minimonolith 0.21.2 → 0.22.1

package/README.md

@@ -31,12 +31,12 @@ This file is used for local development. It runs a local server using `minimonol
 
 ```js
 // server.js
-import { devEnvironment } from 'minimonolith';
-const { runLambdaServer, loadEnvFile } = await devEnvironment();
-loadEnvFile(); // .env file loaded by default
+import { getServer } from 'minimonolith';
 
-const lambdaRootFile = await import('./index.js');
-runLambdaServer(lambdaRootFile.lambdaHandler, 8080);
+const lambdaServer = await getServer(); // loads .env by default, could give '.env.test'
+const { lambdaHandler } = await import('./index.js');
+
+lambdaServer(lambdaHandler, 8080);
 ```
 
 ### index.js
@@ -47,15 +47,21 @@ This file serves as the root of the code in a deployed AWS Lambda:
 // index.js
 'use strict';
 
-import { createAPI } from 'minimonolith';
+import { getNewAPI } from 'minimonolith';
+
+// Define environment
+const { DEV_ENV, PROD_ENV, TEST_ENV } = process.env;
+const API = await getNewAPI({ DEV_ENV, PROD_ENV, TEST_ENV });
 
-const API = createAPI();
+await API.postHealthService();
+await API.postService('todo');
+await API.postCORSService();
 
-await API.registerHealthService(); // Adds health check service to route /
-await API.registerService('todo'); // Registers all /todo routes with respective method handlers
-await API.registerDatabaseService(); // Sets up the database connection
+// Database Authentication
+const { DB_DIALECT, DB_HOST, DB_DB, DB_USER, DB_PASSWORD, DB_STORAGE } = process.env;
+await API.postDatabaseService({ DB_DIALECT, DB_HOST, DB_DB, DB_USER, DB_PASSWORD, DB_STORAGE });
 
-export const lambdaHandler = await API.handler(); // Synchronizes Sequelize models with the database
+export const lambdaHandler = await API.getSyncedHandler()
 ```
 
 ### todo/index.js
@@ -114,6 +120,22 @@ export default ({ MODELS }) => ({
 })
 ```
 
+## 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:
@@ -129,52 +151,55 @@ To better understand their relevance:
 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 MM_API_DEV ENV [TRUE/FALSE] and MM_API_PROD_ENV [TRUE/FALSE]:
+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
-MM_API_DEV_ENV=TRUE
-MM_API_PROD_ENV=FALSE
+DEV_ENV=TRUE
+PROD_ENV=FALSE
+TEST_ENV=FALSE
 [...]
 ```
 
-*NOTICE*: If this variables are not added to .env/Lambda environment it is assumed standard PROD environment (DEV=FLASE + PROD=TRUE)
+*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 provide the necessary environment variables in a `.env` file. Depending on the database dialect the required variables will differ.
+To set up authentication for the database you need to pass necessary variables to postDatabaseService as at index.js above.
+Assuming using same env variables as used at index.js above
 
 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>
+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:
 
 ```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
+DEV_ENV=TRUE
+PROD_ENV=FALSE
+DB_DIALECT=sqlite
+DB_DB=<your_database_name>
+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>
+DB_STORAGE=path/to/your/sqlite/file.db # For file-based SQLite database
 ```
 
 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
+- `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

package/index.js

@@ -1,6 +1,15 @@
-import { z } from './src/zod/index.js';
-import { createAPI } from './src/api/index.js';
-import { DB_VALIDATION } from './src/database/index.js';
-import { createDevEnvironment, createTestEnvironment } from './src/development/index.js';
+import API_SERVICE from './src/api/index.js';
+import SERVER_SERVICE from './src/server/index.js';
+import VALIDATION_SERVICE from './src/validation/index.js';
+import AUTOTEST_SERVICE from './src/autotest/index.js';
 
-export { createDevEnvironment, createTestEnvironment, createAPI, z, DB_VALIDATION };
+const { getNewAPI } = API_SERVICE;
+const { getServerFactory } = SERVER_SERVICE;
+const { z, zdb } = VALIDATION_SERVICE;
+const { getMethodTest } = AUTOTEST_SERVICE;
+
+export {
+  getServerFactory, getNewAPI,
+  z, zdb,
+  getMethodTest,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.21.2",
+  "version": "0.22.1",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
@@ -21,6 +21,7 @@
   "devDependencies": {
     "@aws-sdk/client-s3": "^3.304.0",
     "@aws-sdk/s3-request-presigner": "^3.304.0",
+    "cross-fetch": "^3.1.5",
     "dotenv": "^16.0.3",
     "jest": "^29.5.0",
     "mysql2": "^3.2.0",

package/src/api/get/index.js

@@ -0,0 +1,19 @@
+import getLambdaAPI from 'lambda-api';
+
+import LOG_SERVICE from '../../log/index.js';
+import HEALTH_SERVICE from '../../health/index.js';
+import DATABASE_SERVICE from '../../database/index.js';
+import MIDDLEWARE_SERVICE from '../../middleware/index.js';
+
+import postService from '../postService/index.js';
+import getSyncedHandler from '../getSyncedHandler/index.js';
+
+const API = getLambdaAPI();
+API.postCORSMiddleware = MIDDLEWARE_SERVICE.postCors;
+API.postHealthService = HEALTH_SERVICE.post;
+API.postService = postService;
+API.postDatabaseService = DATABASE_SERVICE.post;
+API.postErrorMiddleware = MIDDLEWARE_SERVICE.postError;
+API.getSyncedHandler = getSyncedHandler;
+
+export default () => API;

package/src/api/getNewAPI/index.js

@@ -0,0 +1,13 @@
+import getAPI from '../get/index.js';
+
+export default ({ DEV_ENV='FALSE', PROD_ENV='TRUE', TEST_ENV='FALSE' } = {}) => {
+  getAPI().SERVICES = {};
+  getAPI().SCHEMAS = {};
+  getAPI().MODELS = {};
+  getAPI().ORM = undefined;
+  getAPI().DEV_ENV = DEV_ENV;
+  getAPI().PROD_ENV = PROD_ENV;
+  getAPI().TEST_ENV = TEST_ENV;
+  getAPI().postCORSMiddleware();
+  return getAPI();
+};

package/src/api/getSyncedHandler/index.js

@@ -0,0 +1,24 @@
+import MODEL_SERVICE from '../../model/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+import getAPI from '../get/index.js';
+
+const META_SERVICE='API', META_METHOD='GET_SYNCED_HANDLER', META_ROUTE=META_SERVICE+'_'+META_METHOD;
+
+export default async () => {
+  getAPI().postErrorMiddleware();
+  if (getAPI().ORM) await MODEL_SERVICE.getSynced();
+  //else LOG_SERVICE.post({ META_ROUTE, INFO: 'NO_DATABASE_SERVICE_POSTED' });
+
+  LOG_SERVICE.post({ META_ROUTE, INFO: 'LISTENING' });
+
+  return async (event, context) => {
+    LOG_SERVICE.post({
+      ROUTE_CODE: 'LAMBDA_EVENT',
+      PATH: event.requestContext?.http?.path,
+      METHOD: event.requestContext?.http?.method,
+    });
+
+    return await getAPI().run(event, context);
+  };
+};

package/src/api/index.js

@@ -1,4 +1,4 @@
-import { createAPI } from './createAPI.js';
-import { apiHandler } from './apiHandler.js';
+import get from './get/index.js';
+import getNewAPI from './getNewAPI/index.js';
 
-export { createAPI, apiHandler };
+export default { get, getNewAPI };

package/src/api/postService/index.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import url from 'url'
+
+import PATH_SERVICE from '../../path/index.js';
+import MODEL_SERVICE from '../../model/index.js';
+import LOG_SERVICE from '../../log/index.js';
+import METHOD_SERVICE from '../../method/index.js';
+import VALIDATION_SERVICE from '../../validation/index.js';
+import ERROR_SERVICE from '../../error/index.js';
+
+import getAPI from '../get/index.js';
+
+const META_SERVICE_NAME = 'API', META_METHOD_NAME = 'POST_SERVICE';
+
+export default async (SERVICE_NAME, SRC_FOLDER='', MODULES_FOLDER='node_modules/') => {
+
+  LOG_SERVICE.post(META_SERVICE_NAME, META_METHOD_NAME, SERVICE_NAME);
+  getAPI().SERVICES[SERVICE_NAME] = {};
+  try {
+
+    const projectRootPath = PATH_SERVICE.getProjectRoot(import.meta.url, MODULES_FOLDER)+'/';
+    const projectRelativeServicePath = './' + SRC_FOLDER + `${SERVICE_NAME}/`;
+    const SERVICE_URL = new URL(projectRelativeServicePath, projectRootPath);
+    await MODEL_SERVICE.post(SERVICE_NAME, SERVICE_URL);
+
+    const SERVICE_MODULE = await import(`${SERVICE_URL}index.js`);
+    LOG_SERVICE.post('METHODS_TO_BE_POSTED', SERVICE_MODULE.default);
+    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 }); }
+};

package/src/autotest/getMethodTest/back.index.js

@@ -0,0 +1,29 @@
+import url from 'url';
+import fetch from 'cross-fetch';
+
+import getTestServerResponse from '../getTestServerResponse/index.js';
+
+export default (serverHandler, expectedCode) => async params => {
+  const URL = new url.URL(params.path, 'http://localhost/');
+
+  const request = {
+    method: params.method,
+    url: URL.pathname + URL.search,
+    headers: {
+      ...params.headers,
+      'Content-Type': 'application/json',
+    },
+    on(eventName, callback) {
+      if (eventName === 'data' && params.body) {
+        callback(Buffer.from(JSON.stringify(params.body)));
+      }
+      if (eventName === 'end') { callback(); }
+    },
+  };
+
+  const response = getTestServerResponse();
+  serverHandler(request, response);
+
+  const result = await response.asyncResult();
+  expect(result.statusCode).toBe(expectedCode);
+}

package/src/autotest/getMethodTest/index.js

@@ -0,0 +1,12 @@
+export default async server => {
+  const fetch = (await import('cross-fetch')).default;
+
+  return async ({ path, method, expectedCode, headers, body }) => {
+
+    const port = server.address().port
+    const url = `http://localhost:${port}${path}`;
+
+    const response = await fetch(url, { method, headers, body });
+    expect(response.status).toBe(expectedCode);
+  };
+};

package/src/autotest/getTestServerResponse/index.js

@@ -0,0 +1,14 @@
+import http from 'http';
+
+export default () => {
+  let resolveAsyncResult;
+  const asyncResultPromise = new Promise(resolve => { resolveAsyncResult = resolve; });
+
+  const res = {
+    statusCode: null,
+    asyncResult: () => asyncResultPromise,
+    end: body => { res.body = body; resolveAsyncResult(res); },
+  };
+
+  return res;
+};

package/src/autotest/index.js

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

package/src/control/get/index.js

@@ -0,0 +1,3 @@
+export default async (METHOD_NAME, SERVICE_URL) => {
+  return (await import(new URL(`${METHOD_NAME}/index.js`, SERVICE_URL))).default;
+}

package/src/control/index.js

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

package/src/database/index.js

@@ -1,4 +1,4 @@
-import { registerDatabaseService } from './databaseService.js';
-import { DB_VALIDATION } from './validation.js';
+import post from './post/index.js';
+import postConnection from './postConnection/index.js';
 
-export { registerDatabaseService, DB_VALIDATION };
+export default { post, postConnection };

package/src/database/post/index.js

@@ -0,0 +1,28 @@
+import Sequelize from 'sequelize';
+//import SequelizeDynamo from 'dynamo-sequelize';
+
+import API_SERVICE  from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+import ERROR_SERVICE from '../../error/index.js';
+
+import postConnection from '../postConnection/index.js'
+
+const META_SERVICE='DATABASE', META_METHOD='POST', META_ROUTE=META_SERVICE+'_'+META_METHOD;
+
+export default async ({ DB_DIALECT='sqlite', DB_HOST=undefined, DB_PORT=undefined, DB_DB=undefined,
+  DB_USER=undefined, DB_PASS=undefined, DB_STORAGE=':memory:'} = {}) => {
+
+  try {
+    const SEQUELIZE_OPTIONS = { dialect: DB_DIALECT, host: DB_HOST,
+      port: DB_PORT, storage: DB_STORAGE, logging: false };
+
+    LOG_SERVICE.postQA({ META_ROUTE, DB_VARS: {
+      DB_DIALECT, DB_HOST, DB_PORT, DB_DB, DB_USER, DB_PASS, DB_STORAGE }});
+
+    API_SERVICE.get().ORM = new Sequelize(DB_DB, DB_USER, DB_PASS, SEQUELIZE_OPTIONS);
+    await postConnection(API_SERVICE.get().ORM);
+
+  } catch (META_METHOD_ERROR) {
+    ERROR_SERVICE.postCompiletime({ META_ROUTE, META_METHOD_ERROR });
+  }
+};

package/src/database/postConnection/index.js

@@ -0,0 +1,25 @@
+import LOG_SERVICE from '../../log/index.js';
+
+const META_SERVICE_NAME='DATABASE', META_METHOD_NAME='POST_CONNECTION';
+
+export default async ORM => {
+  const MAX_RETRIES = 5, INITIAL_WAIT = 100;
+  let connectionRetries = 0, waitTime = INITIAL_WAIT;
+
+  while (connectionRetries < MAX_RETRIES) {
+    try {
+      LOG_SERVICE.post({ META_SERVICE_NAME, META_METHOD_NAME, AUTH_INTENT: connectionRetries });
+      await ORM.authenticate();
+      break;
+
+    } catch (META_METHOD_ERROR) {
+      await new Promise(resolve => setTimeout(resolve, waitTime));
+
+      connectionRetries += 1;
+      const jitter = Math.random() * 0.3 + 0.7;
+      waitTime = Math.min(2 * waitTime * jitter, INITIAL_WAIT * Math.pow(2, MAX_RETRIES));
+    }
+  }
+
+  return connectionRetries;
+};

package/src/environment/getDBEnvVars/index.js

@@ -0,0 +1,4 @@
+export default envVars => {
+  const DB_ENV_VARS = ['DB_DIALECT', 'DB_HOST', 'DB_PORT', 'DB_DB', 'DB_USER', 'DB_PASS', 'DB_STORAGE'];
+  return Object.fromEntries(Object.entries(envVars).filter(([envVar]) => DB_ENV_VARS.includes(envVar)));
+}

package/src/environment/getENVEnvVars/index.js

@@ -0,0 +1,4 @@
+export default envVars => {
+  const API_ENV_VARS = ['DEV_ENV', 'PROD_ENV', 'TEST_ENV'];
+  return Object.fromEntries(Object.entries(envVars).filter(([envVar]) => API_ENV_VARS.includes(envVar)));
+}

package/src/environment/index.js

@@ -0,0 +1,4 @@
+import getENVEnvVars from './getENVEnvVars/index.js';
+import getDBEnvVars from './getDBEnvVars/index.js';
+
+export default { getENVEnvVars, getDBEnvVars };

package/src/{development/loadEnvFile.js → environment/postEnvFile/index.js}

@@ -2,13 +2,12 @@ import path from 'path';
 import url from 'url';
 import dotenv from 'dotenv';
 
-import { getProjectRoot } from '../path/index.js';
+import LOG_SERVICE from '../../log/index.js';
+import PATH_SERVICE from '../../path/index.js';
 
-const loadEnvFile = (ENV_FILE, MODULE_FOLDER) => {
-  const projectRootFileUrl = getProjectRoot(import.meta.url, MODULE_FOLDER);
+export default (ENV_FILE, MODULE_FOLDER) => {
+  const projectRootFileUrl = PATH_SERVICE.getProjectRoot(import.meta.url, MODULE_FOLDER);
   const projectRootPath = url.fileURLToPath(projectRootFileUrl+'/');
   const envFilePath = path.resolve(projectRootPath, ENV_FILE)
   dotenv.config({ path: envFilePath });
 };
-
-export { loadEnvFile };

package/src/environment/postTestEnvironment/index.js

@@ -0,0 +1,6 @@
+export default () => {
+  process.env.DEV_ENV = 'TRUE';
+  process.env.PROD_ENV = 'FALSE';
+  process.env.DB_DIALECT = 'sqlite';
+  process.env.DB_STORAGE = ':memory:';
+}

package/src/error/index.js

@@ -0,0 +1,4 @@
+import postCompiletime from './postCompiletime/index.js';
+import postRuntime from './postRuntime/index.js';
+
+export default { postCompiletime, postRuntime };

package/src/error/postCompiletime/index.js

@@ -0,0 +1,13 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default ({ META_SERVICE_NAME, META_METHOD_NAME, ROUTE_CODE, META_METHOD_ERROR }) => {
+  LOG_SERVICE.postError({
+    META_SERVICE_NAME,
+    META_METHOD_NAME,
+    ROUTE_CODE,
+    META_METHOD_ERROR,
+    STACK_TRACE: META_METHOD_ERROR?.stack,
+  });
+  if (API_SERVICE.get().DEV_ENV==='TRUE') throw META_METHOD_ERROR;
+};

package/src/error/postRuntime/index.js

@@ -0,0 +1,7 @@
+import LOG_SERVICE from '../../log/index.js';
+
+export default (res, ROUTE_CODE, METHOD_ERROR) => {
+  const MESSAGE = { ROUTE_CODE, METHOD_ERROR: METHOD_ERROR.stack.toString() };
+  LOG_SERVICE.postError(MESSAGE);
+  res.status(500).json(MESSAGE);
+}

package/src/event/getParsedEvent/index.js

@@ -0,0 +1,9 @@
+export default event => {
+  const { body, params, query, requestContext } = event;
+  const claims = requestContext.authorizer?.jwt?.claims
+
+  const tempUnifiedBody = { ...body, ...params, ...query };
+  const unifiedBody = Object.keys(tempUnifiedBody).length > 0 ? tempUnifiedBody : undefined;
+
+  return { body: unifiedBody, claims };
+}

package/src/event/index.js

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

package/src/health/index.js

@@ -1,3 +1,3 @@
-import { registerHealthService } from './healthService.js';
+import post from './post/index.js';
 
-export { registerHealthService };
+export default { post };

package/src/health/post/index.js

@@ -0,0 +1,10 @@
+import API_SERVICE from '../../api/index.js';
+import LOG_SERVICE from '../../log/index.js';
+
+export default () => {
+  API_SERVICE.get().get('/', async (req, res) => {
+    const SERVICE_RESPONSE = "API_RUNNING";
+    LOG_SERVICE.post({ SERVICE_RESPONSE });
+    return { SERVICE_RESPONSE: "API_RUNNING" };
+  });
+}

package/src/log/index.js

@@ -0,0 +1,5 @@
+import post from './post/index.js';
+import postError from './postError/index.js';
+import postQA from './postQA/index.js';
+
+export default { post, postError, postQA };

package/src/log/post/index.js

@@ -0,0 +1,3 @@
+import API_SERVICE from '../../api/index.js';
+
+export default (...MESSAGE) => { console.log(...MESSAGE); };

package/src/log/postError/index.js

@@ -0,0 +1,3 @@
+import API_SERVICE from '../../api/index.js';
+
+export default (...ERROR) => { console.error(...ERROR); };

package/src/log/postQA/index.js

@@ -0,0 +1,3 @@
+import API_SERVICE from '../../api/index.js';
+
+export default (...MESSAGE) => { if (API_SERVICE.get().PROD_ENV==='FALSE') { console.log(...MESSAGE); } };

package/src/{service/parseMethodCode.js → method/getParsedCode/index.js}

@@ -1,4 +1,4 @@
-export const parseMethodCode = (SERVICE_NAME, METHOD_CODE) => {
+export default (SERVICE_NAME, METHOD_CODE) => {
   const methodPathParts = METHOD_CODE.split(":");
   const pathParams = methodPathParts.slice(1).map(param => `:${param}`);
   const rawMethodName = methodPathParts[0];

package/src/method/getResponseCode/index.js

@@ -0,0 +1,9 @@
+const typeToResponseCode = {
+  post: 201,
+  delete: 204,
+}
+
+export default methodType => {
+  if (methodType in typeToResponseCode) return typeToResponseCode[methodType];
+  else return 200;
+}

package/src/{service/getMethodRouteCode.js → method/getRouteCode/index.js}

@@ -5,10 +5,8 @@ const getUpperSnakeCase = str => {
     .toUpperCase();
 }
 
-const getMethodRouteCode = (SERVICE_NAME, METHOD_NAME) => {
+export default (SERVICE_NAME, METHOD_NAME) => {
   const snakeServiceName = getUpperSnakeCase(SERVICE_NAME);
   const snakeMethodName = getUpperSnakeCase(METHOD_NAME);
   return snakeServiceName + '_' + snakeMethodName;
-}
-
-export { getMethodRouteCode };
+};

package/src/{service/getMethodType.js → method/getType/index.js}

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

package/src/method/index.js

@@ -0,0 +1,7 @@
+import post from './post/index.js';
+import getParsedCode from './getParsedCode/index.js';
+import getType from './getType/index.js';
+import getRouteCode from './getRouteCode/index.js';
+import postResponse from './postResponse/index.js';
+
+export default { post, getParsedCode, getType, getRouteCode, postResponse };