@evershop/evershop 1.0.0-beta

package/src/lib/webpack/prod/createConfigServer.js

@@ -0,0 +1,38 @@
+const path = require('path');
+const { CONSTANTS } = require('../../helpers');
+const { createBaseConfig } = require('../createBaseConfig');
+const { getRouteBuildPath } = require('../getRouteBuildPath');
+const { getRouteBuildSubPath } = require('../getRouteBuildSubPath');
+const { isBuildRequired } = require('../isBuildRequired');
+const WebpackBar = require('webpackbar');
+
+module.exports.createConfigServer = function createConfigServer(routes) {
+  const entry = {};
+  routes.forEach((route) => {
+    if (!isBuildRequired(route)) {
+      return;
+    }
+    const subPath = getRouteBuildSubPath(route);
+    entry[subPath] = [
+      path.resolve(CONSTANTS.BUILDPATH, subPath, 'server', 'entry.js'),
+      path.resolve(CONSTANTS.LIBPATH, 'components', 'react', 'server', 'render.js')
+    ];
+  });
+  const config = createBaseConfig(true);
+  const plugins = config.plugins;
+  plugins.push(new WebpackBar({ name: 'Server', color: 'orange' }),)
+
+  const loaders = config.module.rules;
+  loaders.push({
+    test: /\.scss$/i,
+    use: [
+      {
+        loader: path.resolve(CONSTANTS.LIBPATH, 'webpack/loaders/styleLoader.js'),
+      }
+    ],
+  })
+  config.entry = entry;
+  config.name = 'Server';
+
+  return config;
+}

package/src/lib/webpack/util/parseGraphql.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const uniqid = require('uniqid');
+const { CONSTANTS } = require('../../helpers');
+const { parseGraphqlByFile } = require('./parseGraphqlByFile');
+
+module.exports.parseGraphql = function (modules) {
+  let inUsedFragments = [];
+  let propsMap = {};
+  let queryStr = '';
+  let fragmentStr = '';
+  let variables = {
+    values: {},
+    defs: []
+  };
+
+  modules.forEach((module) => {
+    if (!fs.existsSync(module)) {
+      return;
+    }
+
+    const moduleKey = Buffer.from(module.replace(CONSTANTS.ROOTPATH, '')).toString('base64');
+    const moduleGraphqlData = parseGraphqlByFile(module);
+    queryStr += '\n' + moduleGraphqlData.query.source;
+    fragmentStr += '\n' + moduleGraphqlData.fragments.source;
+    Object.assign(variables.values, JSON.parse(moduleGraphqlData.variables.source));
+    variables.defs = variables.defs.concat(moduleGraphqlData.variables.definitions);
+    propsMap[moduleKey] = moduleGraphqlData.query.props;
+    inUsedFragments = inUsedFragments.concat(moduleGraphqlData.fragments.pairs);
+  });
+
+  // Process fragments
+  const extraFragments = [];
+  inUsedFragments.forEach((fragment) => {
+    // Check if there was a fragment with same name and type already processed
+    const f = extraFragments.find((f) => f.name === fragment.name && f.type === fragment.type);
+    if (f) {
+      // Replace fragment alias with the one already processed
+      const regex = new RegExp(`\\.\\.\\.([ ]+)?${fragment.alias}`, 'g');
+      queryStr = queryStr.replace(regex, `...${f.alias}`);
+      fragmentStr = fragmentStr.replace(regex, `...${f.alias}`);
+    } else {
+      const regex = new RegExp(`fragment([ ]+)${fragment.name}([ ]+)on([ ]+)${fragment.type}`, 'g');
+      fragmentStr = fragmentStr.replace(regex, (match, p1, p2, p3) => {
+        const alias = `${fragment.name}_${uniqid()}`;
+        // Check if there is a fragment with the same name and type
+        const frm = extraFragments.find((f) => f.name === fragment.name && f.type === fragment.type);
+        if (frm) {
+          frm.child.push(alias);
+        } else {
+          extraFragments.push({
+            name: fragment.name,
+            alias: fragment.alias,
+            type: fragment.type,
+            child: [alias]
+          });
+        }
+        return `fragment ${alias} on ${fragment.type}`;
+      })
+    }
+  });
+  extraFragments.forEach((fragment) => {
+    fragmentStr += `\nfragment ${fragment.alias} on ${fragment.type} {\n ${fragment.child.map((c) => `...${c}`).join('\n')} \n}`;
+  });
+
+  return {
+    query: queryStr,
+    fragments: fragmentStr,
+    variables: JSON.stringify(variables),
+    propsMap: propsMap
+  }
+}

package/src/lib/webpack/util/parseGraphqlByFile.js

@@ -0,0 +1,191 @@
+const fs = require('fs');
+const { parse } = require('graphql');
+const uniqid = require('uniqid');
+const { print } = require("graphql/language/printer");
+
+// This function should return an object { query, fragments, variables }.
+module.exports.parseGraphqlByFile = function (module) {
+  const result = {
+    query: {},
+    fragments: {},
+    variables: {}
+  };
+
+  const variables = [];
+
+  const fileSource = fs.readFileSync(module, 'utf8');
+  /** Process query */
+  // Regex matching export const query = `...` or export const query = "" or export const query = ''
+  const queryRegex = /export\s+const\s+query\s*=\s*`([^`]+)`|export\s+const\s+query\s*=\s*["']([^"']+)["']/g;
+  let queryMatch = fileSource.match(queryRegex);
+  if (queryMatch) {
+    let queryBody = queryMatch[0].replace(queryRegex, (match, p1, p2) => p1 || p2);
+    // Replace 'getContextValue("key")' or getContextValue('key') or 'getContextValue("key", defaultValue)' or 'getContextValue('x', defaultValue)' to 'getContextValue_`base64 encoded of key and defaultValue`'`)' to avoid conflict with graphql-tag
+    queryBody = queryBody.replace(/getContextValue\(([^)]+)\)/g, (match, p1) => {
+      // const args = p1.split(',').map((arg) => arg.trim());
+      // const key = args[0].replace(/['"]/g, '');
+      // const defaultValue = args[1] ? args[1].replace(/['"]/g, '') : undefined;
+      const base64 = Buffer.from(p1).toString('base64');
+      return `"getContextValue_${base64}"`;
+    });
+
+    const queryAst = parse(queryBody);
+    const map = queryAst.definitions[0].selectionSet.selections.map((selection) => {
+      const name = selection.name.value;
+      const alias = selection.alias ? selection.alias.value : name;
+      const newAlias = `e${uniqid()}`;
+      if (!selection.alias) {
+        selection.alias = {
+          kind: 'Name',
+          value: newAlias
+        }
+      } else {
+        selection.alias.value = newAlias;
+      }
+
+      return {
+        origin: alias,
+        alias: newAlias,
+      };
+    });
+
+    // Get back the new query string
+    queryBody = print(queryAst);
+
+    // Regex to find all variable name and type ($name: Type!) in graphql query
+    const variableRegex = /\$([a-zA-Z0-9]+)\s*:\s*([a-zA-Z0-9\[\]!]+)/g;
+    let variableMatch = queryBody.match(variableRegex);
+    if (variableMatch) {
+      variableMatch.map((variable) => {
+        const variableRegex = /\$([a-zA-Z0-9]+)\s*:\s*([a-zA-Z0-9\[\]!]+)/;
+        const variableMatch = variableRegex.exec(variable);
+        const name = variableMatch[1];
+        const type = variableMatch[2];
+        variables.push({
+          origin: name,
+          type,
+          alias: `v${uniqid()}`,
+        });
+      });
+    }
+
+    // Relace all variable in graphql query
+    variables.forEach((variable) => {
+      const regex = new RegExp(`\\$${variable.origin}`, 'g');
+      queryBody = queryBody.replace(regex, `$${variable.alias}`);
+    });
+
+    // Use slice function to get everything between the first '{' and the last '}' in the query
+    queryBody = queryBody.slice(queryBody.indexOf('{') + 1, queryBody.lastIndexOf('}'));
+
+    result.query.source = queryBody;
+    result.query.props = map;
+  } else {
+    result.query.source = '';
+    result.query.props = [];
+  }
+
+  //const variableRegex = /\$([a-zA-Z0-9]+\s*[:][])/g;
+
+  // let variableMatch = queryBody.match(variableRegex);
+  // if (variableMatch) {
+  //   variableMatch.forEach((variable) => {
+  //     const variableName = variable.replace(/[:\s]/g, '');
+  //     variables.push({
+  //       origin: variableName,
+  //       alias: `v${uniqid()}`,
+  //     });
+  //   });
+  // };
+
+  /** Process fragments */
+  // Regex matching export const query = `...` or export const query = "" or export const query = ''
+  const fragmentsRegex = /export\s+const\s+fragments\s*=\s*`([^`]+)`|export\s+const\s+fragments\s*=\s*["']([^"']+)["']/g;
+  let fragmentsMatch = fileSource.match(fragmentsRegex);
+  const fragmentNames = [];
+  if (fragmentsMatch) {
+    let fragmentsBody = fragmentsMatch[0].replace(fragmentsRegex, (match, p1, p2) => p1 || p2);
+    const fragmentsAst = parse(fragmentsBody);
+    fragmentsAst.definitions.forEach((fragment) => {
+      if (fragment.kind === 'FragmentDefinition') {
+        fragmentNames.push({
+          name: fragment.name.value,
+          type: fragment.typeCondition.name.value
+        });
+      } else {
+        throw new Error(`Only fragments are allowed in 'export const fragments = \`...\`. Error in ${module}`);
+      }
+    });
+    result.fragments.source = fragmentsBody;
+  } else {
+    result.fragments.source = '';
+  }
+
+  // Using regex to get all fragment consumption (e.g. ...fragmentName)
+  const fragmentConsumptions = (result.query.source.match(/\.\.\.([ ]+)?([a-zA-Z0-9_]+)/g) || []).concat((result.fragments.source.match(/\.\.\.([ ]+)?([a-zA-Z0-9_]+)/g) || []));
+  if (fragmentConsumptions.length > 0) {
+    fragmentConsumptions.forEach((fragmentConsumption) => {
+      const fragmentName = fragmentConsumption.replace(/\.\.\.([ ]+)?/, '');
+      const fragment = fragmentNames.find((fragment) => fragment.name === fragmentName);
+      if (!fragment) {
+        throw new Error(`Fragment '${fragmentName}' is not defined in ${module}`);
+      } else {
+        result.fragments.pairs = result.fragments.pairs || [];
+        const alias = `${fragmentName}_${uniqid()}`;
+        const regex = new RegExp(`\\.\\.\\.([ ]+)?${fragmentName}`, 'g');
+        // Replace in query source with alias
+        result.query.source = result.query.source.replace(regex, `...${alias}`);
+        // Replace in fragment source with alias
+        result.fragments.source = result.fragments.source.replace(regex, `...${alias}`);
+        result.fragments.pairs.push({
+          name: fragmentName,
+          alias: alias,
+          type: fragment.type
+        });
+      }
+    });
+  } else {
+    result.fragments.pairs = [];
+  }
+
+  /** Processing variables */
+  // Regex matching export const variables = `{ ... }`
+  const variablesRegex = /export\s+const\s+variables\s*=\s*`([^`]+)`/g;
+  let variablesMatch = fileSource.match(variablesRegex);
+  if (variablesMatch) {
+    let variablesBody = variablesMatch[0].replace(variablesRegex, (match, p1) => p1);
+    // Replace 'getContextValue("key")' or getContextValue('key') or 'getContextValue("key", defaultValue)' or 'getContextValue('x', defaultValue)' to 'getContextValue_`base64 encoded of key and defaultValue`'`)' to avoid conflict with graphql-tag
+    variablesBody = variablesBody.replace(/getContextValue\(([^)]+)\)/g, (match, p1) => {
+      // const args = p1.split(',').map((arg) => arg.trim());
+      // const key = args[0].replace(/['"]/g, '');
+      // const defaultValue = args[1] ? args[1].replace(/['"]/g, '') : undefined;
+      // console.log('defaultValue', defaultValue);
+      const base64 = Buffer.from(p1).toString('base64');
+      return `"getContextValue_${base64}"`;
+    });
+
+    try {
+      // Json parse the variables body
+      const variablesJson = JSON.parse(variablesBody);
+      // Replace all variable in graphql query
+      Object.keys(variablesJson).forEach((variableName) => {
+        const variable = variables.find((variable) => variable.origin === variableName);
+        if (variable) {
+          variablesJson[variable.alias] = variablesJson[variableName];
+          delete variablesJson[variableName];
+        }
+      });
+      result.variables.source = JSON.stringify(variablesJson);
+      result.variables.definitions = variables;
+    } catch (e) {
+      console.log(e);
+      throw new Error(`Invalid variables in ${module}`);
+    }
+  } else {
+    result.variables.source = '{}';
+    result.variables.definitions = [];
+  }
+  return result;
+}
+
+

package/src/lib/webpack/webpack.js

@@ -0,0 +1,9 @@
+const { webpack } = require('webpack');
+const { createConfig } = require('./configProvider');
+
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+exports.createWebpack = function createWebpack(scopePath) {
+  return webpack(createConfig(scopePath));
+};

package/src/modules/auth/api/admin/adminAuth/[bodyParser]authenticate.js

@@ -0,0 +1,57 @@
+const { select, insertOnUpdate } = require('@evershop/mysql-query-builder');
+const { pool } = require('../../../../../lib/mysql/connection');
+const { compare } = require('bcrypt');
+const { sign } = require('jsonwebtoken');
+const { camelCase } = require('../../../../../lib/util/camelCase');
+const { v4: uuidv4 } = require('uuid');
+const { getAdminTokenCookieId } = require('../../../services/getAdminTokenCookieId');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, stack, next) => {
+  const { body } = request;
+  const { email, password } = body;
+  const user = await select()
+    .from('admin_user')
+    .where('email', '=', email)
+    .load(pool);
+
+  if (!user) {
+    return response.status(401).json({
+      success: false,
+      message: 'Invalid email or password'
+    });
+  } else {
+    const { password: hash } = user;
+    const result = await compare(password, hash);
+
+    if (!result) {
+      return response.status(401).json({
+        success: false,
+        message: 'Invalid email or password'
+      });
+    } else {
+      const JWT_SECRET = uuidv4();
+      // Save the JWT_SECRET to the database
+      await insertOnUpdate('user_token_secret')
+        .given({
+          user_id: user.uuid,
+          secret: JWT_SECRET
+        })
+        .execute(pool);
+
+      delete user.password;
+      const token = sign({ user: { ...camelCase(user), isAdmin: true }, sid: uuidv4() }, JWT_SECRET, { expiresIn: '1d' });
+      // Send a response with the cookie
+      response.cookie(getAdminTokenCookieId(), token, {
+        httpOnly: true,
+        maxAge: 1000 * 60 * 60 * 24
+      });
+      return response.status(200).json({
+        success: true,
+        data: {
+          token
+        }
+      });
+    }
+  }
+};

package/src/modules/auth/api/admin/adminAuth/bodyParser.js

@@ -0,0 +1,7 @@
+const bodyParser = require('body-parser');
+
+module.exports = (request, response, stack, next) => {
+  bodyParser.json({ inflate: false })(request, response, () => {
+    bodyParser.urlencoded({ extended: true })(request, response, next);
+  });
+}

package/src/modules/auth/api/admin/adminAuth/route

@@ -0,0 +1,2 @@
+POST
+/authenticate

package/src/modules/auth/api/admin/adminLogout/logout.js

@@ -0,0 +1,41 @@
+const { del } = require('@evershop/mysql-query-builder');
+const jwt = require('jsonwebtoken');
+const { pool } = require('../../../../../lib/mysql/connection');
+const { buildUrl } = require('../../../../../lib/router/buildUrl');
+const { getAdminTokenCookieId } = require('../../../services/getAdminTokenCookieId');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, stack, next) => {
+  // Get the jwt token from the cookies
+  const token = request.cookies[getAdminTokenCookieId()];
+  // Get user from token
+  const tokenPayload = jwt.decode(token, { complete: true, json: true });
+
+  // Check if user is in the token
+  if (!tokenPayload.payload?.user) {
+    // Check if the http method is GET
+    if (request.method === 'GET') {
+      // Redirect to login page
+      response.redirect(buildUrl('adminLogin'));
+    } else {
+      return response.status(200).json({
+        success: true
+      });
+    }
+  } else {
+    // Delete the secret from the database
+    await del('user_token_secret')
+      .where('user_id', '=', tokenPayload.payload.user?.uuid)
+      .execute(pool);
+
+    // Check if the http method is GET
+    if (request.method === 'GET') {
+      // Redirect to login page
+      response.redirect(buildUrl('adminLogin'));
+    } else {
+      return response.status(200).json({
+        success: true
+      });
+    }
+  }
+};

package/src/modules/auth/api/admin/adminLogout/route

@@ -0,0 +1,2 @@
+POST, GET
+/logout

package/src/modules/auth/api/admin/all/[tokenVerify]auth.js

@@ -0,0 +1,23 @@
+const { get } = require('../../../../../lib/util/get');
+const { getContextValue } = require('../../../../graphql/services/contextHelper');
+
+module.exports = (request, response, stack, next) => {
+  // Get the token Payload
+  const tokenPayLoad = getContextValue(request, 'tokenPayload');
+  // If there is no token or is not admin, redirect to login page
+  if (!tokenPayLoad || !get(tokenPayLoad, 'user.isAdmin')) {
+    // Check if the current route is adminAuth
+    if (request.currentRoute.id === 'adminAuth') {
+      next();
+    } else {
+      // Response with 401 status code
+      response.status(401);
+      response.json({
+        success: false,
+        message: 'Unauthorized'
+      })
+    }
+  } else {
+    next();
+  }
+};

package/src/modules/auth/api/global/[context]tokenVerify.js

@@ -0,0 +1,56 @@
+const { select } = require('@evershop/mysql-query-builder');
+const jwt = require('jsonwebtoken');
+const { v4: uuidv4 } = require('uuid');
+const { pool } = require('../../../../lib/mysql/connection');
+const { get } = require('../../../../lib/util/get');
+const { setContextValue } = require('../../../graphql/services/contextHelper');
+const { generateToken } = require('../../services/generateToken');
+const { getAdminTokenCookieId } = require('../../services/getAdminTokenCookieId');
+const { getTokenCookieId } = require('../../services/getTokenCookieId');
+const { getTokenSecret } = require('../../services/getTokenSecret');
+
+module.exports = async (request, response, stack, next) => {
+  const message = 'Unauthorized';
+  const cookieId = request.currentRoute.isAdmin ? getAdminTokenCookieId() : getTokenCookieId();
+  // Get the jwt token from the cookies
+  const token = request.cookies[cookieId];
+  // If there is no token, generate a new one for guest user
+  if (!token) {
+    // Issue a new token for guest user
+    const payload = { user: null, sid: uuidv4() };
+    const newToken = generateToken(payload);
+    // Set the new token in the cookies
+    response.cookie(cookieId, newToken, { maxAge: 172800000, httpOnly: true });
+    setContextValue(request, 'tokenPayload', payload);
+    // Continue to the next middleware
+    next();
+  } else {
+    // Get user from token
+    const tokenPayload = jwt.decode(token, { complete: true, json: true });
+    let secret;
+    // Get the secret from database
+    const check = await select()
+      .from('user_token_secret')
+      .where('user_id', '=', get(tokenPayload, 'payload.user.uuid', null))
+      .load(pool);
+
+    if (!check) { // This is guest user
+      secret = getTokenSecret();
+    } else {
+      secret = check.secret;
+    }
+
+    // Verify the token
+    jwt.verify(token, secret, (err, decoded) => {
+      if (err) {
+        response.json({
+          success: false,
+          message: message
+        });
+      } else {
+        setContextValue(request, 'tokenPayload', decoded);
+        next();
+      }
+    });
+  }
+};

package/src/modules/auth/components/AuthContext.js

@@ -0,0 +1,34 @@
+import PropTypes from 'prop-types'
+import React from 'react';
+import { createClient, Provider } from 'urql';
+import Area from '../../../lib/components/Area';
+import { useAppState } from '../../../lib/context/app';
+import { get } from '../../../lib/util/get';
+
+const AuthContext = React.createContext();
+
+export function AuthProvider() {
+  const context = useAppState();
+  const token = get(context, 'token');
+
+  const client = createClient({
+    url: '/v1/graphql'
+  });
+
+  return (
+    <AuthContext.Provider token={token}>
+      <Provider value={client}>
+        <Area id="body" />
+      </Provider>
+    </AuthContext.Provider>
+  );
+}
+
+AuthProvider.propTypes = {
+  children: PropTypes.oneOfType([
+    PropTypes.arrayOf(PropTypes.node),
+    PropTypes.node
+  ]).isRequired,
+};
+
+export const useToken = () => React.useContext(AuthContext);

package/src/modules/auth/graphql/types/AdminUser/AdminUser.graphql

@@ -0,0 +1,19 @@
+type AdminUser {
+  adminUserId: Int!
+  uuid: String!
+  status: Int!
+  email: String!
+  fullName: String!
+}
+
+type AdminUserCollection {
+  items: [AdminUser]
+  currentPage: Int!
+  total: Int!
+  currentFilters: [Filter]
+}
+
+extend type Query {
+  adminUser(id: Int): AdminUser,
+  adminUsers(filters: [FilterInput]): AdminUserCollection
+}

package/src/modules/auth/graphql/types/AdminUser/AdminUser.resolvers.js

@@ -0,0 +1,91 @@
+const { select } = require("@evershop/mysql-query-builder");
+const { buildUrl } = require("../../../../../lib/router/buildUrl");
+const { camelCase } = require("../../../../../lib/util/camelCase");
+const { get } = require("../../../../../lib/util/get");
+
+module.exports = {
+  Query: {
+    adminUser: async (root, { id }, { pool, tokenPayload }) => {
+      if (!get(tokenPayload, "user.isAdmin", false)) {
+        return null;
+      }
+      const query = select()
+        .from('admin_user');
+      query.where('admin_user_id', '=', id);
+
+      const user = await query.load(pool);
+      return user ? camelCase(user) : null;
+    },
+    adminUsers: async (_, { filters = [] }, { pool, tokenPayload }) => {
+      // This field is for admin only
+      if (!get(tokenPayload, "user.isAdmin", false)) {
+        return [];
+      }
+      const query = select().from('admin_user');
+      const currentFilters = [];
+
+      // Attribute filters
+      filters.forEach((filter) => {
+        if (filter.key === 'full_name') {
+          query.andWhere('admin_user.`full_name`', 'LIKE', `%${filter.value}%`);
+          currentFilters.push({
+            key: 'full_name',
+            operation: '=',
+            value: filter.value
+          });
+        }
+        if (filter.key === 'status') {
+          query.andWhere('admin_user.`status`', '=', filter.value);
+          currentFilters.push({
+            key: 'status',
+            operation: '=',
+            value: filter.value
+          });
+        }
+      })
+
+      const sortBy = filters.find((f) => f.key === 'sortBy');
+      const sortOrder = filters.find((f) => f.key === 'sortOrder' && ['ASC', 'DESC'].includes(f.value)) || { value: 'ASC' };
+      if (sortBy && sortBy.value === 'full_name') {
+        query.orderBy('admin_user.`full_name`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else {
+        query.orderBy('admin_user.`admin_user_id`', "DESC");
+      };
+
+      if (sortOrder.key) {
+        currentFilters.push({
+          key: 'sortOrder',
+          operation: '=',
+          value: sortOrder.value
+        });
+      }
+      // Clone the main query for getting total right before doing the paging
+      const cloneQuery = query.clone();
+      cloneQuery.select('COUNT(admin_user.`admin_user_id`)', 'total');
+      // Paging
+      const page = filters.find((f) => f.key === 'page') || { value: 1 };
+      const limit = filters.find((f) => f.key === 'limit') || { value: 20 };// TODO: Get from config
+      currentFilters.push({
+        key: 'page',
+        operation: '=',
+        value: page.value
+      });
+      currentFilters.push({
+        key: 'limit',
+        operation: '=',
+        value: limit.value
+      });
+      query.limit((page.value - 1) * parseInt(limit.value), parseInt(limit.value));
+      return {
+        items: (await query.execute(pool)).map(row => camelCase(row)),
+        total: (await cloneQuery.load(pool))['total'],
+        currentFilters: currentFilters,
+      }
+    }
+  }
+}