@evershop/evershop 1.0.0-beta

package/src/lib/middleware/addMiddleware.js

@@ -0,0 +1,10 @@
+const { Handler } = require("./Handler");
+const { noDublicateId } = require("./noDuplicateId");
+
+module.exports.addMiddleware = function addMiddleware(middleware) {
+  if (noDublicateId(Handler.middlewares, middleware)) {
+    Handler.addMiddleware(middleware);
+  } else {
+    console.error(`Duplicate middleware id: ${middleware.id}`);
+  }
+}

package/src/lib/middleware/async.js

@@ -0,0 +1,25 @@
+const logger = require("../log/logger");
+const { setDelegate } = require("./delegate");
+
+module.exports = exports = {};
+
+exports.asyncMiddlewareWrapper = async function asyncMiddlewareWrapper(id, middlewareFunc, request, response, delegates, next) {
+  logger.log('info', `Executing middleware ${id}`);
+
+  try {
+    // If the middleware function has the next function as a parameter
+    let delegate = undefined;
+    if (middlewareFunc.length === 4) {
+      delegate = middlewareFunc(request, response, delegates, next);
+    } else {
+      delegate = middlewareFunc(request, response, delegates);
+    }
+    setDelegate(id, delegate, request);
+    await delegate;
+  } catch (e) {
+    // Log the error
+    logger.log('error', `Exception in middleware ${id}`, { message: e.message, stack: e.stack });
+    // Call error handler middleware if it is not called yet
+    next(e);
+  }
+}

package/src/lib/middleware/buildMiddlewareFunction.js

@@ -0,0 +1,65 @@
+const { existsSync } = require('fs');
+const { sep } = require('path');
+const { asyncMiddlewareWrapper } = require('./async');
+const eNext = require('./eNext');
+const isErrorHandlerTriggered = require('./isErrorHandlerTriggered');
+const { getDelegates } = require('./delegate');
+const { syncMiddlewareWrapper } = require('./sync');
+const isDevelopmentMode = require('../util/isDevelopmentMode');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * This function takes the defined middleware function and return a new one with wrapper
+ *
+ * @param {string} id
+ * @param {function} middleware: The middleware function
+ * @param {string} routeId: The route Id
+ * @param {string} before: The middleware function that executes after this one
+ * @param {string} after: The middleware function that executes before this one
+ * @returns {object} the middleware object
+ * @throws
+ */
+exports.buildMiddlewareFunction = function buildMiddlewareFunction(id, path) {
+  if (!/^[a-zA-Z0-9_]+$/.test(id)) {
+    throw new TypeError(`Middleware ID ${id} is invalid`);
+  }
+
+  const isRoutedLevel = !['all', 'global'].includes(path.split(sep).reverse()[1]);
+  // Check if the middleware is an error handler. 
+  // TODO: fix me
+  if (id === 'errorHandler' || id === 'apiErrorHandler') {
+    return (error, request, response, next) => {
+      const func = require(path);
+      if (request.currentRoute) {
+        func(error, request, response, getDelegates(request), next);
+      } else {
+        func(error, request, response, [], next);
+      }
+    };
+  } else {
+    return (request, response, next) => {
+      // Fix middleware removed during a request
+      if (isDevelopmentMode() && !existsSync(path)) {
+        next();
+      }
+      const func = require(path);
+      // If there response status is 404. We skip routed middlewares
+      if (response.statusCode === 404 && isRoutedLevel) {
+        next();
+      } else {
+        if (func.constructor.name === 'AsyncFunction') {
+          asyncMiddlewareWrapper(id, func, request, response, getDelegates(request), eNext(request, response, next));
+        } else {
+          syncMiddlewareWrapper(id, func, request, response, getDelegates(request), eNext(request, response, next));
+        }
+
+        // If middleware function does not have next function as a parameter
+        if (func.length < 4 && !isErrorHandlerTriggered(response)) {
+          next();
+        }
+      }
+    };
+  }
+};

package/src/lib/middleware/delegate.js

@@ -0,0 +1,22 @@
+const getDelegates = function getDelegates(request) {
+  return request.locals ? request.locals.delegates || {} : {};
+}
+
+const setDelegate = function setDelegate(id, value, request) {
+  if (request.locals) {
+    if (request.locals.delegates) {
+      request.locals.delegates[id] = value;
+    } else {
+      request.locals.delegates = {};
+      request.locals.delegates[id] = value;
+    }
+  } else {
+    request.locals = {};
+    request.locals.delegates = {};
+    request.locals.delegates[id] = value;
+  }
+}
+
+module.exports.getDelegates = getDelegates
+
+module.exports.setDelegate = setDelegate

package/src/lib/middleware/eNext.js

@@ -0,0 +1,15 @@
+const isErrorHandlerTriggered = require("./isErrorHandlerTriggered");
+
+function noop() { }
+
+function eNext(request, response, next) {
+  return (error) => {
+    if (!isErrorHandlerTriggered(response)) {
+      error ? next(error) : next();
+    } else {
+      noop();
+    }
+  }
+}
+
+module.exports = eNext;

package/src/lib/middleware/findDublicatedMiddleware.js

@@ -0,0 +1,20 @@
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+exports.findDublicatedMiddleware = function findDublicatedMiddleware(registeredMiddlewares, newMiddleware) {
+  return registeredMiddlewares.findIndex(
+    (middleware) => middleware.id === newMiddleware.id
+      && (
+        middleware.routeId === null
+        || middleware.scope === 'app'
+        || newMiddleware.routeId === null
+        || middleware.routeId === newMiddleware.routeId
+        || (middleware.scope === newMiddleware.scope && (
+          [middleware.routeId, newMiddleware.routeId].includes('admin')
+          || [middleware.routeId, newMiddleware.routeId].includes('frontStore')
+        )
+        )
+      )
+      && middleware.region === newMiddleware.region
+  );
+};

package/src/lib/middleware/getRouteFromPath.js

@@ -0,0 +1,30 @@
+const { sep } = require('path');
+
+module.exports.getRouteFromPath = (path) => {
+  const parts = path.split(sep).reverse();
+  let scope, routeId, region;
+  region = parts[3];
+  if (parts[1] === 'global') {
+    scope = 'app';
+    routeId = null;
+    region = parts[2];
+  } else if (parts[1] === 'all' && ['frontStore', 'admin'].includes(parts[2])) {
+    scope = routeId = parts[2];
+  } else if (/^[A-Za-z+.]+$/.test(parts[1]) && ['frontStore', 'admin'].includes(parts[2])) {
+    scope = parts[2];
+    const routes = parts[1].split('+');
+    if (routes.length > 1) {
+      routeId = routes.filter((r) => r !== '');
+    } else {
+      routeId = parts[1];
+    }
+  } else {
+    throw new Error(`Path ${path} is not valid for a route`);
+  }
+
+  return {
+    region,
+    scope,
+    routeId
+  }
+}

package/src/lib/middleware/index.js

@@ -0,0 +1,99 @@
+const { resolve } = require('path');
+const { existsSync, readdirSync } = require('fs');
+const { scanForMiddlewareFunctions } = require('./scanForMiddlewareFunctions');
+const { sortMiddlewares } = require('./sort');
+const { Handler } = require('./Handler');
+const { addMiddleware } = require('./addMiddleware');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+let middlewareList = Handler.middlewares;
+
+exports.getAdminMiddlewares = function getAdminMiddlewares(routeId) {
+  return sortMiddlewares(middlewareList.filter((m) => m.routeId === 'admin' || m.routeId === routeId || m.routeId === null));
+};
+
+exports.getFrontMiddlewares = function getFrontMiddlewares(routeId) {
+  return sortMiddlewares(middlewareList.filter((m) => m.routeId === 'frontStore' || m.routeId === routeId || m.routeId === null));
+};
+
+/**
+ * This function scan and load all middleware function of a module base on module path
+ *
+ * @param   {string}  path  The path of the module
+ *
+ */
+exports.getModuleMiddlewares = function getModuleMiddlewares(path) {
+  if (existsSync(resolve(path, 'pages'))) {
+    // Scan for the application level middleware
+    if (existsSync(resolve(path, 'pages', 'global'))) {
+      scanForMiddlewareFunctions(resolve(path, 'pages', 'global')).forEach((m) => {
+        addMiddleware(m);
+      });
+    }
+    // Scan for the admin level middleware
+    if (existsSync(resolve(path, 'pages', 'admin'))) {
+      const routes = readdirSync(resolve(path, 'pages', 'admin'), { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+      routes.forEach((route) => {
+        scanForMiddlewareFunctions(resolve(path, 'pages', 'admin', route)).forEach((m) => {
+          addMiddleware(m);
+        });
+      });
+    }
+
+    // Scan for the frontStore level middleware
+    if (existsSync(resolve(path, 'pages', 'frontStore'))) {
+      const routes = readdirSync(resolve(path, 'pages', 'frontStore'), { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+      routes.forEach((route) => {
+        scanForMiddlewareFunctions(resolve(path, 'pages', 'frontStore', route)).forEach((m) => {
+          addMiddleware(m);
+        });
+      });
+    }
+  }
+  if (existsSync(resolve(path, 'api'))) {
+    // Scan for the application level middleware
+    if (existsSync(resolve(path, 'api', 'global'))) {
+      scanForMiddlewareFunctions(resolve(path, 'api', 'global')).forEach((m) => {
+        addMiddleware(m);
+      });
+    }
+    // Scan for the admin level middleware
+    if (existsSync(resolve(path, 'api', 'admin'))) {
+      const routes = readdirSync(resolve(path, 'api', 'admin'), { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+      routes.forEach((route) => {
+        scanForMiddlewareFunctions(resolve(path, 'api', 'admin', route)).forEach((m) => {
+          addMiddleware(m);
+        });
+      });
+    }
+
+    // Scan for the frontStore level middleware
+    if (existsSync(resolve(path, 'api', 'frontStore'))) {
+      const routes = readdirSync(resolve(path, 'api', 'frontStore'), { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .map((dirent) => dirent.name);
+      routes.forEach((route) => {
+        scanForMiddlewareFunctions(resolve(path, 'api', 'frontStore', route)).forEach((m) => {
+          addMiddleware(m);
+        });
+      });
+    }
+  }
+};
+
+/**
+ * This function return a list of sorted middleware functions (all)
+ *
+ * @return  {array}  List of sorted middleware functions
+ */
+exports.getAllSortedMiddlewares = function getAllSortedMiddlewares() {
+  return sortMiddlewares(middlewareList);
+};

package/src/lib/middleware/isErrorHandlerTriggered.js

@@ -0,0 +1,7 @@
+module.exports = (response) => {
+  if (!response.locals) {
+    return false;
+  } else {
+    return response.locals.errorHandlerTriggered === true;
+  }
+}

package/src/lib/middleware/isNextRequired.js

@@ -0,0 +1,8 @@
+const { readFileSync } = require('fs');
+
+module.exports = function isNextRequired(path) {
+  const code = readFileSync(path, 'utf8');
+  const test = code.includes('next');
+  //console.log(path, test);
+  return code.includes('next');
+}

package/src/lib/middleware/noDuplicateId.js

@@ -0,0 +1,22 @@
+const { findDublicatedMiddleware } = require("./findDublicatedMiddleware");
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * This function check if the new middleware function has dublicated ID or not
+ *
+ * @param   {array}  registeredMiddlewares  The list of registered middleware functions
+ * @param   {object}  newMiddleware         The new middleware
+ *
+ * @return  {boolean}
+ */
+exports.noDublicateId = function noDublicateId(registeredMiddlewares, newMiddleware) {
+  if (
+    findDublicatedMiddleware(registeredMiddlewares, newMiddleware) !== -1
+  ) {
+    return false;
+  } else {
+    return true;
+  }
+};

package/src/lib/middleware/parseFromFile.js

@@ -0,0 +1,80 @@
+const { basename } = require('path');
+const { buildMiddlewareFunction } = require('./buildMiddlewareFunction');
+const { getRouteFromPath } = require('./getRouteFromPath');
+
+module.exports.parseFromFile = (path) => {
+  const name = basename(path);
+  let m = {}, id;
+  if (/^(\[)[a-zA-Z1-9.,]+(\])[a-zA-Z1-9]+.js$/.test(name)) {
+    // eslint-disable-next-line no-useless-escape
+    const split = name.split(/[\[\]]+/);
+    id = split[2].substr(0, split[2].indexOf('.')).trim();
+    m = {
+      id: id,
+      middleware: buildMiddlewareFunction(id, path),
+      after: split[1].split(',').filter((a) => a.trim() !== ''),
+      path: path
+    };
+  } else if (/^[a-zA-Z1-9]+(\[)[a-zA-Z1-9,]+(\]).js$/.test(name)) {
+    // eslint-disable-next-line no-useless-escape
+    const split = name.split(/[\[\]]+/);
+    id = split[0].trim()
+    m = {
+      id: id,
+      middleware: buildMiddlewareFunction(id, path),
+      before: split[1].split(',').filter((a) => a.trim() !== ''),
+      path: path
+    };
+  } else if (/^(\[)[a-zA-Z1-9,]+(\])[a-zA-Z1-9]+(\[)[a-zA-Z1-9,]+(\]).js$/.test(name)) {
+    // eslint-disable-next-line no-useless-escape
+    const split = name.split(/[\[\]]+/);
+    id = split[2].trim();
+    m = {
+      id: id,
+      middleware: buildMiddlewareFunction(id, path),
+      after: split[1].split(',').filter((a) => a.trim() !== ''),
+      before: split[3].split(',').filter((a) => a.trim() !== ''),
+      path: path
+    };
+  } else {
+    const split = name.split('.');
+    id = split[0].trim();
+    m = {
+      id: id,
+      middleware: buildMiddlewareFunction(id, path),
+      path: path
+    };
+  }
+
+  const route = getRouteFromPath(path);
+  if (route.region === 'api') {
+    if (m.id !== 'context' && m.id !== 'apiErrorHandler') {
+      m.before = !m.before ? (['apiResponse']) : m.before;
+      m.after = !m.after ? (['auth']) : m.after;
+    }
+  } else {
+    if (m.id !== 'context' && m.id !== 'errorHandler') {
+      m.before = !m.before ? (['buildQuery']) : m.before;
+      m.after = !m.after ? (['auth']) : m.after;
+    }
+  }
+
+  // Check if routeId is an array of routeIds or a single routeId
+  if (Array.isArray(route.routeId)) {
+    return route.routeId.map((r) => {
+      return {
+        ...m,
+        region: route.region,
+        scope: route.scope,
+        routeId: r
+      };
+    })
+  } else {
+    return [
+      {
+        ...m,
+        ...route
+      }
+    ];
+  }
+}

package/src/lib/middleware/scanForMiddlewareFunctions.js

@@ -0,0 +1,31 @@
+/* eslint-disable global-require */
+const { readdirSync } = require('fs');
+const { resolve } = require('path');
+const { parseFromFile } = require('./parseFromFile');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * This function take a path and scan for the middleware functions
+ *
+ * @param {string} path  The path of the folder where middleware functions are located
+ *
+ * @return {array}  List of middleware function
+ */
+exports.scanForMiddlewareFunctions = function scanForMiddlewareFunctions(path) {
+  let middlewares = [];
+  readdirSync(resolve(path), { withFileTypes: true })
+    .filter((dirent) => dirent.isFile() && /.js$/.test(dirent.name) && !/^[A-Z]/.test(dirent.name[0]))
+    .map((dirent) => {
+      const middlewareFunc = resolve(path, dirent.name);
+      middlewares = middlewares.concat(parseFromFile(middlewareFunc));
+    });
+
+  return middlewares;
+};
+
+// Check if letter is upper case
+function isUpperCase(str) {
+  return str === str.toUpperCase();
+}

package/src/lib/middleware/sort.js

@@ -0,0 +1,53 @@
+const Topo = require('@hapi/topo');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * This function take a path and scan for the middleware functions
+ *
+ * @param {array} middlewares  The list of middleware functions
+ *
+ * @return {array} List of sorted middleware functions
+ */
+exports.sortMiddlewares = function sortMiddlewares(middlewares = []) {
+  const middlewareFunctions = middlewares.filter((m) => {
+    if (m.before === m.after === null) return true;
+    const dependencies = (m.before || []).concat(m.after || []);
+    let flag = true;
+    dependencies.forEach((d) => {
+      if (
+        flag === false
+        || middlewares.findIndex(
+          (e) => (
+            e.id === d
+            && (
+              e.scope === 'app'
+              || e.scope === 'admin'
+              || e.scope === 'frontStore'
+              || e.routeId === null
+              || e.routeId === m.scope
+              || e.routeId === m.routeId
+            )
+
+          )
+        ) === -1
+      ) {
+        flag = false;
+      }
+    });
+
+    return flag;
+  });
+  const sorter = new Topo.Sorter();
+  middlewareFunctions.forEach((m) => {
+    sorter.add(m.id, { before: m.before, after: m.after, group: m.id });
+  });
+
+  return sorter.nodes.map((n) => {
+    const index = middlewareFunctions.findIndex((m) => m.id === n);
+    const m = middlewareFunctions[index];
+    middlewareFunctions.splice(index, 1);
+    return m;
+  });
+};

package/src/lib/middleware/sync.js

@@ -0,0 +1,25 @@
+const logger = require("../log/logger");
+const { setDelegate } = require("./delegate");
+
+module.exports = exports = {};
+
+exports.syncMiddlewareWrapper = function syncMiddlewareWrapper(id, middlewareFunc, request, response, delegates, next) {
+  logger.log('info', `Executing middleware ${id}`); // TODO: Should use debug instead of logging
+
+  try {
+    let delegate = undefined;
+    // If the middleware function has the next function as a parameter
+    if (middlewareFunc.length === 4) {
+      delegate = middlewareFunc(request, response, delegates, next);
+    } else {
+      delegate = middlewareFunc(request, response, delegates);
+    }
+    setDelegate(id, delegate, request);
+  } catch (e) {
+    // Log the error
+    logger.log('error', `Exception in middleware ${id}`, { message: e.message, stack: e.stack });
+
+    // Call error handler middleware if it is not called yet
+    next(e);
+  }
+}

package/src/lib/middleware/tests/app/app.js

@@ -0,0 +1,93 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-param-reassign */
+/* eslint-disable global-require */
+const path = require('path');
+const { addDefaultMiddlewareFuncs } = require('../../../../../bin/lib/addDefaultMiddlewareFuncs');
+const express = require('express');
+const { loadModuleRoutes } = require('../../../../../bin/lib/loadModuleRoutes');
+const { getModuleMiddlewares } = require('../..');
+const { getRoutes } = require('../../../router/Router');
+const { once } = require('events');
+const { Handler } = require('../../Handler');
+
+
+/** Create express app */
+const app = express();
+
+/* Loading modules and initilize routes, components and services */
+const modules = [
+  {
+    name: 'authcopy',
+    path: path.resolve(__dirname, './modules/authcopy')
+  },
+  {
+    name: 'basecopy',
+    path: path.resolve(__dirname, './modules/basecopy')
+  },
+  {
+    name: 'graphqlcopy',
+    path: path.resolve(__dirname, './modules/graphqlcopy')
+  },
+  {
+    name: '404page',
+    path: path.resolve(__dirname, './modules/404page')
+  },
+  {
+    name: 'error',
+    path: path.resolve(__dirname, './modules/error')
+  },
+  {
+    name: 'delegate',
+    path: path.resolve(__dirname, './modules/delegate')
+  },
+  {
+    name: 'middleware',
+    path: path.resolve(__dirname, './modules/handler')
+  }
+];
+
+// Load routes and middleware functions
+modules.forEach((module) => {
+  try {
+    // Load middleware functions
+    getModuleMiddlewares(module.path);
+    // Load routes
+    loadModuleRoutes(module.path);
+  } catch (e) {
+    console.log(e);
+    process.exit(0);
+  }
+});
+
+// TODO: load extensions, themes
+
+const routes = getRoutes();
+
+// Adding default middlewares
+addDefaultMiddlewareFuncs(app, routes);
+
+/** Hack for 'no route' case*/
+routes.push({
+  id: 'noRoute',
+  path: '/*'
+});
+routes.forEach((route) => {
+  app.all(route.path, Handler.middleware());
+})
+
+module.exports = {
+  app,
+  bootstrap: async (server) => {
+    server.listen();
+    await once(server, 'listening');
+    return server.address().port;
+  },
+  close: (server, done) => {
+    server.close(done);
+  }
+}
+
+
+// server.listen(0, () => {
+//   console.log(server.address().port);
+// });

package/src/lib/middleware/tests/app/modules/404page/pages/frontStore/product/[loadProduct]loadCategory.js

@@ -0,0 +1,3 @@
+const jest = require('jest-mock');
+module.exports = jest.fn((request, response, delegates) => {
+});

package/src/lib/middleware/tests/app/modules/404page/pages/frontStore/product/[loadProduct]loadProductImage.js

@@ -0,0 +1,4 @@
+const jest = require('jest-mock');
+module.exports = jest.fn(async (request, response, delegates, next) => {
+  next();
+});

package/src/lib/middleware/tests/app/modules/404page/pages/frontStore/product/loadProduct.js

@@ -0,0 +1,9 @@
+const jest = require('jest-mock');
+module.exports = jest.fn(async (request, response, delegates, next) => {
+  try {
+    response.status(404);
+    next();
+  } catch (e) {
+    next(e);
+  }
+})

package/src/lib/middleware/tests/app/modules/404page/pages/frontStore/product/route

@@ -0,0 +1,2 @@
+GET
+/product/:id

package/src/lib/middleware/tests/app/modules/authcopy/pages/global/[context]auth.js

@@ -0,0 +1,3 @@
+module.exports = (request, response) => {
+
+}

package/src/lib/middleware/tests/app/modules/basecopy/pages/admin/adminStaticAsset/route

@@ -0,0 +1,2 @@
+GET
+/assets/*

package/src/lib/middleware/tests/app/modules/basecopy/pages/admin/adminStaticAsset/staticAssets.js

@@ -0,0 +1,3 @@
+const staticMiddleware = require('../../../../../../../../../modules/cms/pages/admin/adminStaticAsset/staticAssets');
+
+module.exports = staticMiddleware;

package/src/lib/middleware/tests/app/modules/basecopy/pages/admin/all/adminTitle.js

@@ -0,0 +1,3 @@
+module.exports = (request, response, next) => {
+
+}

package/src/lib/middleware/tests/app/modules/basecopy/pages/frontStore/all/title.js

@@ -0,0 +1,3 @@
+module.exports = (request, response, next) => {
+
+}

package/src/lib/middleware/tests/app/modules/basecopy/pages/frontStore/notFound/route

@@ -0,0 +1,2 @@
+GET
+/notFound