@nlabs/lex 1.56.1 → 1.57.0

package/lib/commands/package-lambda/package-lambda.js

@@ -0,0 +1,110 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { execa } from 'execa';
+import { cpSync, existsSync, mkdirSync, rmSync, statSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { log } from '../../utils/log.js';
+const toList = (value)=>{
+    if (!value) return [];
+    return Array.isArray(value) ? value : [
+        value
+    ];
+};
+const formatSize = (bytes)=>{
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+};
+export const packageLambda = async (cmd, callback = ()=>({}))=>{
+    const { bundle = true, cliName = 'Lex', entry, format = 'cjs', mainFields = 'module,main', minify = false, nodeModulesPath = './node_modules', output = './lambda-package.zip', packageDir = './.lex/lambda-package', platform = 'node', quiet, sourcemap = false, target = 'node24' } = cmd;
+    if (!entry) {
+        log(`\n${cliName} Error: --entry is required.`, 'error', quiet);
+        callback(1);
+        return 1;
+    }
+    const entryPath = resolve(process.cwd(), entry);
+    if (!existsSync(entryPath)) {
+        log(`\n${cliName} Error: Entry file not found, "${entry}".`, 'error', quiet);
+        callback(1);
+        return 1;
+    }
+    const outputPath = resolve(process.cwd(), output);
+    const packagePath = resolve(process.cwd(), packageDir);
+    const outfile = resolve(process.cwd(), cmd.outfile || `${packageDir}/index.js`);
+    try {
+        log(`${cliName} packaging Lambda bundle...`, 'info', quiet);
+        rmSync(packagePath, {
+            force: true,
+            recursive: true
+        });
+        rmSync(outputPath, {
+            force: true
+        });
+        mkdirSync(dirname(outfile), {
+            recursive: true
+        });
+        const esbuildArgs = [
+            entryPath,
+            bundle ? '--bundle' : '--bundle=false',
+            `--platform=${platform}`,
+            `--target=${target}`,
+            `--format=${format}`,
+            `--main-fields=${mainFields}`,
+            '--tree-shaking=true',
+            '--legal-comments=none',
+            `--outfile=${outfile}`
+        ];
+        if (minify) {
+            esbuildArgs.push('--minify');
+        }
+        if (sourcemap) {
+            esbuildArgs.push('--sourcemap');
+        }
+        for (const external of toList(cmd.external)){
+            esbuildArgs.push(`--external:${external}`);
+        }
+        await execa('npx', [
+            '--no-install',
+            'esbuild',
+            ...esbuildArgs
+        ], {
+            cwd: process.cwd(),
+            stdio: 'inherit'
+        });
+        for (const moduleName of toList(cmd.copyNodeModule)){
+            const source = resolve(process.cwd(), nodeModulesPath, moduleName);
+            const destination = resolve(packagePath, 'node_modules', moduleName);
+            if (!existsSync(source)) {
+                log(`${cliName} warning: node module not found, "${moduleName}".`, 'warn', quiet);
+                continue;
+            }
+            mkdirSync(dirname(destination), {
+                recursive: true
+            });
+            cpSync(source, destination, {
+                recursive: true
+            });
+        }
+        mkdirSync(dirname(outputPath), {
+            recursive: true
+        });
+        await execa('zip', [
+            '-qr',
+            outputPath,
+            '.'
+        ], {
+            cwd: packagePath,
+            stdio: 'inherit'
+        });
+        log(`${cliName} Lambda package created: ${outputPath} (${formatSize(statSync(outputPath).size)})`, 'success', quiet);
+        callback(0);
+        return 0;
+    } catch (error) {
+        log(`\n${cliName} Error: Lambda package failed. ${error.message}`, 'error', quiet);
+        callback(1);
+        return 1;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/package-lambda/package-lambda.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {execa} from 'execa';\nimport {cpSync, existsSync, mkdirSync, rmSync, statSync} from 'fs';\nimport {dirname, resolve} from 'path';\n\nimport {log} from '../../utils/log.js';\n\nexport interface PackageLambdaOptions {\n  readonly bundle?: boolean;\n  readonly cliName?: string;\n  readonly copyNodeModule?: string | string[];\n  readonly entry?: string;\n  readonly external?: string | string[];\n  readonly format?: 'cjs' | 'esm';\n  readonly mainFields?: string;\n  readonly minify?: boolean;\n  readonly nodeModulesPath?: string;\n  readonly outfile?: string;\n  readonly output?: string;\n  readonly packageDir?: string;\n  readonly platform?: 'node';\n  readonly quiet?: boolean;\n  readonly sourcemap?: boolean;\n  readonly target?: string;\n}\n\nexport type PackageLambdaCallback = (status: number) => void;\n\nconst toList = (value?: string | string[]): string[] => {\n  if(!value) return [];\n  return Array.isArray(value) ? value : [value];\n};\n\nconst formatSize = (bytes: number): string => {\n  if(bytes < 1024) return `${bytes} B`;\n  if(bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;\n  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;\n};\n\nexport const packageLambda = async (\n  cmd: PackageLambdaOptions,\n  callback: PackageLambdaCallback = () => ({})\n): Promise<number> => {\n  const {\n    bundle = true,\n    cliName = 'Lex',\n    entry,\n    format = 'cjs',\n    mainFields = 'module,main',\n    minify = false,\n    nodeModulesPath = './node_modules',\n    output = './lambda-package.zip',\n    packageDir = './.lex/lambda-package',\n    platform = 'node',\n    quiet,\n    sourcemap = false,\n    target = 'node24'\n  } = cmd;\n\n  if(!entry) {\n    log(`\\n${cliName} Error: --entry is required.`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  const entryPath = resolve(process.cwd(), entry);\n  if(!existsSync(entryPath)) {\n    log(`\\n${cliName} Error: Entry file not found, \"${entry}\".`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n\n  const outputPath = resolve(process.cwd(), output);\n  const packagePath = resolve(process.cwd(), packageDir);\n  const outfile = resolve(process.cwd(), cmd.outfile || `${packageDir}/index.js`);\n\n  try {\n    log(`${cliName} packaging Lambda bundle...`, 'info', quiet);\n\n    rmSync(packagePath, {force: true, recursive: true});\n    rmSync(outputPath, {force: true});\n    mkdirSync(dirname(outfile), {recursive: true});\n\n    const esbuildArgs = [\n      entryPath,\n      bundle ? '--bundle' : '--bundle=false',\n      `--platform=${platform}`,\n      `--target=${target}`,\n      `--format=${format}`,\n      `--main-fields=${mainFields}`,\n      '--tree-shaking=true',\n      '--legal-comments=none',\n      `--outfile=${outfile}`\n    ];\n\n    if(minify) {\n      esbuildArgs.push('--minify');\n    }\n\n    if(sourcemap) {\n      esbuildArgs.push('--sourcemap');\n    }\n\n    for(const external of toList(cmd.external)) {\n      esbuildArgs.push(`--external:${external}`);\n    }\n\n    await execa('npx', ['--no-install', 'esbuild', ...esbuildArgs], {\n      cwd: process.cwd(),\n      stdio: 'inherit'\n    });\n\n    for(const moduleName of toList(cmd.copyNodeModule)) {\n      const source = resolve(process.cwd(), nodeModulesPath, moduleName);\n      const destination = resolve(packagePath, 'node_modules', moduleName);\n\n      if(!existsSync(source)) {\n        log(`${cliName} warning: node module not found, \"${moduleName}\".`, 'warn', quiet);\n        continue;\n      }\n\n      mkdirSync(dirname(destination), {recursive: true});\n      cpSync(source, destination, {recursive: true});\n    }\n\n    mkdirSync(dirname(outputPath), {recursive: true});\n    await execa('zip', ['-qr', outputPath, '.'], {\n      cwd: packagePath,\n      stdio: 'inherit'\n    });\n\n    log(`${cliName} Lambda package created: ${outputPath} (${formatSize(statSync(outputPath).size)})`, 'success', quiet);\n    callback(0);\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: Lambda package failed. ${error.message}`, 'error', quiet);\n    callback(1);\n    return 1;\n  }\n};\n"],"names":["execa","cpSync","existsSync","mkdirSync","rmSync","statSync","dirname","resolve","log","toList","value","Array","isArray","formatSize","bytes","toFixed","packageLambda","cmd","callback","bundle","cliName","entry","format","mainFields","minify","nodeModulesPath","output","packageDir","platform","quiet","sourcemap","target","entryPath","process","cwd","outputPath","packagePath","outfile","force","recursive","esbuildArgs","push","external","stdio","moduleName","copyNodeModule","source","destination","size","error","message"],"mappings":"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"}