minimonolith 0.24.1 → 0.25.4

package/api/postModule/handler.js

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import url from 'url'
+import path from 'path';
+
+import { PATH_MODULE } from '@minimonolith/lib';
+
+export default async ({ body, SERVICES }) => {
+    const moduleName = body.moduleName;
+    const srcFolder = body.srcFolder;
+    const modulesFolder = body.modulesFolder;
+
+    const projectRoot = PATH_MODULE.getProjectRoot(
+        import.meta.url, modulesFolder);
+    const projectRootPath = projectRoot + path.sep;
+    const projectRelativeServicePath = path.join('.',
+        srcFolder, moduleName) + path.sep;
+    //console.log('postmodule', srcFolder, projectRelativeServicePath);
+
+    await SERVICES.api.postRawModule.handler({
+        moduleName, srcFolder, modulesFolder });
+    const moduleURL = new URL(projectRelativeServicePath, projectRootPath);
+    //console.log('postmodule', moduleURL.href);
+    await SERVICES.model.post.handler({ moduleName, moduleURL });
+
+    const apiServices = await SERVICES.api.getServices.handler();
+    for (let serviceName in apiServices[moduleName]) {
+        const serviceCode = apiServices[moduleName][serviceName].code;
+        //console.log('POST_ROUTE', moduleName, serviceCode, apiServices);
+        await SERVICES.service.postRoute.handler({ moduleName, serviceCode });
+    }
+};

package/api/postModule/in.js

@@ -0,0 +1,7 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    srcFolder: z.string().default(''),
+    modulesFolder: z.string().default('node_modules'),
+});

package/api/postORM/handler.js

@@ -0,0 +1,7 @@
+import API from '../api.js';
+
+export default async ({ body }) => {
+    const ORM = body.ORM;
+
+    API().ORM = ORM;
+}

package/api/postORM/in.js

@@ -0,0 +1,5 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    ORM: z.unknown(),
+});

package/api/postRawModule/handler.js

@@ -0,0 +1,9 @@
+import API from '../api.js';
+
+export default async ({ body }) => {
+    const moduleName = body.moduleName;
+    const srcFolder = body.srcFolder;
+    const modulesFolder = body.modulesFolder;
+
+    await API().LIB.postModule(moduleName, srcFolder, modulesFolder);
+};

package/api/postRawModule/in.js

@@ -0,0 +1,9 @@
+import path from 'path';
+
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    srcFolder: z.string().default(''),
+    modulesFolder: z.string().default('node_modules' + path.sep),
+});

package/api/postRoute/handler.js

@@ -0,0 +1,9 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    const method = body.method;
+    const route = body.route;
+    const handler = body.handler;
+
+    API().ROUTES[method](route, handler);
+}

package/api/postRoute/in.js

@@ -0,0 +1,7 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    method: z.string(),
+    route: z.string(),
+    handler: z.function(),
+})

package/api/postSchema/handler.js

@@ -0,0 +1,8 @@
+import API from '../api.js';
+
+export default async ({ body }) => {
+    const moduleName = body.moduleName;
+    const moduleSchema = body.moduleSchema;
+
+    API().SCHEMAS[moduleName] = moduleSchema;
+}

package/api/postSchema/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    moduleSchema: z.unknown(),
+});

package/api/services.js

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

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

@@ -1,12 +1,14 @@
-export default async server => {
-  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/getMethodTest/in.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.unknown();

package/autotest/getMethodTest/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.function();

package/{src/autotest → 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

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

package/control/get/handler.js

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

package/control/get/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    SERVICE_NAME: z.string(),
+    MODULE_URL: z.string(),
+})

package/control/get/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.unknown();

package/control/services.js

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

package/database/post/handler.js

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

package/database/post/in.js

@@ -0,0 +1,12 @@
+import { z } from '@minimonolith/lib';
+
+export default ({ MODELS }) => ({
+    dialect: z.enum(['sqlite', 'mysql', 'mariadb', 'postgres',
+        'mssql', 'snowflake', 'oracle']).default('sqlite'),
+    host: z.string().optional(),
+    user: z.string().optional(),
+    pass: z.string().optional(),
+    port: z.number().optional(),
+    db: z.string().optional(),
+    storage: z.string().default(':memory:'),
+});

package/database/postConnection/handler.js

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

package/database/postConnection/in.js

@@ -0,0 +1,5 @@
+import { z } from '@minimonolith/lib';
+
+export default ({ MODELS }) => ({
+    ORM: z.unknown(),
+});

package/database/postConnection/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default ({ MODELS }) => z.number();

package/database/services.js

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

package/environment/getDBEnvVars/handler.js

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

package/environment/getDBEnvVars/in.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.array(z.string());

package/environment/getDBEnvVars/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.unknown();

package/environment/getENVEnvVars/handler.js

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

package/environment/getENVEnvVars/in.js

@@ -0,0 +1,3 @@
+export default () => ({
+    envVars: z.unknown(),
+})

package/environment/getENVEnvVars/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.unknown();

package/environment/postEnvFile/handler.js

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

package/environment/postEnvFile/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    envFile: z.string(),
+    modulesFolder: z.string(),
+})

package/{src/environment → 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

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

package/{src/error → 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/{src/error → 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/{src/error → 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

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

package/health/services.js

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

package/index.js

@@ -1,15 +1,23 @@
-import API_SERVICE from './src/api/index.js';
-import SERVER_SERVICE from './src/server/index.js';
-import VALIDATION_SERVICE from './src/validation/index.js';
-import AUTOTEST_SERVICE from './src/autotest/index.js';
-
-const { getNewAPI } = API_SERVICE;
-const { getServerFactory } = SERVER_SERVICE;
-const { z, zdb } = VALIDATION_SERVICE;
-const { getMethodTest } = AUTOTEST_SERVICE;
-
-export {
-  getServerFactory, getNewAPI,
-  z, zdb,
-  getMethodTest,
-};
+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/{src/log → 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/{src/log → 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/{src/log → 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/{src/log → 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

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

package/model/post/handler.js

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

package/model/post/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    moduleURL: z.unknown(),
+});

package/model/services.js

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

package/modules.js

@@ -0,0 +1,19 @@
+export default [
+    'api',
+    'server',
+    'environment',
+    'health',
+    'database',
+    'model',
+    'service',
+    'validation',
+    'zdb',
+    'autotest',
+
+    //'log',
+    /*
+    'test',
+    'path',
+    'error',
+    */
+];