@aspan-corporation/ac-shared 0.0.9 → 1.0.0

package/lib/index.d.ts

@@ -1,6 +1,6 @@
 export * from "./plumbingMiddleware.js";
 export * from "./sharedUtils.js";
-export * from "./s3.js";
-export * from "./dynamoDB.js";
+export * from "./services/s3.js";
+export * from "./services/dynamoDB.js";
 export * from "./assertUtils.js";
 export * from "./logger.js";

package/lib/index.js

@@ -102,182 +102,157 @@ var getPersistenceStore = () => {
   });
 };
 
-// src/s3.ts
+// src/services/s3.ts
 import {
   GetObjectCommand,
+  ListObjectsV2Command,
   S3Client
 } from "@aws-sdk/client-s3";
 import { Upload } from "@aws-sdk/lib-storage";
 import { PassThrough } from "node:stream";
-var client = new S3Client({});
-function createS3UploadStream({
-  bucket,
-  key,
-  logger
-}) {
-  const pass = new PassThrough();
-  const parallelUploads3 = new Upload({
+
+// src/logger.ts
+import { Logger as Logger3 } from "@aws-lambda-powertools/logger";
+var rootLogger = new Logger3();
+var getLoggerWithScope = (scope, logger = rootLogger) => {
+  const childLogger = logger.createChild();
+  childLogger.appendKeys({ scope });
+  return childLogger;
+};
+
+// src/services/s3.ts
+var S3Service = class {
+  logger;
+  client;
+  constructor({
+    logger,
     client,
-    params: {
-      Bucket: bucket,
-      Key: key,
-      Body: pass
+    assumeRoleCommandOutput
+  }) {
+    this.logger = getLoggerWithScope("ac-shared:s3", logger);
+    if (assumeRoleCommandOutput) {
+      this.client = new S3Client({
+        region: process.env.AWS_REGION,
+        logger: this.logger,
+        credentials: {
+          accessKeyId: assumeRoleCommandOutput?.Credentials?.AccessKeyId,
+          secretAccessKey: assumeRoleCommandOutput?.Credentials?.SecretAccessKey,
+          sessionToken: assumeRoleCommandOutput?.Credentials?.SessionToken
+        }
+      });
+    } else {
+      this.client = client ?? new S3Client({
+        region: process.env.AWS_REGION,
+        logger: this.logger
+      });
     }
-  });
-  parallelUploads3.done();
-  logger.info("setup upload stream");
-  return pass;
-}
-async function createS3DownloadStream({
-  logger,
-  getObjectCommandInput
-}) {
-  try {
-    const item = await client.send(new GetObjectCommand(getObjectCommandInput));
-    logger.debug("sent GetObjectCommand", { getObjectCommandInput });
+  }
+  async createS3UploadStream(putObjectCommandInput) {
+    this.logger.debug("upload stream started");
+    const pass = new PassThrough();
+    const parallelUploads3 = new Upload({
+      client: this.client,
+      params: {
+        ...putObjectCommandInput,
+        Body: pass
+      }
+    });
+    parallelUploads3.done();
+    this.logger.debug("upload stream finished");
+    return pass;
+  }
+  async createS3DownloadStream(getObjectCommandInput) {
+    this.logger.debug("download stream started");
+    const item = await this.client.send(
+      new GetObjectCommand(getObjectCommandInput)
+    );
+    this.logger.debug("download stream finished");
     return item.Body;
-  } catch (error) {
-    throw Error(`downloadStreamFromS3: ${error.message}`);
   }
-}
+  async listObjectsV2(listObjectsV2CommandInput) {
+    return await this.client.send(
+      new ListObjectsV2Command(listObjectsV2CommandInput)
+    );
+  }
+  async getObject(getObjectCommandInput) {
+    const stream = await this.createS3DownloadStream(getObjectCommandInput);
+    return Buffer.from(await stream.transformToByteArray());
+  }
+};
 
-// src/dynamoDB.ts
-import {
-  CreateTableCommand,
-  DeleteTableCommand,
-  DescribeTableCommand,
-  DynamoDBClient
-} from "@aws-sdk/client-dynamodb";
+// src/services/dynamoDB.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import {
   DynamoDBDocumentClient,
   GetCommand,
+  PutCommand,
   QueryCommand,
-  UpdateCommand,
-  PutCommand
+  UpdateCommand
 } from "@aws-sdk/lib-dynamodb";
-import { setTimeout } from "timers/promises";
-var dynamoDBClient = new DynamoDBClient({});
-var dynamoDBDocumentClient = DynamoDBDocumentClient.from(dynamoDBClient);
-var deleteDynamoDBTable = async (deleteTableInput, logger) => {
-  logger.debug("DeleteTableCommand input", {
-    DeleteTableInput: deleteTableInput
-  });
-  const deleteTableCommandOutput = await dynamoDBClient.send(
-    new DeleteTableCommand(deleteTableInput)
-  );
-  logger.debug("DeleteTableCommand output", {
-    DeleteTableCommandOutput: deleteTableCommandOutput
-  });
-  let describeTableCommandOutput;
-  try {
-    do {
-      describeTableCommandOutput = await dynamoDBClient.send(
-        new DescribeTableCommand(deleteTableInput)
-      );
-      logger.debug("DescribeTableCommand", {
-        DescribeTableCommandOutput: describeTableCommandOutput
+var DynamoDBService = class {
+  logger;
+  client;
+  documentClient;
+  constructor({
+    logger,
+    client,
+    assumeRoleCommandOutput
+  }) {
+    this.logger = getLoggerWithScope("ac-shared:dynamodb", logger);
+    if (assumeRoleCommandOutput) {
+      this.client = new DynamoDBClient({
+        region: process.env.AWS_REGION,
+        logger: this.logger,
+        credentials: {
+          accessKeyId: assumeRoleCommandOutput?.Credentials?.AccessKeyId,
+          secretAccessKey: assumeRoleCommandOutput?.Credentials?.SecretAccessKey,
+          sessionToken: assumeRoleCommandOutput?.Credentials?.SessionToken
+        }
+      });
+    } else {
+      this.client = client ?? new DynamoDBClient({
+        region: process.env.AWS_REGION,
+        logger: this.logger
       });
-      await setTimeout(2e3);
-    } while (true);
-  } catch (error) {
+    }
+    this.documentClient = DynamoDBDocumentClient.from(this.client);
   }
-  return describeTableCommandOutput;
-};
-var createDynamoDBTable = async (createTableInput, logger) => {
-  logger.debug("CreateTableCommand input", {
-    CreateTableInput: createTableInput
-  });
-  const createTableCommandOutput = await dynamoDBClient.send(
-    new CreateTableCommand(createTableInput)
-  );
-  logger.debug("CreateTableCommand output", {
-    CreateTableCommandOutput: createTableCommandOutput
-  });
-  let describeTableCommandOutput;
-  do {
-    await setTimeout(2e3);
-    describeTableCommandOutput = await dynamoDBClient.send(
-      new DescribeTableCommand(createTableInput)
+  async getCommand(getCommandInput) {
+    return await this.documentClient.send(new GetCommand(getCommandInput));
+  }
+  async updateCommand(updateCommandInput) {
+    return await this.documentClient.send(
+      new UpdateCommand(updateCommandInput)
     );
-    logger.debug("DescribeTableCommand", {
-      DescribeTableCommandOutput: describeTableCommandOutput
-    });
-  } while (describeTableCommandOutput.Table?.TableStatus !== "ACTIVE");
-  return describeTableCommandOutput;
-};
-var getCommand = async (getCommandInput, logger) => {
-  logger.debug("GetCommand input", {
-    GetCommandInput: getCommandInput
-  });
-  const getCommandOutput = await dynamoDBDocumentClient.send(
-    new GetCommand(getCommandInput)
-  );
-  logger.debug("GetCommand output", {
-    GetCommandOutput: getCommandOutput
-  });
-  return getCommandOutput;
-};
-var updateCommand = async (updateCommandInput, logger) => {
-  logger.debug("UpdateCommand input", {
-    UpdateCommandInput: updateCommandInput
-  });
-  const updateCommandOutput = await dynamoDBDocumentClient.send(
-    new UpdateCommand(updateCommandInput)
-  );
-  logger.debug("UpdateCommand output", {
-    UpdateCommandOutput: updateCommandOutput
-  });
-  return updateCommandOutput;
-};
-var queryCommand = async (queryCommandInput, logger) => {
-  logger.debug("QueryCommand input", {
-    QueryCommandInput: queryCommandInput
-  });
-  const queryCommandOutput = await dynamoDBDocumentClient.send(
-    new QueryCommand(queryCommandInput)
-  );
-  logger.debug("QueryCommand output", {
-    QueryCommandOutput: queryCommandOutput
-  });
-  return queryCommandOutput;
-};
-var putCommand = async (putCommandInput, logger) => {
-  logger.debug("PutCommand input", {
-    PutCommandInput: putCommandInput
-  });
-  const putCommandOutput = await dynamoDBDocumentClient.send(
-    new PutCommand(putCommandInput)
-  );
-  logger.debug("PutCommand output", {
-    PutCommandOutput: putCommandOutput
-  });
-  return putCommandOutput;
-};
-
-// src/logger.ts
-import { Logger as Logger3 } from "@aws-lambda-powertools/logger";
-var rootLogger = new Logger3();
-var getLoggerWithScope = (scope, logger = rootLogger) => {
-  const childLogger = rootLogger.createChild();
-  childLogger.appendKeys({ scope });
-  return childLogger;
+  }
+  async queryCommand(queryCommandInput) {
+    return await this.documentClient.send(new QueryCommand(queryCommandInput));
+  }
+  async putCommand(putCommandInput) {
+    return await this.documentClient.send(new PutCommand(putCommandInput));
+  }
+  async checkIfItemExists({
+    tableName,
+    key
+  }) {
+    const params = {
+      TableName: tableName,
+      Key: key
+    };
+    const result = await this.getCommand(params);
+    return !!result.Item;
+  }
 };
 export {
+  DynamoDBService,
   Logger2 as Logger,
   Metrics2 as Metrics,
+  S3Service,
   Tracer2 as Tracer,
   assertEnvVar,
   assertString,
-  createDynamoDBTable,
-  createS3DownloadStream,
-  createS3UploadStream,
-  deleteDynamoDBTable,
-  getCommand,
   getLoggerWithScope,
   getPersistenceStore,
   plumbingMiddleware,
-  putCommand,
-  queryCommand,
-  rootLogger,
-  updateCommand
+  rootLogger
 };

package/lib/services/dynamoDB.d.ts

@@ -0,0 +1,22 @@
+import { Logger } from "@aws-lambda-powertools/logger";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommandInput, GetCommandOutput, PutCommandInput, PutCommandOutput, QueryCommandInput, QueryCommandOutput, UpdateCommandInput, UpdateCommandOutput } from "@aws-sdk/lib-dynamodb";
+import { AssumeRoleCommandOutput } from "@aws-sdk/client-sts";
+export declare class DynamoDBService {
+    logger: Logger;
+    client: DynamoDBClient;
+    documentClient: DynamoDBDocumentClient;
+    constructor({ logger, client, assumeRoleCommandOutput }: {
+        logger?: Logger;
+        client?: DynamoDBClient;
+        assumeRoleCommandOutput?: AssumeRoleCommandOutput;
+    });
+    getCommand(getCommandInput: GetCommandInput): Promise<GetCommandOutput>;
+    updateCommand(updateCommandInput: UpdateCommandInput): Promise<UpdateCommandOutput>;
+    queryCommand(queryCommandInput: QueryCommandInput): Promise<QueryCommandOutput>;
+    putCommand(putCommandInput: PutCommandInput): Promise<PutCommandOutput>;
+    checkIfItemExists({ tableName, key }: {
+        tableName: string;
+        key: any;
+    }): Promise<boolean>;
+}

package/lib/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./s3.js";
+export * from "./dynamoDB.js";
+export * from "./ssm.js";
+export * from "./sqs.js";
+export * from "./sts.js";

package/lib/services/s3.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Logger } from "@aws-lambda-powertools/logger";
+import { GetObjectCommandInput, ListObjectsV2CommandInput, PutObjectCommandInput, S3Client } from "@aws-sdk/client-s3";
+import { AssumeRoleCommandOutput } from "@aws-sdk/client-sts";
+import { PassThrough } from "node:stream";
+export declare class S3Service {
+    logger: Logger;
+    client: S3Client;
+    constructor({ logger, client, assumeRoleCommandOutput }: {
+        logger?: Logger;
+        client?: S3Client;
+        assumeRoleCommandOutput?: AssumeRoleCommandOutput;
+    });
+    createS3UploadStream(putObjectCommandInput: PutObjectCommandInput): Promise<PassThrough>;
+    createS3DownloadStream(getObjectCommandInput: GetObjectCommandInput): Promise<import("@smithy/types").StreamingBlobPayloadOutputTypes>;
+    listObjectsV2(listObjectsV2CommandInput: ListObjectsV2CommandInput): Promise<import("@aws-sdk/client-s3").ListObjectsV2CommandOutput>;
+    getObject(getObjectCommandInput: GetObjectCommandInput): Promise<Buffer>;
+}

package/lib/services/sqs.d.ts

@@ -0,0 +1,16 @@
+import { Logger } from "@aws-lambda-powertools/logger";
+import { SQSClient, SendMessageCommandInput, ReceiveMessageCommandInput, DeleteMessageCommandInput, SendMessageBatchCommandInput, ReceiveMessageCommandOutput, SendMessageCommandOutput, DeleteMessageCommandOutput, SendMessageBatchCommandOutput } from "@aws-sdk/client-sqs";
+import { AssumeRoleCommandOutput } from "@aws-sdk/client-sts";
+export declare class SQSService {
+    logger: Logger;
+    client: SQSClient;
+    constructor({ logger, client, assumeRoleCommandOutput }: {
+        logger?: Logger;
+        client?: SQSClient;
+        assumeRoleCommandOutput?: AssumeRoleCommandOutput;
+    });
+    sendMessage(params: SendMessageCommandInput): Promise<SendMessageCommandOutput>;
+    sendMessageBatch(params: SendMessageBatchCommandInput): Promise<SendMessageBatchCommandOutput>;
+    receiveMessage(params: ReceiveMessageCommandInput): Promise<ReceiveMessageCommandOutput>;
+    deleteMessage(params: DeleteMessageCommandInput): Promise<DeleteMessageCommandOutput>;
+}

package/lib/services/ssm.d.ts

@@ -0,0 +1,14 @@
+import { Logger } from "@aws-lambda-powertools/logger";
+import { SSMClient, GetParameterCommandInput, GetParameterCommandOutput, PutParameterCommandInput, PutParameterCommandOutput } from "@aws-sdk/client-ssm";
+import { AssumeRoleCommandOutput } from "@aws-sdk/client-sts";
+export declare class SSMService {
+    logger: Logger;
+    client: SSMClient;
+    constructor({ logger, client, assumeRoleCommandOutput }: {
+        logger?: Logger;
+        client?: SSMClient;
+        assumeRoleCommandOutput?: AssumeRoleCommandOutput;
+    });
+    getParameter(params: GetParameterCommandInput): Promise<GetParameterCommandOutput>;
+    putParameter(params: PutParameterCommandInput): Promise<PutParameterCommandOutput>;
+}

package/lib/services/sts.d.ts

@@ -0,0 +1,11 @@
+import { STSClient, AssumeRoleCommandInput } from "@aws-sdk/client-sts";
+import { Logger } from "@aws-lambda-powertools/logger";
+export declare class STSService {
+    logger: Logger;
+    client: STSClient;
+    constructor({ logger }: {
+        logger?: Logger;
+    });
+    getCallerIdentity(): Promise<import("@aws-sdk/client-sts").GetCallerIdentityCommandOutput>;
+    assumeRole(assumeRoleCommandInput: AssumeRoleCommandInput): Promise<import("@aws-sdk/client-sts").AssumeRoleCommandOutput>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspan-corporation/ac-shared",
-  "version": "0.0.9",
+  "version": "1.0.0",
   "description": "",
   "keywords": [],
   "main": "lib/index.js",
@@ -25,10 +25,13 @@
     "@aws-lambda-powertools/logger": "^2.19.0",
     "@aws-lambda-powertools/metrics": "^2.19.0",
     "@aws-lambda-powertools/tracer": "^2.19.0",
-    "@aws-sdk/client-dynamodb": "^3.549.0",
-    "@aws-sdk/client-s3": "^3.550.0",
-    "@aws-sdk/lib-dynamodb": "^3.549.0",
-    "@aws-sdk/lib-storage": "^3.550.0",
+    "@aws-sdk/client-dynamodb": "^3.812.0",
+    "@aws-sdk/client-s3": "^3.812.0",
+    "@aws-sdk/client-sqs": "^3.812.0",
+    "@aws-sdk/client-ssm": "^3.812.0",
+    "@aws-sdk/client-sts": "^3.812.0",
+    "@aws-sdk/lib-dynamodb": "^3.812.0",
+    "@aws-sdk/lib-storage": "^3.812.0",
     "@middy/core": "^4.7.0",
     "aws-lambda": "^1.0.7"
   },

package/lib/dynamoDB.d.ts

@@ -1,9 +0,0 @@
-import { Logger } from "@aws-lambda-powertools/logger";
-import { CreateTableInput, DeleteTableInput, DescribeTableCommandOutput } from "@aws-sdk/client-dynamodb";
-import { GetCommandInput, GetCommandOutput, QueryCommandInput, QueryCommandOutput, UpdateCommandInput, UpdateCommandOutput, PutCommandOutput, PutCommandInput } from "@aws-sdk/lib-dynamodb";
-export declare const deleteDynamoDBTable: (deleteTableInput: DeleteTableInput, logger: Logger) => Promise<DescribeTableCommandOutput>;
-export declare const createDynamoDBTable: (createTableInput: CreateTableInput, logger: Logger) => Promise<DescribeTableCommandOutput>;
-export declare const getCommand: (getCommandInput: GetCommandInput, logger: Logger) => Promise<GetCommandOutput>;
-export declare const updateCommand: (updateCommandInput: UpdateCommandInput, logger: Logger) => Promise<UpdateCommandOutput>;
-export declare const queryCommand: (queryCommandInput: QueryCommandInput, logger: Logger) => Promise<QueryCommandOutput>;
-export declare const putCommand: (putCommandInput: PutCommandInput, logger: Logger) => Promise<PutCommandOutput>;

package/lib/s3.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Logger } from "@aws-lambda-powertools/logger";
-import { GetObjectCommandInput } from "@aws-sdk/client-s3";
-import { PassThrough } from "node:stream";
-export declare function createS3UploadStream({ bucket, key, logger, }: {
-    bucket: string;
-    key: string;
-    logger: Logger;
-}): PassThrough;
-export declare function createS3DownloadStream({ logger, getObjectCommandInput, }: {
-    getObjectCommandInput: GetObjectCommandInput;
-    logger: Logger;
-}): Promise<import("@smithy/types").StreamingBlobPayloadOutputTypes>;