ee-core 1.0.0

package/core/lib/loader/mixin/config.js

@@ -0,0 +1,138 @@
+'use strict';
+
+const debug = require('debug')('ee-core:config');
+const path = require('path');
+const extend = require('extend2');
+const assert = require('assert');
+const { Console } = require('console');
+
+module.exports = {
+
+  /**
+   * Load config/config.js
+   *
+   * Will merge config.default.js 和 config.${env}.js
+   *
+   * @function EggLoader#loadConfig
+   * @since 1.0.0
+   */
+  loadConfig() {
+    this.timing.start('Load Config');
+    this.configMeta = {};
+
+    const target = {};
+
+    // Load Application config first
+    const appConfig = this._preloadAppConfig();
+    //console.log('----------------------- appConfig:', appConfig);
+
+    //   plugin config.default
+    //     framework config.default
+    //       app config.default
+    //         plugin config.{env}
+    //           framework config.{env}
+    //             app config.{env}
+    for (const filename of this.getTypeFiles('config')) {
+      for (const unit of this.getLoadUnits()) {
+        const isApp = unit.type === 'app';
+        const config = this._loadConfig(unit.path, filename, isApp ? undefined : appConfig, unit.type);
+
+        if (!config) {
+          continue;
+        }
+
+        debug('Loaded config %s, %s, %j', unit.path, filename, config);
+        extend(true, target, config);
+      }
+    }
+
+    // load env from process.env.EE_APP_CONFIG
+    const envConfig = this._loadConfigFromEnv();
+    debug('Loaded config from private env, %j', envConfig);
+    extend(true, target, envConfig);
+
+    // You can manipulate the order of app.config.coreMiddleware and app.config.appMiddleware in app.js
+    target.coreMiddleware = target.coreMiddlewares = target.coreMiddleware || [];
+    target.appMiddleware = target.appMiddlewares = target.middleware || [];
+
+    this.config = target;
+    this.timing.end('Load Config');
+  },
+
+  _preloadAppConfig() {
+    const names = [
+      'config.default',
+      `config.${this.serverEnv}`,
+    ];
+    const target = {};
+    for (const filename of names) {
+      const config = this._loadConfig(this.options.baseDir, filename, undefined, 'app');
+      extend(true, target, config);
+    }
+    return target;
+  },
+
+  _loadConfig(dirpath, filename, extraInject, type) {
+    const isPlugin = type === 'plugin';
+    const isApp = type === 'app';
+
+    let filepath = this.resolveModule(path.join(dirpath, 'config', filename));
+
+    //console.log("_loadConfig filepath:", filepath);
+
+    // let config.js compatible
+    if (filename === 'config.default' && !filepath) {
+      filepath = this.resolveModule(path.join(dirpath, 'config/config'));
+    }
+  
+    const config = this.loadFile(filepath, this.appInfo, extraInject);
+
+    if (!config) return null;
+
+    if (isPlugin || isApp) {
+      assert(!config.coreMiddleware, 'Can not define coreMiddleware in app or plugin');
+    }
+    if (!isApp) {
+      assert(!config.middleware, 'Can not define middleware in ' + filepath);
+    }
+
+    // store config meta, check where is the property of config come from.
+    this._setConfigMeta(config, filepath);
+
+    return config;
+  },
+
+  _loadConfigFromEnv() {
+    const envConfigStr = process.env.EE_APP_CONFIG;
+    if (!envConfigStr) return;
+    try {
+      const envConfig = JSON.parse(envConfigStr);
+      this._setConfigMeta(envConfig, '<process.env.EE_APP_CONFIG>');
+      return envConfig;
+    } catch (err) {
+      this.options.logger.warn('[egg-loader] process.env.EE_APP_CONFIG is not invalid JSON: %s', envConfigStr);
+    }
+  },
+
+  _setConfigMeta(config, filepath) {
+    config = extend(true, {}, config);
+    setConfig(config, filepath);
+    extend(true, this.configMeta, config);
+  },
+};
+
+function setConfig(obj, filepath) {
+  for (const key of Object.keys(obj)) {
+    const val = obj[key];
+    // ignore console
+    if (key === 'console' && val && typeof val.Console === 'function' && val.Console === Console) {
+      obj[key] = filepath;
+      continue;
+    }
+    if (val && Object.getPrototypeOf(val) === Object.prototype && Object.keys(val).length > 0) {
+      setConfig(val, filepath);
+      continue;
+    }
+    obj[key] = filepath;
+  }
+}

package/core/lib/loader/mixin/controller.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const path = require('path');
+const is = require('is-type-of');
+const utility = require('utility');
+const utils = require('../../utils');
+const FULLPATH = require('../file_loader').FULLPATH;
+
+
+module.exports = {
+
+  /**
+   * Load app/controller
+   * @param {Object} opt - LoaderOptions
+   * @since 1.0.0
+   */
+  loadController(opt) {
+    this.timing.start('Load Controller');
+    opt = Object.assign({
+      caseStyle: 'lower',
+      directory: path.join(this.options.baseDir, 'controller'),
+      initializer: (obj, opt) => {
+        // return class if it exports a function
+        // ```js
+        // module.exports = app => {
+        //   return class HomeController extends app.Controller {};
+        // }
+        // ```
+        if (is.function(obj) && !is.generatorFunction(obj) && !is.class(obj) && !is.asyncFunction(obj)) {
+          obj = obj(this.app);
+        }
+        if (is.class(obj)) {
+          obj.prototype.pathName = opt.pathName;
+          obj.prototype.fullPath = opt.path;
+          return wrapClass(obj);
+        }
+        if (is.object(obj)) {
+          return wrapObject(obj, opt.path);
+        }
+        // support generatorFunction for forward compatbility
+        if (is.generatorFunction(obj) || is.asyncFunction(obj)) {
+          return wrapObject({ 'module.exports': obj }, opt.path)['module.exports'];
+        }
+        return obj;
+      },
+    }, opt);
+    const controllerBase = opt.directory;
+
+    this.loadToApp(controllerBase, 'controller', opt);
+    this.options.logger.info('[egg:loader] Controller loaded: %s', controllerBase);
+    this.timing.end('Load Controller');
+  },
+
+};
+
+// wrap the class, yield a object with middlewares
+function wrapClass(Controller) {
+  let proto = Controller.prototype;
+  const ret = {};
+  // tracing the prototype chain
+  while (proto !== Object.prototype) {
+    const keys = Object.getOwnPropertyNames(proto);
+    for (const key of keys) {
+      // getOwnPropertyNames will return constructor
+      // that should be ignored
+      if (key === 'constructor') {
+        continue;
+      }
+      // skip getter, setter & non-function properties
+      const d = Object.getOwnPropertyDescriptor(proto, key);
+      // prevent to override sub method
+      if (is.function(d.value) && !ret.hasOwnProperty(key)) {
+        ret[key] = methodToMiddleware(Controller, key);
+        ret[key][FULLPATH] = Controller.prototype.fullPath + '#' + Controller.name + '.' + key + '()';
+      }
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+  return ret;
+
+  function methodToMiddleware(Controller, key) {
+    return function classControllerMiddleware(...args) {
+      const controller = new Controller(this);
+      // if (!this.app.config.controller || !this.app.config.controller.supportParams) {
+      //   args = [ this ];
+      // }
+      //args = [ this ];
+      return utils.callFn(controller[key], args, controller);
+    };
+  }
+}
+
+// wrap the method of the object, method can receive ctx as it's first argument
+function wrapObject(obj, path, prefix) {
+  const keys = Object.keys(obj);
+  const ret = {};
+  for (const key of keys) {
+    if (is.function(obj[key])) {
+      const names = utility.getParamNames(obj[key]);
+      if (names[0] === 'next') {
+        throw new Error(`controller \`${prefix || ''}${key}\` should not use next as argument from file ${path}`);
+      }
+      ret[key] = functionToMiddleware(obj[key]);
+      ret[key][FULLPATH] = `${path}#${prefix || ''}${key}()`;
+    } else if (is.object(obj[key])) {
+      ret[key] = wrapObject(obj[key], path, `${prefix || ''}${key}.`);
+    }
+  }
+  return ret;
+
+  function functionToMiddleware(func) {
+    const objectControllerMiddleware = async function(...args) {
+      // if (!this.app.config.controller || !this.app.config.controller.supportParams) {
+      //   args = [ this ];
+      // }
+      return await utils.callFn(func, args, this);
+    };
+    for (const key in func) {
+      objectControllerMiddleware[key] = func[key];
+    }
+    return objectControllerMiddleware;
+  }
+}

package/core/lib/loader/mixin/service.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const path = require('path');
+
+
+module.exports = {
+
+  /**
+   * Load app/service
+   * @function EeLoader#loadService
+   * @param {Object} opt - LoaderOptions
+   * @since 1.0.0
+   */
+  loadService(opt) {
+    this.timing.start('Load Service');
+    // 载入到 app.serviceClasses
+    opt = Object.assign({
+      call: true,
+      caseStyle: 'lower',
+      fieldClass: 'serviceClasses',
+      directory: this.getLoadUnits().map(unit => path.join(unit.path, 'service')), // this.getLoadUnits().map(unit => path.join(unit.path, 'app/service'))
+    }, opt);
+
+    const servicePaths = opt.directory;
+    this.loadToContext(servicePaths, 'service', opt);
+    this.timing.end('Load Service');
+  },
+
+};

package/core/lib/utils/base_context_class.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * BaseContextClass is a base class that can be extended,
+ * it's instantiated in context level,
+ * {@link Helper}, {@link Service} is extending it.
+ */
+class BaseContextClass {
+
+  /**
+   * @class
+   * @param {Context} ctx - context instance
+   * @since 1.0.0
+   */
+  constructor(ctx) {
+    /**
+     * @member {Application} BaseContextClass#app
+     * @since 1.0.0
+     */
+    this.app = ctx;
+    /**
+     * @member {Config} BaseContextClass#config
+     * @since 1.0.0
+     */
+    this.config = ctx.config;
+    /**
+     * @member {Service} BaseContextClass#service
+     * @since 1.0.0
+     */
+    this.service = ctx.service;
+  }
+}
+
+module.exports = BaseContextClass;

package/core/lib/utils/index.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const convert = require('koa-convert');
+const is = require('is-type-of');
+const path = require('path');
+const fs = require('fs');
+const co = require('co');
+const BuiltinModule = require('module');
+
+// Guard against poorly mocked module constructors.
+const Module = module.constructor.length > 1
+  ? module.constructor
+  /* istanbul ignore next */
+  : BuiltinModule;
+
+module.exports = {
+  extensions: Module._extensions,
+
+  loadFile(filepath) {
+    try {
+      // if not js module, just return content buffer
+      const extname = path.extname(filepath);
+      if (extname && !Module._extensions[extname]) {
+        return fs.readFileSync(filepath);
+      }
+      // require js module
+      const obj = require(filepath);
+      if (!obj) return obj;
+      // it's es module
+      if (obj.__esModule) return 'default' in obj ? obj.default : obj;
+      return obj;
+    } catch (err) {
+      err.message = `[egg-core] load file: ${filepath}, error: ${err.message}`;
+      throw err;
+    }
+  },
+
+  methods: [ 'head', 'options', 'get', 'put', 'patch', 'post', 'delete' ],
+
+  async callFn(fn, args, ctx) {
+    args = args || [];
+    if (!is.function(fn)) return;
+    if (is.generatorFunction(fn)) fn = co.wrap(fn);
+    return ctx ? fn.call(ctx, ...args) : fn(...args);
+  },
+
+  middleware(fn) {
+    return is.generatorFunction(fn) ? convert(fn) : fn;
+  },
+
+  getCalleeFromStack(withLine, stackIndex) {
+    stackIndex = stackIndex === undefined ? 2 : stackIndex;
+    const limit = Error.stackTraceLimit;
+    const prep = Error.prepareStackTrace;
+
+    Error.prepareStackTrace = prepareObjectStackTrace;
+    Error.stackTraceLimit = 5;
+
+    // capture the stack
+    const obj = {};
+    Error.captureStackTrace(obj);
+    let callSite = obj.stack[stackIndex];
+    let fileName;
+    /* istanbul ignore else */
+    if (callSite) {
+      // egg-mock will create a proxy
+      // https://github.com/eggjs/egg-mock/blob/master/lib/app.js#L174
+      fileName = callSite.getFileName();
+      /* istanbul ignore if */
+      if (fileName && fileName.endsWith('egg-mock/lib/app.js')) {
+        // TODO: add test
+        callSite = obj.stack[stackIndex + 1];
+        fileName = callSite.getFileName();
+      }
+    }
+
+    Error.prepareStackTrace = prep;
+    Error.stackTraceLimit = limit;
+
+    /* istanbul ignore if */
+    if (!callSite || !fileName) return '<anonymous>';
+    if (!withLine) return fileName;
+    return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
+  },
+
+  getResolvedFilename(filepath, baseDir) {
+    const reg = /[/\\]/g;
+    return filepath.replace(baseDir + path.sep, '').replace(reg, '/');
+  },
+};
+
+
+/**
+ * Capture call site stack from v8.
+ * https://github.com/v8/v8/wiki/Stack-Trace-API
+ */
+
+function prepareObjectStackTrace(obj, stack) {
+  return stack;
+}

package/core/lib/utils/sequencify.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const debug = require('debug')('egg-core#sequencify');
+
+function sequence(tasks, names, results, missing, recursive, nest, optional, parent) {
+  names.forEach(function(name) {
+    if (results.requires[name]) return;
+
+    const node = tasks[name];
+
+    if (!node) {
+      if (optional === true) return;
+      missing.push(name);
+    } else if (nest.includes(name)) {
+      nest.push(name);
+      recursive.push(nest.slice(0));
+      nest.pop(name);
+    } else if (node.dependencies.length || node.optionalDependencies.length) {
+      nest.push(name);
+      if (node.dependencies.length) {
+        sequence(tasks, node.dependencies, results, missing, recursive, nest, optional, name);
+      }
+      if (node.optionalDependencies.length) {
+        sequence(tasks, node.optionalDependencies, results, missing, recursive, nest, true, name);
+      }
+      nest.pop(name);
+    }
+    if (!optional) {
+      results.requires[name] = true;
+      debug('task: %s is enabled by %s', name, parent);
+    }
+    if (!results.sequence.includes(name)) {
+      results.sequence.push(name);
+    }
+  });
+}
+
+// tasks: object with keys as task names
+// names: array of task names
+module.exports = function(tasks, names) {
+  const results = {
+    sequence: [],
+    requires: {},
+  }; // the final sequence
+  const missing = []; // missing tasks
+  const recursive = []; // recursive task dependencies
+
+  sequence(tasks, names, results, missing, recursive, [], false, 'app');
+
+  if (missing.length || recursive.length) {
+    results.sequence = []; // results are incomplete at best, completely wrong at worst, remove them to avoid confusion
+  }
+
+  return {
+    sequence: results.sequence.filter(item => results.requires[item]),
+    missingTasks: missing,
+    recursiveDependencies: recursive,
+  };
+};

package/core/lib/utils/timing.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const assert = require('assert');
+const MAP = Symbol('Timing#map');
+const LIST = Symbol('Timing#list');
+
+
+class Timing {
+
+  constructor() {
+    this._enable = true;
+    this[MAP] = new Map();
+    this[LIST] = [];
+
+    this.init();
+  }
+
+  init() {
+    // process start time
+    this.start('Process Start', Date.now() - Math.floor((process.uptime() * 1000)));
+    this.end('Process Start');
+
+    if (typeof process.scriptStartTime === 'number') {
+      // js script start execute time
+      this.start('Script Start', process.scriptStartTime);
+      this.end('Script Start');
+    }
+  }
+
+  start(name, start) {
+    if (!name || !this._enable) return;
+
+    if (this[MAP].has(name)) this.end(name);
+
+    start = start || Date.now();
+    const item = {
+      name,
+      start,
+      end: undefined,
+      duration: undefined,
+      pid: process.pid,
+      index: this[LIST].length,
+    };
+    this[MAP].set(name, item);
+    this[LIST].push(item);
+    return item;
+  }
+
+  end(name) {
+    if (!name || !this._enable) return;
+    assert(this[MAP].has(name), `should run timing.start('${name}') first`);
+
+    const item = this[MAP].get(name);
+    item.end = Date.now();
+    item.duration = item.end - item.start;
+    return item;
+  }
+
+  enable() {
+    this._enable = true;
+  }
+
+  disable() {
+    this._enable = false;
+  }
+
+  clear() {
+    this[MAP].clear();
+    this[LIST] = [];
+  }
+
+  toJSON() {
+    return this[LIST];
+  }
+}
+
+module.exports = Timing;

package/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * @namespace EeCore
+ */
+
+/**
+ * @member {Appliaction} EeCore#Appliaction
+ * @since 1.0.0
+ */
+const Appliaction = require('./lib/application');
+
+/**
+ * @member {Controller} EeCore#Controller
+ * @since 1.0.0
+ */
+const Controller = require('./core/lib/utils/base_context_class');
+
+/**
+ * @member {Service} EeCore#Service
+ * @since 1.0.0
+ */
+const Service = require('./core/lib/utils/base_context_class');
+
+/**
+ * @member {Storage}
+ * @since 1.0.0
+ */
+const Storage = require('./lib/storage/index');
+
+/**
+ * @member {Utils}
+ * @since 1.0.0
+ */
+const Utils = require('./utils/index');
+
+/**
+ * @member {Socket}
+ * @since 1.0.0
+ */
+const Socket = require('./lib/socket/io');
+
+module.exports = {
+  Appliaction,
+  Controller,
+  Service,
+  Storage,
+  Socket,
+  Utils
+};

package/lib/appLoader.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const EeLoader = require('../core/index').EeLoader;
+
+/**
+ * App Loader
+ * @see 
+ */
+class AppLoader extends EeLoader {
+
+  /**
+   * loadPlugin first, then loadConfig
+   * @since 1.0.0
+   */
+  loadConfig() {
+    super.loadConfig();
+  }
+
+  /**
+   * Load all directories in convention
+   * @since 1.0.0
+   */
+  load() {
+
+    // app > plugin
+    this.loadService();
+
+    // app
+    this.loadController();
+    
+  }
+
+  /**
+   * load electron modules
+   * @since 1.0.0
+   */
+  loadElectron() {
+
+    // 预加载功能模块
+    //this.loadPreload();
+    
+  }
+}
+
+module.exports = AppLoader;