@nlabs/lex 1.57.0 → 1.58.0

package/README.md

@@ -92,7 +92,7 @@ Lex comes with everything you need for modern React development:
 | Command | Description | Quick Example |
 |---------|-------------|---------------|
 | [`lex dev`](#dev) | Start development server | `lex dev --open` |
-| [`lex serverless`](#serverless) | Start serverless development server | `lex serverless --host 0.0.0.0` |
+| [`lex serverless-dev`](#serverless-dev) | Start serverless development server | `lex serverless-dev --host 0.0.0.0` |
 | [`lex compile`](#compile) | Compile TypeScript/JavaScript | `lex compile --watch` |
 | [`lex build`](#build) | Build for production | `lex build --mode production` |
 
@@ -166,25 +166,25 @@ export default {
 
 **Static Assets**: Use the `webpack.staticPath` configuration to specify a directory for static assets (images, videos, audio, PDFs, etc.). Files in this directory will be automatically copied to the output and optimized for web delivery.
 
-### **Serverless Development Server** {#serverless}
+### **Serverless Development Server** {#serverless-dev}
 
 ```bash
 # Start serverless development server
-lex serverless
+lex serverless-dev
 
 # With custom host and ports
-lex serverless --host 0.0.0.0 --httpPort 4000 --wsPort 4002
+lex serverless-dev --host 0.0.0.0 --httpPort 4000 --wsPort 4002
 
 # With environment variables
-lex serverless --variables '{"NODE_ENV":"development","API_KEY":"test"}'
+lex serverless-dev --variables '{"NODE_ENV":"development","API_KEY":"test"}'
 
 # With GraphQL debug logging
-lex serverless --debug --printOutput
+lex serverless-dev --debug --printOutput
 ```
 
 **AWS Lambda Simulation**: Lex provides a local development server similar to serverless-offline, allowing you to test AWS Lambda functions with HTTP and WebSocket support.
 
-**Configuration**: Configure your serverless functions in `lex.config.mjs`. See the [Serverless Documentation](src/commands/serverless/serverless.docs.md) for detailed configuration options.
+**Configuration**: Configure your serverless functions in `lex.config.mjs`. See the [Serverless Documentation](src/commands/serverless-dev/serverless-dev.docs.md) for detailed configuration options.
 
 ```javascript
 export default {
@@ -202,7 +202,7 @@ export default {
 
 `--httpPort`, `--httpsPort`, and `--wsPort` override these config values.
 
-**Environment Variables**: The serverless command automatically loads environment variables from `.env`, `.env.local`, and `.env.development` files, with command-line variables taking precedence.
+**Environment Variables**: The `serverless-dev` command automatically loads environment variables from `.env`, `.env.local`, and `.env.development` files, with command-line variables taking precedence.
 
 ### **Production Builds**
 

package/examples/serverless-example/README.md

@@ -1,6 +1,6 @@
 # Serverless Example
 
-This example demonstrates how to use the `lex serverless` command to run AWS Lambda functions locally with HTTP and WebSocket support.
+This example demonstrates how to use the `lex serverless-dev` command to run AWS Lambda functions locally with HTTP and WebSocket support.
 
 ## Setup
 
@@ -13,7 +13,7 @@ cd examples/serverless-example
 2. Start the serverless development server:
 
 ```bash
-lex serverless
+lex serverless-dev
 ```
 
 ## Available Endpoints

package/lib/commands/{package-lambda/package-lambda.d.ts → serverless-deploy/serverless-deploy.d.ts}

@@ -1,4 +1,4 @@
-export interface PackageLambdaOptions {
+export interface ServerlessDeployOptions {
     readonly bundle?: boolean;
     readonly cliName?: string;
     readonly copyNodeModule?: string | string[];
@@ -16,5 +16,5 @@ export interface PackageLambdaOptions {
     readonly sourcemap?: boolean;
     readonly target?: string;
 }
-export type PackageLambdaCallback = (status: number) => void;
-export declare const packageLambda: (cmd: PackageLambdaOptions, callback?: PackageLambdaCallback) => Promise<number>;
+export type ServerlessDeployCallback = (status: number) => void;
+export declare const serverlessDeploy: (cmd: ServerlessDeployOptions, callback?: ServerlessDeployCallback) => Promise<number>;

package/lib/commands/serverless-deploy/serverless-deploy.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 serverlessDeploy = 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/serverless-deploy/serverless-deploy.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 ServerlessDeployOptions {\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 ServerlessDeployCallback = (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 serverlessDeploy = async (\n  cmd: ServerlessDeployOptions,\n  callback: ServerlessDeployCallback = () => ({})\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","serverlessDeploy","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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"}

package/lib/commands/{serverless/serverless.d.ts → serverless-dev/serverless-dev.d.ts}

@@ -1,4 +1,4 @@
-export interface ServerlessOptions {
+export interface ServerlessDevOptions {
     readonly cliName?: string;
     readonly config?: string;
     readonly debug?: boolean;
@@ -12,5 +12,5 @@ export interface ServerlessOptions {
     readonly variables?: string;
     readonly wsPort?: number;
 }
-export type ServerlessCallback = (status: number) => void;
-export declare const serverless: (cmd: ServerlessOptions, callback?: ServerlessCallback) => Promise<number>;
+export type ServerlessDevCallback = (status: number) => void;
+export declare const serverlessDev: (cmd: ServerlessDevOptions, callback?: ServerlessDevCallback) => Promise<number>;