@cumulus/aws-client 18.2.2 → 18.3.0

package/S3.js

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.moveObject = exports.multipartCopyObject = exports.createS3Buckets = exports.createBucket = exports.getFileBucketAndKey = exports.validateS3ObjectChecksum = exports.calculateObjectHash = exports.listS3ObjectsV2 = exports.listS3Objects = exports.uploadS3FileStream = exports.uploadS3Files = exports.deleteS3Buckets = exports.recursivelyDeleteS3Bucket = exports.deleteS3Files = exports.fileExists = exports.putJsonS3Object = exports.getJsonS3Object = exports.getTextObject = exports.getObjectStreamContents = exports.getObjectStreamBuffers = exports.getS3Object = exports.waitForObject = exports.getObject = exports.s3PutObjectTagging = exports.s3GetObjectTagging = exports.getObjectSize = exports.downloadS3File = exports.getObjectReadStream = exports.streamS3Upload = exports.promiseS3Upload = exports.s3CopyObject = exports.putFile = exports.s3PutObject = exports.waitForObjectToExist = exports.s3ObjectExists = exports.headObject = exports.deleteS3Objects = exports.deleteS3Object = exports.s3TagSetToQueryString = exports.buildS3Uri = exports.parseS3Uri = exports.s3Join = void 0;
+exports.moveObject = exports.multipartCopyObject = exports.createS3Buckets = exports.createBucket = exports.getFileBucketAndKey = exports.validateS3ObjectChecksum = exports.calculateObjectHash = exports.deleteS3Buckets = exports.recursivelyDeleteS3Bucket = exports.listS3ObjectsV2Batch = exports.listS3ObjectsV2 = exports.listS3Objects = exports.uploadS3FileStream = exports.uploadS3Files = exports.deleteS3Files = exports.fileExists = exports.putJsonS3Object = exports.getJsonS3Object = exports.getTextObject = exports.getObjectStreamContents = exports.getObjectStreamBuffers = exports.getS3Object = exports.waitForObject = exports.getObject = exports.s3PutObjectTagging = exports.s3GetObjectTagging = exports.getObjectSize = exports.downloadS3File = exports.getObjectReadStream = exports.streamS3Upload = exports.promiseS3Upload = exports.s3CopyObject = exports.putFile = exports.s3PutObject = exports.waitForObjectToExist = exports.s3ObjectExists = exports.headObject = exports.deleteS3Objects = exports.deleteS3Object = exports.s3TagSetToQueryString = exports.buildS3Uri = exports.parseS3Uri = exports.s3Join = void 0;
 const fs_1 = __importDefault(require("fs"));
 const isBoolean_1 = __importDefault(require("lodash/isBoolean"));
 const path_1 = __importDefault(require("path"));
@@ -140,12 +140,12 @@ exports.deleteS3Objects = deleteS3Objects;
 /**
 * Get an object header from S3
 *
-* @param {string} Bucket - name of bucket
-* @param {string} Key - key for object (filepath + filename)
-* @param {Object} retryOptions - options to control retry behavior when an
+* @param Bucket - name of bucket
+* @param Key - key for object (filepath + filename)
+* @param retryOptions - options to control retry behavior when an
 *   object does not exist. See https://github.com/tim-kos/node-retry#retryoperationoptions
 *   By default, retries will not be performed
-* @returns {Promise} returns response from `S3.headObject` as a promise
+* @returns  returns response from `S3.headObject` as a promise
 **/
 const headObject = (Bucket, Key, retryOptions = { retries: 0 }) => (0, p_retry_1.default)(async () => {
     try {
@@ -517,33 +517,6 @@ exports.fileExists = fileExists;
  */
 const deleteS3Files = async (s3Objs) => await (0, p_map_1.default)(s3Objs, (s3Obj) => (0, services_1.s3)().deleteObject(s3Obj), { concurrency: S3_RATE_LIMIT });
 exports.deleteS3Files = deleteS3Files;
-/**
-* Delete a bucket and all of its objects from S3
-*
-* @param {string} bucket - name of the bucket
-* @returns {Promise} the promised result of `S3.deleteBucket`
-**/
-exports.recursivelyDeleteS3Bucket = (0, utils_1.improveStackTrace)(async (bucket) => {
-    const response = await (0, services_1.s3)().listObjects({ Bucket: bucket });
-    const s3Objects = (response.Contents || []).map((o) => {
-        if (!o.Key)
-            throw new Error(`Unable to determine S3 key of ${JSON.stringify(o)}`);
-        return {
-            Bucket: bucket,
-            Key: o.Key,
-        };
-    });
-    await (0, exports.deleteS3Files)(s3Objects);
-    return await (0, services_1.s3)().deleteBucket({ Bucket: bucket });
-});
-/**
-* Delete a list of buckets and all of their objects from S3
-*
-* @param {Array} buckets - list of bucket names
-* @returns {Promise} the promised result of `S3.deleteBucket`
-**/
-const deleteS3Buckets = async (buckets) => await Promise.all(buckets.map(exports.recursivelyDeleteS3Bucket));
-exports.deleteS3Buckets = deleteS3Buckets;
 const uploadS3Files = async (files, defaultBucket, keyPath, s3opts = {}) => {
     let i = 0;
     const n = files.length;
@@ -604,15 +577,6 @@ const uploadS3FileStream = (fileStream, bucket, key, s3opts = {}) => (0, exports
 exports.uploadS3FileStream = uploadS3FileStream;
 /**
  * List the objects in an S3 bucket
- *
- * @param {string} bucket - The name of the bucket
- * @param {string} prefix - Only objects with keys starting with this prefix
- *   will be included (useful for searching folders in buckets, e.g., '/PDR')
- * @param {boolean} skipFolders - If true don't return objects that are folders
- *   (defaults to true)
- * @returns {Promise} A promise that resolves to the list of objects. Each S3
- *   object is represented as a JS object with the following attributes: `Key`,
- * `ETag`, `LastModified`, `Owner`, `Size`, `StorageClass`.
  */
 const listS3Objects = async (bucket, prefix, skipFolders = true) => {
     log.info(`Listing objects in s3://${bucket}`);
@@ -622,10 +586,13 @@ const listS3Objects = async (bucket, prefix, skipFolders = true) => {
     if (prefix)
         params.Prefix = prefix;
     const data = await (0, services_1.s3)().listObjects(params);
-    let contents = data.Contents || [];
+    if (!data.Contents) {
+        return [];
+    }
+    let contents = data.Contents.filter((obj) => obj.Key !== undefined);
     if (skipFolders) {
         // Filter out any references to folders
-        contents = contents.filter((obj) => obj.Key !== undefined && !obj.Key.endsWith('/'));
+        contents = contents.filter((obj) => obj.Key && !obj.Key.endsWith('/'));
     }
     return contents;
 };
@@ -661,9 +628,67 @@ const listS3ObjectsV2 = async (params) => {
         }));
         discoveredObjects = discoveredObjects.concat(listObjectsResponse.Contents ?? []);
     }
-    return discoveredObjects;
+    return discoveredObjects.filter((obj) => obj.Key);
 };
 exports.listS3ObjectsV2 = listS3ObjectsV2;
+/**
+ * Fetch lazy list of S3 objects
+ *
+ * listObjectsV2 is limited to 1,000 results per call.  This function continues
+ * listing objects until there are no more to be fetched.
+ *
+ * The passed params must be compatible with the listObjectsV2 call.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#listObjectsV2-property
+ *
+ * @param params - params for the s3.listObjectsV2 call
+ * @yields a series of objects corresponding to
+ *   the Contents property of the listObjectsV2 response
+ *   batched to allow processing of one chunk at a time
+ *
+ * @static
+ */
+async function* listS3ObjectsV2Batch(params) {
+    let listObjectsResponse = await (0, services_1.s3)().listObjectsV2(params);
+    let discoveredObjects = listObjectsResponse.Contents ?? [];
+    yield discoveredObjects.filter((obj) => 'Key' in obj);
+    // Keep listing more objects from S3 until we have all of them
+    while (listObjectsResponse.IsTruncated) {
+        // eslint-disable-next-line no-await-in-loop
+        listObjectsResponse = (await (0, services_1.s3)().listObjectsV2(
+        // Update the params with a Continuation Token
+        {
+            ...params,
+            ContinuationToken: listObjectsResponse.NextContinuationToken,
+        }));
+        discoveredObjects = listObjectsResponse.Contents ?? [];
+        yield discoveredObjects.filter((obj) => 'Key' in obj);
+    }
+}
+exports.listS3ObjectsV2Batch = listS3ObjectsV2Batch;
+/**
+* Delete a bucket and all of its objects from S3
+*
+* @param bucket - name of the bucket
+* @returns the promised result of `S3.deleteBucket`
+**/
+exports.recursivelyDeleteS3Bucket = (0, utils_1.improveStackTrace)(async (bucket) => {
+    for await (const objectBatch of listS3ObjectsV2Batch({ Bucket: bucket })) {
+        if (objectBatch) {
+            const deleteRequests = objectBatch.filter((obj) => obj.Key).map((obj) => ({ Bucket: bucket, Key: obj.Key }));
+            await (0, exports.deleteS3Files)(deleteRequests);
+        }
+    }
+    return await (0, services_1.s3)().deleteBucket({ Bucket: bucket });
+});
+/**
+* Delete a list of buckets and all of their objects from S3
+*
+* @param {Array} buckets - list of bucket names
+* @returns {Promise} the promised result of `S3.deleteBucket`
+**/
+const deleteS3Buckets = async (buckets) => await Promise.all(buckets.map(exports.recursivelyDeleteS3Bucket));
+exports.deleteS3Buckets = deleteS3Buckets;
 /**
  * Calculate the cryptographic hash of an S3 object
  *

package/SNS.d.ts

@@ -5,13 +5,13 @@
  * Publish a message to an SNS topic. Does not catch
  * errors, to allow more specific handling by the caller.
  *
- * @param {string} snsTopicArn - SNS topic ARN
- * @param {Object} message - Message object
- * @param {Object} retryOptions - options to control retry behavior when publishing
+ * @param snsTopicArn - SNS topic ARN
+ * @param message - Message object
+ * @param retryOptions - options to control retry behavior when publishing
  * a message fails. See https://github.com/tim-kos/node-retry#retryoperationoptions
  * @returns {Promise<undefined>}
  */
-export declare const publishSnsMessage: (snsTopicArn: string, message: any, retryOptions?: {}) => Promise<void>;
+export declare const publishSnsMessageWithRetry: (snsTopicArn: string, message: Object, retryOptions?: {}) => Promise<void>;
 /**
  * Create an SNS topic with a given name.
  *

package/SNS.js

@@ -6,35 +6,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSnsTopic = exports.publishSnsMessage = void 0;
+exports.createSnsTopic = exports.publishSnsMessageWithRetry = void 0;
 const p_retry_1 = __importDefault(require("p-retry"));
 const logger_1 = __importDefault(require("@cumulus/logger"));
+const client_sns_1 = require("@aws-sdk/client-sns");
 const services_1 = require("./services");
 const log = new logger_1.default({ sender: 'aws-client/sns' });
 /**
  * Publish a message to an SNS topic. Does not catch
  * errors, to allow more specific handling by the caller.
  *
- * @param {string} snsTopicArn - SNS topic ARN
- * @param {Object} message - Message object
- * @param {Object} retryOptions - options to control retry behavior when publishing
+ * @param snsTopicArn - SNS topic ARN
+ * @param message - Message object
+ * @param retryOptions - options to control retry behavior when publishing
  * a message fails. See https://github.com/tim-kos/node-retry#retryoperationoptions
  * @returns {Promise<undefined>}
  */
-const publishSnsMessage = async (snsTopicArn, message, retryOptions = {}) => await (0, p_retry_1.default)(async () => {
+const publishSnsMessageWithRetry = async (snsTopicArn, message, retryOptions = {}) => await (0, p_retry_1.default)(async () => {
     if (!snsTopicArn) {
         throw new p_retry_1.default.AbortError('Missing SNS topic ARN');
     }
-    await (0, services_1.sns)().publish({
+    const publishInput = {
         TopicArn: snsTopicArn,
         Message: JSON.stringify(message),
-    });
+    };
+    await (0, services_1.sns)().send(new client_sns_1.PublishCommand(publishInput));
 }, {
     maxTimeout: 5000,
-    onFailedAttempt: (err) => log.debug(`publishSnsMessage('${snsTopicArn}', '${JSON.stringify(message)}') failed with ${err.retriesLeft} retries left: ${JSON.stringify(err)}`),
+    onFailedAttempt: (err) => log.debug(`publishSnsMessageWithRetry('${snsTopicArn}', '${JSON.stringify(message)}') failed with ${err.retriesLeft} retries left: ${JSON.stringify(err)}`),
     ...retryOptions,
 });
-exports.publishSnsMessage = publishSnsMessage;
+exports.publishSnsMessageWithRetry = publishSnsMessageWithRetry;
 /**
  * Create an SNS topic with a given name.
  *
@@ -46,7 +48,8 @@ const createSnsTopic = async (snsTopicName) => {
         Name: snsTopicName,
         KmsMasterKeyId: 'alias/aws/sns',
     };
-    const createTopicResponse = await (0, services_1.sns)().createTopic(createTopicInput);
+    const createTopicCommand = new client_sns_1.CreateTopicCommand(createTopicInput);
+    const createTopicResponse = await (0, services_1.sns)().send(createTopicCommand);
     return { TopicArn: createTopicResponse.TopicArn };
 };
 exports.createSnsTopic = createSnsTopic;

package/SQS.d.ts

@@ -2,8 +2,11 @@
  * @module SQS
  */
 import Logger from '@cumulus/logger';
+import { CumulusMessage } from '@cumulus/types/message';
 import { SQSRecord } from 'aws-lambda';
-export interface SQSMessage extends AWS.SQS.Message {
+import { Message } from '@aws-sdk/client-sqs';
+import { StepFunctionEventBridgeEvent } from './Lambda';
+export interface SQSMessage extends Message {
     ReceiptHandle: string;
 }
 export declare const getQueueNameFromUrl: (queueUrl: string) => string | undefined;
@@ -11,11 +14,6 @@ export declare const getQueueUrl: (sourceArn: string, queueName: string) => stri
 export declare const getQueueUrlByName: (queueName: string) => Promise<string | undefined>;
 /**
  * Create an SQS Queue.  Properly handles localstack queue URLs
- *
- * @param {string} QueueName - queue name
- * @returns {Promise<string>} the Queue URL
- *
- * @static
  */
 export declare function createQueue(QueueName: string): Promise<string | undefined>;
 export declare const deleteQueue: (queueUrl: string) => Promise<import("@aws-sdk/client-sqs").DeleteQueueCommandOutput>;
@@ -46,15 +44,8 @@ export declare const getQueueAttributes: (queueName: string) => Promise<{
 }>;
 /**
  * Send a message to AWS SQS
- *
- * @param {string} queueUrl - url of the SQS queue
- * @param {string|Object} message - either string or object message. If an
- *   object it will be serialized into a JSON string.
- * @param {Logger} [logOverride] - optional Logger passed in for testing
- * @returns {Promise} resolves when the messsage has been sent
-
  **/
-export declare const sendSQSMessage: (queueUrl: string, message: string | object, logOverride: Logger) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
+export declare const sendSQSMessage: (queueUrl: string, message: string | object, logOverride?: Logger | undefined) => Promise<import("@aws-sdk/client-sqs").SendMessageCommandOutput>;
 declare type ReceiveSQSMessagesOptions = {
     numOfMessages?: number;
     visibilityTimeout?: number;
@@ -63,33 +54,22 @@ declare type ReceiveSQSMessagesOptions = {
 /**
  * Receives SQS messages from a given queue. The number of messages received
  * can be set and the timeout is also adjustable.
- *
- * @param {string} queueUrl - url of the SQS queue
- * @param {Object} options - options object
- * @param {integer} [options.numOfMessages=1] - number of messages to read from the queue
- * @param {integer} [options.visibilityTimeout=30] - number of seconds a message is invisible
- *   after read
- * @param {integer} [options.waitTimeSeconds=0] - number of seconds to poll SQS queue (long polling)
- * @returns {Promise<Array>} an array of messages
  */
 export declare const receiveSQSMessages: (queueUrl: string, options: ReceiveSQSMessagesOptions) => Promise<SQSMessage[]>;
-export declare const parseSQSMessageBody: (message: SQSRecord | AWS.SQS.Message) => {
-    [key: string]: any;
-};
+/**
+ * Bare check for SQS message Shape
+ */
+export declare const isSQSRecordLike: (message: Object) => message is SQSRecord;
+/**
+ * Extract SQS message body
+ */
+export declare const parseSQSMessageBody: (message: SQSRecord | Message) => StepFunctionEventBridgeEvent | CumulusMessage | SQSRecord;
 /**
  * Delete a given SQS message from a given queue.
- *
- * @param {string} queueUrl - url of the SQS queue
- * @param {integer} receiptHandle - the unique identifier of the sQS message
- * @returns {Promise} an AWS SQS response
  */
 export declare const deleteSQSMessage: (QueueUrl: string, ReceiptHandle: string) => Promise<import("@aws-sdk/client-sqs").DeleteMessageCommandOutput>;
 /**
  * Test if an SQS queue exists
- *
- * @param {Object} queueUrl     - queue url
- * @returns {Promise<boolean>}  - a Promise that will resolve to a boolean indicating
- *                               if the queue exists
  */
 export declare const sqsQueueExists: (queueUrl: string) => Promise<boolean>;
 export {};

package/SQS.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sqsQueueExists = exports.deleteSQSMessage = exports.parseSQSMessageBody = exports.receiveSQSMessages = exports.sendSQSMessage = exports.getQueueAttributes = exports.deleteQueue = exports.createQueue = exports.getQueueUrlByName = exports.getQueueUrl = exports.getQueueNameFromUrl = void 0;
+exports.sqsQueueExists = exports.deleteSQSMessage = exports.parseSQSMessageBody = exports.isSQSRecordLike = exports.receiveSQSMessages = exports.sendSQSMessage = exports.getQueueAttributes = exports.deleteQueue = exports.createQueue = exports.getQueueUrlByName = exports.getQueueUrl = exports.getQueueNameFromUrl = void 0;
+//@ts-check
 /**
  * @module SQS
  */
@@ -23,44 +24,43 @@ const getQueueUrl = (sourceArn, queueName) => {
 };
 exports.getQueueUrl = getQueueUrl;
 const getQueueUrlByName = async (queueName) => {
-    const response = await (0, services_1.sqs)().getQueueUrl({ QueueName: queueName });
+    const command = new client_sqs_1.GetQueueUrlCommand({ QueueName: queueName });
+    const response = await (0, services_1.sqs)().send(command);
     return response.QueueUrl;
 };
 exports.getQueueUrlByName = getQueueUrlByName;
 /**
  * Create an SQS Queue.  Properly handles localstack queue URLs
- *
- * @param {string} QueueName - queue name
- * @returns {Promise<string>} the Queue URL
- *
- * @static
  */
 async function createQueue(QueueName) {
-    const createQueueResponse = await (0, services_1.sqs)().createQueue({
-        QueueName,
-    }).catch((error) => {
+    const command = new client_sqs_1.CreateQueueCommand({ QueueName });
+    const createQueueResponse = await (0, services_1.sqs)().send(command)
+        .catch((error) => {
         log.error(error);
         throw error;
     });
     return createQueueResponse.QueueUrl;
 }
 exports.createQueue = createQueue;
-const deleteQueue = (queueUrl) => (0, services_1.sqs)().deleteQueue({
-    QueueUrl: queueUrl,
-}).catch((error) => {
-    log.error(error);
-    throw error;
-});
+const deleteQueue = (queueUrl) => {
+    const command = new client_sqs_1.DeleteQueueCommand({ QueueUrl: queueUrl });
+    return (0, services_1.sqs)().send(command)
+        .catch((error) => {
+        log.error(error);
+        throw error;
+    });
+};
 exports.deleteQueue = deleteQueue;
 const getQueueAttributes = async (queueName) => {
     const queueUrl = await (0, exports.getQueueUrlByName)(queueName);
     if (!queueUrl) {
         throw new Error(`Unable to determine QueueUrl of ${queueName}`);
     }
-    const response = await (0, services_1.sqs)().getQueueAttributes({
+    const command = new client_sqs_1.GetQueueAttributesCommand({
         AttributeNames: ['All'],
         QueueUrl: queueUrl,
     });
+    const response = await (0, services_1.sqs)().send(command);
     return {
         ...response.Attributes,
         name: queueName,
@@ -69,15 +69,8 @@ const getQueueAttributes = async (queueName) => {
 exports.getQueueAttributes = getQueueAttributes;
 /**
  * Send a message to AWS SQS
- *
- * @param {string} queueUrl - url of the SQS queue
- * @param {string|Object} message - either string or object message. If an
- *   object it will be serialized into a JSON string.
- * @param {Logger} [logOverride] - optional Logger passed in for testing
- * @returns {Promise} resolves when the messsage has been sent
-
  **/
-const sendSQSMessage = (queueUrl, message, logOverride) => {
+const sendSQSMessage = (queueUrl, message, logOverride = undefined) => {
     const logger = logOverride || log;
     let messageBody;
     if ((0, isString_1.default)(message))
@@ -86,10 +79,12 @@ const sendSQSMessage = (queueUrl, message, logOverride) => {
         messageBody = JSON.stringify(message);
     else
         throw new Error('body type is not accepted');
-    return (0, services_1.sqs)().sendMessage({
+    const command = new client_sqs_1.SendMessageCommand({
         MessageBody: messageBody,
         QueueUrl: queueUrl,
-    }).catch((error) => {
+    });
+    return (0, services_1.sqs)().send(command)
+        .catch((error) => {
         logger.error(error);
         throw error;
     });
@@ -98,14 +93,6 @@ exports.sendSQSMessage = sendSQSMessage;
 /**
  * Receives SQS messages from a given queue. The number of messages received
  * can be set and the timeout is also adjustable.
- *
- * @param {string} queueUrl - url of the SQS queue
- * @param {Object} options - options object
- * @param {integer} [options.numOfMessages=1] - number of messages to read from the queue
- * @param {integer} [options.visibilityTimeout=30] - number of seconds a message is invisible
- *   after read
- * @param {integer} [options.waitTimeSeconds=0] - number of seconds to poll SQS queue (long polling)
- * @returns {Promise<Array>} an array of messages
  */
 const receiveSQSMessages = async (queueUrl, options) => {
     const params = {
@@ -116,7 +103,8 @@ const receiveSQSMessages = async (queueUrl, options) => {
         WaitTimeSeconds: options.waitTimeSeconds || 0,
         MaxNumberOfMessages: options.numOfMessages || 1,
     };
-    const messages = await (0, services_1.sqs)().receiveMessage(params)
+    const command = new client_sqs_1.ReceiveMessageCommand(params);
+    const messages = await (0, services_1.sqs)().send(command)
         .catch((error) => {
         log.error(error);
         throw error;
@@ -124,35 +112,40 @@ const receiveSQSMessages = async (queueUrl, options) => {
     return (messages.Messages ?? []);
 };
 exports.receiveSQSMessages = receiveSQSMessages;
+/**
+ * Bare check for SQS message Shape
+ */
+const isSQSRecordLike = (message) => (message instanceof Object
+    && ('body' in message || 'Body' in message));
+exports.isSQSRecordLike = isSQSRecordLike;
+/**
+ * Extract SQS message body
+ */
 const parseSQSMessageBody = (message) => JSON.parse((0, get_1.default)(message, 'Body', (0, get_1.default)(message, 'body')) ?? '{}');
 exports.parseSQSMessageBody = parseSQSMessageBody;
 /**
  * Delete a given SQS message from a given queue.
- *
- * @param {string} queueUrl - url of the SQS queue
- * @param {integer} receiptHandle - the unique identifier of the sQS message
- * @returns {Promise} an AWS SQS response
  */
-const deleteSQSMessage = (QueueUrl, ReceiptHandle) => (0, services_1.sqs)().deleteMessage({ QueueUrl, ReceiptHandle })
-    .catch((error) => {
-    log.error(error);
-    throw error;
-});
+const deleteSQSMessage = (QueueUrl, ReceiptHandle) => {
+    const command = new client_sqs_1.DeleteMessageCommand({ QueueUrl, ReceiptHandle });
+    return (0, services_1.sqs)().send(command)
+        .catch((error) => {
+        log.error(error);
+        throw error;
+    });
+};
 exports.deleteSQSMessage = deleteSQSMessage;
 /**
  * Test if an SQS queue exists
- *
- * @param {Object} queueUrl     - queue url
- * @returns {Promise<boolean>}  - a Promise that will resolve to a boolean indicating
- *                               if the queue exists
  */
 const sqsQueueExists = async (queueUrl) => {
     const QueueName = (0, exports.getQueueNameFromUrl)(queueUrl);
     if (!QueueName) {
         throw new Error(`Unable to determine QueueName from ${queueUrl}`);
     }
+    const command = new client_sqs_1.GetQueueUrlCommand({ QueueName });
     try {
-        await (0, services_1.sqs)().getQueueUrl({ QueueName });
+        await (0, services_1.sqs)().send(command);
         return true;
     }
     catch (error) {

package/STS.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module STS
+ */
+export { AssumeRoleResponse } from '@aws-sdk/client-sts';
+//# sourceMappingURL=STS.d.ts.map

package/STS.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @module STS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=STS.js.map

package/SecretsManager.js

@@ -5,7 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSecretString = void 0;
 const services_1 = require("./services");
-const getSecretString = (SecretId) => (0, services_1.secretsManager)().getSecretValue({ SecretId }).promise()
+const getSecretString = async (SecretId) => (0, services_1.secretsManager)().getSecretValue({ SecretId })
     .then((response) => response.SecretString);
 exports.getSecretString = getSecretString;
 //# sourceMappingURL=SecretsManager.js.map

package/StepFunctions.d.ts

@@ -1,6 +1,8 @@
 /**
  * @module StepFunctions
  */
+import { DescribeExecutionInput, DescribeExecutionOutput, DescribeStateMachineInput, DescribeStateMachineOutput, GetExecutionHistoryInput, HistoryEvent, ListExecutionsCommandInput } from '@aws-sdk/client-sfn';
+export { HistoryEvent, DescribeExecutionOutput } from '@aws-sdk/client-sfn';
 export declare const doesExecutionExist: (describeExecutionPromise: Promise<unknown>) => Promise<boolean>;
 /**
  * Call StepFunctions DescribeExecution
@@ -11,12 +13,12 @@ export declare const doesExecutionExist: (describeExecutionPromise: Promise<unkn
  * If a ThrottlingException is received, this function will retry using an
  * exponential backoff.
  *
- * @param {Object} params
- * @returns {Promise<Object>}
+ * @param {DescribeExecutionInput} params
+ * @returns {Promise<DescribeExecutionOutput>}
  *
  * @kind function
  */
-export declare const describeExecution: (params: import("aws-sdk/clients/stepfunctions").DescribeExecutionInput) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/stepfunctions").DescribeExecutionOutput, import("aws-sdk").AWSError>>;
+export declare const describeExecution: (params: DescribeExecutionInput) => Promise<DescribeExecutionOutput>;
 /**
  * Call StepFunctions DescribeStateMachine
  *
@@ -26,12 +28,12 @@ export declare const describeExecution: (params: import("aws-sdk/clients/stepfun
  * If a ThrottlingException is received, this function will retry using an
  * exponential backoff.
  *
- * @param {Object} params
- * @returns {Promise<Object>}
+ * @param {DescribeStateMachineInput} params
+ * @returns {Promise<DescribeStateMachineOutput>}
  *
  * @kind function
  */
-export declare const describeStateMachine: (params: import("aws-sdk/clients/stepfunctions").DescribeStateMachineInput) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/stepfunctions").DescribeStateMachineOutput, import("aws-sdk").AWSError>>;
+export declare const describeStateMachine: (params: DescribeStateMachineInput) => Promise<DescribeStateMachineOutput>;
 /**
  * Check if a Step Function Execution exists
  *
@@ -54,24 +56,22 @@ export declare const executionExists: (executionArn: string) => Promise<boolean>
  * If a ThrottlingException is received, this function will retry using an
  * exponential backoff.
  *
- * @param {Object} params
- * @returns {Promise<Object>}
+ * @param {GetExecutionHistoryInput} params
+ * @returns {Promise<GetExecutionHistoryOutput>}
  *
  * @kind function
  */
-export declare const getExecutionHistory: (params: import("aws-sdk/clients/stepfunctions").GetExecutionHistoryInput, previousResponse?: {
-    events: import("aws-sdk/clients/stepfunctions").HistoryEventList;
+export declare const getExecutionHistory: (params: GetExecutionHistoryInput, previousResponse?: {
+    events: HistoryEvent[];
 } | undefined) => Promise<{
-    events: import("aws-sdk/clients/stepfunctions").HistoryEventList;
+    events: HistoryEvent[];
 }>;
 export declare const getExecutionStatus: (executionArn: string) => Promise<{
-    execution: import("aws-sdk/clients/stepfunctions").DescribeExecutionOutput & {
-        $response: import("aws-sdk").Response<import("aws-sdk/clients/stepfunctions").DescribeExecutionOutput, import("aws-sdk").AWSError>;
-    };
+    execution: DescribeExecutionOutput;
     executionHistory: {
-        events: import("aws-sdk/clients/stepfunctions").HistoryEventList;
+        events: HistoryEvent[];
     };
-    stateMachine: import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/stepfunctions").DescribeStateMachineOutput, import("aws-sdk").AWSError>;
+    stateMachine: DescribeStateMachineOutput;
 }>;
 /**
  * Call StepFunctions ListExecutions
@@ -87,5 +87,5 @@ export declare const getExecutionStatus: (executionArn: string) => Promise<{
  *
  * @kind function
  */
-export declare const listExecutions: (params: import("aws-sdk/clients/stepfunctions").ListExecutionsInput) => Promise<import("aws-sdk/lib/request").PromiseResult<import("aws-sdk/clients/stepfunctions").ListExecutionsOutput, import("aws-sdk").AWSError>>;
+export declare const listExecutions: (params: ListExecutionsCommandInput) => Promise<import("@aws-sdk/client-sfn").ListExecutionsCommandOutput>;
 //# sourceMappingURL=StepFunctions.d.ts.map