@nlabs/lex 1.48.6 → 1.49.0

package/examples/serverless-example/dist/handlers/graphql.js

@@ -0,0 +1,137 @@
+export const handler = async (event, context) => {
+  console.log('GraphQL handler started');
+  console.log('Event:', JSON.stringify(event, null, 2));
+
+  // Simulate GraphQL resolver logic
+  const resolvers = {
+    Query: {
+      hello: () => {
+        console.log('Resolver: hello called');
+        return 'Hello from GraphQL!';
+      },
+      users: () => {
+        console.log('Resolver: users called');
+        return [
+          { id: 1, name: 'John Doe', email: 'john@example.com' },
+          { id: 2, name: 'Jane Smith', email: 'jane@example.com' }
+        ];
+      }
+    },
+    Mutation: {
+      signUp: (_, args) => {
+        const user = args.user;
+        console.log('Resolver: signUp called with user:', user);
+        console.log('Processing signup for:', user.email);
+
+        // Simulate some processing
+        const userId = Math.floor(Math.random() * 1000);
+        console.log('Generated user ID:', userId);
+
+        return {
+          userId,
+          username: user.username,
+          email: user.email
+        };
+      }
+    }
+  };
+
+  try {
+    // Parse the GraphQL request
+    const body = JSON.parse(event.body);
+    console.log('GraphQL Query:', body.query);
+    console.log('GraphQL Variables:', body.variables);
+
+    // Simulate GraphQL execution
+    if (body.query.includes('signUp')) {
+      console.log('Executing signUp mutation');
+      // Extract user data from the query since we're not using a real GraphQL parser
+      const userMatch = body.query.match(/signUp\(user:\s*{([^}]+)}\)/);
+      if (userMatch) {
+        const userData = userMatch[1];
+        const emailMatch = userData.match(/email:\s*"([^"]+)"/);
+        const passwordMatch = userData.match(/password:\s*"([^"]+)"/);
+        const usernameMatch = userData.match(/username:\s*"([^"]+)"/);
+        const confirmMatch = userData.match(/confirm:\s*"([^"]+)"/);
+
+        const user = {
+          email: emailMatch ? emailMatch[1] : '',
+          password: passwordMatch ? passwordMatch[1] : '',
+          username: usernameMatch ? usernameMatch[1] : '',
+          confirm: confirmMatch ? confirmMatch[1] : ''
+        };
+
+        const result = resolvers.Mutation.signUp(null, { user });
+        console.log('SignUp result:', result);
+
+        return {
+          statusCode: 200,
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            data: {
+              users: {
+                signUp: result
+              }
+            }
+          })
+        };
+      }
+    } else if (body.query.includes('hello')) {
+      console.log('Executing hello query');
+      const result = resolvers.Query.hello();
+      console.log('Hello result:', result);
+
+      return {
+        statusCode: 200,
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          data: {
+            hello: result
+          }
+        })
+      };
+    } else if (body.query.includes('users')) {
+      console.log('Executing users query');
+      const result = resolvers.Query.users();
+      console.log('Users result:', result);
+
+      return {
+        statusCode: 200,
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          data: {
+            users: result
+          }
+        })
+      };
+    }
+
+    console.log('No matching query found');
+    return {
+      statusCode: 400,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        errors: [{ message: 'Query not supported' }]
+      })
+    };
+  } catch (error) {
+    console.error('GraphQL handler error:', error);
+    return {
+      statusCode: 500,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        errors: [{ message: error.message }]
+      })
+    };
+  }
+};

package/examples/serverless-example/dist/handlers/hello.js

@@ -0,0 +1,15 @@
+export const handler = async (event, context) => {
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      message: 'Hello from serverless!',
+      path: event.path,
+      method: event.httpMethod,
+      queryParams: event.queryStringParameters,
+      timestamp: new Date().toISOString()
+    })
+  };
+};

package/examples/serverless-example/dist/handlers/test.js

@@ -0,0 +1,17 @@
+export const handler = async (event, context) => {
+  console.log('Test handler called');
+  console.log('Event:', event);
+
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      message: 'Hello from test handler!',
+      data: {
+        test: true
+      }
+    })
+  };
+};

package/examples/serverless-example/dist/handlers/websocket.js

@@ -0,0 +1,14 @@
+export const handler = async (event, context) => {
+  const {routeKey, connectionId} = event.requestContext;
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({
+      message: 'WebSocket message received',
+      route: routeKey,
+      connectionId,
+      receivedData: event.body,
+      timestamp: new Date().toISOString()
+    })
+  };
+};

package/examples/serverless-example/lex.config.mjs

@@ -0,0 +1,74 @@
+export default {
+  outputFullPath: './dist',
+  serverless: {
+    custom: {
+      'serverless-offline': {
+        cors: true,
+        host: 'localhost',
+        httpPort: 3000,
+        httpsPort: 3001,
+        wsPort: 3002
+      }
+    },
+    functions: {
+      echo: {
+        events: [
+          {
+            http: {
+              cors: true,
+              method: 'POST',
+              path: '/echo'
+            }
+          }
+        ],
+        handler: 'handlers/echo.js'
+      },
+      graphql: {
+        events: [
+          {
+            http: {
+              cors: true,
+              method: 'POST',
+              path: '/public'
+            }
+          }
+        ],
+        handler: 'handlers/graphql.js'
+      },
+      hello: {
+        events: [
+          {
+            http: {
+              cors: true,
+              method: 'GET',
+              path: '/hello'
+            }
+          }
+        ],
+        handler: 'handlers/hello.js'
+      },
+      test: {
+        events: [
+          {
+            http: {
+              cors: true,
+              method: 'GET',
+              path: '/test'
+            }
+          }
+        ],
+        handler: 'handlers/test.js'
+      },
+      websocket: {
+        events: [
+          {
+            websocket: {
+              route: '$default'
+            }
+          }
+        ],
+        handler: 'handlers/websocket.js'
+      }
+    }
+  }
+};

package/jest.config.mjs

@@ -2,22 +2,23 @@
  * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
  * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
  */
-import {fileURLToPath} from 'url';
-import {dirname, resolve} from 'path';
-import {deepMerge} from './dist/utils/deepMerge.js';
-
 import {readFileSync} from 'fs';
+import merge from 'lodash/merge.js';
+import {dirname, resolve} from 'path';
+import {fileURLToPath} from 'url';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const pack = JSON.parse(readFileSync(resolve(__dirname, 'package.json'), 'utf8'));
+const filename = fileURLToPath(import.meta.url);
+const dirnamePath = dirname(filename);
+const pack = JSON.parse(readFileSync(resolve(dirnamePath, 'package.json'), 'utf8'));
 
 let projectJestConfig = null;
+
 if(process.env.LEX_CONFIG) {
   try {
     const lexConfig = JSON.parse(process.env.LEX_CONFIG);
     projectJestConfig = lexConfig.jest;
-  } catch(error) {
+  } catch (error) {
+    // eslint-disable-next-line no-console
     console.warn('Failed to parse LEX_CONFIG:', error.message);
   }
 }
@@ -36,19 +37,19 @@ const baseConfig = {
   displayName: pack.name,
   moduleFileExtensions: ['ts', 'tsx', 'js', 'json', 'node'],
   moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
+    '^(\\.{1,2}/.*)\\.js$': '$1'
   },
   rootDir: process.cwd(),
   testEnvironment: 'node',
   testRegex: '(/__tests__/.*|\\.(test|spec|integration))\\.(ts|tsx)?$',
   transform: {
-    '^.+\.js$|^.+\.jsx$': ['babel-jest', {
+    '^.+\\.js$|^.+\\.jsx$': ['babel-jest', {
       presets: [
         ['@babel/preset-env', {targets: {node: 'current'}}],
         '@babel/preset-typescript'
       ]
     }],
-    '^.+\.ts$|^.+\.tsx$': ['babel-jest', {
+    '^.+\\.ts$|^.+\\.tsx$': ['babel-jest', {
       presets: [
         ['@babel/preset-env', {targets: {node: 'current'}}],
         '@babel/preset-typescript',
@@ -60,7 +61,7 @@ const baseConfig = {
 };
 
 const finalConfig = projectJestConfig && Object.keys(projectJestConfig).length > 0
-  ? deepMerge(baseConfig, projectJestConfig)
+  ? merge(baseConfig, projectJestConfig)
   : baseConfig;
 
 export default finalConfig;

package/{dist → lib}/LexConfig.d.ts

@@ -1,4 +1,6 @@
+import type { Linter } from 'eslint';
 export interface EsbuildConfig {
+    [key: string]: unknown;
     entryPoints?: string[];
     outdir?: string;
     platform?: 'node' | 'browser';
@@ -16,9 +18,9 @@ export interface EsbuildConfig {
     banner?: Record<string, string>;
     footer?: Record<string, string>;
     define?: Record<string, string>;
-    [key: string]: unknown;
 }
 export interface JestConfig {
+    [key: string]: unknown;
     roots?: string[];
     testEnvironment?: string;
     transform?: Record<string, [string, Record<string, unknown>]>;
@@ -26,14 +28,14 @@ export interface JestConfig {
     moduleNameMapper?: Record<string, string>;
     extensionsToTreatAsEsm?: string[];
     preset?: string;
-    [key: string]: unknown;
 }
 export interface WebpackConfig {
+    [key: string]: unknown;
     entry?: string | string[];
     output?: Record<string, unknown>;
     module?: Record<string, unknown>;
     plugins?: unknown[];
-    [key: string]: unknown;
+    publicPath?: string;
 }
 export interface AIConfig {
     provider?: 'cursor' | 'copilot' | 'openai' | 'anthropic' | 'none';
@@ -42,14 +44,20 @@ export interface AIConfig {
     maxTokens?: number;
     temperature?: number;
 }
+export interface ESLintConfig {
+    [key: string]: unknown;
+    extends?: string[];
+    rules?: Linter.RulesRecord;
+}
 export interface LexConfigType {
     ai?: AIConfig;
     configFiles?: string[];
     copyFiles?: string[];
     entryHTML?: string;
     entryJs?: string;
-    esbuild?: EsbuildConfig;
     env?: object;
+    esbuild?: EsbuildConfig;
+    eslint?: ESLintConfig;
     gitUrl?: string;
     jest?: JestConfig;
     libraryName?: string;
@@ -69,11 +77,11 @@ export interface LexConfigType {
 }
 export type Config = LexConfigType;
 export declare const defaultConfigValues: LexConfigType;
-export declare function getTypeScriptConfigPath(configName: string): string;
+export declare const getTypeScriptConfigPath: (configName: string) => string;
 export declare class LexConfig {
     static config: LexConfigType;
-    static getLexDir(): string;
     static set useTypescript(value: boolean);
+    static getLexDir(): string;
     static updateConfig(updatedConfig: LexConfigType): LexConfigType;
     static addConfigParams(cmd: any, params: LexConfigType): void;
     static parseConfig(cmd: any, isRoot?: boolean): Promise<void>;