minimonolith 0.7.0 → 0.8.1

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.7.0",
+  "version": "0.8.1",
   "main": "index.js",
   "license": "MIT",
   "scripts": {

package/src/service/methodHandler.js

@@ -1,23 +1,33 @@
 import { validationHandler } from './validationHandler.js';
 
-const methodHandler = async (event, API, METHOD, ROUTE_CODE) => {
-  try {
-    const VALIDATION_ERROR = await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
-    if (VALIDATION_ERROR) {
-      console.error({ ROUTE_CODE, VALIDATION_ERROR: VALIDATION_ERROR.toString() });
-      return VALIDATION_ERROR;
-    }
+const validatedMethodHandler = async (event, API, METHOD, ROUTE_CODE) => {
+  await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
 
-    const EVENT_CONTEXT = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
-    const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
+  const EVENT_CONTEXT = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
+  const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
 
-    console.log({ ROUTE_CODE, METHOD_RESPONSE });
-    return METHOD_RESPONSE;
+  return METHOD_RESPONSE;
+};
 
-  } catch (METHOD_ERROR) {
-    console.error({ ROUTE_CODE, METHOD_ERROR });
-    return { statusCode: 500, body: { ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() } };
+const exposedMethodHandler = async (event, res, API, METHOD, ROUTE_CODE) => {
+  try {
+    const METHOD_RESPONSE = await validatedMethodHandler(event, 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);
+
+  }
+  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.toString() });
+        res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.toString() });
+    }
   }
 };
 
-export { methodHandler };
+export { validatedMethodHandler, exposedMethodHandler };

package/src/service/registerMethods.js

@@ -1,4 +1,7 @@
+import fs from 'fs';
+import url from 'url';
 import path from 'path';
+import { z } from 'zod';
 
 import { getMethodRouteCode } from './getMethodRouteCode.js';
 
@@ -7,12 +10,21 @@ const registerMethods = methodNames => async (SERVICE_NAME, SERVICE_URL) => {
 
   try {
     const methods = await methodNames.reduce(async (prevMethods, METHOD_NAME) => {
-      ROUTE_CODE = 'CREATE_METHOD_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
       const methods = await prevMethods;
+      ROUTE_CODE = 'REGISTER_METHODS_' + getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
+      console.log('  FOUND_METHOD', METHOD_NAME);
 
-      const handlerModule = await import(new URL(`./${METHOD_NAME}/handler.js`, SERVICE_URL));
-      const validModule = await import(new URL(`./${METHOD_NAME}/valid.js`, SERVICE_URL));
-      methods[METHOD_NAME] = { handler: handlerModule.handler, VALIDATOR: validModule.VALIDATOR, };
+      methods[METHOD_NAME] = { VALIDATOR: (MODELS, ROUTE_CODE) => z.undefined() };
+      methods[METHOD_NAME].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) =>
+          z.object(VALIDATOR_BODY(MODELS, ROUTE_CODE)).strict();
+      }
 
       return methods;
     }, Promise.resolve({}));

package/src/service/registerService.js

@@ -1,20 +1,28 @@
+import fs from 'fs';
 import url from 'url'
 
 import { getProjectRoot } from '../path/index.js';
 import { registerModel } from '../model/index.js';
-import { methodHandler } from './methodHandler.js';
+import { exposedMethodHandler, validatedMethodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
 import { registerMethods } from './registerMethods.js';
 
+const ROUTE_CODE = 'REGISTER_SERVICE';
+
 const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) => {
   try {
+    console.log(ROUTE_CODE, SERVICE_NAME);
     const PROJECT_ROOT_PATH = getProjectRoot(import.meta.url, MODULE_FOLDER)+'/';
     const PROJECT_RELATIVE_SERVICE_PATH = './' + SRC_FOLDER + `${SERVICE_NAME}/`;
     const SERVICE_URL = new URL(PROJECT_RELATIVE_SERVICE_PATH, PROJECT_ROOT_PATH);
 
     const SERVICE_MODULE = await import(`${SERVICE_URL}index.js`);
-    if (SERVICE_MODULE.model) registerModel(SERVICE_NAME, SERVICE_URL);
+    if (fs.existsSync(url.fileURLToPath(`${SERVICE_URL}model.js`))) {
+      console.log('  FOUND_MODEL');
+      registerModel(SERVICE_NAME, SERVICE_URL);
+    }
+
     const SERVICE_METHODS = await registerMethods(SERVICE_MODULE.methods)(SERVICE_NAME, SERVICE_URL);
 
     API.SERVICES[SERVICE_NAME] = {};
@@ -22,21 +30,17 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
       const ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
 
       API.SERVICES[SERVICE_NAME][METHOD_NAME] = async body => {
-        const eventResponse =
-          await methodHandler({ body }, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
-        return eventResponse.body;
+        return await validatedMethodHandler({ body }, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
       }
 
       const methodType = getMethodType(METHOD_NAME);
       API[methodType](`/${SERVICE_NAME}/${METHOD_NAME}`, async (event, res) => {
-        const { statusCode, body } =
-          await methodHandler(event, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
-        res.status(statusCode).json(body);
+        await exposedMethodHandler(event, res, API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE);
       });
     });
   } catch (SERVICE_HANDLER_ERROR) {
     console.error({
-      ROUTE_CODE: 'SERVICE_HANDLER_ERROR',
+      ROUTE_CODE,
       SERVICE_NAME,
       SERVICE_HANDLER_ERROR,
     });

package/src/service/validationHandler.js

@@ -3,7 +3,12 @@ const validationHandler = async (event, METHOD, MODELS, ROUTE_CODE) => {
   const validation = await METHOD.VALIDATOR(MODELS, ROUTE_CODE).safeParseAsync(event.body);
   if (validation.success) return;
 
-  return { statusCode: 400, body: { ROUTE_CODE, VALIDATION_ERROR: validation.error.format() } };
+  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;
 };
 
 export { validationHandler };