minimonolith 0.24.1 → 0.25.4

package/README.md

@@ -1,208 +1,209 @@
-# minimonolith
-
-[![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.
-
-In addition to its simplicity, `minimonolith` enables seamless inter-service communication within your API. This allows services to call one another's functionality without directly importing them, fostering a modular design. For example, you can call the get method of the todo service from the todoList service using SERVICES.todo.get({ id }). By registering services within the API, you can easily call their methods from other services, which not only promotes a clean architecture but also paves the way for future support of automated end-to-end testing.
-
-## Example Project
-
-Here's an example project using `minimonolith`:
-
-```go
-.
-├── package.json
-├── .gitignore
-├── .env
-├── server.js                  // For local development
-├── index.js                   // Root of the code in a deployed AWS Lambda
-└── todo
-    ├── index.js               // Service 'todo' exported method handlers are declared here
-    ├── model.js               // Optional: Sequelize model for service 'todo' is declared here
-    └── get
-        ├── index.js           // Service 'todo' method 'get' handler
-        └── valid.js           // Optional: Method 'get' handler validation, if body not empty
-```
-
-### server.js
-
-This file is used for local development. It runs a local server using `minimonolith`'s `getServer` function:
-
-```js
-// server.js
-import { getServerFactory } from 'minimonolith';
-
-const getServer = await getServerFactory()(;
-const { lambdaHandler } = await import('./index.js');
-
-getServer(lambdaHandler).listen(8080);
-```
-
-### index.js
-
-This file serves as the root of the code in a deployed AWS Lambda:
-
-```js
-// index.js
-'use strict';
-
-import { getNewAPI } from 'minimonolith';
-
-const API = getNewAPI({
-  PROD_ENV: process.env.PROD_ENV,
-  DEV_ENV: process.env.DEV_ENV,
-});
-
-await API.postHealthService();
-await API.postService('todo');
-await API.postDatabaseService({
-  DB_DIALECT: process.env.DB_DIALECT,
-  DB_HOST: process.env.DB_HOST,
-  DB_PORT: process.env.DB_PORT,
-  DB_DB: process.env.DB_DB,
-  DB_USER: process.env.DB_USER,
-  DB_PASS: process.env.DB_PASS,
-});
-
-export const lambdaHandler = await API.getSyncedHandler();
-```
-
-### todo/index.js
-
-Here, we declare the method handlers for the `todo` service:
-
-```js
-// todo/index.js
-export default ['getAll', 'get:id', 'post', 'patch:id', 'delete:id'];
-```
-
-### todo/model.js
-
-In this file, we define a Sequelize model for the `todo` service:
-
-```js
-// todo/model.js
-export default serviceName => (orm, types) => {
-  const schema = orm.define(serviceName, {
-    name: {
-      type: types.STRING,
-      allowNull: false
-    },
-  });
-
-  schema.associate = MODELS => {}; // e.g. MODELS.todo.belongsTo(MODELS.todoList, {...});
-
-  return schema;
-};
-```
-
-### todo/get/index.js
-
-This file contains the `get:id` method handler for the `todo` service. It retrieves a todo item by its ID:
-
-```js
-// todo/get/index.js
-export default async ({ body, MODELS }) =>  {
-  return await MODELS.todo.findOne({ where: { id: body.id } });
-}
-```
-
-### todo/get/valid.js
-
-This file validates the `get:id` method's input, ensuring that the provided `id` is a string and exists in the `todo` model:
-
-```js
-// todo/get/valid.js
-import { z, zdb } from 'minimonolith';
-
-export default ({ MODELS }) => ({
-  id: z.string()
-    .superRefine(zdb.isSafeInt('id'))
-    .transform(id => parseInt(id))
-    .superRefine(zdb.exists(MODELS.todo, 'id')),
-})
-```
-
-## Response Codes
-
-### Success
-
-- POST -> 201
-- DELETE -> 204
-- Everything else -> 200
-
-### Invalid Request
-
-- ANY -> 400
-
-### Runtime Error
-
-- ANY -> 500
-
-## App Environments
-
-There are 4 possible environments:
-1. DEV=TRUE + PROD=FALSE: This is the standard DEV environment
-2. DEV=FALSE + PROD=FALSE: This is the standard QA environment
-3. DEV=FALSE + PROD=TRUE: This is the stnadard PROD environment
-4. DEV=TRUE + PROD=TRUE: This allows to test the behavior of PROD within the "new concept" of DEV environment
-
-To better understand their relevance:
-1. The "new concept" DEV environments (DEV=TRUE) aim to make the api crash if an "important" error happens
-  - Its current only difference is it makes it crash on error at service registration phase
-  - Some may think QA should also fail on "important" errors They can use DEV=TRUE there But some do training activities on QA that must be minimally disrupted
-2. The "new concept" QA environments (PROD=FALSE) aim at logging data about the system which on production environments would be forbiden personal information
-  - This is relevant because replication of QA activities (even security QA activities) depend heavily on this
-
-The current App environment is determined on the values of DEV ENV [TRUE/FALSE] and PROD_ENV [TRUE/FALSE]
-Assuming using same env variables as used at index.js above
-
-```makefile
-# .env standard dev environment
-DEV_ENV=TRUE
-PROD_ENV=FALSE
-TEST_ENV=FALSE
-[...]
-```
-
-*NOTICE*: Default environment it is assumed standard PROD environment (DEV=FLASE + PROD=TRUE)
-- This means that sequelize will not alter automatically tables having mismatches with defined model.js files
-- Database dialect/credentials detected will not be printed
-- Critical errors will not make the app crash
-
-## Database Authentication
-
-To set up authentication for the database you need to pass necessary variables to postDatabaseService as at index.js above.
-Assuming using same env variable names as at index.js above
-
-For MySQL:
-
-```makefile
-DEV_ENV=TRUE
-PROD_ENV=FALSE
-DB_DIALECT=mysql
-DB_HOST=<your_database_endpoint>
-DB_PORT=<your_database_port>
-DB_DB=<your_database_name>
-DB_USER=<your_database_username>
-DB_PASS=<your_database_password>
-```
-
-For SQLite in memory:
-
-```makefile
-DEV_ENV=TRUE
-PROD_ENV=FALSE
-DB_DIALECT=sqlite
-DB_DB=<your_database_name>
-DB_STORAGE=:memory: # Need to also pass to API.postDatabaseService()
-```
-
-Make sure to replace the placeholders with your actual database credentials.
-- `DEV_ENV=TRUE` allows Sequelize to alter table structure automatically when working locally
-- `PROD_ENV=FALSE` allows logging of DB credentials for debugging purposes in non-production environments
-  - We consider high quality logging important for app performance and evolution
-  - However we recommend automatic DB credentials updates (daily) High quality logging does not mean
-    giving away your infraestructure to hackers
-  - At the risk of stating the obvious do not store personal information at the QA database
+# minimonolith
+
+[![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.
+
+In addition to its simplicity, `minimonolith` enables seamless inter-service communication within your API. This allows services to call one another's functionality without directly importing them, fostering a modular design. For example, you can call the get method of the todo service from the todoList service using SERVICES.todo.get({ id }). By registering services within the API, you can easily call their methods from other services, which not only promotes a clean architecture but also paves the way for future support of automated end-to-end testing.
+
+## Example Project
+
+Here's an example project using `minimonolith`:
+
+```go
+.
+├── package.json
+├── .gitignore
+├── .env
+├── server.js                  // For local development
+├── index.js                   // Root of the code in a deployed AWS Lambda
+└── todo
+    ├── services.js            // Module 'todo' exported services  are declared here
+    ├── model.js               // Optional: Sequelize model for module 'todo' is declared here
+    └── get
+        ├── handler.js         // Module 'todo' service 'get' handler
+        └── in.js           // Optional: Service 'get' input validation, if body not empty
+        └── in.js           // Optional: Service 'get' output validation, if body not empty
+```
+
+### server.js
+
+This file is used for local development. It runs a local server using `minimonolith`'s `getServer` function:
+
+```js
+// server.js
+import { getServerFactory } from 'minimonolith';
+
+const getServer = await getServerFactory()(;
+const { lambdaHandler } = await import('./index.js');
+
+getServer(lambdaHandler).listen(8080);
+```
+
+### index.js
+
+This file serves as the root of the code in a deployed AWS Lambda:
+
+```js
+// index.js
+'use strict';
+
+import { getNewAPI } from 'minimonolith';
+
+const API = getNewAPI({
+  PROD_ENV: process.env.PROD_ENV,
+  DEV_ENV: process.env.DEV_ENV,
+});
+
+await API.postHealthService();
+await API.postModule('todo');
+await API.postDatabaseService({
+  DB_DIALECT: process.env.DB_DIALECT,
+  DB_HOST: process.env.DB_HOST,
+  DB_PORT: process.env.DB_PORT,
+  DB_DB: process.env.DB_DB,
+  DB_USER: process.env.DB_USER,
+  DB_PASS: process.env.DB_PASS,
+});
+
+export const lambdaHandler = await API.getSyncedHandler();
+```
+
+### todo/index.js
+
+Here, we declare the service routes for the `todo` module:
+
+```js
+// todo/services.js
+export default ['getAll', 'get:id', 'post', 'patch:id', 'delete:id'];
+```
+
+### todo/model.js
+
+In this file, we define a Sequelize model for the `todo` module:
+
+```js
+// todo/model.js
+export default moduleName => (orm, types) => {
+  const schema = orm.define(moduleName, {
+    name: {
+      type: types.STRING,
+      allowNull: false
+    },
+  });
+
+  schema.associate = MODELS => {}; // e.g. MODELS.todo.belongsTo(MODELS.todoList, {...});
+
+  return schema;
+};
+```
+
+### todo/get/index.js
+
+This file contains the `get:id` route for the `todo` module. It retrieves a todo item by its ID:
+
+```js
+// todo/get/index.js
+export default async ({ body, MODELS }) =>  {
+  return await MODELS.todo.findOne({ where: { id: body.id } });
+}
+```
+
+### todo/get/valid.js
+
+This file validates the `get:id` service's input, ensuring that the provided `id` is a string and exists in the `todo` model:
+
+```js
+// todo/get/valid.js
+import { z, zdb } from 'minimonolith';
+
+export default ({ MODELS }) => ({
+  id: z.string()
+    .superRefine(zdb.getIsSafeInt('id'))
+    .transform(id => parseInt(id))
+    .superRefine(zdb.getExists(MODELS.todo, 'id')),
+})
+```
+
+## Response Codes
+
+### Success
+
+- POST -> 201
+- DELETE -> 204
+- Everything else -> 200
+
+### Invalid Request
+
+- ANY -> 400
+
+### Runtime Error
+
+- ANY -> 500
+
+## App Environments
+
+There are 4 possible environments:
+1. DEV=TRUE + PROD=FALSE: This is the standard DEV environment
+2. DEV=FALSE + PROD=FALSE: This is the standard QA environment
+3. DEV=FALSE + PROD=TRUE: This is the stnadard PROD environment
+4. DEV=TRUE + PROD=TRUE: This allows to test the behavior of PROD within the "new concept" of DEV environment
+
+To better understand their relevance:
+1. The "new concept" DEV environments (DEV=TRUE) aim to make the api crash if an "important" error happens
+  - Its current only difference is it makes it crash on error at service registration phase
+  - Some may think QA should also fail on "important" errors They can use DEV=TRUE there But some do training activities on QA that must be minimally disrupted
+2. The "new concept" QA environments (PROD=FALSE) aim at logging data about the system which on production environments would be forbiden personal information
+  - This is relevant because replication of QA activities (even security QA activities) depend heavily on this
+
+The current App environment is determined on the values of DEV ENV [TRUE/FALSE] and PROD_ENV [TRUE/FALSE]
+Assuming using same env variables as used at index.js above
+
+```makefile
+# .env standard dev environment
+DEV_ENV=TRUE
+PROD_ENV=FALSE
+TEST_ENV=FALSE
+[...]
+```
+
+*NOTICE*: Default environment it is assumed standard PROD environment (DEV=FLASE + PROD=TRUE)
+- This means that sequelize will not alter automatically tables having mismatches with defined model.js files
+- Database dialect/credentials detected will not be printed
+- Critical errors will not make the app crash
+
+## Database Authentication
+
+To set up authentication for the database you need to pass necessary variables to postDatabaseService as at index.js above.
+Assuming using same env variable names as at index.js above
+
+For MySQL:
+
+```makefile
+DEV_ENV=TRUE
+PROD_ENV=FALSE
+DB_DIALECT=mysql
+DB_HOST=<your_database_endpoint>
+DB_PORT=<your_database_port>
+DB_DB=<your_database_name>
+DB_USER=<your_database_username>
+DB_PASS=<your_database_password>
+```
+
+For SQLite in memory:
+
+```makefile
+DEV_ENV=TRUE
+PROD_ENV=FALSE
+DB_DIALECT=sqlite
+DB_DB=<your_database_name>
+DB_STORAGE=:memory: # Need to also pass to API.postDatabaseService()
+```
+
+Make sure to replace the placeholders with your actual database credentials.
+- `DEV_ENV=TRUE` allows Sequelize to alter table structure automatically when working locally
+- `PROD_ENV=FALSE` allows logging of DB credentials for debugging purposes in non-production environments
+  - We consider high quality logging important for app performance and evolution
+  - However we recommend automatic DB credentials updates (daily) High quality logging does not mean
+    giving away your infraestructure to hackers
+  - At the risk of stating the obvious do not store personal information at the QA database

package/api/api.js

@@ -0,0 +1,5 @@
+let API = undefined;
+
+export const setAPI = api => { API = api; };
+
+export default () => API;

package/api/getModels/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default () => {
+    return API().MODELS;
+}

package/api/getModels/out.js

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

package/api/getNewAPI/handler.js

@@ -0,0 +1,53 @@
+import getLambdaAPI from 'lambda-api';
+
+import { getNewLib, /*LOG_SERVICE*/ } from '@minimonolith/lib';
+
+import { setAPI } from '../api.js';
+
+import CORS_HEADERS from '../corsHeaders.js';
+
+export default async ({ body, SERVICES }) => {
+    const DEV_ENV = body.DEV_ENV;
+    const PROD_ENV = body.PROD_ENV;
+    const TEST_ENV = body.TEST_ENV;
+
+    const API = {
+        ROUTES: getLambdaAPI(),
+        //LIB: await getNewLib({ DEBUG: 'TRUE' }),
+        LIB: await getNewLib(),
+        SCHEMAS: {},
+        MODELS: {},
+        ORM: undefined,
+        DEV_ENV: DEV_ENV,
+        PROD_ENV: PROD_ENV,
+        TEST_ENV: TEST_ENV,
+    };
+
+    API.ROUTES.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');
+        }
+        //console.log('passes here');
+        res.cors(); next();
+    });
+
+    API.ROUTES.options('/*', (req, res) => {
+        for (let k in CORS_HEADERS) { res.header(k, CORS_HEADERS[k]); }
+        res.status(200).send({})
+    });
+
+    API.postHealthService = SERVICES.health.post.handler;
+    API.postModule = SERVICES.api.postModule.handler;
+    API.postDatabaseService = SERVICES.database.post.handler;
+    API.getSyncedHandler =  SERVICES.api.getSyncedHandler.handler;
+
+    setAPI(API);
+
+    return API;
+};

package/api/getNewAPI/in.js

@@ -0,0 +1,7 @@
+import { z } from '@minimonolith/lib';
+
+export default () => ({
+    DEV_ENV: z.string().default('FALSE'),
+    PROD_ENV: z.string().default('TRUE'),
+    TEST_ENV: z.string().default('FALSE'),
+});

package/api/getNewAPI/out.js

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

package/api/getORM/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default () => {
+    return API().ORM;
+}

package/api/getORM/out.js

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

package/api/getSchemas/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default () => {
+    return API().SCHEMAS;
+}

package/api/getSchemas/out.js

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

package/api/getService/handler.js

@@ -0,0 +1,8 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    const moduleName = body.moduleName;
+    const serviceName = body.serviceName;
+
+    return API().LIB.SERVICES[moduleName][serviceName];
+}

package/api/getService/in.js

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

package/api/getService/out.js

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

package/api/getServices/handler.js

@@ -0,0 +1,5 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    return API().LIB.SERVICES;
+}

package/api/getServices/out.js

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

package/api/getSyncedHandler/handler.js

@@ -0,0 +1,40 @@
+import getLambdaAPI from 'lambda-api';
+//import { LOG_SERVICE } from '@minimonolith/lib';
+
+import API from '../api.js';
+
+export default async ({ body, ROUTE_CODE, SERVICES }) => {
+
+  API().ROUTES.use((err, req, res, next) => {
+    //LOG_SERVICE.postError({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
+    console.log({ ROUTE_CODE: 'LAMBDA_API', ERROR: err });
+    res.cors(); //next();
+    res.status(500).send({ ROUTE_CODE: 'LAMBDA_API', ERROR: err.message });
+  });
+
+  if (API().ORM) await SERVICES.model.getSynced.handler();
+
+  API().LIB.postAdditionalKey('MODELS', API().MODELS);
+
+  //LOG_SERVICE.post({ ROUTE_CODE, INFO: 'LISTENING' });
+  console.log({ ROUTE_CODE, INFO: 'LISTENING' });
+
+  return async (event, context) => {
+    /*
+    LOG_SERVICE.post({
+      ROUTE_CODE: 'LAMBDA_EVENT',
+      PATH: event.requestContext?.http?.path,
+      METHOD: event.requestContext?.http?.method,
+    });
+    */
+    console.log({
+      ROUTE_CODE: 'LAMBDA_EVENT',
+      PATH: event.requestContext?.http?.path,
+      METHOD: event.requestContext?.http?.method,
+    });
+
+    //API().ROUTES.routes(true);
+    //return await api.run({ event, context });
+    return await API().ROUTES.run(event, context);
+  };
+};

package/api/getSyncedHandler/in.js

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

package/api/getSyncedHandler/out.js

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

package/api/postModel/handler.js

@@ -0,0 +1,8 @@
+import API from '../api.js';
+
+export default ({ body }) => {
+    const moduleName = body.moduleName;
+    const model = body.model;
+
+    API().MODELS[moduleName] = model;
+}

package/api/postModel/in.js

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