cdk-local-lambda 0.0.2

package/lib/aspect/live-lambda-bootstrap.js

@@ -0,0 +1,260 @@
+/**
+ * Bootstrap file that installs hooks for NodejsFunction and DockerImageFunction
+ * BEFORE any CDK imports.
+ *
+ * This must be imported as the very first thing in the CDK app entry point,
+ * before any other imports.
+ *
+ * Runtime support:
+ * - Node.js: patches Module._load to intercept module loading
+ * - Bun: directly imports and patches modules (Module._load not supported)
+ *
+ * Hooks installed:
+ * - NodejsFunction: captures entry and handler props
+ * - DockerImageFunction: captures docker context path from code prop
+ * - DockerImageCode.fromImageAsset: captures the directory path
+ */
+import { createRequire } from "node:module";
+const requireFromPackage = createRequire(import.meta.url);
+// Prefer resolving dependencies from the *CDK app project* (process.cwd()).
+// This avoids patching a nested aws-cdk-lib copy when cdk-local-lambda is
+// installed with its own node_modules (common with package managers).
+let requireFromProject = requireFromPackage;
+try {
+    requireFromProject = createRequire(`${process.cwd()}/package.json`);
+}
+catch {
+    // Fall back to resolving relative to this package.
+}
+/**
+ * Detect if we're running in Bun runtime
+ */
+const isBun = typeof process.versions.bun !== "undefined";
+// Symbols for NodejsFunction
+const ENTRY_SYMBOL = Symbol.for("live-lambda:entry");
+const HANDLER_SYMBOL = Symbol.for("live-lambda:handler");
+// Symbols for DockerImageFunction
+const DOCKER_CONTEXT_SYMBOL = Symbol.for("live-lambda:docker-context");
+/**
+ * Map to store docker context paths captured from DockerImageCode.fromImageAsset
+ * Key is the DockerImageCode instance, value is the context path
+ */
+const dockerImageCodeContextMap = new WeakMap();
+/**
+ * Check if a module request is for aws-lambda-nodejs.
+ * We need to match:
+ * - "aws-cdk-lib/aws-lambda-nodejs" (direct import)
+ * - Paths ending with "/aws-lambda-nodejs" (resolved paths)
+ * - Paths containing "/aws-lambda-nodejs/" (submodule imports)
+ */
+function isLambdaNodejsModule(request) {
+    return (request === "aws-cdk-lib/aws-lambda-nodejs" ||
+        request.endsWith("/aws-lambda-nodejs") ||
+        request.includes("/aws-lambda-nodejs/"));
+}
+/**
+ * Check if a module request is for aws-lambda (for DockerImageFunction).
+ * We need to match:
+ * - "aws-cdk-lib/aws-lambda" (direct import)
+ * - Paths ending with "/aws-lambda" (resolved paths)
+ * - Paths containing "/aws-lambda/" (submodule imports)
+ */
+function isLambdaModule(request) {
+    // Be careful not to match aws-lambda-nodejs
+    if (request.includes("aws-lambda-nodejs")) {
+        return false;
+    }
+    return (request === "aws-cdk-lib/aws-lambda" ||
+        request.endsWith("/aws-lambda") ||
+        request.includes("/aws-lambda/"));
+}
+// Cache the lambda module for creating dummy code
+let cachedLambdaModule = null;
+/**
+ * Install hooks based on runtime environment.
+ *
+ * Bun notes:
+ * - Bun creates a *snapshot* of CommonJS named exports when importing from ESM.
+ *   This means that mutating/replacing `module.exports.Foo` AFTER the ESM import
+ *   was linked will not affect `import { Foo } from "..."` in the current process.
+ * - Therefore, Bun patching only works reliably when this bootstrap runs before
+ *   the app entry point is loaded, e.g. via `bun --preload cdk-local-lambda/bootstrap`.
+ *
+ * Node.js:
+ * - We can patch Module._load to intercept module loading.
+ */
+if (isBun) {
+    const isLiveMode = process.env.CDK_LIVE === "true";
+    // Best-effort patching for Bun. This is only guaranteed to work when this file
+    // is preloaded (see note above). Even then, we keep this logic lightweight.
+    if (isLiveMode) {
+        const hasPreloadFlag = process.execArgv.includes("--preload");
+        if (!hasPreloadFlag) {
+            console.warn("[LiveLambda] Warning: Running in Bun without --preload. Automatic handler/docker detection is likely disabled.");
+            console.warn("[LiveLambda] Fix: run Bun with `--preload cdk-local-lambda/bootstrap`.");
+        }
+        try {
+            // Patch aws-lambda first so NodejsFunction can create dummy Code.fromInline
+            // when CDK_LIVE=true (skips bundling).
+            const lambdaModule = requireFromProject("aws-cdk-lib/aws-lambda");
+            cachedLambdaModule = lambdaModule;
+            patchDockerImageFunction(lambdaModule);
+            const nodejsModule = requireFromProject("aws-cdk-lib/aws-lambda-nodejs");
+            patchNodejsFunction(nodejsModule);
+        }
+        catch (err) {
+            console.warn("[LiveLambda] Warning: Failed to install Bun patches:", err.message);
+            console.warn("[LiveLambda] Automatic handler/docker detection is required; ensure bootstrap is preloaded.");
+            console.warn("[LiveLambda] See: https://github.com/berenddeboer/cdk-local-lambda#bun-support");
+        }
+    }
+}
+else {
+    // Node.js: use Module._load hook to intercept module loading
+    const Module = requireFromPackage("node:module");
+    const originalLoad = Module._load;
+    Module._load = function (request, parent, isMain) {
+        // Call original load - let errors propagate naturally
+        const result = originalLoad.call(this, request, parent, isMain);
+        // Check if this is the lambda-nodejs module
+        if (isLambdaNodejsModule(request)) {
+            patchNodejsFunction(result);
+        }
+        // Check if this is the lambda module (for DockerImageFunction and Code.fromInline)
+        if (isLambdaModule(request)) {
+            // Cache the lambda module so we can use Code.fromInline in NodejsFunction patch
+            cachedLambdaModule = result;
+            patchDockerImageFunction(result);
+        }
+        return result;
+    };
+}
+/**
+ * Create a dummy inline code that does nothing.
+ * Used to skip bundling when CDK_LIVE=true.
+ */
+function createDummyCode(lambdaModule) {
+    // Access lambda.Code.fromInline to create a no-op code
+    // This avoids bundling entirely since we provide pre-built code
+    const Code = lambdaModule.Code;
+    if (Code?.fromInline) {
+        return Code.fromInline("// Placeholder - replaced by LiveLambdaAspect");
+    }
+    return undefined;
+}
+/**
+ * Patch NodejsFunction to capture entry and handler props
+ */
+function patchNodejsFunction(module) {
+    // If already patched, skip
+    if (module?.NodejsFunction?.__liveLambdaPatched) {
+        return;
+    }
+    // Check if we can patch
+    if (module?.NodejsFunction) {
+        const OriginalNodejsFunction = module.NodejsFunction;
+        const isLiveMode = process.env.CDK_LIVE === "true";
+        // Create wrapper class that captures entry/handler props
+        class NodejsFunctionWithCapture extends OriginalNodejsFunction {
+            constructor(scope, id, props = {}) {
+                // In live mode, provide dummy code to skip bundling entirely
+                // The aspect will replace this with the bridge code from S3
+                let modifiedProps = props;
+                if (isLiveMode && !props.code && cachedLambdaModule) {
+                    const dummyCode = createDummyCode(cachedLambdaModule);
+                    if (dummyCode) {
+                        modifiedProps = { ...props, code: dummyCode };
+                    }
+                }
+                super(scope, id, modifiedProps);
+                // Store the entry path on the instance (validate it's a non-empty string)
+                if (typeof props.entry === "string" && props.entry.trim().length > 0) {
+                    ;
+                    this[ENTRY_SYMBOL] =
+                        props.entry;
+                }
+                // Store the handler name (validate and default to 'handler')
+                const handler = typeof props.handler === "string" && props.handler.trim().length > 0
+                    ? props.handler
+                    : "handler";
+                this[HANDLER_SYMBOL] = handler;
+            }
+            static __liveLambdaPatched = true;
+        }
+        // Try to replace - fail if we can't
+        try {
+            Object.defineProperty(module, "NodejsFunction", {
+                value: NodejsFunctionWithCapture,
+                writable: true,
+                configurable: true,
+            });
+        }
+        catch (err) {
+            console.error("[LiveLambda] FATAL: Cannot patch NodejsFunction - module is frozen or sealed.");
+            console.error("[LiveLambda] This can happen with certain bundlers or Node.js configurations.");
+            console.error("[LiveLambda] Error:", err.message);
+            process.exit(1);
+        }
+    }
+}
+/**
+ * Patch DockerImageFunction and DockerImageCode to capture docker context
+ */
+function patchDockerImageFunction(module) {
+    if (!module)
+        return;
+    // First, patch DockerImageCode.fromImageAsset to capture the directory path
+    if (module.DockerImageCode && !module.DockerImageCode.__liveLambdaPatched) {
+        const OriginalDockerImageCode = module.DockerImageCode;
+        const originalFromImageAsset = OriginalDockerImageCode.fromImageAsset;
+        // Wrap fromImageAsset to capture the directory
+        const patchedFromImageAsset = (directory, props) => {
+            const result = originalFromImageAsset.call(OriginalDockerImageCode, directory, props);
+            // Store the directory path in the WeakMap, keyed by the result instance
+            dockerImageCodeContextMap.set(result, directory);
+            return result;
+        };
+        try {
+            Object.defineProperty(OriginalDockerImageCode, "fromImageAsset", {
+                value: patchedFromImageAsset,
+                writable: true,
+                configurable: true,
+            });
+            OriginalDockerImageCode.__liveLambdaPatched = true;
+        }
+        catch (err) {
+            console.warn("[LiveLambda] Could not patch DockerImageCode.fromImageAsset:", err.message);
+        }
+    }
+    // Then, patch DockerImageFunction to read from the WeakMap
+    if (module.DockerImageFunction &&
+        !module.DockerImageFunction.__liveLambdaPatched) {
+        const OriginalDockerImageFunction = module.DockerImageFunction;
+        // Create wrapper class that captures docker context
+        class DockerImageFunctionWithCapture extends OriginalDockerImageFunction {
+            constructor(scope, id, props) {
+                super(scope, id, props);
+                // Look up the docker context from the WeakMap
+                if (props.code) {
+                    const contextPath = dockerImageCodeContextMap.get(props.code);
+                    if (contextPath) {
+                        ;
+                        this[DOCKER_CONTEXT_SYMBOL] = contextPath;
+                    }
+                }
+            }
+            static __liveLambdaPatched = true;
+        }
+        try {
+            Object.defineProperty(module, "DockerImageFunction", {
+                value: DockerImageFunctionWithCapture,
+                writable: true,
+                configurable: true,
+            });
+        }
+        catch (err) {
+            console.warn("[LiveLambda] Could not patch DockerImageFunction:", err.message);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"live-lambda-bootstrap.js","sourceRoot":"","sources":["../../src/aspect/live-lambda-bootstrap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Bootstrap file that installs hooks for NodejsFunction and DockerImageFunction\n * BEFORE any CDK imports.\n *\n * This must be imported as the very first thing in the CDK app entry point,\n * before any other imports.\n *\n * Runtime support:\n * - Node.js: patches Module._load to intercept module loading\n * - Bun: directly imports and patches modules (Module._load not supported)\n *\n * Hooks installed:\n * - NodejsFunction: captures entry and handler props\n * - DockerImageFunction: captures docker context path from code prop\n * - DockerImageCode.fromImageAsset: captures the directory path\n */\n\nimport { createRequire } from \"node:module\"\n\nconst requireFromPackage = createRequire(import.meta.url)\n\n// Prefer resolving dependencies from the *CDK app project* (process.cwd()).\n// This avoids patching a nested aws-cdk-lib copy when cdk-local-lambda is\n// installed with its own node_modules (common with package managers).\nlet requireFromProject = requireFromPackage\ntry {\n  requireFromProject = createRequire(`${process.cwd()}/package.json`)\n} catch {\n  // Fall back to resolving relative to this package.\n}\n\n/**\n * Detect if we're running in Bun runtime\n */\nconst isBun = typeof process.versions.bun !== \"undefined\"\n\n// Symbols for NodejsFunction\nconst ENTRY_SYMBOL = Symbol.for(\"live-lambda:entry\")\nconst HANDLER_SYMBOL = Symbol.for(\"live-lambda:handler\")\n\n// Symbols for DockerImageFunction\nconst DOCKER_CONTEXT_SYMBOL = Symbol.for(\"live-lambda:docker-context\")\n\n/**\n * Map to store docker context paths captured from DockerImageCode.fromImageAsset\n * Key is the DockerImageCode instance, value is the context path\n */\nconst dockerImageCodeContextMap = new WeakMap<object, string>()\n\n/**\n * Check if a module request is for aws-lambda-nodejs.\n * We need to match:\n * - \"aws-cdk-lib/aws-lambda-nodejs\" (direct import)\n * - Paths ending with \"/aws-lambda-nodejs\" (resolved paths)\n * - Paths containing \"/aws-lambda-nodejs/\" (submodule imports)\n */\nfunction isLambdaNodejsModule(request: string): boolean {\n  return (\n    request === \"aws-cdk-lib/aws-lambda-nodejs\" ||\n    request.endsWith(\"/aws-lambda-nodejs\") ||\n    request.includes(\"/aws-lambda-nodejs/\")\n  )\n}\n\n/**\n * Check if a module request is for aws-lambda (for DockerImageFunction).\n * We need to match:\n * - \"aws-cdk-lib/aws-lambda\" (direct import)\n * - Paths ending with \"/aws-lambda\" (resolved paths)\n * - Paths containing \"/aws-lambda/\" (submodule imports)\n */\nfunction isLambdaModule(request: string): boolean {\n  // Be careful not to match aws-lambda-nodejs\n  if (request.includes(\"aws-lambda-nodejs\")) {\n    return false\n  }\n  return (\n    request === \"aws-cdk-lib/aws-lambda\" ||\n    request.endsWith(\"/aws-lambda\") ||\n    request.includes(\"/aws-lambda/\")\n  )\n}\n\n// Module type for the lambda-nodejs exports\ninterface LambdaNodejsModule {\n  NodejsFunction: NodejsFunctionConstructor & {\n    __liveLambdaPatched?: boolean\n  }\n}\n\n// Constructor type that can be extended\ninterface NodejsFunctionConstructor {\n  new (\n    scope: unknown,\n    id: string,\n    props?: NodejsFunctionProps,\n  ): NodejsFunctionInstance\n  prototype: NodejsFunctionInstance\n}\n\ninterface NodejsFunctionInstance {\n  node: { addr: string }\n}\n\ninterface NodejsFunctionProps {\n  entry?: string\n  handler?: string\n  code?: unknown // lambda.Code - if provided, bundling is skipped\n}\n\n// Module type for the lambda exports\ninterface LambdaModule {\n  DockerImageFunction: DockerImageFunctionConstructor & {\n    __liveLambdaPatched?: boolean\n  }\n  DockerImageCode: DockerImageCodeStatic & {\n    __liveLambdaPatched?: boolean\n  }\n}\n\n// DockerImageFunction constructor type\ninterface DockerImageFunctionConstructor {\n  new (\n    scope: unknown,\n    id: string,\n    props: DockerImageFunctionProps,\n  ): DockerImageFunctionInstance\n  prototype: DockerImageFunctionInstance\n}\n\ninterface DockerImageFunctionInstance {\n  node: { addr: string }\n}\n\ninterface DockerImageFunctionProps {\n  code: DockerImageCodeInstance\n  [key: string]: unknown\n}\n\n// DockerImageCode static type\ninterface DockerImageCodeStatic {\n  fromImageAsset(\n    directory: string,\n    props?: DockerImageAssetProps,\n  ): DockerImageCodeInstance\n}\n\ninterface DockerImageCodeInstance {\n  // Marker to identify docker image code instances\n  __isDockerImageCode?: boolean\n}\n\ninterface DockerImageAssetProps {\n  file?: string\n  cmd?: string[]\n  [key: string]: unknown\n}\n\n// Cache the lambda module for creating dummy code\nlet cachedLambdaModule: LambdaModule | null = null\n\n/**\n * Install hooks based on runtime environment.\n *\n * Bun notes:\n * - Bun creates a *snapshot* of CommonJS named exports when importing from ESM.\n *   This means that mutating/replacing `module.exports.Foo` AFTER the ESM import\n *   was linked will not affect `import { Foo } from \"...\"` in the current process.\n * - Therefore, Bun patching only works reliably when this bootstrap runs before\n *   the app entry point is loaded, e.g. via `bun --preload cdk-local-lambda/bootstrap`.\n *\n * Node.js:\n * - We can patch Module._load to intercept module loading.\n */\nif (isBun) {\n  const isLiveMode = process.env.CDK_LIVE === \"true\"\n\n  // Best-effort patching for Bun. This is only guaranteed to work when this file\n  // is preloaded (see note above). Even then, we keep this logic lightweight.\n  if (isLiveMode) {\n    const hasPreloadFlag = process.execArgv.includes(\"--preload\")\n\n    if (!hasPreloadFlag) {\n      console.warn(\n        \"[LiveLambda] Warning: Running in Bun without --preload. Automatic handler/docker detection is likely disabled.\",\n      )\n      console.warn(\n        \"[LiveLambda] Fix: run Bun with `--preload cdk-local-lambda/bootstrap`.\",\n      )\n    }\n\n    try {\n      // Patch aws-lambda first so NodejsFunction can create dummy Code.fromInline\n      // when CDK_LIVE=true (skips bundling).\n      const lambdaModule = requireFromProject(\n        \"aws-cdk-lib/aws-lambda\",\n      ) as LambdaModule\n      cachedLambdaModule = lambdaModule\n      patchDockerImageFunction(lambdaModule)\n\n      const nodejsModule = requireFromProject(\n        \"aws-cdk-lib/aws-lambda-nodejs\",\n      ) as LambdaNodejsModule\n      patchNodejsFunction(nodejsModule)\n    } catch (err) {\n      console.warn(\n        \"[LiveLambda] Warning: Failed to install Bun patches:\",\n        (err as Error).message,\n      )\n      console.warn(\n        \"[LiveLambda] Automatic handler/docker detection is required; ensure bootstrap is preloaded.\",\n      )\n      console.warn(\n        \"[LiveLambda] See: https://github.com/berenddeboer/cdk-local-lambda#bun-support\",\n      )\n    }\n  }\n} else {\n  // Node.js: use Module._load hook to intercept module loading\n  const Module = requireFromPackage(\"node:module\")\n  const originalLoad: (\n    request: string,\n    parent: NodeModule | undefined,\n    isMain: boolean,\n  ) => unknown = Module._load\n\n  Module._load = function (\n    request: string,\n    parent: NodeModule | undefined,\n    isMain: boolean,\n  ): unknown {\n    // Call original load - let errors propagate naturally\n    const result = originalLoad.call(this, request, parent, isMain)\n\n    // Check if this is the lambda-nodejs module\n    if (isLambdaNodejsModule(request)) {\n      patchNodejsFunction(result as LambdaNodejsModule | null)\n    }\n\n    // Check if this is the lambda module (for DockerImageFunction and Code.fromInline)\n    if (isLambdaModule(request)) {\n      // Cache the lambda module so we can use Code.fromInline in NodejsFunction patch\n      cachedLambdaModule = result as LambdaModule | null\n      patchDockerImageFunction(result as LambdaModule | null)\n    }\n\n    return result\n  }\n}\n\n/**\n * Create a dummy inline code that does nothing.\n * Used to skip bundling when CDK_LIVE=true.\n */\nfunction createDummyCode(lambdaModule: LambdaModule): unknown {\n  // Access lambda.Code.fromInline to create a no-op code\n  // This avoids bundling entirely since we provide pre-built code\n  const Code = (\n    lambdaModule as unknown as {\n      Code?: { fromInline?: (code: string) => unknown }\n    }\n  ).Code\n  if (Code?.fromInline) {\n    return Code.fromInline(\"// Placeholder - replaced by LiveLambdaAspect\")\n  }\n  return undefined\n}\n\n/**\n * Patch NodejsFunction to capture entry and handler props\n */\nfunction patchNodejsFunction(module: LambdaNodejsModule | null): void {\n  // If already patched, skip\n  if (module?.NodejsFunction?.__liveLambdaPatched) {\n    return\n  }\n\n  // Check if we can patch\n  if (module?.NodejsFunction) {\n    const OriginalNodejsFunction = module.NodejsFunction\n    const isLiveMode = process.env.CDK_LIVE === \"true\"\n\n    // Create wrapper class that captures entry/handler props\n    class NodejsFunctionWithCapture extends OriginalNodejsFunction {\n      constructor(scope: unknown, id: string, props: NodejsFunctionProps = {}) {\n        // In live mode, provide dummy code to skip bundling entirely\n        // The aspect will replace this with the bridge code from S3\n        let modifiedProps = props\n        if (isLiveMode && !props.code && cachedLambdaModule) {\n          const dummyCode = createDummyCode(cachedLambdaModule)\n          if (dummyCode) {\n            modifiedProps = { ...props, code: dummyCode }\n          }\n        }\n\n        super(scope, id, modifiedProps)\n\n        // Store the entry path on the instance (validate it's a non-empty string)\n        if (typeof props.entry === \"string\" && props.entry.trim().length > 0) {\n          ;(this as unknown as Record<symbol, string>)[ENTRY_SYMBOL] =\n            props.entry\n        }\n\n        // Store the handler name (validate and default to 'handler')\n        const handler =\n          typeof props.handler === \"string\" && props.handler.trim().length > 0\n            ? props.handler\n            : \"handler\"\n        ;(this as unknown as Record<symbol, string>)[HANDLER_SYMBOL] = handler\n      }\n\n      static __liveLambdaPatched = true\n    }\n\n    // Try to replace - fail if we can't\n    try {\n      Object.defineProperty(module, \"NodejsFunction\", {\n        value: NodejsFunctionWithCapture,\n        writable: true,\n        configurable: true,\n      })\n    } catch (err) {\n      console.error(\n        \"[LiveLambda] FATAL: Cannot patch NodejsFunction - module is frozen or sealed.\",\n      )\n      console.error(\n        \"[LiveLambda] This can happen with certain bundlers or Node.js configurations.\",\n      )\n      console.error(\"[LiveLambda] Error:\", (err as Error).message)\n      process.exit(1)\n    }\n  }\n}\n\n/**\n * Patch DockerImageFunction and DockerImageCode to capture docker context\n */\nfunction patchDockerImageFunction(module: LambdaModule | null): void {\n  if (!module) return\n\n  // First, patch DockerImageCode.fromImageAsset to capture the directory path\n  if (module.DockerImageCode && !module.DockerImageCode.__liveLambdaPatched) {\n    const OriginalDockerImageCode = module.DockerImageCode\n    const originalFromImageAsset = OriginalDockerImageCode.fromImageAsset\n\n    // Wrap fromImageAsset to capture the directory\n    const patchedFromImageAsset = (\n      directory: string,\n      props?: DockerImageAssetProps,\n    ): DockerImageCodeInstance => {\n      const result = originalFromImageAsset.call(\n        OriginalDockerImageCode,\n        directory,\n        props,\n      )\n\n      // Store the directory path in the WeakMap, keyed by the result instance\n      dockerImageCodeContextMap.set(result as object, directory)\n\n      return result\n    }\n\n    try {\n      Object.defineProperty(OriginalDockerImageCode, \"fromImageAsset\", {\n        value: patchedFromImageAsset,\n        writable: true,\n        configurable: true,\n      })\n      ;(\n        OriginalDockerImageCode as DockerImageCodeStatic & {\n          __liveLambdaPatched?: boolean\n        }\n      ).__liveLambdaPatched = true\n    } catch (err) {\n      console.warn(\n        \"[LiveLambda] Could not patch DockerImageCode.fromImageAsset:\",\n        (err as Error).message,\n      )\n    }\n  }\n\n  // Then, patch DockerImageFunction to read from the WeakMap\n  if (\n    module.DockerImageFunction &&\n    !module.DockerImageFunction.__liveLambdaPatched\n  ) {\n    const OriginalDockerImageFunction = module.DockerImageFunction\n\n    // Create wrapper class that captures docker context\n    class DockerImageFunctionWithCapture extends OriginalDockerImageFunction {\n      constructor(scope: unknown, id: string, props: DockerImageFunctionProps) {\n        super(scope, id, props)\n\n        // Look up the docker context from the WeakMap\n        if (props.code) {\n          const contextPath = dockerImageCodeContextMap.get(\n            props.code as object,\n          )\n          if (contextPath) {\n            ;(this as unknown as Record<symbol, string>)[\n              DOCKER_CONTEXT_SYMBOL\n            ] = contextPath\n          }\n        }\n      }\n\n      static __liveLambdaPatched = true\n    }\n\n    try {\n      Object.defineProperty(module, \"DockerImageFunction\", {\n        value: DockerImageFunctionWithCapture,\n        writable: true,\n        configurable: true,\n      })\n    } catch (err) {\n      console.warn(\n        \"[LiveLambda] Could not patch DockerImageFunction:\",\n        (err as Error).message,\n      )\n    }\n  }\n}\n"]}

package/lib/aspect/nodejs-function-hook.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Functions to retrieve captured entry path and handler name from Lambda functions
+ * that were created with NodejsFunction.
+ *
+ * The live-lambda-bootstrap.ts file installs a hook that captures these values
+ * when NodejsFunction instances are created.
+ */
+import type * as lambda from "aws-cdk-lib/aws-lambda";
+/**
+ * Get the entry path that was passed to NodejsFunction constructor.
+ * Returns undefined if the function was not created with NodejsFunction
+ * or if the hook was not installed.
+ */
+export declare function getEntryPath(fn: lambda.Function): string | undefined;
+/**
+ * Get the handler name that was passed to NodejsFunction constructor.
+ * Returns undefined if the function was not created with NodejsFunction
+ * or if the hook was not installed.
+ */
+export declare function getHandlerName(fn: lambda.Function): string | undefined;

package/lib/aspect/nodejs-function-hook.js

@@ -0,0 +1,27 @@
+/**
+ * Functions to retrieve captured entry path and handler name from Lambda functions
+ * that were created with NodejsFunction.
+ *
+ * The live-lambda-bootstrap.ts file installs a hook that captures these values
+ * when NodejsFunction instances are created.
+ */
+// Symbols used by the bootstrap hook to store captured values
+const ENTRY_SYMBOL = Symbol.for("live-lambda:entry");
+const HANDLER_SYMBOL = Symbol.for("live-lambda:handler");
+/**
+ * Get the entry path that was passed to NodejsFunction constructor.
+ * Returns undefined if the function was not created with NodejsFunction
+ * or if the hook was not installed.
+ */
+export function getEntryPath(fn) {
+    return fn[ENTRY_SYMBOL];
+}
+/**
+ * Get the handler name that was passed to NodejsFunction constructor.
+ * Returns undefined if the function was not created with NodejsFunction
+ * or if the hook was not installed.
+ */
+export function getHandlerName(fn) {
+    return fn[HANDLER_SYMBOL];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/bootstrap-stack/bootstrap-stack.d.ts

@@ -0,0 +1,60 @@
+import * as cdk from "aws-cdk-lib";
+import * as appsync from "aws-cdk-lib/aws-appsync";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import type { Construct } from "constructs";
+/**
+ * Properties for the LiveLambdaBootstrapStack
+ */
+export interface CdkLocalLambdaBootstrapStackProps extends cdk.StackProps {
+    /**
+     * Optional name for the AppSync Events API
+     * @default 'LiveLambdaEventsApi'
+     */
+    apiName?: string;
+}
+/**
+ * Bootstrap stack that creates the shared AppSync Events API infrastructure
+ * for live lambda debugging. This stack should be deployed once per account/region.
+ */
+export declare class CdkLocalLambdaBootstrapStack extends cdk.Stack {
+    /**
+     * The AppSync Events API for WebSocket communication
+     */
+    readonly api: appsync.CfnApi;
+    /**
+     * The channel namespace for live debugging channels
+     */
+    readonly channelNamespace: appsync.CfnChannelNamespace;
+    /**
+     * The HTTP endpoint for publishing events
+     */
+    readonly httpEndpoint: string;
+    /**
+     * The WebSocket endpoint for real-time subscriptions
+     */
+    readonly realtimeEndpoint: string;
+    /**
+     * IAM role for publishing to the Events API
+     */
+    readonly publishRole: iam.Role;
+    /**
+     * S3 bucket for storing the bridge Lambda code
+     */
+    readonly bridgeBucket: s3.Bucket;
+    constructor(scope: Construct, id: string, props?: CdkLocalLambdaBootstrapStackProps);
+    /**
+     * Grant a Lambda function permission to publish and subscribe to the Events API
+     */
+    grantPublishSubscribe(grantee: iam.IGrantable): iam.Grant;
+    /**
+     * Build the bridge handler and upload to S3 using a custom resource.
+     * The bridge code has AppSync endpoints baked in at deploy time.
+     */
+    private buildAndUploadBridge;
+    /**
+     * Build Docker bridge images for ARM64 and x86_64 architectures.
+     * Uses CDK Docker image assets to build and push to ECR.
+     */
+    private buildDockerBridgeImages;
+}