minimonolith 0.14.4 → 0.15.2

package/README.md

@@ -6,25 +6,6 @@
 
 In addition to its simplicity, `minimonolith` enables seamless inter-service communication within your API. This allows services to call one another's functionality without directly importing them, fostering a modular design. For example, you can call the get method of the todo service from the todoList service using SERVICES.todo.get({ id }). By registering services within the API, you can easily call their methods from other services, which not only promotes a clean architecture but also paves the way for future support of automated end-to-end testing.
 
-## Project Structure
-
-A typical project using `minimonolith` will have the following structure:
-
-```go
-.
-├── package.json
-├── .gitignore
-├── .env
-├── server.js                  // For local development
-├── index.js                   // Root of the code in a deployed AWS Lambda
-└── service1
-    ├── index.js               // Service1 method handlers are declared here
-    ├── model.js               // Optional: Sequelize model for Service1 is declared here
-    └── method1
-        ├── index.js           // Service1 Method1 handler is declared here
-        └── valid.js           // Optional: Method1 handler body validation, if not empty
-```
-
 ## Example Project
 
 Here's an example project using `minimonolith`:
@@ -37,11 +18,11 @@ Here's an example project using `minimonolith`:
 ├── server.js                  // For local development
 ├── index.js                   // Root of the code in a deployed AWS Lambda
 └── todo
-    ├── index.js               // Todo method handlers are declared here
-    ├── model.js               // Todo Sequelize model is declared here
+    ├── index.js               // Service 'todo' exported method handlers are declared here
+    ├── model.js               // Optional: Sequelize model for service 'todo' is declared here
     └── get
-        ├── index.js           // /todo/get/ handler
-        └── valid.js           // /todo/get/index.js body validation
+        ├── index.js           // Service 'todo' method 'get' handler
+        └── valid.js           // Optional: Method 'get' handler validation, if body not empty
 ```
 
 ### server.js
@@ -82,7 +63,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 +72,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,

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.14.4",
+  "version": "0.15.2",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
     "start:development": "nodemon --inspect=0.0.0.0 ./server.js",
     "test": "NODE_OPTIONS=--experimental-vm-modules npx jest --coverage"
   },
+  "keywords": [
+    "lambda-api",
+    "zod",
+    "sequelize"
+  ],
   "dependencies": {
     "lambda-api": "^1.0.1",
     "sequelize": "^6.30.0",

package/src/model/loadModels.js

@@ -6,20 +6,24 @@ 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 => {
-  console.log({ ROUTE_CODE, LOADING_MODELS: 'LOADING_MODELS' });
   const MODELS = Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
+    console.log({ ROUTE_CODE, LOADING_MODEL: serviceName });
     loadedModels[serviceName] = modelSchemas[serviceName](API.ORM, DataTypes);
     return loadedModels;
   }, {});
 
-  Object.entries(MODELS).forEach(([serviceName, model]) => { model.associate(MODELS); });
+  Object.entries(MODELS).forEach(([serviceName, model]) => {
+    console.log({ ROUTE_CODE, ASSOCIATING_MODEL: serviceName });
+    model.associate(MODELS);
+  });
 
   console.log({ ROUTE_CODE, SYNCING_ORM: 'SYNCING_ORM' });
   await API.ORM.sync({ alter: process.env.MM_API_LOCAL_ENV ? true : false });
+  console.log({ ROUTE_CODE, SYNCING_ORM: 'DONE_SYNCING_ORM' });
 
   return MODELS;
 };

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
-  };
-};