minimonolith 0.26.4 → 0.26.5

package/README.md

@@ -2,9 +2,9 @@
 
 [![codecov](https://codecov.io/gh/DeepHackDev/minimonolith-api/branch/master/graph/badge.svg?token=ORFNKKJRSE)](https://codecov.io/gh/DeepHackDev/minimonolith-lib)
 
-`minimonolith` is a lightweight library designed to help you build serverless APIs using AWS Lambda, with a focus on simplicity and ease of use. The library provides a straightforward structure to organize your API's services, methods, validation, and models while handling common tasks like database connection and request validation.
+`minimonolith` is a lightweight library designed to help you build serverless APIs using AWS Lambda, with a focus on simplicity and ease of use. The library provides a straightforward structure to organize your API's modules, methods, validation, and models while handling common tasks like database connection and request validation.
 
-In addition to its simplicity, `minimonolith` enables seamless inter-service communication within your API. This allows services to call one another's functionality without directly importing them, fostering a modular design. For example, you can call the get method of the todo service from the todoList service using SERVICES.todo.get({ id }). By registering services within the API, you can easily call their methods from other services, which not only promotes a clean architecture but also paves the way for future support of automated end-to-end testing.
+In addition to its simplicity, `minimonolith` enables seamless inter-module communication within your API. This allows modules to call one another's functionality without directly importing them, fostering a modular design. For example, you can call the get method of the todo module from the todoList module using MODULES.todo.get({ id }). By registering modules within the API, you can easily call their methods from other modules, which not only promotes a clean architecture but also paves the way for future support of automated end-to-end testing.
 
 ## Example Project
 
@@ -16,12 +16,12 @@ Here's an example project using `minimonolith`:
 ├── .gitignore
 ├── .env
 ├── server.js                  // For local development
-├── index.js                   // Root of the code in a deployed AWS Lambda
+├── index.js                   // Root of the code in a AWS Lambda
 └── todo
-    ├── index.js               // Service 'todo' exported method handlers are declared here
-    ├── model.js               // Optional: Sequelize model for service 'todo' is declared here
+    ├── index.js               // Module 'todo' exported methods
+    ├── model.js               // Optional: Sequelize model for module
     └── get
-        └─── handler.js         // Service 'todo' method 'get' handler
+        └─── handler.js        // Module 'todo' method 'get' handler
 ```
 
 ### server.js
@@ -58,8 +58,8 @@ import todo from './todo/index.js';
 
 const API = await getNewAPI();
 
-await API.postService(todo.name, todo.service, todo.model);
-await API.postDatabaseService({
+await API.postModule(todo.name, todo.module, todo.model);
+await API.postDatabaseModule({
   DB_DIALECT: process.env.DB_DIALECT,
   DB_HOST: process.env.DB_HOST,
   DB_PORT: process.env.DB_PORT,
@@ -74,7 +74,7 @@ export const lambdaHandler = await API.getSyncedHandler();
 
 ### todo/index.js
 
-Here, we declare the method handlers for the `todo` service:
+Here, we declare the method handlers for the `todo` module:
 
 ```js
 // todo/index.js
@@ -88,7 +88,7 @@ import model from './model.js';
 
 export default {
     name: 'todo',
-    service: {
+    module: {
         'get': get,
         'post': post,
         'patch:id': patch,·
@@ -100,12 +100,12 @@ export default {
 
 ### todo/model.js
 
-In this file, we define a Sequelize model for the `todo` service:
+In this file, we define a Sequelize model for the `todo` module:
 
 ```js
 // todo/model.js
-export default serviceName => (orm, types) => {
-  const schema = orm.define(serviceName, {
+export default moduleName => (orm, types) => {
+  const schema = orm.define(moduleName, {
     name: {
       type: types.STRING,
       allowNull: false
@@ -127,7 +127,7 @@ export default serviceName => (orm, types) => {
 
 ### todo/get/index.js
 
-This file contains the `get:id` method handler for the `todo` service. It retrieves a todo item by its ID:
+This file contains the `get:id` method handler for the `todo` module. It retrieves a todo item by its ID:
 
 ```js
 // todo/get/index.js
@@ -158,7 +158,7 @@ export default async ({ body, MODELS }) =>  {
 
 ## Database Authentication
 
-To set up authentication for the database you need to pass necessary variables to postDatabaseService as at index.js above.
+To set up authentication for the database you need to pass necessary variables to postDatabaseModule as at index.js above.
 Assuming using same env variable names as at index.js above
 
 For MySQL:
@@ -179,5 +179,5 @@ For SQLite in memory:
 ```makefile
 DB_DIALECT=sqlite
 DB_DB=<your_database_name>
-DB_STORAGE=:memory: # Need to also pass to API.postDatabaseService()
+DB_STORAGE=:memory: # Need to also pass to API.postDatabaseModule()
 ```

package/index.js

@@ -1,10 +1,10 @@
-import API_SERVICE from './src/api/index.js';
-import SERVER_SERVICE from './src/server/index.js';
-import AUTOTEST_SERVICE from './src/autotest/index.js';
+import API_MODULE from './src/api/index.js';
+import SERVER_MODULE from './src/server/index.js';
+import AUTOTEST_MODULE from './src/autotest/index.js';
 
-const { getNewAPI } = API_SERVICE;
-const { getServerFactory } = SERVER_SERVICE;
-const { getMethodTest } = AUTOTEST_SERVICE;
+const { getNewAPI } = API_MODULE;
+const { getServerFactory } = SERVER_MODULE;
+const { getMethodTest } = AUTOTEST_MODULE;
 
 export {
   getServerFactory,

package/package.json

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

package/src/api/get/index.js

@@ -1,17 +1,17 @@
 import getLambdaAPI from 'lambda-api';
 
-import LOG_SERVICE from '../../log/index.js';
-import DATABASE_SERVICE from '../../database/index.js';
-import MIDDLEWARE_SERVICE from '../../middleware/index.js';
+import LOG_MODULE from '../../log/index.js';
+import DATABASE_MODULE from '../../database/index.js';
+import MIDDLEWARE_MODULE from '../../middleware/index.js';
 
-import postService from '../postService/index.js';
+import postModule from '../postModule/index.js';
 import getSyncedHandler from '../getSyncedHandler/index.js';
 
 const API = getLambdaAPI();
-API.postCORSMiddleware = MIDDLEWARE_SERVICE.postCors;
-API.postService = postService;
-API.postDatabaseService = DATABASE_SERVICE.post;
-API.postErrorMiddleware = MIDDLEWARE_SERVICE.postError;
+API.postCORSMiddleware = MIDDLEWARE_MODULE.postCors;
+API.postModule = postModule;
+API.postDatabaseModule = DATABASE_MODULE.post;
+API.postErrorMiddleware = MIDDLEWARE_MODULE.postError;
 API.getSyncedHandler = getSyncedHandler;
 
 export default () => API;

package/src/api/getNewAPI/index.js

@@ -1,7 +1,7 @@
 import getAPI from '../get/index.js';
 
 export default ({ ERROR_LEVEL=0 } = {}) => {
-  getAPI().SERVICES = {};
+  getAPI().MODULES = {};
   getAPI().SCHEMAS = {};
   getAPI().MODELS = {};
   getAPI().ORM = undefined;

package/src/api/getSyncedHandler/index.js

@@ -1,18 +1,18 @@
-import MODEL_SERVICE from '../../model/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import MODEL_MODULE from '../../model/index.js';
+import LOG_MODULE from '../../log/index.js';
 
 import getAPI from '../get/index.js';
 
-const META_SERVICE='API', META_METHOD='GET_SYNCED_HANDLER', META_ROUTE=META_SERVICE+'_'+META_METHOD;
+const META_MODULE='API', META_METHOD='GET_SYNCED_HANDLER', META_ROUTE=META_MODULE+'_'+META_METHOD;
 
 export default async () => {
   getAPI().postErrorMiddleware();
-  if (getAPI().ORM) await MODEL_SERVICE.getSynced();
+  if (getAPI().ORM) await MODEL_MODULE.getSynced();
 
-  LOG_SERVICE.post({ META_ROUTE, INFO: 'LISTENING' });
+  LOG_MODULE.post({ META_ROUTE, INFO: 'LISTENING' });
 
   return async (event, context) => {
-    LOG_SERVICE.post({
+    LOG_MODULE.post({
       ROUTE_CODE: 'LAMBDA_EVENT',
       PATH: event.requestContext?.http?.path,
       METHOD: event.requestContext?.http?.method,

package/src/api/postModule/index.js

@@ -0,0 +1,29 @@
+import fs from 'fs';
+
+import MODEL_MODULE from '../../model/index.js';
+import LOG_MODULE from '../../log/index.js';
+import METHOD_MODULE from '../../method/index.js';
+import ERROR_MODULE from '../../error/index.js';
+
+import getAPI from '../get/index.js';
+
+const META_MODULE_NAME = 'API', META_METHOD_NAME = 'POST_MODULE';
+const GREEN = '\x1b[32m', END = '\x1b[0m'
+
+export default async ({ name, methods, model }) => {
+
+  LOG_MODULE.post(`${META_MODULE_NAME} ${META_METHOD_NAME} ${GREEN}${name}${END}`);
+
+  getAPI().MODULES[name] = {};
+  try {
+
+    await MODEL_MODULE.post(name, model);
+
+    for (const METHOD_KEY in methods) {
+      await METHOD_MODULE.post(name, METHOD_KEY, methods[METHOD_KEY]);
+    }
+
+  } catch (META_METHOD_ERROR) {
+    ERROR_MODULE.postCompiletime({ META_MODULE_NAME, META_METHOD_NAME, META_METHOD_ERROR });
+  }
+};

package/src/database/post/index.js

@@ -1,13 +1,13 @@
 import Sequelize from 'sequelize';
 //import SequelizeDynamo from 'dynamo-sequelize';
 
-import API_SERVICE  from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
-import ERROR_SERVICE from '../../error/index.js';
+import API_MODULE  from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
+import ERROR_MODULE from '../../error/index.js';
 
 import postConnection from '../postConnection/index.js'
 
-const META_SERVICE='DATABASE', META_METHOD='POST', META_ROUTE=META_SERVICE+'_'+META_METHOD;
+const META_MODULE='DATABASE', META_METHOD='POST', META_ROUTE=META_MODULE+'_'+META_METHOD;
 
 export default async ({ DB_DIALECT='sqlite', DB_HOST=undefined, DB_PORT=undefined, DB_DB=undefined,
   DB_USER=undefined, DB_PASS=undefined, DB_STORAGE=':memory:'} = {}) => {
@@ -27,12 +27,12 @@ export default async ({ DB_DIALECT='sqlite', DB_HOST=undefined, DB_PORT=undefine
         .filter(([key, val]) => val != null)
     );
 
-    LOG_SERVICE.postINFO({ META_ROUTE, DB_VARS });
+    LOG_MODULE.postINFO({ META_ROUTE, DB_VARS });
 
-    API_SERVICE.get().ORM = new Sequelize(DB_DB, DB_USER, DB_PASS, SEQUELIZE_OPTIONS);
-    await postConnection(API_SERVICE.get().ORM);
+    API_MODULE.get().ORM = new Sequelize(DB_DB, DB_USER, DB_PASS, SEQUELIZE_OPTIONS);
+    await postConnection(API_MODULE.get().ORM);
 
   } catch (META_METHOD_ERROR) {
-    ERROR_SERVICE.postCompiletime({ META_ROUTE, META_METHOD_ERROR });
+    ERROR_MODULE.postCompiletime({ META_ROUTE, META_METHOD_ERROR });
   }
 };

package/src/database/postConnection/index.js

@@ -1,6 +1,6 @@
-import LOG_SERVICE from '../../log/index.js';
+import LOG_MODULE from '../../log/index.js';
 
-const META_SERVICE_NAME='DATABASE', META_METHOD_NAME='POST_CONNECTION';
+const META_MODULE_NAME='DATABASE', META_METHOD_NAME='POST_CONNECTION';
 
 export default async ORM => {
   const MAX_RETRIES = 5, INITIAL_WAIT = 100;
@@ -8,7 +8,7 @@ export default async ORM => {
 
   while (connectionRetries < MAX_RETRIES) {
     try {
-      LOG_SERVICE.post({ META_SERVICE_NAME, META_METHOD_NAME, AUTH_INTENT: connectionRetries });
+      LOG_MODULE.post({ META_MODULE_NAME, META_METHOD_NAME, AUTH_INTENT: connectionRetries });
       await ORM.authenticate();
       break;
 

package/src/error/postCompiletime/index.js

@@ -1,13 +1,13 @@
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
 
-export default ({ META_SERVICE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR }) => {
-  LOG_SERVICE.postERROR({
-    META_SERVICE_NAME,
+export default ({ META_MODULE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR }) => {
+  LOG_MODULE.postERROR({
+    META_MODULE_NAME,
     META_METHOD_NAME,
     ROUTE_CODE,
     META_METHOD_ERROR,
     STACK_TRACE: META_METHOD_ERROR?.stack,
   });
-  if (API_SERVICE.get().DEV_ENV==='TRUE') throw META_METHOD_ERROR;
+  if (API_MODULE.get().DEV_ENV==='TRUE') throw META_METHOD_ERROR;
 };

package/src/error/postRuntime/index.js

@@ -1,7 +1,7 @@
-import LOG_SERVICE from '../../log/index.js';
+import LOG_MODULE from '../../log/index.js';
 
 export default (res, ROUTE_CODE, METHOD_ERROR) => {
   const MESSAGE = { ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack.toString() };
-  LOG_SERVICE.postERROR(MESSAGE);
+  LOG_MODULE.postERROR(MESSAGE);
   res.status(500).json(MESSAGE);
 }

package/src/log/post/index.js

@@ -1,3 +1,3 @@
-import API_SERVICE from '../../api/index.js';
+import API_MODULE from '../../api/index.js';
 
 export default (...MESSAGE) => { console.log(...MESSAGE); };

package/src/log/postERROR/index.js

@@ -1,3 +1,3 @@
-import API_SERVICE from '../../api/index.js';
+import API_MODULE from '../../api/index.js';
 
 export default (...ERROR) => { console.error(...ERROR); };

package/src/log/postINFO/index.js

@@ -1,3 +1,3 @@
-import API_SERVICE from '../../api/index.js';
+import API_MODULE from '../../api/index.js';
 
-export default (...MESSAGE) => { if (API_SERVICE.get().ERROR_LEVEL===0) { console.log(...MESSAGE); } };
+export default (...MESSAGE) => { if (API_MODULE.get().ERROR_LEVEL===0) { console.log(...MESSAGE); } };

package/src/method/getParsedCode/index.js

@@ -1,4 +1,4 @@
-export default (SERVICE_NAME, METHOD_CODE) => {
+export default (MODULE_NAME, METHOD_CODE) => {
   const methodPathParts = METHOD_CODE.split(":");
   const pathParams = methodPathParts.slice(1).map(param => `:${param}`);
   const rawMethodName = methodPathParts[0];
@@ -6,8 +6,8 @@ export default (SERVICE_NAME, METHOD_CODE) => {
 
   const relativeMethodRoute = `${rawMethodName}${pathParams.length > 0 ? '/' : ''}${pathParams.join("/")}`;
   const METHOD_ROUTE = relativeMethodRoute[0]==='!' ?
-    `/${relativeMethodRoute.substring(1)}/${SERVICE_NAME}` :
-    `/${SERVICE_NAME}/${relativeMethodRoute}`;
+    `/${relativeMethodRoute.substring(1)}/${MODULE_NAME}` :
+    `/${MODULE_NAME}/${relativeMethodRoute}`;
 
   return { METHOD_NAME,  METHOD_ROUTE };
 };

package/src/method/getRouteCode/index.js

@@ -5,8 +5,8 @@ const getUpperSnakeCase = str => {
     .toUpperCase();
 }
 
-export default (SERVICE_NAME, METHOD_NAME) => {
-  const snakeServiceName = getUpperSnakeCase(SERVICE_NAME);
+export default (MODULE_NAME, METHOD_NAME) => {
+  const snakeServiceName = getUpperSnakeCase(MODULE_NAME);
   const snakeMethodName = getUpperSnakeCase(METHOD_NAME);
   return snakeServiceName + '_' + snakeMethodName;
 };

package/src/method/post/index.js

@@ -1,44 +1,44 @@
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
-import EVENT_SERVICE from '../../event/index.js';
-import ERROR_SERVICE from '../../error/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
+import EVENT_MODULE from '../../event/index.js';
+import ERROR_MODULE from '../../error/index.js';
 
 import getParsedCode from '../getParsedCode/index.js';
 import getRouteCode from '../getRouteCode/index.js';
 import getType from '../getType/index.js';
 import postResponse from '../postResponse/index.js';
 
-const META_SERVICE_NAME='METHOD', META_METHOD_NAME='POST';
+const META_MODULE_NAME='METHOD', META_METHOD_NAME='POST';
 const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
 
-export default async (SERVICE_NAME, METHOD_KEY, METHOD) => {
-  const { METHOD_NAME, METHOD_ROUTE } = getParsedCode(SERVICE_NAME, METHOD_KEY);
-  const ROUTE_CODE = getRouteCode(SERVICE_NAME, METHOD_NAME);
-  //LOG_SERVICE.post(`  FOUND_METHOD: ${CYAN}${METHOD_NAME}${END}`);
+export default async (MODULE_NAME, METHOD_KEY, METHOD) => {
+  const { METHOD_NAME, METHOD_ROUTE } = getParsedCode(MODULE_NAME, METHOD_KEY);
+  const ROUTE_CODE = getRouteCode(MODULE_NAME, METHOD_NAME);
+  //LOG_MODULE.post(`  FOUND_METHOD: ${CYAN}${METHOD_NAME}${END}`);
 
   try {
 
     // Register service within API
-    API_SERVICE.get().SERVICES[SERVICE_NAME][METHOD_NAME] = async (body, claims=undefined) => {
-      const { MODELS, SERVICES } = API_SERVICE.get();
-      return await METHOD({ MODELS, SERVICES, ROUTE_CODE, body, claims });
+    API_MODULE.get().MODULES[MODULE_NAME][METHOD_NAME] = async (body, claims=undefined) => {
+      const { MODELS, MODULES } = API_MODULE.get();
+      return await METHOD({ MODELS, MODULES, ROUTE_CODE, body, claims });
     }
 
     const METHOD_TYPE = getType(METHOD_NAME);
 
     // Register route forn lAMBDA API
-    LOG_SERVICE.post(`  · ${YELLOW}${METHOD_ROUTE}${END}`);
+    LOG_MODULE.post(`  · ${YELLOW}${METHOD_ROUTE}${END}`);
 
-    API_SERVICE.get()[METHOD_TYPE](METHOD_ROUTE, async (event, res) => {
-      const { body, claims } = EVENT_SERVICE.getParsedEvent(event);
+    API_MODULE.get()[METHOD_TYPE](METHOD_ROUTE, async (event, res) => {
+      const { body, claims } = EVENT_MODULE.getParsedEvent(event);
 
       try {
         await postResponse(res, ROUTE_CODE, METHOD, METHOD_TYPE, body, claims);
       }
-      catch (METHOD_ERROR) { ERROR_SERVICE.postRuntime(res, ROUTE_CODE, METHOD_ERROR); }
+      catch (METHOD_ERROR) { ERROR_MODULE.postRuntime(res, ROUTE_CODE, METHOD_ERROR); }
     });
 
   } catch (META_METHOD_ERROR) {
-    ERROR_SERVICE.postCompiletime({ META_SERVICE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR });
+    ERROR_MODULE.postCompiletime({ META_MODULE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR });
   }
 };

package/src/method/postResponse/index.js

@@ -1,13 +1,13 @@
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
 
 import getResponseCode from '../getResponseCode/index.js';
 
 export default async (res, ROUTE_CODE, METHOD, METHOD_TYPE, body, claims) => {
 
-  const { MODELS, SERVICES } = API_SERVICE.get();
+  const { MODELS, MODULES } = API_MODULE.get();
 
-  const METHOD_RESPONSE = await METHOD({ MODELS, SERVICES, body, claims });
+  const METHOD_RESPONSE = await METHOD({ MODELS, MODULES, body, claims });
   const { status, body: responseBody, cookies, headers } = METHOD_RESPONSE;
 
   // status
@@ -23,7 +23,7 @@ export default async (res, ROUTE_CODE, METHOD, METHOD_TYPE, body, claims) => {
         //console.log('cookie', c.name);
         res.cookie(c.name, c.value, c.options || {}); });
 
-  LOG_SERVICE.post({ ROUTE_CODE, METHOD_RESPONSE });
+  LOG_MODULE.post({ ROUTE_CODE, METHOD_RESPONSE });
 
   res.status(METHOD_RESPONSE_CODE).json(responseBody);
 };

package/src/middleware/postCors/index.js

@@ -1,19 +1,19 @@
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
 
 import CORS_HEADERS from './corsHeaders.js';
 
 export default () =>  {
 
-  API_SERVICE.get().use((req, res, next) => {
+  API_MODULE.get().use((req, res, next) => {
     if (req.headers['x-trigger-error']) {
-      LOG_SERVICE.post({ ROUTE_CODE: 'LAMBDA_API', MESSAGE: 'X_TRIGGER_ERROR_HEADER' });
+      LOG_MODULE.post({ ROUTE_CODE: 'LAMBDA_API', MESSAGE: 'X_TRIGGER_ERROR_HEADER' });
       throw new Error('X_TRIGGER_ERROR_HEADER');
     }
     res.cors(); next();
   });
 
-  API_SERVICE.get().options('/*', (req, res) => {
+  API_MODULE.get().options('/*', (req, res) => {
     for (let k in CORS_HEADERS) { res.header(k, CORS_HEADERS[k]); }
     res.status(200).send({})
   });

package/src/middleware/postError/index.js

@@ -1,9 +1,9 @@
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
 
 export default () =>  {
-  API_SERVICE.get().use((err, req, res, next) => {
-    LOG_SERVICE.postERROR({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
+  API_MODULE.get().use((err, req, res, next) => {
+    LOG_MODULE.postERROR({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
     res.cors(); //next();
     res.status(500).send({ ROUTE_CODE: 'LAMBDA_API', ERROR: err.message });
   });

package/src/model/getSynced/index.js

@@ -1,23 +1,23 @@
 import { DataTypes } from 'sequelize';
 
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
 
-const META_SERVICE='MODEL', META_METHOD='GET_SYNCED', META_ROUTE=META_SERVICE+'_'+META_METHOD;
+const META_MODULE='MODEL', META_METHOD='GET_SYNCED', META_ROUTE=META_MODULE+'_'+META_METHOD;
 
 export default async () => {
-  for (const SERVICE_NAME of Object.keys(API_SERVICE.get().SCHEMAS)) {
-    LOG_SERVICE.post({ META_ROUTE, LOADING: SERVICE_NAME });
-    API_SERVICE.get().MODELS[SERVICE_NAME] = API_SERVICE.get().SCHEMAS[SERVICE_NAME](API_SERVICE.get().ORM, DataTypes);
+  for (const MODULE_NAME of Object.keys(API_MODULE.get().SCHEMAS)) {
+    LOG_MODULE.post({ META_ROUTE, LOADING: MODULE_NAME });
+    API_MODULE.get().MODELS[MODULE_NAME] = API_MODULE.get().SCHEMAS[MODULE_NAME](API_MODULE.get().ORM, DataTypes);
   }
 
-  for (const [SERVICE_NAME, MODEL] of Object.entries(API_SERVICE.get().MODELS)) {
-    LOG_SERVICE.post({ META_ROUTE, ASSOCIATING: SERVICE_NAME });
-    MODEL.associate(API_SERVICE.get().MODELS);
+  for (const [MODULE_NAME, MODEL] of Object.entries(API_MODULE.get().MODELS)) {
+    LOG_MODULE.post({ META_ROUTE, ASSOCIATING: MODULE_NAME });
+    MODEL.associate(API_MODULE.get().MODELS);
   }
 
-  LOG_SERVICE.post({ META_ROUTE, SYNCING_ORM: 'WAITING_ORM_SYNCING' });
-  //await API_SERVICE.get().ORM.sync({ alter: process.env.MM_API_DEV_ENV==='TRUE' ? true : false });
-  await API_SERVICE.get().ORM.sync();
-  LOG_SERVICE.post({ META_ROUTE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
+  LOG_MODULE.post({ META_ROUTE, SYNCING_ORM: 'WAITING_ORM_SYNCING' });
+  //await API_MODULE.get().ORM.sync({ alter: process.env.MM_API_DEV_ENV==='TRUE' ? true : false });
+  await API_MODULE.get().ORM.sync();
+  LOG_MODULE.post({ META_ROUTE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
 };

package/src/model/post/index.js

@@ -1,16 +1,16 @@
 import fs from 'fs';
 import url from 'url';
 
-import API_SERVICE from '../../api/index.js';
-import LOG_SERVICE from '../../log/index.js';
+import API_MODULE from '../../api/index.js';
+import LOG_MODULE from '../../log/index.js';
 const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
 
-export default async (SERVICE_NAME, MODEL) => {
+export default async (MODULE_NAME, MODEL) => {
   if (!MODEL) {
-      LOG_SERVICE.post('  MODEL_NOT_FOUND')
+      LOG_MODULE.post('  MODEL_NOT_FOUND')
       return;
   }
 
-  LOG_SERVICE.post(`  + MODEL: ${CYAN}${SERVICE_NAME}${END}`)
-  API_SERVICE.get().SCHEMAS[SERVICE_NAME] = MODEL(SERVICE_NAME);
+  LOG_MODULE.post(`  + MODEL: ${CYAN}${MODULE_NAME}${END}`)
+  API_MODULE.get().SCHEMAS[MODULE_NAME] = MODEL(MODULE_NAME);
 }

package/src/server/getNodejsServerHandler/index.js

@@ -2,7 +2,7 @@
 
 import url from 'url';
 
-import LOG_SERVICE from '../../log/index.js';
+import LOG_MODULE from '../../log/index.js';
 
 import CORS_HEADERS from '../../middleware/postCors/corsHeaders.js';
 
@@ -63,7 +63,7 @@ export default lambdaHandler => async (req, res) => {
     res.end(lambdaRes.body);
 
   } catch(SERVER_ERROR) {
-    LOG_SERVICE.post({ SERVER_ERROR });
+    LOG_MODULE.post({ SERVER_ERROR });
     res.statusCode = 500;
     for (let k in CORS_HEADERS) res.setHeader(k, CORS_HEADERS[k]);
     res.end(JSON.stringify({ REQUEST_PARSING_ERROR: SERVER_ERROR.toString() }));

package/src/api/postService/index.js

@@ -1,29 +0,0 @@
-import fs from 'fs';
-
-import MODEL_SERVICE from '../../model/index.js';
-import LOG_SERVICE from '../../log/index.js';
-import METHOD_SERVICE from '../../method/index.js';
-import ERROR_SERVICE from '../../error/index.js';
-
-import getAPI from '../get/index.js';
-
-const META_SERVICE_NAME = 'API', META_METHOD_NAME = 'POST_SERVICE';
-const GREEN = '\x1b[32m', END = '\x1b[0m'
-
-export default async (SERVICE_NAME, SERVICE, MODEL) => {
-
-  LOG_SERVICE.post(`${META_SERVICE_NAME} ${META_METHOD_NAME} ${GREEN}${SERVICE_NAME}${END}`);
-
-  getAPI().SERVICES[SERVICE_NAME] = {};
-  try {
-
-    await MODEL_SERVICE.post(SERVICE_NAME, MODEL);
-
-    for (const METHOD_KEY in SERVICE) {
-      await METHOD_SERVICE.post(SERVICE_NAME, METHOD_KEY, SERVICE[METHOD_KEY]);
-    }
-
-  } catch (META_METHOD_ERROR) {
-    ERROR_SERVICE.postCompiletime({ META_SERVICE_NAME, META_METHOD_NAME, META_METHOD_ERROR });
-  }
-};