Self-review on stage 5

Author: GrahamCampbell

package.json

@@ -27,13 +27,20 @@
     "@aws-sdk/client-cloudwatch": "^3.588.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.588.0",
     "@aws-sdk/client-cognito-identity-provider": "^3.588.0",
+    "@aws-sdk/client-dynamodb": "^3.588.0",
     "@aws-sdk/client-ecr": "^3.588.0",
     "@aws-sdk/client-eventbridge": "^3.588.0",
     "@aws-sdk/client-iam": "^3.588.0",
+    "@aws-sdk/client-iot": "^3.588.0",
+    "@aws-sdk/client-iot-data-plane": "^3.588.0",
+    "@aws-sdk/client-kinesis": "^3.588.0",
     "@aws-sdk/client-lambda": "^3.588.0",
     "@aws-sdk/client-s3": "^3.588.0",
+    "@aws-sdk/client-sns": "^3.588.0",
+    "@aws-sdk/client-sqs": "^3.588.0",
     "@aws-sdk/client-ssm": "^3.588.0",
     "@aws-sdk/client-sts": "^3.588.0",
+    "@aws-sdk/lib-dynamodb": "^3.588.0",
     "@aws-sdk/credential-providers": "^3.588.0",
     "@serverless/utils": "^6.13.1",
     "ajv": "^8.12.0",

test/utils/dynamodb.js

@@ -1,15 +1,38 @@
 'use strict';
 
 const awsRequest = require('@serverless/test/aws-request');
-const DDBDocumentClient = require('aws-sdk').DynamoDB.DocumentClient;
+
+// Support for both AWS SDK v2 and v3
+const getDynamoDBClient = () => {
+  if (process.env.SLS_AWS_SDK_V3 === 'true') {
+    // AWS SDK v3 - using DynamoDBDocumentClient from lib-dynamodb
+    const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
+    const { DynamoDBDocumentClient, PutCommand } = require('@aws-sdk/lib-dynamodb');
+    
+    const client = new DynamoDBClient({ region: 'us-east-1' });
+    const docClient = DynamoDBDocumentClient.from(client);
+    
+    return {
+      put: (params) => docClient.send(new PutCommand(params)),
+    };
+  } else {
+    // AWS SDK v2
+    const DDBDocumentClient = require('aws-sdk').DynamoDB.DocumentClient;
+    return {
+      put: (params) => awsRequest(DDBDocumentClient, 'put', params),
+    };
+  }
+};
+
+const dynamodb = getDynamoDBClient();
 
 async function putDynamoDbItem(tableName, item) {
   const params = {
     TableName: tableName,
     Item: item,
   };
 
-  return awsRequest(DDBDocumentClient, 'put', params);
+  return dynamodb.put(params);
 }
 
 module.exports = {

test/utils/event-bridge.js

@@ -1,26 +1,59 @@
 'use strict';
 
 const awsRequest = require('@serverless/test/aws-request');
-const EventBridgeService = require('aws-sdk').EventBridge;
+
+// Support for both AWS SDK v2 and v3
+const getEventBridgeClient = () => {
+  if (process.env.SLS_AWS_SDK_V3 === 'true') {
+    // AWS SDK v3
+    const { EventBridgeClient } = require('@aws-sdk/client-eventbridge');
+    const { 
+      CreateEventBusCommand,
+      DeleteEventBusCommand,
+      DescribeEventBusCommand,
+      PutEventsCommand
+    } = require('@aws-sdk/client-eventbridge');
+    
+    const client = new EventBridgeClient({ region: 'us-east-1' });
+    
+    return {
+      createEventBus: (params) => client.send(new CreateEventBusCommand(params)),
+      deleteEventBus: (params) => client.send(new DeleteEventBusCommand(params)),
+      describeEventBus: (params) => client.send(new DescribeEventBusCommand(params)),
+      putEvents: (params) => client.send(new PutEventsCommand(params)),
+    };
+  } else {
+    // AWS SDK v2
+    const EventBridgeService = require('aws-sdk').EventBridge;
+    return {
+      createEventBus: (params) => awsRequest(EventBridgeService, 'createEventBus', params),
+      deleteEventBus: (params) => awsRequest(EventBridgeService, 'deleteEventBus', params),
+      describeEventBus: (params) => awsRequest(EventBridgeService, 'describeEventBus', params),
+      putEvents: (params) => awsRequest(EventBridgeService, 'putEvents', params),
+    };
+  }
+};
+
+const eventBridge = getEventBridgeClient();
 
 async function createEventBus(name) {
-  return awsRequest(EventBridgeService, 'createEventBus', { Name: name });
+  return eventBridge.createEventBus({ Name: name });
 }
 
 async function deleteEventBus(name) {
-  return awsRequest(EventBridgeService, 'deleteEventBus', { Name: name });
+  return eventBridge.deleteEventBus({ Name: name });
 }
 
 async function describeEventBus(name) {
-  return awsRequest(EventBridgeService, 'describeEventBus', { Name: name });
+  return eventBridge.describeEventBus({ Name: name });
 }
 
 async function putEvents(EventBusName, Entries) {
   Entries.map((entry) => (entry.EventBusName = EventBusName));
   const params = {
     Entries,
   };
-  return awsRequest(EventBridgeService, 'putEvents', params);
+  return eventBridge.putEvents(params);
 }
 
 module.exports = {

test/utils/iot.js

@@ -1,11 +1,49 @@
 'use strict';
 
 const awsRequest = require('@serverless/test/aws-request');
-const IotService = require('aws-sdk').Iot;
-const IotDataService = require('aws-sdk').IotData;
+
+// Support for both AWS SDK v2 and v3
+const getIoTClients = () => {
+  if (process.env.SLS_AWS_SDK_V3 === 'true') {
+    // AWS SDK v3 - dual service pattern (IoT + IoTDataPlane)
+    const { IoTClient, DescribeEndpointCommand } = require('@aws-sdk/client-iot');
+    const { IoTDataPlaneClient, PublishCommand } = require('@aws-sdk/client-iot-data-plane');
+    
+    const iotClient = new IoTClient({ region: 'us-east-1' });
+    
+    return {
+      iot: {
+        describeEndpoint: (params) => iotClient.send(new DescribeEndpointCommand(params)),
+      },
+      createIoTDataClient: (endpoint) => {
+        const iotDataClient = new IoTDataPlaneClient({ 
+          region: 'us-east-1',
+          endpoint: `https://${endpoint}`
+        });
+        return {
+          publish: (params) => iotDataClient.send(new PublishCommand(params)),
+        };
+      }
+    };
+  } else {
+    // AWS SDK v2
+    const IotService = require('aws-sdk').Iot;
+    const IotDataService = require('aws-sdk').IotData;
+    return {
+      iot: {
+        describeEndpoint: (params) => awsRequest(IotService, 'describeEndpoint', params),
+      },
+      createIoTDataClient: (endpoint) => ({
+        publish: (params) => awsRequest({ client: IotDataService, params: { endpoint } }, 'publish', params),
+      })
+    };
+  }
+};
+
+const { iot, createIoTDataClient } = getIoTClients();
 
 async function resolveIotEndpoint() {
-  return awsRequest(IotService, 'describeEndpoint', { endpointType: 'iot:Data-ATS' }).then(
+  return iot.describeEndpoint({ endpointType: 'iot:Data-ATS' }).then(
     (data) => {
       return data.endpointAddress;
     }
@@ -19,7 +57,8 @@ async function publishIotData(topic, message) {
       payload: Buffer.from(message),
     };
 
-    return awsRequest({ client: IotDataService, params: { endpoint } }, 'publish', params);
+    const iotDataClient = createIoTDataClient(endpoint);
+    return iotDataClient.publish(params);
   });
 }
 

test/utils/kinesis.js

@@ -1,15 +1,48 @@
 'use strict';
 
 const awsRequest = require('@serverless/test/aws-request');
-const KinesisService = require('aws-sdk').Kinesis;
+
+// Support for both AWS SDK v2 and v3
+const getKinesisClient = () => {
+  if (process.env.SLS_AWS_SDK_V3 === 'true') {
+    // AWS SDK v3
+    const { KinesisClient } = require('@aws-sdk/client-kinesis');
+    const { 
+      CreateStreamCommand,
+      DeleteStreamCommand,
+      DescribeStreamCommand,
+      PutRecordCommand
+    } = require('@aws-sdk/client-kinesis');
+    
+    const client = new KinesisClient({ region: 'us-east-1' });
+    
+    return {
+      createStream: (params) => client.send(new CreateStreamCommand(params)),
+      deleteStream: (params) => client.send(new DeleteStreamCommand(params)),
+      describeStream: (params) => client.send(new DescribeStreamCommand(params)),
+      putRecord: (params) => client.send(new PutRecordCommand(params)),
+    };
+  } else {
+    // AWS SDK v2
+    const KinesisService = require('aws-sdk').Kinesis;
+    return {
+      createStream: (params) => awsRequest(KinesisService, 'createStream', params),
+      deleteStream: (params) => awsRequest(KinesisService, 'deleteStream', params),
+      describeStream: (params) => awsRequest(KinesisService, 'describeStream', params),
+      putRecord: (params) => awsRequest(KinesisService, 'putRecord', params),
+    };
+  }
+};
+
+const kinesis = getKinesisClient();
 
 async function waitForKinesisStream(streamName) {
   const params = {
     StreamName: streamName,
   };
   return new Promise((resolve) => {
     const interval = setInterval(() => {
-      awsRequest(KinesisService, 'describeStream', params).then((data) => {
+      kinesis.describeStream(params).then((data) => {
         const status = data.StreamDescription.StreamStatus;
         if (status === 'ACTIVE') {
           clearInterval(interval);
@@ -27,7 +60,7 @@ async function createKinesisStream(streamName) {
     StreamName: streamName,
   };
 
-  return awsRequest(KinesisService, 'createStream', params).then(() =>
+  return kinesis.createStream(params).then(() =>
     waitForKinesisStream(streamName)
   );
 }
@@ -37,7 +70,7 @@ async function deleteKinesisStream(streamName) {
     StreamName: streamName,
   };
 
-  return awsRequest(KinesisService, 'deleteStream', params);
+  return kinesis.deleteStream(params);
 }
 
 async function putKinesisRecord(streamName, message) {
@@ -47,7 +80,7 @@ async function putKinesisRecord(streamName, message) {
     PartitionKey: streamName, // test streams are single shards
   };
 
-  return awsRequest(KinesisService, 'putRecord', params);
+  return kinesis.putRecord(params);
 }
 
 module.exports = {

test/utils/misc.js

@@ -1,9 +1,31 @@
 'use strict';
 
 const awsRequest = require('@serverless/test/aws-request');
-const CloudWatchLogsService = require('aws-sdk').CloudWatchLogs;
 const wait = require('timers-ext/promise/sleep');
 
+// Support for both AWS SDK v2 and v3
+const getCloudWatchLogsClient = () => {
+  if (process.env.SLS_AWS_SDK_V3 === 'true') {
+    // AWS SDK v3
+    const { CloudWatchLogsClient } = require('@aws-sdk/client-cloudwatch-logs');
+    const { FilterLogEventsCommand } = require('@aws-sdk/client-cloudwatch-logs');
+    
+    const client = new CloudWatchLogsClient({ region: 'us-east-1' });
+    
+    return {
+      filterLogEvents: (params) => client.send(new FilterLogEventsCommand(params)),
+    };
+  } else {
+    // AWS SDK v2
+    const CloudWatchLogsService = require('aws-sdk').CloudWatchLogs;
+    return {
+      filterLogEvents: (params) => awsRequest(CloudWatchLogsService, 'filterLogEvents', params),
+    };
+  }
+};
+
+const cloudWatchLogs = getCloudWatchLogsClient();
+
 const logger = console;
 
 function replaceEnv(values) {
@@ -33,7 +55,7 @@ async function confirmCloudWatchLogs(logGroupName, trigger, options = {}) {
   const timeout = options.timeout || 3 * 60 * 1000;
   return trigger()
     .then(() => wait(1000))
-    .then(() => awsRequest(CloudWatchLogsService, 'filterLogEvents', { logGroupName }))
+    .then(() => cloudWatchLogs.filterLogEvents({ logGroupName }))
     .then(({ events }) => {
       if (events.length) {
         if (options.checkIsComplete) {

test/utils/sns.js

@@ -1,18 +1,51 @@
 'use strict';
 
 const awsRequest = require('@serverless/test/aws-request');
-const SNSService = require('aws-sdk').SNS;
+
+// Support for both AWS SDK v2 and v3
+const getSNSClient = () => {
+  if (process.env.SLS_AWS_SDK_V3 === 'true') {
+    // AWS SDK v3
+    const { SNSClient } = require('@aws-sdk/client-sns');
+    const { 
+      CreateTopicCommand,
+      DeleteTopicCommand,
+      ListTopicsCommand,
+      PublishCommand
+    } = require('@aws-sdk/client-sns');
+    
+    const client = new SNSClient({ region: 'us-east-1' });
+    
+    return {
+      createTopic: (params) => client.send(new CreateTopicCommand(params)),
+      deleteTopic: (params) => client.send(new DeleteTopicCommand(params)),
+      listTopics: (params) => client.send(new ListTopicsCommand(params)),
+      publish: (params) => client.send(new PublishCommand(params)),
+    };
+  } else {
+    // AWS SDK v2
+    const SNSService = require('aws-sdk').SNS;
+    return {
+      createTopic: (params) => awsRequest(SNSService, 'createTopic', params),
+      deleteTopic: (params) => awsRequest(SNSService, 'deleteTopic', params),
+      listTopics: (params) => awsRequest(SNSService, 'listTopics', params),
+      publish: (params) => awsRequest(SNSService, 'publish', params),
+    };
+  }
+};
+
+const sns = getSNSClient();
 
 async function createSnsTopic(topicName) {
   const params = {
     Name: topicName,
   };
 
-  return awsRequest(SNSService, 'createTopic', params);
+  return sns.createTopic(params);
 }
 
 async function resolveTopicArn(topicName, nextToken = null) {
-  return awsRequest(SNSService, 'listTopics', { NextToken: nextToken }).then((data) => {
+  return sns.listTopics({ NextToken: nextToken }).then((data) => {
     const targetTopic = data.Topics.find((topic) => RegExp(topicName, 'g').test(topic.TopicArn));
 
     if (targetTopic) return targetTopic.TopicArn;
@@ -28,7 +61,7 @@ async function removeSnsTopic(topicName) {
       TopicArn: topicArn,
     };
 
-    return awsRequest(SNSService, 'deleteTopic', params);
+    return sns.deleteTopic(params);
   });
 }
 
@@ -42,7 +75,7 @@ async function publishSnsMessage(topicName, message, messageAttributes = null) {
       params.MessageAttributes = messageAttributes;
     }
 
-    return awsRequest(SNSService, 'publish', params);
+    return sns.publish(params);
   });
 }