minimonolith 0.15.5 → 0.17.0

package/index.js

@@ -1,10 +1,9 @@
-import { z } from 'zod';
-
+import { z } from './src/zod/index.js';
 import { createAPI } from './src/api/index.js';
 import { DB_VALIDATION } from './src/database/index.js';
 
-const devEnvironment = async () => {
-  return await import('./src/local/index.js');
+const createDevEnvironment = async () => {
+  return await import('./src/development/index.js');
 }
 
-export { devEnvironment, createAPI, z, DB_VALIDATION };
+export { createDevEnvironment, createAPI, z, DB_VALIDATION };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.15.5",
+  "version": "0.17.0",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
-    "start:development": "nodemon --inspect=0.0.0.0 ./server.js",
+    "start": "nodemon --inspect=0.0.0.0 ./server.js",
     "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --coverage"
   },
   "keywords": [
@@ -24,6 +24,7 @@
     "dotenv": "^16.0.3",
     "jest": "^29.5.0",
     "mysql2": "^3.2.0",
+    "nodemon": "^2.0.22",
     "sqlite3": "^5.1.6"
   }
 }

package/src/database/databaseService.js

@@ -37,7 +37,10 @@ const registerDatabaseService = async API => {
     API.ORM = new Sequelize(MM_API_DB_DB, MM_API_DB_USER, MM_API_DB_PASS, SEQUELIZE_OPTIONS);
     establishConnection(API.ORM);
 
-  } catch (DB_ERROR) { console.error({ ROUTE_CODE, DB_ERROR }); }
+  } catch (REGISTER_DB_ERROR) {
+    console.error({ ROUTE_CODE, REGISTER_DB_ERROR });
+    if (process.env.MM_API_LOCAL_ENV) throw REGISTER_DB_ERROR;
+  }
 };
 
 export { establishConnection, registerDatabaseService };

package/src/model/loadModels.js

@@ -21,9 +21,9 @@ const loadAndSyncModels = async API => {
     model.associate(MODELS);
   });
 
-  console.log({ ROUTE_CODE, SYNCING_ORM: 'WAIT_SYNCING_ORM' });
+  console.log({ ROUTE_CODE, SYNCING_ORM: 'WAITING_FOR_ORM_SYNCING' });
   await API.ORM.sync({ alter: process.env.MM_API_LOCAL_ENV ? true : false });
-  console.log({ ROUTE_CODE, SYNCING_ORM: 'DONE_SYNCING_ORM' });
+  console.log({ ROUTE_CODE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
 
   return MODELS;
 };

package/src/service/methodHandler.js

@@ -24,9 +24,9 @@ const exposedMethodHandler = async (body, res, claims, API, METHOD, ROUTE_CODE)
         break;
       default:
         //console.error({ ROUTE_CODE, METHOD_ERROR: JSON.stringify(METHOD_ERROR, null, 2) });
-        //console.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
         console.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack });
-        res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
+        //res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
+        res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack.toString() });
 
     }
   }

package/src/service/registerMethod.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import url from 'url';
 import path from 'path';
-import { z } from 'zod';
+import { z, optionalZObject } from '../zod/index.js';
 
 const registerMethod = async (SERVICE_NAME, SERVICE_URL, METHOD_NAME, METHOD_ROUTE_CODE) => {
 
@@ -19,13 +19,14 @@ const registerMethod = async (SERVICE_NAME, SERVICE_URL, METHOD_NAME, METHOD_ROU
       console.log('  FOUND_VALIDATOR');
 
       const VALIDATOR_BODY = (await import(VALIDATOR_URL)).default;
-      method.VALIDATOR = MODELS => z.object(VALIDATOR_BODY(MODELS)).strict();
+      method.VALIDATOR = MODELS => optionalZObject(VALIDATOR_BODY(MODELS));
     }
 
     return method;
 
   } catch (REGISTER_METHOD_ERROR) {
     console.error({ ROUTE_CODE, REGISTER_METHOD_ERROR, STACK_TRASE: REGISTER_METHOD_ERROR.stack });
+    if (process.env.MM_API_LOCAL_ENV) { throw REGISTER_METHOD_ERROR; }
   }
 };
 

package/src/service/registerService.js

@@ -51,12 +51,14 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
           SERVICE_METHODS[METHOD_CODE], METHOD_ROUTE_CODE);
       });
     };
-  } catch (SERVICE_HANDLER_ERROR) {
+  } catch (REGISTER_SERVICE_ERROR) {
     console.error({
       ROUTE_CODE,
       SERVICE_NAME,
-      SERVICE_HANDLER_ERROR,
+      REGISTER_SERVICE_ERROR,
+      STACK_TRASE: REGISTER_SERVICE_ERROR.stack,
     });
+    if (process.env.MM_API_LOCAL_ENV) { throw REGISTER_SERVICE_ERROR; }
   }
 }
 

package/src/zod/index.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+import optionalZObject from './optionalZObject.js';
+
+export { z, optionalZObject };

package/src/zod/optionalZObject.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export default zElements => {
+  const zObject = z.object(zElements).strict();
+  if (!Object.values(zElements).every(zElement => zElement.isOptional())) return zObject;
+
+  return z.custom(inputBody => inputBody===undefined ? true : zObject.parse(inputBody));
+}

package/src/service/back.registerMethods.js

@@ -1,41 +0,0 @@
-import fs from 'fs';
-import url from 'url';
-import path from 'path';
-import { z } from 'zod';
-
-import { parseMethodPathCode } from './parseMethodPathCode.js';
-import { getMethodRouteCode } from './getMethodRouteCode.js';
-
-const registerMethods = methodPathCodes => async (SERVICE_NAME, SERVICE_URL) => {
-  let ROUTE_CODE = 'REGISTER_METHODS';
-
-  try {
-    const methods = await methodPathCodes.reduce(async (prevMethods, METHOD_PATH_CODE) => {
-      const methods = await prevMethods;
-      const { METHOD_NAME } = parseMethodPathCode(METHOD_PATH_CODE);
-      ROUTE_CODE = 'REGISTER_METHODS_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
-      console.log('  FOUND_METHOD', METHOD_NAME);
-
-      methods[METHOD_PATH_CODE] = { VALIDATOR: (MODELS, ROUTE_CODE) => z.undefined() };
-      methods[METHOD_PATH_CODE].handler =
-        (await import(new URL(`${METHOD_NAME}/index.js`, SERVICE_URL))).default;
-
-      const VALIDATOR_URL = new URL(`${METHOD_NAME}/valid.js`, SERVICE_URL);
-      if (fs.existsSync(url.fileURLToPath(VALIDATOR_URL))) {
-        console.log('    FOUND_VALIDATOR');
-        const VALIDATOR_BODY = (await import(VALIDATOR_URL)).default;
-        methods[METHOD_PATH_CODE].VALIDATOR = (MODELS, ROUTE_CODE) =>
-          z.object(VALIDATOR_BODY(MODELS, ROUTE_CODE)).strict();
-      }
-
-      return methods;
-    }, Promise.resolve({}));
-
-    return methods;
-  } catch (REGISTER_METHOD_ERROR) {
-    console.error({ ROUTE_CODE, REGISTER_METHOD_ERROR,
-      STACK_TRASE: REGISTER_METHOD_ERROR.stack });
-  }
-};
-
-export { registerMethods };