@evershop/evershop 1.0.0-beta

package/bin/install/index.js

@@ -0,0 +1,194 @@
+/* eslint-disable no-await-in-loop */
+const { readFileSync } = require('fs');
+const { writeFile, mkdir } = require('fs').promises;
+const path = require('path');
+const { red, green } = require('kleur');
+const ora = require('ora');
+const boxen = require('boxen');
+const mysql = require('mysql');
+const { execute } = require('@evershop/mysql-query-builder');
+const { prompt } = require('enquirer');
+const { CONSTANTS } = require('../../src/lib/helpers');
+const { migrate } = require('./migrate');
+const { createMigrationTable } = require('./createMigrationTable');
+
+function error(message) {
+  console.log(`\n❌ ${red(message)}`);
+}
+
+// eslint-disable-next-line func-names
+((async function () {
+  // eslint-disable-next-line no-var
+  var db;
+  // eslint-disable-next-line no-var
+  var adminUser;
+
+  // eslint-disable-next-line no-console
+  console.log(boxen(green('Welcome to EverShop - The open-source e-commerce platform'), {
+    title: 'EverShop', titleAlignment: 'center', padding: 1, margin: 1, borderColor: 'green'
+  }));
+
+  const dbQuestions = [
+    {
+      type: 'input',
+      name: 'databaseHost',
+      message: 'MySql Database Host (localhost)',
+      initial: 'localhost'
+    },
+    {
+      type: 'input',
+      name: 'databasePort',
+      message: 'MySql Database Port (3306)',
+      initial: 3306
+    },
+    {
+      type: 'input',
+      name: 'databaseName',
+      message: 'MySql Database Name (evershop)',
+      initial: 'evershop'
+    },
+    {
+      type: 'input',
+      name: 'databaseUser',
+      message: 'MySql Database User (root)',
+      initial: 'root'
+    },
+    {
+      type: 'input',
+      name: 'databasePassword',
+      message: 'MySql Database Password (<empty>)',
+      initial: ''
+    }
+  ];
+
+  try {
+    db = await prompt(dbQuestions);
+  } catch (e) {
+    process.exit(0);
+  }
+  const pool = mysql.createPool({
+    host: db.databaseHost,
+    port: db.databasePort,
+    user: db.databaseUser,
+    password: db.databasePassword,
+    database: db.databaseName,
+    dateStrings: true,
+    connectionLimit: 10
+  });
+  // Validate the database
+  try {
+    const result = await execute(pool, `SELECT table_name FROM information_schema.tables WHERE table_schema = '${db.databaseName || 'nodejscart'}'`);
+    if (result.length > 0) {
+      error(`The '${db.databaseName}' database is not empty. Please create a new one`);
+      process.exit(0);
+    }
+  } catch (e) {
+    error(e);
+    process.exit(0);
+  }
+
+  const adminUserQuestions = [
+    {
+      type: 'input',
+      name: 'fullName',
+      message: 'Your full name'
+    },
+    {
+      type: 'input',
+      name: 'email',
+      message: 'Your administrator user email',
+      validate: (value) => {
+        if (!value.match(
+          // eslint-disable-next-line no-useless-escape
+          /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/
+        )) {
+          return 'Invalid email';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Your administrator user password',
+      validate: (value) => {
+        if (value.length < 8) {
+          return 'Your password must be at least 8 characters.';
+        }
+        if (value.search(/[a-z]/i) < 0) {
+          return 'Your password must contain at least one letter.';
+        }
+        if (value.search(/[0-9]/) < 0) {
+          return 'Your password must contain at least one digit.';
+        }
+        return true;
+      }
+    }
+  ];
+
+  try {
+    adminUser = await prompt(adminUserQuestions);
+  } catch (e) {
+    process.exit(0);
+  }
+
+  /* Start installation */
+  const messages = [];
+  messages.push(`\n\n${green('EverShop is being installed ☕ ☕ ☕')}`);
+  messages.push('Creating configuration file');
+  const spinner = ora({
+    text: green(messages.join('\n')),
+    spinner: 'dots12'
+  }).start();
+  spinner.start();
+
+  /* Create folders */
+  await mkdir(path.resolve(CONSTANTS.ROOTPATH, 'config'), { recursive: true });
+  const configuration = JSON.parse(readFileSync(path.resolve(__dirname, './templates/config.json'), 'utf-8'));
+
+  // Update databse information
+  configuration.system.database = {
+    host: db.databaseHost,
+    port: db.databasePort,
+    database: db.databaseName,
+    user: db.databaseUser,
+    password: db.databasePassword
+  };
+
+  // Create a configuration file
+  await writeFile(path.resolve(CONSTANTS.ROOTPATH, 'config', 'default.json'), JSON.stringify(configuration, null, 4));
+
+  // Reload configuration
+  delete require.cache[require.resolve('config')];
+  require('config');
+
+  messages.pop();
+  messages.push(green('✔ Create configuration file'));
+  spinner.text = messages.join('\n');
+
+  // Create `media` folder
+  await mkdir(path.resolve(CONSTANTS.ROOTPATH, 'media'), { recursive: true });
+
+  // Start install database
+  messages.push(green('Setting up a database'));
+  spinner.text = messages.join('\n');
+
+  try {
+    await createMigrationTable(pool);
+  } catch (e) {
+    error(e);
+    process.exit(0);
+  }
+
+  await migrate(pool, path.resolve(__dirname, '../../src/modules'), adminUser);
+  messages.pop();
+  messages.push(green('✔ Setup database'));
+  messages.push(green('✔ Create admin user'));
+  spinner.succeed(messages.join('\n'));
+
+  // eslint-disable-next-line no-console
+  console.log(boxen(green('Installation completed!. Run `npm run build` and `npm run start` to launch your store'), {
+    title: 'EverShop', titleAlignment: 'center', padding: 1, margin: 1, borderColor: 'green'
+  }));
+  process.exit(0);
+})());

package/bin/install/migrate.js

@@ -0,0 +1,67 @@
+const { insertOnUpdate } = require('@evershop/mysql-query-builder');
+const { readdirSync, existsSync } = require('fs');
+const path = require('path');
+const semver = require('semver');
+const bcrypt = require('bcrypt');
+
+module.exports.migrate = async function migrate(connection, modulePath, adminUser) {
+  const modules = readdirSync(path.resolve(modulePath), { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name);
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const module of modules) {
+    try {
+      if (existsSync(path.resolve(modulePath, module, 'migration'))) {
+        const migrations = readdirSync(path.resolve(modulePath, module, 'migration'), { withFileTypes: true })
+          .filter((dirent) => dirent.isFile() && dirent.name.match(/^Version-+([1-9].[0-9].[0-9])+.js$/))
+          .map((dirent) => dirent.name.replace('Version-', '').replace('.js', ''))
+          .sort((first, second) => semver.lt(first, second));
+        // eslint-disable-next-line no-restricted-syntax
+        for (const version of migrations) {
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            // eslint-disable-next-line global-require
+            await (require(path.resolve(modulePath, module, 'migration', `Version-${version}.js`)))();
+            // eslint-disable-next-line no-await-in-loop
+            await insertOnUpdate('migration').given({
+              module,
+              version,
+              status: 1
+            })
+              .execute(connection);
+          } catch (e) {
+            console.error(e.message);
+            process.exit(0);
+          }
+        }
+
+        if (migrations.length === 0) {
+          await insertOnUpdate('migration').given({
+            module,
+            version: '1.0.0',
+            status: 1
+          })
+            .execute(connection);
+        }
+      } else {
+        await insertOnUpdate('migration').given({
+          module,
+          version: '1.0.0',
+          status: 1
+        })
+          .execute(connection);
+      }
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  await insertOnUpdate('admin_user').given({
+    status: 1,
+    email: adminUser?.email || 'demo@demo.com',
+    password: await bcrypt.hash(adminUser?.password || '123456', 10),
+    full_name: adminUser?.fullName || 'Admin'
+  })
+    .execute(connection);
+}

package/bin/install/templates/config.json

@@ -0,0 +1,93 @@
+{
+    "catalog": {
+        "product": {
+            "image": {
+                "thumbnail": {
+                    "width": 100,
+                    "height": 100
+                },
+                "listing": {
+                    "width": 300,
+                    "height": 300
+                },
+                "single": {
+                    "width": 500,
+                    "height": 500
+                },
+                "placeHolder": "/default/image/placeholder.png"
+            }
+        },
+        "showOutOfStockProduct": false
+    },
+    "checkout": {
+        "allowCountries": [
+            "US",
+            "VN"
+        ],
+        "shippingRate": [
+            {
+                "condition": {},
+                "destimation": [
+                    "*"
+                ],
+                "rate": 10
+            }
+        ]
+    },
+    "order": {
+        "shipmentStatus": [
+            {
+                "name": "Unfullfilled",
+                "code": "unfullfilled",
+                "badge": "warning",
+                "progress": "incomplete"
+            },
+            {
+                "name": "Fullfilled",
+                "code": "fullfilled",
+                "badge": "success",
+                "progress": "complete"
+            }
+        ],
+        "paymentStatus": [
+            {
+                "name": "Pending",
+                "code": "pending",
+                "badge": "default",
+                "progress": "incomplete"
+            },
+            {
+                "name": "Paid",
+                "code": "paid",
+                "badge": "success",
+                "progress": "complete"
+            },
+            {
+                "name": "Refunded",
+                "code": "refunded",
+                "badge": "critical",
+                "progress": "complete"
+            }
+        ]
+    },
+    "customer": {
+        "address": {
+            "full_name": {
+                "type": "text",
+                "title": "Full name",
+                "validarionRules": [
+                    "notEmpty"
+                ]
+            }
+        }
+    },
+    "system": {
+        "database": {
+            "host": "localhost",
+            "port": 3306,
+            "database": "nodejscart",
+            "user": "admin",
+            "password": "123456"
+        }
+    }
+}

package/bin/lib/addDefaultMiddlewareFuncs.js

@@ -0,0 +1,177 @@
+const cookieParser = require('cookie-parser');
+const webpack = require("webpack");
+const middleware = require("webpack-dev-middleware");
+const { createConfigClient } = require('../../src/lib/webpack/dev/createConfigClient');
+const isDevelopmentMode = require('../../src/lib/util/isDevelopmentMode');
+const { isBuildRequired } = require('../../src/lib/webpack/isBuildRequired');
+const publicStatic = require('../../src/lib/middlewares/publicStatic');
+
+module.exports = exports = {};
+
+exports.addDefaultMiddlewareFuncs = function addDefaultMiddlewareFuncs(app, routes) {
+  // Add public static middleware
+  app.use(publicStatic);
+
+  routes.forEach((r) => {
+    const currentRouteMiddleware = (request, response, next) => {
+      // eslint-disable-next-line no-underscore-dangle
+      request.currentRoute = r;
+      next();
+    };
+    r.method.forEach((method) => {
+      switch (method.toUpperCase()) {
+        case 'GET':
+          app.get(r.path, currentRouteMiddleware);
+          break;
+        case 'POST':
+          app.post(r.path, currentRouteMiddleware);
+          break;
+        case 'PUT':
+          app.put(r.path, currentRouteMiddleware);
+          break;
+        case 'DELETE':
+          app.delete(r.path, currentRouteMiddleware);
+          break;
+        default:
+          app.get(r.path, currentRouteMiddleware);
+          break;
+      }
+    });
+
+    /** 405 Not Allowed handle */
+    app.all(r.path, (request, response, next) => {
+      // eslint-disable-next-line no-underscore-dangle
+      if (request.currentRoute && !request.currentRoute.method.includes(request.method)) {
+        response.status(405).send('Method Not Allowed');
+      } else {
+        next();
+      }
+    });
+
+    // Cookie parser
+    app.use(cookieParser());
+
+    // TODO:Termporary comment this code, Because some API requires body raw data. Like Stripe
+    // if (r.isApi) {
+    //   app.all(r.path, bodyParser.json({ inflate: false }));
+    //   app.all(r.path, bodyParser.urlencoded({ extended: true }));
+    // }
+
+    // eslint-disable-next-line no-underscore-dangle
+    // eslint-disable-next-line no-param-reassign
+    // eslint-disable-next-line no-underscore-dangle
+    r.__BUILDREQUIRED__ = true;
+  });
+
+  if (isDevelopmentMode()) {
+    routes.forEach((route) => {
+      if (isBuildRequired(route)) {
+        route.webpackCompiler = webpack(createConfigClient(route));
+      } else {
+        return
+      }
+    });
+
+    function findRoute(request) {
+      if (request.currentRoute) {
+        return request.currentRoute
+      } else {
+        const path = request.originalUrl.split('?')[0];
+        if (path.endsWith('.js') || path.endsWith('.css') || path.endsWith('.json')) {
+          const id = path.split('/').pop().split('.')[0];
+          return routes.find((r) => r.id === id) || routes.find((r) => r.id === 'notFound');
+        } else if (path.includes('/eHot/')) {
+          const id = path.split('/').pop();
+          return routes.find((r) => r.id === id);
+        } else {
+          return routes.find((r) => r.id === 'notFound');
+        }
+      }
+    }
+
+    app.use(
+      (request, response, next) => {
+        const route = findRoute(request);
+        request.locals = request.locals || {};
+        request.locals.webpackMatchedRoute = route;
+        if (!isBuildRequired(route)) {
+          next();
+        } else {
+          const webpackCompiler = route.webpackCompiler;
+          let middlewareFunc;
+          if (!route.webpackMiddleware) {
+            middlewareFunc = route.webpackMiddleware = middleware(webpackCompiler, {
+              serverSideRender: true, publicPath: '/', stats: 'none'
+            });
+            middlewareFunc.context.logger.info = (message) => {
+              return
+            }
+          } else {
+            middlewareFunc = route.webpackMiddleware;
+          }
+          // We need to run build for notFound route
+          const notFoundRoute = routes.find((r) => r.id === 'notFound');
+          const notFoundWebpackCompiler = notFoundRoute.webpackCompiler;
+          let notFoundMiddlewareFunc;
+          if (!notFoundRoute.webpackMiddleware) {
+            notFoundMiddlewareFunc = notFoundRoute.webpackMiddleware = middleware(notFoundWebpackCompiler, {
+              serverSideRender: true, publicPath: '/', stats: 'none'
+            });
+            notFoundMiddlewareFunc.context.logger.info = (message) => {
+              return
+            }
+          } else {
+            notFoundMiddlewareFunc = notFoundRoute.webpackMiddleware;
+          }
+
+          // We need to run build for adminNotFound route
+          const adminNotFoundRoute = routes.find((r) => r.id === 'adminNotFound');
+          const adminNotFoundWebpackCompiler = adminNotFoundRoute.webpackCompiler;
+          let adminNotFoundMiddlewareFunc;
+          if (!adminNotFoundRoute.webpackMiddleware) {
+            adminNotFoundMiddlewareFunc = adminNotFoundRoute.webpackMiddleware = middleware(adminNotFoundWebpackCompiler, {
+              serverSideRender: true, publicPath: '/', stats: 'none'
+            });
+            adminNotFoundMiddlewareFunc.context.logger.info = (message) => {
+              return
+            }
+          } else {
+            adminNotFoundMiddlewareFunc = adminNotFoundRoute.webpackMiddleware;
+          }
+
+          middlewareFunc(request, response, () => {
+            notFoundMiddlewareFunc(request, response, () => {
+              adminNotFoundMiddlewareFunc(request, response, next)
+            })
+          });
+        }
+      }
+    );
+
+    routes.forEach((route) => {
+      if (isBuildRequired(route)) {
+        const webpackCompiler = route.webpackCompiler;
+        const hotMiddleware = route.hotMiddleware ? route.hotMiddleware : require("webpack-hot-middleware")(webpackCompiler, { path: `/eHot/${route.id}` });
+        if (!route.hotMiddleware) {
+          route.hotMiddleware = hotMiddleware;
+        }
+        app.use(
+          hotMiddleware
+        );
+      } else {
+        return
+      }
+    });
+  }
+
+  /** 404 Not Found handle */
+  app.use((request, response, next) => {
+    if (!request.currentRoute) {
+      response.status(404);
+      request.currentRoute = routes.find((r) => r.id === 'notFound');
+      next();
+    } else {
+      next();
+    }
+  });
+}

package/bin/lib/app.js

@@ -0,0 +1,63 @@
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-param-reassign */
+/* eslint-disable global-require */
+const express = require('express');
+const { getModuleMiddlewares } = require('../../src/lib/middleware');
+const { getRoutes } = require('../../src/lib/router/Router');
+const { getCoreModules } = require('./loadModules');
+const { addDefaultMiddlewareFuncs } = require('./addDefaultMiddlewareFuncs');
+const { loadModuleRoutes } = require('./loadModuleRoutes');
+const { Handler } = require('../../src/lib/middleware/Handler');
+const { getEnabledExtensions } = require('../extension');
+
+module.exports.createApp = () => {
+  /** Create express app */
+  const app = express();
+
+  /* Loading modules and initilize routes, components and services */
+  const modules = getCoreModules();
+
+  // 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);
+    }
+  });
+
+  /** Load extensions */
+  const extensions = getEnabledExtensions();
+  extensions.forEach((extension) => {
+    try {
+      // Load middleware functions
+      getModuleMiddlewares(extension.resolve);
+      // Load routes
+      loadModuleRoutes(extension.resolve);
+    } catch (e) {
+      console.log(e);
+      process.exit(0);
+    }
+  });
+
+  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());
+  })
+
+  return app;
+};

package/bin/lib/bootstrap/bootstrap.js

@@ -0,0 +1,11 @@
+const { existsSync } = require('fs');
+const path = require('path');
+
+module.exports = exports = {};
+
+exports.loadBootstrapScript = async function loadBootstrapScript(module) {
+  if (existsSync(path.resolve(module.path, 'bootstrap.js'))) {
+    /** We expect the bootstrap script to provide a function as a default export */
+    await require(path.resolve(module.path, 'bootstrap.js'))();
+  };
+}

package/bin/lib/bootstrap/migrate.js

@@ -0,0 +1,46 @@
+const path = require('path');
+const semver = require('semver');
+const { insertOnUpdate, select } = require('@evershop/mysql-query-builder');
+const { pool } = require('../../../src/lib/mysql/connection');
+const { existsSync, readdirSync } = require('fs');
+
+async function getCurrentInstalledVersion(module) {
+  /** Check for current installed version */
+  const check = await select()
+    .from('migration')
+    .where('module', '=', module)
+    .load(pool);
+  if (!check) {
+    return '0.0.1';
+  } else {
+    return check['version'];
+  }
+}
+
+module.exports.migrate = async function migrate(module) {
+  if (!existsSync(path.resolve(module.path, 'migration'))) {
+    return;
+  }
+  const migrations = readdirSync(path.resolve(module.path, 'migration'), { withFileTypes: true })
+    .filter((dirent) => dirent.isFile() && dirent.name.match(/^Version-+([1-9].[0-9].[0-9])+.js$/))
+    .map((dirent) => dirent.name.replace('Version-', '').replace('.js', ''))
+    .sort((first, second) => semver.lt(first, second));
+  const currentInstalledVersion = await getCurrentInstalledVersion(module.name);
+  for (const version of migrations) {
+    /** If the version is lower or equal the installed version, ignore it */
+    if (semver.lte(version, currentInstalledVersion)) {
+      continue;
+    }
+    // eslint-disable-next-line no-await-in-loop
+    // eslint-disable-next-line global-require
+    /** We expect the migration script to provide a function as a default export */
+    await (require(path.resolve(module.path, 'migration', `Version-${version}.js`)))();
+    // eslint-disable-next-line no-await-in-loop
+    await insertOnUpdate('migration').given({
+      module: module.name,
+      version,
+      status: 1
+    })
+      .execute(pool);
+  }
+}