@evershop/evershop 1.0.0-beta

package/src/lib/middleware/tests/unit/middleware.getRouteFromPath.test.js

@@ -0,0 +1,140 @@
+const { resolve } = require('path');
+const { getRouteFromPath } = require("../../getRouteFromPath");
+
+describe('Test getRouteFromPath function', () => {
+  it('Parse app level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/global/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'app',
+      routeId: null
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/global/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'app',
+      routeId: null
+    });
+  });
+
+  it('Parse admin level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/admin/all/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'admin',
+      routeId: 'admin',
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/admin/all/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'admin',
+      routeId: 'admin',
+    });
+  });
+
+  it('Parse frontStore level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/frontStore/all/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'frontStore',
+      routeId: 'frontStore',
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/frontStore/all/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'frontStore',
+      routeId: 'frontStore',
+    });
+  });
+
+  it('Parse admin routed level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/admin/product/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'admin',
+      routeId: 'product',
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/admin/product/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'admin',
+      routeId: 'product',
+    });
+  });
+
+  it('Parse frontStore routed level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/frontStore/product/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'frontStore',
+      routeId: 'product',
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/frontStore/product/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'frontStore',
+      routeId: 'product',
+    });
+  });
+
+  it('Parse multi admin routed level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/admin/product+category/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'admin',
+      routeId: ['product', 'category'],
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/admin/product+category/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'admin',
+      routeId: ['product', 'category'],
+    });
+  });
+
+  it('Parse multi frontStore routed level route', () => {
+    expect(
+      getRouteFromPath(resolve('/catalog/pages/frontStore/product+category/title.js'))
+    ).toEqual({
+      region: 'pages',
+      scope: 'frontStore',
+      routeId: ['product', 'category'],
+    });
+
+    expect(
+      getRouteFromPath(resolve('/cms/api/frontStore/product+category/title.js'))
+    ).toEqual({
+      region: 'api',
+      scope: 'frontStore',
+      routeId: ['product', 'category'],
+    });
+  });
+
+  it('Parse invalid path', () => {
+    expect(
+      () => getRouteFromPath(resolve('/catalog/controllers/fro ntStore/product/title.js'))
+    ).toThrow();
+
+    expect(
+      () => getRouteFromPath(resolve('/catalog/controllers/frontStore/pro2uct/title.js'))
+    ).toThrow();
+  });
+});

package/src/lib/middleware/tests/unit/middleware.noDublicateId.test.js

@@ -0,0 +1,123 @@
+const { noDublicateId } = require("../../noDuplicateId");
+
+describe('Test noDublicateId function', () => {
+  it('It should return false if routed middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'home',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if admin level middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'admin',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'admin'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if admin level middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'admin',
+        scope: 'admin'
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'admin'
+        },
+        'admin'
+      )
+    ).toEqual(false);
+  });
+
+  it('It should return false if frontStore level middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'frontStore',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'frontStore'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if application level middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: null,
+      }],
+        {
+          id: 'routeOne',
+          routeId: null
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if routeId is null', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: null,
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if routeId is admin', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'admin',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if routeId is frontStore', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'frontStore',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return true if routeId is different', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'home',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'category'
+        })
+    ).toEqual(true);
+  });
+});

package/src/lib/middleware/tests/unit/middleware.scanForMiddlewareFunctions.test.js

@@ -0,0 +1,94 @@
+const { noDublicateId } = require("../../noDuplicateId");
+
+describe('Test scanForMiddlewareFunctions function', () => {
+  it('It should return false if routed middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'home',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if admin middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'admin',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'admin'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if frontStore middlewareID is existed', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: null,
+      }],
+        {
+          id: 'routeOne',
+          routeId: null
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if routeId is null', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: null,
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if routeId is admin', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'admin',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return false if routeId is frontStore', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'frontStore',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'home'
+        })
+    ).toEqual(false);
+  });
+
+  it('It should return true if routeId is different', () => {
+    expect(
+      noDublicateId([{
+        id: 'routeOne',
+        routeId: 'home',
+      }],
+        {
+          id: 'routeOne',
+          routeId: 'category'
+        })
+    ).toEqual(true);
+  });
+});

package/src/lib/middlewares/bodyJson.js

@@ -0,0 +1,5 @@
+const bodyParser = require('body-parser');
+
+module.exports = (request, response, stack, next) => {
+  bodyParser.json()(request, response, next);
+};

package/src/lib/middlewares/multerNone.js

@@ -0,0 +1,7 @@
+const multer = require('multer');
+
+const upload = multer();
+
+module.exports = (request, response, stack, next) => {
+  upload.none()(request, response, next);
+};

package/src/lib/middlewares/publicStatic.js

@@ -0,0 +1,23 @@
+const fs = require('fs').promises;
+const { CONSTANTS } = require('../helpers');
+const { join } = require('path');
+const staticMiddleware = require('serve-static');
+
+module.exports = async function publiStatic(request, response, next) {
+  // Get the request path
+  let path = request.path;
+  try {
+    if (!path.includes('.')) {
+      throw new Error('No file extension');
+    }
+    // Asynchoronously check if the path is a file and exists in the public folder
+    const test = await fs.stat(join(CONSTANTS.ROOTPATH, 'public', path));
+    if (test.isFile()) {
+      // If it is a file, serve it
+      staticMiddleware(join(CONSTANTS.ROOTPATH, 'public'))(request, response, next);
+    }
+  } catch (e) {
+    // If the path is not a file or does not exist in the public folder, call next
+    next();
+  }
+}

package/src/lib/middlewares/static.js

@@ -0,0 +1,33 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+const staticMiddleware = require('serve-static');
+const { normalize, join } = require('path');
+const { existsSync } = require('fs');
+const { CONSTANTS } = require('../helpers');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = (request, response, next) => {
+  let path;
+  if (request.isAdmin === true) {
+    path = normalize(request.originalUrl.replace('/admin/assets/', ''));
+  } else {
+    path = normalize(request.originalUrl.replace('/assets/', ''));
+  }
+  if (request.isAdmin === true) {
+    request.originalUrl = request.originalUrl.replace('/admin/assets', '');
+    request.url = request.originalUrl.replace('/admin/assets', '');
+  } else {
+    request.originalUrl = request.originalUrl.replace('/assets', '');
+    request.url = request.originalUrl.replace('/assets', '');
+  }
+
+  if (existsSync(join(CONSTANTS.ROOTPATH, '.evershop/build', path))) {
+    staticMiddleware(join(CONSTANTS.ROOTPATH, '.evershop/build'))(request, response, next);
+  } else if (existsSync(join(CONSTANTS.MEDIAPATH, path))) {
+    staticMiddleware(CONSTANTS.MEDIAPATH)(request, response, next);
+  } else if (existsSync(join(CONSTANTS.ROOTPATH, 'public', path))) {
+    staticMiddleware(join(CONSTANTS.ROOTPATH, 'public'))(request, response, next);
+  } else {
+    response.status(404).send('Not Found');
+  }
+  // TODO: Prevent directory listing
+};

package/src/lib/mysql/connection.js

@@ -0,0 +1,21 @@
+const mysql = require('mysql');
+const util = require('util');
+const config = require('config');
+
+const pool = mysql.createPool({
+  host: config.get('system.database.host'),
+  port: config.get('system.database.port'),
+  user: config.get('system.database.user'),
+  password: config.get('system.database.password'),
+  database: config.get('system.database.database'),
+  dateStrings: true,
+  connectionLimit: 30
+});
+
+async function getConnection() {
+  // eslint-disable-next-line no-return-await
+  return await util.promisify(pool.getConnection).bind(pool)();
+}
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = { pool, getConnection };

package/src/lib/pathToRegexp.js

@@ -0,0 +1,139 @@
+/* eslint-disable func-names */
+/* eslint-disable no-shadow */
+/* eslint-disable no-param-reassign */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable no-nested-ternary */
+/* eslint-disable max-len */
+/* eslint-disable no-useless-escape */
+/* eslint-disable no-sequences */
+/* eslint-disable block-scoped-var */
+/* eslint-disable no-return-assign */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-continue */
+/* eslint-disable no-unused-expressions */
+/* eslint-disable no-use-before-define */
+/* eslint-disable no-var */
+/* eslint-disable vars-on-top */
+/* eslint-disable no-cond-assign */
+function parse(e, t) {
+  for (var r, n = [], o = 0, a = 0, i = '', p = (t && t.delimiter) || '/'; (r = PATH_REGEXP.exec(e)) != null;) {
+    const s = r[0];
+    const c = r[1];
+    const u = r.index;
+    if (((i += e.slice(a, u)), (a = u + s.length), c)) i += c[1];
+    else {
+      const l = e[a];
+      const g = r[2];
+      const f = r[3];
+      const x = r[4];
+      const h = r[5];
+      const d = r[6];
+      const m = r[7];
+      i && (n.push(i), (i = ''));
+      const y = g != null && l != null && l !== g;
+      const R = d === '+' || d === '*';
+      const T = d === '?' || d === '*';
+      const E = r[2] || p;
+      const v = x || h;
+      n.push({
+        name: f || o++, prefix: g || '', delimiter: E, optional: T, repeat: R, partial: y, asterisk: !!m, pattern: v ? escapeGroup(v) : m ? '.*' : `[^${escapeString(E)}]+?`
+      });
+    }
+  }
+  return a < e.length && (i += e.substr(a)), i && n.push(i), n;
+}
+function compile(e, t) {
+  return tokensToFunction(parse(e, t));
+}
+function encodeURIComponentPretty(e) {
+  return encodeURI(e).replace(/[\/?#]/g, (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function encodeAsterisk(e) {
+  return encodeURI(e).replace(/[?#]/g, (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function tokensToFunction(e) {
+  for (var t = new Array(e.length), r = 0; r < e.length; r++) typeof e[r] === 'object' && (t[r] = new RegExp(`^(?:${e[r].pattern})$`));
+  return function (r, n) {
+    for (var o = '', a = r || {}, i = n || {}, p = i.pretty ? encodeURIComponentPretty : encodeURIComponent, s = 0; s < e.length; s++) {
+      const c = e[s];
+      if (typeof c !== 'string') {
+        var u;
+        const l = a[c.name];
+        if (l == null) {
+          if (c.optional) {
+            c.partial && (o += c.prefix);
+            continue;
+          }
+          throw new TypeError(`Expected "${c.name}" to be defined`);
+        }
+        if (isarray(l)) {
+          if (!c.repeat) throw new TypeError(`Expected "${c.name}" to not repeat, but received \`${JSON.stringify(l)}\``);
+          if (l.length === 0) {
+            if (c.optional) continue;
+            throw new TypeError(`Expected "${c.name}" to not be empty`);
+          }
+          for (let g = 0; g < l.length; g++) {
+            if (((u = p(l[g])), !t[s].test(u))) throw new TypeError(`Expected all "${c.name}" to match "${c.pattern}", but received \`${JSON.stringify(u)}\``);
+            o += (g === 0 ? c.prefix : c.delimiter) + u;
+          }
+        } else {
+          if (((u = c.asterisk ? encodeAsterisk(l) : p(l)), !t[s].test(u))) throw new TypeError(`Expected "${c.name}" to match "${c.pattern}", but received "${u}"`);
+          o += c.prefix + u;
+        }
+      } else o += c;
+    }
+    return o;
+  };
+}
+function escapeString(e) {
+  return e.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1');
+}
+function escapeGroup(e) {
+  return e.replace(/([=!:$\/()])/g, '\\$1');
+}
+function attachKeys(e, t) {
+  return (e.keys = t), e;
+}
+function flags(e) {
+  return e.sensitive ? '' : 'i';
+}
+function regexpToRegexp(e, t) {
+  const r = e.source.match(/\((?!\?)/g);
+  if (r) {
+    for (let n = 0; n < r.length; n++) {
+      t.push({
+        name: n, prefix: null, delimiter: null, optional: !1, repeat: !1, partial: !1, asterisk: !1, pattern: null
+      });
+    }
+  }
+  return attachKeys(e, t);
+}
+function arrayToRegexp(e, t, r) {
+  for (var n = [], o = 0; o < e.length; o++) n.push(pathToRegexp(e[o], t, r).source);
+  return attachKeys(new RegExp(`(?:${n.join('|')})`, flags(r)), t);
+}
+function stringToRegexp(e, t, r) {
+  return tokensToRegExp(parse(e, r), t, r);
+}
+function tokensToRegExp(e, t, r) {
+  isarray(t) || ((r = t || r), (t = [])), (r = r || {});
+  for (var n = r.strict, o = !1 !== r.end, a = '', i = 0; i < e.length; i++) {
+    const p = e[i];
+    if (typeof p === 'string') a += escapeString(p);
+    else {
+      const s = escapeString(p.prefix);
+      let c = `(?:${p.pattern})`;
+      t.push(p), p.repeat && (c += `(?:${s}${c})*`), (c = p.optional ? (p.partial ? `${s}(${c})?` : `(?:${s}(${c}))?`) : `${s}(${c})`), (a += c);
+    }
+  }
+  const u = escapeString(r.delimiter || '/');
+  const l = a.slice(-u.length) === u;
+  return n || (a = `${l ? a.slice(0, -u.length) : a}(?:${u}(?=$))?`), (a += o ? '$' : n && l ? '' : `(?=${u}|$)`), attachKeys(new RegExp(`^${a}`, flags(r)), t);
+}
+function pathToRegexp(e, t, r) {
+  return isarray(t) || ((r = t || r), (t = [])), (r = r || {}), e instanceof RegExp ? regexpToRegexp(e, t) : isarray(e) ? arrayToRegexp(e, t, r) : stringToRegexp(e, t, r);
+}
+var isarray = require('isarray');
+
+var PATH_REGEXP = new RegExp(['(\\\\.)', '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'].join('|'), 'g');
+(module.exports = pathToRegexp), (module.exports.parse = parse), (module.exports.compile = compile), (module.exports.tokensToFunction = tokensToFunction), (module.exports.tokensToRegExp = tokensToRegExp);

package/src/lib/response/render.js

@@ -0,0 +1,82 @@
+const path = require('path');
+const { inspect } = require('util');
+const { getRoutes } = require('../router/Router');
+const { get } = require('../util/get');
+const isProductionMode = require('../util/isProductionMode');
+const { getRouteBuildPath } = require('../webpack/getRouteBuildPath');
+
+function normalizeAssets(assets) {
+  if (typeof assets === 'object' &&
+    !Array.isArray(assets) &&
+    assets !== null
+  ) {
+    return Object.values(assets);
+  }
+
+  return Array.isArray(assets) ? assets : [assets];
+}
+
+function renderDevelopment(request, response) {
+  const route = request.locals.webpackMatchedRoute;
+  if (!route) { // In testing mode, we do not have devMiddleware
+    response.send(`
+            <html>
+              <head>
+                <title>Sample Html Response</title>
+                <script>Sample Html Response</script>
+              </head>
+              <body>
+              </body>
+            </html>
+            `);
+    return;
+  }
+  // We can not get devMiddleware from response.locals, because there are 2 build (current route, and notFound)
+  const devMiddleware = route.webpackMiddleware;
+  const contextValue = {
+    graphqlResponse: get(response, 'locals.graphqlResponse', {}),
+    propsMap: get(response, 'locals.propsMap', {}),
+  };
+  console.log(route.id, request.path);
+  const stats = devMiddleware.context.stats;
+  //let stat = jsonWebpackStats.find(st => st.compilation.name === route.id);
+  const { assetsByChunkName, outputPath } = stats.toJson();
+  response.send(`
+            <!doctype html><html>
+                <head>
+                  <script>var eContext = ${inspect(contextValue, { depth: 10, maxArrayLength: null })}</script>
+                </head>
+                <body>
+                <div id="app" className="bg-background"></div>
+                 ${normalizeAssets(assetsByChunkName[route.id])
+      .filter((path) => path.endsWith(".js"))
+      .map((path) => `<script defer src="/${response.statusCode === 404 ?
+        request.currentRoute?.isAdmin ?
+          'adminNotFound.js' :
+          'notFound.js' : path}"></script>`)
+      .join("\n")}
+                </body>
+            </html>
+            `);
+}
+
+function renderProduction(request, response) {
+  const routes = getRoutes()
+  const route = response.statusCode === 404 ? routes.find((route) => route.id === 'notFound') : request.currentRoute;
+  const { renderHtml } = require(path.resolve(getRouteBuildPath(route), 'server', 'index.js'));
+  const assets = require(path.resolve(getRouteBuildPath(route), 'client', 'index.json'));
+  const contextValue = {
+    graphqlResponse: get(response, 'locals.graphqlResponse', {}),
+    propsMap: get(response, 'locals.propsMap', {}),
+  };
+  const source = renderHtml(assets.js, assets.css, contextValue);
+  response.send(source);
+}
+
+module.exports.render = function render(request, response) {
+  if (isProductionMode()) {
+    renderProduction(request, response);
+  } else {
+    renderDevelopment(request, response);
+  }
+}