@celerity-sdk/serverless-aws 0.3.0 → 0.4.0

package/dist/entry.js

@@ -2,12 +2,13 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/entry.ts
-import { dirname, resolve } from "path";
-import createDebug2 from "debug";
-import { discoverModule, bootstrap, executeHandlerPipeline, createDefaultSystemLayers, disposeLayers, resolveHandlerByModuleRef } from "@celerity-sdk/core";
+import createDebug4 from "debug";
+import { CelerityFactory, discoverModule } from "@celerity-sdk/core";
 
 // src/event-mapper.ts
 import createDebug from "debug";
+import { unmarshall } from "@aws-sdk/util-dynamodb";
+import { mapBucketEventType, mapDatastoreEventType } from "@celerity-sdk/common";
 var debug = createDebug("celerity:serverless-aws");
 function parseBody(event) {
   if (!event.body) return {
@@ -105,74 +106,497 @@ function mapHttpResponseToResult(response) {
   return result;
 }
 __name(mapHttpResponseToResult, "mapHttpResponseToResult");
+var VALID_HANDLER_TYPES = /* @__PURE__ */ new Set([
+  "http",
+  "websocket",
+  "consumer",
+  "schedule",
+  "custom"
+]);
+function hasNested(obj, key, nested) {
+  const child = obj[key];
+  return child !== null && typeof child === "object" && nested in child;
+}
+__name(hasNested, "hasNested");
+function detectEventType(event) {
+  const envType = process.env.CELERITY_HANDLER_TYPE;
+  if (envType && VALID_HANDLER_TYPES.has(envType)) {
+    debug("detectEventType: using env var CELERITY_HANDLER_TYPE=%s", envType);
+    return envType;
+  }
+  if (!event || typeof event !== "object") return "custom";
+  const e = event;
+  if (hasNested(e, "requestContext", "http")) return "http";
+  if (hasNested(e, "requestContext", "connectionId") && hasNested(e, "requestContext", "eventType")) return "websocket";
+  if (Array.isArray(e.Records) && e.Records.length > 0 && e.Records[0]?.eventSource === "aws:sqs") return "consumer";
+  if ("source" in e && "detail-type" in e) return "schedule";
+  return "custom";
+}
+__name(detectEventType, "detectEventType");
+var WS_EVENT_TYPE_MAP = {
+  CONNECT: "connect",
+  MESSAGE: "message",
+  DISCONNECT: "disconnect"
+};
+function mapApiGatewayWebSocketEvent(event) {
+  const rc = event.requestContext;
+  const eventType = WS_EVENT_TYPE_MAP[rc.eventType] ?? "message";
+  let jsonBody;
+  let binaryBody;
+  if (event.body) {
+    if (event.isBase64Encoded) {
+      binaryBody = Buffer.from(event.body, "base64");
+    } else {
+      try {
+        jsonBody = JSON.parse(event.body);
+      } catch {
+        jsonBody = event.body;
+      }
+    }
+  }
+  const message = {
+    messageType: binaryBody ? "binary" : "json",
+    eventType,
+    connectionId: rc.connectionId,
+    messageId: rc.requestId,
+    jsonBody,
+    binaryBody,
+    requestContext: {
+      requestId: rc.requestId,
+      requestTime: rc.requestTimeEpoch,
+      path: `/${rc.stage}`,
+      protocolVersion: "websocket",
+      headers: {},
+      clientIp: "",
+      query: {},
+      cookies: {}
+    },
+    traceContext: null
+  };
+  const routeKey = rc.routeKey;
+  const endpoint = `https://${rc.domainName}/${rc.stage}`;
+  debug("mapWebSocketEvent: %s connectionId=%s routeKey=%s", eventType, rc.connectionId, routeKey);
+  return {
+    message,
+    routeKey,
+    endpoint
+  };
+}
+__name(mapApiGatewayWebSocketEvent, "mapApiGatewayWebSocketEvent");
+function tryParseJson(body) {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+}
+__name(tryParseJson, "tryParseJson");
+function isS3Notification(parsed) {
+  if (!parsed || typeof parsed !== "object") return false;
+  const obj = parsed;
+  if (!Array.isArray(obj.Records) || obj.Records.length === 0) return false;
+  const first = obj.Records[0];
+  return first.eventSource === "aws:s3";
+}
+__name(isS3Notification, "isS3Notification");
+function isDynamoDBStreamRecord(parsed) {
+  if (!parsed || typeof parsed !== "object") return false;
+  return parsed.eventSource === "aws:dynamodb";
+}
+__name(isDynamoDBStreamRecord, "isDynamoDBStreamRecord");
+function extractTableName(eventSourceARN) {
+  if (!eventSourceARN) return void 0;
+  const match = eventSourceARN.match(/table\/([^/]+)/);
+  return match?.[1];
+}
+__name(extractTableName, "extractTableName");
+function transformS3Body(record) {
+  return JSON.stringify({
+    key: record.s3.object.key,
+    ...record.s3.object.size !== void 0 && {
+      size: record.s3.object.size
+    },
+    ...record.s3.object.eTag !== void 0 && {
+      eTag: record.s3.object.eTag
+    }
+  });
+}
+__name(transformS3Body, "transformS3Body");
+function unmarshallRecord(attrs) {
+  if (!attrs) return void 0;
+  return unmarshall(attrs);
+}
+__name(unmarshallRecord, "unmarshallRecord");
+function transformDynamoDBBody(record) {
+  const db = record.dynamodb;
+  return JSON.stringify({
+    keys: unmarshallRecord(db?.Keys) ?? {},
+    ...db?.NewImage !== void 0 && {
+      newItem: unmarshallRecord(db.NewImage)
+    },
+    ...db?.OldImage !== void 0 && {
+      oldItem: unmarshallRecord(db.OldImage)
+    }
+  });
+}
+__name(transformDynamoDBBody, "transformDynamoDBBody");
+function mapSqsRecord(record) {
+  const sqsVendor = {
+    receiptHandle: record.receiptHandle,
+    attributes: record.attributes,
+    md5OfBody: record.md5OfBody,
+    eventSource: record.eventSource,
+    awsRegion: record.awsRegion
+  };
+  const parsed = tryParseJson(record.body);
+  if (isS3Notification(parsed)) {
+    const s3Record = parsed.Records[0];
+    return {
+      messageId: record.messageId,
+      body: transformS3Body(s3Record),
+      source: record.eventSourceARN,
+      sourceType: "bucket",
+      sourceName: s3Record.s3.bucket.name,
+      eventType: mapBucketEventType(s3Record.eventName),
+      messageAttributes: record.messageAttributes,
+      vendor: {
+        ...sqsVendor,
+        originalBody: parsed
+      }
+    };
+  }
+  if (isDynamoDBStreamRecord(parsed)) {
+    return {
+      messageId: record.messageId,
+      body: transformDynamoDBBody(parsed),
+      source: record.eventSourceARN,
+      sourceType: "datastore",
+      sourceName: extractTableName(parsed.eventSourceARN),
+      eventType: mapDatastoreEventType(parsed.eventName),
+      messageAttributes: record.messageAttributes,
+      vendor: {
+        ...sqsVendor,
+        originalBody: parsed
+      }
+    };
+  }
+  return {
+    messageId: record.messageId,
+    body: record.body,
+    source: record.eventSourceARN,
+    messageAttributes: record.messageAttributes,
+    vendor: sqsVendor
+  };
+}
+__name(mapSqsRecord, "mapSqsRecord");
+function mapSqsEvent(event, handlerTag) {
+  const messages = event.Records.map(mapSqsRecord);
+  const firstTraceHeader = event.Records[0]?.attributes?.AWSTraceHeader;
+  const traceContext = firstTraceHeader ? {
+    "x-amzn-trace-id": firstTraceHeader
+  } : null;
+  debug("mapSqsEvent: %d records, handlerTag=%s", messages.length, handlerTag);
+  return {
+    handlerTag,
+    messages,
+    vendor: {
+      eventSource: "aws:sqs"
+    },
+    traceContext
+  };
+}
+__name(mapSqsEvent, "mapSqsEvent");
+function mapConsumerResultToSqsBatchResponse(failures) {
+  const batchItemFailures = (failures ?? []).map((f) => ({
+    itemIdentifier: f.messageId
+  }));
+  return {
+    batchItemFailures
+  };
+}
+__name(mapConsumerResultToSqsBatchResponse, "mapConsumerResultToSqsBatchResponse");
+function mapEventBridgeEvent(event, handlerTag) {
+  debug("mapEventBridgeEvent: id=%s handlerTag=%s", event.id, handlerTag);
+  return {
+    handlerTag,
+    scheduleId: event.id,
+    messageId: event.id,
+    schedule: "",
+    input: event.detail,
+    vendor: {
+      source: event.source,
+      detailType: event["detail-type"],
+      account: event.account,
+      region: event.region
+    },
+    traceContext: null
+  };
+}
+__name(mapEventBridgeEvent, "mapEventBridgeEvent");
 
-// src/entry.ts
+// src/adapter.ts
+import { dirname, resolve } from "path";
+import createDebug3 from "debug";
+import { executeHttpPipeline, executeWebSocketPipeline, executeConsumerPipeline, executeSchedulePipeline, executeCustomPipeline, resolveHandlerByModuleRef } from "@celerity-sdk/core";
+import { WebSocketSender as WS_SENDER_TOKEN } from "@celerity-sdk/types";
+
+// src/websocket-sender.ts
+import createDebug2 from "debug";
 var debug2 = createDebug2("celerity:serverless-aws");
-var cached = null;
+var API_GW_MGMT_PKG = "@aws-sdk/client-apigatewaymanagementapi";
+var ApiGatewayWebSocketSender = class {
+  static {
+    __name(this, "ApiGatewayWebSocketSender");
+  }
+  endpoint;
+  client = null;
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+    debug2("ApiGatewayWebSocketSender: created with endpoint=%s", endpoint);
+  }
+  async sendMessage(connectionId, data, _options) {
+    const client = await this.getClient();
+    const payload = typeof data === "string" ? data : JSON.stringify(data);
+    const { PostToConnectionCommand } = await import(API_GW_MGMT_PKG);
+    await client.send(new PostToConnectionCommand({
+      ConnectionId: connectionId,
+      Data: new TextEncoder().encode(payload)
+    }));
+    debug2("ApiGatewayWebSocketSender: sent message to connectionId=%s", connectionId);
+  }
+  async getClient() {
+    if (!this.client) {
+      const { ApiGatewayManagementApiClient } = await import(API_GW_MGMT_PKG);
+      this.client = new ApiGatewayManagementApiClient({
+        endpoint: this.endpoint
+      });
+      debug2("ApiGatewayWebSocketSender: client initialized for endpoint=%s", this.endpoint);
+    }
+    return this.client;
+  }
+};
+
+// src/adapter.ts
+var debug3 = createDebug3("celerity:serverless-aws");
+var AwsLambdaAdapter = class {
+  static {
+    __name(this, "AwsLambdaAdapter");
+  }
+  config;
+  wsSenderRegistered = false;
+  constructor() {
+    this.config = captureAwsLambdaConfig();
+  }
+  createHttpHandler(registry, options) {
+    let cachedHandler2 = null;
+    return async (event, _context) => {
+      const apiEvent = event;
+      const httpRequest = mapApiGatewayV2Event(apiEvent);
+      if (!cachedHandler2) {
+        debug3("adapter: cache miss, looking up handler for %s %s", httpRequest.method, httpRequest.path);
+        cachedHandler2 = (this.config.handlerId ? registry.getHandlerById("http", this.config.handlerId) : void 0) ?? null;
+        if (!cachedHandler2 && this.config.handlerId) {
+          cachedHandler2 = await resolveHandlerByModuleRef(this.config.handlerId, "http", registry, this.config.moduleDir);
+        }
+        if (!cachedHandler2) {
+          cachedHandler2 = registry.getHandler("http", `${httpRequest.method} ${httpRequest.path}`) ?? null;
+        }
+      } else {
+        debug3("adapter: using cached handler for %s %s", httpRequest.method, httpRequest.path);
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: no handler found \u2192 404");
+        return {
+          statusCode: 404,
+          headers: {
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            message: `No handler for ${httpRequest.method} ${httpRequest.path}`
+          })
+        };
+      }
+      const httpResponse = await executeHttpPipeline(cachedHandler2, httpRequest, options);
+      return mapHttpResponseToResult(httpResponse);
+    };
+  }
+  createWebSocketHandler(registry, options) {
+    let cachedHandler2 = null;
+    return async (event, _context) => {
+      const wsEvent = event;
+      const { message, routeKey, endpoint } = mapApiGatewayWebSocketEvent(wsEvent);
+      if (!this.wsSenderRegistered) {
+        const sender = new ApiGatewayWebSocketSender(endpoint);
+        options.container.register(WS_SENDER_TOKEN, {
+          useValue: sender
+        });
+        this.wsSenderRegistered = true;
+        debug3("adapter: registered ApiGatewayWebSocketSender for endpoint=%s", endpoint);
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: cache miss, looking up WebSocket handler for routeKey=%s", routeKey);
+        cachedHandler2 = (this.config.handlerId ? registry.getHandlerById("websocket", this.config.handlerId) : void 0) ?? null;
+        if (!cachedHandler2 && this.config.handlerId) {
+          cachedHandler2 = await resolveHandlerByModuleRef(this.config.handlerId, "websocket", registry, this.config.moduleDir);
+        }
+        if (!cachedHandler2) {
+          cachedHandler2 = registry.getHandler("websocket", routeKey) ?? null;
+        }
+      } else {
+        debug3("adapter: using cached WebSocket handler");
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: no WebSocket handler found \u2192 404");
+        return {
+          statusCode: 404
+        };
+      }
+      await executeWebSocketPipeline(cachedHandler2, message, options);
+      return {
+        statusCode: 200
+      };
+    };
+  }
+  createConsumerHandler(registry, options) {
+    let cachedHandler2 = null;
+    return async (event, _context) => {
+      const sqsEvent = event;
+      const handlerTag = this.config.handlerTag ?? sqsEvent.Records[0]?.eventSourceARN ?? "unknown";
+      const consumerEvent = mapSqsEvent(sqsEvent, handlerTag);
+      if (!cachedHandler2) {
+        debug3("adapter: cache miss, looking up Consumer handler for tag=%s", handlerTag);
+        cachedHandler2 = (this.config.handlerId ? registry.getHandlerById("consumer", this.config.handlerId) : void 0) ?? null;
+        if (!cachedHandler2 && this.config.handlerId) {
+          cachedHandler2 = await resolveHandlerByModuleRef(this.config.handlerId, "consumer", registry, this.config.moduleDir);
+        }
+        if (!cachedHandler2) {
+          cachedHandler2 = registry.getHandler("consumer", handlerTag) ?? null;
+        }
+      } else {
+        debug3("adapter: using cached Consumer handler");
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: no Consumer handler found \u2192 empty response");
+        return {
+          batchItemFailures: []
+        };
+      }
+      const result = await executeConsumerPipeline(cachedHandler2, consumerEvent, options);
+      return mapConsumerResultToSqsBatchResponse(result.failures);
+    };
+  }
+  createScheduleHandler(registry, options) {
+    let cachedHandler2 = null;
+    return async (event, _context) => {
+      const ebEvent = event;
+      const handlerTag = this.config.handlerTag ?? ebEvent.resources?.[0] ?? "unknown";
+      const scheduleEvent = mapEventBridgeEvent(ebEvent, handlerTag);
+      if (!cachedHandler2) {
+        debug3("adapter: cache miss, looking up Schedule handler for tag=%s", handlerTag);
+        cachedHandler2 = (this.config.handlerId ? registry.getHandlerById("schedule", this.config.handlerId) : void 0) ?? null;
+        if (!cachedHandler2 && this.config.handlerId) {
+          cachedHandler2 = await resolveHandlerByModuleRef(this.config.handlerId, "schedule", registry, this.config.moduleDir);
+        }
+        if (!cachedHandler2) {
+          cachedHandler2 = registry.getHandler("schedule", handlerTag) ?? null;
+        }
+      } else {
+        debug3("adapter: using cached Schedule handler");
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: no Schedule handler found");
+        return {
+          success: false,
+          errorMessage: `No handler for schedule tag: ${handlerTag}`
+        };
+      }
+      return executeSchedulePipeline(cachedHandler2, scheduleEvent, options);
+    };
+  }
+  createCustomHandler(registry, options) {
+    let cachedHandler2 = null;
+    return async (event, _context) => {
+      let handlerName = this.config.handlerId;
+      let payload = event;
+      if (!handlerName && event && typeof event === "object") {
+        const e = event;
+        if (typeof e.handlerName === "string") {
+          handlerName = e.handlerName;
+          payload = e.payload ?? {};
+        }
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: cache miss, looking up Custom handler for name=%s", handlerName);
+        cachedHandler2 = (handlerName ? registry.getHandlerById("custom", handlerName) : void 0) ?? null;
+        if (!cachedHandler2 && handlerName) {
+          cachedHandler2 = await resolveHandlerByModuleRef(handlerName, "custom", registry, this.config.moduleDir);
+        }
+        if (!cachedHandler2 && handlerName) {
+          cachedHandler2 = registry.getHandler("custom", handlerName) ?? null;
+        }
+        if (!cachedHandler2) {
+          const allCustom = registry.getHandlersByType("custom");
+          if (allCustom.length === 1) cachedHandler2 = allCustom[0];
+        }
+      } else {
+        debug3("adapter: using cached Custom handler");
+      }
+      if (!cachedHandler2) {
+        debug3("adapter: no Custom handler found");
+        return {
+          error: `No handler found for custom invoke: ${handlerName ?? "unknown"}`
+        };
+      }
+      return executeCustomPipeline(cachedHandler2, payload, options);
+    };
+  }
+};
+function captureAwsLambdaConfig() {
+  const modulePath = process.env.CELERITY_MODULE_PATH;
+  return {
+    handlerId: process.env.CELERITY_HANDLER_ID,
+    handlerTag: process.env.CELERITY_HANDLER_TAG,
+    moduleDir: modulePath ? dirname(resolve(modulePath)) : process.cwd()
+  };
+}
+__name(captureAwsLambdaConfig, "captureAwsLambdaConfig");
+
+// src/entry.ts
+var debug4 = createDebug4("celerity:serverless-aws");
+var app = null;
+var cachedHandler = null;
 var shutdownRegistered = false;
-function registerShutdownHandler(options) {
+async function ensureBootstrapped() {
+  if (!app) {
+    debug4("entry: cold start, bootstrapping via CelerityFactory");
+    const rootModule = await discoverModule();
+    app = await CelerityFactory.create(rootModule, {
+      adapter: new AwsLambdaAdapter()
+    });
+    debug4("entry: bootstrap complete");
+  }
+  return app;
+}
+__name(ensureBootstrapped, "ensureBootstrapped");
+function registerShutdownHandler(application) {
   if (shutdownRegistered) return;
   shutdownRegistered = true;
-  debug2("entry: SIGTERM shutdown handler registered");
+  debug4("entry: SIGTERM shutdown handler registered");
   process.on("SIGTERM", async () => {
-    await options.container.closeAll();
-    await disposeLayers([
-      ...options.systemLayers ?? [],
-      ...options.appLayers ?? []
-    ]);
+    await application.close();
     process.exit(0);
   });
 }
 __name(registerShutdownHandler, "registerShutdownHandler");
-async function ensureBootstrapped() {
-  if (!cached) {
-    debug2("entry: cold start, bootstrapping");
-    const systemLayers = await createDefaultSystemLayers();
-    debug2("entry: %d system layers created", systemLayers.length);
-    const rootModule = await discoverModule();
-    const result = await bootstrap(rootModule);
-    const modulePath = process.env.CELERITY_MODULE_PATH;
-    cached = {
-      registry: result.registry,
-      options: {
-        container: result.container,
-        systemLayers
-      },
-      moduleDir: modulePath ? dirname(resolve(modulePath)) : process.cwd()
-    };
-    debug2("entry: bootstrap complete");
-  }
-  return cached;
-}
-__name(ensureBootstrapped, "ensureBootstrapped");
-async function handler(event, _context) {
-  const { registry, options, moduleDir } = await ensureBootstrapped();
-  registerShutdownHandler(options);
-  const apiEvent = event;
-  const httpRequest = mapApiGatewayV2Event(apiEvent);
-  debug2("entry: %s %s", httpRequest.method, httpRequest.path);
-  const handlerId = process.env.CELERITY_HANDLER_ID;
-  let resolved = handlerId ? registry.getHandlerById(handlerId) : void 0;
-  if (!resolved && handlerId) {
-    resolved = await resolveHandlerByModuleRef(handlerId, registry, moduleDir) ?? void 0;
-  }
-  if (!resolved) {
-    resolved = registry.getHandler(httpRequest.path, httpRequest.method);
-  }
-  if (!resolved) {
-    return {
-      statusCode: 404,
-      headers: {
-        "content-type": "application/json"
-      },
-      body: JSON.stringify({
-        statusCode: 404,
-        message: `No handler for ${httpRequest.method} ${httpRequest.path}`
-      })
-    };
+async function handler(event, context) {
+  const application = await ensureBootstrapped();
+  registerShutdownHandler(application);
+  if (!cachedHandler) {
+    const eventType = detectEventType(event);
+    debug4("entry: creating handler for type=%s", eventType);
+    cachedHandler = application.createHandler(eventType);
   }
-  const httpResponse = await executeHandlerPipeline(resolved, httpRequest, options);
-  return mapHttpResponseToResult(httpResponse);
+  return cachedHandler(event, context);
 }
 __name(handler, "handler");
 export {