minimonolith 0.21.2 → 0.22.1

package/src/method/post/index.js

@@ -0,0 +1,48 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+import CONTROL_SERVICE from '../../control/index.js';
+import EVENT_SERVICE from '../../event/index.js';
+import VALIDATION_SERVICE from '../../validation/index.js';
+import ERROR_SERVICE from '../../error/index.js';
+
+import getParsedCode from '../getParsedCode/index.js';
+import getRouteCode from '../getRouteCode/index.js';
+import getType from '../getType/index.js';
+import postResponse from '../postResponse/index.js';
+
+const META_SERVICE_NAME='METHOD', META_METHOD_NAME='POST';
+
+export default async (SERVICE_NAME, SERVICE_URL, METHOD_CODE) => {
+  const { METHOD_NAME, METHOD_ROUTE } = getParsedCode(SERVICE_NAME, METHOD_CODE);
+  const ROUTE_CODE = getRouteCode(SERVICE_NAME, METHOD_NAME);
+  LOG_SERVICE.post('  FOUND_METHOD', METHOD_NAME);
+
+  try {
+
+    const METHOD = {
+      CONTROLLER: await CONTROL_SERVICE.get(METHOD_NAME, SERVICE_URL),
+      VALIDATOR: await VALIDATION_SERVICE.get(METHOD_NAME, SERVICE_URL),
+    };
+
+    API_SERVICE.get().SERVICES[SERVICE_NAME][METHOD_NAME] = async (body, claims=undefined) => {
+      const { MODELS, SERVICES } = API_SERVICE.get();
+      return await METHOD.CONTROLLER({ MODELS, SERVICES, ROUTE_CODE, body, claims });
+    }
+
+    const METHOD_TYPE = getType(METHOD_NAME);
+
+    LOG_SERVICE.post('POSTING_ROUTE', METHOD_ROUTE);
+    API_SERVICE.get()[METHOD_TYPE](METHOD_ROUTE, async (event, res) => {
+      const { body, claims } = EVENT_SERVICE.getParsedEvent(event);
+
+      try {
+        if (await VALIDATION_SERVICE.postError(res, ROUTE_CODE, METHOD.VALIDATOR, body)) return;
+        await postResponse(res, ROUTE_CODE, METHOD.CONTROLLER, METHOD_TYPE, body, claims);
+      }
+      catch (METHOD_ERROR) { ERROR_SERVICE.postRuntime(res, ROUTE_CODE, METHOD_ERROR); }
+    });
+
+  } catch (META_METHOD_ERROR) {
+    ERROR_SERVICE.postCompiletime({ META_SERVICE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR });
+  }
+};

package/src/method/postResponse/index.js

@@ -0,0 +1,13 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+import getResponseCode from '../getResponseCode/index.js';
+
+export default async (res, ROUTE_CODE, CONTROLLER, METHOD_TYPE, body, claims) => {
+
+  const { MODELS, SERVICES } = API_SERVICE.get();
+  const METHOD_RESPONSE = await CONTROLLER({ MODELS, SERVICES, body, claims });
+  const METHOD_RESPONSE_CODE = getResponseCode(METHOD_TYPE);
+  LOG_SERVICE.post({ ROUTE_CODE, METHOD_RESPONSE });
+  res.status(METHOD_RESPONSE_CODE).json(METHOD_RESPONSE);
+};

package/src/middleware/index.js

@@ -0,0 +1,4 @@
+import postCors from './postCors/index.js';
+import postError from './postError/index.js';
+
+export default { postCors, postError };

package/src/middleware/postCors/index.js

@@ -0,0 +1,21 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default () =>  {
+
+  API_SERVICE.get().use((req, res, next) => {
+    if (req.headers['x-trigger-error']) {
+      LOG_SERVICE.post({ ROUTE_CODE: 'LAMBDA_API', MESSAGE: 'X_TRIGGER_ERROR_HEADER' });
+      throw new Error('X_TRIGGER_ERROR_HEADER');
+    }
+    res.cors(); next();
+  });
+
+  API_SERVICE.get().options('/*', (req, res) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'OPTIONS, POST, GET, PUT, PATCH, DELETE');
+    res.header('Access-Control-Allow-Headers', '*');
+    res.header('Access-Control-Allow-Credentials', true);
+    res.status(200).send({})
+  });
+};

package/src/middleware/postError/index.js

@@ -0,0 +1,10 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default () =>  {
+  API_SERVICE.get().use((err, req, res, next) => {
+    LOG_SERVICE.postError({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
+    res.cors(); //next();
+    res.status(500).send({ ROUTE_CODE: 'LAMBDA_API', ERROR: err.message });
+  });
+};

package/src/model/getSynced/index.js

@@ -0,0 +1,22 @@
+import { DataTypes } from 'sequelize';
+
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+const META_SERVICE='MODEL', META_METHOD='GET_SYNCED', META_ROUTE=META_SERVICE+'_'+META_METHOD;
+
+export default async () => {
+  for (const SERVICE_NAME of Object.keys(API_SERVICE.get().SCHEMAS)) {
+    LOG_SERVICE.post({ META_ROUTE, LOADING: SERVICE_NAME });
+    API_SERVICE.get().MODELS[SERVICE_NAME] = API_SERVICE.get().SCHEMAS[SERVICE_NAME](API_SERVICE.get().ORM, DataTypes);
+  }
+
+  for (const [SERVICE_NAME, MODEL] of Object.entries(API_SERVICE.get().MODELS)) {
+    LOG_SERVICE.post({ META_ROUTE, ASSOCIATING: SERVICE_NAME });
+    MODEL.associate(API_SERVICE.get().MODELS);
+  }
+
+  LOG_SERVICE.post({ META_ROUTE, SYNCING_ORM: 'WAITING_ORM_SYNCING' });
+  await API_SERVICE.get().ORM.sync({ alter: process.env.MM_API_DEV_ENV==='TRUE' ? true : false });
+  LOG_SERVICE.post({ META_ROUTE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
+};

package/src/model/index.js

@@ -1,3 +1,4 @@
-import { registerModel, loadAndSyncModels } from './loadModels.js';
+import getSynced from './getSynced/index.js';
+import post from './post/index.js';
 
-export { registerModel, loadAndSyncModels };
+export default { getSynced, post };

package/src/model/post/index.js

@@ -0,0 +1,11 @@
+import fs from 'fs';
+import url from 'url';
+
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default async (SERVICE_NAME, SERVICE_URL) => {
+  if (!fs.existsSync(url.fileURLToPath(`${SERVICE_URL}model.js`))) return;
+  LOG_SERVICE.post('  FOUND_MODEL')
+  API_SERVICE.get().SCHEMAS[SERVICE_NAME] = (await import(`${SERVICE_URL}model.js`)).default(SERVICE_NAME);
+}

package/src/path/{getProjectRoot.js → getProjectRoot/index.js}

@@ -2,7 +2,7 @@ import path from 'path';
 import url from 'url';
 
 // Function to find the project root from any nested directory inside node_modules/
-const getProjectRoot = (currentFileUrl, MODULE_FOLDER) => {
+export default (currentFileUrl, MODULE_FOLDER) => {
   const currentPath = path.dirname(url.fileURLToPath(currentFileUrl));
   const nodeModulesIndex = currentPath.indexOf(MODULE_FOLDER);
   if (nodeModulesIndex === -1) {
@@ -12,5 +12,3 @@ const getProjectRoot = (currentFileUrl, MODULE_FOLDER) => {
   const nodeModulesPath = currentPath.substring(0, nodeModulesIndex);
   return url.pathToFileURL(nodeModulesPath);
 }
-
-export { getProjectRoot };

package/src/path/index.js

@@ -1,3 +1,3 @@
-import { getProjectRoot } from './getProjectRoot.js';
+import getProjectRoot from './getProjectRoot/index.js';
 
-export { getProjectRoot };
+export default { getProjectRoot };

package/src/{development/serverHandler.js → server/getNodejsServerHandler/index.js}

@@ -2,9 +2,9 @@
 
 import url from 'url';
 
-import { logger } from '../logger/index.js';
+import LOG_SERVICE from '../../log/index.js';
 
-const loadBody = req => {
+const getBody = req => {
   return new Promise((resolve, reject) => {
     let body = '';
     req.on('data', chunk => { body += chunk; });
@@ -18,41 +18,36 @@ const getJWTClaims = authHeader => {
   return JSON.parse(Buffer.from(b64Claims, 'base64').toString());
 }
 
-const putCORS = res => {
-  res.setHeader('Access-Control-Allow-Origin', '*');
-  res.setHeader('Access-Control-Request-Method', '*');
-  res.setHeader('Access-Control-Allow-Methods', 'OPTIONS,GET,POST,PUT,PATCH,DELETE');
-  res.setHeader('Access-Control-Allow-Headers', '*');
-};
-
 const getLambdaEvent = (req, queryString, jwtClaims, body) => {
-  return {
+  const event = {
     path: req.url,
     httpMethod: req.method,
     queryStringParameters: queryString,
     requestContext: {
       authorizer: { jwt: { claims: jwtClaims }, },
+      http: { method: req.method, path: req.url },
     },
-    headers: {
-      accept: req.headers.accept,
-      'User-Agent': req.headers['user-agent']
-    },
+    headers: {},
     body,
   };
+  
+  if (req.headers['content-type']) event.headers['Content-Type'] = req.headers['content-type'];
+  if (req.headers['x-trigger-error']) event.headers['x-trigger-error'] = 'TRUE';
+  if (req.headers.accept) event.headers.accept = req.headers.accept;
+  if (req.headers['user-agent']) event.headers['User-Agent'] = req.headers['user-agent'];
+  console.log(event);
+  return event;
 };
 
-const getServerHandler = lambdaHandler => async (req, res) => {
+export default lambdaHandler => async (req, res) => {
   try {
-    putCORS(res);
-    if (req.method === 'OPTIONS') { res.writeHead(200); res.end(); return; }
-
     const authHeader = req.headers.authorization;
     const jwtClaims = authHeader?.startsWith('Bearer ') ? getJWTClaims(authHeader) : null;
 
     const tempQueryString = url.parse(req.url, true).query;
     const queryString = tempQueryString ? tempQueryString : undefined;
 
-    const tempBody = await loadBody(req);
+    const tempBody = await getBody(req);
     const body = tempBody ? tempBody : undefined;
 
     const lambdaEvent = getLambdaEvent(req, queryString, jwtClaims, body);
@@ -61,7 +56,9 @@ const getServerHandler = lambdaHandler => async (req, res) => {
     res.statusCode = lambdaRes.statusCode;
     res.end(lambdaRes.body);
 
-  } catch(SERVER_ERROR) { logger.log({ SERVER_ERROR }); }
+  } catch(SERVER_ERROR) {
+    LOG_SERVICE.post({ SERVER_ERROR });
+    res.statusCode = 500;
+    res.end(JSON.stringify({ REQUEST_PARSING_ERROR: SERVER_ERROR.toString() }));
+  }
 }
-
-export { getServerHandler };

package/src/server/getServerFactory/index.js

@@ -0,0 +1,13 @@
+import http from 'http';
+
+import getNodejsServerHandler from '../getNodejsServerHandler/index.js';
+
+export default async (ENV_FILE='.env', MODULE_FOLDER='node_modules/') => {
+  (await import('../../environment/postEnvFile/index.js')).default(ENV_FILE, MODULE_FOLDER);
+
+  return (lambdaHandler) => {
+    const serverHandler = getNodejsServerHandler(lambdaHandler);
+    const server = http.createServer(serverHandler);
+    return server;
+  }
+}

package/src/server/index.js

@@ -0,0 +1,3 @@
+import getServerFactory from './getServerFactory/index.js';
+
+export default { getServerFactory };

package/src/{database/validation.js → validation/dbValidation.js}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-const DB_VALIDATION = {
+export default {
   exists: (model, field) => async (value, ctx) => {
     const valueCount = await model.count({ where: { [field]: value } });
     if (valueCount == 0) {
@@ -31,5 +31,3 @@ const DB_VALIDATION = {
     }
   },
 };
-
-export { DB_VALIDATION };

package/src/validation/get/index.js

@@ -0,0 +1,19 @@
+import fs from 'fs';
+import url from 'url';
+import { z } from 'zod';
+
+import LOG_SERVICE from '../../log/index.js';
+
+import getOptionalObject from '../getOptionalObject/index.js';
+
+export default async (METHOD_NAME, SERVICE_URL) => {
+  const VALIDATION_URL = new URL(`${METHOD_NAME}/valid.js`, SERVICE_URL);
+
+  if (!fs.existsSync(url.fileURLToPath(VALIDATION_URL)))
+    return EVENT_CONTEXT => z.undefined();
+
+  LOG_SERVICE.post('  FOUND_VALIDATOR');
+  const Z_ELEMENTS = (await import(VALIDATION_URL)).default;
+
+  return EVENT_CONTEXT => getOptionalObject(Z_ELEMENTS(EVENT_CONTEXT));
+};

package/src/{zod/optionalZObject.js → validation/getOptionalObject/index.js}

@@ -4,5 +4,5 @@ export default zElements => {
   const zObject = z.object(zElements).strict();
   if (!Object.values(zElements).every(zElement => zElement.isOptional())) return zObject;
 
-  return z.custom(inputBody => inputBody===undefined ? true : zObject.parse(inputBody));
+  return z.custom(unifiedBody => unifiedBody===undefined ? true : zObject.parse(unifiedBody));
 }

package/src/validation/index.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+import getOptionalObject from './getOptionalObject/index.js';
+import get from './get/index.js';
+import postError from './postError/index.js';
+import zdb from './dbValidation.js';
+
+export default { z, get, postError, zdb, getOptionalObject };

package/src/validation/postError/index.js

@@ -0,0 +1,15 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default async (res, ROUTE_CODE, VALIDATOR, input) => {
+  const { MODELS, SERVICES } = API_SERVICE.get(), EVENT_CONTEXT = { MODELS, SERVICES };
+  const VALIDATION_ERROR = (await VALIDATOR(EVENT_CONTEXT).safeParseAsync(input)).error?.format();
+
+  if (!VALIDATION_ERROR) return false;
+
+  const MESSAGE = { ROUTE_CODE, VALIDATION_ERROR };
+  LOG_SERVICE.postError(MESSAGE);
+  res.status(400).json(MESSAGE);
+
+  return true;
+}

package/src/api/apiHandler.js

@@ -1,13 +0,0 @@
-import { logger } from '../logger/index.js';
-
-const apiHandler = API => async (event, context) => {
-  logger.log({
-    ROUTE_CODE: 'LAMBDA_EVENT',
-    EVENT_PATH: event.path,
-    EVENT_METHOD: event.httpMethod,
-  });
-
-  return await API.run(event, context);
-};
-
-export { apiHandler };

package/src/api/createAPI.js

@@ -1,51 +0,0 @@
-import lambdaAPICreateAPI from 'lambda-api';
-
-import { registerHealthService } from '../health/index.js';
-import { registerDatabaseService } from '../database/index.js';
-import { loadAndSyncModels } from '../model/index.js';
-import { registerService } from '../service/index.js';
-import { logger } from '../logger/index.js';
-import { apiHandler } from './apiHandler.js';
-
-const ROUTE_CODE = 'CREATE_API';
-
-const addCORS = API =>  {
-  API.use((req, res, next) => { res.cors(); next(); });
-  API.use((err, req, res, next) => { res.cors(); next(); });
-  API.options('/*', (req, res) => {
-    res.header('Access-Control-Allow-Origin', '*');
-    res.header('Access-Control-Allow-Methods', 'OPTIONS, POST, GET, PUT, PATCH, DELETE');
-    res.header('Access-Control-Allow-Headers', '*');
-    res.header('Access-Control-Allow-Credentials', true);
-    //logger.log('OPTIONS_SUCCESS');
-    res.status(200).send({})
-  });
-};
-
-const createAPI = () => {
-  const API = lambdaAPICreateAPI();
-
-  addCORS(API);
-
-  API.registerService = (SERVICE_NAME, SRC_FOLDER='', MODULE_FOLDER='node_modules/') => 
-    registerService(API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER);
-
-  API.registerHealthService = () => registerHealthService(API);
-
-  API.registerDatabaseService = async () => { await registerDatabaseService(API) };
-
-  API.handler = async () => {
-    if (API.ORM) API.MODELS = await loadAndSyncModels(API);
-    else logger.log({ ROUTE_CODE, INFO: 'NO_DATABASE_REGISTERED' });
-
-    logger.log({ ROUTE_CODE, INFO: 'LISTENING' });
-    return apiHandler(API);
-  }
-
-  API.SERVICES = {};
-
-
-  return API;
-}
-
-export { createAPI };

package/src/crasher/crasher.js

@@ -1 +0,0 @@
-export default ERROR => { if (process.env.MM_API_DEV_ENV==='TRUE') throw ERROR; };

package/src/crasher/index.js

@@ -1,3 +0,0 @@
-import crasher from './crasher.js';
-
-export { crasher };

package/src/database/databaseService.js

@@ -1,49 +0,0 @@
-import Sequelize from 'sequelize';
-//import SequelizeDynamo from 'dynamo-sequelize';
-
-import { logger } from '../logger/index.js';
-import { crasher } from '../crasher/index.js';
-
-const ROUTE_CODE = 'DB_CONNECTION';
-
-const establishConnection = async ORM => {
-  const MAX_RETRIES = 5, INITIAL_WAIT = 100;
-  let connectionRetries = 0, waitTime = INITIAL_WAIT;
-
-  while (connectionRetries < MAX_RETRIES) {
-    try {
-      logger.log({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
-      await ORM.authenticate();
-      break;
-
-    } catch (DATABASE_CONNECTION_ERROR) {
-      await new Promise(resolve => setTimeout(resolve, waitTime));
-
-      connectionRetries += 1;
-      const jitter = Math.random() * 0.3 + 0.7;
-      waitTime = Math.min(2 * waitTime * jitter, INITIAL_WAIT * Math.pow(2, MAX_RETRIES));
-    }
-  }
-
-  return connectionRetries;
-};
-
-const registerDatabaseService = async API => {
-  try {
-    const { MM_API_DB_DIALECT, MM_API_DB_DB, MM_API_DB_USER,
-      MM_API_DB_PASS, MM_API_DB_HOST, MM_API_DB_PORT, MM_API_DB_STORAGE } = process.env;
-    const SEQUELIZE_OPTIONS = { dialect: MM_API_DB_DIALECT, host: MM_API_DB_HOST,
-      port: MM_API_DB_PORT, storage: MM_API_DB_STORAGE, logging: false };
-
-    logger.qa({ ROUTE_CODE, MM_API_DB_VARS: { MM_API_DB_DIALECT,
-      MM_API_DB_USER, MM_API_DB_PASS, MM_API_DB_HOST, MM_API_DB_PORT, MM_API_DB_DB, MM_API_DB_STORAGE }});
-    API.ORM = new Sequelize(MM_API_DB_DB, MM_API_DB_USER, MM_API_DB_PASS, SEQUELIZE_OPTIONS);
-    establishConnection(API.ORM);
-
-  } catch (REGISTER_DB_ERROR) {
-    logger.error({ ROUTE_CODE, REGISTER_DB_ERROR });
-    crasher(REGISTER_DB_ERROR);
-  }
-};
-
-export { establishConnection, registerDatabaseService };

package/src/development/createDevEnvironment.js

@@ -1,10 +0,0 @@
-import lambdaServer from './lambdaServer.js';
-
-const createDevEnvironment = async (ENV_FILE='.env', MODULE_FOLDER='node_modules/') => {
-  const { loadEnvFile } = await import('./loadEnvFile.js');
-  loadEnvFile(ENV_FILE, MODULE_FOLDER);
-
-  return lambdaServer;
-}
-
-export default createDevEnvironment;

package/src/development/createTestEnvironment.js

@@ -1,9 +0,0 @@
-const createTestEnvironment = async () => {
-  process.env.MM_API_DEV_ENV = 'TRUE';
-  process.env.MM_API_PROD_ENV = 'FALSE';
-  process.env.MM_API_TEST_ENV = 'TRUE';
-  process.env.MM_API_DB_DIALECT = 'sqlite';
-  process.env.MM_API_DB_STORAGE = ':memory:';
-}
-
-export default createTestEnvironment;

package/src/development/index.js

@@ -1,4 +0,0 @@
-import createDevEnvironment from './createDevEnvironment.js';
-import createTestEnvironment from './createTestEnvironment.js';
-
-export { createTestEnvironment, createDevEnvironment };

package/src/development/lambdaServer.js

@@ -1,11 +0,0 @@
-import http from 'http';
-
-import { getServerHandler } from './serverHandler.js';
-
-const lambdaServer = (lambdaHandler, port) => {
-  const serverHandler = getServerHandler(lambdaHandler);
-  const server = http.createServer(serverHandler);
-  server.listen(port);
-}
-
-export default lambdaServer;

package/src/health/healthService.js

@@ -1,15 +0,0 @@
-import { logger } from '../logger/index.js';
-
-const healthHandler = () => {
-  return "API_RUNNING";
-}
-
-const registerHealthService = API => {
-  API.get('/', async (req, res) => {
-    const SERVICE_RESPONSE = healthHandler();
-    logger.log({ SERVICE_RESPONSE });
-    return { SERVICE_RESPONSE };
-  });
-}
-
-export { registerHealthService };

package/src/logger/index.js

@@ -1,3 +0,0 @@
-import logger from './logger.js';
-
-export { logger };

package/src/logger/logger.js

@@ -1,5 +0,0 @@
-export default {
-  error: (...ERROR) => { console.error(...ERROR) },
-  log: (...MESSAGE) => { console.log(...MESSAGE) },
-  qa: (...MESSAGE) => { if (process.env.MM_API_PROD_ENV==='FALSE') console.log(...MESSAGE) }
-};

package/src/model/loadModels.js

@@ -1,33 +0,0 @@
-import { DataTypes } from 'sequelize';
-
-import { logger } from '../logger/index.js';
-
-const ROUTE_CODE = 'LOAD_MODELS';
-
-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.default(SERVICE_NAME);
-}
-
-const loadAndSyncModels = async API => {
-  const MODELS = Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
-    logger.log({ ROUTE_CODE, LOADING_MODEL: serviceName });
-    loadedModels[serviceName] = modelSchemas[serviceName](API.ORM, DataTypes);
-    return loadedModels;
-  }, {});
-
-  Object.entries(MODELS).forEach(([serviceName, model]) => {
-    logger.log({ ROUTE_CODE, ASSOCIATING_MODEL: serviceName });
-    model.associate(MODELS);
-  });
-
-  logger.log({ ROUTE_CODE, SYNCING_ORM: 'WAITING_FOR_ORM_SYNCING' });
-  await API.ORM.sync({ alter: process.env.MM_API_DEV_ENV==='TRUE' ? true : false });
-  logger.log({ ROUTE_CODE, SYNCING_ORM: 'DONE_ORM_SYNCING' });
-
-  return MODELS;
-};
-
-export { registerModel, loadAndSyncModels };

package/src/service/index.js

@@ -1,4 +0,0 @@
-import { registerService } from './registerService.js';
-
-export { registerService };
-

package/src/service/methodHandler.js

@@ -1,25 +0,0 @@
-import { logger } from '../logger/index.js';
-
-const methodHandler = async (res, METHOD, EVENT_CONTEXT) => {
-  const { body, ROUTE_CODE } = EVENT_CONTEXT;
-
-  try {
-
-    const validation = await METHOD.VALIDATOR(EVENT_CONTEXT).safeParseAsync(body);
-    if (validation.success) {
-      const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
-      logger.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();
-    logger.error({ ROUTE_CODE, VALIDATION_ERROR });
-    res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR });
-  }
-  catch (METHOD_ERROR) {
-    logger.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack });
-    res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack.toString() });
-  }
-};
-
-export { methodHandler };

package/src/service/registerMethod.js

@@ -1,36 +0,0 @@
-import fs from 'fs';
-import url from 'url';
-import path from 'path';
-
-import { z, optionalZObject } from '../zod/index.js';
-import { logger } from '../logger/index.js';
-import { crasher } from '../crasher/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: EVENT_CONTEXT => z.undefined() };
-
-  try {
-    logger.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))) {
-
-      logger.log('  FOUND_VALIDATOR');
-
-      const Z_ELEMENTS = (await import(VALIDATOR_URL)).default;
-      method.VALIDATOR = EVENT_CONTEXT => optionalZObject(Z_ELEMENTS(EVENT_CONTEXT));
-    }
-
-    return method;
-
-  } catch (REGISTER_METHOD_ERROR) {
-    logger.error({ ROUTE_CODE, REGISTER_METHOD_ERROR, STACK_TRASE: REGISTER_METHOD_ERROR.stack });
-    crasher(REGISTER_METHOD_ERROR);
-  }
-};
-
-export { registerMethod };