@nlabs/lex 1.49.5 → 1.50.1

package/templates/typescript/DataLayer.test.ts.txt

@@ -0,0 +1,269 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import {APIGatewayProxyEvent, Context} from 'aws-lambda';
+
+import {DataLayer, handler} from './DataLayer.js';
+
+describe('DataLayer', () => {
+  let dataLayer: DataLayer;
+  let mockContext: Context;
+
+  beforeEach(() => {
+    dataLayer = new DataLayer({
+      tableName: 'test-table',
+      region: 'us-east-1'
+    });
+
+    mockContext = {
+      awsRequestId: 'test-request-id',
+      functionName: 'test-function',
+      functionVersion: '$LATEST',
+      getRemainingTimeInMillis: () => 30000,
+      invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function',
+      logGroupName: '/aws/lambda/test-function',
+      logStreamName: 'test-log-stream',
+      memoryLimitInMB: '128'
+    } as Context;
+  });
+
+  describe('getItem', () => {
+    it('should get an item by ID', async () => {
+      const result = await dataLayer.getItem('test-id');
+
+      expect(result).toEqual({
+        id: 'test-id',
+        data: 'sample data',
+        timestamp: expect.any(String)
+      });
+    });
+  });
+
+  describe('createItem', () => {
+    it('should create a new item', async () => {
+      const itemData = {
+        name: 'Test Item',
+        description: 'A test item'
+      };
+
+      const result = await dataLayer.createItem(itemData);
+
+      expect(result).toEqual({
+        id: expect.stringMatching(/^item-\d+$/),
+        name: 'Test Item',
+        description: 'A test item',
+        createdAt: expect.any(String),
+        updatedAt: expect.any(String)
+      });
+    });
+
+    it('should create an item with custom ID', async () => {
+      const itemData = {
+        id: 'custom-id',
+        name: 'Test Item'
+      };
+
+      const result = await dataLayer.createItem(itemData);
+
+      expect(result.id).toBe('custom-id');
+      expect(result.name).toBe('Test Item');
+    });
+  });
+
+  describe('updateItem', () => {
+    it('should update an existing item', async () => {
+      const updateData = {
+        name: 'Updated Item',
+        description: 'Updated description'
+      };
+
+      const result = await dataLayer.updateItem('test-id', updateData);
+
+      expect(result).toEqual({
+        id: 'test-id',
+        name: 'Updated Item',
+        description: 'Updated description',
+        updatedAt: expect.any(String)
+      });
+    });
+  });
+
+  describe('deleteItem', () => {
+    it('should delete an item by ID', async () => {
+      const result = await dataLayer.deleteItem('test-id');
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('listItems', () => {
+    it('should list items without filters', async () => {
+      const result = await dataLayer.listItems();
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0]).toHaveProperty('id');
+      expect(result[0]).toHaveProperty('data');
+      expect(result[0]).toHaveProperty('timestamp');
+    });
+
+    it('should list items with filters', async () => {
+      const filters = {
+        status: 'active'
+      };
+
+      const result = await dataLayer.listItems(filters);
+
+      expect(Array.isArray(result)).toBe(true);
+    });
+  });
+
+  describe('handleRequest', () => {
+    it('should handle GET request for single item', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'GET',
+        pathParameters: {id: 'test-id'},
+        body: null,
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      expect(result.headers['Content-Type']).toBe('application/json');
+      expect(result.headers['Access-Control-Allow-Origin']).toBe('*');
+
+      const body = JSON.parse(result.body);
+      expect(body.id).toBe('test-id');
+    });
+
+    it('should handle GET request for list items', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'GET',
+        pathParameters: null,
+        body: null,
+        queryStringParameters: {status: 'active'}
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      const body = JSON.parse(result.body);
+      expect(Array.isArray(body)).toBe(true);
+    });
+
+    it('should handle POST request', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'POST',
+        pathParameters: null,
+        body: JSON.stringify({
+          name: 'New Item',
+          description: 'A new item'
+        }),
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      const body = JSON.parse(result.body);
+      expect(body.name).toBe('New Item');
+      expect(body.description).toBe('A new item');
+    });
+
+    it('should handle PUT request', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'PUT',
+        pathParameters: {id: 'test-id'},
+        body: JSON.stringify({
+          name: 'Updated Item'
+        }),
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      const body = JSON.parse(result.body);
+      expect(body.id).toBe('test-id');
+      expect(body.name).toBe('Updated Item');
+    });
+
+    it('should handle DELETE request', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'DELETE',
+        pathParameters: {id: 'test-id'},
+        body: null,
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      const body = JSON.parse(result.body);
+      expect(body.message).toBe('Item deleted successfully');
+    });
+
+    it('should return 400 for PUT without ID', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'PUT',
+        pathParameters: null,
+        body: JSON.stringify({name: 'Updated Item'}),
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(400);
+      const body = JSON.parse(result.body);
+      expect(body.error).toBe('ID is required for update operations');
+    });
+
+    it('should return 400 for DELETE without ID', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'DELETE',
+        pathParameters: null,
+        body: null,
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(400);
+      const body = JSON.parse(result.body);
+      expect(body.error).toBe('ID is required for delete operations');
+    });
+
+    it('should return 405 for unsupported method', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'OPTIONS',
+        pathParameters: null,
+        body: null,
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await dataLayer.handleRequest(event, mockContext);
+
+      expect(result.statusCode).toBe(405);
+      const body = JSON.parse(result.body);
+      expect(body.error).toBe('Method not allowed');
+    });
+  });
+
+  describe('handler function', () => {
+    it('should work as Lambda handler', async () => {
+      const event: APIGatewayProxyEvent = {
+        httpMethod: 'GET',
+        pathParameters: {id: 'test-id'},
+        body: null,
+        queryStringParameters: null
+      } as APIGatewayProxyEvent;
+
+      const result = await handler(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      expect(result.headers['Content-Type']).toBe('application/json');
+    });
+  });
+});

package/templates/typescript/DataLayer.ts.txt

@@ -0,0 +1,227 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import {APIGatewayProxyEvent, APIGatewayProxyResult, Context} from 'aws-lambda';
+
+export interface DataLayerOptions {
+  readonly tableName?: string;
+  readonly region?: string;
+  readonly endpoint?: string;
+}
+
+export class DataLayer {
+  private readonly options: DataLayerOptions;
+
+  constructor(options: DataLayerOptions = {}) {
+    this.options = {
+      tableName: process.env.TABLE_NAME || 'default-table',
+      region: process.env.AWS_REGION || 'us-east-1',
+      endpoint: process.env.DYNAMODB_ENDPOINT,
+      ...options
+    };
+  }
+
+  /**
+   * Get a single item by ID
+   */
+  async getItem(id: string): Promise<any> {
+    try {
+      // TODO: Implement DynamoDB getItem logic
+      console.log(`Getting item with ID: ${id}`);
+
+      // Example response structure
+      return {
+        id,
+        data: 'sample data',
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      console.error('Error getting item:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Create a new item
+   */
+  async createItem(data: any): Promise<any> {
+    try {
+      // TODO: Implement DynamoDB putItem logic
+      console.log('Creating new item:', data);
+
+      const newItem = {
+        id: data.id || `item-${Date.now()}`,
+        ...data,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString()
+      };
+
+      return newItem;
+    } catch (error) {
+      console.error('Error creating item:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing item
+   */
+  async updateItem(id: string, data: any): Promise<any> {
+    try {
+      // TODO: Implement DynamoDB updateItem logic
+      console.log(`Updating item ${id}:`, data);
+
+      const updatedItem = {
+        id,
+        ...data,
+        updatedAt: new Date().toISOString()
+      };
+
+      return updatedItem;
+    } catch (error) {
+      console.error('Error updating item:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete an item by ID
+   */
+  async deleteItem(id: string): Promise<boolean> {
+    try {
+      // TODO: Implement DynamoDB deleteItem logic
+      console.log(`Deleting item with ID: ${id}`);
+
+      return true;
+    } catch (error) {
+      console.error('Error deleting item:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * List items with optional filtering
+   */
+  async listItems(filters?: any): Promise<any[]> {
+    try {
+      // TODO: Implement DynamoDB scan/query logic
+      console.log('Listing items with filters:', filters);
+
+      // Example response
+      return [
+        {
+          id: 'item-1',
+          data: 'sample data 1',
+          timestamp: new Date().toISOString()
+        },
+        {
+          id: 'item-2',
+          data: 'sample data 2',
+          timestamp: new Date().toISOString()
+        }
+      ];
+    } catch (error) {
+      console.error('Error listing items:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Lambda handler for HTTP requests
+   */
+  async handleRequest(event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> {
+    try {
+      const {httpMethod, pathParameters, body, queryStringParameters} = event;
+      const id = pathParameters?.id;
+
+      let result: any;
+
+      switch (httpMethod) {
+        case 'GET':
+          if (id) {
+            result = await this.getItem(id);
+          } else {
+            result = await this.listItems(queryStringParameters);
+          }
+          break;
+
+        case 'POST':
+          const createData = body ? JSON.parse(body) : {};
+          result = await this.createItem(createData);
+          break;
+
+        case 'PUT':
+        case 'PATCH':
+          if (!id) {
+            return {
+              statusCode: 400,
+              headers: {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+              },
+              body: JSON.stringify({error: 'ID is required for update operations'})
+            };
+          }
+          const updateData = body ? JSON.parse(body) : {};
+          result = await this.updateItem(id, updateData);
+          break;
+
+        case 'DELETE':
+          if (!id) {
+            return {
+              statusCode: 400,
+              headers: {
+                'Content-Type': 'application/json',
+                'Access-Control-Allow-Origin': '*'
+              },
+              body: JSON.stringify({error: 'ID is required for delete operations'})
+            };
+          }
+          await this.deleteItem(id);
+          result = {message: 'Item deleted successfully'};
+          break;
+
+        default:
+          return {
+            statusCode: 405,
+            headers: {
+              'Content-Type': 'application/json',
+              'Access-Control-Allow-Origin': '*'
+            },
+            body: JSON.stringify({error: 'Method not allowed'})
+          };
+      }
+
+      return {
+        statusCode: 200,
+        headers: {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*'
+        },
+        body: JSON.stringify(result)
+      };
+
+    } catch (error) {
+      console.error('Handler error:', error);
+
+      return {
+        statusCode: 500,
+        headers: {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*'
+        },
+        body: JSON.stringify({
+          error: 'Internal server error',
+          message: error instanceof Error ? error.message : 'Unknown error'
+        })
+      };
+    }
+  }
+}
+
+// Export the handler function for Lambda
+export const handler = async (event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult> => {
+  const dataLayer = new DataLayer();
+  return dataLayer.handleRequest(event, context);
+};

package/webpack.config.js

@@ -9,7 +9,7 @@ import CompressionWebpackPlugin from 'compression-webpack-plugin';
 import CopyWebpackPlugin from 'copy-webpack-plugin';
 import cssnano from 'cssnano';
 import DotenvPlugin from 'dotenv-webpack';
-import {EsbuildPlugin} from 'esbuild-loader';
+import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
 import FaviconsWebpackPlugin from 'favicons-webpack-plugin';
 import {existsSync} from 'fs';
 import {sync as globSync} from 'glob';
@@ -34,6 +34,7 @@ import {merge} from 'webpack-merge';
 import {WebpackPluginServe} from 'webpack-plugin-serve';
 
 import {relativeFilePath, relativeNodePath} from './lib/utils/file.js';
+import {LexConfig} from './lib/LexConfig.js';
 
 const {ProgressPlugin, ProvidePlugin} = webpack;
 const isProduction = process.env.NODE_ENV === 'production';
@@ -53,7 +54,7 @@ const {
   webpack: webpackCustom
 } = lexConfig;
 
-const webpackPublicPath = webpackCustom?.publicPath || './src/static';
+const webpackStaticPath = webpackCustom?.staticPath || './src/static';
 
 const { publicPath: _, ...webpackConfigFiltered } = webpackCustom || {};
 
@@ -153,13 +154,13 @@ const imagePath = `${sourceFullPath}/images/`;
 const fontPath = `${sourceFullPath}/fonts/`;
 const docPath = `${sourceFullPath}/docs/`;
 
-const publicPathFull = pathResolve(process.cwd(), webpackPublicPath);
-if(existsSync(publicPathFull)) {
+const staticPathFull = pathResolve(process.cwd(), webpackStaticPath);
+if(existsSync(staticPathFull)) {
   staticPaths.push({
-    from: publicPathFull,
+    from: staticPathFull,
     to: './'
   });
-  watchIgnorePaths.push(publicPathFull);
+  watchIgnorePaths.push(staticPathFull);
 }
 
 if(existsSync(imagePath)) {
@@ -233,7 +234,7 @@ if(existsSync(`${sourceFullPath}/tsconfig.json`)) {
   }));
 }
 
-const esbuildLoaderPath = relativeNodePath('esbuild-loader', dirName);
+const swcLoaderPath = relativeNodePath('swc-loader', dirName);
 const cssLoaderPath = relativeNodePath('css-loader', dirName);
 const graphqlLoaderPath = relativeNodePath('graphql-tag/loader', dirName);
 const htmlLoaderPath = relativeNodePath('html-loader', dirName);
@@ -263,7 +264,7 @@ const alias = aliasKeys.reduce((aliases, key) => {
 }, {});
 
 export default (webpackEnv, webpackOptions) => {
-  const {bundleAnalyzer, watch, entry: cliEntry, mode: cliMode} = webpackOptions;
+  const {bundleAnalyzer, watch, entry: cliEntry, mode: cliMode, port} = webpackOptions;
   const entryValue = Array.isArray(cliEntry) ? cliEntry[0] : cliEntry;
 
   // Debug printout for environment and mode
@@ -322,10 +323,16 @@ export default (webpackEnv, webpackOptions) => {
             `${sourceFullPath}/**/*.test.ts*`
           ],
           include: sourceFullPath,
-          loader: esbuildLoaderPath,
+          loader: swcLoaderPath,
           options: {
-            loader: 'ts',
-            target: targetEnvironment === 'node' ? 'node16' : 'es2016'
+            ...LexConfig.config.swc,
+            jsc: {
+              ...LexConfig.config.swc?.jsc,
+              parser: {
+                ...LexConfig.config.swc?.jsc?.parser,
+                tsx: false
+              }
+            }
           },
           resolve: {
             symlinks: true
@@ -339,10 +346,23 @@ export default (webpackEnv, webpackOptions) => {
             `${sourceFullPath}/**/*.test.ts*`
           ],
           include: sourceFullPath,
-          loader: esbuildLoaderPath,
+          loader: swcLoaderPath,
           options: {
-            loader: 'tsx',
-            target: targetEnvironment === 'node' ? 'node16' : 'es2016'
+            ...LexConfig.config.swc,
+            jsc: {
+              ...LexConfig.config.swc?.jsc,
+              parser: {
+                ...LexConfig.config.swc?.jsc?.parser,
+                tsx: true
+              },
+              transform: {
+                ...LexConfig.config.swc?.jsc?.transform,
+                react: {
+                  ...LexConfig.config.swc?.jsc?.transform?.react,
+                  runtime: 'automatic'
+                }
+              }
+            }
           },
           resolve: {
             symlinks: true
@@ -433,13 +453,6 @@ export default (webpackEnv, webpackOptions) => {
                   ]
                 }
               }
-            },
-            {
-              loader: esbuildLoaderPath,
-              options: {
-                loader: 'css',
-                minify: isProduction
-              }
             }
           ]
         },
@@ -451,7 +464,7 @@ export default (webpackEnv, webpackOptions) => {
         },
         {
           test: /\.(jpg|jpeg|png|gif|webp|svg|mp4|webm|ogg|mp3|wav|flac|aac)$/,
-          include: publicPathFull,
+          include: staticPathFull,
           type: 'asset/resource',
           generator: {
             filename: '[name].[hash][ext]'
@@ -504,10 +517,7 @@ export default (webpackEnv, webpackOptions) => {
       isProduction && isWeb
         ? {
           minimizer: [
-            new EsbuildPlugin({
-              css: true,
-              target: targetEnvironment
-            })
+            new CssMinimizerPlugin()
           ],
           runtimeChunk: 'single',
           splitChunks: {
@@ -605,7 +615,7 @@ export default (webpackEnv, webpackOptions) => {
               }
             },
             {
-              from: /\.[css,gif,ico,jpg,json,png,svg]/,
+              from: /\\.(css|gif|ico|jpg|json|png|svg)$/,
               to: ({parsedUrl: {pathname}}) => pathname
             }
           ],
@@ -623,7 +633,7 @@ export default (webpackEnv, webpackOptions) => {
             await next();
           }),
         open: process.env.WEBPACK_DEV_OPEN === 'true',
-        port: 7001,
+        port: port || 3000,
         progress: 'minimal',
         static: existsSync(outputFullPath) ? [outputFullPath] : [],
         status: true

package/lib/commands/lint/autofix.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};