minimonolith 0.1.0

package/index.js

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

package/jest.config.js

@@ -0,0 +1,4 @@
+export default {
+  testEnvironment: 'jest-environment-node',
+  transform: {}
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "minimonolith",
+  "type": "module",
+  "version": "0.1.0",
+  "main": "index.js",
+  "license": "MIT",
+  "scripts": {
+    "start:development": "nodemon --inspect=0.0.0.0 ./server.js",
+    "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --coverage"
+  },
+  "dependencies": {
+    "lambda-api": "^1.0.1",
+    "mysql2": "^3.2.0",
+    "sequelize": "^6.30.0",
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "jest": "^29.5.0",
+    "@aws-sdk/client-s3": "^3.304.0",
+    "@aws-sdk/s3-request-presigner": "^3.304.0",
+    "sqlite3": "^5.1.6"
+  }
+}

package/src/databaseHandler/databaseHandler.js

@@ -0,0 +1,87 @@
+import Sequelize from 'sequelize';
+//import SequelizeDynamo from 'dynamo-sequelize';
+import { loadModels } from './modelsHandler.js';
+
+const db = process.env.DB_DB
+const user = process.env.DB_USER;
+const pass = process.env.DB_PASS;
+const host = process.env.DB_ENDPOINT;
+const dialect = 'mysql';
+const logging = false;
+const dialectOptions = null;
+const ROUTE_CODE = 'DB_CONNECTION';
+let sequelize = null;
+let MODELS = null;
+
+const tryAuthenticating = async (connectionRetries) => {
+  if (!process.env.TEST_ENVIRONMENT)
+    console.log(ROUTE_CODE, 'Authenticating sequelize intent:', connectionRetries);
+  await sequelize.authenticate();
+};
+
+const createSequelizeInstance = () => {
+  if (process.env.TEST_ENVIRONMENT) {
+    sequelize = new Sequelize('sqlite::memory:');
+    sequelize.options.logging = false;
+  } else {
+    console.log(ROUTE_CODE, 'Trying to connect using { ' + user + ', ' + pass + ', ' + host + ', ' + db + ' }');
+    sequelize = new Sequelize(db, user, pass, { host, dialect, dialectOptions, logging });
+  }
+};
+
+
+const establishConnection = async () => {
+  const MAX_RETRIES = 5;
+  const INITIAL_WAIT_TIME_MS = 100;
+  let connectionRetries = 0;
+  let waitTime = INITIAL_WAIT_TIME_MS;
+
+  while (connectionRetries < MAX_RETRIES) {
+    try {
+      if (!sequelize) createSequelizeInstance();
+      await tryAuthenticating(connectionRetries);
+      break;
+    } catch (databaseConnectionError) {
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+      waitTime *= 2; connectionRetries += 1;
+      createSequelizeInstance();
+    }
+  }
+
+  return sequelize;
+};
+
+
+const loadAndSyncModels = async () => {
+  if (!process.env.TEST_ENVIRONMENT)
+    console.log(ROUTE_CODE, 'Loading sequelize models');
+  MODELS = loadModels(sequelize, Sequelize);
+
+  if (!process.env.TEST_ENVIRONMENT)
+    console.log(ROUTE_CODE, 'Syncing sequelize');
+  await sequelize.sync({ alter: process.env.LOCAL ? true : false });
+};
+
+const databaseHandler = async () => {
+  try {
+    await establishConnection();
+    await loadAndSyncModels();
+    return { MODELS };
+  } catch (DB_ERROR) {
+    console.error({
+      ROUTE_CODE,
+      DB_ERROR
+    });
+
+    const databaseErrorResponse = {
+      statusCode: 500,
+      body: {
+        ROUTE_CODE,
+        error: DB_ERROR.toString(),
+      },
+    };
+    return { databaseErrorResponse };
+  }
+};
+
+export { databaseHandler };

package/src/databaseHandler/index.js

@@ -0,0 +1,4 @@
+import { databaseHandler } from './databaseHandler.js';
+import { registerModel } from './modelsHandler.js';
+
+export { databaseHandler, registerModel };

package/src/databaseHandler/modelsHandler.js

@@ -0,0 +1,12 @@
+const modelSchemas = {};
+
+export const registerModel = (serviceName, modelSchema) => {
+  modelSchemas[serviceName] = modelSchema(serviceName);
+}
+
+export const loadModels = (orm, types) => {
+  return Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
+    loadedModels[serviceName] = modelSchemas[serviceName](orm, types);
+    return loadedModels;
+  }, {});
+}

package/src/healthCheck/index.js

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

package/src/index.js

@@ -0,0 +1,25 @@
+'use strict';
+
+import createAPI from 'lambda-api';
+import healthCheck from './healthCheck/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 };
+});
+
+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);
+};

package/src/serviceHandler/index.js

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

package/src/serviceHandler/methodHandler.js

@@ -0,0 +1,42 @@
+import { databaseHandler } from '../databaseHandler/index.js';
+import { validationHandler } from './validationHandler.js';
+
+const methodHandlerErrorThrower = async (e, METHOD, ROUTE_CODE) => {
+
+  const { MODELS, databaseErrorResponse } = await databaseHandler(e);
+  if (databaseErrorResponse) return databaseErrorResponse;
+
+  const validationErrorResponse =
+    await validationHandler(e, METHOD, MODELS, ROUTE_CODE);
+  if (validationErrorResponse) return validationErrorResponse;
+
+  const methodResponse = await METHOD.handler(e, MODELS);
+
+  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, methodResponse);
+  return methodResponse;
+};
+
+const methodErrorHandler = (METHOD_ERROR, METHOD, ROUTE_CODE) => {
+
+  if (!process.env.TEST_ENVIRONMENT) console.error({ ROUTE_CODE, METHOD_ERROR });
+  const methodErrorResponse = {
+    statusCode: 500, body: {
+      ROUTE_CODE,
+      METHOD_ERROR: METHOD_ERROR.toString(),
+    }
+  };
+  return methodErrorResponse;
+}
+
+const methodHandler = async (METHOD, ROUTE_CODE, e) => {
+  try {
+    if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'ENTERING');
+    const methodResponse = await methodHandlerErrorThrower(e, METHOD, ROUTE_CODE);
+    return methodResponse;
+  } catch (METHOD_ERROR) {
+    const methodErrorResponse = methodErrorHandler(METHOD_ERROR, METHOD, ROUTE_CODE);
+    return methodErrorResponse;
+  }
+};
+
+export { methodHandler };

package/src/serviceHandler/registerMethods.js

@@ -0,0 +1,33 @@
+import path from 'path';
+
+const registerMethod = async (methodName, SERVICE_URL) => {
+  const handlerModule = await import(new URL(`./${methodName}/handler.js`, SERVICE_URL));
+  const validModule = await import(new URL(`./${methodName}/valid.js`, SERVICE_URL));
+
+  return {
+    handler: handlerModule.handler,
+    VALIDATOR: validModule.VALIDATOR,
+  };
+};
+
+const registerMethods = methodNames => {
+  return async SERVICE_URL => {
+    const methods = {};
+
+    for (const methodName of methodNames) {
+      try {
+        methods[methodName] = await registerMethod(methodName, SERVICE_URL);
+      } catch (CREATE_METHOD_ERROR) {
+        console.error({
+          ROUTE_CODE: 'CREATE_METHOD_ERROR',
+          METHOD_NAME: methodName,
+          CREATE_METHOD_ERROR
+        });
+      }
+    }
+
+    return methods;
+  };
+};
+
+export { registerMethods };

package/src/serviceHandler/serviceHandler.js

@@ -0,0 +1,32 @@
+import url from 'url'
+
+import { registerModel } from '../databaseHandler/modelsHandler.js';
+import { methodHandler } from './methodHandler.js';
+import { registerMethods } from './registerMethods.js';
+
+const serviceHandler = async (API, SERVICE_NAME, SRC_FOLDER='src', MODULE_FOLDER='node_modules') => {
+  try {
+    const SERVICE_URL = new URL(`./${SRC_FOLDER}/${SERVICE_NAME}/`, url.pathToFileURL(process.cwd()+'/'));
+    const SERVICE_MODULE = await import(`${SERVICE_URL}index.js`);
+
+    if (SERVICE_MODULE.modelSchema) registerModel(SERVICE_NAME, SERVICE_MODULE.modelSchema);
+    const SERVICE_METHODS = await registerMethods(SERVICE_MODULE.methods)(SERVICE_URL);
+
+    Object.keys(SERVICE_METHODS).forEach(METHOD_NAME => {
+      API[METHOD_NAME](`/${SERVICE_NAME}/${METHOD_NAME}`, async (req, res) => {
+        const ROUTE_CODE = SERVICE_NAME.toUpperCase()+'_'+METHOD_NAME.toUpperCase();
+        const { statusCode, body } =
+          await methodHandler(SERVICE_METHODS[METHOD_NAME], ROUTE_CODE, req);
+        res.status(statusCode).json(body);
+      });
+    });
+  } catch (SERVICE_HANDLER_ERROR) {
+    console.error({
+      ROUTE_CODE: 'SERVICE_HANDLER_ERROR',
+      SERVICE_NAME,
+      SERVICE_HANDLER_ERROR,
+    });
+  }
+}
+
+export { serviceHandler };

package/src/serviceHandler/validationHandler.js

@@ -0,0 +1,17 @@
+const validationHandler = async (e, METHOD, MODELS, ROUTE_CODE) => {
+
+  let validationErrorResponse = null;
+  const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(e.body);
+  if (!validation.success) {
+    const validationErrorMessage = {
+      ROUTE_CODE,
+      VALIDATION_ERROR: validation.error.format()
+    };
+    console.log(validationErrorMessage);
+    validationErrorResponse = { statusCode: 400, body: validationErrorMessage };
+  }
+
+  return validationErrorResponse;
+};
+
+export { validationHandler };

package/test/serviceHandler/registerMethods.test.js

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,95 @@
+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

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

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

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

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

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

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

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

package/test/serviceHandler/testService/index.js

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

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

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

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

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