ee-core 2.12.0 → 4.0.0-beta.1

package/app/application.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const debug = require('debug')('ee-core:app:appliaction');
+const { loadController } = require('../controller');
+const { eventBus, Ready } = require('./events');
+const { loadSocket } = require('../socket');
+const { loadElectron } = require('../electron');
+
+class Appliaction {
+  constructor() {
+
+  }
+
+  register(eventName, handler) {
+    return eventBus.register(eventName, handler);
+  }
+
+  run() {
+    loadController();
+    loadSocket();
+    eventBus.emitLifecycle(Ready);
+    loadElectron();
+  }
+}
+
+const app = new Appliaction();
+
+module.exports = {
+  Appliaction,
+  app,
+};

package/app/boot.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const debug = require('debug')('ee-core:app:boot');
+const path = require('path');
+const { loadException } = require('../exception');
+const { electronApp } = require('../electron/app');
+const { getArgumentByName, getBundleDir } = require('../ps');
+const { loadConfig } = require('../config');
+const { loadLog } = require('../log');
+const { app } = require('./application');
+const { loadDir } = require('./dir');
+// const { isJsProject } = require('../utils');
+
+class ElectronEgg {
+  constructor() {
+    const baseDir = electronApp.getAppPath();
+    const { env } = process;
+    const environmet = getArgumentByName('env') || 'prod';
+    console.log('argv:', process.argv);
+
+    const options = {
+      env: environmet,
+      baseDir,
+      electronDir: getBundleDir(baseDir),
+      appName: electronApp.getName(),
+      userHome: electronApp.getPath('home'),
+      appData: electronApp.getPath('appData'),
+      appUserData: electronApp.getPath('userData'),
+      appVersion: electronApp.getVersion(),
+      isPackaged: electronApp.isPackaged,
+      execDir: baseDir,
+    }
+
+    // exec directory (exe dmg dep) for prod
+    if (environmet == 'prod' && options.isPackaged) {
+      options.execDir = path.dirname(electronApp.getPath('exe'));
+    }
+
+    // js开发环境使用源码目录
+    // if (isJsProject(baseDir) && environmet !== 'prod' ) {
+    //   options.electronDir = path.join(baseDir, 'electron');
+    // }
+
+    // normalize env
+    env.EE_ENV = environmet;
+    env.EE_APP_NAME = options.appName;
+    env.EE_APP_VERSION = options.appVersion;
+    env.EE_BASE_DIR = options.baseDir;
+    env.EE_ELECTRON_DIR = options.electronDir;
+    env.EE_USER_HOME = options.userHome;
+    env.EE_APP_DATA = options.appData;
+    env.EE_APP_USER_DATA = options.appUserData;
+    env.EE_EXEC_DIR = options.execDir;
+    env.EE_IS_PACKAGED = options.isPackaged;
+    env.EE_SOCKET_PORT = null;
+    env.EE_HTTP_PORT = null;
+    debug('[constructor] options:%j', options)
+
+    this.init();
+  }
+
+  init() {
+    // basic functions
+    loadException();
+    loadConfig();
+    loadDir();
+    loadLog();
+  }
+
+  register(eventName, handler) {
+    return app.register(eventName, handler);
+  }
+
+  run() {
+    app.run();
+  }
+}
+
+module.exports = {
+  ElectronEgg,
+};

package/app/dir.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const fs = require('fs');
+const { getUserHomeHiddenAppDir, getLogDir, getDataDir } = require('../ps');
+const { mkdir } = require('../utils/helper');
+function loadDir() {
+  initDir();
+}
+
+function initDir() {
+  const homeHiddenAppDir = getUserHomeHiddenAppDir();
+  if (!fs.existsSync(homeHiddenAppDir)) {
+    mkdir(homeHiddenAppDir, { mode: 0o755 });
+  }
+  const dataDir = getDataDir();
+  if (!fs.existsSync(dataDir)) {
+    mkdir(dataDir, { mode: 0o755 });
+  }
+  const logDir = getLogDir();
+  if (!fs.existsSync(logDir)) {
+    mkdir(logDir, { mode: 0o755 });
+  }
+}
+
+module.exports = {
+  loadDir
+};

package/app/events.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Ready = "ready";
+const ElectronAppReady = "electron-app-ready";
+const WindowReady = "window-ready";
+const BeforeClose = "before-close";
+const Preload = "preload";
+
+class EventBus {
+  constructor() {
+    this.lifecycleEvents = {};
+    this.eventsMap = {};
+  }
+
+  // add lifecycle event
+  register(eventName, handler) {
+    if (!this.lifecycleEvents[eventName]) {
+      this.lifecycleEvents[eventName] = handler;
+    }
+  }
+
+  // call lifecycle event
+  emitLifecycle(eventName, ...args) {
+    const eventFn = this.lifecycleEvents[eventName];
+    if (eventFn) {
+      eventFn(...args);
+    }
+  } 
+
+  // add listener
+  on(eventName, handler) {
+    if (!this.eventsMap[eventName]) {
+      this.eventsMap[eventName] = handler;
+    }
+  }
+
+  // emit listener
+  emit(eventName, ...args) {
+    const eventFn = this.eventsMap[eventName];
+    if (eventFn) {
+      eventFn(...args);
+    }
+  }
+}
+
+const eventBus = new EventBus();
+
+module.exports = {
+  EventBus,
+  eventBus,
+  Ready,
+  ElectronAppReady,
+  WindowReady,
+  Preload,
+  BeforeClose
+};

package/app/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { ElectronEgg } = require('./boot');
+
+module.exports = {
+  ElectronEgg,
+};

package/config/config_loader.js

@@ -2,15 +2,15 @@
 
 const debug = require('debug')('ee-core:config:config_loader');
 const path = require('path');
-const Ps = require('../ps');
-const extend = require('../utils/extend');
-const Timing = require('../core/lib/utils/timing');
-const Loader= require('../loader');
+const { appName, env, getElectronDir, getBaseDir, getRootDir } = require('../ps');
+const { extend } = require('../utils/extend');
+const { loadFile } = require('../loader');
+const { Timing } = require('../core/utils/timing');
+const defaultConfig = require('./default_config');
 
 class ConfigLoader {
   constructor() {
     this.timing = new Timing();
-    this.config = {};
   }
 
   /**
@@ -21,21 +21,24 @@ class ConfigLoader {
 
     // Load Application config
     const appConfig = this._AppConfig();
-    debug("[load] appConfig: %o", appConfig);
-    this.config = appConfig;
+    // debug("[load] appConfig: %O", appConfig);
+
+    const defaultConf = defaultConfig();
+    const config = extend(true, defaultConf, appConfig);
+    debug("[load] config: %o", config);
 
     this.timing.end('Load Config');
-    return this.config;
+    return config;
   }
 
   _AppConfig() {
     const names = [
       'config.default',
-      `config.${Ps.env()}`,
+      `config.${env()}`,
     ];
     const target = {};
     for (const filename of names) {
-      const config = this._loadConfig(Ps.getElectronDir(), filename);
+      const config = this._loadConfig(getElectronDir(), filename);
       extend(true, target, config);
     }
     return target;
@@ -43,21 +46,14 @@ class ConfigLoader {
 
   _loadConfig(dirpath, filename) {
     const appInfo = {
-      name: Ps.appName(),
-      baseDir: Ps.getElectronDir(),
-      electronDir: Ps.getElectronDir(),
-      env: Ps.env(),
-      home: Ps.getHomeDir(),
-      root: Ps.getRootDir(),
-      appUserDataDir: Ps.getAppUserDataDir(),
-      userHome: Ps.getUserHomeDir(),
-      appVersion: Ps.appVersion(),
-      isPackaged: Ps.isPackaged(),
-      isEncrypted: Ps.isEncrypted(),
-      execDir: Ps.getExecDir(),
+      name: appName(),
+      baseDir: getBaseDir(),
+      electronDir: getElectronDir(),
+      env: env(),
+      root: getRootDir(),
     }
     const filepath = path.join(dirpath, 'config', filename);
-    const config = Loader.loadOneFile(filepath, appInfo);
+    const config = loadFile(filepath, appInfo);
     debug("[_loadConfig] filepath: %s", filepath);
     if (!config) return null;
 

package/config/default_config.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const path = require('path');
+const { env, getBaseDir, getLogDir } = require('../ps');
+const { SocketIO } = require('../const/channel');
+
+/**
+ * default
+ */
+module.exports = () => {
+  return {
+    openDevTools: false,
+    singleLock: true,
+    windowsOption: {
+      title: 'electron-egg',
+      width: 980,
+      height: 650,
+      minWidth: 400,
+      minHeight: 300,
+      webPreferences: {
+        //webSecurity: false,
+        contextIsolation: false, // false -> 可在渲染进程中使用electron的api，true->需要bridge.js(contextBridge)
+        nodeIntegration: true,
+        //preload: path.join(appInfo.electronDir, 'preload', 'bridge.js'),
+      },
+      frame: true,
+      show: false,
+      icon: path.join(getBaseDir(), 'public', 'images', 'logo-32.png'),
+    },
+    logger: {
+      type: 'application',
+      dir: getLogDir(),
+      encoding: 'utf8',
+      env: env(),
+      level: 'INFO',
+      consoleLevel: 'INFO',
+      disableConsoleAfterReady: env() !== 'local',
+      outputJSON: false,
+      buffer: true,
+      appLogName: `ee.log`,
+      coreLogName: 'ee-core.log',
+      agentLogName: 'ee-agent.log',
+      errorLogName: `ee-error.log`,
+      coreLogger: {},
+      allowDebugAtProd: false,
+      enablePerformanceTimer: false,
+      rotator: 'day',
+    },
+    socketServer: {
+      enable: false, // is it enabled
+      port: 7070, // default port (if the port is in use, randomly select one)
+      path: "/socket.io/", // path
+      connectTimeout: 45000, // client connection timeout
+      pingTimeout: 30000, // heartbeat detection timeout
+      pingInterval: 25000, // heartbeat detection interval
+      maxHttpBufferSize: 1e8, // the data size of each message 1M
+      transports: ["polling", "websocket"], // http polling or websocket
+      cors: {
+        origin: true, // http协议时，要设置跨域 类型 Boolean String RegExp Array Function
+      },
+      channel: SocketIO.partySoftware
+    },
+    httpServer: {
+      enable: false, // Is it enabled
+      https: {
+        enable: false,
+        key: '/public/ssl/localhost+1.key',
+        cert: '/public/ssl/localhost+1.pem'
+      },
+      protocol: 'http://',
+      host: '127.0.0.1',
+      port: 7071, // Default port (if the port is in use, randomly select one)
+      cors: {
+        origin: "*"
+      },
+      body: {
+        multipart: true,
+        formidable: {
+          keepExtensions: true
+        }
+      },
+      filterRequest: {
+        uris:  [
+          'favicon.ico'
+        ],
+        returnData: ''
+      }
+    },
+    remote: {
+      enable: false,
+      url: ''
+    },
+    mainServer: {
+      protocol: 'file://', // file://
+      indexPath: '/public/dist/index.html',
+      options: {},
+      takeover: '',
+      loadingPage: '',
+    },
+    exception: {
+      mainExit: false,
+      childExit: true,
+      rendererExit: true,
+    },
+    jobs: {
+      messageLog: false
+    },
+    cross: {}
+  }
+}

package/config/index.js

@@ -1,42 +1,25 @@
-const ConfigCache = require('./cache');
+'use strict';
 
-const Cfg = {
+const { ConfigLoader } = require('./config_loader');
 
-  /**
-   * all
-   */
-  all() {
-    const cacheValue = ConfigCache.all();
-    return cacheValue;
-  },
-
-  /**
-   * getValue
-   */
-  getValue(key) {
-    const cacheValue = ConfigCache.getValue(key);
-    return cacheValue;
-  },  
+const Instance = {
+  config: null,
+};
 
-  /**
-   * isFileProtocol
-   */
-  isFileProtocol(config) {
-    if (config.protocol == 'file://') {
-      return true;
-    }
-    return false;
-  },
+function loadConfig() {
+  const configLoader = new ConfigLoader();
+  Instance["config"] = configLoader.load();
+  return Instance["config"];
+}
 
-  /**
-   * isWebProtocol
-   */
-  isWebProtocol(config) {
-    if (['http://', 'https://'].includes(config.protocol)) {
-      return true;
-    }
-    return false;
-  },   
-};
+function getConfig() {
+  if (!Instance["config"]) {
+    loadConfig();
+  };
+  return Instance["config"];
+}
 
-module.exports = Cfg;
+module.exports = {
+  loadConfig,
+  getConfig,
+};

package/const/channel.js

@@ -1,18 +1,28 @@
+'use strict';
+
+const Processes = {
+  showException: 'ee#showException',
+  sendToMain: 'ee#sendToMain'
+}
+
+const SocketIO = {
+  partySoftware: 'c1',
+}
+
+const Events = {
+  childProcessExit: 'ee#childProcess#exit',
+  childProcessError: 'ee#childProcess#error',
+}
+
+const Receiver = {
+  childJob: 'job',
+  forkProcess: 'task',
+  all: 'all'
+}
+
 module.exports = {
-  process: {
-    showException: 'ee#showException',
-    sendToMain: 'ee#sendToMain'
-  },
-  socketIo: {
-    partySoftware: 'c1',
-  },
-  events: {
-    childProcessExit: 'ee#childProcess#exit',
-    childProcessError: 'ee#childProcess#error',
-  },
-  receiver: {
-    childJob: 'job',
-    forkProcess: 'task',
-    all: 'all'
-  }
+  Processes,
+  SocketIO,
+  Events,
+  Receiver
 };

package/const/index.js

@@ -1,8 +1,4 @@
 module.exports = {
-  storageKey: {
-    cache: 'cache',
-    cacheConfig: 'cache.config',
-  },
   jobs: {
     inspectStartIndex: 5858
   }

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.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.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,