@evershop/evershop 1.0.0-beta

package/src/lib/router/Router.js

@@ -0,0 +1,39 @@
+module.exports = exports = {};
+
+class Router {
+  constructor() {
+    this.routes = [];
+  }
+
+  getFrontStoreRoutes() {
+    return this.routes.filter((r) => r.isAdmin === false)
+  };
+
+  getAdminRoutes() {
+    return this.routes.filter((r) => r.isAdmin === true)
+  };
+
+  getRoutes() {
+    return this.routes;
+  }
+
+  addRoute(route) {
+    let r = this.routes.find((r) => r.id === route.id);
+    if (r !== undefined) {
+      Object.assign(r, route);
+    } else {
+      this.routes.push(route);
+    }
+  }
+
+  empty() {
+    this.routes = [];
+  }
+}
+
+const router = new Router();
+exports.addRoute = (route) => router.addRoute(route);
+exports.getFrontStoreRoutes = () => router.getFronStoreRoutes();
+exports.getAdminRoutes = () => router.getAdminRoutes();
+exports.getRoutes = () => router.getRoutes();
+exports.empty = () => router.empty();

package/src/lib/router/buildUrl.js

@@ -0,0 +1,21 @@
+const { getRoutes } = require('./Router');
+const { compile } = require('../pathToRegexp');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+/**
+ * This function take a route ID, list of params and return the url
+ *
+ * @param   {string}  routeId
+ * @param   {object}  params   Key-Pair value of route params
+ *
+ * @return  {string} The Url
+ */
+exports.buildUrl = (routeId, params = {}) => {
+  const routes = getRoutes();
+  const route = routes.find((r) => r.id === routeId);
+  if (route === undefined) { throw new Error(`Route ${routeId} is not existed`); }
+
+  const toPath = compile(route.path);
+  return toPath(params);
+};

package/src/lib/router/registerAdminRoute.js

@@ -0,0 +1,27 @@
+const { addRoute } = require('./Router');
+const { validateRoute } = require('./validateRoute');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * Register an admin route
+ *
+ * @param   {string}  id      Id of route, this must be unique
+ * @param   {string|array} method  HTTP method, can be string like "GET", array like ["GET", "POST"]
+ * @param   {string}  path    The path of route
+ *
+ */
+exports.registerAdminRoute = (id, method, path, isApi = false, folder = '') => {
+  //const route = validateRoute(id, method, path);
+  const route = {
+    id: String(id),
+    method,
+    path,
+  }
+  route.isAdmin = true;
+  route.isApi = isApi;
+  route.path = route.path === '/' ? '/admin' : `/admin${path}`;
+  route.folder = folder;
+  addRoute(route);
+};

package/src/lib/router/registerFrontStoreRoute.js

@@ -0,0 +1,26 @@
+const { addRoute } = require('./Router');
+const { validateRoute } = require('./validateRoute');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * Register a frontStore route
+ *
+ * @param   {string}  id      Id of route, this must be unique
+ * @param   {string|array} method  HTTP method, can be string like "GET", array like ["GET", "POST"]
+ * @param   {string}  path    The path of route
+ *
+ */
+exports.registerFrontStoreRoute = (id, method, path, isApi = false, folder = '') => {
+  //const route = validateRoute(id, method, path);
+  const route = {
+    id: String(id),
+    method,
+    path,
+  }
+  route.isAdmin = false;
+  route.isApi = isApi;
+  route.folder = folder;
+  addRoute(route);
+};

package/src/lib/router/scanForRoutes.js

@@ -0,0 +1,63 @@
+const { readdirSync, existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+function startWith(str, prefix) {
+  return str.slice(0, prefix.length) === prefix;
+}
+
+function validateRoute(methods, path, routePath) {
+  if (methods.length === 0) {
+    throw new Error(`Method is required. Please check the route defined at ${routePath}`);
+  }
+  const check = methods.find((m) => ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'].includes(m) === false);
+  if (check !== undefined) {
+    throw new Error(`Method ${check} is invalid. Please check the route defined at ${routePath}`);
+  }
+  if (startWith(path, '/') === false) {
+    throw new Error(`Path ${path} is invalid. Please check the route defined at ${routePath}`);
+  }
+
+  return true;
+}
+
+/**
+ * Scan for routes base on module path.
+ */
+
+exports.scanForRoutes = (path, isAdmin, isApi) => {
+  const scanedRoutes = readdirSync(path, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+  return scanedRoutes.map((r) => {
+    if (/^[A-Za-z.]+$/.test(r) === true) {
+      if (existsSync(join(path, r, 'route'))) {
+        let lines = readFileSync(join(path, r, 'route'), 'utf-8');
+        lines = lines.split(/\r?\n/).map((p) => p.replace('\\\\', '\\'));
+        const methods = lines[0].split(',').map((m) => m.trim()).filter((m) => m !== '');
+        let p = lines[1];
+        if (validateRoute(methods, p, join(path, r, 'route')) === true) {
+          if (isApi === true) {
+            p = `/v1${p}`;
+          }
+          return {
+            id: r,
+            method: methods,
+            path: p,
+            isAdmin,
+            isApi,
+            folder: join(path, r),
+          };
+        } else {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }).filter((e) => e !== false);
+};

package/src/lib/router/tests/unit/a/invalidMethod/routeOne/route

@@ -0,0 +1,2 @@
+GET, INVALID
+/a/:url_key

package/src/lib/router/tests/unit/a/invalidPath/routeTwo/route

@@ -0,0 +1,2 @@
+GET, POST
+invalidPath

package/src/lib/router/tests/unit/b/routeOne/route

@@ -0,0 +1,2 @@
+GET, POST
+/a/:url_key

package/src/lib/router/tests/unit/b/routeThree/route

@@ -0,0 +1,2 @@
+GET, PUT
+/b/:url_key

package/src/lib/router/tests/unit/b/routeTwo/route

@@ -0,0 +1,2 @@
+GET,
+/a/:url_key

package/src/lib/router/tests/unit/unit.scanForRoutes.test.js

@@ -0,0 +1,18 @@
+const { scanForRoutes } = require("../../scanForRoutes");
+const path = require('path');
+
+describe('Test scanForRoutes', () => {
+  it('It should thrown an exception if path is not valid', () => {
+    expect(() => scanForRoutes(path.resolve(__dirname, 'a/invalidPath'), true, false)).toThrow(Error);
+  });
+
+  it('It should thrown an exception if methods are not valid', () => {
+    expect(() => scanForRoutes(path.resolve(__dirname, 'a/invalidMethod'), true, false)).toThrow(Error);
+  });
+
+  it('It should return an array of routes', () => {
+    const routes = scanForRoutes(path.resolve(__dirname, 'b'), true, false);
+    expect(Array.isArray(routes)).toBe(true);
+    expect(routes.length).toBe(3);
+  });
+});

package/src/lib/router/tests/unit/unit.validateRoute.test.js

@@ -0,0 +1,29 @@
+const { scanForRoutes } = require("../../scanForRoutes");
+const path = require('path');
+const { registerAdminRoute } = require("../../registerAdminRoute");
+const { validateRoute } = require("../../validateRoute");
+
+describe('Test validateRoute', () => {
+  beforeAll(() => {
+    const routes = scanForRoutes(path.resolve(__dirname, 'b'), true, false);
+    routes.forEach((route) => {
+      registerAdminRoute(
+        route.id,
+        route.method,
+        route.path,
+        route.isApi
+      );
+    });
+  });
+
+  it('It should thrown an exception if route is already existed', () => {
+    expect(() => validateRoute('routeOne', ['GET'], '/')).toThrow(Error);
+  });
+
+  it('It should return a route object if id is valid', () => {
+    let route = validateRoute('newRoute', ['GET'], '/');
+    expect(route.id).toBeTruthy();
+    expect(route.method).toBeTruthy();
+    expect(route.path).toBeTruthy();
+  });
+});

package/src/lib/router/validateRoute.js

@@ -0,0 +1,26 @@
+const { getRoutes } = require('./Router');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+/**
+ * This function validate where ther the id of route is already existed or not.
+ * It return a route object
+ *
+ * @param   {string}  id      Route ID
+ * @param {string||array} method HTTP method, can be string like "GET", array like ["GET", "POST"]
+ * @param   {string}  path    The route path
+ *
+ * @return  {object}          The Route object
+ */
+exports.validateRoute = (id, method, path) => {
+  const routes = getRoutes();
+  if (routes.find((r) => r.id === id) !== undefined) {
+    throw new Error(`Route with ID ${String(id)} is already existed`);
+  }
+  return {
+    id: String(id),
+    method,
+    path
+  };
+};

package/src/lib/util/assign.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-param-reassign */
+/**
+ * This function take 2 objects and merge the second one to the first one
+ *
+ * @param   {object}  object  The main object
+ * @param   {object}  data    The object to be merged
+ *
+ */
+function assign(object, data) {
+  if (typeof object !== 'object' || object === null) { throw new Error('`object` must be an object'); }
+
+  if (typeof data !== 'object' || data === null) { throw new Error('`data` must be an object'); }
+
+  Object.keys(data).forEach((key) => {
+    if (
+      (data[key] && data[key].constructor === Array)
+      && (object[key] && object[key].constructor === Array)
+    ) {
+      object[key] = object[key].concat(data[key]);
+    } else if (typeof object[key] !== 'object' || typeof data[key] !== 'object' || object[key] === null) {
+      object[key] = data[key];
+    } else {
+      assign(object[key], data[key]);
+    }
+  });
+}
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = { assign };

package/src/lib/util/buildFilterFromUrl.js

@@ -0,0 +1,70 @@
+module.exports.buildFilterFromUrl = (query) => {
+  if (!query) {
+    return [];
+  } else {
+    const filtersFromUrl = [];
+
+    // Attribute filters
+    Object.keys(query).forEach((key) => {
+      const filter = query[key];
+      if (Array.isArray(filter)) {
+        const values = filter
+          .map((v) => parseInt(v))
+          .filter((v) => isNaN(v) === false);
+        if (values.length > 0) {
+          filtersFromUrl.push({
+            key: key,
+            operation: "IN",
+            value: values.join(',')
+          });
+        }
+      } else {
+        // Use regex to check if filter is either started or ended with a '%'
+        // If so, use LIKE operation
+        const regex = /^%|%$/;
+        if (!regex.test(filter)) {
+          filtersFromUrl.push({
+            key: key,
+            operation: "=",
+            value: filter
+          });
+        } else {
+          filtersFromUrl.push({
+            key: key,
+            operation: "LIKE",
+            value: filter
+          });
+        }
+      }
+    });
+
+    const sortBy = query.sortBy;
+    const sortOrder = (query.sortOrder && ['ASC', 'DESC'].includes(query.sortOrder.toUpperCase())) ? query.sortOrder.toUpperCase() : 'ASC';
+    if (sortBy) {
+      filtersFromUrl.push({
+        key: 'sortBy',
+        operation: '=',
+        value: sortBy
+      });
+    }
+
+    if (sortOrder !== 'ASC') {
+      filtersFromUrl.push({
+        key: 'sortOrder',
+        operation: '=',
+        value: sortOrder
+      });
+    }
+    // Paging
+    const page = isNaN(parseInt(query.page)) ? "1" : query.page.toString();
+    if (page !== "1") {
+      filtersFromUrl.push({ key: 'page', operation: '=', value: page });
+    }
+    const limit = isNaN(parseInt(query.limit)) ? "20" : query.limit.toString();// TODO: Get from config
+    if (limit !== "20") {
+      filtersFromUrl.push({ key: 'limit', operation: '=', value: limit });
+    }
+
+    return filtersFromUrl
+  }
+}

package/src/lib/util/camelCase.js

@@ -0,0 +1,18 @@
+module.exports.camelCase = (object) => {
+  // Throw error if the object is not an object
+  if (typeof object !== 'object' && object !== null) {
+    throw new Error('The object must be an object');
+  }
+  let newObject = {};
+  Object.keys(object).forEach((key) => {
+    // Convert the key to camelCase
+    const newKey = key.replace(/([-_][a-zA-Z0-9])/gi, ($1) => {
+      return $1.toUpperCase().replace('-', '').replace('_', '');
+    }
+    );
+    // Add the new key to the new object
+    newObject[newKey] = object[key];
+  });
+
+  return newObject;
+}

package/src/lib/util/events.js

@@ -0,0 +1,3 @@
+export const FORM_VALIDATED = 'FORM_VALIDATED';
+export const FORM_SUBMIT = 'FORM_SUBMIT';
+export const FORM_FIELD_UPDATED = 'FORM_FIELD_UPDATED';

package/src/lib/util/formData.js

@@ -0,0 +1,30 @@
+/* eslint-disable no-multi-assign */
+class _FormData {
+  constructor() {
+    this.data = {};
+  }
+
+  append(name, value) {
+    this.data[name] = value;
+    return this;
+  }
+
+  delete(name) {
+    delete this.data[name];
+    return this;
+  }
+
+  build() {
+    const data = new FormData();
+    Object.keys(this.data).forEach((key) => {
+      data.append(key, this.data[key]);
+    });
+    return data;
+  }
+}
+
+function formData() {
+  return new _FormData();
+}
+
+module.exports = exports = formData;

package/src/lib/util/formToJson.js

@@ -0,0 +1,48 @@
+module.exports = exports = {};
+
+function update(data, keys, value) {
+  if (keys.length === 0) {
+    // Leaf node
+    return value;
+  }
+
+  let key = keys.shift();
+  if (!key) {
+    data = data || [];
+    if (Array.isArray(data)) {
+      key = data.length;
+    }
+  }
+
+  // Try converting key to a numeric value
+  let index = +key;
+  if (!isNaN(index)) {
+    // We have a numeric index, make data a numeric array
+    // This will not work if this is a associative array 
+    // with numeric keys
+    data = data || [];
+    key = index;
+  }
+
+  // If none of the above matched, we have an associative array
+  data = data || {};
+
+  let val = update(data[key], keys, value);
+  data[key] = val;
+
+  return data;
+}
+
+exports.serializeForm = function serializeForm(formDataEntries) {
+  return Array.from(formDataEntries)
+    .reduce((data, [field, value]) => {
+      let [_, prefix, keys] = field.match(/^([^\[]+)((?:\[[^\]]*\])*)/);
+
+      if (keys) {
+        keys = Array.from(keys.matchAll(/\[([^\]]*)\]/g), m => m[1]);
+        value = update(data[prefix], keys, value);
+      }
+      data[prefix] = value;
+      return data;
+    }, {});
+}

package/src/lib/util/get.js

@@ -0,0 +1,23 @@
+/**
+ * Get the value base on the path
+ *
+ * @param   {object}  obj           The Data object
+ * @param   {string}  path          The path of the property "a.b.c"
+ * @param   {any}  defaultValue     The default value in case the path is not existed
+ *
+ * @return  {any}                   The value
+ */
+function get(obj, path, defaultValue) {
+  const pathSplit = path.split('.');
+  let current = obj;
+  while (pathSplit.length) {
+    if (typeof current !== 'object' || current === null) { return defaultValue; }
+    const key = pathSplit.shift();
+    if (current[key] === undefined || current[key] === null) { return defaultValue; }
+    current = current[key];
+  }
+  return current;
+}
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = { get };

package/src/lib/util/getConfig.js

@@ -0,0 +1,17 @@
+const config = require('config');
+
+/**
+ * Get the configuration value base on path
+ *
+ * @param   {string}  path          Path of the configuration
+ * @param   {any}  defaultValue     The default value in case the path is not existed
+ *
+ * @return  {any}                   The configuration value
+ */
+function getConfig(path, defaultValue) {
+  return config.has(path) ? config.get(path) : defaultValue;
+}
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+exports.getConfig = getConfig;

package/src/lib/util/isAjax.js

@@ -0,0 +1,13 @@
+/**
+ * Get the value base on the path
+ *
+ * @param   {object}  request   The request object
+ *
+ * @return  {boolean}
+ */
+function isAjax(request) {
+  return request.get('X-Requested-With') === 'XMLHttpRequest';
+}
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = { isAjax };

package/src/lib/util/isDevelopmentMode.js

@@ -0,0 +1,3 @@
+module.exports = () => {
+  return process.env.NODE_ENV === 'development';
+}

package/src/lib/util/isProductionMode.js

@@ -0,0 +1,3 @@
+module.exports = () => {
+  return process.env.NODE_ENV === 'production';
+}

package/src/lib/util/merge.js

@@ -0,0 +1,25 @@
+/* eslint-disable no-param-reassign */
+/**
+ * This function take 2 objects and merge them into a new object
+ *
+ * @param   {object}  objectOne  The first object
+ * @param   {object}  objectTwo  The second object
+ *
+ * @return  {object}             The new object
+ */
+function merge(objectOne, objectTwo) {
+  if (typeof objectOne !== 'object' || objectOne === null) { throw new Error('`object` must be an object'); }
+  if (typeof objectTwo !== 'object' || objectTwo === null) { throw new Error('`object` must be an object'); }
+
+  const result = Object.create({});
+
+  Object.keys(objectOne).forEach((key) => {
+    result[key] = objectOne[key] ? objectOne[key] : objectTwo[key];
+    delete objectTwo[key];
+  });
+
+  return { ...result, ...objectTwo };
+}
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = { merge };

package/src/lib/util/tests/unit/util.assign.test.js

@@ -0,0 +1,41 @@
+const { assign } = require('../../assign');
+
+describe('assign', () => {
+  it('It should assign an object to the main object', () => {
+    const a = { a: 1 };
+    const b = { b: 1 };
+    assign(a, b);
+    expect(a).toEqual({ a: 1, b: 1 });
+  });
+
+  it('It should thrown an exception if `object` is not an object or null', () => {
+    const a = 1;
+    const b = { b: 1 };
+    expect(() => assign(a, b)).toThrow(Error);
+  });
+
+  it('It should thrown an exception if `object` is not an object or null', () => {
+    const a = null;
+    const b = { b: 1 };
+    expect(() => assign(a, b)).toThrow(Error);
+  });
+
+  it('It should thrown an exception if data is not an object or null', () => {
+    const a = { a: 1 };
+    const b = 1;
+    expect(() => assign(a, b)).toThrow(Error);
+  });
+
+  it('It should thrown an exception if data is not an object or null', () => {
+    const a = { a: 1 };
+    const b = null;
+    expect(() => assign(a, b)).toThrow(Error);
+  });
+
+  it('It should overwrite if the property is already existed', () => {
+    const a = { a: 1, b: 1 };
+    const b = { b: 2 };
+    assign(a, b);
+    expect(a).toEqual({ a: 1, b: 2 });
+  });
+});

package/src/lib/util/tests/unit/util.get.test.js

@@ -0,0 +1,24 @@
+const { get } = require('../../get');
+
+describe('Test until get', () => {
+  it('It should return the value if path is valid', () => {
+    const object = { a: 1, b: { c: 1 } };
+    let result = get(object, 'b.c');
+    expect(result).toEqual(1);
+  });
+
+  it('It should return undefined if the object is not an object', () => {
+    const object = 1;
+    expect(get(object, 'a.b')).toEqual(undefined);
+  });
+
+  it('It should return undefined if the path is not found', () => {
+    const object = { a: 1, b: { c: 1 } };
+    expect(get(object, 'a.b.c')).toEqual(undefined);
+  });
+
+  it('It should return default value if the path is not found', () => {
+    const object = { a: 1, b: { c: 1 } }, defaultValue = 10;
+    expect(get(object, 'a.b.d', defaultValue)).toEqual(10);
+  });
+});

package/src/lib/util/tests/unit/util.getConfig.test.js

@@ -0,0 +1,8 @@
+const { getConfig } = require('../../getConfig');
+
+describe('Test until getConfig', () => {
+  it('It should return the default value if path is invalid', () => {
+    expect(getConfig('a.b', 1)).toEqual(1);
+    expect(getConfig('a.b')).toEqual(undefined);
+  });
+});