minimonolith 0.8.0 → 0.9.0

package/index.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
 import { createAPI } from './src/api/index.js';
-import { runLambdaServer, loadEnvFile } from './src/server/index.js';
+import { runLambdaServer, loadEnvFile } from './src/local/index.js';
 
 export { runLambdaServer, loadEnvFile, createAPI, z };

package/package.json

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

package/src/service/methodHandler.js

@@ -1,17 +1,17 @@
 import { validationHandler } from './validationHandler.js';
 
-const validatedMethodHandler = async (event, API, METHOD, ROUTE_CODE) => {
-  await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
+const validatedMethodHandler = async (body, API, METHOD, ROUTE_CODE) => {
+  await validationHandler(body, METHOD, API.MODELS, ROUTE_CODE);
 
-  const EVENT_CONTEXT = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
+  const EVENT_CONTEXT = { body, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
   const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
 
   return METHOD_RESPONSE;
 };
 
-const exposedMethodHandler = async (event, res, API, METHOD, ROUTE_CODE) => {
+const exposedMethodHandler = async (body, res, API, METHOD, ROUTE_CODE) => {
   try {
-    const METHOD_RESPONSE = await validatedMethodHandler(event, API, METHOD, ROUTE_CODE);
+    const METHOD_RESPONSE = await validatedMethodHandler(body, API, METHOD, ROUTE_CODE);
     console.log({ ROUTE_CODE, METHOD_RESPONSE: METHOD_RESPONSE.toString() });
     //console.log({ ROUTE_CODE, METHOD_RESPONSE: JSON.stringify(METHOD_RESPONSE, null, 2) });
     res.status(200).json(METHOD_RESPONSE);
@@ -24,8 +24,10 @@ const exposedMethodHandler = async (event, res, 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.toString() });
+        console.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack });
         res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
+
     }
   }
 };

package/src/service/parseMethodPathCode.js

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

package/src/service/registerMethods.js

@@ -3,26 +3,29 @@ import url from 'url';
 import path from 'path';
 import { z } from 'zod';
 
+import { parseMethodPathCode } from './parseMethodPathCode.js';
 import { getMethodRouteCode } from './getMethodRouteCode.js';
 
-const registerMethods = methodNames => async (SERVICE_NAME, SERVICE_URL) => {
+const registerMethods = methodPathCodes => async (SERVICE_NAME, SERVICE_URL) => {
   let ROUTE_CODE = 'REGISTER_METHODS';
 
   try {
-    const methods = await methodNames.reduce(async (prevMethods, METHOD_NAME) => {
+    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);
       ROUTE_CODE = 'REGISTER_METHODS_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
       console.log('  FOUND_METHOD', METHOD_NAME);
 
-      methods[METHOD_NAME] = { VALIDATOR: (MODELS, ROUTE_CODE) => z.undefined() };
-      methods[METHOD_NAME].handler =
+      methods[METHOD_PATH_CODE] = { VALIDATOR: (MODELS, ROUTE_CODE) => z.undefined() };
+      methods[METHOD_PATH_CODE].handler =
         (await import(new URL(`${METHOD_NAME}/handler.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_NAME].VALIDATOR = (MODELS, ROUTE_CODE) =>
+        methods[METHOD_PATH_CODE].VALIDATOR = (MODELS, ROUTE_CODE) =>
           z.object(VALIDATOR_BODY(MODELS, ROUTE_CODE)).strict();
       }
 
@@ -30,8 +33,9 @@ const registerMethods = methodNames => async (SERVICE_NAME, SERVICE_URL) => {
     }, Promise.resolve({}));
 
     return methods;
-  } catch (METHOD_ERROR) {
-    console.error({ ROUTE_CODE, METHOD_ERROR });
+  } catch (REGISTER_METHOD_ERROR) {
+    console.error({ ROUTE_CODE, REGISTER_METHOD_ERROR,
+      STACK_TRASE: REGISTER_METHOD_ERROR.stack });
   }
 };
 

package/src/service/registerService.js

@@ -6,6 +6,7 @@ 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';
 
 const ROUTE_CODE = 'REGISTER_SERVICE';
@@ -23,19 +24,31 @@ 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);
+    const SERVICE_METHODS =
+      await registerMethods(SERVICE_MODULE.methods)(SERVICE_NAME, SERVICE_URL);
 
     API.SERVICES[SERVICE_NAME] = {};
-    Object.keys(SERVICE_METHODS).forEach(METHOD_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][METHOD_NAME] = async body => {
-        return await validatedMethodHandler({ body }, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
+        return await validatedMethodHandler(body, API,
+          SERVICE_METHODS[METHOD_PATH_CODE], ROUTE_CODE);
       }
 
       const methodType = getMethodType(METHOD_NAME);
-      API[methodType](`/${SERVICE_NAME}/${METHOD_NAME}`, async (event, res) => {
-        await exposedMethodHandler(event, res, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
+      //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) => {
+        const { body, params, queryStringParameters } = event;
+        const parsedBody = body || Object.keys(params).length > 0 || queryStringParameters ?
+          { ...body, ...params, ...queryStringParameters } : undefined;
+        //console.log({ RECEIVED_BODY: parsedBody.toString() });
+        console.log({ RECEIVED_BODY: JSON.stringify(parsedBody) });
+        await exposedMethodHandler(parsedBody, res, API,
+          SERVICE_METHODS[METHOD_PATH_CODE], ROUTE_CODE);
       });
     });
   } catch (SERVICE_HANDLER_ERROR) {

package/src/service/validationHandler.js

@@ -1,6 +1,6 @@
-const validationHandler = async (event, METHOD, MODELS, ROUTE_CODE) => {
+const validationHandler = async (body, METHOD, MODELS, ROUTE_CODE) => {
 
-  const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(event.body);
+  const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(body);
   if (validation.success) return;
 
   const VALIDATION_ERROR = new Error('VALIDATION_ERROR');

package/npm_publish.yml

@@ -1,32 +0,0 @@
-name: NPM Publish
-
-on:
-  push:
-    branches:
-      - master # Change this to the branch where you want to trigger the workflow
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Set up Node.js
-      uses: actions/setup-node@v3
-      with:
-        node-version: 18 # Change this to the Node.js version you need
-
-    - name: Install dependencies
-      run: yarn install
-
-    - name: Run tests
-      run: yarn test
-
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v3
-
-    - name: Publish to NPM
-      run: yarn publish
-      env:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} # Set up the NPM_TOKEN in your GitHub repository secrets