ee-core 2.12.0 → 4.0.0

package/controller/controller_loader.d.ts

@@ -0,0 +1,9 @@
+import { Timing } from "../core/utils/timing";
+export declare class ControllerLoader {
+    timing: Timing;
+    /**
+     * Load controller/xxx.js
+     */
+    load(): any;
+}
+

package/controller/controller_loader.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const debug = require('debug')('ee-core:controller:controller_loader');
+const path = require('path');
+const is = require('is-type-of');
+const { getElectronDir } = require('../ps');
+const { Timing } = require('../core/utils/timing');
+const { FileLoader, FULLPATH } = require('../core/loader/file_loader');
+const { isBytecodeClass, callFn } = require('../core/utils');
+
+class ControllerLoader {
+  constructor() {
+    this.timing = new Timing();
+  }
+
+  /**
+   * Load controller/xxx.js
+   */
+  load() {
+    this.timing.start('Load Controller');
+
+    const opt = {
+      caseStyle: 'lower',
+      directory: path.join(getElectronDir(), 'controller'),
+      initializer: (obj, opt) => {
+        if (is.class(obj) || isBytecodeClass(obj)) {
+          obj.prototype.pathName = opt.pathName;
+          obj.prototype.fullPath = opt.path;
+          return wrapClass(obj);
+        }
+        return obj;
+      },
+    };
+    const target = new FileLoader(opt).load();
+    debug("[load] controllers: %o", target);
+    this.timing.end('Load Controller');
+    return target;
+  }
+}
+
+// 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);
+    // debug("[wrapClass] keys:", keys);
+    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();
+    return callFn(controller[key], args, controller);
+  };
+}
+
+module.exports = {
+  ControllerLoader
+};

package/controller/index.d.ts

@@ -0,0 +1,2 @@
+export declare function loadController(): void;
+export declare function getController(): any;

package/controller/index.js

@@ -1,25 +1,24 @@
-'use strict';
+'use strict'
 
-/**
- * BaseContextClass is a base class that can be extended,
- * it's instantiated in context level,
- */
-class BaseContextClass {
+const { ControllerLoader } = require('./controller_loader');
 
-  /**
-   * @class
-   * @param {Context} ctx - context instance
-   * @since 1.1.0
-   */
-  constructor(ctx) {
+const Instance = {
+  controller: null,
+};
 
-    // todo 兼容旧版本，后续废弃ctx
-    if (typeof ctx === 'object') {
-      this.app = ctx;
-      this.config = ctx.config;
-      this.service = ctx.service;
-    }
+function loadController() {
+  const controllerLoader = new ControllerLoader();
+  Instance.controller = controllerLoader.load();
+}
+
+function getController() {
+  if (!Instance.controller) {
+    loadController();
   }
+  return Instance.controller;
 }
 
-module.exports = BaseContextClass;
+module.exports = {
+  loadController,
+  getController
+};

package/core/index.d.ts

@@ -0,0 +1,2 @@
+import utils = require("./utils");
+export { EeLoader, BaseContextClass, utils };

package/core/index.js

@@ -1,10 +1,11 @@
-const EeCore = require('./lib/ee');
-const EeLoader = require('./lib/loader/ee_loader');
-const BaseContextClass = require('./lib/utils/base_context_class');
-const utils = require('./lib/utils');
+'use strict';
+
+const EeLoader = require('./loader/ee_loader');
+const BaseContextClass = require('./utils/base_context_class');
+const utils = require('./utils');
+
 
 module.exports = {
-  EeCore,
   EeLoader,
   BaseContextClass,
   utils,

package/core/loader/file_loader.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Load files from directory to target object.
+ */
+export declare class FileLoader {
+    /**
+     * @class
+     * @param {Object} options - options
+     * @param {String|Array} options.directory - directories to be loaded
+     * @param {Object} options.target - attach the target object from loaded files
+     * @param {String} options.match - match the files when load, support glob, default to all js files
+     * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+     * @param {Boolean} options.call - determine whether invoke when exports is function
+     * @param {Object} options.inject - an object that be the argument when invoke the function
+     * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+     */
+    constructor(options: {
+        directory: string | any[];
+        target: any;
+        match: string;
+        initializer: Function;
+        call: boolean;
+        inject: any;
+        caseStyle: string | Function;
+    });
+    options: {
+        directory: any;
+        target: any;
+        match: any;
+        caseStyle: string;
+        initializer: any;
+        call: boolean;
+        inject: any;
+    } & {
+        directory: string | any[];
+        target: any;
+        match: string;
+        initializer: Function;
+        call: boolean;
+        inject: any;
+        caseStyle: string | Function;
+    };
+    /**
+     * attach items to target object. Mapping the directory to properties.
+     * `xxx/group/repository.js` => `target.group.repository`
+     * @return {Object} target
+     */
+    load(): any;
+    /**
+     * Parse files from given directories, then return an items list, each item contains properties and exports.
+     * For example, parse `controller/group/repository.js`
+     * It returns a item
+     * ```
+     * {
+     *   fullpath: '',
+     *   properties: [ 'group', 'repository' ],
+     *   exports: { ... },
+     * }
+     * ```
+     * `Properties` is an array that contains the directory of a filepath.
+     * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+     * @return {Array} items
+     */
+    parse(): any[];
+}
+export declare const EXPORTS: unique symbol;
+export declare const FULLPATH: unique symbol;

package/core/{lib/loader → loader}/file_loader.js

@@ -1,35 +1,27 @@
 'use strict';
 
+const debug = require('debug')('ee-core:core:loader:file_loader');
 const assert = require('assert');
 const fs = require('fs');
-const debug = require('debug')('ee-core:fileLoader');
 const path = require('path');
 const globby = require('globby');
 const is = require('is-type-of');
-const deprecate = require('../../../utils/depd')('ee');
-const Utils = require('../utils');
-const FULLPATH = Symbol('EE_LOADER_ITEM_FULLPATH');
-const EXPORTS = Symbol('EE_LOADER_ITEM_EXPORTS');
-//const Addon = require('../../../addon');
+const { isBytecodeClass, loadFile, filePatterns } = require('../utils');
+const FULLPATH = Symbol('LOADER_ITEM_FULLPATH');
+const EXPORTS = Symbol('LOADER_ITEM_EXPORTS');
 
 const defaults = {
   directory: null,
   target: null,
   match: undefined,
-  ignore: undefined,
-  lowercaseFirst: false,
   caseStyle: 'camel',
   initializer: null,
   call: true,
-  override: false,
   inject: undefined,
-  filter: null,
-  loader: undefined,
 };
 
 /**
  * Load files from directory to target object.
- * @since 1.0.0
  */
 class FileLoader {
 
@@ -39,46 +31,31 @@ class FileLoader {
    * @param {String|Array} options.directory - directories to be loaded
    * @param {Object} options.target - attach the target object from loaded files
    * @param {String} options.match - match the files when load, support glob, default to all js files
-   * @param {String} options.ignore - ignore the files when load, support glob
    * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
    * @param {Boolean} options.call - determine whether invoke when exports is function
-   * @param {Boolean} options.override - determine whether override the property when get the same name
    * @param {Object} options.inject - an object that be the argument when invoke the function
-   * @param {Function} options.filter - a function that filter the exports which can be loaded
    * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
-   * @param {Object} options.loader - an object that be the argument when invoke the function
    */
   constructor(options) {
     assert(options.directory, 'options.directory is required');
-    assert(options.target, 'options.target is required');
     this.options = Object.assign({}, defaults, options);
-
-    // compatible old options _lowercaseFirst_
-    if (this.options.lowercaseFirst === true) {
-      deprecate('lowercaseFirst is deprecated, use caseStyle instead');
-      this.options.caseStyle = 'lower';
-    }
+    debug("[constructor] options: %o", this.options);
   }
 
   /**
    * attach items to target object. Mapping the directory to properties.
-   * `app/controller/group/repository.js` => `target.group.repository`
+   * `xxx/group/repository.js` => `target.group.repository`
    * @return {Object} target
-   * @since 1.0.0
    */
   load() {
     const items = this.parse();
-    const target = this.options.target;
+    const target = {};
     for (const item of items) {
-      // item { properties: [ 'a', 'b', 'c'], exports }
-      // => target.a.b.c = exports
+      // item { fullpath, properties: [ 'a', 'b', 'c'], exports }
       item.properties.reduce((target, property, index) => {
         let obj;
-        const properties = item.properties.slice(0, index + 1).join('.');
+        // properties is a path slice, only the last value is the file name
         if (index === item.properties.length - 1) {
-          if (property in target) {
-            if (!this.options.override) throw new Error(`can't overwrite property '${properties}' from ${target[property][FULLPATH]} by ${item.fullpath}`);
-          }
           obj = item.exports;
           if (obj && !is.primitive(obj)) {
             obj[FULLPATH] = item.fullpath;
@@ -89,166 +66,78 @@ class FileLoader {
         }
         
         target[property] = obj;
-        debug('loaded %s', properties);
+        // const properties = item.properties.slice(0, index + 1).join('.');
+        // debug('[load] properties: %s', properties);
         return obj;
       }, target);
     }
-
+    //debug('[load] target: %O', target);
     return target;
   }
 
   /**
    * Parse files from given directories, then return an items list, each item contains properties and exports.
-   *
-   * For example, parse `app/controller/group/repository.js`
-   *
-   * ```
-   * module.exports = app => {
-   *   return class RepositoryController extends app.Controller {};
-   * }
-   * ```
-   *
+   * For example, parse `controller/group/repository.js`
    * It returns a item
-   *
    * ```
    * {
+   *   fullpath: '',
    *   properties: [ 'group', 'repository' ],
-   *   exports: app => { ... },
+   *   exports: { ... },
    * }
    * ```
-   *
    * `Properties` is an array that contains the directory of a filepath.
-   *
    * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
    * @return {Array} items
-   * @since 1.0.0
    */
   parse() {
     let files = this.options.match;
     if (!files) {
-      files = (process.env.EE_TYPESCRIPT === 'true' && Utils.extensions['.ts'])
-        ? [ '**/*.(js|ts)', '!**/*.d.ts' ]
-        : [ '**/*.js', '**/*.jsc'];
+      files = filePatterns();
     } else {
       files = Array.isArray(files) ? files : [ files ];
     }
-    
-    let ignore = this.options.ignore;
-    if (ignore) {
-      ignore = Array.isArray(ignore) ? ignore : [ ignore ];
-      ignore = ignore.filter(f => !!f).map(f => '!' + f);
-      files = files.concat(ignore);
-    }
 
     let directories = this.options.directory;
     if (!Array.isArray(directories)) {
       directories = [ directories ];
     }
 
-    const filter = is.function(this.options.filter) ? this.options.filter : null;
     const items = [];
-    debug('parsing %j', directories);
-
+    debug('[parse] directories %o', directories);
+    
     for (const directory of directories) {
       const filepaths = globby.sync(files, { cwd: directory });
+      debug('[parse] filepaths %o', filepaths);
       for (const filepath of filepaths) {
         const fullpath = path.join(directory, filepath);
         if (!fs.statSync(fullpath).isFile()) continue;
         // get properties
-        // app/service/foo/bar.js => [ 'foo', 'bar' ]
+        // controller/foo/bar.js => [ 'foo', 'bar' ]
         const properties = getProperties(filepath, this.options);
-        // app/service/foo/bar.js => service.foo.bar
+        // debug('[parse] properties %o', properties);
+        // controller/foo/bar.js => controller.foo.bar
         const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
+        // debug('[parse] pathName %s', pathName);
         // get exports from the file
         let exports = getExports(fullpath, this.options, pathName);
         // ignore exports when it's null or false returned by filter function
-        if (exports == null || (filter && filter(exports) === false)) continue;
+        if (exports == null) continue;
 
         // set properties of class
-        if (is.class(exports) || Utils.isBytecodeClass(exports)) {
+        if (is.class(exports) || isBytecodeClass(exports)) {
           exports.prototype.pathName = pathName;
           exports.prototype.fullPath = fullpath;
         }
-
         items.push({ fullpath, properties, exports });
-        debug('parse %s, properties %j, export %O', fullpath, properties, exports);
+        //debug('[parse] fullpath %s, properties %o, export %o', fullpath, properties, exports);
       }
     }
-
+    //debug('[parse] items %O', items);
     return items;
   }
-
-  /**
-   * attach items to target object for addons.
-   * `app/addon/group/index.js` => `target.group`
-   * @return {Object} target
-   * @since 1.0.0
-   */
-  loadAddons() {
-    const items = [];
-    const files = '*';
-    const app = this.options.inject;
-    const loader = this.options.loader;
-    const target = this.options.target;
-    let directories = this.options.directory;
-    
-    if (!Array.isArray(directories)) {
-      directories = [ directories ];
-    }
-
-    // check addon 
-    const config = app.config.addons;
-    let filterAddons = [];
-    for (let key of Object.keys(config)) {
-      if (!config[key].enable) {
-        filterAddons.push(key);
-      }
-    }
-
-    for (const directory of directories) {
-      const addonpaths = globby.sync(files, { cwd: directory, deep: 1, onlyDirectories: true});
-      for (const addonName of addonpaths) {
-        if (filterAddons.includes(addonName)) continue;
-
-        const filepath = path.join(directory, addonName, 'index');
-        const fullpath = loader.resolveModule(filepath);
-        if (!fs.existsSync(fullpath)) {
-          throw new Error(`The ${filepath} file does not exist`);
-        }
-        if (!fs.statSync(fullpath).isFile()) continue;
-  
-        let exports = getExports(fullpath, this.options, addonName);
-        if (exports == null) continue;
-  
-        const properties = [addonName];
-        if (is.class(exports) || Utils.isBytecodeClass(exports)) {
-          exports.prototype.pathName = addonName;
-          exports.prototype.fullPath = fullpath;
-        }
-  
-        items.push({ fullpath, properties, exports });
-      }
-  
-      for (const item of items) {
-        const property = item.properties[0];
-        let obj = item.exports;
-        if (obj && !is.primitive(obj)) {
-          obj[FULLPATH] = item.fullpath;
-          obj[EXPORTS] = true;
-        }
-        
-        target[property] = obj;
-      }
-    }
-
-    return target;
-  }
 }
 
-module.exports = FileLoader;
-module.exports.EXPORTS = EXPORTS;
-module.exports.FULLPATH = FULLPATH;
-
 // convert file path to an array of properties
 // a/b/c.js => ['a', 'b', 'c']
 function getProperties(filepath, { caseStyle }) {
@@ -265,29 +154,18 @@ function getProperties(filepath, { caseStyle }) {
 // Get exports from filepath
 // If exports is null/undefined, it will be ignored
 function getExports(fullpath, { initializer, call, inject }, pathName) {
-  let exports = Utils.loadFile(fullpath);
-
-  // process exports as you like
+  let exports = loadFile(fullpath);
+  //debug('[getExports] exports %o', exports);
   if (initializer) {
+    // exports type is Class or Object
     exports = initializer(exports, { path: fullpath, pathName });
   }
 
-  // return exports when it's a class or generator
-  //
-  // module.exports = class Service {};
-  // or
-  // module.exports = function*() {}
-  //new exports;
-
-  if (is.class(exports) || is.generatorFunction(exports) || is.asyncFunction(exports) || Utils.isBytecodeClass(exports)) {
+  if (is.class(exports) || is.generatorFunction(exports) || is.asyncFunction(exports) || isBytecodeClass(exports)) {
     return exports;
   }
 
-  // return exports after call when it's a function
-  //
-  // module.exports = function(app) {
-  //   return {};
-  // }
+  // whether to execute the function
   if (call && is.function(exports)) {
     exports = exports(inject);
     if (exports != null) {
@@ -295,7 +173,6 @@ function getExports(fullpath, { initializer, call, inject }, pathName) {
     }
   }
 
-  // return exports what is
   return exports;
 }
 
@@ -311,7 +188,7 @@ function defaultCamelize(filepath, caseStyle) {
     // fooBar.js  > FooBar
     // FooBar.js  > FooBar
     // FooBar.js  > FooBar
-    // FooBar.js  > fooBar (if lowercaseFirst is true)
+    // FooBar.js  > fooBar
     property = property.replace(/[_-][a-z]/ig, s => s.substring(1).toUpperCase());
     let first = property[0];
     switch (caseStyle) {
@@ -327,3 +204,9 @@ function defaultCamelize(filepath, caseStyle) {
     return first + property.substring(1);
   });
 }
+
+module.exports = {
+  FileLoader,
+  EXPORTS,
+  FULLPATH,
+};

package/core/utils/index.d.ts

@@ -0,0 +1,12 @@
+export declare const extensions: any;
+export declare function loadFile(filepath: any): any;
+export declare function callFn(fn: any, args: any, ctx: any): Promise<any>;
+export declare function getResolvedFilename(filepath: any, baseDir: any): any;
+/**
+ * 字节码类
+ */
+export declare function isBytecodeClass(exports: any): boolean;
+/**
+ * 文件类型
+ */
+export declare function filePatterns(): string[];

package/core/utils/index.js

@@ -0,0 +1,83 @@
+'use strict';
+
+require('bytenode');
+const is = require('is-type-of');
+const path = require('path');
+const fs = require('fs');
+const BuiltinModule = require('module');
+
+// Guard against poorly mocked module constructors.
+const Module = module.constructor.length > 1
+  ? module.constructor
+  /* istanbul ignore next */
+  : BuiltinModule;
+
+// Module._extensions:
+// '.js': [Function (anonymous)],
+// '.json': [Function (anonymous)],
+// '.node': [Function: func],
+// '.jsc': [Function (anonymous)]
+
+const extensions = Module._extensions;
+
+function 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 = `[ee-core] load file: ${filepath}, error: ${err.message}`;
+    throw err;
+  }
+}
+
+async function callFn(fn, args, ctx) {
+  args = args || [];
+  if (!is.function(fn)) return;
+  return ctx ? fn.call(ctx, ...args) : fn(...args);
+}
+
+function getResolvedFilename(filepath, baseDir) {
+  const reg = /[/\\]/g;
+  return filepath.replace(baseDir + path.sep, '').replace(reg, '/');
+}
+
+/**
+ * 字节码类
+ */
+function isBytecodeClass(exports) {
+  let isClass = false;
+
+  // 标识
+  if (exports.toString().indexOf('[class') != -1) {
+    isClass = true;
+  }
+  
+  return isClass;
+}
+
+/**
+ * 文件类型
+ */
+function filePatterns() {
+  const files = [ '**/*.js','**/*.jsc' ];
+  return files;
+}
+
+module.exports = {
+  extensions,
+  loadFile,
+  callFn,
+  getResolvedFilename,
+  isBytecodeClass,
+  filePatterns,
+};

package/core/utils/timing.d.ts

@@ -0,0 +1,22 @@
+export declare class Timing {
+    _enable: boolean;
+    init(): void;
+    start(name: any, start: any): {
+        name: any;
+        start: any;
+        end: any;
+        duration: any;
+        pid: number;
+        index: number;
+    };
+    end(name: any): any;
+    enable(): void;
+    disable(): void;
+    clear(): void;
+    toJSON(): any[];
+    [MAP]: Map<any, any>;
+    [LIST]: any[];
+}
+declare const MAP: unique symbol;
+declare const LIST: unique symbol;
+export {};