lambda-live-debugger 0.0.113 → 0.0.115

package/dist/types/lldConfig.d.ts

@@ -1,5 +1,5 @@
-import { AwsConfiguration } from "./awsConfiguration.js";
-import { LambdaResource } from "./resourcesDiscovery.js";
+import { AwsConfiguration } from './awsConfiguration.js';
+import { LambdaResource } from './resourcesDiscovery.js';
 export type LldConfigBase = {
     /**
      * Verbose logs
@@ -50,12 +50,12 @@ export type LldConfigBase = {
     subfolder?: string;
 } & AwsConfiguration;
 export type LldConfigCliArgs = {
-    remove?: "keep-layer" | "all";
+    remove?: 'keep-layer' | 'all';
     vscode?: boolean;
     gitignore?: boolean;
     config?: string;
     wizard?: boolean;
-} & Omit<LldConfigBase, "getResources">;
+} & Omit<LldConfigBase, 'getResources'>;
 export type LldConfigTs = Partial<LldConfigBase>;
 export type LldConfig = LldConfigCliArgs & LldConfigTs & {
     debuggerId: string;

package/dist/types/resourcesDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { BuildOptions } from "esbuild";
+import { BuildOptions } from 'esbuild';
 export type LambdaResource = {
     functionName: string;
     codePath: string;
@@ -15,4 +15,4 @@ export declare enum BundlingType {
     ESBUILD = "ESBUILD",
     NONE = "NONE"
 }
-export type EsBuildOptions = Omit<BuildOptions, "outfile" | "outdir" | "outbase" | "write" | "allowOverwrite" | "sourcemap" | "keepnames" | "entryPoints" | "stdin">;
+export type EsBuildOptions = Omit<BuildOptions, 'outfile' | 'outdir' | 'outbase' | 'write' | 'allowOverwrite' | 'sourcemap' | 'keepnames' | 'entryPoints' | 'stdin'>;

package/dist/utils/findNpmPath.mjs

@@ -1,15 +1,15 @@
-import fs from "fs/promises";
-import path from "path";
+import fs from 'fs/promises';
+import path from 'path';
 /**
  * Function to find the path of a module in the directory and parent directories
  * @param {*} dir
  * @param {*} moduleName
  */
 export async function findNpmPath(dir, moduleName) {
-    if (dir === "/")
+    if (dir === '/')
         return undefined;
     try {
-        await fs.access(path.join(dir, "package.json"));
+        await fs.access(path.join(dir, 'package.json'));
         const modulePath = await checkModuleInPackageJson(dir, moduleName);
         if (modulePath) {
             return modulePath;
@@ -18,7 +18,7 @@ export async function findNpmPath(dir, moduleName) {
     catch {
         // ignore, no package.json in this directory
     }
-    return await findNpmPath(path.resolve(path.join(dir, "..")), moduleName);
+    return await findNpmPath(path.resolve(path.join(dir, '..')), moduleName);
 }
 /**
  * Function to check if a module exists in package.json and return the path
@@ -27,7 +27,7 @@ export async function findNpmPath(dir, moduleName) {
  * @returns
  */
 async function checkModuleInPackageJson(dir, moduleName) {
-    const modulePath = path.join(dir, "node_modules", moduleName);
+    const modulePath = path.join(dir, 'node_modules', moduleName);
     try {
         await fs.access(modulePath);
     }

package/dist/utils/findPackageJson.mjs

@@ -1,5 +1,5 @@
-import * as path from "path";
-import * as fs from "fs/promises";
+import * as path from 'path';
+import * as fs from 'fs/promises';
 /**
  * Find the package.json file for a given code path
  * @param codePath
@@ -7,9 +7,9 @@ import * as fs from "fs/promises";
  */
 export async function findPackageJson(codePath) {
     const handlerParsedPath = path.parse(codePath);
-    const packageJsonRoot = await findAboveFolderWithAFile(handlerParsedPath.dir, "package.json");
+    const packageJsonRoot = await findAboveFolderWithAFile(handlerParsedPath.dir, 'package.json');
     const packageJsonPath = packageJsonRoot
-        ? path.resolve(path.join(packageJsonRoot, "package.json"))
+        ? path.resolve(path.join(packageJsonRoot, 'package.json'))
         : undefined;
     return packageJsonPath;
 }
@@ -20,7 +20,7 @@ export async function findPackageJson(codePath) {
  * @returns
  */
 async function findAboveFolderWithAFile(dir, file) {
-    if (dir === "/")
+    if (dir === '/')
         return undefined;
     try {
         // Check if the file exists in the current directory
@@ -28,6 +28,6 @@ async function findAboveFolderWithAFile(dir, file) {
         return dir;
     }
     catch {
-        return findAboveFolderWithAFile(path.resolve(path.join(dir, "..")), file);
+        return findAboveFolderWithAFile(path.resolve(path.join(dir, '..')), file);
     }
 }

package/dist/utils/getRootFolder.mjs

@@ -5,16 +5,16 @@
  */
 export function getRootFolder(folders) {
     if (folders.length === 0)
-        return "";
+        return '';
     // Sort folders to ensure the shortest and most nested folder is first
     folders.sort((a, b) => a.length - b.length);
     // Split the first folder to get its parts
-    const rootParts = folders[0].split("/");
+    const rootParts = folders[0].split('/');
     // Iterate through the parts and check if all folders start with the same root
     for (let i = 1; i < rootParts.length; i++) {
-        const currentRoot = rootParts.slice(0, i + 1).join("/");
+        const currentRoot = rootParts.slice(0, i + 1).join('/');
         if (!folders.every((folder) => folder.startsWith(currentRoot))) {
-            return rootParts.slice(0, i).join("/");
+            return rootParts.slice(0, i).join('/');
         }
     }
     return folders[0]; // If all folders have the same root

package/dist/utils/removeUndefinedProperties.mjs

@@ -8,7 +8,7 @@ export function removeUndefinedProperties(obj) {
         return obj;
     }
     for (const key in obj) {
-        if (typeof obj[key] === "undefined") {
+        if (typeof obj[key] === 'undefined') {
             delete obj[key];
         }
     }

package/dist/version.mjs

@@ -1,6 +1,6 @@
-import * as fs from "fs";
-import * as path from "path";
-import { getModuleDirname } from "./getDirname.mjs";
+import * as fs from 'fs';
+import * as path from 'path';
+import { getModuleDirname } from './getDirname.mjs';
 let versionStored = undefined;
 /**
  * Get the version of the package
@@ -10,9 +10,9 @@ export async function getVersion() {
     if (versionStored) {
         return versionStored;
     }
-    const pachageJsonPath = path.join(getModuleDirname(), "../", "package.json");
+    const pachageJsonPath = path.join(getModuleDirname(), '../', 'package.json');
     try {
-        const packageJson = await fs.promises.readFile(pachageJsonPath, "utf-8");
+        const packageJson = await fs.promises.readFile(pachageJsonPath, 'utf-8');
         const { version } = JSON.parse(packageJson);
         versionStored = version;
         return version;

package/dist/vsCode.mjs

@@ -1,21 +1,21 @@
-import fs from "fs/promises";
-import path from "path";
-import { parse, printParseErrorCode, applyEdits, modify, } from "jsonc-parser";
-import { getModuleDirname, getProjectDirname } from "./getDirname.mjs";
-import { Logger } from "./logger.mjs";
+import fs from 'fs/promises';
+import path from 'path';
+import { parse, printParseErrorCode, applyEdits, modify, } from 'jsonc-parser';
+import { getModuleDirname, getProjectDirname } from './getDirname.mjs';
+import { Logger } from './logger.mjs';
 async function getVsCodeLaunchConfig() {
-    const localRuntimeExecutable = "${workspaceFolder}/node_modules/.bin/lld";
+    const localRuntimeExecutable = '${workspaceFolder}/node_modules/.bin/lld';
     const config = {
-        version: "0.2.0",
+        version: '0.2.0',
         configurations: [
             {
-                name: "Lambda Live Debugger",
-                type: "node",
-                request: "launch",
+                name: 'Lambda Live Debugger',
+                type: 'node',
+                request: 'launch',
                 runtimeExecutable: localRuntimeExecutable,
                 runtimeArgs: [],
-                console: "integratedTerminal",
-                skipFiles: ["<node_internals>/**"],
+                console: 'integratedTerminal',
+                skipFiles: ['<node_internals>/**'],
                 env: {},
             },
         ],
@@ -24,14 +24,14 @@ async function getVsCodeLaunchConfig() {
     //Logger.log("Module folder", moduleDirname);
     const projectDirname = getProjectDirname();
     //Logger.log("Current folder", currentFolder);
-    const localFolder = path.resolve(path.join(projectDirname, "node_modules/.bin/lld"));
+    const localFolder = path.resolve(path.join(projectDirname, 'node_modules/.bin/lld'));
     let runtimeExecutableSet = false;
     //if installed locally
-    if (moduleDirname.startsWith("/home/")) {
-        Logger.verbose("Lambda Live Debugger is installed locally");
+    if (moduleDirname.startsWith('/home/')) {
+        Logger.verbose('Lambda Live Debugger is installed locally');
         // check if file exists
         try {
-            Logger.log("Checking local folder for runtimeExecutable setting for VsCode configuration", localFolder);
+            Logger.log('Checking local folder for runtimeExecutable setting for VsCode configuration', localFolder);
             await fs.access(localFolder, fs.constants.F_OK);
             config.configurations[0].runtimeExecutable = localRuntimeExecutable;
             runtimeExecutableSet = true;
@@ -42,16 +42,16 @@ async function getVsCodeLaunchConfig() {
         }
     }
     else {
-        Logger.verbose("Lambda Live Debugger is installed globally");
+        Logger.verbose('Lambda Live Debugger is installed globally');
     }
     if (!runtimeExecutableSet) {
         Logger.verbose(`Setting absolute path for runtimeExecutable setting for VsCode configuration`);
-        const localFolderSubfolder = path.resolve("node_modules/.bin/lld");
-        const globalModule1 = path.join(moduleDirname, "..", "..", ".bin/lld");
-        const globalModule2 = path.join(moduleDirname, "..", "..", "bin/lld");
-        const globalModule3 = path.join(moduleDirname, "..", "..", "..", "..", "bin/lld");
+        const localFolderSubfolder = path.resolve('node_modules/.bin/lld');
+        const globalModule1 = path.join(moduleDirname, '..', '..', '.bin/lld');
+        const globalModule2 = path.join(moduleDirname, '..', '..', 'bin/lld');
+        const globalModule3 = path.join(moduleDirname, '..', '..', '..', '..', 'bin/lld');
         const possibleFolders = {
-            [localFolder]: "${workspaceFolder}/node_modules/.bin/lld",
+            [localFolder]: '${workspaceFolder}/node_modules/.bin/lld',
             [localFolderSubfolder]: localFolderSubfolder,
             [globalModule1]: globalModule1,
             [globalModule2]: globalModule2,
@@ -80,7 +80,7 @@ async function getVsCodeLaunchConfig() {
 }
 async function readLaunchJson(filePath) {
     try {
-        const jsonString = await fs.readFile(filePath, "utf-8");
+        const jsonString = await fs.readFile(filePath, 'utf-8');
         const errors = [];
         const json = parse(jsonString, errors, {
             allowTrailingComma: true,
@@ -107,13 +107,13 @@ async function writeConfiguration(filePath, jsonString, changes, position) {
             tabSize: 2,
         };
         // Apply changes to the original JSON string
-        const edits = modify(jsonString, ["configurations", position], changes, {
+        const edits = modify(jsonString, ['configurations', position], changes, {
             formattingOptions,
         });
         const modifiedJsonString = applyEdits(jsonString, edits);
         // Write the modified JSON string back to the file
         Logger.verbose(`Adding to VsCode configuration file: ${filePath}`);
-        await fs.writeFile(filePath, modifiedJsonString, "utf-8");
+        await fs.writeFile(filePath, modifiedJsonString, 'utf-8');
     }
     catch (err) {
         Logger.error(`Error writing the file: ${err}`);
@@ -121,7 +121,7 @@ async function writeConfiguration(filePath, jsonString, changes, position) {
     }
 }
 async function getCurrentState() {
-    const filePath = path.join(getProjectDirname(), ".vscode/launch.json");
+    const filePath = path.join(getProjectDirname(), '.vscode/launch.json');
     let createNewFile = false;
     // does file exist
     try {
@@ -141,7 +141,7 @@ async function getCurrentState() {
         if (!exists) {
             Logger.verbose(`${filePath} exists but configuration does not exist!`);
             return {
-                state: "FILE_EXISTS_CONFIGURATION_DOES_NOT_EXIST",
+                state: 'FILE_EXISTS_CONFIGURATION_DOES_NOT_EXIST',
                 jsonString,
                 configurationsLength: existingConfig.configurations?.length || 0,
                 filePath,
@@ -150,38 +150,38 @@ async function getCurrentState() {
         else {
             Logger.verbose(`Configuration already exists in ${filePath}`);
             return {
-                state: "FILE_EXISTS_CONFIGURATION_EXISTS",
+                state: 'FILE_EXISTS_CONFIGURATION_EXISTS',
             };
         }
     }
     else {
         Logger.verbose(`${filePath} does not exist!`);
         return {
-            state: "FILE_DOES_NOT_EXIST",
+            state: 'FILE_DOES_NOT_EXIST',
             filePath,
         };
     }
 }
 async function isConfigured() {
     const state = await getCurrentState();
-    if (state.state === "FILE_EXISTS_CONFIGURATION_EXISTS") {
+    if (state.state === 'FILE_EXISTS_CONFIGURATION_EXISTS') {
         return true;
     }
     return false;
 }
 async function addConfiguration() {
-    Logger.log("Adding configuration to .vscode/launch.json");
+    Logger.log('Adding configuration to .vscode/launch.json');
     const state = await getCurrentState();
     const config = await getVsCodeLaunchConfig();
-    if (state.state === "FILE_EXISTS_CONFIGURATION_DOES_NOT_EXIST") {
+    if (state.state === 'FILE_EXISTS_CONFIGURATION_DOES_NOT_EXIST') {
         const { jsonString, filePath, configurationsLength } = state;
         await writeConfiguration(filePath, jsonString, config.configurations[0], configurationsLength);
     }
-    else if (state.state === "FILE_DOES_NOT_EXIST") {
+    else if (state.state === 'FILE_DOES_NOT_EXIST') {
         // crete folder of filePath recursive if not exists
         await fs.mkdir(path.dirname(state.filePath), { recursive: true });
         Logger.verbose(`Creating VsCode configuration file: ${state.filePath}`);
-        await fs.writeFile(state.filePath, JSON.stringify(config, null, 2), "utf-8");
+        await fs.writeFile(state.filePath, JSON.stringify(config, null, 2), 'utf-8');
     }
 }
 export const VsCode = {

package/eslint.config.js

@@ -1,27 +1,27 @@
-import globals from "globals";
-import pluginJs from "@eslint/js";
-import tseslint from "typescript-eslint";
-import pluginPrettier from "eslint-plugin-prettier";
-import prettierConfig from "eslint-config-prettier";
+import globals from 'globals';
+import pluginJs from '@eslint/js';
+import tseslint from 'typescript-eslint';
+import pluginPrettier from 'eslint-plugin-prettier';
+import prettierConfig from 'eslint-config-prettier';
 
 export default [
-  { files: ["**/*.{js,mjs,cjs,ts}"] },
+  { files: ['**/*.{js,mjs,cjs,ts}'] },
   {
     ignores: [
-      "**/dist/**",
-      "**/cdk.out/**",
-      "**/.lldebugger/**",
-      "**/.serverless/**",
-      "**/.aws-sam/**",
-      "src/extension/aws/*.js",
+      '**/dist/**',
+      '**/cdk.out/**',
+      '**/.lldebugger/**',
+      '**/.serverless/**',
+      '**/.aws-sam/**',
+      'src/extension/aws/*.js',
     ],
   },
   {
     languageOptions: {
       globals: globals.node,
-      parser: "@typescript-eslint/parser",
+      parser: '@typescript-eslint/parser',
       parserOptions: {
-        project: "./tsconfig.json",
+        project: './tsconfig.json',
       },
     },
   },
@@ -33,10 +33,10 @@ export default [
     },
     rules: {
       ...pluginPrettier.configs.recommended.rules,
-      "@typescript-eslint/no-floating-promises": "error",
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-require-imports": "off",
-      "@typescript-eslint/ban-ts-comment": "off",
+      '@typescript-eslint/no-floating-promises': 'error',
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/ban-ts-comment': 'off',
     },
   },
   prettierConfig,

package/fix-imports.js

@@ -1,6 +1,6 @@
-import { readdir, readFile, writeFile, rename } from "fs/promises";
-import { join, dirname, parse } from "path";
-import { fileURLToPath } from "url";
+import { readdir, readFile, writeFile, rename } from 'fs/promises';
+import { join, dirname, parse } from 'path';
+import { fileURLToPath } from 'url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -15,32 +15,32 @@ async function processFiles(directory) {
     const fullPath = join(directory, entry.name);
     if (entry.isDirectory()) {
       await processFiles(fullPath);
-    } else if (entry.isFile() && entry.name.endsWith(".js")) {
-      const data = await readFile(fullPath, "utf8");
+    } else if (entry.isFile() && entry.name.endsWith('.js')) {
+      const data = await readFile(fullPath, 'utf8');
       const updatedData = data
-        .split("\n")
+        .split('\n')
         .map((line) => {
-          if (line.trim().startsWith("import")) {
-            return line.replace(/\.js"/g, '.mjs"');
+          if (line.trim().startsWith('import')) {
+            return line.replace(/\.js"/g, '.mjs"').replace(/\.js'/g, ".mjs'");
           }
           return line;
         })
-        .join("\n");
+        .join('\n');
       const { dir, name } = parse(fullPath);
       const newFullPath = join(dir, `${name}.mjs`);
 
-      await writeFile(fullPath, updatedData, "utf8");
+      await writeFile(fullPath, updatedData, 'utf8');
       await rename(fullPath, newFullPath);
     }
   }
 }
 
-const directoryPath = join(__dirname, "dist");
+const directoryPath = join(__dirname, 'dist');
 
 processFiles(directoryPath)
   .then(() =>
     console.log(
-      "JS files have been converted to MJS and import paths updated.",
+      'JS files have been converted to MJS and import paths updated.',
     ),
   )
-  .catch((err) => console.error("Error processing files:", err));
+  .catch((err) => console.error('Error processing files:', err));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambda-live-debugger",
-  "version": "0.0.113",
+  "version": "0.0.115",
   "type": "module",
   "description": "Debug Lambda functions locally like it is running in the cloud",
   "repository": {
@@ -91,6 +91,7 @@
     "@aws-sdk/client-s3": "^3.577.0",
     "@aws-sdk/credential-providers": "^3.577.0",
     "aws-iot-device-sdk": "^2.2.13",
+    "chalk": "^5.3.0",
     "chokidar": "^3.6.0",
     "commander": "^12.0.0",
     "esbuild": "^0.20.1",
@@ -117,7 +118,8 @@
     "yaml",
     "typescript",
     "inquirer",
-    "jsonc-parser"
+    "jsonc-parser",
+    "chalk"
   ],
   "workspaces": [
     "src/extension/*",