feat: init project

Author: bencode

.eslintrc

@@ -0,0 +1,6 @@
+{
+  extends: 'eslint-config-bce',
+  rules: {
+    class-methods-use-this: 0
+  }
+}

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+yarn.lock

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 大鱼
+Copyright (c) 2020 [email protected]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

lib/components/core/errorHandler.js

@@ -0,0 +1,33 @@
+/**
+ * 错误处理中间件
+ */
+
+const util = require('util');
+
+module.exports = function createErrorHandler(config) {
+  const development = (config || {}).env === 'development';
+  return function errorHandler(ctx, next) {
+    return next().catch(e => {
+      const status = e.status || 500;
+      // 只处理500及以上的异常
+      if (status < 500) {
+        throw e;
+      }
+
+      global.console.error(e);
+      ctx.app.emit('error', e, ctx);
+      ctx.status = status;
+
+      const message = development ?
+        '<pre>' + util.inspect(e) + '\n' + (e.stack || '') + '</pre>' :
+        'Internel Server Error';
+
+      if (ctx.is('application/json') ||
+          !ctx.accepts('html') && ctx.accepts('application/json')) {
+        ctx.body = { success: false, message };
+      } else {
+        ctx.body = message;
+      }
+    });
+  };
+};

lib/components/core/index.js

@@ -0,0 +1,65 @@
+const assert = require('assert');
+const { sortBy } = require('ramda');
+const debug = require('debug')('avada:core');
+const createErrorHandler = require('./errorHandler');
+
+
+module.exports = function CoreComponent(app, settings) {
+  setupConfig(app, settings);
+
+  const starter = hookUse(app);
+
+  const errorHandler = createErrorHandler(app);
+  app.use(errorHandler, { level: 3 });
+
+  return starter;
+};
+
+
+function setupConfig(app, settings) {
+  const appConfig = {
+    env: settings.env,
+    ...settings.app
+  };
+
+  const props = {
+    get() {
+      return appConfig;
+    }
+  };
+
+  Object.defineProperty(app, 'config', props);
+  Object.defineProperty(app.context, 'config', props);
+}
+
+
+function hookUse(app) {
+  const list = [];
+
+  const use = app.use;
+  app.use = (middleware, options) => {
+    assert(
+      typeof middleware === 'function',
+      'middleware should be typeof function'
+    );
+
+    options = { level: 3, ...options };
+    list.push({ middleware, options });
+  };
+
+  return () => {
+    const sorted = sortBy(item => item.options.level, list);
+    const oriUse = fn => use.call(app, fn);
+    useMiddlewares(oriUse, sorted);
+  };
+}
+
+
+function useMiddlewares(use, list) {
+  for (const item of list) {
+    const mw = item.middleware;
+    const opts = item.options;
+    debug('use %s, %o', mw.$name || mw.name, opts);
+    use(mw);
+  }
+}

lib/components/navigator/Controller.js

@@ -0,0 +1,27 @@
+const debug = require('debug')('avada:navigator/Controller');
+
+module.exports = function Controller() {
+  const map = new Map();
+
+  const add = (name, controller) => {
+    if (map.has(name)) {
+      global.console.error(`controller already exists: ${name}`);
+      return;
+    }
+    debug('add controller: %s', name);
+    map.set(name, controller);
+  };
+
+  const has = (module, action) => {
+    const controller = map.get(module);
+    return controller && typeof controller[action] === 'function';
+  };
+
+  const invoke = (module, action, ctx) => {
+    const controller = map.get(module);
+    debug('invoke %s[%s]', module, action);
+    return controller[action](ctx);
+  };
+
+  return { add, has, invoke };
+};

lib/components/navigator/index.js

@@ -0,0 +1,55 @@
+const fs = require('fs');
+const pathUtil = require('path');
+const loadModule = require('../../utils/loadModule');
+const Controller = require('./Controller');
+
+
+module.exports = function NavigatorComponent(app, settings) {
+  const appRoot = settings.applicationRoot;
+  const config = settings.navigator || {};
+  const controllerRoot = config.controllerRoot || pathUtil.join(appRoot, 'controllers');
+
+  const controller = new Controller();
+  app.controller = controller.add.bind(controller);
+
+  setupControllers(controller, { controllerRoot });
+
+  const navigator = createNavigator({ controller });
+  app.use(navigator, { level: 4 });
+};
+
+
+function setupControllers(controller, { controllerRoot }) {
+  const list = fs.readdirSync(controllerRoot);
+  for (const name of list) {
+    const path = pathUtil.join(controllerRoot, name);
+    const mod = loadModule(path);
+    if (mod) {
+      controller.add(name, mod);
+    }
+  }
+}
+
+
+function createNavigator({ controller }) {
+  return function Navigator(ctx, next) {
+    const { route } = ctx;
+    if (!route) {
+      return next();
+    }
+
+    if (!controller.has(route.module, route.action)) {
+      global.console.error(`action not found: ${route.module}[${route.action}]`);
+      return next();
+    }
+
+    const query = {
+      ...route.query,
+      ...ctx.query
+    };
+    ctx.originalQuery = ctx.query;
+    ctx.query = query;
+
+    return controller.invoke(route.module, route.action, ctx);
+  };
+}

lib/components/router/Router.js

@@ -0,0 +1,101 @@
+const debug = require('debug')('avada:Router');
+const pathToRegexp = require('../../utils/pathToRegexp');
+
+
+const rNum = /^\d+$/;
+
+module.exports = function Router() {
+  const routes = [];
+
+  /**
+   * 添加路由规则
+   *
+   * @param {String|RegExp} pattern - 用于url匹配的规则
+   *  目前路由匹配是使用`path-to-regexp`这个库来实现的
+   *  它可以很方便地将路径样式的字符串转换成正则表达式
+   *
+   * @param {String|Object} rule     - 定位的规则
+   * @param {Object} options         - 额外的选项
+   *  - method {String|Array} 只允许指定method
+   */
+  const add = (pattern, rule, options = {}) => {
+    const keys = [];
+    const regexp = pathToRegexp(pattern, keys);
+    const queries = keys.map((key, index) => {
+      const name = key.name;
+      return rNum.test(name) ? null : { index: index + 1, name };
+    }).filter(v => v);
+
+    rule = typeof rule === 'string' ? parseRule(rule) : rule;
+    const item = { regexp, queries, rule, options };
+    debug('add %o', item);
+    routes.push(item);
+  };
+
+  /**
+   * 将path路由成RouteInfo
+   *
+   * @param {String}  path    - 路径
+   * @param {Object}  request - 选项
+   *  - method 当前请求method
+   *
+   * @return {Object|null} - 路由信息
+   *  - module  {String}
+   *  - action  {String}
+   *  - query   {Object}
+   */
+  const route = (path, request) => {
+    if (routes.length === 0) {
+      return null;
+    }
+    for (const item of routes) {
+      // 对规则进行一次正则匹配，成功后将不对后续的路由进行匹配
+      if (verifyRequest(item, request)) {
+        const match = item.regexp.exec(path);
+        if (match) {
+          const result = createRouteInfo(item, match);
+          debug('route success: %o', result);
+          return result;
+        }
+      }
+    }
+    return null;
+  };
+
+  return { add, route };
+};
+
+/*
+ * 测试是否允许访问
+ * - method是否匹配
+ */
+function verifyRequest(item, request) {
+  const method = item.options.method;
+  if (!method || !request) {
+    return true;
+  }
+
+  const current = request.method.toLowerCase();
+  if (typeof method === 'string') {
+    return current === method;
+  }
+
+  // for Array
+  return method.indexOf(current) !== -1;
+}
+
+function parseRule(rule) {
+  const parts = rule.split('#');
+  return { module: parts[0], action: parts[1] };
+}
+
+function createRouteInfo(item, match) {
+  const { rule, queries } = item;
+  const paramQuery = queries.reduce((acc, { name, index }) => {
+    acc[name] = match[index];
+    return acc;
+  }, {});
+
+  const query = rule.query ? { ...paramQuery, ...rule.query } : paramQuery;
+  return { module: rule.module, action: rule.action, query };
+}