minimonolith 0.18.0 → 0.19.0

package/.env.example

@@ -1,4 +1,4 @@
 MM_API_DB_DIALECT=sqlite
 MM_API_DB_STORAGE=:memory:
-MM_API_PROD_ENV=false
-MM_API_LOCAL_ENV=true
+MM_API_PROD_ENV=FALSE
+MM_API_DEV_ENV=TRUE

package/README.md

@@ -106,7 +106,7 @@ This file validates the `get:id` method's input, ensuring that the provided `id`
 // todo/get/valid.js
 import { z, DB_VALIDATION } from 'minimonolith';
 
-export default (MODELS, ROUTE_CODE) => ({
+export default ({ MODELS }) => ({
   id: z.string()
     .superRefine(DB_VALIDATION.isSafeInt('id'))
     .transform(id => parseInt(id))
@@ -114,6 +114,29 @@ export default (MODELS, ROUTE_CODE) => ({
 })
 ```
 
+## App Environments
+
+There are 4 possible environments: DEV=TRUE & PROD=FALSE, DEV=TRUE & PROD=TRUE, DEV=FALSE & PROD=TRUE, DEV=FALSE & PROD=TRUE
+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
+  1. Its current only difference is it makes it crash on error at service registration phase
+2. The "new concept" QA environments (PROD=FALSE) aim at logging data about the system which on production environments would be forbiden personal information
+  1. 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 MM_API_DEV ENV [TRUE/FALSE] and MM_API_PROD_ENV [TRUE/FALSE]:
+
+```makefile
+# .env standard dev environment
+MM_API_DEV_ENV=TRUE
+MM_API_PROD_ENV=FALSE
+[...]
+```
+
 ## Database Authentication
 
 To set up authentication for the database, you need to provide the necessary environment variables in a `.env` file. Depending on the database dialect the required variables will differ.
@@ -121,27 +144,32 @@ To set up authentication for the database, you need to provide the necessary env
 For MySQL:
 
 ```makefile
+MM_API_DEV_ENV=TRUE
+MM_API_PROD_ENV=FALSE
 MM_API_DB_DIALECT=mysql
 MM_API_DB_HOST=<your_database_endpoint>
 MM_API_DB_PORT=<your_database_port>
 MM_API_DB_DATABASE=<your_database_name>
 MM_API_DB_USERNAME=<your_database_username>
 MM_API_DB_PASSWORD=<your_database_password>
-MM_API_LOCAL_ENV=true
-MM_API_PROD_ENV=false
 ```
 
 For SQLite:
 
 ```makefile
+MM_API_DEV_ENV=TRUE
+MM_API_PROD_ENV=FALSE
 MM_API_DB_DIALECT=sqlite
 MM_API_DB_STORAGE=:memory: # For in-memory SQLite database
 # Or
 MM_API_DB_STORAGE=path/to/your/sqlite/file.db # For file-based SQLite database
 MM_API_DB_DATABASE=<your_database_name>
-MM_API_LOCAL_ENV=true
-MM_API_PROD_ENV=false
 ```
 
-Make sure to replace the placeholders with your actual database credentials. The `MM_API_LOCAL_ENV` variable is used to allow Sequelize to alter table structure automatically when working locally, while the `MM_API_PROD_ENV` variable controls logging of secret credentials for debugging purposes in non-production environments.
-
+Make sure to replace the placeholders with your actual database credentials.
+- `MM_API_DEV_ENV=TRUE` allows Sequelize to alter table structure automatically when working locally
+- `MM_API_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/package.json

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

package/src/api/apiHandler.js

@@ -1,5 +1,7 @@
+import { logger } from '../logger/index.js';
+
 const apiHandler = API => async (event, context) => {
-  console.log({
+  logger.log({
     ROUTE_CODE: 'LAMBDA_EVENT',
     EVENT_PATH: event.path,
     EVENT_METHOD: event.httpMethod,

package/src/api/createAPI.js

@@ -4,6 +4,7 @@ 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';
@@ -16,7 +17,7 @@ const addCORS = API =>  {
     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);
-    console.log('OPTIONS_SUCCESS');
+    //logger.log('OPTIONS_SUCCESS');
     res.status(200).send({})
   });
 };
@@ -35,9 +36,9 @@ const createAPI = () => {
 
   API.handler = async () => {
     if (API.ORM) API.MODELS = await loadAndSyncModels(API);
-    else console.log({ ROUTE_CODE, INFO: 'NO_DATABASE_REGISTERED' });
+    else logger.log({ ROUTE_CODE, INFO: 'NO_DATABASE_REGISTERED' });
 
-    console.log({ ROUTE_CODE, INFO: 'LISTENING' });
+    logger.log({ ROUTE_CODE, INFO: 'LISTENING' });
     return apiHandler(API);
   }
 

package/src/crasher/crasher.js

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

package/src/crasher/index.js

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

package/src/database/databaseService.js

@@ -1,6 +1,9 @@
 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 => {
@@ -9,7 +12,7 @@ const establishConnection = async ORM => {
 
   while (connectionRetries < MAX_RETRIES) {
     try {
-      console.log({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
+      logger.log({ ROUTE_CODE, AUTH_INTENT: connectionRetries });
       await ORM.authenticate();
       break;
 
@@ -32,14 +35,14 @@ const registerDatabaseService = async API => {
     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 };
 
-    if (!process.env.PROD_ENV) console.log({ ROUTE_CODE, MM_API_DB_VARS: { MM_API_DB_DIALECT,
+    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) {
-    console.error({ ROUTE_CODE, REGISTER_DB_ERROR });
-    if (process.env.MM_API_LOCAL_ENV) throw REGISTER_DB_ERROR;
+    logger.error({ ROUTE_CODE, REGISTER_DB_ERROR });
+    crasher(REGISTER_DB_ERROR);
   }
 };
 

package/src/development/serverHandler.js

@@ -2,6 +2,8 @@
 
 import url from 'url';
 
+import { logger } from '../logger/index.js';
+
 const loadBody = req => {
   return new Promise((resolve, reject) => {
     let body = '';
@@ -59,7 +61,7 @@ const getServerHandler = lambdaHandler => async (req, res) => {
     res.statusCode = lambdaRes.statusCode;
     res.end(lambdaRes.body);
 
-  } catch(SERVER_ERROR) { console.log({ SERVER_ERROR }); }
+  } catch(SERVER_ERROR) { logger.log({ SERVER_ERROR }); }
 }
 
 export { getServerHandler };

package/src/health/healthService.js

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

package/src/logger/index.js

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

package/src/logger/logger.js

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

package/src/model/loadModels.js

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

package/src/service/methodHandler.js

@@ -1,3 +1,5 @@
+import { logger } from '../logger/index.js';
+
 const methodHandler = async (res, METHOD, EVENT_CONTEXT) => {
   const { body, ROUTE_CODE } = EVENT_CONTEXT;
 
@@ -6,17 +8,16 @@ const methodHandler = async (res, METHOD, EVENT_CONTEXT) => {
     const validation = await METHOD.VALIDATOR(EVENT_CONTEXT).safeParseAsync(body);
     if (validation.success) {
       const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
-      //const METHOD_RESPONSE = await internalMethodHandler(METHOD, EVENT_CONTEXT);
-      console.log({ ROUTE_CODE, METHOD_RESPONSE: METHOD_RESPONSE ? METHOD_RESPONSE.toString(): METHOD_RESPONSE });
+      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();
-    console.error({ ROUTE_CODE, VALIDATION_ERROR });
+    logger.error({ ROUTE_CODE, VALIDATION_ERROR });
     res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR });
   }
   catch (METHOD_ERROR) {
-    console.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack });
+    logger.error({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack });
     res.status(500).json({ ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack.toString() });
   }
 };

package/src/service/registerMethod.js

@@ -1,7 +1,10 @@
 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) => {
 
@@ -9,14 +12,14 @@ const registerMethod = async (SERVICE_NAME, SERVICE_URL, METHOD_NAME, METHOD_ROU
   const method = { VALIDATOR: EVENT_CONTEXT => z.undefined() };
 
   try {
-    console.log('  FOUND_METHOD', METHOD_NAME);
+    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))) {
 
-      console.log('  FOUND_VALIDATOR');
+      logger.log('  FOUND_VALIDATOR');
 
       const Z_ELEMENTS = (await import(VALIDATOR_URL)).default;
       method.VALIDATOR = EVENT_CONTEXT => optionalZObject(Z_ELEMENTS(EVENT_CONTEXT));
@@ -25,8 +28,8 @@ const registerMethod = async (SERVICE_NAME, SERVICE_URL, METHOD_NAME, METHOD_ROU
     return method;
 
   } catch (REGISTER_METHOD_ERROR) {
-    console.error({ ROUTE_CODE, REGISTER_METHOD_ERROR, STACK_TRASE: REGISTER_METHOD_ERROR.stack });
-    if (process.env.MM_API_LOCAL_ENV) { throw REGISTER_METHOD_ERROR; }
+    logger.error({ ROUTE_CODE, REGISTER_METHOD_ERROR, STACK_TRASE: REGISTER_METHOD_ERROR.stack });
+    crasher(REGISTER_METHOD_ERROR);
   }
 };
 

package/src/service/registerService.js

@@ -3,6 +3,8 @@ import url from 'url'
 
 import { getProjectRoot } from '../path/index.js';
 import { registerModel } from '../model/index.js';
+import { logger } from '../logger/index.js';
+import { crasher } from '../crasher/index.js';
 import { methodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
@@ -13,23 +15,23 @@ const ROUTE_CODE = 'REGISTER_SERVICE';
 
 const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) => {
   try {
-    console.log(ROUTE_CODE, SERVICE_NAME);
+    logger.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 (fs.existsSync(url.fileURLToPath(`${SERVICE_URL}model.js`))) {
-      console.log('  FOUND_MODEL');
+      logger.log('  FOUND_MODEL');
       registerModel(SERVICE_NAME, SERVICE_URL);
     }
 
-    console.log('METHODS_TO_BE_REGISTERED', SERVICE_MODULE.default);
+    logger.log('METHODS_TO_BE_REGISTERED', SERVICE_MODULE.default);
 
     API.SERVICES[SERVICE_NAME] = {}; const SERVICE_METHODS = [];
     for (const METHOD_CODE of SERVICE_MODULE.default) {
       const { METHOD_NAME, METHOD_ROUTE } = parseMethodCode(SERVICE_NAME, METHOD_CODE);
-      console.log('REGISTERING_ROUTE', METHOD_ROUTE);
+      logger.log('REGISTERING_ROUTE', METHOD_ROUTE);
 
       const METHOD_ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
 
@@ -55,13 +57,13 @@ const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) =>
       });
     };
   } catch (REGISTER_SERVICE_ERROR) {
-    console.error({
+    logger.error({
       ROUTE_CODE,
       SERVICE_NAME,
       REGISTER_SERVICE_ERROR,
       STACK_TRASE: REGISTER_SERVICE_ERROR.stack,
     });
-    if (process.env.MM_API_LOCAL_ENV) { throw REGISTER_SERVICE_ERROR; }
+    crasher(REGISTER_SERVICE_ERROR);
   }
 }
 

package/src/service/validationHandler.js

@@ -1,16 +0,0 @@
-const validationHandler = async (res, METHOD, EVENT_CONTEXT) => {
-  const { body, ROUTE_CODE } = EVENT_CONTEXT;
-
-  const validation = await METHOD.VALIDATOR(EVENT_CONTEXT).safeParseAsync(body);
-  if (validation.success) {
-    const METHOD_RESPONSE = await METHOD.handler(EVENT_CONTEXT);
-    console.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();
-  console.error({ ROUTE_CODE, VALIDATION_ERROR });
-  res.status(400).json({ ROUTE_CODE, VALIDATION_ERROR });
-};
-
-export { validationHandler };