minimonolith 0.23.1 → 0.24.0

package/README.md

@@ -1,6 +1,6 @@
 # minimonolith
 
-[![codecov](https://codecov.io/gh/DeepHackDev/minimonolith-lib/branch/master/graph/badge.svg?token=ORFNKKJRSE)](https://codecov.io/gh/DeepHackDev/minimonolith-lib)
+[![codecov](https://codecov.io/gh/DeepHackDev/minimonolith-api/branch/master/graph/badge.svg?token=ORFNKKJRSE)](https://codecov.io/gh/DeepHackDev/minimonolith-lib)
 
 `minimonolith` is a lightweight library designed to help you build serverless APIs using AWS Lambda, with a focus on simplicity and ease of use. The library provides a straightforward structure to organize your API's services, methods, validation, and models while handling common tasks like database connection and request validation.
 

package/package.json

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

package/src/api/postService/index.js

@@ -28,5 +28,6 @@ export default async (SERVICE_NAME, SRC_FOLDER='', MODULES_FOLDER='node_modules/
     for (const METHOD_CODE of SERVICE_MODULE.default) await METHOD_SERVICE.post(SERVICE_NAME, SERVICE_URL, METHOD_CODE);
 
   } catch (META_METHOD_ERROR) {
-    ERROR_SERVICE.postCompiletime({ META_SERVICE_NAME, META_METHOD_NAME, META_METHOD_ERROR }); }
+    ERROR_SERVICE.postCompiletime({ META_SERVICE_NAME, META_METHOD_NAME, META_METHOD_ERROR });
+  }
 };

package/src/method/post/index.js

@@ -24,24 +24,27 @@ export default async (SERVICE_NAME, SERVICE_URL, METHOD_CODE) => {
       VALIDATOR: await VALIDATION_SERVICE.get(METHOD_NAME, SERVICE_URL),
     };
 
+    // Register service within API
     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 });
     }
 
-    API_SERVICE.get().VALIDATORS[SERVICE_NAME][METHOD_NAME] = () => {
+    // Register service within API
+    API_SERVICE.get().VALIDATORS[SERVICE_NAME][METHOD_NAME] = (body, claims=undefined) => {
       const { MODELS, SERVICES, VALIDATORS } = API_SERVICE.get();
-      return METHOD.VALIDATOR({ MODELS, SERVICES, VALIDATORS });
+      return METHOD.VALIDATOR({ MODELS, SERVICES, VALIDATORS, body, claims });
     }
 
     const METHOD_TYPE = getType(METHOD_NAME);
 
+    // Register route forn lAMBDA API
     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;
+        if (await VALIDATION_SERVICE.postError(res, ROUTE_CODE, METHOD.VALIDATOR, body, claims)) return;
         await postResponse(res, ROUTE_CODE, METHOD.CONTROLLER, METHOD_TYPE, body, claims);
       }
       catch (METHOD_ERROR) { ERROR_SERVICE.postRuntime(res, ROUTE_CODE, METHOD_ERROR); }

package/src/middleware/postCors/corsHeaders.js

@@ -0,0 +1,6 @@
+export default {
+  'Access-Control-Allow-Origin': '*',
+  'Access-Control-Allow-Methods': 'OPTIONS, POST, GET, PUT, PATCH, DELETE',
+  'Access-Control-Allow-Headers': '*',
+  'Access-Control-Allow-Credentials': true,
+};

package/src/middleware/postCors/index.js

@@ -1,6 +1,8 @@
 import API_SERVICE from '../../api/index.js';
 import LOG_SERVICE from '../../log/index.js';
 
+import CORS_HEADERS from './corsHeaders.js';
+
 export default () =>  {
 
   API_SERVICE.get().use((req, res, next) => {
@@ -12,10 +14,7 @@ export default () =>  {
   });
 
   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);
+    for (let k in CORS_HEADERS) { res.header(k, CORS_HEADERS[k]); }
     res.status(200).send({})
   });
 };

package/src/server/getNodejsServerHandler/index.js

@@ -4,6 +4,8 @@ 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 = '';
@@ -54,11 +56,13 @@ export default lambdaHandler => async (req, res) => {
     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() }));
   }
 }

package/src/validation/postError/index.js

@@ -3,8 +3,9 @@ import LOG_SERVICE from '../../log/index.js';
 
 import getOptionalObject from '../getOptionalObject/index.js';
 
-export default async (res, ROUTE_CODE, VALIDATOR, input) => {
-  const { MODELS, SERVICES, VALIDATORS } = API_SERVICE.get(), EVENT_CONTEXT = { MODELS, SERVICES, VALIDATORS };
+export default async (res, ROUTE_CODE, VALIDATOR, input, claims) => {
+  const { MODELS, SERVICES, VALIDATORS } = API_SERVICE.get(),
+    EVENT_CONTEXT = { MODELS, SERVICES, VALIDATORS, body: input, claims };
 
   if (!VALIDATOR && input) {
     const MESSAGE = { ROUTE_CODE, VALIDATION_ERROR: JSON.stringify({ message: 'BODY_NOT_ALLOWED' }) };
@@ -14,9 +15,8 @@ export default async (res, ROUTE_CODE, VALIDATOR, input) => {
   }
 
   if (!VALIDATOR) return false;
-  
-  const VALIDATION_ERROR =
-    (await getOptionalObject(VALIDATOR(EVENT_CONTEXT)).safeParseAsync(input)).error?.format();
+  const VALIDATION_OBJECT = await VALIDATOR(EVENT_CONTEXT);
+  const VALIDATION_ERROR = (await getOptionalObject(VALIDATION_OBJECT).safeParseAsync(input)).error?.format();
 
   if (VALIDATION_ERROR) {
     const MESSAGE = { ROUTE_CODE, VALIDATION_ERROR: JSON.stringify(VALIDATION_ERROR) };