minimonolith 0.6.3 → 0.6.4

package/index.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
 import { createAPI } from './src/createAPI/index.js';
-import { runLambdaServer, loadEnvVariables } from './src/server/index.js';
+import { runLambdaServer, loadEnvFile } from './src/server/index.js';
 
-export { runLambdaServer, loadEnvVariables, createAPI, z };
+export { runLambdaServer, loadEnvFile, createAPI, z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "main": "index.js",
   "license": "MIT",
   "scripts": {

package/src/createAPI/apiHandler.js

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

package/src/database/databaseService.js

@@ -0,0 +1,49 @@
+import Sequelize from 'sequelize';
+//import SequelizeDynamo from 'dynamo-sequelize';
+import { loadAndSyncModels } from './loadModels.js';
+
+const ROUTE_CODE = 'DB_CONNECTION';
+
+const createORMInstance = () => {
+  if (process.env.TEST_ENV) return new Sequelize('sqlite::memory:', { logging: false });
+
+  const { DB_DB, DB_USER, DB_PASS, DB_HOST } = process.env;
+  const SEQUELIZE_OPTIONS = { host: DB_HOST, dialect: 'mysql', logging: false };
+
+  if (process.env.DEV_ENV) console.log({ ROUTE_CODE, DB_VARS: { DB_USER, DB_PASS, DB_HOST, DB_DB, }});
+  return new Sequelize(DB_DB, DB_USER, DB_PASS, SEQUELIZE_OPTIONS);
+};
+
+
+const establishConnection = async () => {
+  const MAX_RETRIES = 5, INITIAL_WAIT = 100;
+  let connectionRetries = 0, waitTime = INITIAL_WAIT;
+  const orm = createORMInstance();
+
+  while (connectionRetries < MAX_RETRIES) {
+    try {
+      if (!process.env.TEST_ENV) console.log({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
+      await orm.authenticate();
+      break;
+
+    } catch (DATABASE_CONNECTION_ERROR) {
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+
+      connectionRetries += 1;
+      const jitter = Math.random() * 0.3 + 0.7;
+      waitTime = Math.min(2 * waitTime * jitter, INITIAL_WAIT * Math.pow(2, MAX_RETRIES));
+    }
+  }
+
+  return orm;
+};
+
+const registerDatabaseService = async API => {
+  try {
+    const orm = await establishConnection();
+    API.MODELS = await loadAndSyncModels(orm, Sequelize);
+
+  } catch (DB_ERROR) { console.error({ ROUTE_CODE, DB_ERROR }); }
+};
+
+export { createORMInstance, establishConnection, registerDatabaseService };

package/src/database/index.js

@@ -1,4 +1,4 @@
-import { registerDatabaseService } from './registerDatabaseService.js';
+import { registerDatabaseService } from './databaseService.js';
 import { registerModel } from './loadModels.js';
 
 export { registerDatabaseService, registerModel };

package/src/database/loadModels.js

@@ -18,11 +18,11 @@ const loadModels = (orm, types) => {
 }
 
 const loadAndSyncModels = async (orm, types) => {
-  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'Loading sequelize models');
+  if (!process.env.TEST_ENV) console.log({ ROUTE_CODE, LOADING_MODELS: 'LOADING_MODELS' });
   const MODELS = loadModels(orm, types);
 
-  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'Syncing sequelize');
-  await orm.sync({ alter: process.env.LOCAL ? true : false });
+  if (!process.env.TEST_ENV) console.log({ ROUTE_CODE, SYNCING_ORM: 'SYNCING_ORM' });
+  await orm.sync({ alter: process.env.LOCAL_ENV ? true : false });
 
   return MODELS;
 };

package/src/health/healthService.js

@@ -0,0 +1,13 @@
+const healthHandler = () => {
+  return "API_RUNNING";
+}
+
+const registerHealthService = API => {
+  API.get('/', async (req, res) => {
+    const SERVICE_RESPONSE = healthHandler();
+    if (!process.env.TEST_ENV) console.log({ SERVICE_RESPONSE });
+    return { SERVICE_RESPONSE };
+  });
+}
+
+export { registerHealthService };

package/src/health/index.js

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

package/src/server/index.js

@@ -1,4 +1,4 @@
-import { loadEnvVariables } from './loadEnvVariables.js';
+import { loadEnvFile } from './loadEnvFile.js';
 import { runLambdaServer } from './lambdaServer.js';
 
-export { runLambdaServer, loadEnvVariables };
+export { runLambdaServer, loadEnvFile };

package/src/server/loadEnvFile.js

@@ -0,0 +1,14 @@
+import path from 'path';
+import url from 'url';
+import dotenv from 'dotenv';
+
+import { getProjectRoot } from '../path/index.js';
+
+const loadEnvFile = (ENV_FILE='.env', MODULE_FOLDER='node_modules/') => {
+  const projectRootFileUrl = getProjectRoot(import.meta.url, MODULE_FOLDER);
+  const projectRootPath = url.fileURLToPath(projectRootFileUrl+'/');
+  const envFilePath = path.resolve(projectRootPath, ENV_FILE)
+  dotenv.config({ path: envFilePath });
+};
+
+export { loadEnvFile };

package/src/server/serverHandler.js

@@ -2,15 +2,18 @@
 
 import url from 'url';
 
-const reqBodyPromise = req => {
+const loadBody = req => {
   return new Promise((resolve, reject) => {
-    let data = ''; req.on('data', chunk => { data+=chunk; });
-    req.on('end', () => { data!==''? resolve(data):resolve(null); });
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', () => { resolve(body !== '' ? body : null); });
   });
-}
+};
 
-const parseJWT = token => {
-  return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+const getJWTClaims = authHeader => {
+  const b64JWT = authHeader.split(" ")[1];
+  const b64Claims = b64JWT.split('.')[1];
+  return JSON.parse(Buffer.from(b64Claims, 'base64').toString());
 }
 
 const putCORS = res => {
@@ -20,14 +23,13 @@ const putCORS = res => {
   res.setHeader('Access-Control-Allow-Headers', '*');
 };
 
-const getEvent = (req, queryString, token, body) => {
+const getLambdaEvent = (req, queryString, jwtClaims, body) => {
   return {
     path: req.url,
     httpMethod: req.method,
     queryStringParameters: queryString,
     requestContext: {
-      http: { path: req.url, method: req.method, },
-      authorizer: { jwt: { claims: token }, },
+      authorizer: { jwt: { claims: jwtClaims }, },
     },
     headers: {
       accept: req.headers.accept,
@@ -42,21 +44,22 @@ const getServerHandler = lambdaHandler => async (req, res) => {
     putCORS(res);
     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 authHeader = req.headers.authorization;
+    const jwtClaims = authHeader?.startsWith('Bearer ') ? getJWTClaim(authHeader) : null;
 
     const tempQueryString = url.parse(req.url, true).query;
-    const queryString = tempQueryString? tempQueryString : undefined;
+    const queryString = tempQueryString ? tempQueryString : undefined;
+
+    const tempBody = await loadBody(req);
+    const body = tempBody ? tempBody : undefined;
 
-    const tempBody = await reqBodyPromise(req);
-    const body = tempBody? tempBody : undefined;
+    const lambdaEvent = getLambdaEvent(req, queryString, jwtClaims, body);
+    const lambdaRes = await lambdaHandler(lambdaEvent, null)
 
-    const event = getEvent(req, queryString, token, body);
-    const resL = await lambdaHandler(event, null)
+    res.statusCode = lambdaRes.statusCode;
+    res.end(lambdaRes.body);
 
-    res.statusCode = resL.statusCode;
-    res.end(resL.body);
-  } catch(err) { console.log(err); }
+  } catch(SERVER_ERROR) { console.log({ SERVER_ERROR }); }
 }
 
 export { getServerHandler };

package/src/service/getMethodRouteCode.js

@@ -6,9 +6,9 @@ const getUpperSnakeCase = str => {
 }
 
 const getMethodRouteCode = (SERVICE_NAME, METHOD_NAME) => {
-  const serviceName = getUpperSnakeCase(SERVICE_NAME);
-  const methodName = getUpperSnakeCase(METHOD_NAME);
-  return serviceName + '_' + methodName;
+  const snakeServiceName = getUpperSnakeCase(SERVICE_NAME);
+  const snakeMethodName = getUpperSnakeCase(METHOD_NAME);
+  return snakeServiceName + '_' + snakeMethodName;
 }
 
 export { getMethodRouteCode };

package/src/service/getMethodType.js

@@ -2,10 +2,9 @@ const methodsAvailable = ['post', 'get', 'patch', 'put', 'delete'];
 
 const getMethodType = METHOD_NAME => {
   const methodMatched = METHOD_NAME.match(/^[a-z]*/);
-  if (!methodMatched || !methodsAvailable.includes(methodMatched[0])) {
-    console.log('methodMatched "'+methodMatched[0]+'"');
+  if (!methodMatched || !methodsAvailable.includes(methodMatched[0]))
     throw new Error('UNKNOWN_METHOD_TYPE: ' + METHOD_NAME);
-  }
+
   return methodMatched[0];
 }
 

package/src/service/methodHandler.js

@@ -1,38 +1,22 @@
 import { validationHandler } from './validationHandler.js';
 
-const methodHandlerErrorThrower = async (event, API, METHOD, ROUTE_CODE) => {
-
-  const validationErrorResponse =
-    await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
-  if (validationErrorResponse) return validationErrorResponse;
-
-  const eventContext = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
-  const methodResponse = await METHOD.handler(eventContext);
-
-  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, methodResponse);
-  return methodResponse;
-};
+const methodHandler = async (event, API, METHOD, ROUTE_CODE) => {
+  try {
+    const VALIDATION_ERROR = await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
+    if (VALIDATION_ERROR) {
+      if (!process.env.TEST_ENV) console.error({ ROUTE_CODE, VALIDATION_ERROR });
+      return VALIDATION_ERROR;
+    }
 
-const methodErrorHandler = (METHOD_ERROR, METHOD, ROUTE_CODE) => {
+    const EVENT_CONTEXT = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
+    const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
 
-  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;
-}
+    if (!process.env.TEST_ENV) console.log({ ROUTE_CODE, METHOD_RESPONSE });
+    return METHOD_RESPONSE;
 
-const methodHandler = async (API, METHOD, ROUTE_CODE, event) => {
-  try {
-    if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'ENTERING');
-    const methodResponse = await methodHandlerErrorThrower(event, API, METHOD, ROUTE_CODE);
-    return methodResponse;
   } catch (METHOD_ERROR) {
-    const methodErrorResponse = methodErrorHandler(METHOD_ERROR, METHOD, ROUTE_CODE);
-    return methodErrorResponse;
+    if (!process.env.TEST_ENV) console.error({ ROUTE_CODE, METHOD_ERROR });
+    return { statusCode: 500, body: { ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() } };
   }
 };
 

package/src/service/registerMethods.js

@@ -1,33 +1,26 @@
 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));
+import { getMethodRouteCode } from './getMethodRouteCode.js';
 
-  return {
-    handler: handlerModule.handler,
-    VALIDATOR: validModule.VALIDATOR,
-  };
-};
+const registerMethods = methodNames => async (SERVICE_NAME, SERVICE_URL) => {
+  let ROUTE_CODE = 'REGISTER_METHODS';
+
+  try {
+    const methods = await methodNames.reduce(async (prevMethods, METHOD_NAME) => {
+      ROUTE_CODE = 'CREATE_METHOD_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
+      const methods = await prevMethods;
 
-const registerMethods = methodNames => {
-  return async SERVICE_URL => {
-    const methods = {};
+      const handlerModule = await import(new URL(`./${METHOD_NAME}/handler.js`, SERVICE_URL));
+      const validModule = await import(new URL(`./${METHOD_NAME}/valid.js`, SERVICE_URL));
+      methods[METHOD_NAME] = { handler: handlerModule.handler, VALIDATOR: validModule.VALIDATOR, };
 
-    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;
+    }, Promise.resolve({}));
 
     return methods;
-  };
+  } catch (METHOD_ERROR) {
+    console.error({ ROUTE_CODE, METHOD_ERROR });
+  }
 };
 
 export { registerMethods };

package/src/service/registerService.js

@@ -15,15 +15,15 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
 
     const SERVICE_MODULE = await import(`${SERVICE_URL}index.js`);
     if (SERVICE_MODULE.model) registerModel(SERVICE_NAME, SERVICE_URL);
-    const SERVICE_METHODS = await registerMethods(SERVICE_MODULE.methods)(SERVICE_URL);
+    const SERVICE_METHODS = await registerMethods(SERVICE_MODULE.methods)(SERVICE_NAME, SERVICE_URL);
 
     API.SERVICES[SERVICE_NAME] = {};
     Object.keys(SERVICE_METHODS).forEach(METHOD_NAME => {
 
-      API.SERVICES[SERVICE_NAME][METHOD_NAME] = async (req, res) => {
+      API.SERVICES[SERVICE_NAME][METHOD_NAME] = async (event, res) => {
         const ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
         const { statusCode, body } =
-          await methodHandler(API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE, req);
+          await methodHandler(event, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
         res.status(statusCode).json(body);
       }
 

package/src/service/validationHandler.js

@@ -1,17 +1,12 @@
-const validationHandler = async (e, METHOD, MODELS, ROUTE_CODE) => {
+const validationHandler = async (event, 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 };
-  }
+  const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(event.body);
+  if (validation.success) return;
 
-  return validationErrorResponse;
+  const body = { ROUTE_CODE, VALIDATION_ERROR: validation.error.format() };
+  if (!process.env.TEST_ENV) console.error(body);
+
+  return { statusCode: 400, body };
 };
 
 export { validationHandler };

package/src/database/registerDatabaseService.js

@@ -1,61 +0,0 @@
-import Sequelize from 'sequelize';
-//import SequelizeDynamo from 'dynamo-sequelize';
-import { loadAndSyncModels } from './loadModels.js';
-
-const ROUTE_CODE = 'DB_CONNECTION';
-
-const tryAuthenticating = async (orm, connectionRetries) => {
-  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'Authenticating sequelize intent:', connectionRetries);
-  await orm.authenticate();
-};
-
-const createORMInstance = () => {
-  if (process.env.TEST_ENVIRONMENT) {
-    const orm = new Sequelize('sqlite::memory:');
-    orm.options.logging = false;
-    return orm;
-  } else {
-    const dialect = 'mysql', logging = false, dialectOptions = null;
-    const db=process.env.DB_DB, user=process.env.DB_USER,
-      pass=process.env.DB_PASS, host=process.env.DB_ENDPOINT;
-    console.log(ROUTE_CODE,
-      'Trying to connect using { ' + user + ', ' + pass + ', ' + host + ', ' + db + ' }');
-    return 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;
-  const orm = createORMInstance();
-
-  while (connectionRetries < MAX_RETRIES) {
-    try {
-      await tryAuthenticating(orm, connectionRetries);
-      break;
-    } catch (databaseConnectionError) {
-      await new Promise(resolve => setTimeout(resolve, waitTime));
-      waitTime *= 2; connectionRetries += 1;
-    }
-  }
-
-  return orm;
-};
-
-const registerDatabaseService = async API => {
-  try {
-    const orm = await establishConnection();
-    API.MODELS = await loadAndSyncModels(orm, Sequelize);
-
-  } catch (DB_ERROR) {
-    console.error({
-      ROUTE_CODE,
-      DB_ERROR
-    });
-  }
-};
-
-export { registerDatabaseService };

package/src/health/registerHealthService.js

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

package/src/server/loadEnvVariables.js

@@ -1,13 +0,0 @@
-import dotenv from 'dotenv';
-import path from 'path';
-import url from 'url';
-
-import { getProjectRoot } from '../path/index.js';
-
-const loadEnvVariables = (MODULE_FOLDER='node_modules/') => {
-  const projectRootPath = url.fileURLToPath(getProjectRoot(import.meta.url, MODULE_FOLDER)+'/');
-  const envVarsPath = path.resolve(projectRootPath, '.env')
-  dotenv.config({ path: envVarsPath });
-};
-
-export { loadEnvVariables };