ee-core 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Wallace Gao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# ee-core
+ee core

package/bin/tools.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const codeCompress = require('../tools/codeCompress');
+const replaceDist = require('../tools/replaceDist');
+
+// argv
+const args = process.argv;
+//console.log('[ee-core] args:', args);
+const cmd = args[2];
+console.log('[ee-core] cmd:', cmd);
+
+if (cmd == 'rd') {
+  replaceDist.run();
+}
+
+if (cmd == 'compress') {
+  codeCompress.compress();
+}
+
+if (cmd == 'restore') {
+  codeCompress.restore();
+}

package/config/config.default.js

@@ -0,0 +1,179 @@
+'use strict';
+const path = require('path');
+
+/**
+ * The configuration of ee application, can be access by `app.config`
+ * @class Config
+ * @since 1.0.0
+ */
+
+module.exports = appInfo => {
+
+  const config = {
+
+    /**
+     * The environment of ee
+     * @member {String} Config#env
+     * @see {appInfo#env}
+     * @since 1.0.0
+     */
+    env: appInfo.env,
+
+    /**
+     * The name of the application
+     * @member {String} Config#name
+     * @see {appInfo#name}
+     * @since 1.0.0
+     */
+    name: appInfo.name,
+
+    /**
+     * package.json
+     * @member {Object} Config#pkg
+     * @see {appInfo#pkg}
+     * @since 1.0.0
+     */
+    pkg: appInfo.pkg,
+
+    /**
+     * The current directory of the application
+     * @member {String} Config#baseDir
+     * @see {appInfo#baseDir}
+     * @since 1.0.0
+     */
+    baseDir: appInfo.baseDir,
+
+    /**
+     * The current HOME directory
+     * @member {String} Config#HOME
+     * @see {appInfo#HOME}
+     * @since 1.0.0
+     */
+    HOME: appInfo.home,
+
+    /**
+     * The directory of server running. You can find `application_config.json` under it that is dumpped from `app.config`.
+     * @member {String} Config#rundir
+     * @default
+     * @since 1.0.0
+     */
+    rundir: path.join(appInfo.baseDir, 'run'),
+
+    /**
+     * dump config
+     *
+     * It will ignore special keys when dumpConfig
+     *
+     * @member Config#dump
+     * @property {Set} ignore - keys to ignore
+     */
+    dump: {
+      ignore: new Set([
+        'pass', 'pwd', 'passd', 'passwd', 'password', 'keys', 'masterKey', 'accessKey',
+        // ignore any key contains "secret" keyword
+        /secret/i,
+      ]),
+    },
+
+    /**
+     * application home directory
+     * @member {String} Config#homeDir
+     * @default
+     * @since 1.0.0
+     */
+    homeDir: appInfo.home,
+
+    /**
+     * application data & logs directory by env
+     * @member {String} Config#root
+     * @default
+     * @since 1.0.0
+     */
+    root: appInfo.root,
+
+    /**
+     * application data directory
+     * @member {String} Config#appUserDataDir
+     * @default
+     * @since 1.0.0
+     */
+    appUserDataDir: appInfo.appUserDataDir
+  };
+
+  /**
+   * logger options
+   * @member Config#logger
+   * @property {String} dir - directory of log files
+   * @property {String} encoding - log file encoding, defaults to utf8
+   * @property {String} level - default log level, could be: DEBUG, INFO, WARN, ERROR or NONE, defaults to INFO in production
+   * @property {String} consoleLevel - log level of stdout, defaults to INFO in local serverEnv, defaults to WARN in unittest, defaults to NONE elsewise
+   * @property {Boolean} disableConsoleAfterReady - disable logger console after app ready. defaults to `false` on local and unittest env, others is `true`.
+   * @property {Boolean} outputJSON - log as JSON or not, defaults to false
+   * @property {Boolean} buffer - if enabled, flush logs to disk at a certain frequency to improve performance, defaults to true
+   * @property {String} errorLogName - file name of errorLogger
+   * @property {String} coreLogName - file name of coreLogger
+   * @property {String} agentLogName - file name of agent worker log
+   * @property {Object} coreLogger - custom config of coreLogger
+   * @property {Boolean} allowDebugAtProd - allow debug log at prod, defaults to false
+   * @property {Boolean} enablePerformanceTimer - using performance.now() timer instead of Date.now() for more more precise milliseconds, defaults to false. e.g.: logger will set 1.456ms instead of 1ms.
+   */
+  config.logger = {
+    dir: path.join(appInfo.root, 'logs'),
+    encoding: 'utf8',
+    env: appInfo.env,
+    level: 'INFO',
+    consoleLevel: 'INFO',
+    disableConsoleAfterReady: appInfo.env !== 'local' && appInfo.env !== 'unittest',
+    outputJSON: false,
+    buffer: true,
+    appLogName: `ee.log`,
+    coreLogName: 'ee-core.log',
+    agentLogName: 'ee-agent.log',
+    errorLogName: `ee-error.log`,
+    coreLogger: {},
+    allowDebugAtProd: false,
+    enablePerformanceTimer: false,
+  };
+
+  /**
+   * The option for httpclient
+   * @member Config#httpclient
+   * @property {Boolean} enableDNSCache - Enable DNS lookup from local cache or not, default is false.
+   * @property {Boolean} dnsCacheLookupInterval - minimum interval of DNS query on the same hostname (default 10s).
+   *
+   * @property {Number} request.timeout - httpclient request default timeout, default is 5000 ms.
+   *
+   * @property {Boolean} httpAgent.keepAlive - Enable http agent keepalive or not, default is true
+   * @property {Number} httpAgent.freeSocketTimeout - http agent socket keepalive max free time, default is 4000 ms.
+   * @property {Number} httpAgent.maxSockets - http agent max socket number of one host, default is `Number.MAX_SAFE_INTEGER` @ses https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+   * @property {Number} httpAgent.maxFreeSockets - http agent max free socket number of one host, default is 256.
+   *
+   * @property {Boolean} httpsAgent.keepAlive - Enable https agent keepalive or not, default is true
+   * @property {Number} httpsAgent.freeSocketTimeout - httpss agent socket keepalive max free time, default is 4000 ms.
+   * @property {Number} httpsAgent.maxSockets - https agent max socket number of one host, default is `Number.MAX_SAFE_INTEGER` @ses https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+   * @property {Number} httpsAgent.maxFreeSockets - https agent max free socket number of one host, default is 256.
+   */
+  config.httpclient = {
+    enableDNSCache: false,
+    dnsCacheLookupInterval: 10000,
+    dnsCacheMaxLength: 1000,
+
+    request: {
+      timeout: 5000,
+    },
+    httpAgent: {
+      keepAlive: true,
+      freeSocketTimeout: 4000,
+      maxSockets: Number.MAX_SAFE_INTEGER,
+      maxFreeSockets: 256,
+    },
+    httpsAgent: {
+      keepAlive: true,
+      freeSocketTimeout: 4000,
+      maxSockets: Number.MAX_SAFE_INTEGER,
+      maxFreeSockets: 256,
+    },
+  };
+
+  return config;
+};

package/core/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+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');
+
+module.exports = {
+  EeCore,
+  EeLoader,
+  BaseContextClass,
+  utils,
+};

package/core/lib/ee.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const KoaApplication = require('koa');
+const is = require('is-type-of');
+const co = require('co');
+const BaseContextClass = require('./utils/base_context_class');
+const utils = require('./utils');
+const Timing = require('./utils/timing');
+const EggConsoleLogger = require('egg-logger').EggConsoleLogger;
+const debug = require('debug')('ee-core:EeCore');
+const EE_LOADER = Symbol.for('ee#loader');
+
+class EeCore extends KoaApplication {
+
+  /**
+   * @class
+   * @param {Object} options - options
+   * @since 1.0.0
+   */
+  constructor(options = {}) {
+    options.type = options.type || 'application';
+
+    assert(typeof options.baseDir === 'string', 'options.baseDir required, and must be a string');
+    assert(fs.existsSync(options.baseDir), `Directory ${options.baseDir} not exists`);
+    assert(fs.statSync(options.baseDir).isDirectory(), `Directory ${options.baseDir} is not a directory`);
+
+    super();
+
+    // todo 
+    //this.context = null;
+
+    this.timing = new Timing();
+
+    this.console = new EggConsoleLogger();
+
+    /**
+     * @member {Object} EeCore#options
+     * @private
+     * @since 1.0.0
+     */
+    this._options = this.options = options;
+
+    /**
+     * @member {BaseContextClass} EeCore#BaseContextClass
+     * @since 1.0.0
+     */
+    this.BaseContextClass = BaseContextClass;
+
+    /**
+     * Base controller to be extended by controller in `app.controller`
+     * @class Controller
+     * @extends BaseContextClass
+     * @example
+     * class UserController extends app.Controller {}
+     */
+    const Controller = this.BaseContextClass;
+
+    /**
+     * Retrieve base controller
+     * @member {Controller} EeCore#Controller
+     * @since 1.0.0
+     */
+    this.Controller = Controller;
+
+    /**
+     * Base service to be extended by services in `app.service`
+     * @class Service
+     * @extends BaseContextClass
+     * @example
+     * class UserService extends app.Service {}
+     */
+    const Service = this.BaseContextClass;
+
+    /**
+     * Retrieve base service
+     * @member {Service} EeCore#Service
+     * @since 1.0.0
+     */
+    this.Service = Service;
+
+    /**
+     * The loader instance, the default class is {@link EeLoader}.
+     * If you want define
+     * @member {EeLoader} EeCore#loader
+     * @since 1.0.0
+     */
+    const Loader = this[EE_LOADER];
+    assert(Loader, 'Symbol.for(\'ee#loader\') is required');
+    this.loader = new Loader({
+      baseDir: options.baseDir,
+      homeDir: options.homeDir,
+      logger: this.console,
+      app: this,
+      env: options.env,
+      appUserData: options.appUserData
+    });
+  }
+
+  /**
+   * override koa's app.use, support generator function
+   * @param {Function} fn - middleware
+   * @return {Application} app
+   * @since 1.0.0
+   */
+  use(fn) {
+    assert(is.function(fn), 'app.use() requires a function');
+    debug('use %s', fn._name || fn.name || '-');
+    this.middleware.push(utils.middleware(fn));
+    return this;
+  }
+
+  /**
+   * The home directory of application
+   * @member {String}
+   * @see {@link AppInfo#homeDir}
+   * @since 1.0.0
+   */
+  get homeDir() {
+    return this.options.homeDir;
+  }
+
+  /**
+   * The electron current directory of application
+   * @member {String}
+   * @see {@link AppInfo#baseDir}
+   * @since 1.0.0
+   */
+  get baseDir() {
+    return this.options.baseDir;
+  }
+
+  /**
+   * The ee-core directory of framework
+   * @member {String}
+   * @see {@link AppInfo#EeCoreDir}
+   * @since 1.0.0
+   */
+  get eeCoreDir() {
+    return this.options.framework;
+  }
+
+  /**
+   * The name of application
+   * @member {String}
+   * @see {@link AppInfo#name}
+   * @since 1.0.0
+   */
+  get name() {
+    return this.loader ? this.loader.pkg.name : '';
+  }
+
+  /**
+   * The configuration of application
+   * @member {Config}
+   * @since 1.0.0
+   */
+  get config() {
+    return this.loader ? this.loader.config : {};
+  }
+
+  get [EE_LOADER]() {
+    return require('./loader/ee_loader');
+  }
+
+  /**
+   * Convert a generator function to a promisable one.
+   *
+   * Notice: for other kinds of functions, it directly returns you what it is.
+   *
+   * @param  {Function} fn The inputted function.
+   * @return {AsyncFunction} An async promise-based function.
+   * @example
+    ```javascript
+     const fn = function* (arg) {
+        return arg;
+      };
+      const wrapped = app.toAsyncFunction(fn);
+      wrapped(true).then((value) => console.log(value));
+    ```
+   */
+  toAsyncFunction(fn) {
+    if (!is.generatorFunction(fn)) return fn;
+    fn = co.wrap(fn);
+    return async function(...args) {
+      return fn.apply(this, args);
+    };
+  }
+
+  /**
+   * Convert an object with generator functions to a Promisable one.
+   * @param  {Mixed} obj The inputted object.
+   * @return {Promise} A Promisable result.
+   * @example
+    ```javascript
+     const fn = function* (arg) {
+        return arg;
+      };
+      const arr = [ fn(1), fn(2) ];
+      const promise = app.toPromise(arr);
+      promise.then(res => console.log(res));
+    ```
+   */
+  toPromise(obj) {
+    return co(function* () {
+      return yield obj;
+    });
+  }
+}
+
+// delegate all router method to application
+// utils.methods.concat([ 'all', 'resources', 'register', 'redirect' ]).forEach(method => {
+//   EeCore.prototype[method] = function(...args) {
+//     this.router[method](...args);
+//     return this;
+//   };
+// });
+
+module.exports = EeCore;

package/core/lib/loader/context_loader.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const assert = require('assert');
+const is = require('is-type-of');
+const FileLoader = require('./file_loader');
+const CLASSLOADER = Symbol('classLoader');
+const EXPORTS = FileLoader.EXPORTS;
+
+class ClassLoader {
+
+  constructor(options) {
+    assert(options.ctx, 'options.ctx is required');
+    const properties = options.properties;
+    this._cache = new Map();
+    this._ctx = options.ctx;
+
+    for (const property in properties) {
+      this.defineProperty(property, properties[property]);
+    }
+  }
+
+  defineProperty(property, values) {
+    Object.defineProperty(this, property, {
+      get() {
+        let instance = this._cache.get(property);
+        if (!instance) {
+          instance = getInstance(values, this._ctx);
+          this._cache.set(property, instance);
+        }
+        return instance;
+      },
+    });
+  }
+}
+
+/**
+ * Same as {@link FileLoader}, but it will attach file to `inject[fieldClass]`. The exports will be lazy loaded, such as `ctx.group.repository`.
+ * @extends FileLoader
+ * @since 1.0.0
+ */
+class ContextLoader extends FileLoader {
+
+  /**
+   * @class
+   * @param {Object} options - options same as {@link FileLoader}
+   * @param {String} options.fieldClass - determine the field name of inject object.
+   */
+  constructor(options) {
+    assert(options.property, 'options.property is required');
+    assert(options.inject, 'options.inject is required');
+    const target = options.target = {};
+    if (options.fieldClass) {
+      options.inject[options.fieldClass] = target;
+    }
+    super(options);
+
+    const app = this.options.inject;
+    const property = options.property;
+
+    // define ctx.service
+    Object.defineProperty(app, property, {
+      get() {
+        // distinguish property cache,
+        // cache's lifecycle is the same with this context instance
+        // e.x. ctx.service1 and ctx.service2 have different cache
+        if (!this[CLASSLOADER]) {
+          this[CLASSLOADER] = new Map();
+        }
+        const classLoader = this[CLASSLOADER];
+
+        let instance = classLoader.get(property);
+        if (!instance) {
+          instance = getInstance(target, this);
+          classLoader.set(property, instance);
+        }
+        return instance;
+      },
+    });
+  }
+}
+
+module.exports = ContextLoader;
+
+
+function getInstance(values, ctx) {
+  // it's a directory when it has no exports
+  // then use ClassLoader
+  const Class = values[EXPORTS] ? values : null;
+  let instance;
+  if (Class) {
+    if (is.class(Class)) {
+      instance = new Class(ctx);
+    } else {
+      // it's just an object
+      instance = Class;
+    }
+  // Can't set property to primitive, so check again
+  // e.x. module.exports = 1;
+  } else if (is.primitive(values)) {
+    instance = values;
+  } else {
+    instance = new ClassLoader({ ctx, properties: values });
+  }
+  return instance;
+}