minimonolith 0.24.1 → 0.25.4

package/package.json

@@ -1,32 +1,33 @@
-{
-  "name": "minimonolith",
-  "type": "module",
-  "version": "0.24.1",
-  "main": "index.js",
-  "license": "MIT",
-  "scripts": {
-    "start": "nodemon --inspect=0.0.0.0 ./server.js",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules npx jest --coverage"
-  },
-  "keywords": [
-    "lambda-api",
-    "zod",
-    "sequelize"
-  ],
-  "dependencies": {
-    "lambda-api": "^1.0.1",
-    "sequelize": "^6.30.0",
-    "zod": "^3.21.4"
-  },
-  "devDependencies": {
-    "@aws-sdk/client-s3": "^3.304.0",
-    "@aws-sdk/s3-request-presigner": "^3.304.0",
-    "cross-env": "^7.0.3",
-    "cross-fetch": "^3.1.5",
-    "dotenv": "^16.0.3",
-    "jest": "^29.5.0",
-    "mysql2": "^3.2.0",
-    "nodemon": "^2.0.22",
-    "sqlite3": "^5.1.6"
-  }
-}
+{
+  "name": "minimonolith",
+  "type": "module",
+  "version": "0.25.4",
+  "main": "index.js",
+  "license": "MIT",
+  "scripts": {
+    "start": "nodemon --inspect=0.0.0.0 ./server.js",
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules npx jest --coverage"
+  },
+  "keywords": [
+    "lambda-api",
+    "zod",
+    "sequelize"
+  ],
+  "dependencies": {
+    "@minimonolith/lib": "^0.13.1",
+    "lambda-api": "^1.0.3",
+    "sequelize": "^6.30.0",
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "@aws-sdk/client-s3": "^3.304.0",
+    "@aws-sdk/s3-request-presigner": "^3.304.0",
+    "cross-env": "^7.0.3",
+    "cross-fetch": "^3.1.5",
+    "dotenv": "^16.0.3",
+    "jest": "^29.5.0",
+    "mysql2": "^3.2.0",
+    "nodemon": "^2.0.22",
+    "sqlite3": "^5.1.6"
+  }
+}

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

@@ -1,68 +1,70 @@
-'use strict';
-
-import url from 'url';
-
-import LOG_SERVICE from '../../log/index.js';
-
-import CORS_HEADERS from '../../middleware/postCors/corsHeaders.js';
-
-const getBody = req => {
-  return new Promise((resolve, reject) => {
-    let body = '';
-    req.on('data', chunk => { body += chunk; });
-    req.on('end', () => { resolve(body !== '' ? body : null); });
-  });
-};
-
-const getJWTClaims = authHeader => {
-  const b64JWT = authHeader.split(" ")[1];
-  const b64Claims = b64JWT.split('.')[1];
-  return JSON.parse(Buffer.from(b64Claims, 'base64').toString());
-}
-
-const getLambdaEvent = (req, queryString, jwtClaims, body) => {
-  const event = {
-    path: req.url,
-    httpMethod: req.method,
-    queryStringParameters: queryString,
-    requestContext: {
-      authorizer: { jwt: { claims: jwtClaims }, },
-      http: { method: req.method, path: req.url },
-    },
-    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;
-};
-
-export default lambdaHandler => async (req, res) => {
-  try {
-    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 getBody(req);
-    const body = tempBody ? tempBody : undefined;
-
-    const lambdaEvent = getLambdaEvent(req, queryString, jwtClaims, body);
-    const lambdaRes = await lambdaHandler(lambdaEvent, null)
-
-    res.statusCode = lambdaRes.statusCode;
-    for (let k in CORS_HEADERS) res.setHeader(k, CORS_HEADERS[k]);
-    res.end(lambdaRes.body);
-
-  } catch(SERVER_ERROR) {
-    LOG_SERVICE.post({ SERVER_ERROR });
-    res.statusCode = 500;
-    for (let k in CORS_HEADERS) res.setHeader(k, CORS_HEADERS[k]);
-    res.end(JSON.stringify({ REQUEST_PARSING_ERROR: SERVER_ERROR.toString() }));
-  }
-}
+'use strict';
+
+import url from 'url';
+
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+import CORS_HEADERS from '../../api/corsHeaders.js';
+
+const getBody = req => {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => { body += chunk; });
+    req.on('end', () => { resolve(body !== '' ? body : null); });
+  });
+};
+
+const getJWTClaims = authHeader => {
+  const b64JWT = authHeader.split(" ")[1];
+  const b64Claims = b64JWT.split('.')[1];
+  return JSON.parse(Buffer.from(b64Claims, 'base64').toString());
+}
+
+const getLambdaEvent = (req, queryString, jwtClaims, body) => {
+  const event = {
+    path: req.url,
+    httpMethod: req.method,
+    queryStringParameters: queryString,
+    requestContext: {
+      authorizer: { jwt: { claims: jwtClaims }, },
+      http: { method: req.method, path: req.url },
+    },
+    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;
+};
+
+export default lambdaHandler => async (req, res) => {
+  try {
+    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 getBody(req);
+    const body = tempBody ? tempBody : undefined;
+
+    const lambdaEvent = getLambdaEvent(req, queryString, jwtClaims, body);
+    const lambdaRes = await lambdaHandler(lambdaEvent, null)
+
+    res.statusCode = lambdaRes.statusCode;
+    for (let k in CORS_HEADERS) res.setHeader(k, CORS_HEADERS[k]);
+    res.end(lambdaRes.body);
+
+  } catch(SERVER_ERROR) {
+    //LOG_SERVICE.post({ SERVER_ERROR });
+    console.log({ SERVER_ERROR });
+    res.statusCode = 500;
+    for (let k in CORS_HEADERS) res.setHeader(k, CORS_HEADERS[k]);
+    res.end(JSON.stringify({ REQUEST_PARSING_ERROR: SERVER_ERROR.toString() }));
+  }
+}

package/server/getServerFactory/handler.js

@@ -0,0 +1,17 @@
+import http from 'http';
+import path from 'path';
+
+import getNodejsServerHandler from '../getNodejsServerHandler/index.js';
+
+export default async ({ body, SERVICES }) => {
+    const envFile = body.envFile;
+    const modulesFolder = body.modulesFolder;
+
+    await SERVICES.environment.postEnvFile.handler({ envFile, modulesFolder });
+
+    return (lambdaHandler) => {
+        const serverHandler = getNodejsServerHandler(lambdaHandler);
+        const server = http.createServer(serverHandler);
+        return server;
+    }
+}

package/server/getServerFactory/in.js

@@ -0,0 +1,8 @@
+import path from 'path';
+
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    envFile: z.string().default('.env'),
+    modulesFolder: z.string().default('node_modules'+path.sep),
+});

package/server/getServerFactory/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.function();

package/server/services.js

@@ -0,0 +1 @@
+export default ['getServerFactory'];

package/service/getParsedCode/handler.js

@@ -0,0 +1,22 @@
+export default ({ body }) => {
+    const moduleName = body.moduleName;
+    const serviceCode = body.serviceCode;
+
+    const servicePathParts = serviceCode.split(":");
+    const pathParams = servicePathParts.slice(1).map(param => `:${param}`);
+    const rawServiceName = servicePathParts[0];
+    const serviceName = rawServiceName[0] === '!' ?
+        rawServiceName.substring(1) : rawServiceName;
+
+    const relativeServiceRoute = `${rawServiceName}`+
+        `${pathParams.length > 0 ? '/' : ''}${pathParams.join("/")}`;
+
+    const serviceRoute = relativeServiceRoute[0]==='!' ?
+      `/${relativeServiceRoute.substring(1)}/${moduleName}` :
+      `/${moduleName}/${relativeServiceRoute}`;
+
+    console.log('serviceRoute', '['+relativeServiceRoute+']');
+    console.log('serviceRoute', relativeServiceRoute.substring(1), 'fdfd', serviceRoute);
+
+    return { serviceName, serviceRoute };
+};

package/service/getParsedCode/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    serviceCode: z.string(),
+});

package/service/getParsedCode/out.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    serviceName: z.string(),
+    serviceRoute: z.string(),
+});

package/service/getParsedEvent/handler.js

@@ -0,0 +1,12 @@
+export default ({ body }) => {
+  const event = body.event;
+
+  const { params, query, requestContext } = event;
+  const claims = requestContext.authorizer?.jwt?.claims
+
+  const tempUnifiedBody = { ...event.body, ...params, ...query };
+  const unifiedBody = Object.keys(tempUnifiedBody).length > 0 ?
+        tempUnifiedBody : undefined;
+
+  return { body: unifiedBody, claims };
+}

package/service/getParsedEvent/in.js

@@ -0,0 +1,5 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    event: z.unknown(),
+});

package/service/getParsedEvent/out.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    body: z.unknown(),
+    claims: z.unknown(),
+});

package/{src/method/getResponseCode/index.js → service/getResponseCode/handler.js}

@@ -1,9 +1,11 @@
-const typeToResponseCode = {
-  post: 201,
-  delete: 204,
-}
-
-export default methodType => {
-  if (methodType in typeToResponseCode) return typeToResponseCode[methodType];
-  else return 200;
-}
+const typeToResponseCode = {
+  post: 201,
+  delete: 204,
+}
+
+export default ({ body }) => {
+  const methodType = body;
+
+  if (methodType in typeToResponseCode) return typeToResponseCode[methodType];
+  else return 200;
+}

package/service/getResponseCode/in.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.enum(['get','post','patch','put','delete']);

package/service/getResponseCode/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.number();

package/service/getRouteCode/handler.js

@@ -0,0 +1,15 @@
+const getUpperSnakeCase = str => {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase();
+}
+
+export default ({ body }) => {
+    const moduleName = body.moduleName;
+    const serviceName = body.serviceName;
+
+    const snakeModuleName = getUpperSnakeCase(moduleName);
+    const snakeServiceName = getUpperSnakeCase(serviceName);
+    return snakeModuleName + '_' + snakeServiceName;
+};

package/service/getRouteCode/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    serviceName: z.string(),
+});

package/service/getRouteCode/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () => z.string();

package/service/getType/handler.js

@@ -0,0 +1,11 @@
+const methodsAvailable = ['post', 'get', 'patch', 'put', 'delete'];
+
+export default ({ body }) => {
+    const serviceName = body.serviceName;
+
+    const methodMatched = serviceName.match(/^[a-z]*/);
+    if (!methodMatched || !methodsAvailable.includes(methodMatched[0]))
+        throw new Error('UNKNOWN_METHOD_TYPE: ' + serviceName);
+
+    return methodMatched[0];
+}

package/service/getType/in.js

@@ -0,0 +1,5 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    serviceName: z.string(),
+});

package/service/getType/out.js

@@ -0,0 +1,3 @@
+import { z } from '@minimonolith/lib';
+
+export default () =>  z.string();

package/{src/method → service}/postResponse/index.js

@@ -1,13 +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);
-};
+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/service/postRoute/handler.js

@@ -0,0 +1,82 @@
+//import LOG_SERVICE from '../../log/index.js';
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+export default async ({ body, ROUTE_CODE, SERVICES }) => {
+    const moduleName = body.moduleName;
+    const serviceCode = body.serviceCode;
+
+    const { serviceName, serviceRoute } = await SERVICES.service
+        .getParsedCode.handler({ moduleName, serviceCode });
+
+    const service =
+        await SERVICES.api.getService.handler({ moduleName, serviceName });
+
+    //const method = await SERVICES.service.getType.handler({ serviceName });
+    const ADDITIONAL_KEYS = { MODELS: await SERVICES.api.getModels.handler() };
+
+    const handler = async (event, res) => {
+        const { body: inBody, claims } =
+            await SERVICES.service.getParsedEvent.handler({ event });
+        //const service =
+        //    await SERVICES.api.getService.handler({ moduleName, serviceName });
+
+        let parsedInBody = inBody;
+        //console.log('service', service);
+
+        //if (service.in) {
+            const validationIn = await SERVICES.validation
+                .getParsedAsync.handler({ ROUTE_CODE: ROUTE_CODE+'_IN',
+                    VALIDATOR: service.in, input: inBody });
+
+            if (validationIn?.error) {
+                //LOG_SERVICE.post({ VALIDATION_ERROR: validationIn.error });
+                console.log({ VALIDATION_ERROR: validationIn.error });
+                res.status(400).json(validationIn.error);
+                return;
+            }
+
+            if (validationIn) parsedInBody = validationIn.parsedBody;
+        //}
+
+        let outBody = undefined;
+        try {
+            outBody = await service
+                .rawHandler(parsedInBody, claims);
+
+        } catch (SERVICE_ERROR) {
+            if (!service.error) {
+                //LOG_SERVICE.post({ SERVICE_ERROR });
+                console.log({ SERVICE_ERROR });
+                res.status(500).json(SERVICE_ERROR);
+                return;
+            }
+
+            outBody = await service.error(parsedInBody, claims);
+        }
+
+        let parsedOutBody = outBody;
+        //if (service.out) {
+            const validationOut = await SERVICES.validation
+                .getParsedAsync.handler({ ROUTE_CODE: ROUTE_CODE+'_OUT',
+                    VALIDATOR: service.out, input: outBody });
+
+            if (validationOut?.error) {
+                //LOG_SERVICE.post({ VALIDATION_ERROR: validationOut.error });
+                console.log({ VALIDATION_ERROR: validationOut.error });
+                res.status(400).json(validationOut.error);
+                return;
+            }
+
+            if (validationOut) parsedOutBody = validationOut.parsedBody;
+        //}
+
+        //console.log('method', method);
+        const serviceResponseCode =
+            //await SERVICES.service.getResponseCode.handler(method);
+            await SERVICES.service.getResponseCode.handler(service.type);
+        return res.status(serviceResponseCode).json(parsedOutBody);
+    };
+
+    await SERVICES.api.postRoute.handler({
+        method: service.type, route: serviceRoute, handler });
+};

package/service/postRoute/in.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    moduleName: z.string(),
+    serviceCode: z.string(),
+});

package/service/services.js

@@ -0,0 +1,9 @@
+export default [
+    'postRoute',
+    'getParsedCode',
+    //'getType',
+    //'getRouteCode',
+    //'postResponse',
+    'getParsedEvent',
+    'getResponseCode',
+];

package/validation/getParsedAsync/handler.js

@@ -0,0 +1,38 @@
+import { /*LOG_SERVICE,*/ VALIDATION_MODULE } from '@minimonolith/lib';
+
+export default async ({ body, SERVICES }) => {
+  const ROUTE_CODE = body.ROUTE_CODE;
+  const VALIDATOR = body.VALIDATOR;
+  const input = body.input;
+  const ADDITIONAL_KEYS = body.ADDITIONAL_KEYS;
+
+  const EVENT_CONTEXT = { SERVICES, body: input };
+  //console.log('EVENT_CONTEXT', EVENT_CONTEXT);
+
+  if (!VALIDATOR && input) {
+    const MESSAGE = { ROUTE_CODE,
+        VALIDATION_ERROR: JSON.stringify({ message: 'BODY_NOT_ALLOWED' }) };
+    //LOG_MODULE.postError(MESSAGE);
+    console.error(MESSAGE);
+    return { error: MESSAGE };
+  }
+
+  if (!VALIDATOR) return undefined;
+
+  const zodobject = await VALIDATION_MODULE.getZodObject(ROUTE_CODE,
+      VALIDATOR(EVENT_CONTEXT));
+
+  const VALIDATION_RESULT = await VALIDATION_MODULE.getZodObject(ROUTE_CODE,
+      VALIDATOR(EVENT_CONTEXT)).safeParseAsync(input);
+  const VALIDATION_ERROR = VALIDATION_RESULT.error?.format();
+
+  if (VALIDATION_ERROR) {
+    const MESSAGE = { ROUTE_CODE,
+        VALIDATION_ERROR: JSON.stringify(VALIDATION_ERROR) };
+    //LOG_MODULE.postError(MESSAGE);
+    console.error(MESSAGE);
+    return { error: MESSAGE };
+  }
+
+  return { parsedBody: VALIDATION_RESULT.data };
+}

package/validation/getParsedAsync/in.js

@@ -0,0 +1,9 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    ROUTE_CODE: z.string(),
+    VALIDATOR: z.unknown(),
+    input: z.unknown(),
+    //ADDITIONAL_KEYS: z.object(),
+    ADDITIONAL_KEYS: z.unknown(),
+});

package/validation/getParsedAsync/out.js

@@ -0,0 +1,6 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    error: z.unknown().optional(),
+    parsedBody: z.unknown().optional(),
+});

package/validation/services.js

@@ -0,0 +1 @@
+export default ['getParsedAsync'];