lambda-live-debugger 1.10.5 → 1.11.0

package/dist/cloudFormation.d.ts

@@ -12,10 +12,11 @@ declare function getCloudFormationStackTemplate(stackName: string, awsConfigurat
  * @param awsConfiguration
  * @returns
  */
-declare function getLambdasInStack(stackName: string, awsConfiguration: AwsConfiguration): Promise<Array<{
+declare function getLambdasInStack(stackName: string, awsConfiguration: AwsConfiguration, stackLogicalId?: string): Promise<Array<{
     lambdaName: string;
     logicalId: string;
     stackName: string;
+    stackLogicalId: string;
 }>>;
 export declare const CloudFormation: {
     getCloudFormationStackTemplate: typeof getCloudFormationStackTemplate;

package/dist/cloudFormation.mjs

@@ -108,7 +108,7 @@ async function getCloudFormationResources(stackName, awsConfiguration) {
  * @param awsConfiguration
  * @returns
  */
-async function getLambdasInStack(stackName, awsConfiguration) {
+async function getLambdasInStack(stackName, awsConfiguration, stackLogicalId) {
     const response = await getCloudFormationResources(stackName, awsConfiguration);
     const lambdaResources = response?.filter((resource) => resource.ResourceType === 'AWS::Lambda::Function');
     const nestedStacks = response?.filter((resource) => resource.ResourceType === 'AWS::CloudFormation::Stack');
@@ -117,12 +117,13 @@ async function getLambdasInStack(stackName, awsConfiguration) {
             lambdaName: resource.PhysicalResourceId,
             logicalId: resource.LogicalResourceId,
             stackName: stackName,
+            stackLogicalId: stackLogicalId ?? stackName,
         };
     }) ?? [];
     const lambdasInNestedStacks = await Promise.all((nestedStacks ?? []).map(async (nestedStack) => {
         if (!nestedStack.PhysicalResourceId)
             return [];
-        const lambdasInNestedStack = await getLambdasInStack(nestedStack.PhysicalResourceId, awsConfiguration);
+        const lambdasInNestedStack = await getLambdasInStack(nestedStack.PhysicalResourceId, awsConfiguration, nestedStack.LogicalResourceId);
         return lambdasInNestedStack;
     }));
     const flattenedLambdasInNestedStacks = lambdasInNestedStacks.flat();

package/dist/frameworks/samFramework.d.ts

@@ -26,5 +26,11 @@ export declare class SamFramework implements IFramework {
      * @returns Lambda functions
      */
     getLambdas(config: LldConfigBase): Promise<LambdaResource[]>;
+    /**
+     * Recursively parse templates to find all Lambda functions, including nested stacks
+     * @param templatePath The path to the CloudFormation/SAM template file
+     * @param stackName The name of the stack this template belongs to (for nested stacks)
+     */
+    private parseLambdasFromTemplate;
 }
 export declare const samFramework: SamFramework;

package/dist/frameworks/samFramework.mjs

@@ -83,43 +83,32 @@ export class SamFramework {
         if (!stackName) {
             throw new Error(`Stack name not found in ${samConfigFile}`);
         }
-        const samTemplateContent = await fs.readFile(path.resolve(samTemplateFile), 'utf-8');
-        const template = yaml.parse(samTemplateContent);
-        const lambdas = [];
-        // get all resources of type AWS::Serverless::Function
-        for (const resourceName in template.Resources) {
-            const resource = template.Resources[resourceName];
-            if (resource.Type === 'AWS::Serverless::Function') {
-                lambdas.push({
-                    Name: resourceName,
-                    ...resource,
-                });
-            }
-        }
+        const lambdas = await this.parseLambdasFromTemplate(samTemplateFile, stackName);
         const lambdasDiscovered = [];
         Logger.verbose(`[SAM] Found Lambdas`, JSON.stringify(lambdas, null, 2));
         const lambdasInStack = await CloudFormation.getLambdasInStack(stackName, awsConfiguration);
         Logger.verbose(`[SAM] Found Lambdas in stack ${stackName}:`, JSON.stringify(lambdasInStack, null, 2));
         // get tags for each Lambda
         for (const func of lambdas) {
-            const handlerFull = path.join(func.Properties.CodeUri ?? '', func.Properties.Handler);
+            const handlerFull = path.join(func.codeUri ?? '', func.handler);
             const handlerParts = handlerFull.split('.');
             const handler = handlerParts[1];
-            const functionName = lambdasInStack.find((lambda) => lambda.logicalId === func.Name)?.lambdaName;
+            const functionName = lambdasInStack.find((lambda) => lambda.logicalId === func.name &&
+                lambda.stackLogicalId === func.stackLogicalId)?.lambdaName;
             if (!functionName) {
-                throw new Error(`Function name not found for function: ${func.Name}`);
+                throw new Error(`Function name not found for function: ${func.name}`);
             }
             let esBuildOptions = undefined;
             let codePath;
-            if (func.Metadata?.BuildMethod?.toLowerCase() === 'esbuild') {
-                if (func.Metadata?.BuildProperties?.EntryPoints?.length > 0) {
-                    codePath = path.join(func.Properties.CodeUri ?? '', func.Metadata?.BuildProperties?.EntryPoints[0]);
+            if (func.buildMethod?.toLowerCase() === 'esbuild') {
+                if (func.entryPoints && func.entryPoints.length > 0) {
+                    codePath = path.join(func.codeUri ?? '', func.entryPoints[0]);
                 }
                 esBuildOptions = {
-                    external: func.Metadata?.BuildProperties?.External,
-                    minify: func.Metadata?.BuildProperties?.Minify,
-                    format: func.Metadata?.BuildProperties?.Format,
-                    target: func.Metadata?.BuildProperties?.Target,
+                    external: func.external,
+                    minify: func.minify,
+                    format: func.format,
+                    target: func.target,
                 };
             }
             if (!codePath) {
@@ -164,5 +153,58 @@ export class SamFramework {
         }
         return lambdasDiscovered;
     }
+    /**
+     * Recursively parse templates to find all Lambda functions, including nested stacks
+     * @param templatePath The path to the CloudFormation/SAM template file
+     * @param stackName The name of the stack this template belongs to (for nested stacks)
+     */
+    async parseLambdasFromTemplate(templatePath, stackName) {
+        const resolvedTemplatePath = path.resolve(templatePath);
+        const templateDir = path.dirname(resolvedTemplatePath);
+        let template;
+        try {
+            const templateContent = await fs.readFile(resolvedTemplatePath, 'utf-8');
+            template = yaml.parse(templateContent);
+        }
+        catch (err) {
+            Logger.warn(`[SAM] Could not read or parse template at ${templatePath}: ${err.message}`);
+            return [];
+        }
+        if (!template.Resources) {
+            return [];
+        }
+        const lambdas = [];
+        for (const resourceName in template.Resources) {
+            const resource = template.Resources[resourceName];
+            // Check if it's a Lambda function
+            if (resource.Type === 'AWS::Serverless::Function') {
+                lambdas.push({
+                    templatePath,
+                    name: resourceName,
+                    codeUri: resource.Properties?.CodeUri,
+                    handler: resource.Properties?.Handler,
+                    buildMethod: resource.Metadata?.BuildMethod,
+                    entryPoints: resource.Metadata?.BuildProperties?.EntryPoints,
+                    external: resource.Metadata?.BuildProperties?.External,
+                    minify: resource.Metadata?.BuildProperties?.Minify,
+                    format: resource.Metadata?.BuildProperties?.Format,
+                    target: resource.Metadata?.BuildProperties?.Target,
+                    stackLogicalId: stackName,
+                });
+            }
+            // Check if it's a nested stack
+            else if (resource.Type === 'AWS::Serverless::Application' ||
+                resource.Type === 'AWS::CloudFormation::Stack') {
+                const nestedTemplateLocation = resource.Properties?.Location ?? resource.Properties?.TemplateURL;
+                if (nestedTemplateLocation) {
+                    const nestedTemplatePath = path.resolve(templateDir, nestedTemplateLocation);
+                    const nestedLambdas = await this.parseLambdasFromTemplate(nestedTemplatePath, resourceName);
+                    lambdas.push(...nestedLambdas);
+                }
+            }
+        }
+        Logger.verbose(JSON.stringify(lambdas, null, 2));
+        return lambdas;
+    }
 }
 export const samFramework = new SamFramework();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda-live-debugger",
-  "version": "1.10.5",
+  "version": "1.11.0",
   "type": "module",
   "description": "Debug Lambda functions locally like it is running in the cloud",
   "repository": {
@@ -70,6 +70,8 @@
     "test-osls-esbuild-esm-observable": "npm run build && RUN_TEST_FROM_CLI=true OBSERVABLE_MODE=true vitest run test/osls-esbuild-esm.test.ts",
     "test-sam-basic": "npm run build && RUN_TEST_FROM_CLI=true vitest run test/sam-basic.test.ts",
     "test-sam-basic-observable": "npm run build && RUN_TEST_FROM_CLI=true OBSERVABLE_MODE=true vitest run test/sam-basic.test.ts",
+    "test-sam-nested": "npm run build && RUN_TEST_FROM_CLI=true vitest run test/sam-nested.test.ts",
+    "test-sam-nested-observable": "npm run build && RUN_TEST_FROM_CLI=true OBSERVABLE_MODE=true vitest run test/sam-nested.test.ts",
     "test-sam-alt": "npm run build && RUN_TEST_FROM_CLI=true vitest run test/sam-alt.test.ts",
     "test-sam-alt-observable": "npm run build && RUN_TEST_FROM_CLI=true OBSERVABLE_MODE=true vitest run test/sam-alt.test.ts",
     "test-terraform-basic": "npm run build && RUN_TEST_FROM_CLI=true vitest run test/terraform-basic.test.ts",
@@ -161,6 +163,7 @@
     "test/osls-esbuild",
     "test/osls-esbuild-cjs",
     "test/sam-basic",
+    "test/sam-nested",
     "test/sam-alt",
     "test/terraform-basic",
     "test/opentofu-basic"