@evershop/evershop 1.0.0-beta

package/bin/lib/buildEntry.js

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const { mkdir, writeFile } = require('fs').promises;
+const path = require('path');
+const { inspect } = require('util');
+const { Componee } = require('../../src/lib/componee/Componee');
+const { getComponentsByRoute } = require('../../src/lib/componee/getComponentsByRoute');
+const { CONSTANTS } = require('../../src/lib/helpers');
+const { getRouteBuildPath } = require('../../src/lib/webpack/getRouteBuildPath');
+const { parseGraphql } = require('../../src/lib/webpack/util/parseGraphql');
+const JSON5 = require('json5');
+/**
+ * Only pass the page routes, not api routes
+*/
+module.exports.buildEntry = async function buildEntry(routes, clientOnly = false) {
+  await Promise.all(routes.map(async (route) => {
+    const subPath = getRouteBuildPath(route);
+    const components = getComponentsByRoute(route);
+    if (!components) {
+      return;
+    }
+    /** Build layout and query */
+    const areas = {};
+    components.forEach((module) => {
+      if (!fs.existsSync(module)) {
+        return;
+      }
+      const source = fs.readFileSync(module, 'utf8');
+      // Regex matching 'export const layout = { ... }'
+      const layoutRegex = /export\s+const\s+layout\s*=\s*{\s*areaId\s*:\s*['"]([^'"]+)['"],\s*sortOrder\s*:\s*(\d+)\s*,*\s*}/;
+      const match = source.match(layoutRegex);
+      if (match) {
+        // Remove everything before '{' from the beginning of the match
+        const check = match[0].replace(/^[^{]*/, '').replace(/(['"])?([a-zA-Z0-9_]+)(['"])?:/g, '"$2": ');
+        try {
+          const layout = JSON5.parse(check);
+          const id = Buffer.from(module.replace(CONSTANTS.ROOTPATH, '')).toString('base64');
+          areas[layout.areaId] = areas[layout.areaId] || {};
+          areas[layout.areaId][id] = {
+            id: id,
+            sortOrder: layout.sortOrder,
+            component: `---require('${module}')---`,
+          };
+        } catch (e) {
+          console.log(`Error parsing layout from ${module}`);
+          console.log(e);
+        }
+      }
+    });
+
+    let contentClient = `
+      import React from 'react';
+      import ReactDOM from 'react-dom';
+      import Area from '@evershop/evershop/src/lib/components/Area';
+      import Hydrate from '@evershop/evershop/src/lib/components/react/client/Hydrate';
+      `;
+    contentClient += '\r\n';
+    contentClient += `Area.defaultProps.components = ${inspect(areas, { depth: 5 }).replace(/"---/g, '').replace(/---"/g, '')} `;
+    contentClient += '\r\n';
+    contentClient += `ReactDOM.hydrate(
+        <Hydrate/>,
+        document.getElementById('app')
+      );`
+    if (!fs.existsSync(path.resolve(subPath, 'client'))) {
+      await mkdir(path.resolve(subPath, 'client'), { recursive: true });
+    }
+    await writeFile(path.resolve(subPath, 'client', 'entry.js'), contentClient);
+
+    if (!clientOnly) {
+      /** Build query*/
+      const query = `${JSON.stringify(parseGraphql(components))}`
+
+      let contentServer = `import React from 'react'; `;
+      contentServer += '\r\n';
+      contentServer += `import ReactDOM from 'react-dom'; `;
+      contentServer += '\r\n';
+      contentServer += `import Area from '@evershop/evershop/src/lib/components/Area';`;
+      contentServer += '\r\n';
+      contentServer += `Area.defaultProps.components = ${inspect(areas, { depth: 5 }).replace(/"---/g, '').replace(/---"/g, '')} `;
+
+      if (!fs.existsSync(path.resolve(subPath, 'server'))) {
+        await mkdir(path.resolve(subPath, 'server'), { recursive: true });
+      }
+      await writeFile(path.resolve(subPath, 'server', 'entry.js'), contentServer);
+      await writeFile(path.resolve(subPath, 'server', 'query.graphql'), query);
+    }
+  }));
+}

package/bin/lib/buildTailWind.js

@@ -0,0 +1,83 @@
+const fs = require('fs');
+const { mkdir, writeFile } = require('fs').promises;
+const path = require('path');
+const { getComponentsByRoute } = require('../../src/lib/componee/getComponentsByRoute');
+const { CONSTANTS } = require('../../src/lib/helpers');
+const { getRouteBuildPath } = require('../../src/lib/webpack/getRouteBuildPath');
+const dependencyTree = require('dependency-tree');
+const { isBuildRequired } = require('../../src/lib/webpack/isBuildRequired');
+const postcss = require('postcss');
+const tailwindcss = require('tailwindcss');
+const autoprefixer = require('autoprefixer');
+
+/**
+ * Only pass the page routes, not api routes
+*/
+module.exports.buildTailwind = async function buildTailwind(routes, clientOnly = false) {
+  await Promise.all(routes.map(async (route) => {
+    if (!isBuildRequired(route)) {
+      return;
+    }
+    const subPath = getRouteBuildPath(route);
+    const components = getComponentsByRoute(route);
+    if (!components) {
+      return;
+    }
+    /** Build layout and query */
+    let listModules = [];
+    components.forEach((module) => {
+      if (!fs.existsSync(module)) {
+        return;
+      }
+
+      const list = dependencyTree.toList({
+        filename: module,
+        directory: CONSTANTS.ROOTPATH,
+        filter: path => path.indexOf('.js') !== -1 && (path.indexOf('node_modules') === -1 || path.indexOf('@evershop') !== -1),
+      });
+
+      listModules = [...listModules, ...list];
+    });
+
+    // Use PostCss to parse tailwind.css with tailwind config
+    const defaultTailwindConfig = route.isAdmin ?
+      require('@evershop/evershop/src/modules/cms/services/tailwind.admin.config.js') :
+      require('@evershop/evershop/src/modules/cms/services/tailwind.frontStore.config.js');
+
+    let tailwindConfig = {};
+    if (route.isAdmin) {
+      if (fs.existsSync(path.join(CONSTANTS.ROOTPATH, 'tailwind.admin.config.js'))) {
+        tailwindConfig = require(path.join(CONSTANTS.ROOTPATH, 'tailwind.admin.config.js'));
+      }
+    } else {
+      if (fs.existsSync(path.join(CONSTANTS.ROOTPATH, 'tailwind.frontStore.config.js'))) {
+        tailwindConfig = require(path.join(CONSTANTS.ROOTPATH, 'tailwind.frontStore.config.js'));
+      }
+    }
+
+    // Merge defaultTailwindConfig with tailwindConfigJs
+    const mergedTailwindConfig = Object.assign(defaultTailwindConfig, tailwindConfig);
+    // get list of modules that are used in the webpack build
+
+    mergedTailwindConfig.content = listModules;
+
+    // Postcss with tailwind plugin
+
+    try {
+      // The default tailwind file
+      const c = `@tailwind base;
+@tailwind components;
+@tailwind utilities;`
+      const tailwindCssResult = postcss([tailwindcss(mergedTailwindConfig), autoprefixer]).process(c);
+
+      // get the css from the result
+      const tailwindCss = tailwindCssResult.css;
+      if (!fs.existsSync(path.resolve(subPath, 'client'))) {
+        await mkdir(path.resolve(subPath, 'client'), { recursive: true });
+      }
+      await writeFile(path.resolve(subPath, 'client', 'tailwind.scss'), tailwindCss);
+    } catch (error) {
+      throw new Error(error);
+    }
+  }));
+}

package/bin/lib/createComponents.js

@@ -0,0 +1,64 @@
+const { mkdir, writeFile } = require('fs').promises;
+const path = require('path');
+const { inspect } = require('util');
+const { Componee } = require('../../src/lib/componee/Componee');
+const isProductionMode = require('../../src/lib/util/isProductionMode');
+const { getRouteBuildPath } = require('../../src/lib/webpack/getRouteBuildPath');
+
+module.exports.createComponents = async function createComponents(routes, clientOnly = false) {
+  await Promise.all(routes.map(async (route) => {
+    const components = Componee.getComponentsByRoute(route.id);
+    if (!components) { return; }
+    Object.keys(components).forEach((area) => {
+      Object.keys(components[area]).forEach((id) => {
+        components[area][id].component = `---require("${components[area][id].source}")---`;
+        delete components[area][id].source;
+      });
+    });
+
+    let contentClient = `
+      import React from 'react';
+      import ReactDOM from 'react-dom';
+      import Area from '@evershop/evershop/src/lib/components/Area';
+      `;
+    if (isProductionMode()) {
+      contentClient += `import Hydrate from '@evershop/evershop/src/lib/components/react/client/Hydrate';`
+    } else {
+      contentClient += `import { App } from '@evershop/evershop/src/lib/components/react/client/Client';
+      const hot = require('webpack-hot-middleware/client?path=/eHot/${route.id}&reload=true');
+      import { HotReload } from '@evershop/evershop/src/lib/components/react/client/HotReload';
+      `;
+    }
+    contentClient += '\r\n';
+    contentClient += `Area.defaultProps.components = ${inspect(components, { depth: 5 }).replace(/'---/g, '').replace(/---'/g, '')} `;
+    contentClient += '\r\n';
+    if (isProductionMode()) {
+      contentClient += `ReactDOM.hydrate(
+        <Hydrate/>,
+        document.getElementById('app')
+      );`
+    } else {
+      contentClient += `
+      ReactDOM.render(<App routeId="${route.id}"><HotReload hot={hot} /></App>, document.getElementById('app'));
+      if (module.hot) {
+        module.hot.accept();
+      }
+      `;
+    }
+    await mkdir(path.resolve(getRouteBuildPath(route), 'client'), { recursive: true });
+    await writeFile(path.resolve(getRouteBuildPath(route), 'client', 'components.js'), contentClient);
+
+    if (!clientOnly) {
+      let contentServer = `import React from 'react'; `;
+      contentServer += '\r\n';
+      contentServer += `import ReactDOM from 'react-dom'; `;
+      contentServer += '\r\n';
+      contentServer += `import Area from '@evershop/evershop/src/lib/components/Area';`;
+      contentServer += '\r\n';
+      contentServer += `Area.defaultProps.components = ${inspect(components, { depth: 5 }).replace(/'---/g, '').replace(/---'/g, '')} `;
+
+      await mkdir(path.resolve(getRouteBuildPath(route), 'server'), { recursive: true });
+      await writeFile(path.resolve(getRouteBuildPath(route), 'server', 'components.js'), contentServer);
+    }
+  }));
+}

package/bin/lib/loadModuleRoutes.js

@@ -0,0 +1,62 @@
+const path = require('path');
+const { existsSync } = require('fs');
+const { registerAdminRoute } = require('../../src/lib/router/registerAdminRoute');
+const { registerFrontStoreRoute } = require('../../src/lib/router/registerFrontStoreRoute');
+const { scanForRoutes } = require('../../src/lib/router/scanForRoutes');
+
+module.exports = exports = {};
+
+exports.loadModuleRoutes = function loadModuleRoutes(modulePath) {
+  // Check for routes
+  if (existsSync(path.resolve(modulePath, 'pages', 'admin'))) {
+    const adminControllerRoutes = scanForRoutes(path.resolve(modulePath, 'pages', 'admin'), true, false);
+    adminControllerRoutes.forEach((route) => {
+      registerAdminRoute(
+        route.id,
+        route.method,
+        route.path,
+        route.isApi,
+        route.folder
+      );
+    });
+  }
+
+  if (existsSync(path.resolve(modulePath, 'pages', 'frontStore'))) {
+    const frontStoreControllerRoutes = scanForRoutes(path.resolve(modulePath, 'pages', 'frontStore'), false, false);
+    frontStoreControllerRoutes.forEach((route) => {
+      registerFrontStoreRoute(
+        route.id,
+        route.method,
+        route.path,
+        route.isApi,
+        route.folder
+      );
+    });
+  }
+
+  if (existsSync(path.resolve(modulePath, 'api', 'admin'))) {
+    const adminApiRoutes = scanForRoutes(path.resolve(modulePath, 'api', 'admin'), true, true);
+    adminApiRoutes.forEach((route) => {
+      registerAdminRoute(
+        route.id,
+        route.method,
+        route.path,
+        route.isApi,
+        route.folder
+      );
+    });
+  }
+
+  if (existsSync(path.resolve(modulePath, 'api', 'frontStore'))) {
+    const frontStoreApiRoutes = scanForRoutes(path.resolve(modulePath, 'api', 'frontStore'), false, true);
+    frontStoreApiRoutes.forEach((route) => {
+      registerFrontStoreRoute(
+        route.id,
+        route.method,
+        route.path,
+        route.isApi,
+        route.folder
+      );
+    });
+  }
+}

package/bin/lib/loadModules.js

@@ -0,0 +1,18 @@
+const { resolve } = require('path');
+const { readdirSync } = require('fs');
+module.exports = exports = {};
+
+var coreModules = [];
+
+exports.loadModules = function loadModule(path) {
+  return readdirSync(path, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => { return { name: dirent.name, path: resolve(path, dirent.name) } });
+}
+
+exports.getCoreModules = function getCoreModules() {
+  if (coreModules.length === 0) {
+    coreModules = exports.loadModules(resolve(__dirname, '../../src/modules'));
+  }
+  return coreModules;
+}

package/bin/lib/normalizePort.js

@@ -0,0 +1,19 @@
+/**
+ * Normalize a port into a number, string, or false.
+ */
+module.exports = function normalizePort() {
+  // eslint-disable-next-line no-shadow
+  const port = parseInt(process.env.PORT, 10);
+
+  // eslint-disable-next-line no-restricted-globals
+  if (isNaN(port)) {
+    return 3000;
+  }
+
+  if (port >= 0) {
+    // port number
+    return port;
+  }
+
+  return 3000;
+}

package/bin/lib/onError.js

@@ -0,0 +1,32 @@
+const { red, green } = require('kleur');
+const normalizePort = require('./normalizePort');
+
+const port = normalizePort()
+/**
+* Event listener for HTTP server "error" event.
+*/
+module.exports = function onError(error) {
+  if (error.syscall !== 'listen') {
+    throw error;
+  }
+
+
+  const bind = typeof port === 'string'
+    ? `Pipe ${port}`
+    : `Port ${port}`;
+
+  // handle specific listen errors with friendly messages
+  switch (error.code) {
+    case 'EACCES':
+      console.log(`${red(`${bind} requires elevated privileges`)}\n`);
+      process.exit(1);
+      break;
+    case 'EADDRINUSE':
+      console.log(`${red(`${bind} is already in use`)}\n`);
+      process.exit(1);
+      break;
+    default:
+      throw error;
+  }
+}
+

package/bin/lib/onListening.js

@@ -0,0 +1,19 @@
+const boxen = require('boxen');
+const { red, green } = require('kleur');
+const isDevelopmentMode = require('../../src/lib/util/isDevelopmentMode');
+const normalizePort = require('./normalizePort');
+const port = normalizePort()
+/**
+ * Event listener for HTTP server "listening" event.
+ */
+module.exports = function onListening(server) {
+  console.log(boxen(green(`Your website is running at "http://localhost:${port}"`), {
+    title: 'EverShop', titleAlignment: 'center', padding: 1, margin: 1, borderColor: 'green'
+  }));
+
+  // const addr = server.address();
+  // const bind = typeof addr === 'string'
+  //   ? `pipe ${addr}`
+  //   : `port ${addr.port}`;
+  // debug(`Listening on ${bind}`);
+}

package/bin/lib/prepare.js

@@ -0,0 +1,68 @@
+const { getAdminRoutes } = require("../../src/lib/router/Router");
+
+module.exports = exports = {};
+
+exports.prepare = function prepare(app, middlewares, routes) {
+  const adminRoutes = getAdminRoutes();
+
+  middlewares.forEach((m) => {
+    if (m.routeId === null) {
+      app.use(m.middleware);
+    } else if (m.routeId === 'admin') {
+      adminRoutes.forEach((route) => {
+        if ((route.id !== 'adminStaticAsset') || m.id === 'isAdmin') {
+          route.method.forEach((method) => {
+            switch (method.toUpperCase()) {
+              case 'GET':
+                app.get(route.path, m.middleware);
+                break;
+              case 'POST':
+                app.post(route.path, m.middleware);
+                break;
+              case 'PUT':
+                app.put(route.path, m.middleware);
+                break;
+              case 'DELETE':
+                app.delete(route.path, m.middleware);
+                break;
+              default:
+                app.get(route.path, m.middleware);
+                break;
+            }
+          });
+        }
+      });
+    } else if (m.routeId === 'frontStore') {
+      app.all('*', (request, response, next) => {
+        const route = request.currentRoute;
+        if (route.isAdmin === true || route.id === 'staticAsset') {
+          return next();
+        }
+        return m.middleware(request, response, next);
+      });
+    } else {
+      const route = routes.find((r) => r.id === m.routeId);
+      if (route !== undefined) {
+        route.method.forEach((method) => {
+          switch (method.toUpperCase()) {
+            case 'GET':
+              app.get(route.path, m.middleware);
+              break;
+            case 'POST':
+              app.post(route.path, m.middleware);
+              break;
+            case 'PUT':
+              app.put(route.path, m.middleware);
+              break;
+            case 'DELETE':
+              app.delete(route.path, m.middleware);
+              break;
+            default:
+              app.get(route.path, m.middleware);
+              break;
+          }
+        });
+      }
+    }
+  });
+}

package/bin/lib/startUp.js

@@ -0,0 +1,76 @@
+const http = require('http');
+const { createApp } = require('./app');
+const normalizePort = require('./normalizePort');
+const onListening = require('./onListening');
+const onError = require('./onError');
+const { Handler } = require('../../src/lib/middleware/Handler');
+const { getCoreModules } = require('./loadModules');
+const { migrate } = require('./bootstrap/migrate');
+const { loadBootstrapScript } = require('./bootstrap/bootstrap');
+const { getEnabledExtensions } = require('../extension');
+
+var app = createApp();
+/** Create a http server */
+const server = http.createServer(app);
+
+module.exports.start = async function start(cb) {
+  const modules = [...getCoreModules(), ...getEnabledExtensions()];
+  // /** Loading front-end components */
+  // modules.forEach((module) => {
+  //   try {
+  //     // Load components
+  //     Componee.loadModuleComponents(module);
+  //   } catch (e) {
+  //     console.log(e);
+  //     process.exit(0);
+  //   }
+  // });
+
+  /** Build the components */
+  // if (isDevelopmentMode()) {
+  //   const routes = getRoutes();
+  //   await createComponents(routes.filter((r) => isBuildRequired(r)), true);
+  // }
+
+  /** Migration */
+  try {
+    for (const module of modules) {
+      await migrate(module);
+    };
+  } catch (e) {
+    console.log(e);
+    process.exit(0);
+  }
+
+  /** Loading bootstrap script from modules */
+  try {
+    for (const module of modules) {
+      await loadBootstrapScript(module);
+    };
+  } catch (e) {
+    console.log(e);
+    process.exit(0);
+  }
+
+  /**
+   * Get port from environment and store in Express.
+   */
+  const port = normalizePort(process.env.PORT || '3000');
+  app.set('port', port);
+
+  /** Start listening */
+  server.on('listening', onListening);
+  cb ? server.on('listening', cb) : null;
+  server.on('error', onError);
+  server.listen(port);
+}
+
+module.exports.updateApp = function updateApp(cb) {
+  /** Clean up middleware */
+  Handler.middlewares = [];
+  var newApp = createApp();
+  server.removeListener('request', app);
+  server.on('request', newApp);
+  app = newApp;
+  cb();
+}

package/bin/lib/watch/broadcash.js

@@ -0,0 +1,17 @@
+const { getRoutes } = require('../../../src/lib/router/Router');
+
+module.exports.broadcash = function broadcash() {
+  const routes = getRoutes();
+  routes.forEach((route) => {
+    if (!route.isApi && !['staticAsset', 'adminStaticAsset'].includes(route.id)) {
+      const hotMiddleware = route.hotMiddleware;
+      if (hotMiddleware) {
+        hotMiddleware.publish({
+          action: 'serverReloaded'
+        });
+      }
+    } else {
+      return
+    }
+  });
+};

package/bin/lib/watch/refreshable.js

@@ -0,0 +1,20 @@
+const chokidar = require('chokidar');
+const { resolve } = require('path');
+const { CONSTANTS } = require('../../../src/lib/helpers');
+const { broadcash } = require('./broadcash');
+
+function refreshable() {
+  const watcher = chokidar.watch('./packages/evershop/src/lib/response/*', {
+    ignored: /node_modules[\\/]/,
+    ignoreInitial: true,
+    persistent: true
+  })
+  watcher.add('./packages/evershop/src/lib/util/*');
+  watcher.on('all', (event, path) => {
+    console.log(event);
+    delete require.cache[require.resolve(resolve(CONSTANTS.ROOTPATH, path))];
+    broadcash();
+  });
+}
+
+module.exports.refreshable = refreshable;

package/bin/lib/watch/watch.js

@@ -0,0 +1,31 @@
+const chokidar = require('chokidar');
+const { resolve, sep, normalize } = require('path');
+const { CONSTANTS } = require('../../../src/lib/helpers');
+const { existsSync } = require('fs');
+const { getConfig } = require('../../../src/lib/util/getConfig');
+
+function watch(calbacks = []) {
+  const watcher = chokidar.watch(resolve(CONSTANTS.ROOTPATH, 'extensions/**'), {
+    //ignored: /node_modules[\\/]/,
+    ignoreInitial: true,
+    persistent: true
+  });
+
+  if (existsSync(resolve(CONSTANTS.ROOTPATH, 'packages'))) {
+    watcher.add(resolve(CONSTANTS.ROOTPATH, 'packages/evershop/src/**'))
+  };
+
+  // Watch themes folder
+  const theme = getConfig('system.theme');
+  if (theme && existsSync(resolve(CONSTANTS.ROOTPATH, 'themes', theme))) {
+    watcher.add(resolve(CONSTANTS.ROOTPATH, 'themes', theme, '**'));
+  }
+
+  watcher.on('all', (event, path) => {
+    calbacks.forEach((callback) => {
+      callback(event, path);
+    });
+  });
+}
+
+module.exports.watch = watch;

package/bin/lib/watch/watchComponents.js

@@ -0,0 +1,25 @@
+const chokidar = require('chokidar');
+const { resolve, sep, normalize } = require('path');
+const { CONSTANTS } = require('../../../src/lib/helpers');
+const { Componee } = require('../../../src/lib/componee/Componee');
+const { createComponents } = require('../../lib/createComponents');
+const { getRoutes } = require('../../../src/lib/router/Router');
+const { isBuildRequired } = require('../../../src/lib/webpack/isBuildRequired');
+
+function watchComponents() {
+  chokidar.watch('**/**/pages/*.js', {
+    ignored: /node_modules[\\/]/,
+    ignoreInitial: true,
+    persistent: true
+  }).on('all', (event, path) => {
+    const modulePath = resolve(CONSTANTS.ROOTPATH, path).split(normalize('/views/'))[0];
+    Componee.updateModuleComponents({
+      name: modulePath.split(sep).reverse()[0],
+      path: modulePath
+    });
+    const routes = getRoutes();
+    createComponents(routes.filter((r) => isBuildRequired(r)), true);
+  });
+}
+
+module.exports.watchComponents = watchComponents;

package/bin/lib/watch/watchMF.js

@@ -0,0 +1,39 @@
+const { normalize, basename } = require('path');
+const { CONSTANTS } = require("../../../src/lib/helpers");
+const { Handler } = require('../../../src/lib/middleware/Handler');
+const { broadcash } = require('./broadcash');
+
+module.exports.watchMF = function (event, path) {
+  // Check if path include graphql/types
+  if (!path.includes(normalize('pages/admin')) &&
+    !path.includes(normalize('pages/frontStore')) &&
+    !path.includes(normalize('pages/global')) &&
+    !path.includes(normalize('api/admin')) &&
+    !path.includes(normalize('api/frontStore')) &&
+    !path.includes(normalize('api/global'))
+  ) {
+    return;
+  }
+
+  // Check if the file name is capitalized, then it is not a middleware
+  const fileName = basename(path);
+  if (fileName[0] !== '[' && fileName[0] === fileName[0].toUpperCase()) {
+    return;
+  }
+
+  if (event === 'change') {
+    delete require.cache[require.resolve(path)];
+  }
+  if (event === 'unlink') {
+    Handler.removeMiddleware(path);
+  }
+  if (event === 'add') {
+    Handler.addMiddlewareFromPath(path);
+  }
+  console.log('broadcashing')
+  try {
+    broadcash();
+  } catch (e) {
+    console.log(red(`Hot Reload Error: ${e.message}`));
+  }
+}