review: move from v2 to v3 of AWS SDK

Author: pjhartzell

src/lib/aws-clients.js

@@ -1,6 +1,6 @@
-import { S3 } from '@aws-sdk/client-s3'
-import { SNS } from '@aws-sdk/client-sns'
-import { SQS } from '@aws-sdk/client-sqs'
+import { S3Client } from '@aws-sdk/client-s3'
+import { SNSClient } from '@aws-sdk/client-sns'
+import { SQSClient } from '@aws-sdk/client-sqs'
 
 const localStackEndpointEnvVar = 'LOCAL_STACK_ENDPOINT'
 
@@ -28,7 +28,7 @@ export const s3 = (options = {}) => {
 
   const overrides = useLocalStack() ? localStackOverrides : {}
 
-  return new S3({
+  return new S3Client({
     ...overrides,
     ...options
   })
@@ -37,7 +37,7 @@ export const s3 = (options = {}) => {
 export const sns = (options = {}) => {
   const overrides = useLocalStack() ? localStackParams() : {}
 
-  return new SNS({
+  return new SNSClient({
     ...overrides,
     ...options
   })
@@ -46,7 +46,7 @@ export const sns = (options = {}) => {
 export const sqs = (options = {}) => {
   const overrides = useLocalStack() ? localStackParams() : {}
 
-  return new SQS({
+  return new SQSClient({
     ...overrides,
     ...options
   })

src/lib/s3-utils.js

@@ -1,12 +1,14 @@
+import { GetObjectCommand } from '@aws-sdk/client-s3'
 import { s3 } from './aws-clients.js'
 import logger from './logger.js'
 
 const getObjectBody = async (s3Location) => {
   try {
-    const result = await s3().getObject({
+    const command = new GetObjectCommand({
       Bucket: s3Location.bucket,
       Key: s3Location.key
     })
+    const result = await s3().send(command)
 
     if (result.Body === undefined) {
       throw new Error(`Body of ${s3Location.url} is undefined`)

src/lib/s3-utils.ts

@@ -1,12 +1,15 @@
+import { GetObjectCommand } from '@aws-sdk/client-s3'
 import { s3 } from './aws-clients.js'
 
 const getObjectBody = async (s3Location: {bucket: string, key: string}) => {
   try {
-    const result = await s3().getObject({
+    const command = new GetObjectCommand({
       Bucket: s3Location.bucket,
       Key: s3Location.key
     })
 
+    const result = await s3().send(command)
+
     if (result.Body === undefined) {
       throw new Error(`Body of ${s3Location.bucket}/${s3Location.key} is undefined`)
     }

src/lib/sns.js

@@ -1,3 +1,4 @@
+import { PublishCommand } from '@aws-sdk/client-sns'
 import { sns } from './aws-clients.js'
 import logger from './logger.js'
 import { getBBox, getStartAndEndDates, isCollection, isItem } from './stac-utils.js'
@@ -86,11 +87,12 @@ const attrsFromPayload = function (payload) {
 export async function publishRecordToSns(topicArn, record, error) {
   const payload = { record, error }
   try {
-    await sns().publish({
+    const command = new PublishCommand({
       Message: JSON.stringify(payload),
       TopicArn: topicArn,
       MessageAttributes: attrsFromPayload(payload)
     })
+    await sns().send(command)
     logger.info(`Wrote record ${record.id} to ${topicArn}`)
   } catch (err) {
     logger.error(`Failed to write record ${record.id} to ${topicArn}: ${err}`)

tests/helpers/ingest.js

@@ -1,3 +1,5 @@
+import { PublishCommand } from '@aws-sdk/client-sns'
+import { ReceiveMessageCommand } from '@aws-sdk/client-sqs'
 import { sns, sqs } from '../../src/lib/aws-clients.js'
 import { handler } from '../../src/lambdas/ingest/index.js'
 import { sqsTriggerLambda } from './sqs.js'
@@ -16,10 +18,11 @@ import { loadFixture } from './utils.js'
  * @returns {Promise<void>}
  */
 export const ingestItem = async (params) => {
-  await sns().publish({
+  const command = new PublishCommand({
     TopicArn: params.ingestTopicArn,
     Message: JSON.stringify(params.item)
   })
+  await sns().send(command)
 
   await sqsTriggerLambda(params.ingestQueueUrl, handler)
 
@@ -78,10 +81,11 @@ export async function testPostIngestSNS(t, record, shouldError = false) {
   // @ts-ignore
   process.env['POST_INGEST_TOPIC_ARN'] = t.context.postIngestTopicArn
 
-  await sns().publish({
+  const publishCommand = new PublishCommand({
     TopicArn: t.context.ingestTopicArn,
     Message: JSON.stringify(record)
   })
+  await sns().send(publishCommand)
 
   try {
     await sqsTriggerLambda(t.context.ingestQueueUrl, handler)
@@ -91,10 +95,11 @@ export async function testPostIngestSNS(t, record, shouldError = false) {
     }
   }
 
-  const { Messages } = await sqs().receiveMessage({
+  const receiveCommand = new ReceiveMessageCommand({
     QueueUrl: t.context.postIngestQueueUrl,
     WaitTimeSeconds: 1
   })
+  const { Messages } = await sqs().send(receiveCommand)
 
   t.truthy(Messages, 'Post-ingest message not found in queue')
   t.false(Messages && Messages.length > 1, 'More than one message in post-ingest queue')

tests/helpers/sns.js

@@ -1,3 +1,4 @@
+import { CreateTopicCommand, SubscribeCommand } from '@aws-sdk/client-sns'
 import { sns as _sns } from '../../src/lib/aws-clients.js'
 import { randomId } from './utils.js'
 
@@ -7,9 +8,10 @@ import { randomId } from './utils.js'
 export const createTopic = async () => {
   const sns = _sns()
 
-  const { TopicArn } = await sns.createTopic({
+  const command = new CreateTopicCommand({
     Name: randomId('topic')
   })
+  const { TopicArn } = await sns.send(command)
 
   if (TopicArn) return TopicArn
 
@@ -22,9 +24,10 @@ export const createTopic = async () => {
  * @returns {Promise<void>}
  */
 export const addSnsToSqsSubscription = async (topicArn, queueArn) => {
-  await _sns().subscribe({
+  const command = new SubscribeCommand({
     TopicArn: topicArn,
     Protocol: 'sqs',
     Endpoint: queueArn
   })
+  await _sns().send(command)
 }

tests/helpers/sqs.js

@@ -1,6 +1,12 @@
 // @ts-nocheck
 
 import { isUndefined } from 'lodash-es'
+import {
+  ReceiveMessageCommand,
+  PurgeQueueCommand,
+  CreateQueueCommand,
+  GetQueueAttributesCommand
+} from '@aws-sdk/client-sqs'
 import { sqs as _sqs } from '../../src/lib/aws-clients.js'
 import { randomId } from './utils.js'
 
@@ -17,10 +23,11 @@ const sqsMessageToRecord = (message) => ({
 })
 
 const eventFromQueue = async (ingestQueueUrl) => {
-  const { Messages } = await _sqs().receiveMessage({
+  const command = new ReceiveMessageCommand({
     QueueUrl: ingestQueueUrl,
     WaitTimeSeconds: 1
   })
+  const { Messages } = await _sqs().send(command)
 
   return {
     Records: Messages.map((m) => sqsMessageToRecord(m))
@@ -37,7 +44,8 @@ export const sqsTriggerLambda = async (sqsUrl, handler, _context = {}) => {
  * @returns {Promise<void>}
  */
 export const purgeQueue = async (url) => {
-  await _sqs().purgeQueue({ QueueUrl: url })
+  const command = new PurgeQueueCommand({ QueueUrl: url })
+  await _sqs().send(command)
 }
 
 /**
@@ -46,9 +54,10 @@ export const purgeQueue = async (url) => {
 export const createQueue = async () => {
   const sqs = _sqs()
 
-  const { QueueUrl } = await sqs.createQueue({
+  const command = new CreateQueueCommand({
     QueueName: randomId('queue')
   })
+  const { QueueUrl } = await sqs.send(command)
 
   if (QueueUrl) return QueueUrl
 
@@ -62,10 +71,11 @@ export const createQueue = async () => {
 export const getQueueArn = async (queueUrl) => {
   const sqs = _sqs()
 
-  const getQueueAttributesResult = await sqs.getQueueAttributes({
+  const command = new GetQueueAttributesCommand({
     QueueUrl: queueUrl,
     AttributeNames: ['QueueArn']
   })
+  const getQueueAttributesResult = await sqs.send(command)
 
   if (
     isUndefined(getQueueAttributesResult.Attributes)

tests/system/test-ingest.js

@@ -4,6 +4,9 @@ import url from 'url'
 import test from 'ava'
 import nock from 'nock'
 import { DateTime } from 'luxon'
+import { PublishCommand } from '@aws-sdk/client-sns'
+import { ReceiveMessageCommand } from '@aws-sdk/client-sqs'
+import { CreateBucketCommand, PutObjectCommand } from '@aws-sdk/client-s3'
 import { getCollectionIds, getItem } from '../helpers/api.js'
 import { handler, resetAssetProxy } from '../../src/lambdas/ingest/index.js'
 import { loadFixture, randomId } from '../helpers/utils.js'
@@ -54,10 +57,11 @@ test('The ingest lambda supports ingesting a collection published to SNS', async
     { id: randomId('collection') }
   )
 
-  await sns().publish({
+  const publishCommand = new PublishCommand({
     TopicArn: ingestTopicArn,
     Message: JSON.stringify(collection)
   })
+  await sns().send(publishCommand)
 
   await sqsTriggerLambda(ingestQueueUrl, handler)
 
@@ -85,23 +89,26 @@ test('The ingest lambda supports ingesting a collection sourced from S3', async
   const sourceBucket = randomId('bucket')
   const sourceKey = randomId('key')
 
-  await s3.createBucket({
+  const createBucketCommand = new CreateBucketCommand({
     Bucket: sourceBucket,
     CreateBucketConfiguration: {
       LocationConstraint: 'us-west-2'
     }
   })
+  await s3.send(createBucketCommand)
 
-  await s3.putObject({
+  const putObjectCommand = new PutObjectCommand({
     Bucket: sourceBucket,
     Key: sourceKey,
     Body: JSON.stringify(collection)
   })
+  await s3.send(putObjectCommand)
 
-  await sns().publish({
+  const publishCommand2 = new PublishCommand({
     TopicArn: ingestTopicArn,
     Message: JSON.stringify({ href: `s3://${sourceBucket}/${sourceKey}` })
   })
+  await sns().send(publishCommand2)
 
   await sqsTriggerLambda(ingestQueueUrl, handler)
 
@@ -125,10 +132,11 @@ test('The ingest lambda supports ingesting a collection sourced from http', asyn
 
   nock('http://source.local').get('/my-file.dat').reply(200, collection)
 
-  await sns().publish({
+  const publishCommand3 = new PublishCommand({
     TopicArn: ingestTopicArn,
     Message: JSON.stringify({ href: 'http://source.local/my-file.dat' })
   })
+  await sns().send(publishCommand3)
 
   await sqsTriggerLambda(ingestQueueUrl, handler)
 
@@ -417,11 +425,12 @@ async function emptyPostIngestQueue(t) {
   //    We recommend waiting for 60 seconds regardless of your queue's size."
   let result
   do {
-    // eslint-disable-next-line no-await-in-loop
-    result = await sqs().receiveMessage({
+    const receiveCommand = new ReceiveMessageCommand({
       QueueUrl: t.context.postIngestQueueUrl,
       WaitTimeSeconds: 1
     })
+    // eslint-disable-next-line no-await-in-loop
+    result = await sqs().send(receiveCommand)
   } while (result.Message && result.Message.length > 0)
 }