@aspan-corporation/ac-shared 0.0.1

package/README.md

@@ -0,0 +1 @@
+# Aspan Corporation code sharing

package/lib/dynamoDB.d.ts

@@ -0,0 +1,9 @@
+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/index.d.ts

@@ -0,0 +1,4 @@
+export * from './plumbingMiddleware.js';
+export * from './sharedUtils.js';
+export * from './s3.js';
+export * from './dynamoDB.js';

package/lib/index.js

@@ -0,0 +1,256 @@
+// src/plumbingMiddleware.ts
+import { Logger } from "@aws-lambda-powertools/logger";
+import { Metrics } from "@aws-lambda-powertools/metrics";
+import { Tracer } from "@aws-lambda-powertools/tracer";
+import assert from "node:assert";
+var plumbingMiddleware = () => {
+  assert(
+    process.env.POWERTOOLS_METRICS_NAMESPACE,
+    "POWERTOOLS_METRICS_NAMESPACE is not configured"
+  );
+  assert(
+    process.env.POWERTOOLS_SERVICE_NAME,
+    "POWERTOOLS_SERVICE_NAME is not configured"
+  );
+  const metrics = new Metrics();
+  const logger = new Logger();
+  const tracer = new Tracer();
+  let segment;
+  let subsegment;
+  let handlerSegment;
+  const before = async ({ context, event }) => {
+    logger.appendKeys({
+      awsRequestId: context.awsRequestId
+    });
+    const localLogger = logger.createChild();
+    localLogger.appendKeys({ function: "plumbingMiddleware.before" });
+    localLogger.info("incoming", { event });
+    segment = tracer.getSegment();
+    if (!segment) {
+      localLogger.error("Failed to get segment");
+      return;
+    }
+    metrics.captureColdStartMetric();
+    handlerSegment = segment.addNewSubsegment(`## ${process.env._HANDLER}`);
+    tracer.setSegment(handlerSegment);
+    tracer.annotateColdStart();
+    tracer.addServiceNameAnnotation();
+    tracer.putAnnotation("awsRequestId", context.awsRequestId);
+    subsegment = handlerSegment.addNewSubsegment("### MySubSegment");
+    tracer.setSegment(subsegment);
+    context.clientContext = {
+      client: context.clientContext?.client || {
+        appPackageName: "",
+        appTitle: "",
+        appVersionCode: "",
+        appVersionName: "",
+        installationId: ""
+      },
+      env: context.clientContext?.env || {
+        platform: "",
+        platformVersion: "",
+        make: "",
+        model: "",
+        locale: ""
+      },
+      Custom: { tracer, logger, metrics }
+    };
+  };
+  const after = async () => {
+    const localLogger = logger.createChild();
+    localLogger.appendKeys({ function: "plumbingMiddleware.after" });
+    try {
+      localLogger.debug("started closing in after");
+      subsegment.close();
+      handlerSegment.close();
+      tracer.setSegment(segment);
+      metrics.publishStoredMetrics();
+      localLogger.debug("finished closing in after");
+    } catch (error) {
+      localLogger.error("error in after", { error });
+      throw error;
+    }
+  };
+  return {
+    before,
+    after
+  };
+};
+
+// src/sharedUtils.ts
+import { DynamoDBPersistenceLayer } from "@aws-lambda-powertools/idempotency/dynamodb";
+import assert2 from "node:assert";
+var getPersistenceStore = () => {
+  assert2(
+    process.env.AC_IDEMPOTENCY_TABLE_NAME,
+    "AC_IDEMPOTENCY_TABLE_NAME is not configured"
+  );
+  const idempotencyTableName = process.env.AC_IDEMPOTENCY_TABLE_NAME;
+  return new DynamoDBPersistenceLayer({
+    tableName: idempotencyTableName
+  });
+};
+
+// src/s3.ts
+import {
+  GetObjectCommand,
+  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({
+    client,
+    params: {
+      Bucket: bucket,
+      Key: key,
+      Body: pass
+    }
+  });
+  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 });
+    return item.Body;
+  } catch (error) {
+    throw Error(`downloadStreamFromS3: ${error.message}`);
+  }
+}
+
+// src/dynamoDB.ts
+import {
+  CreateTableCommand,
+  DeleteTableCommand,
+  DescribeTableCommand,
+  DynamoDBClient
+} from "@aws-sdk/client-dynamodb";
+import {
+  DynamoDBDocumentClient,
+  GetCommand,
+  QueryCommand,
+  UpdateCommand,
+  PutCommand
+} 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
+      });
+      await setTimeout(2e3);
+    } while (true);
+  } catch (error) {
+  }
+  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)
+    );
+    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;
+};
+export {
+  createDynamoDBTable,
+  createS3DownloadStream,
+  createS3UploadStream,
+  deleteDynamoDBTable,
+  getCommand,
+  getPersistenceStore,
+  plumbingMiddleware,
+  putCommand,
+  queryCommand,
+  updateCommand
+};

package/lib/plumbingMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareObj } from "@middy/core";
+export declare const plumbingMiddleware: () => MiddlewareObj;

package/lib/s3.d.ts

@@ -0,0 +1,13 @@
+/// <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>;

package/lib/sharedUtils.d.ts

@@ -0,0 +1,2 @@
+import { DynamoDBPersistenceLayer } from "@aws-lambda-powertools/idempotency/dynamodb";
+export declare const getPersistenceStore: () => DynamoDBPersistenceLayer;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@aspan-corporation/ac-shared",
+  "version": "0.0.1",
+  "description": "",
+  "keywords": [],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "author": "",
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf lib",
+    "build": "npm run clean && npm run build:code && npm run build:types",
+    "build:code": "esbuild src/index.ts --outdir=lib --bundle --format=esm --platform=node --external:@aws-lambda-powertools/logger --external:@aws-lambda-powertools/metrics  --external:@aws-lambda-powertools/tracer  --external:@aws-sdk/client-dynamodb --external:@aws-sdk/lib-dynamodb --external:@aws-sdk/client-s3 --external:@aws-sdk/lib-storage --external:@aws-lambda-powertools/idempotency",
+    "build:types": "tsc --emitDeclarationOnly --declaration"
+  },
+  "devDependencies": {
+    "@aws-lambda-powertools/idempotency": "^2.0.3",
+    "@aws-lambda-powertools/logger": "^2.0.3",
+    "@aws-lambda-powertools/metrics": "^2.0.3",
+    "@aws-lambda-powertools/tracer": "^2.0.3",
+    "@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",
+    "@types/aws-lambda": "^8.10.137",
+    "@types/node": "^20.12.5",
+    "esbuild": "^0.20.2",
+    "typescript": "^5.4.4"
+  },
+  "dependencies": {
+    "@middy/core": "^4.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "lib",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ]
+}