minimonolith 0.1.4 → 0.2.0

package/index.js

@@ -1,5 +1,7 @@
-import createAPI from 'lambda-api';
 import { z } from 'zod';
-import { serviceHandler } from './src/serviceHandler/serviceHandler.js';
 
-export { createAPI, serviceHandler, z };
+import { serviceHandler } from './src/serviceHandler/index.js';
+import { createAPI, apiHandler } from './src/apiHandler/index.js';
+import { runLambdaServer } from './src/lambdaServer/index.js';
+
+export { runLambdaServer, createAPI, apiHandler serviceHandler, z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
@@ -15,9 +15,10 @@
     "zod": "^3.21.4"
   },
   "devDependencies": {
-    "jest": "^29.5.0",
     "@aws-sdk/client-s3": "^3.304.0",
     "@aws-sdk/s3-request-presigner": "^3.304.0",
+    "dotenv": "^16.0.3",
+    "jest": "^29.5.0",
     "sqlite3": "^5.1.6"
   }
 }

package/src/apiHandler/apiHandler.js

@@ -0,0 +1,6 @@
+const apiHandler = API => async (e, context) => {
+  console.log({ EVENT_PATH: e.path, EVENT_METHOD: e.httpMethod, });
+  return await API.run(e, context);
+};
+
+export { apiHandler };

package/src/apiHandler/createAPI.js

@@ -0,0 +1,24 @@
+import lambdaAPICreateAPI from 'lambda-api';
+
+const addCORS = API =>  {
+  API.use((req, res, next) => { res.cors(); next(); });
+  API.use((err, req, res, next) => { res.cors(); next(); });
+  API.options('/*', (req, res) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'OPTIONS, POST, GET, PUT, PATCH, DELETE');
+    res.header('Access-Control-Allow-Headers', '*');
+    res.header('Access-Control-Allow-Credentials', true);
+    console.log('OPTIONS_SUCCESS');
+    res.status(200).send({})
+  });
+}
+
+const createAPI = () => {
+  const API = lambdaAPICreateAPI();
+
+  addCORS(API);
+
+  return API;
+}
+
+export { createAPI };

package/src/apiHandler/index.js

@@ -0,0 +1,4 @@
+import { createAPI } from './createAPI.js';
+import { apiHandler } from './apiHandler.js';
+
+export { createAPI, apiHandler };

package/src/healthHandler/healthHandler.js

@@ -0,0 +1,14 @@
+const healthCheck = () => {
+  return "API running...";
+}
+
+const healthHandler = API => {
+  API.get('/', async (req, res) => {
+    console.log('HEALTH_CHECK ENTERING');
+    const response = healthCheck();
+    console.log('HEALTH_CHECK SUCCESS');
+    return { response };
+  });
+}
+
+export { healthHandler };

package/src/healthHandler/index.js

@@ -0,0 +1,3 @@
+import { healthHandler } from './healthHandler.js';
+
+export { healthHandler };

package/src/index.js

@@ -1,25 +1,13 @@
 'use strict';
 
-import createAPI from 'lambda-api';
-import healthCheck from './healthCheck/index.js';
+import { createAPI, apiHandler } from './apiHandler/index.js';
+import { healthHandler } from './healthHandler/index.js';
 import { serviceHandler } from './serviceHandler/index.js';
 
 const API = createAPI();
 
-// Health Check
-API.get('/', async (req, res) => {
-  console.log('HEALTH_CHECK ENTERING');
-  const response = healthCheck();
-  console.log('HEALTH_CHECK SUCCESS');
-  return { response };
-});
+healthHandler(API);
+serviceHandler(API, 'todo');
+const lambdaAPIHandler = apiHandler(API);
 
-serviceHandler(API, 'todo', 'src');
-
-export const handler = async (e, context) => {
-  console.log({
-    EVENT_PATH: e.path,
-    EVENT_METHOD: e.httpMethod,
-  });
-  return await API.run(e, context);
-};
+export { lambdaAPIHandler };

package/src/lambdaServer/index.js

@@ -0,0 +1,3 @@
+import { runLambdaServer } from './lambdaServer';
+
+export { runLambdaServer };

package/src/lambdaServer/lambdaServer.js

@@ -0,0 +1,12 @@
+import http from 'http';
+
+import './loadEnv.js';
+import { serverHandlerContext } from './serverHandler.js';
+
+const runLambdaServer = (lambdaAPIHandler, port) => {
+  const serverHandler = serverHandlerContext(lambdaAPIHandler);
+  const server = http.createServer(serverHandler);
+  server.listen(port);
+}
+
+export { runLambdaServer };

package/src/lambdaServer/serverHandler.js

@@ -0,0 +1,66 @@
+'use strict';
+
+import url from 'url';
+
+const reqBodyPromise = req => {
+  return new Promise((resolve, reject) => {
+    let data = ''; req.on('data', chunk => { data+=chunk; });
+    req.on('end', () => { data!==''? resolve(data):resolve(null); });
+  });
+}
+
+const parseJWT = token => {
+  const tokenString = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+  return tokenString;
+}
+
+const serverHandlerContext = lambdaAPIHandler => async (req, res) => {
+  try {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Request-Method', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'OPTIONS,GET,POST,PUT,PATCH,DELETE');
+    res.setHeader('Access-Control-Allow-Headers', '*');
+    if (req.method === 'OPTIONS') {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    const token =
+      req.headers.authorization && req.headers.authorization.startsWith('Bearer ') ?
+      parseJWT(req.headers.authorization.split(" ")[1]) : null;
+
+    const tempQueryString = url.parse(req.url, true).query;
+    const queryString = tempQueryString? tempQueryString : undefined;
+
+    const tempBody = await reqBodyPromise(req);
+    const body = tempBody? tempBody : undefined;
+
+    const e = {
+      path: req.url,
+      httpMethod: req.method,
+      queryStringParameters: queryString,
+      requestContext: {
+        http: {
+          path: req.url,
+          method: req.method,
+        },
+        authorizer: {
+          jwt: { claims: token },
+        },
+      },
+      headers: {
+        accept: req.headers.accept,
+        'User-Agent': req.headers['user-agent']
+      },
+      body,
+    };
+
+    const resL = await lambdaAPIHandler(e, null)
+
+    res.statusCode = resL.statusCode;
+    res.end(resL.body);
+  } catch(err) { console.log(err); }
+}
+
+export { serverHandlerContext };

package/src/serviceHandler/index.js

@@ -1,5 +1,4 @@
 import { serviceHandler } from './serviceHandler.js';
-import { registerMethods } from './registerMethods.js';
 
-export { serviceHandler, registerMethods };
+export { serviceHandler };
 

package/src/healthCheck/index.js

@@ -1,3 +0,0 @@
-export default () => {
-  return "API running...";
-}

package/src/todo/delete/handler.js

@@ -1,10 +0,0 @@
-const handler = async (e, MODELS) =>  {
-  const { id } = e.body;
-  
-  const todo = await MODELS.todo.findOne({ where: { id: e.body.id } });
-  await todo.destroy();
-
-  return { statusCode: 200 };
-}
-
-export { handler };

package/src/todo/delete/valid.js

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-
-const VALIDATOR = (MODELS, ROUTE_CODE) =>
-  z.object({
-    id: z.number(),
-  }).strict();
-
-export { VALIDATOR };

package/src/todo/get/handler.js

@@ -1,7 +0,0 @@
-const handler = async (e, MODELS) =>  {
-  const todos = await MODELS.todo.findAll();
-
-  return { statusCode: 200, body: todos };
-}
-
-export { handler };

package/src/todo/get/valid.js

@@ -1,6 +0,0 @@
-import { z } from 'zod';
-
-const VALIDATOR = (MODELS, ROUTE_CODE) =>
-  z.undefined();
-
-export { VALIDATOR };

package/src/todo/index.js

@@ -1,5 +0,0 @@
-import { modelSchema } from './model.js';
-
-const methods = ['get', 'post', 'delete'];
-
-export { modelSchema, methods };

package/src/todo/model.js

@@ -1,8 +0,0 @@
-export const modelSchema = serviceName => (sequelize, type) => {
-  return sequelize.define(serviceName, {
-    name: {
-      type: type.STRING,
-      allowNull: false
-    },
-  });
-};

package/src/todo/post/handler.js

@@ -1,9 +0,0 @@
-const handler = async (e, MODELS) =>  {
-  const { name } = e.body;
-  
-  const todo = await MODELS.todo.create({ name });
-
-  return { statusCode: 201, body: todo.toJSON() };
-}
-
-export { handler };

package/src/todo/post/valid.js

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-
-const VALIDATOR = (MODELS, ROUTE_CODE) =>
-  z.object({
-    name: z.string(),
-  }).strict();
-
-export { VALIDATOR };

package/test/serviceHandler/registerMethods.test.js

@@ -1,34 +0,0 @@
-import jest from 'jest-mock';
-import path from 'path';
-import { registerMethods } from '../../src/serviceHandler/registerMethods';
-
-describe('registerMethods', () => {
-  beforeAll(() => { process.env.TEST_ENVIRONMENT = true; });
-  afterAll(() => { delete process.env.TEST_ENVIRONMENT; });
-
-  test('should create methods object', async () => {
-    const methods = registerMethods([
-      'serviceHandler/testService/get',
-      'serviceHandler/testService/post',
-      'serviceHandler/testService/delete',
-    ]);
-
-    const result = await methods(path.dirname(import.meta.url));
-    expect(result).toHaveProperty('serviceHandler/testService/get');
-    expect(result).toHaveProperty('serviceHandler/testService/post');
-    expect(result).toHaveProperty('serviceHandler/testService/delete');
-  });
-
-  test('should throw error for invalid path', async () => {
-    const methods = registerMethods(['serviceHandler/testService/invalid']);
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-
-    try {
-      await methods(path.dirname(import.meta.url));
-    } catch (error) {
-      expect(error).toMatch(/Error importing handler or validator/);
-      expect(consoleSpy).toHaveBeenCalled()
-      consoleSpy.mockRestore();
-    }
-  });
-});

package/test/serviceHandler/serviceHandler.test.js

@@ -1,95 +0,0 @@
-import jest from 'jest-mock';
-import { serviceHandler } from '../../src/serviceHandler/serviceHandler.js';
-
-// Mock API object to simulate the behavior of an API (e.g., Express)
-const createMockAPI = () => {
-  const routes = {};
-
-  return {
-    get: (path, handler) => (routes[path] = { method: 'get', handler }),
-    post: (path, handler) => (routes[path] = { method: 'post', handler }),
-    put: (path, handler) => (routes[path] = { method: 'put', handler }),
-    delete: (path, handler) => (routes[path] = { method: 'delete', handler }),
-    routes,
-  };
-};
-
-describe('serviceHandler', () => {
-  beforeAll(() => { process.env.TEST_ENVIRONMENT = true; });
-  afterAll(() => { delete process.env.TEST_ENVIRONMENT; });
-
-  test('should add routes and methods to the API object', async () => {
-    const mockAPI = createMockAPI();
-    const serviceName = 'testService';
-    const SRC_FOLDER = 'test/serviceHandler';
-
-    await serviceHandler(mockAPI, serviceName, SRC_FOLDER);
-
-    // Check if routes are added to the API object
-    expect(mockAPI.routes).toHaveProperty(`/${serviceName}/get`);
-    expect(mockAPI.routes).toHaveProperty(`/${serviceName}/post`);
-    expect(mockAPI.routes).toHaveProperty(`/${serviceName}/delete`);
-
-    // Check if methods are added to the API object
-    expect(mockAPI.routes[`/${serviceName}/get`].method).toBe('get');
-    expect(mockAPI.routes[`/${serviceName}/post`].method).toBe('post');
-    expect(mockAPI.routes[`/${serviceName}/delete`].method).toBe('delete');
-
-    // Check if handlers are added to the API object
-    expect(mockAPI.routes[`/${serviceName}/get`].handler).toBeInstanceOf(Function);
-    expect(mockAPI.routes[`/${serviceName}/post`].handler).toBeInstanceOf(Function);
-    expect(mockAPI.routes[`/${serviceName}/delete`].handler).toBeInstanceOf(Function);
-  });
-
-  test('should call handlers with the correct ROUTE_CODE, req, and res', async () => {
-    const mockAPI = createMockAPI();
-    const serviceName = 'testService';
-    const SRC_FOLDER = 'test/serviceHandler';
-
-    await serviceHandler(mockAPI, serviceName, SRC_FOLDER);
-
-    const mockReq = { foo: 'bar' };
-    const mockRes = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn(),
-    };
-
-    // Call the GET handler
-    await mockAPI.routes[`/${serviceName}/get`].handler(mockReq, mockRes);
-
-    // Check if res.status and res.json are called with the correct values
-    expect(mockRes.status).toHaveBeenCalledWith(200);
-    expect(mockRes.json).toHaveBeenCalledWith('GET method');
-
-    // Call the POST handler
-    await mockAPI.routes[`/${serviceName}/post`].handler(mockReq, mockRes);
-
-    // Check if res.status and res.json are called with the correct values
-    expect(mockRes.status).toHaveBeenCalledWith(200);
-    expect(mockRes.json).toHaveBeenCalledWith('POST method');
-
-    // Call the DELETE handler
-    await mockAPI.routes[`/${serviceName}/delete`].handler(mockReq, mockRes);
-
-    // Check if res.status and res.json are called with the correct values
-    expect(mockRes.status).toHaveBeenCalledWith(200);
-    expect(mockRes.json).toHaveBeenCalledWith('DELETE method');
-  });
-
-  test('should log an error if the serviceHandler fails', async () => {
-    const mockAPI = createMockAPI();
-    const serviceName = 'nonExistentService';
-    const SRC_FOLDER = 'test/serviceHandler';
-
-    // Spy on console.error to check if it's called
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-
-    await serviceHandler(mockAPI, serviceName, SRC_FOLDER);
-
-    // Check if console.error is called
-    expect(consoleSpy).toHaveBeenCalled();
-
-    // Restore the original console.error implementation
-    consoleSpy.mockRestore();
-  });
-});

package/test/serviceHandler/testService/delete/handler.js

@@ -1,3 +0,0 @@
-export const handler =  async () => {
-  return { statusCode: 200, body: 'DELETE method' };
-}

package/test/serviceHandler/testService/delete/valid.js

@@ -1,3 +0,0 @@
-export const VALIDATOR = () => {
-  return { safeParseAsync: async () => { return { success: true } } };
-}

package/test/serviceHandler/testService/get/handler.js

@@ -1,3 +0,0 @@
-export const handler =  async () => {
-  return { statusCode: 200, body: 'GET method' };
-}

package/test/serviceHandler/testService/get/valid.js

@@ -1,3 +0,0 @@
-export const VALIDATOR = () => {
-  return { safeParseAsync: async () => { return { success: true } } };
-}

package/test/serviceHandler/testService/index.js

@@ -1,3 +0,0 @@
-const methods = ['get', 'post', 'delete'];
-
-export { methods };

package/test/serviceHandler/testService/post/handler.js

@@ -1,3 +0,0 @@
-export const handler =  async () => {
-  return { statusCode: 200, body: 'POST method' };
-}

package/test/serviceHandler/testService/post/valid.js

@@ -1,3 +0,0 @@
-export const VALIDATOR = () => {
-  return { safeParseAsync: async () => { return { success: true } } };
-}