lambda-live-debugger 0.0.113 → 0.0.115

package/dist/lambdaConnection.mjs

@@ -1,8 +1,8 @@
-import { AwsCredentials } from "./awsCredentials.mjs";
-import { Configuration } from "./configuration.mjs";
-import { IoTService } from "./ioTService.mjs";
-import { Logger } from "./logger.mjs";
-import { NodeHandler } from "./nodeHandler.mjs";
+import { AwsCredentials } from './awsCredentials.mjs';
+import { Configuration } from './configuration.mjs';
+import { IoTService } from './ioTService.mjs';
+import { Logger } from './logger.mjs';
+import { NodeHandler } from './nodeHandler.mjs';
 let ioTServiceConnection;
 let topic;
 const lambdasProcessingObservableMode = new Set();
@@ -30,7 +30,7 @@ async function onMessageFromLambda(message) {
     if (!Configuration.config.observable) {
         //immediately respond to the ping message to confirm the local debugging is alive
         await ioTServiceConnection.publish({
-            type: "PING",
+            type: 'PING',
             data: {
                 workerId: message.data.workerId,
                 requestId: message.data.requestId,
@@ -38,7 +38,7 @@ async function onMessageFromLambda(message) {
             },
         }, `${topic}/${message.data.workerId}`);
     }
-    if (message.type !== "INVOKE") {
+    if (message.type !== 'INVOKE') {
         throw new Error(`Unexpected message type: ${message.type}`);
     }
     try {
@@ -58,32 +58,32 @@ async function onMessageFromLambda(message) {
             }
         }
         if (Configuration.config.verbose) {
-            Logger.verbose(`[Function ${message.data.functionId}] Response: `, JSON.stringify(message.data, null, 2));
+            Logger.log(`[Function ${message.data.functionId}] Response: `, JSON.stringify(message.data, null, 2));
         }
         else {
             // first 50 characters of the response
             const requestPretty = message.data
                 ? JSON.stringify(message.data).substring(0, 100)
-                : "";
-            Logger.log(`[Function ${message.data.functionId}] Request: ${requestPretty}${requestPretty.length < 50 ? "" : "..."}`);
+                : '';
+            Logger.log(`[Function ${message.data.functionId}] Request: ${requestPretty}${requestPretty.length < 50 ? '' : '...'}`);
         }
         const response = await NodeHandler.invokeLambda(message.data);
         if (Configuration.config.verbose) {
-            Logger.verbose(`[Function ${message.data.functionId}] Response: `, JSON.stringify(response, null, 2));
+            Logger.log(`[Function ${message.data.functionId}] Response: `, JSON.stringify(response, null, 2));
         }
         else {
             // first 50 characters of the response
             const responsePretty = response
                 ? JSON.stringify(response).substring(0, 100)
-                : "";
-            Logger.log(`[Function ${message.data.functionId}] Response: ${responsePretty}${responsePretty.length < 50 ? "" : "..."}`);
+                : '';
+            Logger.log(`[Function ${message.data.functionId}] Response: ${responsePretty}${responsePretty.length < 50 ? '' : '...'}`);
         }
         if (Configuration.config.observable) {
             // if we are in observable mode, mark the worker as processed
             lambdasProcessingObservableMode.delete(message.data.functionId);
         }
         const payload = {
-            type: "SUCCESS",
+            type: 'SUCCESS',
             data: {
                 functionId: message.data.functionId,
                 requestId: message.data.requestId,
@@ -98,7 +98,7 @@ async function onMessageFromLambda(message) {
     catch (e) {
         Logger.error(`[Function ${message.data.functionId}] Error: `, e);
         const payload = {
-            type: "ERROR",
+            type: 'ERROR',
             data: {
                 functionId: message.data.functionId,
                 requestId: message.data.requestId,

package/dist/lldebugger.mjs

@@ -1,33 +1,33 @@
 #!/usr/bin/env node
 // ******  support require in for CJS modules ******
-import { createRequire } from "module";
+import { createRequire } from 'module';
 // @ts-ignore
 const require = createRequire(import.meta.url);
 global.require = require;
-import { InfraDeploy } from "./infraDeploy.mjs";
-import { getVersion } from "./version.mjs";
-import { Configuration } from "./configuration.mjs";
-import { FileWatcher } from "./fileWatcher.mjs";
-import { GitIgnore } from "./gitignore.mjs";
-import { VsCode } from "./vsCode.mjs";
-import path from "path";
-import { getRootFolder } from "./utils/getRootFolder.mjs";
-import fs from "fs/promises";
-import { Logger } from "./logger.mjs";
-import { getModuleDirname, getProjectDirname } from "./getDirname.mjs";
-import { LambdaConnection } from "./lambdaConnection.mjs";
+import { InfraDeploy } from './infraDeploy.mjs';
+import { getVersion } from './version.mjs';
+import { Configuration } from './configuration.mjs';
+import { FileWatcher } from './fileWatcher.mjs';
+import { GitIgnore } from './gitignore.mjs';
+import { VsCode } from './vsCode.mjs';
+import path from 'path';
+import { getRootFolder } from './utils/getRootFolder.mjs';
+import fs from 'fs/promises';
+import { Logger } from './logger.mjs';
+import { getModuleDirname, getProjectDirname } from './getDirname.mjs';
+import { LambdaConnection } from './lambdaConnection.mjs';
 /**
  * Start the Lambda Live Debugger
  */
 async function run() {
     const version = await getVersion();
     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!");
+    Logger.important('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);
     Logger.verbose(`Parameters: \n${Object.entries(Configuration.config)
         .map(([key, value]) => ` - ${key}=${value}`)
-        .join("\n")}`);
+        .join('\n')}`);
     Logger.verbose(`NPM module folder: ${getModuleDirname()}`);
     Logger.verbose(`Project folder: ${getProjectDirname()}`);
     if (Configuration.config.gitignore) {
@@ -40,9 +40,8 @@ async function run() {
         return;
     }
     Logger.log(`Starting the debugger ${Configuration.config.observable
-        ? "in observable mode"
-        : `(ID ${Configuration.config.debuggerId})`}
-    ...`);
+        ? 'in observable mode'
+        : `(ID ${Configuration.config.debuggerId})`}...`);
     if (Configuration.config.subfolder) {
         // change the current working directory to the subfolder for monorepos
         const newCurrentFolder = path.resolve(Configuration.config.subfolder);
@@ -51,28 +50,28 @@ async function run() {
     }
     await Configuration.discoverLambdas();
     if (Configuration.config.remove) {
-        Logger.log(`Removing Lambda Live Debugger${Configuration.config.remove === "all" ? " including layer" : ""}...`);
+        Logger.log(`Removing Lambda Live Debugger${Configuration.config.remove === 'all' ? ' including layer' : ''}...`);
         await InfraDeploy.removeInfrastructure();
         // await GitIgnore.removeFromGitIgnore();
         // delete folder .lldebugger
-        const folder = path.join(getProjectDirname(), ".lldebugger");
+        const folder = path.join(getProjectDirname(), '.lldebugger');
         Logger.verbose(`Removing ${folder} folder...`);
         await fs.rm(folder, { recursive: true });
-        if (Configuration.config.remove === "all") {
+        if (Configuration.config.remove === 'all') {
             await InfraDeploy.deleteLayer();
         }
-        Logger.log("Lambda Live Debugger removed!");
+        Logger.log('Lambda Live Debugger removed!');
         return;
     }
     await InfraDeploy.deployInfrastructure();
     const folders = [
-        path.resolve("."),
+        path.resolve('.'),
         ...Configuration.getLambdas().map((l) => l.codePath),
     ];
     // get the uppermost folder of all lambdas or the project root to watch for changes
     const rootFolderForWarchingChanges = getRootFolder(folders);
     FileWatcher.watchForFileChanges(rootFolderForWarchingChanges);
     await LambdaConnection.connect();
-    Logger.log("Debugger started!");
+    Logger.log('Debugger started!');
 }
 run().catch(Logger.error);

package/dist/logger.d.ts

@@ -1,17 +1,38 @@
 /**
- * Log verbose message in verbose logging is enabled
- * @param args
+ * Log a message
+ * @param args The arguments to log
+ */
+declare function log(...args: any[]): void;
+/**
+ * Log an important message
+ * @param args The arguments to log
+ */
+declare function important(...args: any[]): void;
+/**
+ * Log an error message in red
+ * @param args The arguments to log
+ */
+declare function error(...args: any[]): void;
+/**
+ * Log a warning message in orange
+ * @param args The arguments to log
+ */
+declare function warn(...args: any[]): void;
+/**
+ * Log a verbose message if verbose is enabled. Log the message in grey.
+ * @param args The arguments to log
  */
 declare function verbose(...args: any[]): void;
 /**
- *
- * @param enabled
+ * Set the verbosity of logging
+ * @param enabled Whether verbose logging should be enabled
  */
 declare function setVerbose(enabled: boolean): void;
 export declare const Logger: {
-    log: (message?: any, ...optionalParams: any[]) => void;
-    error: (message?: any, ...optionalParams: any[]) => void;
-    warn: (message?: any, ...optionalParams: any[]) => void;
+    log: typeof log;
+    error: typeof error;
+    warn: typeof warn;
+    important: typeof important;
     verbose: typeof verbose;
     setVerbose: typeof setVerbose;
 };

package/dist/logger.mjs

@@ -1,24 +1,62 @@
+import chalk from 'chalk';
+const orange = '#D24E01';
 let verboseEnabled = false;
 /**
- * Log verbose message in verbose logging is enabled
- * @param args
+ * Log a message
+ * @param args The arguments to log
+ */
+function log(...args) {
+    args = args.map((arg) => {
+        if (typeof arg === 'string') {
+            // Regular expression to find text within square brackets
+            return arg.replace(/\[(.*?)\]/g, (match) => chalk.gray(match)); // Colorizes the entire bracketed content
+        }
+        return arg;
+    });
+    console.log(...args);
+}
+/**
+ * Log an important message
+ * @param args The arguments to log
+ */
+function important(...args) {
+    console.log(chalk.hex(orange)(...args));
+}
+/**
+ * Log an error message in red
+ * @param args The arguments to log
+ */
+function error(...args) {
+    console.error(chalk.red(...args));
+}
+/**
+ * Log a warning message in orange
+ * @param args The arguments to log
+ */
+function warn(...args) {
+    console.warn(chalk.hex(orange)(...args));
+}
+/**
+ * Log a verbose message if verbose is enabled. Log the message in grey.
+ * @param args The arguments to log
  */
 function verbose(...args) {
     if (verboseEnabled) {
-        console.info(...args);
+        console.info(chalk.grey(...args));
     }
 }
 /**
- *
- * @param enabled
+ * Set the verbosity of logging
+ * @param enabled Whether verbose logging should be enabled
  */
 function setVerbose(enabled) {
     verboseEnabled = enabled;
 }
 export const Logger = {
-    log: console.log,
-    error: console.error,
-    warn: console.warn,
+    log,
+    error,
+    warn,
+    important,
     verbose,
     setVerbose,
 };

package/dist/nodeEsBuild.mjs

@@ -1,14 +1,14 @@
-import * as path from "path";
-import * as fs from "fs/promises";
-import * as esbuild from "esbuild";
-import { Configuration } from "./configuration.mjs";
-import { Logger } from "./logger.mjs";
-import { getProjectDirname } from "./getDirname.mjs";
-import { outputFolder } from "./constants.mjs";
-import { combineArray } from "./utils/combineArray.mjs";
-import { combineObject } from "./utils/combineObject.mjs";
-import { combineObjectStrings } from "./utils/combineObjectStrings.mjs";
-import { removeUndefinedProperties } from "./utils/removeUndefinedProperties.mjs";
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import * as esbuild from 'esbuild';
+import { Configuration } from './configuration.mjs';
+import { Logger } from './logger.mjs';
+import { getProjectDirname } from './getDirname.mjs';
+import { outputFolder } from './constants.mjs';
+import { combineArray } from './utils/combineArray.mjs';
+import { combineObject } from './utils/combineObject.mjs';
+import { combineObjectStrings } from './utils/combineObjectStrings.mjs';
+import { removeUndefinedProperties } from './utils/removeUndefinedProperties.mjs';
 const buildCache = {};
 /**
  * Get the build for the function
@@ -20,9 +20,9 @@ async function getBuild(functionId) {
         let newBuild = false;
         const func = await Configuration.getLambda(functionId);
         // if handler is a JavaScript file and not force bundle, just return the file
-        if ((func.codePath.endsWith(".js") ||
-            func.codePath.endsWith(".mjs") ||
-            func.codePath.endsWith(".cjs")) &&
+        if ((func.codePath.endsWith('.js') ||
+            func.codePath.endsWith('.mjs') ||
+            func.codePath.endsWith('.cjs')) &&
             !func.forceBundle) {
             return func.codePath;
         }
@@ -54,7 +54,7 @@ async function getBuild(functionId) {
         if (newBuild) {
             Logger.verbose(`[Function ${functionId}] Build complete`);
         }
-        const artifactFile = Object.keys(result.metafile.outputs).find((key) => key.endsWith(".js"));
+        const artifactFile = Object.keys(result.metafile.outputs).find((key) => key.endsWith('.js'));
         if (!artifactFile) {
             throw new Error(`Artifact file not found for function ${functionId}`);
         }
@@ -81,15 +81,15 @@ async function build(input) {
     const packageJsonPath = input.function.packageJsonPath;
     let isESMFromPackageJson = false;
     if (packageJsonPath) {
-        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: "utf-8" }));
-        isESMFromPackageJson = packageJson.type === "module";
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, { encoding: 'utf-8' }));
+        isESMFromPackageJson = packageJson.type === 'module';
     }
-    const isESMFromBundling = esbuildOptions?.format === "esm" ? true : undefined;
+    const isESMFromBundling = esbuildOptions?.format === 'esm' ? true : undefined;
     let isESM;
     if (isESMFromPackageJson !== undefined &&
         isESMFromBundling !== undefined &&
         isESMFromPackageJson !== isESMFromBundling) {
-        Logger.warn(`WARNING! Mismatch module type between package.json and bundling options for ${handlerCodePath}. Package.json: ${isESMFromPackageJson ? "ESM" : "CJS"}, bundling options: ${isESMFromBundling ? "ESM" : "CJS"}. Using ${isESMFromBundling ? "ESM" : "CJS"} from bunding otions.`);
+        Logger.warn(`WARNING! Mismatch module type between package.json and bundling options for ${handlerCodePath}. Package.json: ${isESMFromPackageJson ? 'ESM' : 'CJS'}, bundling options: ${isESMFromBundling ? 'ESM' : 'CJS'}. Using ${isESMFromBundling ? 'ESM' : 'CJS'} from bunding otions.`);
         isESM = isESMFromBundling;
     }
     else if (isESMFromPackageJson !== undefined) {
@@ -102,35 +102,35 @@ async function build(input) {
         isESM = false;
     }
     let ctx = input.oldCtx;
-    Logger.verbose(`[Function ${input.functionId}] Module type: ${isESM ? "ESM" : "CJS"})`);
+    Logger.verbose(`[Function ${input.functionId}] Module type: ${isESM ? 'ESM' : 'CJS'})`);
     if (!ctx) {
         const optionsDefault = {
             entryPoints: [handlerCodePath],
-            platform: "node",
+            platform: 'node',
             keepNames: true,
             bundle: true,
-            logLevel: "silent",
+            logLevel: 'silent',
             metafile: true,
             ...(isESM
                 ? {
-                    format: "esm",
-                    target: "esnext",
-                    mainFields: ["module", "main"],
+                    format: 'esm',
+                    target: 'esnext',
+                    mainFields: ['module', 'main'],
                     banner: {
                         js: [
                             `import { createRequire as topLevelCreateRequire } from 'module';`,
                             `global.require = global.require ?? topLevelCreateRequire(import.meta.url);`,
                             `import { fileURLToPath as topLevelFileUrlToPath, URL as topLevelURL } from "url"`,
                             `global.__dirname = global.__dirname ?? topLevelFileUrlToPath(new topLevelURL(".", import.meta.url))`,
-                        ].join("\n"),
+                        ].join('\n'),
                     },
                 }
                 : {
-                    format: "cjs",
-                    target: "node14",
+                    format: 'cjs',
+                    target: 'node14',
                 }),
             outdir: targetFolder,
-            sourcemap: "linked",
+            sourcemap: 'linked',
         };
         const options = {
             ...optionsDefault,
@@ -161,7 +161,7 @@ async function build(input) {
     if (input.function.packageJsonPath) {
         const from = path.resolve(input.function.packageJsonPath);
         Logger.verbose(`[Function ${input.functionId}] package.json: ${from}`);
-        const to = path.resolve(path.join(targetFolder, "package.json"));
+        const to = path.resolve(path.join(targetFolder, 'package.json'));
         await fs.copyFile(from, to);
     }
     else {

package/dist/nodeHandler.d.ts

@@ -1,4 +1,4 @@
-import { FuctionRequest } from "./ioTService.js";
+import { FuctionRequest } from './ioTService.js';
 /**
  * Invoke a Lambda function locally
  * @param fuctionRequest

package/dist/nodeHandler.mjs

@@ -1,7 +1,7 @@
-import * as path from "path";
-import * as fs from "fs/promises";
-import { NodeEsBuild } from "./nodeEsBuild.mjs";
-import { NodeWorker } from "./nodeWorker.mjs";
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { NodeEsBuild } from './nodeEsBuild.mjs';
+import { NodeWorker } from './nodeWorker.mjs';
 /**
  * Build the Lambda function
  * @param functionId

package/dist/nodeWorker.d.ts

@@ -1,4 +1,4 @@
-import { FuctionRequest } from "./ioTService.js";
+import { FuctionRequest } from './ioTService.js';
 /**
  * Run the function in a Node.js Worker Thread
  * @param input

package/dist/nodeWorker.mjs

@@ -1,8 +1,8 @@
-import { Worker } from "node:worker_threads";
-import * as path from "path";
-import { Configuration } from "./configuration.mjs";
-import { getModuleDirname, getProjectDirname } from "./getDirname.mjs";
-import { Logger } from "./logger.mjs";
+import { Worker } from 'node:worker_threads';
+import * as path from 'path';
+import { Configuration } from './configuration.mjs';
+import { getModuleDirname, getProjectDirname } from './getDirname.mjs';
+import { Logger } from './logger.mjs';
 const workers = new Map();
 /**
  * Run the function in a Node.js Worker Thread
@@ -15,7 +15,7 @@ async function runInWorker(input) {
         let worker = workers.get(input.fuctionRequest.workerId);
         if (!worker) {
             worker = startWorker({
-                handler: func.handler ?? "handler",
+                handler: func.handler ?? 'handler',
                 artifactFile: input.artifactFile,
                 workerId: input.fuctionRequest.workerId,
                 functionId: input.fuctionRequest.functionId,
@@ -26,7 +26,7 @@ async function runInWorker(input) {
         else {
             Logger.verbose(`[Function ${input.fuctionRequest.functionId}] [Worker ${input.fuctionRequest.workerId}] Reusing worker`);
         }
-        worker.on("message", (msg) => {
+        worker.on('message', (msg) => {
             Logger.verbose(`[Function ${input.fuctionRequest.functionId}] [Worker ${input.fuctionRequest.workerId}] Worker message`, JSON.stringify(msg));
             if (msg?.errorType) {
                 reject(msg);
@@ -35,7 +35,7 @@ async function runInWorker(input) {
                 resolve(msg);
             }
         });
-        worker.on("error", (err) => {
+        worker.on('error', (err) => {
             Logger.error(`[Function ${input.fuctionRequest.functionId}] [Worker ${input.fuctionRequest.workerId}] Error`, err);
             reject(err);
         });
@@ -57,23 +57,23 @@ function startWorker(input) {
     const worker = new Worker(path.resolve(path.join(getModuleDirname(), `./nodeWorkerRunner.mjs`)), {
         env: {
             ...input.environment,
-            IS_LOCAL: "true",
+            IS_LOCAL: 'true',
             LOCAL_PROJECT_DIR: localProjectDir,
         },
-        execArgv: ["--enable-source-maps"],
+        execArgv: ['--enable-source-maps'],
         workerData: input,
         stderr: true,
         stdin: true,
         stdout: true,
         //type: "module",
     });
-    worker.stdout.on("data", (data) => {
+    worker.stdout.on('data', (data) => {
         Logger.verbose(`[Function ${input.functionId}] [Worker ${input.workerId}] `, data.toString());
     });
-    worker.stderr.on("data", (data) => {
+    worker.stderr.on('data', (data) => {
         Logger.verbose(`[Function ${input.functionId}] [Worker ${input.workerId}] `, data.toString());
     });
-    worker.on("exit", () => {
+    worker.on('exit', () => {
         Logger.verbose(`[Function ${input.functionId}] [Worker ${input.workerId}] Worker exited`);
         workers.delete(input.workerId);
     });
@@ -84,7 +84,7 @@ function startWorker(input) {
  * Stop all Node.js Worker Threads
  */
 async function stopAllWorkers() {
-    Logger.verbose("Stopping all workers");
+    Logger.verbose('Stopping all workers');
     const promises = [];
     for (const worker of workers.values()) {
         promises.push(worker.terminate());

package/dist/nodeWorkerRunner.mjs

@@ -1,16 +1,16 @@
-import { createRequire as topLevelCreateRequire } from "module";
+import { createRequire as topLevelCreateRequire } from 'module';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const require = topLevelCreateRequire(import.meta.url);
 
-import { workerData, parentPort } from "node:worker_threads";
-import { Logger } from "./logger.mjs";
+import { workerData, parentPort } from 'node:worker_threads';
+import { Logger } from './logger.mjs';
 
 Logger.setVerbose(workerData.verbose);
 Logger.verbose(
   `[Function ${workerData.functionId}] [Worker ${workerData.workerId}] Worker started.`,
 );
 
-parentPort.on("message", async (data) => {
+parentPort.on('message', async (data) => {
   Logger.verbose(`[Worker ${workerData.workerId}] Received message`, data);
   const mod = await import(workerData.artifactFile);
   const fn = mod[workerData.handler];
@@ -21,17 +21,17 @@ parentPort.on("message", async (data) => {
       getRemainingTimeInMillis: () => 2147483647, // Max 32-bit signed integer
       done() {
         throw new Error(
-          "`done` function on lambda Context is not implemented in Lambda Live Debugger.",
+          '`done` function on lambda Context is not implemented in Lambda Live Debugger.',
         );
       },
       fail() {
         throw new Error(
-          "`fail` function on lambda Context is not implemented in Lambda Live Debugger.",
+          '`fail` function on lambda Context is not implemented in Lambda Live Debugger.',
         );
       },
       succeed() {
         throw new Error(
-          "`succeed` function on lambda Context is not implemented in Lambda Live Debugger.",
+          '`succeed` function on lambda Context is not implemented in Lambda Live Debugger.',
         );
       },
     };
@@ -47,7 +47,7 @@ parentPort.on("message", async (data) => {
   }
 });
 
-process.on("unhandledRejection", (error) => {
+process.on('unhandledRejection', (error) => {
   Logger.error(
     `[Function ${workerData.functionId}] [Worker ${workerData.workerId}] Unhandled Rejection`,
     error,
@@ -57,7 +57,7 @@ process.on("unhandledRejection", (error) => {
 
 function handleError(error) {
   parentPort.postMessage({
-    errorType: error.name ?? "Error",
+    errorType: error.name ?? 'Error',
     errorMessage: error.message,
     trace: error.stack,
   });

package/dist/resourceDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { LldConfig } from "./types/lldConfig.js";
+import { LldConfig } from './types/lldConfig.js';
 /**
  * Get the names of the supported frameworks
  */

package/dist/resourceDiscovery.mjs

@@ -1,9 +1,9 @@
-import { cdkFramework } from "./frameworks/cdkFramework.mjs";
-import { slsFramework } from "./frameworks/slsFramework.mjs";
-import { samFramework } from "./frameworks/samFramework.mjs";
-import { terraformFramework } from "./frameworks/terraformFramework.mjs";
-import { Logger } from "./logger.mjs";
-import path from "node:path";
+import { cdkFramework } from './frameworks/cdkFramework.mjs';
+import { slsFramework } from './frameworks/slsFramework.mjs';
+import { samFramework } from './frameworks/samFramework.mjs';
+import { terraformFramework } from './frameworks/terraformFramework.mjs';
+import { Logger } from './logger.mjs';
+import path from 'node:path';
 /**
  * List of supported frameworks
  */
@@ -30,7 +30,7 @@ async function getLambdas(config) {
     let resources = undefined;
     let frameworks = [...frameworksSupported];
     if (config.framework) {
-        if (config.framework === "none") {
+        if (config.framework === 'none') {
             frameworks = [];
         }
         else {
@@ -46,7 +46,7 @@ async function getLambdas(config) {
             resources = resources.filter(
             // filter by function name, can use * as wildcard
             (l) => l.functionName === functionNameFilter ||
-                new RegExp("^" + functionNameFilter.split("*").join(".*") + "$").test(l.functionName));
+                new RegExp('^' + functionNameFilter.split('*').join('.*') + '$').test(l.functionName));
         }
     }
     else {

package/dist/types/lambdaProps.d.ts

@@ -1,4 +1,4 @@
-import { LambdaResource } from "./resourcesDiscovery.js";
+import { LambdaResource } from './resourcesDiscovery.js';
 export type LambdaProps = {
     functionId: string;
 } & LambdaResource;