minimonolith 0.25.24 → 0.26.3

package/backtest/todo/post/valid.js

@@ -0,0 +1,5 @@
+import { z, zdb } from '../../../index.js';
+
+export default ({ MODELS }) => ({
+  name: z.string().superRefine(zdb.notExists(MODELS.todo, 'name')),
+});

package/backtest/todo/postSeed/index.js

@@ -0,0 +1,9 @@
+import seed from './seed.js';
+
+export default async ({ MODELS }) => {
+  for (const todo of seed) await MODELS.todo.create(todo);
+
+  const todos = await MODELS.todo.findAll();
+
+  return todos.map((item) => item.toJSON());
+};

package/backtest/todo/postSeed/seed.js

@@ -0,0 +1,4 @@
+export default [
+  { name: 'example1', },
+  { name: 'example2', },
+];

package/backtest/todoCompiletimeError/got/index.js

@@ -0,0 +1 @@
+//export default async () => 'ERROR';

package/backtest/todoCompiletimeError/index.js

@@ -0,0 +1 @@
+export default ['got'];

package/backtest/todoList/delete/handler.js

@@ -0,0 +1,7 @@
+export default async ({ body, MODELS }) =>  {
+
+  const todo = await MODELS.todo.findOne({ where: { id: body.id } });
+  await todo.destroy();
+
+  return undefined;
+}

package/backtest/todoList/delete/valid.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export default (MODELS, ROUTE_CODE) => ({
+  id: z.number(),
+});

package/backtest/todoList/get/handler.js

@@ -0,0 +1,5 @@
+export default async ({ MODELS }) =>  {
+  const todos = await MODELS.todo.findAll();
+
+  return todos;
+}

package/backtest/todoList/index.js

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

package/backtest/todoList/model.js

@@ -0,0 +1,17 @@
+export const modelSchema = serviceName => (orm, types) => {
+  const schema = orm.define(serviceName, {
+    name: {
+      type: types.STRING,
+      allowNull: false
+    },
+  });
+
+  schema.associate = MODELS => {
+    schema.hasMany(MODELS.todo, {
+      foreignKey: 'todoListId',
+      as: 'todoElements',
+    });
+  };
+
+  return schema;
+};

package/backtest/todoList/post/handler.js

@@ -0,0 +1,9 @@
+export default async ({ body, MODELS, SERVICES }) =>  {
+  
+  const todoList = await MODELS.todoList.create({ name: body.name });
+  const todo = SERVICES.todo.post({ name: body.name });
+
+  todoList.addTodoElement(todo);
+
+  return todoList.toJSON();
+};

package/backtest/todoList/post/valid.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export default (MODELS, ROUTE_CODE) => ({
+  name: z.string(),
+});
+

package/backtest/todoRuntimeError/get/index.js

@@ -0,0 +1 @@
+export default async () =>  { throw Error(); }

package/index.js

@@ -1,22 +1,13 @@
-import path from 'path';
-import { getNewLib, z } from '@minimonolith/lib';
-
-import modules from './modules.js';
-
-const LIB = await getNewLib({ LOG_LEVEL: 1 });
-
-await Promise.all(modules.map(module => LIB.postModule(
-    module,
-    'minimonolith' + path.sep,
-    path.join('@minimonolith', 'lib') + path.sep
-)));
-
-
-const { SERVICES, COMPONENTS } = LIB;
-const zdb = COMPONENTS.zdb;
-const database = SERVICES.database;
-const getServerFactory = SERVICES.server.getServerFactory.handler;
-const autotest = SERVICES.autotest;
-const getNewAPI = SERVICES.api.getNewAPI.handler;
-
-export { z, zdb, database, getServerFactory, autotest, getNewAPI };
+import API_SERVICE from './src/api/index.js';
+import SERVER_SERVICE from './src/server/index.js';
+import AUTOTEST_SERVICE from './src/autotest/index.js';
+
+const { getNewAPI } = API_SERVICE;
+const { getServerFactory } = SERVER_SERVICE;
+const { getMethodTest } = AUTOTEST_SERVICE;
+
+export {
+  getServerFactory,
+  getNewAPI,
+  getMethodTest,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.25.24",
+  "version": "0.26.3",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
@@ -10,24 +10,23 @@
   },
   "keywords": [
     "lambda-api",
-    "zod",
     "sequelize"
   ],
   "dependencies": {
-    "@minimonolith/lib": "^0.14.9",
-    "lambda-api": "^1.0.3",
-    "sequelize": "^6.30.0",
-    "dotenv": "^16.0.3",
-    "zod": "^3.23.8"
+    "lambda-api": "^1.0.1",
+    "sequelize": "^6.30.0"
   },
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.304.0",
     "@aws-sdk/s3-request-presigner": "^3.304.0",
+    "@jest/globals": "^30.2.0",
     "cross-env": "^7.0.3",
     "cross-fetch": "^3.1.5",
+    "dotenv": "^16.0.3",
     "jest": "^29.5.0",
     "mysql2": "^3.2.0",
     "nodemon": "^2.0.22",
-    "sqlite3": "^5.1.6"
+    "sqlite3": "^5.1.6",
+    "zod": "^3.21.4"
   }
 }

package/src/api/get/index.js

@@ -0,0 +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 postService from '../postService/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.getSyncedHandler = getSyncedHandler;
+
+export default () => API;

package/src/api/getNewAPI/index.js

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

package/src/api/getSyncedHandler/index.js

@@ -0,0 +1,23 @@
+import MODEL_SERVICE from '../../model/index.js';
+import LOG_SERVICE 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;
+
+export default async () => {
+  getAPI().postErrorMiddleware();
+  if (getAPI().ORM) await MODEL_SERVICE.getSynced();
+
+  LOG_SERVICE.post({ META_ROUTE, INFO: 'LISTENING' });
+
+  return async (event, context) => {
+    LOG_SERVICE.post({
+      ROUTE_CODE: 'LAMBDA_EVENT',
+      PATH: event.requestContext?.http?.path,
+      METHOD: event.requestContext?.http?.method,
+    });
+
+    return await getAPI().run(event, context);
+  };
+};

package/src/api/index.js

@@ -0,0 +1,4 @@
+import get from './get/index.js';
+import getNewAPI from './getNewAPI/index.js';
+
+export default { get, getNewAPI };

package/src/api/postService/index.js

@@ -0,0 +1,29 @@
+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 });
+  }
+};

package/src/autotest/getMethodTest/back.index.js

@@ -0,0 +1,29 @@
+import url from 'url';
+import fetch from 'cross-fetch';
+
+import getTestServerResponse from '../getTestServerResponse/index.js';
+
+export default (serverHandler, expectedCode) => async params => {
+  const URL = new url.URL(params.path, 'http://localhost/');
+
+  const request = {
+    method: params.method,
+    url: URL.pathname + URL.search,
+    headers: {
+      ...params.headers,
+      'Content-Type': 'application/json',
+    },
+    on(eventName, callback) {
+      if (eventName === 'data' && params.body) {
+        callback(Buffer.from(JSON.stringify(params.body)));
+      }
+      if (eventName === 'end') { callback(); }
+    },
+  };
+
+  const response = getTestServerResponse();
+  serverHandler(request, response);
+
+  const result = await response.asyncResult();
+  expect(result.statusCode).toBe(expectedCode);
+}

package/{autotest/getMethodTest/handler.js → src/autotest/getMethodTest/index.js}

@@ -1,6 +1,4 @@
-export default async ({ body }) => {
-  const server = body;
-
+export default async server => {
   const fetch = (await import('cross-fetch')).default;
 
   return async ({ path, method, expectedCode, headers, body }) => {

package/src/autotest/index.js

@@ -0,0 +1,3 @@
+import getMethodTest from './getMethodTest/index.js';
+
+export default { getMethodTest };

package/src/database/index.js

@@ -0,0 +1,4 @@
+import post from './post/index.js';
+import postConnection from './postConnection/index.js';
+
+export default { post, postConnection };

package/src/database/post/index.js

@@ -0,0 +1,38 @@
+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 postConnection from '../postConnection/index.js'
+
+const META_SERVICE='DATABASE', META_METHOD='POST', META_ROUTE=META_SERVICE+'_'+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:'} = {}) => {
+
+  try {
+    if (DB_DIALECT!=='sqlite' && (!DB_HOST || !DB_PORT || !DB_DB || !DB_USER || !DB_PASS)) {
+      throw new Error(
+          'One of these DB parameters not given: [DB_HOST, DB_PORT, DB_DB, DB_USER, DB_PASS]');
+    }
+
+    const SEQUELIZE_OPTIONS = { dialect: DB_DIALECT, host: DB_HOST,
+      port: DB_PORT, storage: DB_STORAGE, logging: false };
+
+    const DB_VARS = Object.fromEntries(
+        Object.entries({
+            DB_DIALECT, DB_HOST, DB_PORT, DB_DB, DB_USER, DB_PASS, DB_STORAGE })
+        .filter(([key, val]) => val != null)
+    );
+
+    LOG_SERVICE.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);
+
+  } catch (META_METHOD_ERROR) {
+    ERROR_SERVICE.postCompiletime({ META_ROUTE, META_METHOD_ERROR });
+  }
+};

package/src/database/postConnection/index.js

@@ -0,0 +1,25 @@
+import LOG_SERVICE from '../../log/index.js';
+
+const META_SERVICE_NAME='DATABASE', META_METHOD_NAME='POST_CONNECTION';
+
+export default async ORM => {
+  const MAX_RETRIES = 5, INITIAL_WAIT = 100;
+  let connectionRetries = 0, waitTime = INITIAL_WAIT;
+
+  while (connectionRetries < MAX_RETRIES) {
+    try {
+      LOG_SERVICE.post({ META_SERVICE_NAME, META_METHOD_NAME, AUTH_INTENT: connectionRetries });
+      await ORM.authenticate();
+      break;
+
+    } catch (META_METHOD_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 connectionRetries;
+};

package/src/error/index.js

@@ -0,0 +1,4 @@
+import postCompiletime from './postCompiletime/index.js';
+import postRuntime from './postRuntime/index.js';
+
+export default { postCompiletime, postRuntime };

package/src/error/postCompiletime/index.js

@@ -0,0 +1,13 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default ({ META_SERVICE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR }) => {
+  LOG_SERVICE.postERROR({
+    META_SERVICE_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;
+};

package/src/error/postRuntime/index.js

@@ -0,0 +1,7 @@
+import LOG_SERVICE 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);
+  res.status(500).json(MESSAGE);
+}

package/src/event/getParsedEvent/index.js

@@ -0,0 +1,9 @@
+export default event => {
+  const { body, params, query, requestContext } = event;
+  const claims = requestContext.authorizer?.jwt?.claims
+
+  const tempUnifiedBody = { ...body, ...params, ...query };
+  const unifiedBody = Object.keys(tempUnifiedBody).length > 0 ? tempUnifiedBody : undefined;
+
+  return { body: unifiedBody, claims };
+}

package/src/event/index.js

@@ -0,0 +1,3 @@
+import getParsedEvent from './getParsedEvent/index.js';
+
+export default { getParsedEvent };

package/src/log/index.js

@@ -0,0 +1,5 @@
+import post from './post/index.js';
+import postERROR from './postERROR/index.js';
+import postINFO from './postINFO/index.js';
+
+export default { post, postERROR, postINFO };

package/src/log/post/index.js

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

package/src/log/postERROR/index.js

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

package/src/log/postINFO/index.js

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

package/src/method/getParsedCode/index.js

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

package/{service/getResponseCode/handler.js → src/method/getResponseCode/index.js}

@@ -3,9 +3,7 @@ const typeToResponseCode = {
   delete: 204,
 }
 
-export default ({ body }) => {
-  const methodType = body;
-
+export default methodType => {
   if (methodType in typeToResponseCode) return typeToResponseCode[methodType];
   else return 200;
 }

package/src/method/getRouteCode/index.js

@@ -0,0 +1,12 @@
+const getUpperSnakeCase = str => {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase();
+}
+
+export default (SERVICE_NAME, METHOD_NAME) => {
+  const snakeServiceName = getUpperSnakeCase(SERVICE_NAME);
+  const snakeMethodName = getUpperSnakeCase(METHOD_NAME);
+  return snakeServiceName + '_' + snakeMethodName;
+};

package/src/method/getType/index.js

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

package/src/method/index.js

@@ -0,0 +1,7 @@
+import post from './post/index.js';
+import getParsedCode from './getParsedCode/index.js';
+import getType from './getType/index.js';
+import getRouteCode from './getRouteCode/index.js';
+import postResponse from './postResponse/index.js';
+
+export default { post, getParsedCode, getType, getRouteCode, postResponse };

package/src/method/post/index.js

@@ -0,0 +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 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 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}`);
+
+  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 });
+    }
+
+    const METHOD_TYPE = getType(METHOD_NAME);
+
+    // Register route forn lAMBDA API
+    LOG_SERVICE.post(`  · ${YELLOW}${METHOD_ROUTE}${END}`);
+
+    API_SERVICE.get()[METHOD_TYPE](METHOD_ROUTE, async (event, res) => {
+      const { body, claims } = EVENT_SERVICE.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 (META_METHOD_ERROR) {
+    ERROR_SERVICE.postCompiletime({ META_SERVICE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR });
+  }
+};

package/src/method/postResponse/index.js

@@ -0,0 +1,29 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE 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 METHOD_RESPONSE = await METHOD({ MODELS, SERVICES, body, claims });
+  const { status, body: responseBody, cookies, headers } = METHOD_RESPONSE;
+
+  // status
+  let METHOD_RESPONSE_CODE = status;
+  if (!status) METHOD_RESPONSE_CODE = getResponseCode(METHOD_TYPE);
+
+  // headers
+  if (headers) Object.entries(headers).forEach(([k, v]) => res.header(k, v));
+
+  // cookies
+  if (cookies && Array.isArray(cookies))
+    cookies.forEach(c => {
+        //console.log('cookie', c.name);
+        res.cookie(c.name, c.value, c.options || {}); });
+
+  LOG_SERVICE.post({ ROUTE_CODE, METHOD_RESPONSE });
+
+  res.status(METHOD_RESPONSE_CODE).json(responseBody);
+};

package/src/middleware/index.js

@@ -0,0 +1,4 @@
+import postCors from './postCors/index.js';
+import postError from './postError/index.js';
+
+export default { postCors, postError };

package/src/middleware/postCors/index.js

@@ -0,0 +1,20 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+import CORS_HEADERS from './corsHeaders.js';
+
+export default () =>  {
+
+  API_SERVICE.get().use((req, res, next) => {
+    if (req.headers['x-trigger-error']) {
+      LOG_SERVICE.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) => {
+    for (let k in CORS_HEADERS) { res.header(k, CORS_HEADERS[k]); }
+    res.status(200).send({})
+  });
+};

package/src/middleware/postError/index.js

@@ -0,0 +1,10 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default () =>  {
+  API_SERVICE.get().use((err, req, res, next) => {
+    LOG_SERVICE.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

@@ -0,0 +1,23 @@
+import { DataTypes } from 'sequelize';
+
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+const META_SERVICE='MODEL', META_METHOD='GET_SYNCED', META_ROUTE=META_SERVICE+'_'+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 [SERVICE_NAME, MODEL] of Object.entries(API_SERVICE.get().MODELS)) {
+    LOG_SERVICE.post({ META_ROUTE, ASSOCIATING: SERVICE_NAME });
+    MODEL.associate(API_SERVICE.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' });
+};