minimonolith 0.5.0 → 0.6.0

package/package.json

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

package/src/{apiHandler → createAPI}/createAPI.js

@@ -1,7 +1,8 @@
 import lambdaAPICreateAPI from 'lambda-api';
 
-import { healthHandler } from '../healthHandler/index.js';
-import { serviceHandler } from '../serviceHandler/index.js';
+import { registerHealthService } from '../registerHealthService/index.js';
+import { registerDatabaseService } from '../registerDatabaseService/index.js';
+import { registerService } from '../registerService/index.js';
 import { apiHandler } from './apiHandler.js';
 
 const addCORS = API =>  {
@@ -15,6 +16,10 @@ const addCORS = API =>  {
     console.log('OPTIONS_SUCCESS');
     res.status(200).send({})
   });
+};
+
+const addService = API => {
+
 }
 
 const createAPI = () => {
@@ -23,13 +28,17 @@ const createAPI = () => {
   addCORS(API);
 
   API.registerService = (SERVICE_NAME, SRC_FOLDER='', MODULE_FOLDER='node_modules/') => 
-    serviceHandler(API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER);
+    registerService(API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER);
+
+  API.registerHealthService = () => registerHealthService(API);
 
-  API.registerHealthService = () =>
-    healthHandler(API);
+  API.registerDatabaseService = async () => { await registerDatabaseService(API) };
 
   API.handler = () => apiHandler(API);
 
+  API.SERVICES = {};
+
+
   return API;
 }
 

package/src/registerDatabaseService/index.js

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

package/src/{databaseHandler/modelsHandler.js → registerDatabaseService/loadModels.js}

@@ -1,3 +1,5 @@
+const ROUTE_CODE = 'LOAD_MODELS';
+
 const modelSchemas = {};
 
 export const registerModel = async (SERVICE_NAME, SERVICE_URL) => {
@@ -5,7 +7,7 @@ export const registerModel = async (SERVICE_NAME, SERVICE_URL) => {
   modelSchemas[SERVICE_NAME] = SERVICE_MODEL_MODULE.modelSchema(SERVICE_NAME);
 }
 
-export const loadModels = (orm, types) => {
+const loadModels = (orm, types) => {
   const MODELS = Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
     loadedModels[serviceName] = modelSchemas[serviceName](orm, types);
     return loadedModels;
@@ -14,3 +16,15 @@ export const loadModels = (orm, types) => {
   Object.entries(MODELS).forEach(([serviceName, model]) => { model.associate(MODELS); });
   return MODELS;
 }
+
+const loadAndSyncModels = async (orm, types) => {
+  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'Loading sequelize models');
+  const MODELS = loadModels(orm, types);
+
+  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'Syncing sequelize');
+  await orm.sync({ alter: process.env.LOCAL ? true : false });
+
+  return MODELS;
+};
+
+export { loadAndSyncModels };

package/src/registerDatabaseService/registerDatabaseService.js

@@ -0,0 +1,61 @@
+import Sequelize from 'sequelize';
+//import SequelizeDynamo from 'dynamo-sequelize';
+import { loadAndSyncModels } from './loadModels.js';
+
+const ROUTE_CODE = 'DB_CONNECTION';
+
+const tryAuthenticating = async (orm, connectionRetries) => {
+  if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'Authenticating sequelize intent:', connectionRetries);
+  await orm.authenticate();
+};
+
+const createORMInstance = () => {
+  if (process.env.TEST_ENVIRONMENT) {
+    const orm = new Sequelize('sqlite::memory:');
+    orm.options.logging = false;
+    return orm;
+  } else {
+    const dialect = 'mysql', logging = false, dialectOptions = null;
+    const db=process.env.DB_DB, user=process.env.DB_USER,
+      pass=process.env.DB_PASS, host=process.env.DB_ENDPOINT;
+    console.log(ROUTE_CODE,
+      'Trying to connect using { ' + user + ', ' + pass + ', ' + host + ', ' + db + ' }');
+    return new Sequelize(db, user, pass, { host, dialect, dialectOptions, logging });
+  }
+};
+
+
+const establishConnection = async () => {
+  const MAX_RETRIES = 5;
+  const INITIAL_WAIT_TIME_MS = 100;
+  let connectionRetries = 0;
+  let waitTime = INITIAL_WAIT_TIME_MS;
+  const orm = createORMInstance();
+
+  while (connectionRetries < MAX_RETRIES) {
+    try {
+      await tryAuthenticating(orm, connectionRetries);
+      break;
+    } catch (databaseConnectionError) {
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+      waitTime *= 2; connectionRetries += 1;
+    }
+  }
+
+  return orm;
+};
+
+const registerDatabaseService = async API => {
+  try {
+    const orm = await establishConnection();
+    API.MODELS = await loadAndSyncModels(orm, Sequelize);
+
+  } catch (DB_ERROR) {
+    console.error({
+      ROUTE_CODE,
+      DB_ERROR
+    });
+  }
+};
+
+export { registerDatabaseService };

package/src/{healthHandler → registerHealthService}/healthHandler.js

@@ -1,14 +1,14 @@
-const healthCheck = () => {
+const healthHandler = () => {
   return "API running...";
 }
 
-const healthHandler = API => {
+const registerHealthService = API => {
   API.get('/', async (req, res) => {
     console.log('HEALTH_CHECK ENTERING');
-    const response = healthCheck();
+    const response = healthHandler();
     console.log('HEALTH_CHECK SUCCESS');
     return { response };
   });
 }
 
-export { healthHandler };
+export { registerHealthService };

package/src/registerHealthService/index.js

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

package/src/registerService/index.js

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

package/src/{serviceHandler → registerService}/methodHandler.js

@@ -1,16 +1,13 @@
-import { databaseHandler } from '../databaseHandler/index.js';
 import { validationHandler } from './validationHandler.js';
 
-const methodHandlerErrorThrower = async (e, METHOD, ROUTE_CODE) => {
-
-  const { MODELS, databaseErrorResponse } = await databaseHandler(e);
-  if (databaseErrorResponse) return databaseErrorResponse;
+const methodHandlerErrorThrower = async (event, API, METHOD, ROUTE_CODE) => {
 
   const validationErrorResponse =
-    await validationHandler(e, METHOD, MODELS, ROUTE_CODE);
+    await validationHandler(event, METHOD, API.MODELS, ROUTE_CODE);
   if (validationErrorResponse) return validationErrorResponse;
 
-  const methodResponse = await METHOD.handler(e, MODELS);
+  const eventContext = { event, MODELS: API.MODELS, SERVICES: API.SERVICES, ROUTE_CODE };
+  const methodResponse = await METHOD.handler(eventContext);
 
   if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, methodResponse);
   return methodResponse;
@@ -28,10 +25,10 @@ const methodErrorHandler = (METHOD_ERROR, METHOD, ROUTE_CODE) => {
   return methodErrorResponse;
 }
 
-const methodHandler = async (METHOD, ROUTE_CODE, e) => {
+const methodHandler = async (API, METHOD, ROUTE_CODE, event) => {
   try {
     if (!process.env.TEST_ENVIRONMENT) console.log(ROUTE_CODE, 'ENTERING');
-    const methodResponse = await methodHandlerErrorThrower(e, METHOD, ROUTE_CODE);
+    const methodResponse = await methodHandlerErrorThrower(event, API, METHOD, ROUTE_CODE);
     return methodResponse;
   } catch (METHOD_ERROR) {
     const methodErrorResponse = methodErrorHandler(METHOD_ERROR, METHOD, ROUTE_CODE);

package/src/{serviceHandler/serviceHandler.js → registerService/registerService.js}

@@ -1,31 +1,35 @@
 import url from 'url'
 
 import { getProjectRoot } from '../pathHandler/index.js';
-import { registerModel } from '../databaseHandler/index.js';
+import { registerModel } from '../registerDatabaseService/index.js';
 import { methodHandler } from './methodHandler.js';
 import { getMethodType } from './getMethodType.js';
 import { getMethodRouteCode } from  './getMethodRouteCode.js';
 import { registerMethods } from './registerMethods.js';
 
-const serviceHandler = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) => {
+const registerService = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) => {
   try {
     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 (SERVICE_MODULE.modelSchema) registerModel(SERVICE_NAME, SERVICE_MODULE.modelSchema);
+    const SERVICE_MODULE = await import(`${SERVICE_URL}index.js`);
     if (SERVICE_MODULE.model) registerModel(SERVICE_NAME, SERVICE_URL);
     const SERVICE_METHODS = await registerMethods(SERVICE_MODULE.methods)(SERVICE_URL);
 
+    API.SERVICES[SERVICE_NAME] = {};
     Object.keys(SERVICE_METHODS).forEach(METHOD_NAME => {
-      const methodType = getMethodType(METHOD_NAME);
-      API[methodType](`/${SERVICE_NAME}/${METHOD_NAME}`, async (req, res) => {
+
+      API.SERVICES[SERVICE_NAME][METHOD_NAME] = async (req, res) => {
         const ROUTE_CODE = getMethodRouteCode(SERVICE_NAME, METHOD_NAME);
         const { statusCode, body } =
-          await methodHandler(SERVICE_METHODS[METHOD_NAME], ROUTE_CODE, req);
+          await methodHandler(API, SERVICE_METHODS[METHOD_NAME], ROUTE_CODE, req);
         res.status(statusCode).json(body);
-      });
+      }
+
+      const methodType = getMethodType(METHOD_NAME);
+      API[methodType](`/${SERVICE_NAME}/${METHOD_NAME}`,
+        API.SERVICES[SERVICE_NAME][METHOD_NAME]);
     });
   } catch (SERVICE_HANDLER_ERROR) {
     console.error({
@@ -36,4 +40,4 @@ const serviceHandler = async (API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER) => {
   }
 }
 
-export { serviceHandler };
+export { registerService };

package/src/databaseHandler/databaseHandler.js

@@ -1,86 +0,0 @@
-import Sequelize from 'sequelize';
-//import SequelizeDynamo from 'dynamo-sequelize';
-import { loadModels } from './modelsHandler.js';
-
-const dialect = 'mysql';
-const logging = false;
-const dialectOptions = null;
-const ROUTE_CODE = 'DB_CONNECTION';
-let sequelize = null;
-let MODELS = null;
-
-const tryAuthenticating = async (connectionRetries) => {
-  if (!process.env.TEST_ENVIRONMENT)
-    console.log(ROUTE_CODE, 'Authenticating sequelize intent:', connectionRetries);
-  await sequelize.authenticate();
-};
-
-const createSequelizeInstance = () => {
-  if (process.env.TEST_ENVIRONMENT) {
-    sequelize = new Sequelize('sqlite::memory:');
-    sequelize.options.logging = false;
-  } else {
-    const db=process.env.DB_DB, user=process.env.DB_USER,
-      pass=process.env.DB_PASS, host=process.env.DB_ENDPOINT;
-    console.log(ROUTE_CODE,
-      'Trying to connect using { ' + user + ', ' + pass + ', ' + host + ', ' + db + ' }');
-    sequelize = new Sequelize(db, user, pass, { host, dialect, dialectOptions, logging });
-  }
-};
-
-
-const establishConnection = async () => {
-  const MAX_RETRIES = 5;
-  const INITIAL_WAIT_TIME_MS = 100;
-  let connectionRetries = 0;
-  let waitTime = INITIAL_WAIT_TIME_MS;
-
-  while (connectionRetries < MAX_RETRIES) {
-    try {
-      if (!sequelize) createSequelizeInstance();
-      await tryAuthenticating(connectionRetries);
-      break;
-    } catch (databaseConnectionError) {
-      await new Promise(resolve => setTimeout(resolve, waitTime));
-      waitTime *= 2; connectionRetries += 1;
-      createSequelizeInstance();
-    }
-  }
-
-  return sequelize;
-};
-
-
-const loadAndSyncModels = async () => {
-  if (!process.env.TEST_ENVIRONMENT)
-    console.log(ROUTE_CODE, 'Loading sequelize models');
-  MODELS = loadModels(sequelize, Sequelize);
-
-  if (!process.env.TEST_ENVIRONMENT)
-    console.log(ROUTE_CODE, 'Syncing sequelize');
-  await sequelize.sync({ alter: process.env.LOCAL ? true : false });
-};
-
-const databaseHandler = async () => {
-  try {
-    await establishConnection();
-    await loadAndSyncModels();
-    return { MODELS };
-  } catch (DB_ERROR) {
-    console.error({
-      ROUTE_CODE,
-      DB_ERROR
-    });
-
-    const databaseErrorResponse = {
-      statusCode: 500,
-      body: {
-        ROUTE_CODE,
-        error: DB_ERROR.toString(),
-      },
-    };
-    return { databaseErrorResponse };
-  }
-};
-
-export { databaseHandler };

package/src/databaseHandler/index.js

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

package/src/healthHandler/index.js

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

package/src/serviceHandler/index.js

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

package/todoList/delete/valid.js

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-
-const VALIDATOR = (MODELS, ROUTE_CODE) =>
-  z.object({
-    id: z.number(),
-  }).strict();
-
-export { VALIDATOR };

package/todoList/get/valid.js

@@ -1,6 +0,0 @@
-import { z } from 'zod';
-
-const VALIDATOR = (MODELS, ROUTE_CODE) =>
-  z.undefined();
-
-export { VALIDATOR };

package/todoList/index.js

@@ -1,2 +0,0 @@
-export const model = true;
-export const methods = ['get', 'post', 'delete'];

package/todoList/model.js

@@ -1,17 +0,0 @@
-export const modelSchema = serviceName => (sequelize, type) => {
-  const schema = sequelize.define(serviceName, {
-    name: {
-      type: type.STRING,
-      allowNull: false
-    },
-  });
-
-  schema.associate = MODELS => {
-    schema.hasMany(MODELS.todo, {
-      foreignKey: 'todoListId',
-      as: 'todoElements',
-    });
-  };
-
-  return schema;
-};

package/todoList/post/valid.js

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-
-const VALIDATOR = (MODELS, ROUTE_CODE) =>
-  z.object({
-    name: z.string(),
-  }).strict();
-
-export { VALIDATOR };