minimonolith 0.17.0 → 0.18.0

package/package.json

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

package/src/service/methodHandler.js

@@ -1,35 +1,24 @@
-import { validationHandler } from './validationHandler.js';
+const methodHandler = async (res, METHOD, EVENT_CONTEXT) => {
+  const { body, ROUTE_CODE } = EVENT_CONTEXT;
 
-const validatedMethodHandler = async (body, claims, API, METHOD, ROUTE_CODE) => {
-  await validationHandler(body, METHOD, API.MODELS, ROUTE_CODE);
-
-  const EVENT_CONTEXT = { body, claims, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
-  const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
-
-  return METHOD_RESPONSE;
-};
-
-const exposedMethodHandler = async (body, res, claims, API, METHOD, ROUTE_CODE) => {
   try {
-    const METHOD_RESPONSE = await validatedMethodHandler(body, claims, API, METHOD, ROUTE_CODE);
-    console.log({ ROUTE_CODE, METHOD_RESPONSE: METHOD_RESPONSE ? METHOD_RESPONSE.toString(): METHOD_RESPONSE });
-    //console.log({ ROUTE_CODE, METHOD_RESPONSE: JSON.stringify(METHOD_RESPONSE, null, 2) });
-    res.status(200).json(METHOD_RESPONSE);
 
+    const validation = await METHOD.VALIDATOR(EVENT_CONTEXT).safeParseAsync(body);
+    if (validation.success) {
+      const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
+      //const METHOD_RESPONSE = await internalMethodHandler(METHOD, EVENT_CONTEXT);
+      console.log({ ROUTE_CODE, METHOD_RESPONSE: METHOD_RESPONSE ? METHOD_RESPONSE.toString(): METHOD_RESPONSE });
+      res.status(200).json(METHOD_RESPONSE); return;
+    }
+
+    const VALIDATION_ERROR = validation.error.format();
+    console.error({ ROUTE_CODE, VALIDATION_ERROR });
+    res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR });
   }
   catch (METHOD_ERROR) {
-    switch (METHOD_ERROR.code) {
-      case 'VALIDATION_ERROR':
-        res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR: METHOD_ERROR.error });
-        break;
-      default:
-        //console.error({ ROUTE_CODE, METHOD_ERROR: JSON.stringify(METHOD_ERROR, null, 2) });
-        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.stack.toString() });
-
-    }
+    console.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack });
+    res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack.toString() });
   }
 };
 
-export { validatedMethodHandler, exposedMethodHandler };
+export { methodHandler };

package/src/service/registerMethod.js

@@ -6,7 +6,7 @@ import { z, optionalZObject } from '../zod/index.js';
 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() };
+  const method = { VALIDATOR: EVENT_CONTEXT => z.undefined() };
 
   try {
     console.log('  FOUND_METHOD', METHOD_NAME);
@@ -18,8 +18,8 @@ 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 => optionalZObject(VALIDATOR_BODY(MODELS));
+      const Z_ELEMENTS = (await import(VALIDATOR_URL)).default;
+      method.VALIDATOR = EVENT_CONTEXT => optionalZObject(Z_ELEMENTS(EVENT_CONTEXT));
     }
 
     return method;

package/src/service/registerService.js

@@ -3,7 +3,7 @@ import url from 'url'
 
 import { getProjectRoot } from '../path/index.js';
 import { registerModel } from '../model/index.js';
-import { exposedMethodHandler, validatedMethodHandler } from './methodHandler.js';
+import { methodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
 import { parseMethodCode } from './parseMethodCode.js';
@@ -36,19 +36,22 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
       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_CODE], METHOD_ROUTE_CODE);
+        const EVENT_CONTEXT = { MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE: METHOD_ROUTE_CODE };
+        return await SERVICE_METHODS[METHOD_CODE].handler({ ...EVENT_CONTEXT, body, claims });
       }
 
       const methodType = getMethodType(METHOD_NAME);
       API[methodType](METHOD_ROUTE, async (event, res) => {
         const { body, params, query } = event;
-        const claims = event.requestContext.authorizer?.jwt?.claims;
+        const claims = event.requestContext.authorizer?.jwt?.claimsr
+
         const parsedBody = body || Object.keys(params).length > 0 || Object.keys(query).length > 0 ?
           { ...body, ...params, ...query } : undefined;
-        await exposedMethodHandler(parsedBody, res, claims, API,
-          SERVICE_METHODS[METHOD_CODE], METHOD_ROUTE_CODE);
+
+        const EVENT_CONTEXT = { MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE: METHOD_ROUTE_CODE };
+        await methodHandler(res, SERVICE_METHODS[METHOD_CODE], { ...EVENT_CONTEXT, body: parsedBody, claims });
       });
     };
   } catch (REGISTER_SERVICE_ERROR) {

package/src/service/validationHandler.js

@@ -1,14 +1,16 @@
-const validationHandler = async (body, METHOD, MODELS, ROUTE_CODE) => {
+const validationHandler = async (res, METHOD, EVENT_CONTEXT) => {
+  const { body, ROUTE_CODE } = EVENT_CONTEXT;
 
-  const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(body);
-  if (validation.success) return;
+  const validation = await METHOD.VALIDATOR(EVENT_CONTEXT).safeParseAsync(body);
+  if (validation.success) {
+    const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
+    console.log({ ROUTE_CODE, METHOD_RESPONSE: METHOD_RESPONSE ? METHOD_RESPONSE.toString(): METHOD_RESPONSE });
+    res.status(200).json(METHOD_RESPONSE); return;
+  }
 
-  const VALIDATION_ERROR = new Error('VALIDATION_ERROR');
-  VALIDATION_ERROR.error = validation.error.format()
-  VALIDATION_ERROR.code = 'VALIDATION_ERROR';
-  console.error({ ROUTE_CODE, VALIDATION_ERROR: VALIDATION_ERROR.error });
-  //console.error({ ROUTE_CODE, VALIDATION_ERROR: JSON.stringify(VALIDATION_ERROR, null, 2) });
-  throw VALIDATION_ERROR;
+  const VALIDATION_ERROR = validation.error.format();
+  console.error({ ROUTE_CODE, VALIDATION_ERROR });
+  res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR });
 };
 
 export { validationHandler };