cdk-local-lambda 0.0.2

package/lib/cli/runtime-wrapper/nodejs-runtime.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Node.js runtime wrapper that emulates the Lambda Runtime environment.
+ *
+ * This script does what the Lambda runtime does inside a container:
+ * 1. Polls our local Runtime API for invocations (GET /invocation/next)
+ * 2. Loads and invokes the user's handler via import()
+ * 3. Posts responses back (POST /invocation/{requestId}/response)
+ *
+ * Environment variables:
+ * - AWS_LAMBDA_RUNTIME_API: The host:port of our local Runtime API server
+ * - _HANDLER: The handler path in format "path/to/file.handlerName"
+ * - LAMBDA_TASK_ROOT: The project root directory for resolving handler modules
+ *
+ * This script is spawned by the daemon for each Node.js Lambda function.
+ */
+export {};

package/lib/cli/runtime-wrapper/nodejs-runtime.js

@@ -0,0 +1,248 @@
+/**
+ * Node.js runtime wrapper that emulates the Lambda Runtime environment.
+ *
+ * This script does what the Lambda runtime does inside a container:
+ * 1. Polls our local Runtime API for invocations (GET /invocation/next)
+ * 2. Loads and invokes the user's handler via import()
+ * 3. Posts responses back (POST /invocation/{requestId}/response)
+ *
+ * Environment variables:
+ * - AWS_LAMBDA_RUNTIME_API: The host:port of our local Runtime API server
+ * - _HANDLER: The handler path in format "path/to/file.handlerName"
+ * - LAMBDA_TASK_ROOT: The project root directory for resolving handler modules
+ *
+ * This script is spawned by the daemon for each Node.js Lambda function.
+ */
+import * as path from "node:path";
+// Runtime API base URL from environment
+const RUNTIME_API = process.env.AWS_LAMBDA_RUNTIME_API;
+if (!RUNTIME_API) {
+    console.error("AWS_LAMBDA_RUNTIME_API not set");
+    process.exit(1);
+}
+// Handler path from environment (e.g., "functions/greeter/handler.handler")
+const HANDLER = process.env._HANDLER;
+if (!HANDLER) {
+    console.error("_HANDLER not set");
+    process.exit(1);
+}
+// Project root for resolving handler modules
+const PROJECT_ROOT = process.env.LAMBDA_TASK_ROOT ?? process.cwd();
+const RUNTIME_API_BASE = `http://${RUNTIME_API}`;
+// Current request ID for logging context (set during invocation)
+let currentRequestId = null;
+/**
+ * Log an error in Lambda log format so it gets the proper invocation prefix.
+ * Format: TIMESTAMP\tREQUEST_ID\tLEVEL\tMESSAGE
+ */
+function lambdaError(level, message) {
+    const timestamp = new Date().toISOString();
+    const requestId = currentRequestId ?? "00000000-0000-0000-0000-000000000000";
+    console.error(`${timestamp}\t${requestId}\t${level}\t${message}`);
+}
+/**
+ * Parse handler path into module path and export name.
+ * Handler format: "path/to/module.exportName"
+ * Example: "functions/greeter/handler.handler" -> { modulePath: "functions/greeter/handler", exportName: "handler" }
+ */
+function parseHandler(handlerPath) {
+    const lastDot = handlerPath.lastIndexOf(".");
+    if (lastDot === -1) {
+        throw new Error(`Invalid handler format: "${handlerPath}". Expected "path/to/module.exportName"`);
+    }
+    return {
+        modulePath: handlerPath.substring(0, lastDot),
+        exportName: handlerPath.substring(lastDot + 1),
+    };
+}
+/**
+ * Resolve and load the handler function.
+ * Tries common extensions: .ts, .js, .mjs, .cjs (Bun handles all natively)
+ */
+async function loadHandler(handlerPath, projectRoot) {
+    const { modulePath, exportName } = parseHandler(handlerPath);
+    // Extensions to try (Bun supports all natively)
+    const extensions = [".ts", ".js", ".mjs", ".cjs", ""];
+    let loadedModule;
+    let resolvedPath;
+    for (const ext of extensions) {
+        const fullPath = path.resolve(projectRoot, modulePath + ext);
+        try {
+            loadedModule = (await import(fullPath));
+            resolvedPath = fullPath;
+            break;
+        }
+        catch {
+            // Try next extension
+        }
+    }
+    if (!loadedModule || !resolvedPath) {
+        throw new Error(`Could not load handler module: "${modulePath}" (tried extensions: ${extensions.join(", ")})`);
+    }
+    const handler = loadedModule[exportName];
+    if (typeof handler !== "function") {
+        throw new Error(`Handler "${exportName}" is not a function (got ${typeof handler})`);
+    }
+    return handler;
+}
+/**
+ * Get next invocation from Runtime API.
+ * This blocks until an invocation is available.
+ *
+ * Returns null if the server returned 503 (poll timeout), signaling we should retry.
+ * This is expected behavior - the server times out idle connections to work within
+ * HTTP server limitations, but native workers can just reconnect and keep polling.
+ */
+async function getNextInvocation() {
+    const response = await fetch(`${RUNTIME_API_BASE}/2018-06-01/runtime/invocation/next`);
+    // 503 means the server's poll timeout expired - this is expected behavior
+    // for idle connections. Native workers should just retry polling.
+    if (response.status === 503) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to get next invocation: ${response.status}`);
+    }
+    const event = await response.json();
+    const requestId = response.headers.get("Lambda-Runtime-Aws-Request-Id") ?? "";
+    const deadlineMs = response.headers.get("Lambda-Runtime-Deadline-Ms") ?? "0";
+    const invokedFunctionArn = response.headers.get("Lambda-Runtime-Invoked-Function-Arn") ?? "";
+    const logGroupName = response.headers.get("Lambda-Runtime-Log-Group-Name") ?? "";
+    const logStreamName = response.headers.get("Lambda-Runtime-Log-Stream-Name") ?? "";
+    // Extract function name and version from ARN
+    // ARN format: arn:aws:lambda:region:account:function:name:version
+    const arnParts = invokedFunctionArn.split(":");
+    const functionName = arnParts[6] ?? "";
+    const functionVersion = arnParts[7] ?? "$LATEST";
+    // Build Lambda context object
+    const context = {
+        functionName,
+        functionVersion,
+        invokedFunctionArn,
+        memoryLimitInMB: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE ?? "128",
+        awsRequestId: requestId,
+        logGroupName,
+        logStreamName,
+        getRemainingTimeInMillis: () => Math.max(0, Number(deadlineMs) - Date.now()),
+        // These are not used in local execution but required by the type
+        callbackWaitsForEmptyEventLoop: true,
+        identity: undefined,
+        clientContext: undefined,
+        done: () => { },
+        fail: () => { },
+        succeed: () => { },
+    };
+    return { event, context, requestId };
+}
+/**
+ * Post successful response to Runtime API.
+ */
+async function postResponse(requestId, result) {
+    const response = await fetch(`${RUNTIME_API_BASE}/2018-06-01/runtime/invocation/${requestId}/response`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(result),
+    });
+    if (!response.ok) {
+        lambdaError("ERROR", `Failed to post response: ${response.status}`);
+    }
+}
+/**
+ * Post error to Runtime API.
+ */
+async function postError(requestId, error) {
+    const errorPayload = {
+        errorType: error.name ?? "Error",
+        errorMessage: error.message ?? String(error),
+        stackTrace: error.stack?.split("\n") ?? [],
+    };
+    const response = await fetch(`${RUNTIME_API_BASE}/2018-06-01/runtime/invocation/${requestId}/error`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Lambda-Runtime-Function-Error-Type": errorPayload.errorType,
+        },
+        body: JSON.stringify(errorPayload),
+    });
+    if (!response.ok) {
+        lambdaError("ERROR", `Failed to post error: ${response.status}`);
+    }
+}
+/**
+ * Post init error to Runtime API.
+ */
+async function postInitError(error) {
+    const errorPayload = {
+        errorType: error.name ?? "InitError",
+        errorMessage: error.message ?? String(error),
+        stackTrace: error.stack?.split("\n") ?? [],
+    };
+    try {
+        await fetch(`${RUNTIME_API_BASE}/2018-06-01/runtime/init/error`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Lambda-Runtime-Function-Error-Type": errorPayload.errorType,
+            },
+            body: JSON.stringify(errorPayload),
+        });
+    }
+    catch {
+        // Ignore - we're already in an error state
+    }
+}
+/**
+ * Main runtime loop.
+ */
+async function main() {
+    // Load handler once at startup
+    // Note: bun --watch automatically tracks dynamic imports and restarts when they change
+    let handler;
+    try {
+        handler = await loadHandler(HANDLER, PROJECT_ROOT);
+    }
+    catch (error) {
+        console.error(`Failed to load handler: ${error}`);
+        await postInitError(error instanceof Error ? error : new Error(String(error)));
+        process.exit(1);
+    }
+    // Main invocation loop
+    while (true) {
+        try {
+            // Get next invocation (blocks until available)
+            const invocation = await getNextInvocation();
+            // null means 503 timeout - server wants us to reconnect and keep polling
+            if (invocation === null) {
+                // Small delay before reconnecting to avoid tight loop
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                continue;
+            }
+            const { event, context, requestId } = invocation;
+            currentRequestId = requestId;
+            try {
+                // Invoke handler
+                const result = await handler(event, context);
+                // Post response
+                await postResponse(requestId, result);
+            }
+            catch (error) {
+                lambdaError("ERROR", `Handler error: ${error}`);
+                await postError(requestId, error instanceof Error ? error : new Error(String(error)));
+            }
+            finally {
+                currentRequestId = null;
+            }
+        }
+        catch (error) {
+            // Error getting next invocation - this is fatal, exit and let daemon restart
+            console.error(`Fatal error in invocation loop: ${error}`);
+            process.exit(1);
+        }
+    }
+}
+// Run the main loop
+main().catch((error) => {
+    console.error(`Unhandled error: ${error}`);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nodejs-runtime.js","sourceRoot":"","sources":["../../../src/cli/runtime-wrapper/nodejs-runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Node.js runtime wrapper that emulates the Lambda Runtime environment.\n *\n * This script does what the Lambda runtime does inside a container:\n * 1. Polls our local Runtime API for invocations (GET /invocation/next)\n * 2. Loads and invokes the user's handler via import()\n * 3. Posts responses back (POST /invocation/{requestId}/response)\n *\n * Environment variables:\n * - AWS_LAMBDA_RUNTIME_API: The host:port of our local Runtime API server\n * - _HANDLER: The handler path in format \"path/to/file.handlerName\"\n * - LAMBDA_TASK_ROOT: The project root directory for resolving handler modules\n *\n * This script is spawned by the daemon for each Node.js Lambda function.\n */\n\nimport * as path from \"node:path\"\nimport type { Context } from \"aws-lambda\"\n\n// Runtime API base URL from environment\nconst RUNTIME_API = process.env.AWS_LAMBDA_RUNTIME_API\nif (!RUNTIME_API) {\n  console.error(\"AWS_LAMBDA_RUNTIME_API not set\")\n  process.exit(1)\n}\n\n// Handler path from environment (e.g., \"functions/greeter/handler.handler\")\nconst HANDLER = process.env._HANDLER\nif (!HANDLER) {\n  console.error(\"_HANDLER not set\")\n  process.exit(1)\n}\n\n// Project root for resolving handler modules\nconst PROJECT_ROOT = process.env.LAMBDA_TASK_ROOT ?? process.cwd()\n\nconst RUNTIME_API_BASE = `http://${RUNTIME_API}`\n\n// Current request ID for logging context (set during invocation)\nlet currentRequestId: string | null = null\n\n/**\n * Log an error in Lambda log format so it gets the proper invocation prefix.\n * Format: TIMESTAMP\\tREQUEST_ID\\tLEVEL\\tMESSAGE\n */\nfunction lambdaError(level: string, message: string): void {\n  const timestamp = new Date().toISOString()\n  const requestId = currentRequestId ?? \"00000000-0000-0000-0000-000000000000\"\n  console.error(`${timestamp}\\t${requestId}\\t${level}\\t${message}`)\n}\n\n/**\n * Parse handler path into module path and export name.\n * Handler format: \"path/to/module.exportName\"\n * Example: \"functions/greeter/handler.handler\" -> { modulePath: \"functions/greeter/handler\", exportName: \"handler\" }\n */\nfunction parseHandler(handlerPath: string): {\n  modulePath: string\n  exportName: string\n} {\n  const lastDot = handlerPath.lastIndexOf(\".\")\n  if (lastDot === -1) {\n    throw new Error(\n      `Invalid handler format: \"${handlerPath}\". Expected \"path/to/module.exportName\"`,\n    )\n  }\n  return {\n    modulePath: handlerPath.substring(0, lastDot),\n    exportName: handlerPath.substring(lastDot + 1),\n  }\n}\n\n/**\n * Resolve and load the handler function.\n * Tries common extensions: .ts, .js, .mjs, .cjs (Bun handles all natively)\n */\nasync function loadHandler(\n  handlerPath: string,\n  projectRoot: string,\n): Promise<(event: unknown, context: Context) => Promise<unknown>> {\n  const { modulePath, exportName } = parseHandler(handlerPath)\n\n  // Extensions to try (Bun supports all natively)\n  const extensions = [\".ts\", \".js\", \".mjs\", \".cjs\", \"\"]\n\n  let loadedModule: Record<string, unknown> | undefined\n  let resolvedPath: string | undefined\n\n  for (const ext of extensions) {\n    const fullPath = path.resolve(projectRoot, modulePath + ext)\n    try {\n      loadedModule = (await import(fullPath)) as Record<string, unknown>\n      resolvedPath = fullPath\n      break\n    } catch {\n      // Try next extension\n    }\n  }\n\n  if (!loadedModule || !resolvedPath) {\n    throw new Error(\n      `Could not load handler module: \"${modulePath}\" (tried extensions: ${extensions.join(\", \")})`,\n    )\n  }\n\n  const handler = loadedModule[exportName]\n  if (typeof handler !== \"function\") {\n    throw new Error(\n      `Handler \"${exportName}\" is not a function (got ${typeof handler})`,\n    )\n  }\n\n  return handler as (event: unknown, context: Context) => Promise<unknown>\n}\n\n/**\n * Get next invocation from Runtime API.\n * This blocks until an invocation is available.\n *\n * Returns null if the server returned 503 (poll timeout), signaling we should retry.\n * This is expected behavior - the server times out idle connections to work within\n * HTTP server limitations, but native workers can just reconnect and keep polling.\n */\nasync function getNextInvocation(): Promise<{\n  event: unknown\n  context: Context\n  requestId: string\n} | null> {\n  const response = await fetch(\n    `${RUNTIME_API_BASE}/2018-06-01/runtime/invocation/next`,\n  )\n\n  // 503 means the server's poll timeout expired - this is expected behavior\n  // for idle connections. Native workers should just retry polling.\n  if (response.status === 503) {\n    return null\n  }\n\n  if (!response.ok) {\n    throw new Error(`Failed to get next invocation: ${response.status}`)\n  }\n\n  const event = await response.json()\n  const requestId = response.headers.get(\"Lambda-Runtime-Aws-Request-Id\") ?? \"\"\n  const deadlineMs = response.headers.get(\"Lambda-Runtime-Deadline-Ms\") ?? \"0\"\n  const invokedFunctionArn =\n    response.headers.get(\"Lambda-Runtime-Invoked-Function-Arn\") ?? \"\"\n  const logGroupName =\n    response.headers.get(\"Lambda-Runtime-Log-Group-Name\") ?? \"\"\n  const logStreamName =\n    response.headers.get(\"Lambda-Runtime-Log-Stream-Name\") ?? \"\"\n\n  // Extract function name and version from ARN\n  // ARN format: arn:aws:lambda:region:account:function:name:version\n  const arnParts = invokedFunctionArn.split(\":\")\n  const functionName = arnParts[6] ?? \"\"\n  const functionVersion = arnParts[7] ?? \"$LATEST\"\n\n  // Build Lambda context object\n  const context: Context = {\n    functionName,\n    functionVersion,\n    invokedFunctionArn,\n    memoryLimitInMB: process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE ?? \"128\",\n    awsRequestId: requestId,\n    logGroupName,\n    logStreamName,\n    getRemainingTimeInMillis: () =>\n      Math.max(0, Number(deadlineMs) - Date.now()),\n    // These are not used in local execution but required by the type\n    callbackWaitsForEmptyEventLoop: true,\n    identity: undefined,\n    clientContext: undefined,\n    done: () => {},\n    fail: () => {},\n    succeed: () => {},\n  }\n\n  return { event, context, requestId }\n}\n\n/**\n * Post successful response to Runtime API.\n */\nasync function postResponse(requestId: string, result: unknown): Promise<void> {\n  const response = await fetch(\n    `${RUNTIME_API_BASE}/2018-06-01/runtime/invocation/${requestId}/response`,\n    {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify(result),\n    },\n  )\n\n  if (!response.ok) {\n    lambdaError(\"ERROR\", `Failed to post response: ${response.status}`)\n  }\n}\n\n/**\n * Post error to Runtime API.\n */\nasync function postError(requestId: string, error: Error): Promise<void> {\n  const errorPayload = {\n    errorType: error.name ?? \"Error\",\n    errorMessage: error.message ?? String(error),\n    stackTrace: error.stack?.split(\"\\n\") ?? [],\n  }\n\n  const response = await fetch(\n    `${RUNTIME_API_BASE}/2018-06-01/runtime/invocation/${requestId}/error`,\n    {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        \"Lambda-Runtime-Function-Error-Type\": errorPayload.errorType,\n      },\n      body: JSON.stringify(errorPayload),\n    },\n  )\n\n  if (!response.ok) {\n    lambdaError(\"ERROR\", `Failed to post error: ${response.status}`)\n  }\n}\n\n/**\n * Post init error to Runtime API.\n */\nasync function postInitError(error: Error): Promise<void> {\n  const errorPayload = {\n    errorType: error.name ?? \"InitError\",\n    errorMessage: error.message ?? String(error),\n    stackTrace: error.stack?.split(\"\\n\") ?? [],\n  }\n\n  try {\n    await fetch(`${RUNTIME_API_BASE}/2018-06-01/runtime/init/error`, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        \"Lambda-Runtime-Function-Error-Type\": errorPayload.errorType,\n      },\n      body: JSON.stringify(errorPayload),\n    })\n  } catch {\n    // Ignore - we're already in an error state\n  }\n}\n\n/**\n * Main runtime loop.\n */\nasync function main(): Promise<void> {\n  // Load handler once at startup\n  // Note: bun --watch automatically tracks dynamic imports and restarts when they change\n  let handler: (event: unknown, context: Context) => Promise<unknown>\n  try {\n    handler = await loadHandler(HANDLER!, PROJECT_ROOT)\n  } catch (error) {\n    console.error(`Failed to load handler: ${error}`)\n    await postInitError(\n      error instanceof Error ? error : new Error(String(error)),\n    )\n    process.exit(1)\n  }\n\n  // Main invocation loop\n  while (true) {\n    try {\n      // Get next invocation (blocks until available)\n      const invocation = await getNextInvocation()\n\n      // null means 503 timeout - server wants us to reconnect and keep polling\n      if (invocation === null) {\n        // Small delay before reconnecting to avoid tight loop\n        await new Promise((resolve) => setTimeout(resolve, 100))\n        continue\n      }\n\n      const { event, context, requestId } = invocation\n      currentRequestId = requestId\n\n      try {\n        // Invoke handler\n        const result = await handler(event, context)\n\n        // Post response\n        await postResponse(requestId, result)\n      } catch (error) {\n        lambdaError(\"ERROR\", `Handler error: ${error}`)\n        await postError(\n          requestId,\n          error instanceof Error ? error : new Error(String(error)),\n        )\n      } finally {\n        currentRequestId = null\n      }\n    } catch (error) {\n      // Error getting next invocation - this is fatal, exit and let daemon restart\n      console.error(`Fatal error in invocation loop: ${error}`)\n      process.exit(1)\n    }\n  }\n}\n\n// Run the main loop\nmain().catch((error) => {\n  console.error(`Unhandled error: ${error}`)\n  process.exit(1)\n})\n"]}

package/lib/cli/watcher/file-watcher.d.ts

@@ -0,0 +1,32 @@
+/**
+ * File watching for hot-reload support.
+ *
+ * Watches handler files and triggers rebuilds when they change.
+ */
+import chokidar from "chokidar";
+import { Stream } from "effect";
+/**
+ * File change event.
+ */
+export interface FileChangeEvent {
+    type: "add" | "change" | "unlink";
+    path: string;
+}
+/**
+ * Create a file watcher stream that emits events when files change.
+ *
+ * @param patterns - Glob patterns to watch (e.g., ["src/**\/*.ts"])
+ * @param options - Chokidar options
+ */
+export declare const watchFiles: (patterns: string | string[], options?: Parameters<typeof chokidar.watch>[1]) => Stream.Stream<FileChangeEvent, Error>;
+/**
+ * Watch for changes to handler files and debounce notifications.
+ *
+ * @param patterns - Glob patterns to watch
+ * @param debounceMs - Debounce delay in milliseconds (default: 500)
+ */
+export declare const watchHandlerFiles: (patterns: string | string[], debounceMs?: number) => Stream.Stream<FileChangeEvent[], Error>;
+/**
+ * Watch a directory and accumulate changes.
+ */
+export declare const watchDirectory: (directory: string, extensions?: string[]) => Stream.Stream<FileChangeEvent[], Error>;

package/lib/cli/watcher/file-watcher.js

@@ -0,0 +1,57 @@
+/**
+ * File watching for hot-reload support.
+ *
+ * Watches handler files and triggers rebuilds when they change.
+ */
+import chokidar from "chokidar";
+import { Effect, Stream } from "effect";
+/**
+ * Create a file watcher stream that emits events when files change.
+ *
+ * @param patterns - Glob patterns to watch (e.g., ["src/**\/*.ts"])
+ * @param options - Chokidar options
+ */
+export const watchFiles = (patterns, options) => Stream.asyncScoped((emit) => Effect.gen(function* () {
+    const watcher = chokidar.watch(patterns, {
+        ignoreInitial: true,
+        ...options,
+    });
+    watcher.on("add", (path) => {
+        emit.single({ type: "add", path });
+    });
+    watcher.on("change", (path) => {
+        emit.single({ type: "change", path });
+    });
+    watcher.on("unlink", (path) => {
+        emit.single({ type: "unlink", path });
+    });
+    watcher.on("error", (err) => {
+        const error = err;
+        emit.fail(new Error(`Watcher error: ${error.message}`));
+    });
+    // Cleanup when scope closes
+    yield* Effect.addFinalizer(() => Effect.gen(function* () {
+        yield* Effect.promise(async () => {
+            await watcher.close();
+        });
+        yield* Effect.logInfo("File watcher closed");
+    }));
+    yield* Effect.logInfo(`Watching: ${Array.isArray(patterns) ? patterns.join(", ") : patterns}`);
+}));
+/**
+ * Watch for changes to handler files and debounce notifications.
+ *
+ * @param patterns - Glob patterns to watch
+ * @param debounceMs - Debounce delay in milliseconds (default: 500)
+ */
+export const watchHandlerFiles = (patterns, debounceMs = 500) => watchFiles(patterns).pipe(
+// Collect events within the debounce window
+Stream.debounce(`${debounceMs} millis`), Stream.map((event) => [event]));
+/**
+ * Watch a directory and accumulate changes.
+ */
+export const watchDirectory = (directory, extensions = ["ts", "js", "mjs", "cjs", "json"]) => {
+    const pattern = `${directory}/**/*.{${extensions.join(",")}}`;
+    return watchHandlerFiles(pattern);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/functions/bridge/appsync-client.d.ts

@@ -0,0 +1,73 @@
+/**
+ * AppSync Events client with AWS SigV4 signing.
+ *
+ * This client handles:
+ * - HTTP requests to publish events (with IAM signing)
+ * - WebSocket connections for real-time subscriptions (with IAM signing)
+ */
+export interface AppSyncEventsClientConfig {
+    httpEndpoint: string;
+    realtimeEndpoint: string;
+    region?: string;
+}
+export interface PublishAndWaitOptions<T> {
+    publishChannel: string;
+    subscribeChannel: string;
+    message: unknown;
+    timeoutMs: number;
+    matchResponse: (message: T) => boolean;
+}
+export interface SubscriptionOptions<T> {
+    channel: string;
+    onMessage: (message: T) => void | Promise<void>;
+    onError?: (error: Error) => void;
+}
+/**
+ * Client for AppSync Events API
+ */
+export declare class AppSyncEventsClient {
+    private readonly httpEndpoint;
+    private readonly realtimeEndpoint;
+    private readonly region;
+    private ws;
+    constructor(config: AppSyncEventsClientConfig);
+    /**
+     * Publish a message to a channel and wait for a response on another channel.
+     */
+    publishAndWaitForResponse<T>(options: PublishAndWaitOptions<T>): Promise<T>;
+    /**
+     * Publish a message to a channel via HTTP
+     */
+    publish(channel: string, message: unknown): Promise<void>;
+    /**
+     * Subscribe to a channel and receive messages continuously.
+     * Returns an unsubscribe function.
+     */
+    subscribe<T>(options: SubscriptionOptions<T>): Promise<() => void>;
+    /**
+     * Check if WebSocket is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to WebSocket and subscribe to a channel
+     */
+    private connectAndSubscribe;
+    /**
+     * Connect to WebSocket and subscribe to a channel with continuous message handling.
+     * Unlike connectAndSubscribe, this doesn't close after receiving a message.
+     */
+    private connectAndSubscribeContinuous;
+    /**
+     * Create authorization headers for subscribe operation
+     */
+    private createSubscribeAuthorization;
+    /**
+     * Build signed WebSocket connection info for AppSync Events
+     * Returns [url, subprotocols] for WebSocket constructor
+     */
+    private buildSignedWebSocketConnection;
+    /**
+     * Close the WebSocket connection
+     */
+    close(): Promise<void>;
+}