minimonolith 0.25.6 → 0.25.9

package/api/getNewAPI/handler.js

@@ -1,39 +1,32 @@
 import getLambdaAPI from 'lambda-api';
 
-import { getNewLib, /*LOG_SERVICE*/ } from '@minimonolith/lib';
+import { getNewLib } from '@minimonolith/lib';
 
 import { setAPI } from '../api.js';
 
 import CORS_HEADERS from '../corsHeaders.js';
 
 export default async ({ body, SERVICES }) => {
-    const DEV_ENV = body.DEV_ENV;
-    const PROD_ENV = body.PROD_ENV;
-    const TEST_ENV = body.TEST_ENV;
+    //const LOG_LEVEL = body.LOG_LEVEL;
+    const LOG_LEVEL = body;
 
     const API = {
         ROUTES: getLambdaAPI(),
-        //LIB: await getNewLib({ DEBUG: 'TRUE' }),
-        LIB: await getNewLib(),
+        LIB: await getNewLib({ LOG_LEVEL }),
         SCHEMAS: {},
         MODELS: {},
         ORM: undefined,
-        DEV_ENV: DEV_ENV,
-        PROD_ENV: PROD_ENV,
-        TEST_ENV: TEST_ENV,
     };
 
     API.ROUTES.use((req, res, next) => {
         if (req.headers['x-trigger-error']) {
-          /*
-          LOG_SERVICE.post({
+          const MESSAGE ={
               ROUTE_CODE: 'LAMBDA_API',
               MESSAGE: 'X_TRIGGER_ERROR_HEADER'
-          });
-          */
-          throw new Error('X_TRIGGER_ERROR_HEADER');
+          }
+          API.LIB.error(MESSAGE);
+          throw new Error(JSON.stringify(MESSAGE));
         }
-        //console.log('passes here');
         res.cors(); next();
     });
 

package/api/getNewAPI/in.js

@@ -1,7 +1,8 @@
 import { z } from '@minimonolith/lib';
 
+export default () => z.number().default(2);
+/*
 export default () => ({
-    DEV_ENV: z.string().default('FALSE'),
-    PROD_ENV: z.string().default('TRUE'),
-    TEST_ENV: z.string().default('FALSE'),
+    LOG_LEVEL: z.number().default(2),
 });
+*/

package/api/getSyncedHandler/handler.js

@@ -1,13 +1,11 @@
 import getLambdaAPI from 'lambda-api';
-//import { LOG_SERVICE } from '@minimonolith/lib';
 
 import API from '../api.js';
 
 export default async ({ body, ROUTE_CODE, SERVICES }) => {
 
   API().ROUTES.use((err, req, res, next) => {
-    //LOG_SERVICE.postError({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
-    console.log({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
+    API().LIB.error({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
     res.cors(); //next();
     res.status(500).send({ ROUTE_CODE: 'LAMBDA_API', ERROR: err.message });
   });
@@ -16,25 +14,15 @@ export default async ({ body, ROUTE_CODE, SERVICES }) => {
 
   API().LIB.postAdditionalKey('MODELS', API().MODELS);
 
-  //LOG_SERVICE.post({ ROUTE_CODE, INFO: 'LISTENING' });
-  console.log({ ROUTE_CODE, INFO: 'LISTENING' });
+  API().LIB.info({ ROUTE_CODE, INFO: 'LISTENING' });
 
   return async (event, context) => {
-    /*
-    LOG_SERVICE.post({
-      ROUTE_CODE: 'LAMBDA_EVENT',
-      PATH: event.requestContext?.http?.path,
-      METHOD: event.requestContext?.http?.method,
-    });
-    */
-    console.log({
+    API().LIB.info({
       ROUTE_CODE: 'LAMBDA_EVENT',
       PATH: event.requestContext?.http?.path,
       METHOD: event.requestContext?.http?.method,
     });
 
-    //API().ROUTES.routes(true);
-    //return await api.run({ event, context });
     return await API().ROUTES.run(event, context);
   };
 };

package/api/postDebug/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    API().LIB.debug(body);
+}

package/api/postDebug/in.js

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

package/api/postError/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    API().LIB.error(body);
+}

package/api/postError/in.js

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

package/api/postInfo/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    API()?.LIB.info(body);
+}

package/api/postInfo/in.js

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

package/api/services.js

@@ -12,4 +12,7 @@ export default [
     'postSchema',
     'postORM',
     'postModel',
+    'postInfo',
+    'postDebug',
+    'postError',
 ];

package/database/post/handler.js

@@ -1,8 +1,6 @@
 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;
@@ -13,10 +11,12 @@ export default async ({ body, SERVICES, ROUTE }) => {
     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 }});
+    //await SERVICES.api.postDebug.handler({
+    //    'SEQUELIZE_OPTIONS': SEQUELIZE_OPTIONS });
+
+    await SERVICES.api.postDebug.handler({ 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 });

package/database/postConnection/handler.js

@@ -1,6 +1,4 @@
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
-export default async ({ body, ROUTE_CODE }) => {
+export default async ({ body, ROUTE_CODE, SERVICES }) => {
     const ORM = body.ORM;
 
     const MAX_RETRIES = 5, INITIAL_WAIT = 100;
@@ -8,8 +6,8 @@ export default async ({ body, ROUTE_CODE }) => {
 
     while (connectionRetries < MAX_RETRIES) {
         try {
-            //LOG_SERVICE.post({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
-            console.log({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
+            await SERVICES.api.postInfo.handler({
+                ROUTE_CODE, AUTH_INTENT: connectionRetries });
             await ORM.authenticate();
             break;
 

package/environment/postEnvFile/handler.js

@@ -2,7 +2,7 @@ import path from 'path';
 import url from 'url';
 import dotenv from 'dotenv';
 
-import { /*LOG_SERVICE,*/ PATH_MODULE } from '@minimonolith/lib';
+import { PATH_MODULE } from '@minimonolith/lib';
 
 export default async ({ body }) => {
   const envFile = body.envFile;
@@ -10,11 +10,7 @@ export default async ({ body }) => {
 
   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/health/post/handler.js

@@ -1,12 +1,9 @@
-//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 });
+        await SERVICES.api.postInfo.handler({ SERVICE_RESPONSE });
         return { SERVICE_RESPONSE: "API_RUNNING" };
     }
 

package/index.js

@@ -3,8 +3,7 @@ import { getNewLib, z } from '@minimonolith/lib';
 
 import modules from './modules.js';
 
-//const LIB = await getNewLib({ DEBUG: 'TRUE' });
-const LIB = await getNewLib();
+const LIB = await getNewLib({ LOG_LEVEL: 1 );
 
 await Promise.all(modules.map(module => LIB.postModule(
     module,

package/model/getSynced/handler.js

@@ -1,14 +1,12 @@
 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 });
+        await SERVICES.api.postInfo.handler({
+            ROUTE_CODE, LOADING: moduleName });
 
         const model = SCHEMAS[moduleName](ORM, DataTypes);
         await SERVICES.api.postModel.handler({ moduleName, model });
@@ -17,12 +15,15 @@ export default async ({ ROUTE_CODE, SERVICES }) => {
     const MODELS = await SERVICES.api.getModels.handler();
 
     for (const [moduleName, MODEL] of Object.entries(MODELS)) {
-        //LOG_SERVICE.post({ ROUTE_CODE, ASSOCIATING: moduleName });
+        await SERVICES.api.postInfo.handler({
+            ROUTE_CODE, ASSOCIATING: moduleName });
         MODEL.associate(MODELS);
     }
 
-    //LOG_SERVICE.post({ ROUTE_CODE, SYNCING_ORM: 'WAITING_ORM_SYNCING' });
+    await SERVICES.api.postInfo.handler({
+        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' });
+    await SERVICES.api.postInfo.handler({
+        ROUTE_CODE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
 };

package/model/post/handler.js

@@ -1,15 +1,12 @@
 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'] })
+    await SERVICES.api.postInfo.handler(`  FOUND_MODEL ${moduleName}`)
 
     const moduleSchema =
         (await import(`${moduleURL}model.js`)).default(moduleName);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.25.6",
+  "version": "0.25.9",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
@@ -14,7 +14,7 @@
     "sequelize"
   ],
   "dependencies": {
-    "@minimonolith/lib": "^0.13.1",
+    "@minimonolith/lib": "^0.14.2",
     "lambda-api": "^1.0.3",
     "sequelize": "^6.30.0",
     "zod": "^3.21.4"

package/server/getNodejsServerHandler/index.js

@@ -2,8 +2,6 @@
 
 import url from 'url';
 
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
 import CORS_HEADERS from '../../api/corsHeaders.js';
 
 const getBody = req => {
@@ -62,7 +60,7 @@ export default lambdaHandler => async (req, res) => {
 
   } catch(SERVER_ERROR) {
     //LOG_SERVICE.post({ SERVER_ERROR });
-    console.log({ SERVER_ERROR });
+    console.error({ 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/service/getParsedCode/handler.js

@@ -15,11 +15,5 @@ export default ({ body }) => {
       `/${relativeServiceRoute.substring(1)}/${moduleName}` :
       `/${moduleName}/${relativeServiceRoute}`;
 
-    /*
-    console.log('serviceRoute', '['+relativeServiceRoute+']');
-    console.log('serviceRoute',
-        relativeServiceRoute.substring(1), 'fdfd', serviceRoute);
-    */
-
     return { serviceName, serviceRoute };
 };

package/service/postRoute/handler.js

@@ -1,6 +1,3 @@
-//import LOG_SERVICE from '../../log/index.js';
-//import { LOG_SERVICE } from '@minimonolith/lib';
-
 export default async ({ body, ROUTE_CODE, SERVICES }) => {
     const moduleName = body.moduleName;
     const serviceCode = body.serviceCode;
@@ -11,32 +8,28 @@ export default async ({ body, ROUTE_CODE, SERVICES }) => {
     const service =
         await SERVICES.api.getService.handler({ moduleName, serviceName });
 
-    //const method = await SERVICES.service.getType.handler({ serviceName });
     const ADDITIONAL_KEYS = { MODELS: await SERVICES.api.getModels.handler() };
 
     const handler = async (event, res) => {
         const { body: inBody, claims } =
             await SERVICES.service.getParsedEvent.handler({ event });
-        //const service =
-        //    await SERVICES.api.getService.handler({ moduleName, serviceName });
 
         let parsedInBody = inBody;
-        //console.log('service', service);
 
-        //if (service.in) {
+        {
             const validationIn = await SERVICES.validation
                 .getParsedAsync.handler({ ROUTE_CODE: ROUTE_CODE+'_IN',
                     VALIDATOR: service.in, input: inBody });
 
             if (validationIn?.error) {
-                //LOG_SERVICE.post({ VALIDATION_ERROR: validationIn.error });
-                console.log({ VALIDATION_ERROR: validationIn.error });
+                await SERVICES.api.postInfo.handler({
+                    VALIDATION_ERROR: validationIn.error });
                 res.status(400).json(validationIn.error);
                 return;
             }
 
             if (validationIn) parsedInBody = validationIn.parsedBody;
-        //}
+        }
 
         let outBody = undefined;
         try {
@@ -45,8 +38,7 @@ export default async ({ body, ROUTE_CODE, SERVICES }) => {
 
         } catch (SERVICE_ERROR) {
             if (!service.error) {
-                //LOG_SERVICE.post({ SERVICE_ERROR });
-                console.log({ SERVICE_ERROR });
+                await SERVICES.api.postError.handler({ SERVICE_ERROR });
                 res.status(500).json(SERVICE_ERROR);
                 return;
             }
@@ -55,24 +47,23 @@ export default async ({ body, ROUTE_CODE, SERVICES }) => {
         }
 
         let parsedOutBody = outBody;
-        //if (service.out) {
+
+        {
             const validationOut = await SERVICES.validation
                 .getParsedAsync.handler({ ROUTE_CODE: ROUTE_CODE+'_OUT',
                     VALIDATOR: service.out, input: outBody });
 
             if (validationOut?.error) {
-                //LOG_SERVICE.post({ VALIDATION_ERROR: validationOut.error });
-                console.log({ VALIDATION_ERROR: validationOut.error });
+                await SERVICES.api.postInfo.handler({
+                    VALIDATION_ERROR: validationOut.error });
                 res.status(400).json(validationOut.error);
                 return;
             }
 
             if (validationOut) parsedOutBody = validationOut.parsedBody;
-        //}
+        }
 
-        //console.log('method', method);
         const serviceResponseCode =
-            //await SERVICES.service.getResponseCode.handler(method);
             await SERVICES.service.getResponseCode.handler(service.type);
         return res.status(serviceResponseCode).json(parsedOutBody);
     };

package/setupTesting.js

@@ -3,12 +3,10 @@ import { getNewLib, z } from '@minimonolith/lib';
 
 import modules from './modules.js';
 
-//const LIB = await getNewLib({ DEBUG: 'TRUE' });
-const LIB = await getNewLib();
+const LIB = await getNewLib({ LOG_LEVEL: 1 });
 
 await Promise.all(modules.map(module => LIB.postModule(module)));
 
-
 const { SERVICES, COMPONENTS } = LIB;
 const zdb = COMPONENTS.zdb;
 const database = SERVICES.database;

package/validation/getParsedAsync/handler.js

@@ -1,40 +1,36 @@
-import { /*LOG_SERVICE,*/ VALIDATION_MODULE } from '@minimonolith/lib';
+import { VALIDATION_MODULE } from '@minimonolith/lib';
 
 export default async ({ body, SERVICES }) => {
-  const ROUTE_CODE = body.ROUTE_CODE;
-  const VALIDATOR = body.VALIDATOR;
-  const input = body.input;
-  const ADDITIONAL_KEYS = body.ADDITIONAL_KEYS;
-
-  const EVENT_CONTEXT = { SERVICES, body: input };
-  //console.log('EVENT_CONTEXT', EVENT_CONTEXT);
-  console.log('EVENT_CONTEXT\n', '----------------------\n',
-      EVENT_CONTEXT, '\n------------------------');
-
-  if (!VALIDATOR && input) {
-    const MESSAGE = { ROUTE_CODE,
-        VALIDATION_ERROR: JSON.stringify({ message: 'BODY_NOT_ALLOWED' }) };
-    //LOG_MODULE.postError(MESSAGE);
-    console.error(MESSAGE);
-    return { error: MESSAGE };
-  }
-
-  if (!VALIDATOR) return undefined;
-
-  const zodobject = await VALIDATION_MODULE.getZodObject(ROUTE_CODE,
-      VALIDATOR(EVENT_CONTEXT));
-
-  const VALIDATION_RESULT = await VALIDATION_MODULE.getZodObject(ROUTE_CODE,
-      VALIDATOR(EVENT_CONTEXT)).safeParseAsync(input);
-  const VALIDATION_ERROR = VALIDATION_RESULT.error?.format();
-
-  if (VALIDATION_ERROR) {
-    const MESSAGE = { ROUTE_CODE,
-        VALIDATION_ERROR: JSON.stringify(VALIDATION_ERROR) };
-    //LOG_MODULE.postError(MESSAGE);
-    console.error(MESSAGE);
-    return { error: MESSAGE };
-  }
-
-  return { parsedBody: VALIDATION_RESULT.data };
+    const ROUTE_CODE = body.ROUTE_CODE;
+    const VALIDATOR = body.VALIDATOR;
+    const input = body.input;
+    const ADDITIONAL_KEYS = body.ADDITIONAL_KEYS;
+
+    const apiServices = await SERVICES.api.getServices.handler();
+
+    const EVENT_CONTEXT = { SERVICES: apiServices, body: input };
+
+    if (!VALIDATOR && input) {
+        const MESSAGE = { ROUTE_CODE, VALIDATION_ERROR: 'BODY_NOT_ALLOWED' };
+        await SERVICES.api.postInfo.handler(MESSAGE);
+        return { error: MESSAGE };
+    }
+
+    if (!VALIDATOR) return undefined;
+
+    const zodobject = await VALIDATION_MODULE.getZodObject(ROUTE_CODE,
+        VALIDATOR(EVENT_CONTEXT));
+
+    const VALIDATION_RESULT = await VALIDATION_MODULE.getZodObject(ROUTE_CODE,
+        VALIDATOR(EVENT_CONTEXT)).safeParseAsync(input);
+    const VALIDATION_ERROR = VALIDATION_RESULT.error?.format();
+
+    if (VALIDATION_ERROR) {
+        const MESSAGE = { ROUTE_CODE,
+            VALIDATION_ERROR: JSON.stringify(VALIDATION_ERROR) };
+        await SERVICES.api.postInfo.handler(MESSAGE);
+        return { error: MESSAGE };
+    }
+
+    return { parsedBody: VALIDATION_RESULT.data };
 }

package/error/index.js

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

package/error/postCompiletime/index.js

@@ -1,13 +0,0 @@
-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 +0,0 @@
-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/log/index.js

@@ -1,5 +0,0 @@
-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 +0,0 @@
-import API_SERVICE from '../../api/index.js';
-
-export default (...MESSAGE) => { console.log(...MESSAGE); };

package/log/postError/index.js

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

package/log/postQA/index.js

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

package/service/postResponse/index.js

@@ -1,13 +0,0 @@
-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, CONTROLLER, METHOD_TYPE, body, claims) => {
-
-  const { MODELS, SERVICES } = API_SERVICE.get();
-  const METHOD_RESPONSE = await CONTROLLER({ MODELS, SERVICES, body, claims });
-  const METHOD_RESPONSE_CODE = getResponseCode(METHOD_TYPE);
-  LOG_SERVICE.post({ ROUTE_CODE, METHOD_RESPONSE });
-  res.status(METHOD_RESPONSE_CODE).json(METHOD_RESPONSE);
-};