minimonolith 0.6.6 → 0.8.0

package/index.js

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

package/npm_publish.yml

@@ -0,0 +1,32 @@
+name: NPM Publish
+
+on:
+  push:
+    branches:
+      - master # Change this to the branch where you want to trigger the workflow
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18 # Change this to the Node.js version you need
+
+    - name: Install dependencies
+      run: yarn install
+
+    - name: Run tests
+      run: yarn test
+
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v3
+
+    - name: Publish to NPM
+      run: yarn publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} # Set up the NPM_TOKEN in your GitHub repository secrets

package/package.json

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

package/src/{createAPI → api}/createAPI.js

@@ -2,9 +2,12 @@ import lambdaAPICreateAPI from 'lambda-api';
 
 import { registerHealthService } from '../health/index.js';
 import { registerDatabaseService } from '../database/index.js';
+import { loadAndSyncModels } from '../model/index.js';
 import { registerService } from '../service/index.js';
 import { apiHandler } from './apiHandler.js';
 
+const ROUTE_CODE = 'CREATE_API';
+
 const addCORS = API =>  {
   API.use((req, res, next) => { res.cors(); next(); });
   API.use((err, req, res, next) => { res.cors(); next(); });
@@ -18,10 +21,6 @@ const addCORS = API =>  {
   });
 };
 
-const addService = API => {
-
-}
-
 const createAPI = () => {
   const API = lambdaAPICreateAPI();
 
@@ -34,7 +33,11 @@ const createAPI = () => {
 
   API.registerDatabaseService = async () => { await registerDatabaseService(API) };
 
-  API.handler = () => apiHandler(API);
+  API.handler = async () => {
+    if (API.ORM) API.MODELS = await loadAndSyncModels(API);
+    else console.log({ ROUTE_CODE, INFO: 'NO_DATABASE_REGISTERED' });
+    return apiHandler(API);
+  }
 
   API.SERVICES = {};
 

package/src/database/databaseService.js

@@ -1,29 +1,16 @@
 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 establishConnection = async ORM => {
   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();
+      console.log({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
+      await ORM.authenticate();
       break;
 
     } catch (DATABASE_CONNECTION_ERROR) {
@@ -35,15 +22,19 @@ const establishConnection = async () => {
     }
   }
 
-  return orm;
+  return connectionRetries;
 };
 
 const registerDatabaseService = async API => {
   try {
-    const orm = await establishConnection();
-    API.MODELS = await loadAndSyncModels(orm, Sequelize);
+    const { DB_DIALECT, DB_DB, DB_USER, DB_PASS, DB_HOST } = process.env;
+    const SEQUELIZE_OPTIONS = { host: DB_HOST, dialect: DB_DIALECT, logging: false };
+
+    if (!process.env.PROD_ENV) console.log({ ROUTE_CODE, DB_VARS: { DB_USER, DB_PASS, DB_HOST, DB_DB, }});
+    API.ORM = new Sequelize(DB_DB, DB_USER, DB_PASS, SEQUELIZE_OPTIONS);
+    establishConnection(API.ORM);
 
   } catch (DB_ERROR) { console.error({ ROUTE_CODE, DB_ERROR }); }
 };
 
-export { createORMInstance, establishConnection, registerDatabaseService };
+export { establishConnection, registerDatabaseService };

package/src/database/index.js

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

package/src/health/healthService.js

@@ -5,7 +5,7 @@ const healthHandler = () => {
 const registerHealthService = API => {
   API.get('/', async (req, res) => {
     const SERVICE_RESPONSE = healthHandler();
-    if (!process.env.TEST_ENV) console.log({ SERVICE_RESPONSE });
+    console.log({ SERVICE_RESPONSE });
     return { SERVICE_RESPONSE };
   });
 }

package/src/model/index.js

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

package/src/model/loadModels.js

@@ -0,0 +1,27 @@
+import { DataTypes } from 'sequelize';
+
+const ROUTE_CODE = 'LOAD_MODELS';
+
+const modelSchemas = {};
+
+const registerModel = async (SERVICE_NAME, SERVICE_URL) => {
+  const SERVICE_MODEL_MODULE = await import(`${SERVICE_URL}model.js`);
+  modelSchemas[SERVICE_NAME] = SERVICE_MODEL_MODULE.modelSchema(SERVICE_NAME);
+}
+
+const loadAndSyncModels = async API => {
+  console.log({ ROUTE_CODE, LOADING_MODELS: 'LOADING_MODELS' });
+  const MODELS = Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
+    loadedModels[serviceName] = modelSchemas[serviceName](API.ORM, DataTypes);
+    return loadedModels;
+  }, {});
+
+  Object.entries(MODELS).forEach(([serviceName, model]) => { model.associate(MODELS); });
+
+  console.log({ ROUTE_CODE, SYNCING_ORM: 'SYNCING_ORM' });
+  await API.ORM.sync({ alter: process.env.LOCAL_ENV ? true : false });
+
+  return MODELS;
+};
+
+export { registerModel, loadAndSyncModels };

package/src/service/methodHandler.js

@@ -1,23 +1,33 @@
 import { validationHandler } from './validationHandler.js';
 
-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 validatedMethodHandler = async (event, API, METHOD, ROUTE_CODE) => {
+  await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
 
-    const EVENT_CONTEXT = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
-    const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
+  const EVENT_CONTEXT = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
+  const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
 
-    if (!process.env.TEST_ENV) console.log({ ROUTE_CODE, METHOD_RESPONSE });
-    return METHOD_RESPONSE;
+  return METHOD_RESPONSE;
+};
 
-  } catch (METHOD_ERROR) {
-    if (!process.env.TEST_ENV) console.error({ ROUTE_CODE, METHOD_ERROR });
-    return { statusCode: 500, body: { ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() } };
+const exposedMethodHandler = async (event, res, API, METHOD, ROUTE_CODE) => {
+  try {
+    const METHOD_RESPONSE = await validatedMethodHandler(event, API, METHOD, ROUTE_CODE);
+    console.log({ ROUTE_CODE, METHOD_RESPONSE: METHOD_RESPONSE.toString() });
+    //console.log({ ROUTE_CODE, METHOD_RESPONSE: JSON.stringify(METHOD_RESPONSE, null, 2) });
+    res.status(200).json(METHOD_RESPONSE);
+
+  }
+  catch (METHOD_ERROR) {
+    switch (METHOD_ERROR.code) {
+      case 'VALIDATION_ERROR':
+        res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR: METHOD_ERROR.error });
+        break;
+      default:
+        //console.error({ ROUTE_CODE, METHOD_ERROR: JSON.stringify(METHOD_ERROR, null, 2) });
+        console.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
+        res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
+    }
   }
 };
 
-export { methodHandler };
+export { validatedMethodHandler, exposedMethodHandler };

package/src/service/registerMethods.js

@@ -1,4 +1,7 @@
+import fs from 'fs';
+import url from 'url';
 import path from 'path';
+import { z } from 'zod';
 
 import { getMethodRouteCode } from './getMethodRouteCode.js';
 
@@ -7,12 +10,21 @@ const registerMethods = methodNames => async (SERVICE_NAME, SERVICE_URL) => {
 
   try {
     const methods = await methodNames.reduce(async (prevMethods, METHOD_NAME) => {
-      ROUTE_CODE = 'CREATE_METHOD_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
       const methods = await prevMethods;
+      ROUTE_CODE = 'REGISTER_METHODS_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
+      console.log('  FOUND_METHOD', METHOD_NAME);
 
-      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, };
+      methods[METHOD_NAME] = { VALIDATOR: (MODELS, ROUTE_CODE) => z.undefined() };
+      methods[METHOD_NAME].handler =
+        (await import(new URL(`${METHOD_NAME}/handler.js`, SERVICE_URL))).default;
+
+      const VALIDATOR_URL = new URL(`${METHOD_NAME}/valid.js`, SERVICE_URL);
+      if (fs.existsSync(url.fileURLToPath(VALIDATOR_URL))) {
+        console.log('    FOUND_VALIDATOR');
+        const VALIDATOR_BODY = (await import(VALIDATOR_URL)).default;
+        methods[METHOD_NAME].VALIDATOR = (MODELS, ROUTE_CODE) =>
+          z.object(VALIDATOR_BODY(MODELS, ROUTE_CODE)).strict();
+      }
 
       return methods;
     }, Promise.resolve({}));

package/src/service/registerService.js

@@ -1,39 +1,46 @@
+import fs from 'fs';
 import url from 'url'
 
 import { getProjectRoot } from '../path/index.js';
-import { registerModel } from '../database/index.js';
-import { methodHandler } from './methodHandler.js';
+import { registerModel } from '../model/index.js';
+import { exposedMethodHandler, validatedMethodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
 import { registerMethods } from './registerMethods.js';
 
+const ROUTE_CODE = 'REGISTER_SERVICE';
+
 const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) => {
   try {
+    console.log(ROUTE_CODE, SERVICE_NAME);
     const PROJECT_ROOT_PATH = getProjectRoot(import.meta.url, MODULE_FOLDER)+'/';
     const PROJECT_RELATIVE_SERVICE_PATH = './' + SRC_FOLDER + `${SERVICE_NAME}/`;
     const SERVICE_URL = new URL(PROJECT_RELATIVE_SERVICE_PATH, PROJECT_ROOT_PATH);
 
     const SERVICE_MODULE = await import(`${SERVICE_URL}index.js`);
-    if (SERVICE_MODULE.model) registerModel(SERVICE_NAME, SERVICE_URL);
+    if (fs.existsSync(url.fileURLToPath(`${SERVICE_URL}model.js`))) {
+      console.log('  FOUND_MODEL');
+      registerModel(SERVICE_NAME, 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 => {
+      const ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
 
-      API.SERVICES[SERVICE_NAME][METHOD_NAME] = async (event, res) => {
-        const ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
-        const { statusCode, body } =
-          await methodHandler(event, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
-        res.status(statusCode).json(body);
+      API.SERVICES[SERVICE_NAME][METHOD_NAME] = async body => {
+        return await validatedMethodHandler({ body }, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
       }
 
       const methodType = getMethodType(METHOD_NAME);
-      API[methodType](`/${SERVICE_NAME}/${METHOD_NAME}`,
-        API.SERVICES[SERVICE_NAME][METHOD_NAME]);
+      API[methodType](`/${SERVICE_NAME}/${METHOD_NAME}`, async (event, res) => {
+        await exposedMethodHandler(event, res, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
+      });
     });
   } catch (SERVICE_HANDLER_ERROR) {
     console.error({
-      ROUTE_CODE: 'SERVICE_HANDLER_ERROR',
+      ROUTE_CODE,
       SERVICE_NAME,
       SERVICE_HANDLER_ERROR,
     });

package/src/service/validationHandler.js

@@ -3,7 +3,12 @@ const validationHandler = async (event, METHOD, MODELS, ROUTE_CODE) => {
   const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(event.body);
   if (validation.success) return;
 
-  return { statusCode: 400, body: { ROUTE_CODE, VALIDATION_ERROR: validation.error.format() } };
+  const VALIDATION_ERROR = new Error('VALIDATION_ERROR');
+  VALIDATION_ERROR.error = validation.error.format()
+  VALIDATION_ERROR.code = 'VALIDATION_ERROR';
+  console.error({ ROUTE_CODE, VALIDATION_ERROR: VALIDATION_ERROR.error });
+  //console.error({ ROUTE_CODE, VALIDATION_ERROR: JSON.stringify(VALIDATION_ERROR, null, 2) });
+  throw VALIDATION_ERROR;
 };
 
 export { validationHandler };

package/src/database/loadModels.js

@@ -1,30 +0,0 @@
-const ROUTE_CODE = 'LOAD_MODELS';
-
-const modelSchemas = {};
-
-export const registerModel = async (SERVICE_NAME, SERVICE_URL) => {
-  const SERVICE_MODEL_MODULE = await import(`${SERVICE_URL}model.js`);
-  modelSchemas[SERVICE_NAME] = SERVICE_MODEL_MODULE.modelSchema(SERVICE_NAME);
-}
-
-const loadModels = (orm, types) => {
-  const MODELS = Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
-    loadedModels[serviceName] = modelSchemas[serviceName](orm, types);
-    return loadedModels;
-  }, {});
-
-  Object.entries(MODELS).forEach(([serviceName, model]) => { model.associate(MODELS); });
-  return MODELS;
-}
-
-const loadAndSyncModels = async (orm, types) => {
-  if (!process.env.TEST_ENV) console.log({ ROUTE_CODE, LOADING_MODELS: 'LOADING_MODELS' });
-  const MODELS = loadModels(orm, types);
-
-  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;
-};
-
-export { loadAndSyncModels };