minimonolith 0.14.3 → 0.15.1

package/README.md

@@ -82,7 +82,7 @@ Here, we declare the method handlers for the `todo` service:
 
 ```js
 // todo/index.js
-export const methods = ['getAll', 'get:id', 'post', 'patch:id', 'delete:id'];
+export default ['getAll', 'get:id', 'post', 'patch:id', 'delete:id'];
 ```
 
 ### todo/model.js
@@ -91,7 +91,7 @@ In this file, we define a Sequelize model for the `todo` service:
 
 ```js
 // todo/model.js
-export const modelSchema = serviceName => (orm, types) => {
+export default serviceName => (orm, types) => {
   const schema = orm.define(serviceName, {
     name: {
       type: types.STRING,
@@ -153,10 +153,10 @@ For SQLite:
 
 ```makefile
 MM_API_DB_DIALECT=sqlite
-MM_API_DB_DATABASE=<your_database_name>
 MM_API_DB_STORAGE=:memory: # For in-memory SQLite database
 # Or
 MM_API_DB_STORAGE=path/to/your/sqlite/file.db # For file-based SQLite database
+MM_API_DB_DATABASE=<your_database_name>
 MM_API_LOCAL_ENV=true
 MM_API_PROD_ENV=false
 ```

package/package.json

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

package/src/model/loadModels.js

@@ -6,7 +6,7 @@ const modelSchemas = {};
 
 const registerModel = async (SERVICE_NAME, SERVICE_URL) => {
   const SERVICE_MODEL_MODULE = await import(`${SERVICE_URL}model.js`);
-  modelSchemas[SERVICE_NAME] = SERVICE_MODEL_MODULE.modelSchema(SERVICE_NAME);
+  modelSchemas[SERVICE_NAME] = SERVICE_MODEL_MODULE.default(SERVICE_NAME);
 }
 
 const loadAndSyncModels = async API => {

package/src/service/{registerMethods.js → back.registerMethods.js}

@@ -12,8 +12,7 @@ const registerMethods = methodPathCodes => async (SERVICE_NAME, SERVICE_URL) =>
   try {
     const methods = await methodPathCodes.reduce(async (prevMethods, METHOD_PATH_CODE) => {
       const methods = await prevMethods;
-      //console.log('pathCodes', methodPathCodes, METHOD_PATH_CODE);
-      const { METHOD_NAME, METHOD_PATH } = parseMethodPathCode(METHOD_PATH_CODE);
+      const { METHOD_NAME } = parseMethodPathCode(METHOD_PATH_CODE);
       ROUTE_CODE = 'REGISTER_METHODS_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
       console.log('  FOUND_METHOD', METHOD_NAME);
 

package/src/service/parseMethodCode.js

@@ -0,0 +1,13 @@
+export const parseMethodCode = (SERVICE_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)}/${SERVICE_NAME}` :
+    `/${SERVICE_NAME}/${relativeMethodRoute}`;
+
+  return { METHOD_NAME,  METHOD_ROUTE };
+};

package/src/service/registerMethod.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import url from 'url';
+import path from 'path';
+import { z } from 'zod';
+
+const registerMethod = async (SERVICE_NAME, SERVICE_URL, METHOD_NAME, METHOD_ROUTE_CODE) => {
+
+  const ROUTE_CODE = 'REGISTER_METHOD_' + METHOD_ROUTE_CODE;
+  const method = { VALIDATOR: MODELS => z.undefined() };
+
+  try {
+    console.log('  FOUND_METHOD', METHOD_NAME);
+
+    method.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;
+      method.VALIDATOR = MODELS => z.object(VALIDATOR_BODY(MODELS)).strict();
+    }
+
+    return method;
+
+  } catch (REGISTER_METHOD_ERROR) {
+    console.error({ ROUTE_CODE, REGISTER_METHOD_ERROR, STACK_TRASE: REGISTER_METHOD_ERROR.stack });
+  }
+};
+
+export { registerMethod };

package/src/service/registerService.js

@@ -6,8 +6,8 @@ import { registerModel } from '../model/index.js';
 import { exposedMethodHandler, validatedMethodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
-import { parseMethodPathCode } from './parseMethodPathCode.js';
-import { registerMethods } from './registerMethods.js';
+import { parseMethodCode } from './parseMethodCode.js';
+import { registerMethod } from './registerMethod.js';
 
 const ROUTE_CODE = 'REGISTER_SERVICE';
 
@@ -24,32 +24,33 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
       registerModel(SERVICE_NAME, SERVICE_URL);
     }
 
-    const SERVICE_METHODS =
-      await registerMethods(SERVICE_MODULE.methods)(SERVICE_NAME, SERVICE_URL);
+    console.log('METHODS_TO_BE_REGISTERED', SERVICE_MODULE.default);
 
-    API.SERVICES[SERVICE_NAME] = {};
-    Object.keys(SERVICE_METHODS).forEach(METHOD_PATH_CODE => {
-      const { METHOD_NAME, METHOD_PATH } = parseMethodPathCode(METHOD_PATH_CODE);
-      //console.log('first', METHOD_PATH_CODE, METHOD_NAME, METHOD_PATH);
-      const ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
+    API.SERVICES[SERVICE_NAME] = {}; const SERVICE_METHODS = [];
+    for (const METHOD_CODE of SERVICE_MODULE.default) {
+      const { METHOD_NAME, METHOD_ROUTE } = parseMethodCode(SERVICE_NAME, METHOD_CODE);
+      console.log('REGISTERING_ROUTE', METHOD_ROUTE);
+
+      const METHOD_ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
+
+      SERVICE_METHODS[METHOD_CODE] = await registerMethod(SERVICE_NAME, SERVICE_URL,
+        METHOD_NAME, METHOD_ROUTE_CODE);
 
       API.SERVICES[SERVICE_NAME][METHOD_NAME] = async (body, claims=undefined) => {
         return await validatedMethodHandler(body, claims, API,
-          SERVICE_METHODS[METHOD_PATH_CODE], ROUTE_CODE);
+          SERVICE_METHODS[METHOD_CODE], METHOD_ROUTE_CODE);
       }
 
       const methodType = getMethodType(METHOD_NAME);
-      //console.log('second', METHOD_PATH_CODE, METHOD_NAME, METHOD_PATH);
-      console.log('REGISTERING_ROUTE', `/${SERVICE_NAME}/${METHOD_PATH}`);
-      API[methodType](`/${SERVICE_NAME}/${METHOD_PATH}`, async (event, res) => {
+      API[methodType](METHOD_ROUTE, async (event, res) => {
         const { body, params, queryStringParameters } = event;
         const claims = event.requestContext.authorizer?.jwt?.claims;
         const parsedBody = body || Object.keys(params).length > 0 || queryStringParameters ?
           { ...body, ...params, ...queryStringParameters } : undefined;
         await exposedMethodHandler(parsedBody, res, claims, API,
-          SERVICE_METHODS[METHOD_PATH_CODE], ROUTE_CODE);
+          SERVICE_METHODS[METHOD_CODE], METHOD_ROUTE_CODE);
       });
-    });
+    };
   } catch (SERVICE_HANDLER_ERROR) {
     console.error({
       ROUTE_CODE,

package/src/service/parseMethodPathCode.js

@@ -1,11 +0,0 @@
-export const parseMethodPathCode = (METHOD_PATH_CODE) => {
-  const methodPathParts = METHOD_PATH_CODE.split(":");
-  const METHOD_NAME = methodPathParts[0];
-  const pathParams = methodPathParts.slice(1).map(param => `:${param}`);
-  const METHOD_PATH = `${METHOD_NAME}${pathParams.length > 0 ? '/' : ''}${pathParams.join("/")}`;
-
-  return {
-    METHOD_NAME,
-    METHOD_PATH
-  };
-};