minimonolith 0.2.12 → 0.4.0

package/index.js

@@ -1,9 +1,6 @@
 import { z } from 'zod';
 
-import { serviceHandler } from './src/serviceHandler/index.js';
-import { healthHandler } from './src/healthHandler/index.js';
-import { createAPI, apiHandler } from './src/apiHandler/index.js';
+import { createAPI } from './src/apiHandler/index.js';
 import { runLambdaServer, loadEnvVariables } from './src/lambdaServer/index.js';
 
-export { runLambdaServer, loadEnvVariables,
-  createAPI, apiHandler, serviceHandler, healthHandler, z };
+export { runLambdaServer, loadEnvVariables, createAPI, z };

package/package.json

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

package/src/apiHandler/createAPI.js

@@ -1,5 +1,9 @@
 import lambdaAPICreateAPI from 'lambda-api';
 
+import { healthHandler } from '../healthHandler/index.js';
+import { serviceHandler } from '../serviceHandler/index.js';
+import { apiHandler } from './apiHandler.js';
+
 const addCORS = API =>  {
   API.use((req, res, next) => { res.cors(); next(); });
   API.use((err, req, res, next) => { res.cors(); next(); });
@@ -18,6 +22,14 @@ const createAPI = () => {
 
   addCORS(API);
 
+  API.registerService = (SERVICE_NAME, SRC_FOLDER='', MODULE_FOLDER='node_modules/') => 
+    serviceHandler(API, SERVICE_NAME, SRC_FOLDER, MODULE_FOLDER);
+
+  API.registerHealthService = () =>
+    healthHandler(API);
+
+  API.handler = () => apiHandler(API);
+
   return API;
 }
 

package/src/databaseHandler/modelsHandler.js

@@ -5,8 +5,11 @@ export const registerModel = (serviceName, modelSchema) => {
 }
 
 export const loadModels = (orm, types) => {
-  return Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
+  const MODELS = Object.keys(modelSchemas).reduce((loadedModels, serviceName) => {
     loadedModels[serviceName] = modelSchemas[serviceName](orm, types);
     return loadedModels;
   }, {});
+
+  Object.entries(MODELS).forEach(([serviceName, model]) => { model.associate(MODELS); });
+  return MODELS;
 }

package/src/serviceHandler/getMethodRouteCode.js

@@ -0,0 +1,14 @@
+const getUpperSnakeCase = str => {
+  return str
+    .replace(/([a-z])([A-Z])/g, '$1_$2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+    .toUpperCase();
+}
+
+const getMethodRouteCode = (SERVICE_NAME, METHOD_NAME) => {
+  const serviceName = getUpperSnakeCase(SERVICE_NAME);
+  const methodName = getUpperSnakeCase(METHOD_NAME);
+  return serviceName + '_' + methodName;
+}
+
+export { getMethodRouteCode };

package/src/serviceHandler/getMethodType.js

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

package/src/serviceHandler/serviceHandler.js

@@ -3,9 +3,11 @@ import url from 'url'
 import { getProjectRoot } from '../pathHandler/index.js';
 import { registerModel } from '../databaseHandler/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='node_modules/') => {
+const serviceHandler = 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}/`;
@@ -17,8 +19,9 @@ const serviceHandler = async (API, SERVICE_NAME, SRC_FOLDER='', MODULE_FOLDER='n
     const SERVICE_METHODS = await registerMethods(SERVICE_MODULE.methods)(SERVICE_URL);
 
     Object.keys(SERVICE_METHODS).forEach(METHOD_NAME => {
-      API[METHOD_NAME](`/${SERVICE_NAME}/${METHOD_NAME}`, async (req, res) => {
-        const ROUTE_CODE = SERVICE_NAME.toUpperCase()+'_'+METHOD_NAME.toUpperCase();
+      const methodType = getMethodType(METHOD_NAME);
+      API[methodType](`/${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);
         res.status(statusCode).json(body);

package/todoList/delete/valid.js

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

package/todoList/get/valid.js

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

package/todoList/index.js

@@ -0,0 +1,5 @@
+import { modelSchema } from './model.js';
+
+const methods = ['get', 'post', 'delete'];
+
+export { modelSchema, methods };

package/todoList/model.js

@@ -0,0 +1,17 @@
+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

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