minimonolith 0.6.5 → 0.7.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.5",
+  "version": "0.7.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

@@ -4,18 +4,18 @@ 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 });
+      console.error({ ROUTE_CODE, VALIDATION_ERROR: VALIDATION_ERROR.toString() });
       return VALIDATION_ERROR;
     }
 
     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 });
+    console.log({ ROUTE_CODE, METHOD_RESPONSE });
     return METHOD_RESPONSE;
 
   } catch (METHOD_ERROR) {
-    if (!process.env.TEST_ENV) console.error({ ROUTE_CODE, METHOD_ERROR });
+    console.error({ ROUTE_CODE, METHOD_ERROR });
     return { statusCode: 500, body: { ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() } };
   }
 };

package/src/service/registerService.js

@@ -1,7 +1,7 @@
 import url from 'url'
 
 import { getProjectRoot } from '../path/index.js';
-import { registerModel } from '../database/index.js';
+import { registerModel } from '../model/index.js';
 import { methodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
@@ -19,17 +19,20 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
 
     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 => {
+        const eventResponse =
+          await methodHandler({ body }, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
+        return eventResponse.body;
       }
 
       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) => {
+        const { statusCode, body } =
+          await methodHandler(event, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
+        res.status(statusCode).json(body);
+      });
     });
   } catch (SERVICE_HANDLER_ERROR) {
     console.error({

package/src/service/validationHandler.js

@@ -3,7 +3,7 @@ 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, { ROUTE_CODE, VALIDATION_ERROR: validation.error.format() } };
+  return { statusCode: 400, body: { ROUTE_CODE, VALIDATION_ERROR: validation.error.format() } };
 };
 
 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 };