@aspan-corporation/ac-shared 1.2.19 → 1.2.21

package/lib/index.js

@@ -1,1581 +1,3 @@
-// src/services/s3.ts
-import {
-  DeleteObjectCommand,
-  DeleteObjectsCommand,
-  GetObjectCommand,
-  HeadObjectCommand,
-  ListObjectsV2Command,
-  PutObjectCommand,
-  S3Client
-} from "@aws-sdk/client-s3";
-import { Upload } from "@aws-sdk/lib-storage";
-import assert3 from "node:assert/strict";
-import { PassThrough } from "node:stream";
-
-// src/utils/index.ts
-import assert2 from "node:assert/strict";
-
-// src/utils/normalizeErrorMessage.ts
-var normalizeErrorMessage = (error) => {
-  if (error instanceof Error) {
-    return error.message;
-  } else if (typeof error === "string") {
-    return error;
-  } else if (typeof error === "object" && error !== null) {
-    return JSON.stringify(error);
-  } else {
-    return String(error);
-  }
-};
-
-// src/utils/thumbsKey.ts
-import { extname } from "node:path";
-var JPEG_EXTENSION = "jpeg";
-var JPG_EXTENSION = "jpg";
-var HEIC_EXTENSION = "heic";
-var MOV_EXTENSION = "mov";
-var THUMBS_EXTENSION = JPG_EXTENSION;
-var ENCODED_VIDEO_EXTENSION = "mp4";
-var ALLOWED_EXTENSIONS = [
-  JPEG_EXTENSION,
-  JPG_EXTENSION,
-  HEIC_EXTENSION
-];
-var ALLOWED_VIDEO_EXTENSIONS = [MOV_EXTENSION];
-var THUMBNAIL_RESOLUTIONS = [
-  [200, 200],
-  [1180, 820]
-];
-var getThumbsKey = ({
-  key,
-  width,
-  height
-}) => {
-  return `${key.split(".").slice(0, -1).join(".")}.${width}x${height}.${THUMBS_EXTENSION}`;
-};
-var getEncodedVideoKey = ({ key }) => {
-  return `${key.split(".").slice(0, -1).join(".")}.${ENCODED_VIDEO_EXTENSION}`;
-};
-var getKeyExtension = (key) => extname(key).slice(1).toLowerCase();
-var isAllowedExtension = (key) => {
-  const ext = getKeyExtension(key);
-  return ALLOWED_EXTENSIONS.includes(ext);
-};
-var isAllowedVideoExtension = (key) => {
-  const ext = getKeyExtension(key);
-  return ALLOWED_VIDEO_EXTENSIONS.includes(ext);
-};
-
-// src/utils/helpers.ts
-var getObjectWithAssumeRoleCommandOutputAttribute = (assumeRoleCommandOutput) => assumeRoleCommandOutput ? {
-  credentials: {
-    accessKeyId: assumeRoleCommandOutput?.Credentials?.AccessKeyId,
-    secretAccessKey: assumeRoleCommandOutput?.Credentials?.SecretAccessKey,
-    sessionToken: assumeRoleCommandOutput?.Credentials?.SessionToken
-  }
-} : {};
-var getObjectWithStackAttribute = (error) => error && error instanceof Error ? { stack: error.stack } : {};
-
-// src/utils/processMeta.ts
-import assert from "node:assert/strict";
-var processMeta = async ({
-  id,
-  meta,
-  metaTableName,
-  size,
-  logger: logger2,
-  locationService,
-  dynamoDBService
-}) => {
-  const latitude = Number(meta.find((tag) => tag.key === "latitude")?.value);
-  const longitude = Number(meta.find((tag) => tag.key === "longitude")?.value);
-  let geoPositionResult;
-  if (!Number.isNaN(longitude) && !Number.isNaN(latitude)) {
-    try {
-      const res = await locationService.searchPlaceIndexForPositionCommand({
-        IndexName: "TauPlaceIndex",
-        Position: [longitude, latitude]
-      });
-      if (res?.Results && res?.Results?.length > 0) {
-        geoPositionResult = res?.Results[0];
-      } else {
-        throw Error("Can not resolve geo data");
-      }
-    } catch (error) {
-      logger2.error("Error fetching geo data", {
-        message: error instanceof Error ? error.message : ""
-      });
-    }
-  }
-  const newTags = [
-    ...meta,
-    ...meta.find((tag) => tag.key === "dateCreated") ? [] : extractMetaFromKey(id),
-    { key: "extension", value: getKeyExtension(id) },
-    { key: "size", value: String(size) },
-    { key: "sizeMb", value: String(Math.round(size / 1024 ** 2)) },
-    ...geoPositionResult?.Place?.Label ? [{ key: "label", value: geoPositionResult?.Place?.Label }] : [],
-    ...geoPositionResult?.Place?.Country ? [{ key: "country", value: geoPositionResult?.Place?.Country }] : [],
-    ...geoPositionResult?.Place?.Region ? [{ key: "region", value: geoPositionResult?.Place?.Region }] : [],
-    ...geoPositionResult?.Place?.SubRegion ? [{ key: "subRegion", value: geoPositionResult?.Place?.SubRegion }] : [],
-    ...geoPositionResult?.Place?.Municipality ? [{ key: "municipality", value: geoPositionResult?.Place?.Municipality }] : [],
-    ...geoPositionResult?.Place?.Neighborhood ? [{ key: "neighborhood", value: geoPositionResult?.Place?.Neighborhood }] : [],
-    ...geoPositionResult?.Place?.PostalCode ? [{ key: "postalCode", value: geoPositionResult?.Place?.PostalCode }] : []
-  ].map((tag) => ({
-    key: "ac:tau:" + tag.key,
-    value: tag.value
-  }));
-  logger2.debug("metaData", { newTags });
-  logger2.debug("trying to read existing metadata");
-  const getResponse = await dynamoDBService.getCommand({
-    TableName: metaTableName,
-    Key: {
-      id
-    }
-  });
-  const oldTags = getResponse.Item?.tags;
-  logger2.debug("existing tags", { getResponse });
-  const reconciledTags = reconcileTags({ newTags, oldTags }, logger2);
-  logger2.debug("result", { reconciledTags });
-  const updateResponse = await dynamoDBService.updateCommand({
-    TableName: metaTableName,
-    Key: {
-      id
-    },
-    UpdateExpression: "set tags = :tags",
-    ExpressionAttributeValues: {
-      ":tags": reconciledTags
-    },
-    ReturnValues: "ALL_NEW"
-  });
-  logger2.debug("sent UpdateCommand", { updateResponse });
-};
-var reconcileTags = ({ oldTags = [], newTags = [] }, logger2) => oldTags.reduce((acc, cur) => {
-  if (acc.find((element) => element.key === cur.key)) {
-    return acc;
-  } else {
-    logger2.debug("added", cur);
-    return [...acc, cur];
-  }
-}, newTags);
-var SUBSTRING_ANSI_DATES_BEGIN_WITH = "20";
-var extractMetaFromKey = (key) => {
-  if (!key)
-    return [];
-  let firstToken = void 0;
-  try {
-    const folder = key.split("/").at(-2);
-    assert(typeof folder === "string");
-    firstToken = folder.split(".")[0];
-  } catch (error) {
-  }
-  if (firstToken === void 0 || firstToken.length !== 8 || !firstToken.startsWith(SUBSTRING_ANSI_DATES_BEGIN_WITH))
-    return [];
-  const year = Number(firstToken.substring(0, 4));
-  const month = Number(firstToken.substring(4, 6)) - 1;
-  const day = Number(firstToken.substring(6));
-  if (isNaN(year) || isNaN(month) || isNaN(day))
-    return [];
-  if (year < 2e3 || month < 1 || month > 11 || day < 1 || day > 31)
-    return [];
-  const dateCreatedBin = new Date(year, month, day);
-  return [
-    { key: "dateCreated", value: dateCreatedBin.toISOString() },
-    { key: "yearCreated", value: dateCreatedBin.getFullYear().toString() },
-    { key: "dayCreated", value: dateCreatedBin.getDate().toString() },
-    {
-      key: "monthCreated",
-      value: (dateCreatedBin.getMonth() + 1).toString()
-    }
-  ];
-};
-
-// src/utils/index.ts
-var assertEnvVar = (envVar) => {
-  assert2(process.env[envVar], `${envVar} is not set`);
-  return process.env[envVar];
-};
-
-// src/services/s3.ts
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-var S3Service = class {
-  logger;
-  client;
-  constructor({
-    logger: logger2,
-    client,
-    assumeRoleCommandOutput,
-    region
-  }) {
-    this.logger = logger2;
-    if (client) {
-      this.client = client;
-    } else {
-      assert3(region, "Region must be provided if client is not passed");
-      this.client = new S3Client({
-        region,
-        ...getObjectWithAssumeRoleCommandOutputAttribute(
-          assumeRoleCommandOutput
-        )
-      });
-    }
-  }
-  createS3UploadStream(putObjectCommandInput) {
-    this.logger.debug("upload stream started", { putObjectCommandInput });
-    const pass = new PassThrough();
-    const parallelUploads = new Upload({
-      client: this.client,
-      params: {
-        ...putObjectCommandInput,
-        Body: pass
-      }
-    });
-    const donePromise = parallelUploads.done().then(() => this.logger.debug("upload stream finished")).catch((err) => {
-      this.logger.error("upload stream error", err);
-      pass.destroy(err);
-    });
-    return { stream: pass, done: donePromise };
-  }
-  async createS3DownloadStream(getObjectCommandInput) {
-    this.logger.debug("download stream started", { getObjectCommandInput });
-    const item = await this.client.send(
-      new GetObjectCommand(getObjectCommandInput)
-    );
-    this.logger.debug("download stream finished");
-    return item.Body;
-  }
-  async listObjectsV2(listObjectsV2CommandInput) {
-    this.logger.debug("listObjectsV2", { listObjectsV2CommandInput });
-    return await this.client.send(
-      new ListObjectsV2Command(listObjectsV2CommandInput)
-    );
-  }
-  async getObject(getObjectCommandInput) {
-    this.logger.debug("getObject", { getObjectCommandInput });
-    const stream = await this.createS3DownloadStream(getObjectCommandInput);
-    return Buffer.from(await stream.transformToByteArray());
-  }
-  async getSignedUrl(getObjectCommandInput) {
-    this.logger.debug("getSignedUrl", { getObjectCommandInput });
-    const signedUrl = await getSignedUrl(
-      this.client,
-      new GetObjectCommand(getObjectCommandInput),
-      { expiresIn: 3600 }
-    );
-    return signedUrl;
-  }
-  async putObject(putObjectCommandInput) {
-    this.logger.debug("putObject", { putObjectCommandInput });
-    return await this.client.send(new PutObjectCommand(putObjectCommandInput));
-  }
-  async headObject(headObjectCommandInput) {
-    this.logger.debug("headObject", { headObjectCommandInput });
-    return await this.client.send(
-      new HeadObjectCommand(headObjectCommandInput)
-    );
-  }
-  async checkIfObjectExists(headObjectCommandInput) {
-    this.logger.debug("checkIfObjectExists", { headObjectCommandInput });
-    try {
-      await this.headObject(headObjectCommandInput);
-      return true;
-    } catch (error) {
-      if (error.name === "NotFound") {
-        return false;
-      }
-      throw error;
-    }
-  }
-  async deleteObject(deleteObjectCommandInput) {
-    this.logger.debug("deleteObject", { deleteObjectCommandInput });
-    return await this.client.send(
-      new DeleteObjectCommand(deleteObjectCommandInput)
-    );
-  }
-  async deleteObjects(deleteObjectsCommandInput) {
-    this.logger.debug("deleteObjects", { deleteObjectsCommandInput });
-    return await this.client.send(
-      new DeleteObjectsCommand(deleteObjectsCommandInput)
-    );
-  }
-};
-
-// src/services/dynamoDB.ts
-import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import {
-  DynamoDBDocumentClient,
-  GetCommand,
-  PutCommand,
-  QueryCommand,
-  UpdateCommand,
-  ScanCommand,
-  BatchWriteCommand
-} from "@aws-sdk/lib-dynamodb";
-import assert4 from "node:assert/strict";
-var DynamoDBService = class {
-  logger;
-  client;
-  documentClient;
-  constructor({
-    logger: logger2,
-    client,
-    assumeRoleCommandOutput,
-    region
-  }) {
-    this.logger = logger2;
-    if (client) {
-      this.client = client;
-    } else {
-      assert4(region, "Region must be provided if client is not passed");
-      this.client = new DynamoDBClient({
-        region,
-        ...getObjectWithAssumeRoleCommandOutputAttribute(
-          assumeRoleCommandOutput
-        )
-      });
-    }
-    this.documentClient = DynamoDBDocumentClient.from(this.client);
-  }
-  async getCommand(getCommandInput) {
-    return await this.documentClient.send(new GetCommand(getCommandInput));
-  }
-  async updateCommand(updateCommandInput) {
-    return await this.documentClient.send(
-      new UpdateCommand(updateCommandInput)
-    );
-  }
-  async queryCommand(queryCommandInput) {
-    return await this.documentClient.send(new QueryCommand(queryCommandInput));
-  }
-  async putCommand(putCommandInput) {
-    return await this.documentClient.send(new PutCommand(putCommandInput));
-  }
-  async checkIfItemExists(checkInput) {
-    const result = await this.getCommand(checkInput);
-    return !!result.Item;
-  }
-  async scanCommand(scanCommandInput) {
-    return await this.client.send(new ScanCommand(scanCommandInput));
-  }
-  async batchWriteCommand(batchWriteCommandInput) {
-    return await this.client.send(
-      new BatchWriteCommand(batchWriteCommandInput)
-    );
-  }
-};
-
-// src/services/ssm.ts
-import {
-  GetParameterCommand,
-  PutParameterCommand,
-  SSMClient
-} from "@aws-sdk/client-ssm";
-import assert5 from "node:assert/strict";
-var SSMService = class {
-  logger;
-  client;
-  constructor({
-    logger: logger2,
-    client,
-    assumeRoleCommandOutput,
-    region
-  }) {
-    this.logger = logger2;
-    if (client) {
-      this.client = client;
-    } else {
-      assert5(region, "Region must be provided if client is not passed");
-      this.client = new SSMClient({
-        region,
-        ...getObjectWithAssumeRoleCommandOutputAttribute(
-          assumeRoleCommandOutput
-        )
-      });
-    }
-  }
-  async getParameter(params) {
-    return await this.client.send(new GetParameterCommand(params));
-  }
-  async putParameter(params) {
-    return await this.client.send(new PutParameterCommand(params));
-  }
-};
-
-// src/services/sqs.ts
-import {
-  DeleteMessageCommand,
-  ReceiveMessageCommand,
-  SQSClient,
-  SendMessageBatchCommand,
-  SendMessageCommand
-} from "@aws-sdk/client-sqs";
-import assert6 from "node:assert/strict";
-var SQSService = class {
-  logger;
-  client;
-  constructor({
-    logger: logger2,
-    client,
-    assumeRoleCommandOutput,
-    region
-  }) {
-    this.logger = logger2;
-    if (client) {
-      this.client = client;
-    } else {
-      assert6(region, "Region must be provided if client is not passed");
-      this.client = new SQSClient({
-        region,
-        ...getObjectWithAssumeRoleCommandOutputAttribute(
-          assumeRoleCommandOutput
-        )
-      });
-    }
-  }
-  async sendMessage(params) {
-    return await this.client.send(new SendMessageCommand(params));
-  }
-  async sendMessageBatch(params) {
-    return await this.client.send(new SendMessageBatchCommand(params));
-  }
-  async receiveMessage(params) {
-    return await this.client.send(new ReceiveMessageCommand(params));
-  }
-  async deleteMessage(params) {
-    return await this.client.send(new DeleteMessageCommand(params));
-  }
-};
-
-// src/services/sts.ts
-import { Logger } from "@aws-lambda-powertools/logger";
-import {
-  AssumeRoleCommand,
-  GetCallerIdentityCommand,
-  STSClient
-} from "@aws-sdk/client-sts";
-import assert7 from "node:assert/strict";
-var STSService = class {
-  logger;
-  client;
-  constructor({
-    logger: logger2,
-    region,
-    client
-  }) {
-    if (logger2) {
-      this.logger = logger2;
-    } else {
-      this.logger = new Logger();
-      this.logger.appendKeys({ scope: "STSService" });
-    }
-    if (client) {
-      this.client = client;
-    } else {
-      assert7(region, "Region must be provided if client is not passed");
-      this.client = new STSClient({
-        region
-      });
-    }
-  }
-  async getCallerIdentity() {
-    this.logger.debug("getCallerIdentity");
-    return await this.client.send(new GetCallerIdentityCommand({}));
-  }
-  async assumeRole(assumeRoleCommandInput) {
-    this.logger.debug("assumeRole", { assumeRoleCommandInput });
-    return await this.client.send(
-      new AssumeRoleCommand(assumeRoleCommandInput)
-    );
-  }
-};
-
-// src/services/location.ts
-import {
-  LocationClient,
-  SearchPlaceIndexForPositionCommand
-} from "@aws-sdk/client-location";
-import assert8 from "node:assert/strict";
-var LocationService = class {
-  logger;
-  client;
-  constructor({
-    logger: logger2,
-    client,
-    assumeRoleCommandOutput,
-    region
-  }) {
-    this.logger = logger2;
-    if (client) {
-      this.client = client;
-    } else {
-      assert8(region, "Region must be provided if client is not passed");
-      this.client = new LocationClient({
-        region,
-        ...getObjectWithAssumeRoleCommandOutputAttribute(
-          assumeRoleCommandOutput
-        )
-      });
-    }
-  }
-  async searchPlaceIndexForPositionCommand(searchPlaceIndexForPositionCommandInput) {
-    return await this.client.send(
-      new SearchPlaceIndexForPositionCommand(
-        searchPlaceIndexForPositionCommandInput
-      )
-    );
-  }
-};
-
-// src/services/cloudWatch.ts
-import {
-  CloudWatchLogsClient,
-  DescribeLogStreamsCommand,
-  PutLogEventsCommand
-} from "@aws-sdk/client-cloudwatch-logs";
-import assert9 from "node:assert/strict";
-var CloudWatchService = class {
-  logger;
-  client;
-  constructor({
-    logger: logger2,
-    client,
-    assumeRoleCommandOutput,
-    region
-  }) {
-    this.logger = logger2;
-    if (client) {
-      this.client = client;
-    } else {
-      assert9(region, "Region must be provided if client is not passed");
-      this.client = new CloudWatchLogsClient({
-        region,
-        ...getObjectWithAssumeRoleCommandOutputAttribute(
-          assumeRoleCommandOutput
-        )
-      });
-    }
-  }
-  async describeLogStreamsCommand(describeLogStreamsCommandInput) {
-    this.logger.debug("describeLogStreamsCommand", {
-      describeLogStreamsCommandInput
-    });
-    return await this.client.send(
-      new DescribeLogStreamsCommand(describeLogStreamsCommandInput)
-    );
-  }
-  async putLogEventsCommand(putLogEventsCommandInput) {
-    this.logger.debug("putLogEventsCommand", { putLogEventsCommandInput });
-    return await this.client.send(
-      new PutLogEventsCommand(putLogEventsCommandInput)
-    );
-  }
-};
-
-// node_modules/@aws-lambda-powertools/batch/node_modules/@aws/lambda-invoke-store/dist-es/invoke-store.js
-var PROTECTED_KEYS = {
-  REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
-  X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
-  TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID")
-};
-var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
-if (!NO_GLOBAL_AWS_LAMBDA) {
-  globalThis.awslambda = globalThis.awslambda || {};
-}
-var InvokeStoreBase = class {
-  static PROTECTED_KEYS = PROTECTED_KEYS;
-  isProtectedKey(key) {
-    return Object.values(PROTECTED_KEYS).includes(key);
-  }
-  getRequestId() {
-    return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
-  }
-  getXRayTraceId() {
-    return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
-  }
-  getTenantId() {
-    return this.get(PROTECTED_KEYS.TENANT_ID);
-  }
-};
-var InvokeStoreSingle = class extends InvokeStoreBase {
-  currentContext;
-  getContext() {
-    return this.currentContext;
-  }
-  hasContext() {
-    return this.currentContext !== void 0;
-  }
-  get(key) {
-    return this.currentContext?.[key];
-  }
-  set(key, value) {
-    if (this.isProtectedKey(key)) {
-      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
-    }
-    this.currentContext = this.currentContext || {};
-    this.currentContext[key] = value;
-  }
-  run(context, fn) {
-    this.currentContext = context;
-    return fn();
-  }
-};
-var InvokeStoreMulti = class _InvokeStoreMulti extends InvokeStoreBase {
-  als;
-  static async create() {
-    const instance = new _InvokeStoreMulti();
-    const asyncHooks = await import("node:async_hooks");
-    instance.als = new asyncHooks.AsyncLocalStorage();
-    return instance;
-  }
-  getContext() {
-    return this.als.getStore();
-  }
-  hasContext() {
-    return this.als.getStore() !== void 0;
-  }
-  get(key) {
-    return this.als.getStore()?.[key];
-  }
-  set(key, value) {
-    if (this.isProtectedKey(key)) {
-      throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
-    }
-    const store = this.als.getStore();
-    if (!store) {
-      throw new Error("No context available");
-    }
-    store[key] = value;
-  }
-  run(context, fn) {
-    return this.als.run(context, fn);
-  }
-};
-var InvokeStore;
-(function(InvokeStore2) {
-  let instance = null;
-  async function getInstanceAsync() {
-    if (!instance) {
-      instance = (async () => {
-        const isMulti = "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
-        const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle();
-        if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
-          return globalThis.awslambda.InvokeStore;
-        } else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
-          globalThis.awslambda.InvokeStore = newInstance;
-          return newInstance;
-        } else {
-          return newInstance;
-        }
-      })();
-    }
-    return instance;
-  }
-  InvokeStore2.getInstanceAsync = getInstanceAsync;
-  InvokeStore2._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
-    reset: () => {
-      instance = null;
-      if (globalThis.awslambda?.InvokeStore) {
-        delete globalThis.awslambda.InvokeStore;
-      }
-      globalThis.awslambda = {};
-    }
-  } : void 0;
-})(InvokeStore || (InvokeStore = {}));
-
-// node_modules/@aws-lambda-powertools/batch/node_modules/@aws-lambda-powertools/commons/lib/esm/constants.js
-var AWS_LAMBDA_MAX_CONCURRENCY = "AWS_LAMBDA_MAX_CONCURRENCY";
-
-// node_modules/@aws-lambda-powertools/batch/node_modules/@aws-lambda-powertools/commons/lib/esm/envUtils.js
-var getStringFromEnv = ({ key, defaultValue, errorMessage }) => {
-  const value = process.env[key];
-  if (value === void 0) {
-    if (defaultValue !== void 0) {
-      return defaultValue;
-    }
-    if (errorMessage) {
-      throw new Error(errorMessage);
-    }
-    throw new Error(`Environment variable ${key} is required`);
-  }
-  return value.trim();
-};
-var shouldUseInvokeStore = () => {
-  const res = getStringFromEnv({
-    key: AWS_LAMBDA_MAX_CONCURRENCY,
-    defaultValue: ""
-  });
-  return res !== "";
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/BatchProcessingStore.js
-var BatchProcessingStore = class {
-  #recordsKey = Symbol("powertools.batch.records");
-  #handlerKey = Symbol("powertools.batch.handler");
-  #optionsKey = Symbol("powertools.batch.options");
-  #failureMessagesKey = Symbol("powertools.batch.failureMessages");
-  #successMessagesKey = Symbol("powertools.batch.successMessages");
-  #batchResponseKey = Symbol("powertools.batch.batchResponse");
-  #errorsKey = Symbol("powertools.batch.errors");
-  #fallbackRecords = [];
-  #fallbackHandler = () => {
-  };
-  #fallbackOptions;
-  #fallbackFailureMessages = [];
-  #fallbackSuccessMessages = [];
-  #fallbackBatchResponse = {
-    batchItemFailures: []
-  };
-  #fallbackErrors = [];
-  getRecords() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackRecords;
-    }
-    if (globalThis.awslambda?.InvokeStore === void 0) {
-      throw new Error("InvokeStore is not available");
-    }
-    const store = globalThis.awslambda.InvokeStore;
-    return store.get(this.#recordsKey) ?? [];
-  }
-  setRecords(records) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackRecords = records;
-      return;
-    }
-    if (globalThis.awslambda?.InvokeStore === void 0) {
-      throw new Error("InvokeStore is not available");
-    }
-    const store = globalThis.awslambda.InvokeStore;
-    store.set(this.#recordsKey, records);
-  }
-  getHandler() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackHandler;
-    }
-    return globalThis.awslambda?.InvokeStore?.get(this.#handlerKey) ?? (() => {
-    });
-  }
-  setHandler(handler) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackHandler = handler;
-      return;
-    }
-    globalThis.awslambda?.InvokeStore?.set(this.#handlerKey, handler);
-  }
-  getOptions() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackOptions;
-    }
-    return globalThis.awslambda?.InvokeStore?.get(this.#optionsKey);
-  }
-  setOptions(options) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackOptions = options;
-      return;
-    }
-    globalThis.awslambda?.InvokeStore?.set(this.#optionsKey, options);
-  }
-  getFailureMessages() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackFailureMessages;
-    }
-    return globalThis.awslambda?.InvokeStore?.get(this.#failureMessagesKey) ?? [];
-  }
-  setFailureMessages(messages) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackFailureMessages = messages;
-      return;
-    }
-    globalThis.awslambda?.InvokeStore?.set(this.#failureMessagesKey, messages);
-  }
-  getSuccessMessages() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackSuccessMessages;
-    }
-    return globalThis.awslambda?.InvokeStore?.get(this.#successMessagesKey) ?? [];
-  }
-  setSuccessMessages(messages) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackSuccessMessages = messages;
-      return;
-    }
-    globalThis.awslambda?.InvokeStore?.set(this.#successMessagesKey, messages);
-  }
-  getBatchResponse() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackBatchResponse;
-    }
-    return globalThis.awslambda?.InvokeStore?.get(this.#batchResponseKey) ?? { batchItemFailures: [] };
-  }
-  setBatchResponse(response) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackBatchResponse = response;
-      return;
-    }
-    globalThis.awslambda?.InvokeStore?.set(this.#batchResponseKey, response);
-  }
-  getErrors() {
-    if (!shouldUseInvokeStore()) {
-      return this.#fallbackErrors;
-    }
-    return globalThis.awslambda?.InvokeStore?.get(this.#errorsKey) ?? [];
-  }
-  setErrors(errors) {
-    if (!shouldUseInvokeStore()) {
-      this.#fallbackErrors = errors;
-      return;
-    }
-    globalThis.awslambda?.InvokeStore?.set(this.#errorsKey, errors);
-  }
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/BasePartialProcessor.js
-var BasePartialProcessor = class {
-  /**
-   * Store for managing invocation-specific state
-   */
-  #store = new BatchProcessingStore();
-  get errors() {
-    return this.#store.getErrors();
-  }
-  set errors(errors) {
-    this.#store.setErrors(errors);
-  }
-  get failureMessages() {
-    return this.#store.getFailureMessages();
-  }
-  set failureMessages(messages) {
-    this.#store.setFailureMessages(messages);
-  }
-  get handler() {
-    return this.#store.getHandler();
-  }
-  set handler(handler) {
-    this.#store.setHandler(handler);
-  }
-  get options() {
-    return this.#store.getOptions();
-  }
-  set options(options) {
-    this.#store.setOptions(options);
-  }
-  get records() {
-    return this.#store.getRecords();
-  }
-  set records(records) {
-    this.#store.setRecords(records);
-  }
-  get successMessages() {
-    return this.#store.getSuccessMessages();
-  }
-  set successMessages(messages) {
-    this.#store.setSuccessMessages(messages);
-  }
-  get batchResponse() {
-    return this.#store.getBatchResponse();
-  }
-  set batchResponse(response) {
-    this.#store.setBatchResponse(response);
-  }
-  /**
-   * Method to handle a record that failed processing
-   *
-   * This method should be called when a record fails processing so that
-   * the processor can keep track of the error and the record that failed.
-   *
-   * @param record - Record that failed processing
-   * @param error - Error that was thrown
-   */
-  failureHandler(record, error) {
-    const entry = ["fail", error.message, record];
-    this.errors.push(error);
-    this.failureMessages.push(record);
-    return entry;
-  }
-  /**
-   * Process all records with an asynchronous handler
-   *
-   * Once called, the processor will create an array of promises to process each record
-   * and wait for all of them to settle before returning the results.
-   *
-   * Before and after processing, the processor will call the prepare and clean methods respectively.
-   */
-  async process() {
-    this.prepare();
-    const processInParallel = this.options?.processInParallel ?? true;
-    const processedRecords = processInParallel ? await this.#processRecordsInParallel() : await this.#processRecordsSequentially();
-    this.clean();
-    return processedRecords;
-  }
-  /**
-   * Orchestrate the processing of a batch of records synchronously
-   * and sequentially.
-   *
-   * The method is responsible for calling the prepare method before
-   * processing the records and the clean method after processing the records.
-   *
-   * In the middle, the method will iterate over the records and call the
-   * processRecordSync method for each record.
-   *
-   * @returns List of processed records
-   */
-  processSync() {
-    if (this.constructor.name === "BatchProcessor") {
-      this.processRecordSync(this.records[0]);
-    }
-    this.prepare();
-    const processedRecords = [];
-    for (const record of this.records) {
-      processedRecords.push(this.processRecordSync(record));
-    }
-    this.clean();
-    return processedRecords;
-  }
-  /**
-   * Set up the processor with the records and the handler
-   *
-   * This method should be called before processing the records to
-   * bind the records and the handler for a specific invocation to
-   * the processor.
-   *
-   * We use a separate method to do this rather than the constructor
-   * to allow for reusing the processor instance across multiple invocations
-   * by instantiating the processor outside the Lambda function handler.
-   *
-   * @param records - Array of records to be processed
-   * @param handler - CallableFunction to process each record from the batch
-   * @param options - Options to be used during processing (optional)
-   */
-  register(records, handler, options) {
-    this.records = records;
-    this.handler = handler;
-    if (options) {
-      this.options = options;
-    }
-    return this;
-  }
-  /**
-   * Method to handle a record that succeeded processing
-   *
-   * This method should be called when a record succeeds processing so that
-   * the processor can keep track of the result and the record that succeeded.
-   *
-   * @param record - Record that succeeded processing
-   * @param result - Result from record handler
-   */
-  successHandler(record, result) {
-    const entry = ["success", result, record];
-    this.successMessages.push(record);
-    return entry;
-  }
-  /**
-   * Processes records in parallel using `Promise.all`.
-   */
-  #processRecordsInParallel() {
-    return Promise.all(this.records.map((record) => this.processRecord(record)));
-  }
-  /**
-   * Processes records sequentially, ensuring that each record is processed one after the other.
-   */
-  async #processRecordsSequentially() {
-    const processedRecords = [];
-    for (const record of this.records) {
-      processedRecords.push(await this.processRecord(record));
-    }
-    return processedRecords;
-  }
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/constants.js
-var EventType = {
-  SQS: "SQS",
-  KinesisDataStreams: "KinesisDataStreams",
-  DynamoDBStreams: "DynamoDBStreams"
-};
-var DEFAULT_RESPONSE = {
-  batchItemFailures: []
-};
-var DATA_CLASS_MAPPING = {
-  [EventType.SQS]: (record) => record,
-  [EventType.KinesisDataStreams]: (record) => record,
-  [EventType.DynamoDBStreams]: (record) => record
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/errors.js
-var BatchProcessingError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "BatchProcessingError";
-  }
-};
-var FullBatchFailureError = class extends BatchProcessingError {
-  recordErrors;
-  constructor(childErrors) {
-    super("All records failed processing. See individual errors below.");
-    this.recordErrors = childErrors;
-    this.name = "FullBatchFailureError";
-  }
-};
-var UnexpectedBatchTypeError = class extends BatchProcessingError {
-  constructor() {
-    super(`Unexpected batch type. Possible values are: ${Object.values(EventType).join(", ")}`);
-    this.name = "UnexpectedBatchTypeError";
-  }
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/BasePartialBatchProcessor.js
-var BasePartialBatchProcessor = class extends BasePartialProcessor {
-  /**
-   * Mapping of event types to their respective failure collectors
-   *
-   * Each service expects a different format for partial failure reporting,
-   * this mapping ensures that the correct format is used for each event type.
-   */
-  COLLECTOR_MAPPING;
-  /**
-   * Type of event that the processor is handling
-   */
-  eventType;
-  /**
-   * A logger instance to be used for logging debug, warning, and error messages.
-   *
-   * When no logger is provided, we'll only log warnings and errors using the global `console` object.
-   */
-  logger;
-  /**
-   * The configuration options for the parser integration
-   */
-  parserConfig;
-  /**
-   * Initializes base batch processing class
-   *
-   * @param eventType The type of event to process (SQS, Kinesis, DynamoDB)
-   */
-  constructor(eventType, parserConfig) {
-    super();
-    this.eventType = eventType;
-    this.batchResponse = DEFAULT_RESPONSE;
-    this.COLLECTOR_MAPPING = {
-      [EventType.SQS]: () => this.collectSqsFailures(),
-      [EventType.KinesisDataStreams]: () => this.collectKinesisFailures(),
-      [EventType.DynamoDBStreams]: () => this.collectDynamoDBFailures()
-    };
-    this.parserConfig = parserConfig;
-    const alcLogLevel = getStringFromEnv({
-      key: "AWS_LAMBDA_LOG_LEVEL",
-      defaultValue: ""
-    });
-    this.logger = parserConfig?.logger ?? {
-      debug: alcLogLevel === "DEBUG" ? console.debug : () => void 0,
-      error: console.error,
-      warn: console.warn
-    };
-  }
-  /**
-   * Clean up logic to be run after processing a batch
-   *
-   * If the entire batch failed this method will throw a {@link FullBatchFailureError | `FullBatchFailureError`} with the list of
-   * errors that occurred during processing, unless the `throwOnFullBatchFailure` option is set to `false`.
-   *
-   * Otherwise, it will build the partial failure response based on the event type.
-   */
-  clean() {
-    if (!this.hasMessagesToReport()) {
-      return;
-    }
-    if (this.options?.throwOnFullBatchFailure !== false && this.entireBatchFailed()) {
-      throw new FullBatchFailureError(this.errors);
-    }
-    const messages = this.getMessagesToReport();
-    this.batchResponse = { batchItemFailures: messages };
-  }
-  /**
-   * Collect the identifiers of failed items for a DynamoDB stream
-   *
-   * The failures are collected based on the sequence number of the record
-   * and formatted as a list of objects with the key `itemIdentifier` as
-   * expected by the service.
-   */
-  collectDynamoDBFailures() {
-    const failures = [];
-    for (const msg of this.failureMessages) {
-      const msgId = msg.dynamodb?.SequenceNumber;
-      if (msgId) {
-        failures.push({ itemIdentifier: msgId });
-      }
-    }
-    return failures;
-  }
-  /**
-   * Collect identifiers of failed items for a Kinesis batch
-   *
-   * The failures are collected based on the sequence number of the record
-   * and formatted as a list of objects with the key `itemIdentifier` as
-   * expected by the service.
-   */
-  collectKinesisFailures() {
-    const failures = [];
-    for (const msg of this.failureMessages) {
-      const msgId = msg.kinesis.sequenceNumber;
-      failures.push({ itemIdentifier: msgId });
-    }
-    return failures;
-  }
-  /**
-   * Collect identifiers of failed items for an SQS batch
-   *
-   * The failures are collected based on the message ID of the record
-   * and formatted as a list of objects with the key `itemIdentifier` as
-   * expected by the service.
-   */
-  collectSqsFailures() {
-    const failures = [];
-    for (const msg of this.failureMessages) {
-      const msgId = msg.messageId;
-      failures.push({ itemIdentifier: msgId });
-    }
-    return failures;
-  }
-  /**
-   * Determine if the entire batch failed
-   *
-   * If the number of errors is equal to the number of records, then the
-   * entire batch failed and this method will return `true`.
-   */
-  entireBatchFailed() {
-    return this.errors.length === this.records.length;
-  }
-  /**
-   * Collect identifiers for failed batch items
-   *
-   * The method will call the appropriate collector based on the event type
-   * and return the list of failed items.
-   */
-  getMessagesToReport() {
-    return this.COLLECTOR_MAPPING[this.eventType]();
-  }
-  /**
-   * Determine if there are any failed records to report
-   *
-   * If there are no failed records, then the batch was successful
-   * and this method will return `false`.
-   */
-  hasMessagesToReport() {
-    return this.failureMessages.length !== 0;
-  }
-  /**
-   * Set up the processor with the initial state ready for processing
-   */
-  prepare() {
-    this.successMessages = [];
-    this.failureMessages = [];
-    this.errors = [];
-    this.batchResponse = DEFAULT_RESPONSE;
-  }
-  /**
-   * Get the response from the batch processing
-   */
-  response() {
-    return this.batchResponse;
-  }
-  /**
-   * Forward a record to the appropriate batch type
-   *
-   * Based on the event type that the processor was initialized with, this method
-   * will cast the record to the appropriate batch type handler.
-   *
-   * @param record The record to be processed
-   * @param eventType The type of event to process
-   */
-  toBatchType(record, eventType) {
-    return DATA_CLASS_MAPPING[eventType](record);
-  }
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/BatchProcessor.js
-var BatchProcessor = class extends BasePartialBatchProcessor {
-  /**
-   * Handle a record asynchronously with the instance handler provided.
-   *
-   * This method implements the abstract method from the parent class,
-   * and orchestrates the processing of a single record.
-   *
-   * First, it converts the record to the appropriate type for the batch processor.
-   * Then, it calls the handler function with the record data and context.
-   *
-   * If the handler function completes successfully, the method returns a success response.
-   * Otherwise, it returns a failure response with the error that occurred during processing.
-   *
-   * @param record - The record to be processed
-   */
-  async processRecord(record) {
-    try {
-      const recordToProcess = this.parserConfig?.parser ? await this.parserConfig.parser(record, this.eventType, this.logger, this.parserConfig) : record;
-      const data = this.toBatchType(recordToProcess, this.eventType);
-      const result = await this.handler(data, this.options?.context);
-      return this.successHandler(record, result);
-    } catch (error) {
-      return this.failureHandler(record, error);
-    }
-  }
-  /**
-   * @throws {BatchProcessingError} This method is not implemented for synchronous processing.
-   *
-   * @param _record - The record to be processed
-   */
-  processRecordSync(_record) {
-    throw new BatchProcessingError("Not implemented. Use asyncProcess() instead.");
-  }
-};
-
-// node_modules/@aws-lambda-powertools/batch/lib/esm/processPartialResponse.js
-var processPartialResponse = async (event, recordHandler, processor, options) => {
-  if (!event.Records || !Array.isArray(event.Records)) {
-    throw new UnexpectedBatchTypeError();
-  }
-  processor.register(event.Records, recordHandler, options);
-  await processor.process();
-  return processor.response();
-};
-
-// src/lambda/index.ts
-import { IdempotencyConfig } from "@aws-lambda-powertools/idempotency";
-import { DynamoDBPersistenceLayer } from "@aws-lambda-powertools/idempotency/dynamodb";
-import { Logger as Logger2 } from "@aws-lambda-powertools/logger";
-import { injectLambdaContext } from "@aws-lambda-powertools/logger/middleware";
-import { Metrics, MetricUnit } from "@aws-lambda-powertools/metrics";
-import { logMetrics } from "@aws-lambda-powertools/metrics/middleware";
-import { Tracer } from "@aws-lambda-powertools/tracer";
-import { captureLambdaHandler } from "@aws-lambda-powertools/tracer/middleware";
-
-// node_modules/@middy/core/index.js
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { setTimeout as setTimeout2 } from "node:timers/promises";
-var defaultLambdaHandler = () => {
-};
-var defaultPlugin = {
-  timeoutEarlyInMillis: 5,
-  timeoutEarlyResponse: () => {
-    throw new Error("Timeout");
-  },
-  streamifyResponse: false
-  // Deprecate need for this when AWS provides a flag for when it's looking for it
-};
-var middy = (lambdaHandler = defaultLambdaHandler, plugin = {}) => {
-  if (typeof lambdaHandler !== "function") {
-    plugin = lambdaHandler;
-    lambdaHandler = defaultLambdaHandler;
-  }
-  plugin = {
-    ...defaultPlugin,
-    ...plugin
-  };
-  plugin.timeoutEarly = plugin.timeoutEarlyInMillis > 0;
-  plugin.beforePrefetch?.();
-  const beforeMiddlewares = [];
-  const afterMiddlewares = [];
-  const onErrorMiddlewares = [];
-  const middyHandler = (event = {}, context = {}) => {
-    plugin.requestStart?.();
-    const request = {
-      event,
-      context,
-      response: void 0,
-      error: void 0,
-      internal: plugin.internal ?? {}
-    };
-    return runRequest(request, [
-      ...beforeMiddlewares
-    ], lambdaHandler, [
-      ...afterMiddlewares
-    ], [
-      ...onErrorMiddlewares
-    ], plugin);
-  };
-  const middy2 = plugin.streamifyResponse ? awslambda.streamifyResponse(async (event, responseStream, context) => {
-    const handlerResponse = await middyHandler(event, context);
-    let handlerBody = handlerResponse;
-    if (handlerResponse.statusCode) {
-      handlerBody = handlerResponse.body ?? "";
-      responseStream = awslambda.HttpResponseStream.from(responseStream, handlerResponse);
-    }
-    let handlerStream;
-    if (handlerBody._readableState) {
-      handlerStream = handlerBody;
-    } else if (typeof handlerBody === "string") {
-      function* iterator(input) {
-        const size = 16384;
-        let position = 0;
-        const length = input.length;
-        while (position < length) {
-          yield input.substring(position, position + size);
-          position += size;
-        }
-      }
-      handlerStream = Readable.from(iterator(handlerBody));
-    }
-    if (!handlerStream) {
-      throw new Error("handler response not a ReadableStream");
-    }
-    await pipeline(handlerStream, responseStream);
-  }) : middyHandler;
-  middy2.use = (middlewares) => {
-    if (!Array.isArray(middlewares)) {
-      middlewares = [
-        middlewares
-      ];
-    }
-    for (const middleware of middlewares) {
-      const { before, after, onError } = middleware;
-      if (!before && !after && !onError) {
-        throw new Error('Middleware must be an object containing at least one key among "before", "after", "onError"');
-      }
-      if (before)
-        middy2.before(before);
-      if (after)
-        middy2.after(after);
-      if (onError)
-        middy2.onError(onError);
-    }
-    return middy2;
-  };
-  middy2.before = (beforeMiddleware) => {
-    beforeMiddlewares.push(beforeMiddleware);
-    return middy2;
-  };
-  middy2.after = (afterMiddleware) => {
-    afterMiddlewares.unshift(afterMiddleware);
-    return middy2;
-  };
-  middy2.onError = (onErrorMiddleware) => {
-    onErrorMiddlewares.unshift(onErrorMiddleware);
-    return middy2;
-  };
-  middy2.handler = (replaceLambdaHandler) => {
-    lambdaHandler = replaceLambdaHandler;
-    return middy2;
-  };
-  return middy2;
-};
-var runRequest = async (request, beforeMiddlewares, lambdaHandler, afterMiddlewares, onErrorMiddlewares, plugin) => {
-  let timeoutAbort;
-  const timeoutEarly = plugin.timeoutEarly && request.context.getRemainingTimeInMillis;
-  try {
-    await runMiddlewares(request, beforeMiddlewares, plugin);
-    if (typeof request.response === "undefined") {
-      plugin.beforeHandler?.();
-      const handlerAbort = new AbortController();
-      if (timeoutEarly)
-        timeoutAbort = new AbortController();
-      request.response = await Promise.race([
-        lambdaHandler(request.event, request.context, {
-          signal: handlerAbort.signal
-        }),
-        timeoutEarly ? setTimeout2(request.context.getRemainingTimeInMillis() - plugin.timeoutEarlyInMillis, void 0, {
-          signal: timeoutAbort.signal
-        }).then(() => {
-          handlerAbort.abort();
-          return plugin.timeoutEarlyResponse();
-        }) : Promise.race([])
-      ]);
-      timeoutAbort?.abort();
-      plugin.afterHandler?.();
-      await runMiddlewares(request, afterMiddlewares, plugin);
-    }
-  } catch (e) {
-    timeoutAbort?.abort();
-    request.response = void 0;
-    request.error = e;
-    try {
-      await runMiddlewares(request, onErrorMiddlewares, plugin);
-    } catch (e2) {
-      e2.originalError = request.error;
-      request.error = e2;
-      throw request.error;
-    }
-    if (typeof request.response === "undefined")
-      throw request.error;
-  } finally {
-    await plugin.requestEnd?.(request);
-  }
-  return request.response;
-};
-var runMiddlewares = async (request, middlewares, plugin) => {
-  for (const nextMiddleware of middlewares) {
-    plugin.beforeMiddleware?.(nextMiddleware.name);
-    const res = await nextMiddleware(request);
-    plugin.afterMiddleware?.(nextMiddleware.name);
-    if (typeof res !== "undefined") {
-      request.response = res;
-      return;
-    }
-  }
-};
-var core_default = middy;
-
-// node_modules/@middy/util/index.js
-var jsonSafeParse = (text, reviver) => {
-  if (typeof text !== "string")
-    return text;
-  const firstChar = text[0];
-  if (firstChar !== "{" && firstChar !== "[" && firstChar !== '"')
-    return text;
-  try {
-    return JSON.parse(text, reviver);
-  } catch (_e) {
-  }
-  return text;
-};
-var normalizeHttpResponse = (request) => {
-  let { response } = request;
-  if (typeof response === "undefined") {
-    response = {};
-  } else if (typeof response?.statusCode === "undefined" && typeof response?.body === "undefined" && typeof response?.headers === "undefined") {
-    response = { statusCode: 200, body: response };
-  }
-  response.statusCode ??= 500;
-  response.headers ??= {};
-  request.response = response;
-  return response;
-};
-
-// node_modules/@middy/http-error-handler/index.js
-var defaults = {
-  logger: console.error,
-  // TODO v7 change to pass in request
-  fallbackMessage: void 0
-};
-var httpErrorHandlerMiddleware = (opts = {}) => {
-  const options = { ...defaults, ...opts };
-  const httpErrorHandlerMiddlewareOnError = async (request) => {
-    if (request.response !== void 0)
-      return;
-    if (typeof options.logger === "function") {
-      options.logger(request.error);
-    }
-    if (request.error.statusCode && request.error.expose === void 0) {
-      request.error.expose = request.error.statusCode < 500;
-    }
-    if (!request.error.expose || !request.error.statusCode) {
-      request.error = {
-        statusCode: 500,
-        message: options.fallbackMessage,
-        expose: true
-      };
-    }
-    if (request.error.expose) {
-      normalizeHttpResponse(request);
-      const { statusCode, message, headers } = request.error;
-      request.response = {
-        ...request.response,
-        statusCode,
-        headers: {
-          ...request.response.headers,
-          ...headers
-        }
-      };
-      if (message) {
-        const headerContentType = typeof jsonSafeParse(message) === "string" ? "text/plain" : "application/json";
-        request.response.body = message;
-        request.response.headers["Content-Type"] = headerContentType;
-      }
-    }
-  };
-  return {
-    onError: httpErrorHandlerMiddlewareOnError
-  };
-};
-var http_error_handler_default = httpErrorHandlerMiddleware;
-
-// src/lambda/index.ts
-import { randomUUID } from "node:crypto";
-import { MetricUnit as MetricUnit2 } from "@aws-lambda-powertools/metrics";
-var logger = new Logger2();
-var tracer = new Tracer();
-var metrics = new Metrics({ namespace: "aspan-corporation" });
-var withMiddlewares = (handler) => core_default(handler).use(injectLambdaContext(logger)).use(captureLambdaHandler(tracer)).use(logMetrics(metrics, { captureColdStartMetric: true })).use({
-  before: async (request) => {
-    if (!logger.getCorrelationId()) {
-      logger.setCorrelationId(request.context.awsRequestId || randomUUID());
-    }
-    logger.logEventIfEnabled(request.event);
-    request.context.logger = logger;
-    request.context.tracer = tracer;
-    request.context.metrics = metrics;
-  }
-}).use({
-  onError: async ({ error, context: { logger: logger2, metrics: metrics2 } }) => {
-    logger2.error("Error handled by middleware", {
-      error
-    });
-    metrics2.addMetric("ErrorHandled", MetricUnit.Count, 1);
-  }
-}).use(http_error_handler_default());
-var getPersistenceStore = (tableName) => {
-  return new DynamoDBPersistenceLayer({
-    tableName
-  });
-};
-var getIdempotencyConfig = (eventKeyJmesPath) => {
-  return new IdempotencyConfig({
-    eventKeyJmesPath
-  });
-};
-var getIdempotencyOptions = (tableName, path) => ({
-  persistenceStore: getPersistenceStore(tableName),
-  config: getIdempotencyConfig(path)
-});
-var getPartialResponseHandler = (handler) => {
-  const processor = new BatchProcessor(EventType.SQS);
-  return async (event, context) => processPartialResponse(event, handler, processor, {
-    context
-  });
-};
-export {
-  ALLOWED_EXTENSIONS,
-  ALLOWED_VIDEO_EXTENSIONS,
-  CloudWatchService,
-  DynamoDBService,
-  ENCODED_VIDEO_EXTENSION,
-  HEIC_EXTENSION,
-  JPEG_EXTENSION,
-  JPG_EXTENSION,
-  LocationService,
-  MOV_EXTENSION,
-  MetricUnit2 as MetricUnit,
-  S3Service,
-  SQSService,
-  SSMService,
-  STSService,
-  THUMBNAIL_RESOLUTIONS,
-  THUMBS_EXTENSION,
-  assertEnvVar,
-  getEncodedVideoKey,
-  getIdempotencyConfig,
-  getIdempotencyOptions,
-  getKeyExtension,
-  getObjectWithAssumeRoleCommandOutputAttribute,
-  getObjectWithStackAttribute,
-  getPartialResponseHandler,
-  getPersistenceStore,
-  getThumbsKey,
-  isAllowedExtension,
-  isAllowedVideoExtension,
-  logger,
-  metrics,
-  normalizeErrorMessage,
-  processMeta,
-  tracer,
-  withMiddlewares
-};
-/*! Bundled license information:
-
-@aws-lambda-powertools/batch/lib/esm/BasePartialBatchProcessor.js:
-  (* v8 ignore else -- @preserve *)
-
-@aws-lambda-powertools/batch/lib/esm/BatchProcessorSync.js:
-  (* v8 ignore next -- @preserve *)
-
-@aws-lambda-powertools/batch/lib/esm/processPartialResponseSync.js:
-  (* v8 ignore next -- @preserve *)
-*/
-//# sourceMappingURL=index.js.map
+export * from "./services/index.js";
+export * from "./lambda/index.js";
+export * from "./utils/index.js";