@nlabs/lex 1.49.4 → 1.50.0

package/templates/typescript/DataLayer.js.txt

@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+
+class DataLayer {
+  constructor(options = {}) {
+    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) {
+    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) {
+    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, data) {
+    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) {
+    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) {
+    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, context) {
+    try {
+      const {httpMethod, pathParameters, body, queryStringParameters} = event;
+      const id = pathParameters?.id;
+
+      let result;
+
+      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, context) => {
+  const dataLayer = new DataLayer();
+  return dataLayer.handleRequest(event, context);
+};

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

@@ -0,0 +1,268 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+
+import {DataLayer, handler} from './DataLayer.js';
+
+describe('DataLayer', () => {
+  let dataLayer;
+  let mockContext;
+
+  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'
+    };
+  });
+
+  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 = {
+        httpMethod: 'GET',
+        pathParameters: {id: 'test-id'},
+        body: null,
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'GET',
+        pathParameters: null,
+        body: null,
+        queryStringParameters: {status: 'active'}
+      };
+
+      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 = {
+        httpMethod: 'POST',
+        pathParameters: null,
+        body: JSON.stringify({
+          name: 'New Item',
+          description: 'A new item'
+        }),
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'PUT',
+        pathParameters: {id: 'test-id'},
+        body: JSON.stringify({
+          name: 'Updated Item'
+        }),
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'DELETE',
+        pathParameters: {id: 'test-id'},
+        body: null,
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'PUT',
+        pathParameters: null,
+        body: JSON.stringify({name: 'Updated Item'}),
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'DELETE',
+        pathParameters: null,
+        body: null,
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'OPTIONS',
+        pathParameters: null,
+        body: null,
+        queryStringParameters: null
+      };
+
+      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 = {
+        httpMethod: 'GET',
+        pathParameters: {id: 'test-id'},
+        body: null,
+        queryStringParameters: null
+      };
+
+      const result = await handler(event, mockContext);
+
+      expect(result.statusCode).toBe(200);
+      expect(result.headers['Content-Type']).toBe('application/json');
+    });
+  });
+});