lambda-live-debugger 0.0.110 → 0.0.112

package/README.md

@@ -146,15 +146,6 @@ export default {
 
 The setting are the same as for CLI parameters.
 
-### Custom framework implementation and adjustment
-
-```typescript
-getLambdas: async (foundLambdas) => {
-//you can customize the list of lambdas here or create your own
-//return foundLambdas;
-},
-```
-
 ### Debugging
 
 You might want to configure your development tool for debugging. The wizard automatically configures for VsCode in `.vscode/launch.json`. Here is an example:
@@ -221,6 +212,101 @@ Only the basic setup is supported. Check the [test case](https://github.com/Serv
 
 I am not a Terraform developer, so I only know the basics. Please provide a sample project so I can build better support.
 
+### Custom framework implementation and adjustment
+
+Configuration file `lldebugger.config.ts` enables you to modify the list of Lambdas, change the code path, esBuild configuration, or provide your own list of Lambdas, thereby supporting support **any framework**. For this to work, install Lambda Live Debugger locally in the project.
+
+```typescript
+getLambdas: async (foundLambdas, config) => {
+  //you can customize the list of lambdas here or create your own
+  return foundLambdas;
+},
+```
+
+**Filter list of functions:**
+
+```typescript
+getLambdas: async (foundLambdas, config) => {
+  return foundLambdas?.filter((l) =>
+    l.functionName.includes("myfunction"),
+ );
+},
+```
+
+**Modify code path:**\
+For example, when the framework has only a list of JavaScript files, but you transpiled them from TypeScript with your own solution.
+
+```typescript
+getLambdas: async (foundLambdas, config) => {
+  if (foundLambdas) {
+    for (const lambda of foundLambdas) {
+ lambda.codePath = lambda.codePath
+        .replace("/dist/", "/src/")
+        .replace(".js", ".ts");
+ }
+ }
+},
+```
+
+**Modfiy esBuild configuration:**
+
+```typescript
+import { type EsBuildOptions, type LldConfigTs } from "lambda-live-debugger";
+
+export default {
+  ...
+ getLambdas: async (foundLambdas, config) => {
+    if (foundLambdas) {
+      for (const lambda of foundLambdas) {
+ lambda.esBuildOptions = {
+ target: "node14",
+ };
+ }
+ }
+ },
+} satisfies LldConfigTs;
+```
+
+**Provide your own list of Lambdas and support any framework**:
+
+```typescript
+export default {
+  //framework: <-- you do not need this line
+  ...
+ getLambdas: async (foundLambdas, config) => {
+    return [
+ {
+        // function name as deployed on AWS
+ functionName: "mystack-myfunction",
+ codePath: "/src/myLambda.ts",
+ },
+ ];
+ },
+} satisfies LldConfigTs;
+```
+
+**Modify existing framework support:**
+
+```typescript
+import { CdkFramework, type LldConfigBase, type LldConfigTs } from "lambda-live-debugger";
+
+class MyCdkFramework extends CdkFramework {
+  override getCdkContext(
+ cdkConfigPath: string,
+ config: LldConfigBase,
+ ) {
+    // your implementation
+ }
+}
+
+export default {
+  ...
+ getLambdas: async (foundLambdas, config) => {
+    return new MyCdkFramework().getLambdas(config);
+ }
+} satisfies LldConfigTs;s
+```
+
 ## Know issues
 
 Check the [GitHub issues](https://github.com/ServerlessLife/lambda-live-debugger/issues).
@@ -235,7 +321,7 @@ Check the [GitHub issues](https://github.com/ServerlessLife/lambda-live-debugger
 - Use descriptive titles with prefixes like "bug:", "help:", "feature:", or "discussion:".
 - Enable verbose logging and provide the full log.
 - Describe your setup in detail, or better yet, provide a sample project.
-- Specify exact framework version (CDK, SLS, SAM ...) and exact version of Lambda Live Debugger version.
+- Specify the exact framework version (CDK, SLS, SAM ...) and the exact Lambda Live Debugger version.
 
 ## Authors:
 

package/dist/configuration.mjs

@@ -118,7 +118,7 @@ async function discoverLambdas() {
         noFramework = true;
     }
     if (config.getLambdas) {
-        lambdasListNew = await config.getLambdas(lambdasListNew);
+        lambdasListNew = await config.getLambdas(lambdasListNew, config);
     }
     if (!lambdasListNew) {
         if (noFramework) {

package/dist/frameworks/cdkFramework.d.ts

@@ -2,6 +2,7 @@ import { LambdaResource } from "../types/resourcesDiscovery.js";
 import { IFramework } from "./iFrameworks.js";
 import { AwsConfiguration } from "../types/awsConfiguration.js";
 import { LldConfigBase } from "../types/lldConfig.js";
+import { type BundlingOptions } from "aws-cdk-lib/aws-lambda-nodejs";
 /**
  * Support for AWS CDK framework
  */
@@ -38,12 +39,32 @@ export declare class CdkFramework implements IFramework {
      * @returns
      */
     protected getLambdasDataFromCdkByCompilingAndRunning(cdkConfigPath: string, config: LldConfigBase): Promise<{
-        cdkPath: any;
-        stackName: any;
+        cdkPath: string;
+        stackName: string;
         packageJsonPath: string | undefined;
-        codePath: any;
-        handler: any;
-        bundling: any;
+        codePath: string;
+        handler: string | undefined;
+        bundling: BundlingOptions;
+    }[]>;
+    /**
+     * Run CDK code in a node thread worker and return the Lambda functions
+     * @param param0
+     * @returns
+     */
+    protected runCdkCodeAndReturnLambdas({ config, awsCdkLibPath, compileCodeFile, }: {
+        config: LldConfigBase;
+        awsCdkLibPath: string | undefined;
+        compileCodeFile: string;
+    }): Promise<{
+        cdkPath: string;
+        stackName: string;
+        codePath?: string | undefined;
+        code: {
+            path?: string;
+        };
+        handler: string;
+        packageJsonPath: string;
+        bundling: BundlingOptions;
     }[]>;
     /**
      * Get CDK context

package/dist/frameworks/cdkFramework.mjs

@@ -8,7 +8,6 @@ import { CloudFormation } from "../cloudFormation.mjs";
 import { Logger } from "../logger.mjs";
 import { Worker } from "node:worker_threads";
 import { getModuleDirname, getProjectDirname } from "../getDirname.mjs";
-import { Configuration } from "../configuration.mjs";
 import { findNpmPath } from "../utils/findNpmPath.mjs";
 /**
  * Support for AWS CDK framework
@@ -219,32 +218,11 @@ export class CdkFramework {
         Logger.verbose(`[CDK] Context:`, JSON.stringify(CDK_CONTEXT_JSON, null, 2));
         const awsCdkLibPath = await findNpmPath(path.join(getProjectDirname(), config.subfolder ?? "/"), "aws-cdk-lib");
         Logger.verbose(`[CDK] aws-cdk-lib path: ${awsCdkLibPath}`);
-        const lambdas = await new Promise((resolve, reject) => {
-            const worker = new Worker(path.resolve(path.join(getModuleDirname(), "frameworks/cdkFrameworkWorker.mjs")), {
-                workerData: {
-                    verbose: Configuration.config.verbose,
-                    awsCdkLibPath,
-                },
-            });
-            worker.on("message", async (message) => {
-                resolve(message);
-                await worker.terminate();
-            });
-            worker.on("error", (error) => {
-                reject(new Error(`Error running CDK code in worker: ${error.message}`, {
-                    cause: error,
-                }));
-            });
-            worker.on("exit", (code) => {
-                if (code !== 0) {
-                    reject(new Error(`CDK worker stopped with exit code ${code}`));
-                }
-            });
-            worker.postMessage({
-                compileOutput,
-            });
+        const lambdas = await this.runCdkCodeAndReturnLambdas({
+            config,
+            awsCdkLibPath,
+            compileCodeFile: compileOutput,
         });
-        Logger.verbose(`[CDK] Found the following Lambda functions in the CDK code:`, JSON.stringify(lambdas, null, 2));
         const list = await Promise.all(lambdas.map(async (lambda) => {
             // handler slit into file and file name
             const handlerSplit = lambda.handler.split(".");
@@ -252,11 +230,19 @@ export class CdkFramework {
             const filename = handlerSplit[0];
             let codePath = lambda.codePath;
             if (!codePath) {
-                const codePathJs = path.join(lambda.code.path, `${filename}.js`);
-                const codePathCjs = path.join(lambda.code.path, `${filename}.cjs`);
-                const codePathMjs = path.join(lambda.code.path, `${filename}.mjs`);
-                // get the first file that exists
-                codePath = [codePathJs, codePathCjs, codePathMjs].find((file) => fs
+                const codePathJs = lambda.code?.path
+                    ? path.join(lambda.code.path, `${filename}.js`)
+                    : undefined;
+                const codePathCjs = lambda.code?.path
+                    ? path.join(lambda.code.path, `${filename}.cjs`)
+                    : undefined;
+                const codePathMjs = lambda.code?.path
+                    ? path.join(lambda.code.path, `${filename}.mjs`)
+                    : undefined;
+                // get  the first file that exists
+                codePath = [codePathJs, codePathCjs, codePathMjs]
+                    .filter((c) => c)
+                    .find((file) => fs
                     .access(file)
                     .then(() => true)
                     .catch(() => false));
@@ -277,6 +263,42 @@ export class CdkFramework {
         }));
         return list;
     }
+    /**
+     * Run CDK code in a node thread worker and return the Lambda functions
+     * @param param0
+     * @returns
+     */
+    async runCdkCodeAndReturnLambdas({ config, awsCdkLibPath, compileCodeFile, }) {
+        const lambdas = await new Promise((resolve, reject) => {
+            const worker = new Worker(path.resolve(path.join(getModuleDirname(), "frameworks/cdkFrameworkWorker.mjs")), {
+                workerData: {
+                    verbose: config.verbose,
+                    awsCdkLibPath,
+                    projectDirname: getProjectDirname(),
+                    moduleDirname: getModuleDirname(),
+                },
+            });
+            worker.on("message", async (message) => {
+                resolve(message);
+                await worker.terminate();
+            });
+            worker.on("error", (error) => {
+                reject(new Error(`Error running CDK code in worker: ${error.message}`, {
+                    cause: error,
+                }));
+            });
+            worker.on("exit", (code) => {
+                if (code !== 0) {
+                    reject(new Error(`CDK worker stopped with exit code ${code}`));
+                }
+            });
+            worker.postMessage({
+                compileOutput: compileCodeFile,
+            });
+        });
+        Logger.verbose(`[CDK] Found the following Lambda functions in the CDK code:`, JSON.stringify(lambdas, null, 2));
+        return lambdas;
+    }
     /**
      * Get CDK context
      * @param cdkConfigPath

package/dist/frameworks/cdkFrameworkWorker.mjs

@@ -1,10 +1,7 @@
+// @ts-nocheck
 import { createRequire as topLevelCreateRequire } from "module";
 const require = topLevelCreateRequire(import.meta.url);
 import path from "path";
-import { fileURLToPath } from "node:url";
-const __filename = fileURLToPath(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const __dirname = path.dirname(__filename);
 
 import { workerData, parentPort } from "node:worker_threads";
 import fs from "fs/promises";
@@ -12,6 +9,9 @@ import fs from "fs/promises";
 import { Logger } from "../logger.mjs";
 
 Logger.setVerbose(workerData.verbose);
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const __dirname = path.resolve(path.join(workerData.projectDirname, "/x/x"));
+
 Logger.verbose(`[CDK] [Worker] Started`);
 
 parentPort.on("message", async (data) => {

package/dist/frameworks/terraformFramework.d.ts

@@ -2,6 +2,7 @@
 import { LambdaResource } from "../types/resourcesDiscovery.js";
 import { exec } from "child_process";
 import { IFramework } from "./iFrameworks.js";
+import { LldConfigBase } from "../types/lldConfig.js";
 export declare const execAsync: typeof exec.__promisify__;
 interface TerraformState {
     resources: Array<{
@@ -31,10 +32,10 @@ export declare class TerraformFramework implements IFramework {
     canHandle(): Promise<boolean>;
     /**
      * Get Lambda functions
-     * @param config Configuration
+     * @param _config Configuration
      * @returns Lambda functions
      */
-    getLambdas(): Promise<LambdaResource[]>;
+    getLambdas(config: LldConfigBase): Promise<LambdaResource[]>;
     protected extractLambdaInfo(state: TerraformState): {
         functionName: string;
         sourceDir?: string | undefined;

package/dist/frameworks/terraformFramework.mjs

@@ -32,10 +32,11 @@ export class TerraformFramework {
     }
     /**
      * Get Lambda functions
-     * @param config Configuration
+     * @param _config Configuration
      * @returns Lambda functions
      */
-    async getLambdas() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async getLambdas(config) {
         const state = await this.readTerraformState();
         const lambdas = this.extractLambdaInfo(state);
         Logger.verbose("[Terraform] Found Lambdas:", JSON.stringify(lambdas, null, 2));

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { type LldConfigTs } from "./types/lldConfig.js";
-export type { EsBuildOptions, BundlingType, LambdaResource as LambdaResource, } from "./types/resourcesDiscovery.js";
+export { type LldConfigTs, type LldConfigBase } from "./types/lldConfig.js";
+export type { EsBuildOptions, BundlingType, LambdaResource, } from "./types/resourcesDiscovery.js";
 export { CdkFramework } from "./frameworks/cdkFramework.js";
 export { SlsFramework } from "./frameworks/slsFramework.js";
 export { SamFramework } from "./frameworks/samFramework.js";
 export { TerraformFramework } from "./frameworks/terraformFramework.js";
-export type { IFramework } from "./frameworks/iFrameworks.js";
+export { type IFramework } from "./frameworks/iFrameworks.js";
+export { type AwsConfiguration } from "./types/awsConfiguration.js";

package/dist/lldebugger.mjs

@@ -21,7 +21,7 @@ import { LambdaConnection } from "./lambdaConnection.mjs";
  */
 async function run() {
     const version = await getVersion();
-    Logger.log(`Welcome to Lambda Live Debugger version ${version}.`);
+    Logger.log(`Welcome to Lambda Live Debugger 🐞 version ${version}.`);
     Logger.log("To keep the project moving forward, please fill out the feedback form at https://forms.gle/v6ekZtuB45Rv3EyW9. Your input is greatly appreciated!");
     await Configuration.readConfig();
     Logger.setVerbose(Configuration.config.verbose === true);
@@ -39,8 +39,7 @@ async function run() {
     if (!Configuration.config.start && !Configuration.config.remove) {
         return;
     }
-    Logger.log(`Starting the debugger
-      ${Configuration.config.observable
+    Logger.log(`Starting the debugger ${Configuration.config.observable
         ? "in observable mode"
         : `(ID ${Configuration.config.debuggerId})`}
     ...`);

package/dist/types/lldConfig.d.ts

@@ -43,7 +43,7 @@ export type LldConfigBase = {
     /**
      * Resources discovery function
      */
-    getLambdas?: (foundFunctions?: LambdaResource[]) => Promise<LambdaResource[] | undefined>;
+    getLambdas?: (foundFunctions?: LambdaResource[], config?: LldConfigBase) => Promise<LambdaResource[] | undefined>;
     /**
      * Monorepo subfolder
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda-live-debugger",
-  "version": "0.0.110",
+  "version": "0.0.112",
   "type": "module",
   "description": "Debug Lambda functions locally like it is running in the cloud",
   "repository": {