minimonolith 0.25.4 → 0.25.5

package/api/services.js

@@ -1,15 +1,15 @@
-export default [
-    'getNewAPI',
-    'getSyncedHandler',
-    'postModule',
-    'getService',
-    'getServices',
-    'getORM',
-    'getModels',
-    'getSchemas',
-    'postRoute',
-    'postRawModule',
-    'postSchema',
-    'postORM',
-    'postModel',
-];
+export default [
+    'getNewAPI',
+    'getSyncedHandler',
+    'postModule',
+    'getService',
+    'getServices',
+    'getORM',
+    'getModels',
+    'getSchemas',
+    'postRoute',
+    'postRawModule',
+    'postSchema',
+    'postORM',
+    'postModel',
+];

package/autotest/getMethodTest/handler.js

@@ -1,14 +1,14 @@
-export default async ({ body }) => {
-  const server = body;
-
-  const fetch = (await import('cross-fetch')).default;
-
-  return async ({ path, method, expectedCode, headers, body }) => {
-
-    const port = server.address().port
-    const url = `http://localhost:${port}${path}`;
-
-    const response = await fetch(url, { method, headers, body });
-    expect(response.status).toBe(expectedCode);
-  };
-};
+export default async ({ body }) => {
+  const server = body;
+
+  const fetch = (await import('cross-fetch')).default;
+
+  return async ({ path, method, expectedCode, headers, body }) => {
+
+    const port = server.address().port
+    const url = `http://localhost:${port}${path}`;
+
+    const response = await fetch(url, { method, headers, body });
+    expect(response.status).toBe(expectedCode);
+  };
+};

package/autotest/getTestServerResponse/index.js

@@ -1,14 +1,14 @@
-import http from 'http';
-
-export default () => {
-  let resolveAsyncResult;
-  const asyncResultPromise = new Promise(resolve => { resolveAsyncResult = resolve; });
-
-  const res = {
-    statusCode: null,
-    asyncResult: () => asyncResultPromise,
-    end: body => { res.body = body; resolveAsyncResult(res); },
-  };
-
-  return res;
-};
+import http from 'http';
+
+export default () => {
+  let resolveAsyncResult;
+  const asyncResultPromise = new Promise(resolve => { resolveAsyncResult = resolve; });
+
+  const res = {
+    statusCode: null,
+    asyncResult: () => asyncResultPromise,
+    end: body => { res.body = body; resolveAsyncResult(res); },
+  };
+
+  return res;
+};

package/autotest/services.js

@@ -1 +1 @@
-export default ['getMethodTest'];
+export default ['getMethodTest'];

package/control/get/handler.js

@@ -1,8 +1,8 @@
-export default async ({ body }) => {
-    const SERVICE_NAME = body.SERVICE_NAME;
-    const MODULE_URL = body.MODULE_URL;
-
-    const handler = (await import(new URL(`${SERVICE_NAME}/index.js`,
-        MODULE_URL))).default;
-    return handler;
-}
+export default async ({ body }) => {
+    const SERVICE_NAME = body.SERVICE_NAME;
+    const MODULE_URL = body.MODULE_URL;
+
+    const handler = (await import(new URL(`${SERVICE_NAME}/index.js`,
+        MODULE_URL))).default;
+    return handler;
+}

package/control/services.js

@@ -1 +1 @@
-export default ['get'];
+export default ['get'];

package/database/post/handler.js

@@ -1,24 +1,24 @@
-import Sequelize from 'sequelize';
-//import SequelizeDynamo from 'dynamo-sequelize';
-
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
-export default async ({ body, SERVICES, ROUTE }) => {
-    const dialect = body.dialect;
-    const host = body.host;
-    const port = body.port;
-    const user = body.user;
-    const pass = body.pass;
-    const db = body.db;
-    const storage = body.storage;
-
-    const SEQUELIZE_OPTIONS = { dialect, host, port, storage, logging: false };
-    console.log('SEQUELIZE_OPTIONS', SEQUELIZE_OPTIONS);
-
-    //LOG_SERVICE.postQA({ ROUTE, DB_VARS: {
-    //  dialect, host, port, db, user, pass, storage }});
-
-    const ORM = new Sequelize(db, user, pass, SEQUELIZE_OPTIONS);
-    await SERVICES.api.postORM.handler({ ORM });
-    await SERVICES.database.postConnection.handler({ ORM });
-};
+import Sequelize from 'sequelize';
+//import SequelizeDynamo from 'dynamo-sequelize';
+
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+export default async ({ body, SERVICES, ROUTE }) => {
+    const dialect = body.dialect;
+    const host = body.host;
+    const port = body.port;
+    const user = body.user;
+    const pass = body.pass;
+    const db = body.db;
+    const storage = body.storage;
+
+    const SEQUELIZE_OPTIONS = { dialect, host, port, storage, logging: false };
+    console.log('SEQUELIZE_OPTIONS', SEQUELIZE_OPTIONS);
+
+    //LOG_SERVICE.postQA({ ROUTE, DB_VARS: {
+    //  dialect, host, port, db, user, pass, storage }});
+
+    const ORM = new Sequelize(db, user, pass, SEQUELIZE_OPTIONS);
+    await SERVICES.api.postORM.handler({ ORM });
+    await SERVICES.database.postConnection.handler({ ORM });
+};

package/database/postConnection/handler.js

@@ -1,27 +1,27 @@
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
-export default async ({ body, ROUTE_CODE }) => {
-    const ORM = body.ORM;
-
-    const MAX_RETRIES = 5, INITIAL_WAIT = 100;
-    let connectionRetries = 0, waitTime = INITIAL_WAIT;
-
-    while (connectionRetries < MAX_RETRIES) {
-        try {
-            //LOG_SERVICE.post({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
-            console.log({ ROUTE_CODE, 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;
-};
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+export default async ({ body, ROUTE_CODE }) => {
+    const ORM = body.ORM;
+
+    const MAX_RETRIES = 5, INITIAL_WAIT = 100;
+    let connectionRetries = 0, waitTime = INITIAL_WAIT;
+
+    while (connectionRetries < MAX_RETRIES) {
+        try {
+            //LOG_SERVICE.post({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
+            console.log({ ROUTE_CODE, 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/database/services.js

@@ -1 +1 @@
-export default ['post', 'postConnection'];
+export default ['post', 'postConnection'];

package/environment/getDBEnvVars/handler.js

@@ -1,6 +1,6 @@
-export default envVars => {
-  const DB_ENV_VARS = ['DB_DIALECT', 'DB_HOST', 'DB_PORT', 'DB_DB',
-      'DB_USER', 'DB_PASS', 'DB_STORAGE'];
-  return Object.fromEntries(Object.entries(envVars).filter(
-      ([envVar]) => DB_ENV_VARS.includes(envVar)));
-}
+export default envVars => {
+  const DB_ENV_VARS = ['DB_DIALECT', 'DB_HOST', 'DB_PORT', 'DB_DB',
+      'DB_USER', 'DB_PASS', 'DB_STORAGE'];
+  return Object.fromEntries(Object.entries(envVars).filter(
+      ([envVar]) => DB_ENV_VARS.includes(envVar)));
+}

package/environment/getENVEnvVars/handler.js

@@ -1,7 +1,7 @@
-export default ({ body }) => {
-    const envVars = body.envVars;
-
-    const API_ENV_VARS = ['DEV_ENV', 'PROD_ENV', 'TEST_ENV'];
-    return Object.fromEntries(Object.entries(envVars).filter(
-        ([envVar]) => API_ENV_VARS.includes(envVar)));
-}
+export default ({ body }) => {
+    const envVars = body.envVars;
+
+    const API_ENV_VARS = ['DEV_ENV', 'PROD_ENV', 'TEST_ENV'];
+    return Object.fromEntries(Object.entries(envVars).filter(
+        ([envVar]) => API_ENV_VARS.includes(envVar)));
+}

package/environment/postEnvFile/handler.js

@@ -1,20 +1,20 @@
-import path from 'path';
-import url from 'url';
-import dotenv from 'dotenv';
-
-import { /*LOG_SERVICE,*/ PATH_MODULE } from '@minimonolith/lib';
-
-export default async ({ body }) => {
-  const envFile = body.envFile;
-  const modulesFolder = body.modulesFolder;
-
-  const projectRootFileUrl = PATH_MODULE.getProjectRoot(
-      import.meta.url, modulesFolder);
-  console.log('meta url', import.meta.url);
-  console.log('modulesFolder', modulesFolder);
-  const projectRootPath = url.fileURLToPath(projectRootFileUrl + path.sep);
-  console.log('projectRootPath', projectRootPath);
-  const envFilePath = path.resolve(projectRootPath, envFile)
-  console.log('envFilePath', envFilePath);
-  dotenv.config({ path: envFilePath });
-};
+import path from 'path';
+import url from 'url';
+import dotenv from 'dotenv';
+
+import { /*LOG_SERVICE,*/ PATH_MODULE } from '@minimonolith/lib';
+
+export default async ({ body }) => {
+  const envFile = body.envFile;
+  const modulesFolder = body.modulesFolder;
+
+  const projectRootFileUrl = PATH_MODULE.getProjectRoot(
+      import.meta.url, modulesFolder);
+  console.log('meta url', import.meta.url);
+  console.log('modulesFolder', modulesFolder);
+  const projectRootPath = url.fileURLToPath(projectRootFileUrl + path.sep);
+  console.log('projectRootPath', projectRootPath);
+  const envFilePath = path.resolve(projectRootPath, envFile)
+  console.log('envFilePath', envFilePath);
+  dotenv.config({ path: envFilePath });
+};

package/environment/postTestEnvironment/index.js

@@ -1,6 +1,6 @@
-export default () => {
-  process.env.DEV_ENV = 'TRUE';
-  process.env.PROD_ENV = 'FALSE';
-  process.env.DB_DIALECT = 'sqlite';
-  process.env.DB_STORAGE = ':memory:';
-}
+export default () => {
+  process.env.DEV_ENV = 'TRUE';
+  process.env.PROD_ENV = 'FALSE';
+  process.env.DB_DIALECT = 'sqlite';
+  process.env.DB_STORAGE = ':memory:';
+}

package/environment/services.js

@@ -1,5 +1,5 @@
-export default [
-    //'getENVEnvVars',
-    //'getDBEnvVars',
-    'postEnvFile'
-];
+export default [
+    //'getENVEnvVars',
+    //'getDBEnvVars',
+    'postEnvFile'
+];

package/error/index.js

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

package/error/postCompiletime/index.js

@@ -1,13 +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;
-};
+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/error/postRuntime/index.js

@@ -1,7 +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);
-}
+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/health/post/handler.js

@@ -1,14 +1,14 @@
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
-export default async ({ SERVICES }) => {
-    const method = 'get';
-    const route = '/';
-    const handler = async (req, res) => {
-        const SERVICE_RESPONSE = "API_RUNNING";
-        //LOG_SERVICE.post({ SERVICE_RESPONSE });
-        console.log({ SERVICE_RESPONSE });
-        return { SERVICE_RESPONSE: "API_RUNNING" };
-    }
-
-    await SERVICES.api.postRoute.handler({ method, route, handler })
-}
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+export default async ({ SERVICES }) => {
+    const method = 'get';
+    const route = '/';
+    const handler = async (req, res) => {
+        const SERVICE_RESPONSE = "API_RUNNING";
+        //LOG_SERVICE.post({ SERVICE_RESPONSE });
+        console.log({ SERVICE_RESPONSE });
+        return { SERVICE_RESPONSE: "API_RUNNING" };
+    }
+
+    await SERVICES.api.postRoute.handler({ method, route, handler })
+}

package/health/services.js

@@ -1 +1 @@
-export default ['post'];
+export default ['post'];

package/index.js

@@ -1,23 +1,23 @@
-import path from 'path';
-import { getNewLib, z } from '@minimonolith/lib';
-
-import modules from './modules.js';
-
-//const LIB = await getNewLib({ DEBUG: 'TRUE' });
-const LIB = await getNewLib();
-
-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 path from 'path';
+import { getNewLib, z } from '@minimonolith/lib';
+
+import modules from './modules.js';
+
+//const LIB = await getNewLib({ DEBUG: 'TRUE' });
+const LIB = await getNewLib();
+
+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 };

package/log/index.js

@@ -1,5 +1,5 @@
-import post from './post/index.js';
-import postError from './postError/index.js';
-import postQA from './postQA/index.js';
-
-export default { post, postError, postQA };
+import post from './post/index.js';
+import postError from './postError/index.js';
+import postQA from './postQA/index.js';
+
+export default { post, postError, postQA };

package/log/post/index.js

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

package/log/postError/index.js

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

package/log/postQA/index.js

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

package/model/getSynced/handler.js

@@ -1,28 +1,28 @@
-import { DataTypes } from 'sequelize';
-
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
-export default async ({ ROUTE_CODE, SERVICES }) => {
-    const SCHEMAS = await SERVICES.api.getSchemas.handler();
-    const ORM = await SERVICES.api.getORM.handler();
-
-    //for (const moduleName of SCHEMAS) {
-    for (const moduleName of Object.keys(SCHEMAS)) {
-        //LOG_SERVICE.post({ ROUTE_CODE, LOADING: moduleName });
-
-        const model = SCHEMAS[moduleName](ORM, DataTypes);
-        await SERVICES.api.postModel.handler({ moduleName, model });
-    }
-
-    const MODELS = await SERVICES.api.getModels.handler();
-
-    for (const [moduleName, MODEL] of Object.entries(MODELS)) {
-        //LOG_SERVICE.post({ ROUTE_CODE, ASSOCIATING: moduleName });
-        MODEL.associate(MODELS);
-    }
-
-    //LOG_SERVICE.post({ ROUTE_CODE, SYNCING_ORM: 'WAITING_ORM_SYNCING' });
-    await ORM.sync({ alter: process.env.DEV_ENV==='TRUE' ? true : false });
-
-    //LOG_SERVICE.post({ ROUTE_CODE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
-};
+import { DataTypes } from 'sequelize';
+
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+export default async ({ ROUTE_CODE, SERVICES }) => {
+    const SCHEMAS = await SERVICES.api.getSchemas.handler();
+    const ORM = await SERVICES.api.getORM.handler();
+
+    //for (const moduleName of SCHEMAS) {
+    for (const moduleName of Object.keys(SCHEMAS)) {
+        //LOG_SERVICE.post({ ROUTE_CODE, LOADING: moduleName });
+
+        const model = SCHEMAS[moduleName](ORM, DataTypes);
+        await SERVICES.api.postModel.handler({ moduleName, model });
+    }
+
+    const MODELS = await SERVICES.api.getModels.handler();
+
+    for (const [moduleName, MODEL] of Object.entries(MODELS)) {
+        //LOG_SERVICE.post({ ROUTE_CODE, ASSOCIATING: moduleName });
+        MODEL.associate(MODELS);
+    }
+
+    //LOG_SERVICE.post({ ROUTE_CODE, SYNCING_ORM: 'WAITING_ORM_SYNCING' });
+    await ORM.sync({ alter: process.env.DEV_ENV==='TRUE' ? true : false });
+
+    //LOG_SERVICE.post({ ROUTE_CODE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
+};

package/model/post/handler.js

@@ -1,17 +1,17 @@
-import fs from 'fs';
-import url from 'url';
-
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
-export default async ({ body, SERVICES }) => {
-    const moduleName = body.moduleName;
-    const moduleURL = body.moduleURL;
-
-    console.log('moduleURL', moduleURL);
-    if (!fs.existsSync(url.fileURLToPath(`${moduleURL}model.js`))) return;
-    //LOG_SERVICE.post({ messages: ['  FOUND_MODEL'] })
-
-    const moduleSchema =
-        (await import(`${moduleURL}model.js`)).default(moduleName);
-    await SERVICES.api.postSchema.handler({ moduleName, moduleSchema });
-};
+import fs from 'fs';
+import url from 'url';
+
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+export default async ({ body, SERVICES }) => {
+    const moduleName = body.moduleName;
+    const moduleURL = body.moduleURL;
+
+    console.log('moduleURL', moduleURL);
+    if (!fs.existsSync(url.fileURLToPath(`${moduleURL}model.js`))) return;
+    //LOG_SERVICE.post({ messages: ['  FOUND_MODEL'] })
+
+    const moduleSchema =
+        (await import(`${moduleURL}model.js`)).default(moduleName);
+    await SERVICES.api.postSchema.handler({ moduleName, moduleSchema });
+};

package/model/services.js

@@ -1 +1 @@
-export default ['getSynced', 'post'];
+export default ['getSynced', 'post'];