Upgrafde aws sdk

Author: quittle

package-lock.json

@@ -25,12 +25,13 @@
         "release": "npm run build && npm run package && npm run deploy"
     },
     "devDependencies": {
+        "@aws-sdk/client-cloudformation": "^3.507.0",
+        "@aws-sdk/client-s3": "^3.507.0",
         "@types/jest": "^29.5.0",
         "@types/minimatch": "^5.1.2",
         "@types/node": "^18.16.3",
         "@typescript-eslint/eslint-plugin": "^5.59.6",
         "@typescript-eslint/parser": "^5.59.6",
-        "aws-sdk": "^2.1381.0",
         "deepmerge": "^4.3.1",
         "eslint": "^8.41.0",
         "jest": "^29.5.0",

package.json

@@ -1,6 +1,6 @@
 import { Minimatch } from "minimatch";
 import deepmerge from "deepmerge";
-import S3 from "aws-sdk/clients/s3";
+import { PutObjectRequest } from "@aws-sdk/client-s3";
 
 /** Format of the config file  */
 interface S3UploadFileStructure {
@@ -46,14 +46,14 @@ class S3UploadConfig {
      * @param objectKey The key name to match against in the config
      * @returns A partial S3.PutObjectRequest object based off the configuration
      */
-    public getS3ParamsForKey(objectKey: string): S3.PutObjectRequest {
+    public getS3ParamsForKey(objectKey: string): PutObjectRequest {
         let mergedConfig: S3ObjectConfig = {};
         for (const [matcher, config] of this.parsedS3UploadConfig) {
             if (matcher.match(objectKey)) {
                 mergedConfig = deepmerge(mergedConfig, config);
             }
         }
-        const putObjectRequest = {} as S3.PutObjectRequest;
+        const putObjectRequest = {} as PutObjectRequest;
         if (mergedConfig.metadata) {
             putObjectRequest.Metadata = mergedConfig.metadata;
         }

src/aws-helper.ts

@@ -1,70 +1,59 @@
-import S3 from "aws-sdk/clients/s3";
-import { autoPaginate } from "./aws-helper";
+import { S3, paginateListObjectsV2, PutObjectRequest } from "@aws-sdk/client-s3";
 
 export class SimpleS3 {
-    private readonly s3: S3 = new S3();
+    private readonly s3 = new S3();
 
     public async deleteObject(bucketName: string, key: string): Promise<void> {
-        await this.s3.deleteObject({ Bucket: bucketName, Key: key }).promise();
+        await this.s3.deleteObject({ Bucket: bucketName, Key: key });
     }
 
     public async listObjects(
         bucketName: string,
         objectPrefix: string | undefined
     ): Promise<string[]> {
-        const response = await autoPaginate<S3, S3.ListObjectsV2Request, S3.ListObjectsV2Output>(
-            this.s3,
-            // eslint-disable-next-line @typescript-eslint/unbound-method
-            this.s3.listObjectsV2,
+        const keys: string[] = [];
+        for await (const page of paginateListObjectsV2(
+            { client: this.s3 },
             {
                 Bucket: bucketName,
                 Prefix: objectPrefix,
             }
-        );
-        const keys = response.reduce(
-            (acc: string[], page) =>
-                acc.concat(page.Contents?.map((object) => object?.Key) as string[]),
-            []
-        );
+        )) {
+            for (const object of page.Contents ?? []) {
+                if (object.Key) {
+                    keys.push(object.Key);
+                }
+            }
+        }
         return keys;
     }
 
     public async isBucketEmpty(
         bucketName: string,
         objectPrefix: string | undefined
     ): Promise<boolean> {
-        return await this.s3
-            .listObjectsV2({
-                Bucket: bucketName,
-                Prefix: objectPrefix,
-                MaxKeys: 1,
-            })
-            .promise()
-            .then((data) => {
-                if (data.KeyCount && data.KeyCount > 0) {
-                    return false;
-                } else {
-                    return true;
-                }
-            });
+        const objects = await this.s3.listObjectsV2({
+            Bucket: bucketName,
+            Prefix: objectPrefix,
+            MaxKeys: 1,
+        });
+        return (objects.KeyCount ?? 0) === 0;
     }
 
     public async uploadFile(
         bucketName: string,
         objectPrefix: string | undefined,
         localFilePath: string,
         localFileContents: Buffer,
-        extraParams?: S3.PutObjectRequest
+        extraParams?: PutObjectRequest
     ): Promise<void> {
-        const key = (objectPrefix || "") + localFilePath;
+        const key = (objectPrefix ?? "") + localFilePath;
 
-        await this.s3
-            .upload({
-                Bucket: bucketName,
-                Key: key,
-                Body: localFileContents,
-                ...extraParams,
-            })
-            .promise();
+        await this.s3.putObject({
+            Bucket: bucketName,
+            Key: key,
+            Body: localFileContents,
+            ...extraParams,
+        });
     }
 }

src/s3-upload-config.ts

@@ -1,10 +1,15 @@
 import process from "process";
-import { CloudFormation, S3 } from "aws-sdk/clients/all";
+import {
+    CloudFormation,
+    ListStacksOutput,
+    paginateListStacks,
+    StackSummary,
+} from "@aws-sdk/client-cloudformation";
+import { S3 } from "@aws-sdk/client-s3";
 import { SimpleFs } from "../src/simple-fs";
 import path from "path";
 import childProcess from "child_process";
 import os from "os";
-import { autoPaginate } from "../src/aws-helper";
 
 import {
     fooBarContents1,
@@ -44,7 +49,7 @@ async function compareBucketContents(
         ContentDisposition?: string;
         CacheControl?: string;
     };
-    const response = await s3.listObjectsV2({ Bucket: bucketName }).promise();
+    const response = await s3.listObjectsV2({ Bucket: bucketName });
     const simpleResponse: ObjectDescription[] =
         response.Contents?.map((c) => ({
             Key: c.Key as string,
@@ -54,9 +59,7 @@ async function compareBucketContents(
 
     await Promise.all(
         simpleResponse.map(async (response) => {
-            const description = await s3
-                .headObject({ Bucket: bucketName, Key: response.Key })
-                .promise();
+            const description = await s3.headObject({ Bucket: bucketName, Key: response.Key });
             response.Metadata = description.Metadata;
             response.ContentType = description.ContentType;
 
@@ -175,33 +178,24 @@ async function createStackAndExpectFailure(
 
     await deleteStackIfExists(cloudFormation, stackName);
 
-    /* eslint-disable @typescript-eslint/unbound-method */
-    const stacks: CloudFormation.ListStacksOutput[] = await autoPaginate<
-        CloudFormation,
-        CloudFormation.ListStacksInput,
-        CloudFormation.ListStacksOutput
-    >(cloudFormation, cloudFormation.listStacks, {
-        StackStatusFilter: ["DELETE_COMPLETE"],
-    });
-    /* eslint-enable */
+    const stacks: ListStacksOutput[] = [];
+    for await (const page of paginateListStacks(
+        { client: cloudFormation },
+        { StackStatusFilter: ["DELETE_COMPLETE"] }
+    )) {
+        stacks.push(page);
+    }
 
     const mostRecentStackId = stacks
-        .reduce(
-            (acc: CloudFormation.StackSummary[], response) =>
-                acc.concat(response.StackSummaries || []),
-            []
-        )
+        .reduce((acc: StackSummary[], response) => acc.concat(response.StackSummaries || []), [])
         .filter((summary) => summary.StackName === stackName)
         .map((summary) => ({
             id: summary.StackId,
-            time: summary.DeletionTime!.getTime(), // eslint-disable-line @typescript-eslint/no-non-null-assertion
+            time: summary.DeletionTime?.getTime() ?? 0,
         }))
         .sort((a, b) => b.time - a.time)[0].id;
 
-    const events = await cloudFormation
-        .describeStackEvents({ StackName: mostRecentStackId })
-        .promise();
-
+    const events = await cloudFormation.describeStackEvents({ StackName: mostRecentStackId });
     const reasons = events.StackEvents?.filter(
         (event) => event.ResourceStatus === "CREATE_FAILED"
     ).map((event) => event.ResourceStatusReason);

src/simple-s3.ts

@@ -1,4 +1,8 @@
-import CloudFormation from "aws-sdk/clients/cloudformation";
+import {
+    CloudFormation,
+    waitUntilStackDeleteComplete,
+    Output,
+} from "@aws-sdk/client-cloudformation";
 
 interface StringMap {
     [key: string]: string;
@@ -9,25 +13,25 @@ async function describeStack(
     cloudFormation: CloudFormation,
     stackName: string
 ): Promise<StringMap> {
-    const descriptions = await cloudFormation.describeStacks({ StackName: stackName }).promise();
-    return descriptions.Stacks![0]!.Outputs!.reduce(
-        (accumulator: StringMap, output: CloudFormation.Output) => {
-            return {
-                [output.OutputKey!]: output.OutputValue,
-                ...accumulator,
-            } as StringMap;
-        },
-        {}
-    );
+    const descriptions = await cloudFormation.describeStacks({ StackName: stackName });
+    return descriptions.Stacks![0]!.Outputs!.reduce((accumulator: StringMap, output: Output) => {
+        return {
+            [output.OutputKey!]: output.OutputValue,
+            ...accumulator,
+        } as StringMap;
+    }, {});
 }
 /* eslint-enable */
 
 async function deleteStackIfExists(
     cloudFormation: CloudFormation,
     stackName: string
 ): Promise<void> {
-    await cloudFormation.deleteStack({ StackName: stackName }).promise();
-    await cloudFormation.waitFor("stackDeleteComplete", { StackName: stackName }).promise();
+    await cloudFormation.deleteStack({ StackName: stackName });
+    await waitUntilStackDeleteComplete(
+        { client: cloudFormation, maxWaitTime: Number.MAX_VALUE },
+        { StackName: stackName }
+    );
 }
 
 export { describeStack, deleteStackIfExists, StringMap };

tst/integration.test.ts

@@ -5,6 +5,7 @@ module.exports = {
     output: {
         filename: "s3-upload-custom-resource.js",
         path: path.resolve(__dirname, "dist"),
+        asyncChunks: false,
     },
     mode: "production",
     target: "node",