minimonolith 0.26.7 → 0.26.9

package/README.md

@@ -55,9 +55,9 @@ import { getNewAPI } from 'minimonolith';
 
 import todo from './todo/index.js';
 
-const API = await getNewAPI();
+const API = await getNewAPI({ ERROR_LEVEL: 0 });
 
-await API.postModule(todo.name, todo.module, todo.model);
+await API.postModule(todo);
 await API.postDatabaseModule({
   DB_DIALECT: process.env.DB_DIALECT,
   DB_HOST: process.env.DB_HOST,
@@ -72,6 +72,11 @@ await API.postDatabaseModule({
 export const lambdaHandler = await API.getSyncedHandler();
 ```
 
+`ERROR_LEVEL` can be:
+- 0: DEBUG logs
+- 1: INFO logs and below (default)
+- 2: ERROR logs and below
+
 ### todo/index.js
 
 Here, we declare the method handlers for the `todo` module:
@@ -88,7 +93,7 @@ import model from './model.js';
 
 export default {
     name: 'todo',
-    methods: {
+    endpoints: {
         'get': get,
         'post': post,
         'patch:id': patch,·
@@ -98,6 +103,8 @@ export default {
 };
 ```
 
+Modules need to export `name`, `endpoints` and `model` attributes.
+
 ### todo/model.js
 
 In this file, we define a Sequelize model for the `todo` module:
@@ -126,6 +133,9 @@ export default moduleName => (orm, types) => {
 };
 ```
 
+For now every module can have at most one model, which will have the
+same name as the module.
+
 ### todo/get/index.js
 
 This file contains the `get:id` method handler for the `todo` module. It retrieves a todo item by its ID:
@@ -143,6 +153,9 @@ export default async ({ body, MODELS }) =>  {
 }
 ```
 
+Endpoint receive `MODELS`, `MODULES`, `body` and `claims`, and
+can return `body`, `cookies`, `headers` and a custom `status`.
+
 ## Database Authentication
 
 To set up authentication for the database you need to pass necessary variables to postDatabaseModule as at index.js above.

package/index.js

@@ -3,11 +3,12 @@ import SERVER_MODULE from './src/server/index.js';
 import AUTOTEST_MODULE from './src/autotest/index.js';
 
 const { getNewAPI } = API_MODULE;
-const { getServerFactory } = SERVER_MODULE;
+const { getServerFactory, getHttpsServerFactory } = SERVER_MODULE;
 const { getMethodTest } = AUTOTEST_MODULE;
 
 export {
   getServerFactory,
+  getHttpsServerFactory,
   getNewAPI,
   getMethodTest,
 };

package/package.json

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

package/src/api/getNewAPI/index.js

@@ -1,11 +1,17 @@
 import getAPI from '../get/index.js';
+import LOG_MODULE from '../../log/index.js';
+const GREEN = '\x1b[32m', CYAN = '\x1b[36m',
+    YELLOW = '\x1b[33m', END = '\x1b[0m';
 
-export default ({ ERROR_LEVEL=0 } = {}) => {
+export default ({ ERROR_LEVEL = 1 } = {}) => {
   getAPI().MODULES = {};
   getAPI().SCHEMAS = {};
   getAPI().MODELS = {};
   getAPI().ORM = undefined;
   getAPI().ERROR_LEVEL = ERROR_LEVEL;
   getAPI().postCORSMiddleware();
+  LOG_MODULE.postINFO(`API components:`,
+    `(${GREEN}modules${END}, ${CYAN}models${END},`,
+    `${YELLOW}endpoints${END})`);
   return getAPI();
 };

package/src/api/getSyncedHandler/index.js

@@ -3,19 +3,19 @@ import LOG_MODULE from '../../log/index.js';
 
 import getAPI from '../get/index.js';
 
-const META_MODULE='API', META_METHOD='GET_SYNCED_HANDLER', META_ROUTE=META_MODULE+'_'+META_METHOD;
+const META_MODULE='API', META_ENDPOINT='GET_SYNCED_HANDLER',
+    META_ROUTE=META_MODULE+'_'+META_ENDPOINT;
 
 export default async () => {
   getAPI().postErrorMiddleware();
   if (getAPI().ORM) await MODEL_MODULE.getSynced();
 
-  LOG_MODULE.post({ META_ROUTE, INFO: 'LISTENING' });
+  LOG_MODULE.postINFO(`API listening...`);
 
   return async (event, context) => {
-    LOG_MODULE.post({
-      ROUTE_CODE: 'LAMBDA_EVENT',
-      PATH: event.requestContext?.http?.path,
-      METHOD: event.requestContext?.http?.method,
+    LOG_MODULE.postINFO('ENDPOINT request:', {
+      path: event.requestContext?.http?.path,
+      method: event.requestContext?.http?.method,
     });
 
     return await getAPI().run(event, context);

package/src/api/postModule/index.js

@@ -2,28 +2,31 @@ 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 ENDPOINT_MODULE from '../../endpoint/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'
+const META_MODULE_NAME = 'API', META_ENDPOINT_NAME = 'POST_MODULE';
+const GREEN = '\x1b[32m', CYAN = '\x1b[36m',
+    YELLOW = '\x1b[33m', END = '\x1b[0m';
 
-export default async ({ name, methods, model }) => {
+export default async ({ name, endpoints, model }) => {
 
-  LOG_MODULE.post(`${META_MODULE_NAME} ${META_METHOD_NAME} ${GREEN}${name}${END}`);
+  LOG_MODULE.postINFO(`  ${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]);
+    for (const ENDPOINT_KEY in endpoints) {
+      await ENDPOINT_MODULE.post(name, ENDPOINT_KEY,
+          endpoints[ENDPOINT_KEY]);
     }
 
-  } catch (META_METHOD_ERROR) {
-    ERROR_MODULE.postCompiletime({ META_MODULE_NAME, META_METHOD_NAME, META_METHOD_ERROR });
+  } catch (META_ENDPOINT_ERROR) {
+    ERROR_MODULE.postCompiletime({
+        META_MODULE_NAME, META_ENDPOINT_NAME, META_ENDPOINT_ERROR });
   }
 };

package/src/database/post/index.js

@@ -7,15 +7,21 @@ import ERROR_MODULE from '../../error/index.js';
 
 import postConnection from '../postConnection/index.js'
 
-const META_MODULE='DATABASE', META_METHOD='POST', META_ROUTE=META_MODULE+'_'+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:'} = {}) => {
+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)) {
+    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]');
+          '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,
@@ -23,13 +29,15 @@ export default async ({ DB_DIALECT='sqlite', DB_HOST=undefined, DB_PORT=undefine
 
     const DB_VARS = Object.fromEntries(
         Object.entries({
-            DB_DIALECT, DB_HOST, DB_PORT, DB_DB, DB_USER, DB_PASS, DB_STORAGE })
+            DB_DIALECT, DB_HOST, DB_PORT, DB_DB,
+            DB_USER, DB_PASS, DB_STORAGE })
         .filter(([key, val]) => val != null)
     );
 
-    LOG_MODULE.postINFO({ META_ROUTE, DB_VARS });
+    LOG_MODULE.postDEBUG(`DB vars:`, DB_VARS);
 
-    API_MODULE.get().ORM = new Sequelize(DB_DB, DB_USER, DB_PASS, SEQUELIZE_OPTIONS);
+    API_MODULE.get().ORM = new Sequelize(DB_DB, DB_USER,
+        DB_PASS, SEQUELIZE_OPTIONS);
     await postConnection(API_MODULE.get().ORM);
 
   } catch (META_METHOD_ERROR) {

package/src/database/postConnection/index.js

@@ -1,25 +1,39 @@
 import LOG_MODULE from '../../log/index.js';
 
 const META_MODULE_NAME='DATABASE', META_METHOD_NAME='POST_CONNECTION';
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
 
 export default async ORM => {
   const MAX_RETRIES = 5, INITIAL_WAIT = 100;
-  let connectionRetries = 0, waitTime = INITIAL_WAIT;
+  let connectionRetries = 0, waitTime = INITIAL_WAIT, CONNECTED = false;
 
   while (connectionRetries < MAX_RETRIES) {
     try {
-      LOG_MODULE.post({ META_MODULE_NAME, META_METHOD_NAME, AUTH_INTENT: connectionRetries });
+      LOG_MODULE.postINFO(`DB connection attempt:`,
+          `${YELLOW}${connectionRetries}${END}`);
       await ORM.authenticate();
+      CONNECTED = true;
       break;
 
     } catch (META_METHOD_ERROR) {
+      if (connectionRetries >= MAX_RETRIES-1) {
+        break;
+      }
+
       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));
+      waitTime = Math.min(2 * waitTime * jitter,
+          INITIAL_WAIT * Math.pow(2, MAX_RETRIES));
     }
   }
 
+  if (CONNECTED) LOG_MODULE.postINFO(`DB connected`);
+  else {
+    throw new Error(`DB conection attempts ran out `+
+        `${connectionRetries}/${MAX_RETRIES}`);
+  }
+
   return connectionRetries;
 };

package/src/{method/getType → endpoint/getMethod}/index.js

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

package/src/endpoint/getParsedCode/index.js

@@ -0,0 +1,16 @@
+export default (MODULE_NAME, ENDPOINT_CODE) => {
+  const methodPathParts = ENDPOINT_CODE.split(":");
+  const pathParams = methodPathParts.slice(1).map(param => `:${param}`);
+  const rawEndpointName = methodPathParts[0];
+  const ENDPOINT_NAME = rawEndpointName[0] === '!' ?
+        rawEndpointName.substring(1) : rawEndpointName;
+
+  const relativeEndpointRoute =
+    `${rawEndpointName}${pathParams.length > 0 ? '/' : ''}`+
+        `${pathParams.join("/")}`;
+  const ENDPOINT_ROUTE = relativeEndpointRoute[0]==='!' ?
+    `/${relativeEndpointRoute.substring(1)}/${MODULE_NAME}` :
+    `/${MODULE_NAME}/${relativeEndpointRoute}`;
+
+  return { ENDPOINT_NAME,  ENDPOINT_ROUTE };
+};

package/src/endpoint/getResponseCode/index.js

@@ -0,0 +1,10 @@
+const typeToResponseCode = {
+  post: 201,
+  delete: 204,
+}
+
+export default endpointType => {
+  if (endpointType in typeToResponseCode)
+    return typeToResponseCode[endpointType];
+  else return 200;
+}

package/src/{method → endpoint}/getRouteCode/index.js

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

package/src/{method → endpoint}/index.js

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

package/src/endpoint/post/index.js

@@ -0,0 +1,55 @@
+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 getMethod from '../getMethod/index.js';
+import postResponse from '../postResponse/index.js';
+
+const META_MODULE_NAME='ENDPOINT', META_ENDPOINT_NAME='POST';
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
+
+export default async (MODULE_NAME, ENDPOINT_KEY, ENDPOINT) => {
+  const { ENDPOINT_NAME, ENDPOINT_ROUTE }
+        = getParsedCode(MODULE_NAME, ENDPOINT_KEY);
+  const ROUTE_CODE = getRouteCode(MODULE_NAME, ENDPOINT_NAME);
+  //LOG_MODULE.postINFO(
+  //  `  FOUND_ENDPOINT: ${CYAN}${ENDPOINT_NAME}${END}`);
+
+  try {
+
+    // Register service within API
+    API_MODULE.get().MODULES[MODULE_NAME][ENDPOINT_NAME] =
+          async (body, claims=undefined) => {
+
+      const { MODELS, MODULES } = API_MODULE.get();
+      return await ENDPOINT({ MODELS, MODULES, ROUTE_CODE,
+          body, claims });
+    }
+
+    const ENDPOINT_METHOD = getMethod(ENDPOINT_NAME);
+
+    // Register route forn lAMBDA API
+    LOG_MODULE.postINFO(`    ${YELLOW}${ENDPOINT_ROUTE}${END}`);
+
+    API_MODULE.get()[ENDPOINT_METHOD](
+        ENDPOINT_ROUTE, async (event, res) => {
+
+      const { body, claims } = EVENT_MODULE.getParsedEvent(event);
+
+      try {
+        await postResponse(res, ROUTE_CODE, ENDPOINT,
+            ENDPOINT_METHOD, body, claims);
+      }
+      catch (ENDPOINT_ERROR) {
+          ERROR_MODULE.postRuntime(res, ROUTE_CODE, ENDPOINT_ERROR);
+      }
+    });
+
+  } catch (META_ENDPOINT_ERROR) {
+    ERROR_MODULE.postCompiletime({ META_MODULE_NAME,
+        META_ENDPOINT_NAME, ROUTE_CODE, META_ENDPOINT_ERROR });
+  }
+};

package/src/{method → endpoint}/postResponse/index.js

@@ -3,16 +3,19 @@ import LOG_MODULE from '../../log/index.js';
 
 import getResponseCode from '../getResponseCode/index.js';
 
-export default async (res, ROUTE_CODE, METHOD, METHOD_TYPE, body, claims) => {
+export default async (res, ROUTE_CODE, ENDPOINT, ENDPOINT_TYPE,
+    body, claims) => {
 
   const { MODELS, MODULES } = API_MODULE.get();
 
-  const METHOD_RESPONSE = await METHOD({ MODELS, MODULES, body, claims });
-  const { status, body: responseBody, cookies, headers } = METHOD_RESPONSE;
+  const ENDPOINT_RESPONSE =
+        await ENDPOINT({ MODELS, MODULES, body, claims });
+  const { status, body: responseBody, cookies, headers } =
+        ENDPOINT_RESPONSE;
 
   // status
-  let METHOD_RESPONSE_CODE = status;
-  if (!status) METHOD_RESPONSE_CODE = getResponseCode(METHOD_TYPE);
+  let ENDPOINT_RESPONSE_CODE = status;
+  if (!status) ENDPOINT_RESPONSE_CODE = getResponseCode(ENDPOINT_TYPE);
 
   // headers
   if (headers) Object.entries(headers).forEach(([k, v]) => res.header(k, v));
@@ -23,7 +26,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_MODULE.post({ ROUTE_CODE, METHOD_RESPONSE });
+  LOG_MODULE.postINFO(`ENDPOINT response:`, ENDPOINT_RESPONSE);
 
-  res.status(METHOD_RESPONSE_CODE).json(responseBody);
+  res.status(ENDPOINT_RESPONSE_CODE).json(responseBody);
 };

package/src/error/postCompiletime/index.js

@@ -1,13 +1,9 @@
 import API_MODULE from '../../api/index.js';
 import LOG_MODULE from '../../log/index.js';
 
-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_MODULE.get().DEV_ENV==='TRUE') throw META_METHOD_ERROR;
+export default ({ META_METHOD_ERROR }) => {
+  //LOG_MODULE.postERROR({ STACK_TRACE: META_METHOD_ERROR?.stack });
+  //throw META_METHOD_ERROR;
+  console.error(META_METHOD_ERROR?.stack);
+  process.exit(1);
 };

package/src/log/index.js

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

package/src/log/postDEBUG/index.js

@@ -0,0 +1,9 @@
+import API_MODULE from '../../api/index.js';
+
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
+
+export default (...MESSAGE) => {
+    if (API_MODULE.get().ERROR_LEVEL===0) {
+        console.log(`${YELLOW}DEBUG${END}:`, ...MESSAGE);
+    }
+};

package/src/log/postERROR/index.js

@@ -1,3 +1,7 @@
 import API_MODULE from '../../api/index.js';
 
-export default (...ERROR) => { console.error(...ERROR); };
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
+
+export default (...ERROR) => {
+    console.error(...ERROR);
+};

package/src/log/postINFO/index.js

@@ -1,3 +1,9 @@
 import API_MODULE from '../../api/index.js';
 
-export default (...MESSAGE) => { if (API_MODULE.get().ERROR_LEVEL===0) { console.log(...MESSAGE); } };
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
+
+export default (...MESSAGE) => {
+    if (API_MODULE.get().ERROR_LEVEL<=1) {
+        console.log(`${YELLOW}INFO${END}:`, ...MESSAGE);
+    }
+};

package/src/middleware/postCors/index.js

@@ -7,7 +7,7 @@ export default () =>  {
 
   API_MODULE.get().use((req, res, next) => {
     if (req.headers['x-trigger-error']) {
-      LOG_MODULE.post({ ROUTE_CODE: 'LAMBDA_API', MESSAGE: 'X_TRIGGER_ERROR_HEADER' });
+      LOG_MODULE.postINFO('Header de prueba: X_TRIGGER_ERROR_HEADER');
       throw new Error('X_TRIGGER_ERROR_HEADER');
     }
     res.cors(); next();

package/src/model/getSynced/index.js

@@ -3,21 +3,32 @@ import { DataTypes } from 'sequelize';
 import API_MODULE from '../../api/index.js';
 import LOG_MODULE from '../../log/index.js';
 
-const META_MODULE='MODEL', META_METHOD='GET_SYNCED', META_ROUTE=META_MODULE+'_'+META_METHOD;
+const META_MODULE='MODEL', META_METHOD='GET_SYNCED',
+    META_ROUTE=META_MODULE+'_'+META_METHOD;
+const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
 
 export default async () => {
   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);
+
+    LOG_MODULE.postINFO(`DB model being loaded:`,
+        `${CYAN}${MODULE_NAME}${END}`);
+
+    API_MODULE.get().MODELS[MODULE_NAME] =
+          API_MODULE.get().SCHEMAS[MODULE_NAME](
+              API_MODULE.get().ORM, DataTypes);
   }
 
-  for (const [MODULE_NAME, MODEL] of Object.entries(API_MODULE.get().MODELS)) {
-    LOG_MODULE.post({ META_ROUTE, ASSOCIATING: MODULE_NAME });
+  for (const [MODULE_NAME, MODEL] of
+      Object.entries(API_MODULE.get().MODELS)) {
+
+    LOG_MODULE.postINFO(`DB model being associated:`,
+        `${CYAN}${MODULE_NAME}${END}`);
     MODEL.associate(API_MODULE.get().MODELS);
   }
 
-  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 });
+  LOG_MODULE.postINFO('DB synchronizing...');
+  //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' });
+  LOG_MODULE.postINFO('DB synchronized');
 };

package/src/model/post/index.js

@@ -7,10 +7,10 @@ const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
 
 export default async (MODULE_NAME, MODEL) => {
   if (!MODEL) {
-      LOG_MODULE.post('  MODEL_NOT_FOUND')
+      //LOG_MODULE.post('  MODEL_NOT_FOUND')
       return;
   }
 
-  LOG_MODULE.post(`  + MODEL: ${CYAN}${MODULE_NAME}${END}`)
+  LOG_MODULE.postINFO(`    ${CYAN}${MODULE_NAME}${END}`)
   API_MODULE.get().SCHEMAS[MODULE_NAME] = MODEL(MODULE_NAME);
 }

package/src/server/getHttpsServerFactory/index.js

@@ -0,0 +1,13 @@
+import https from 'https';
+
+import getNodejsServerHandler from '../getNodejsServerHandler/index.js';
+
+export default async ({ key, cert }) => {
+
+  return (lambdaHandler) => {
+    const serverHandler = getNodejsServerHandler(lambdaHandler);
+
+    const server = https.createServer({ key, cert }, serverHandler);
+    return server;
+  }
+}

package/src/server/getNodejsServerHandler/index.js

@@ -63,7 +63,7 @@ export default lambdaHandler => async (req, res) => {
     res.end(lambdaRes.body);
 
   } catch(SERVER_ERROR) {
-    LOG_MODULE.post({ SERVER_ERROR });
+    LOG_MODULE.postERROR({ 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/server/index.js

@@ -1,3 +1,4 @@
 import getServerFactory from './getServerFactory/index.js';
+import getHttpsServerFactory from './getHttpsServerFactory/index.js';
 
-export default { getServerFactory };
+export default { getServerFactory, getHttpsServerFactory };

package/src/log/post/index.js

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

package/src/method/getParsedCode/index.js

@@ -1,13 +0,0 @@
-export default (MODULE_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)}/${MODULE_NAME}` :
-    `/${MODULE_NAME}/${relativeMethodRoute}`;
-
-  return { METHOD_NAME,  METHOD_ROUTE };
-};

package/src/method/getResponseCode/index.js

@@ -1,9 +0,0 @@
-const typeToResponseCode = {
-  post: 201,
-  delete: 204,
-}
-
-export default methodType => {
-  if (methodType in typeToResponseCode) return typeToResponseCode[methodType];
-  else return 200;
-}

package/src/method/post/index.js

@@ -1,44 +0,0 @@
-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_MODULE_NAME='METHOD', META_METHOD_NAME='POST';
-const CYAN = '\x1b[36m', YELLOW = '\x1b[33m', END = '\x1b[0m';
-
-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_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_MODULE.post(`  · ${YELLOW}${METHOD_ROUTE}${END}`);
-
-    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_MODULE.postRuntime(res, ROUTE_CODE, METHOD_ERROR); }
-    });
-
-  } catch (META_METHOD_ERROR) {
-    ERROR_MODULE.postCompiletime({ META_MODULE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR });
-  }
-};