ee-core 1.0.0

package/lib/httpclient.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const Agent = require('agentkeepalive');
+const HttpsAgent = require('agentkeepalive').HttpsAgent;
+const urllib = require('urllib');
+const ms = require('humanize-ms');
+const { FrameworkBaseError } = require('egg-errors');
+
+class HttpClientError extends FrameworkBaseError {
+  get module() {
+    return 'httpclient';
+  }
+}
+
+class HttpClient extends urllib.HttpClient2 {
+  constructor(app) {
+    normalizeConfig(app);
+    const config = app.config.httpclient;
+    super({
+      app,
+      defaultArgs: config.request,
+      agent: new Agent(config.httpAgent),
+      httpsAgent: new HttpsAgent(config.httpsAgent),
+    });
+    this.app = app;
+  }
+
+  request(url, args, callback) {
+    if (typeof args === 'function') {
+      callback = args;
+      args = null;
+    }
+
+    args = args || {};
+
+    // the callback style
+    if (callback) {
+      //this.app.deprecate('[httpclient] We now support async for this function, so callback isn\'t recommended.');
+      super.request(url, args)
+        .then(result => process.nextTick(() => callback(null, result.data, result.res)))
+        .catch(err => process.nextTick(() => callback(err)));
+      return;
+    }
+
+    // the Promise style
+    return super.request(url, args)
+      .catch(err => {
+        if (err.code === 'ENETUNREACH') {
+          throw HttpClientError.create(err.message, err.code);
+        }
+        throw err;
+      });
+  }
+
+  curl(url, args, callback) {
+    return this.request(url, args, callback);
+  }
+
+  requestThunk(url, args) {
+    //this.app.deprecate('[httpclient] Please use `request()` instead of `requestThunk()`');
+    return callback => {
+      this.request(url, args, (err, data, res) => {
+        if (err) {
+          return callback(err);
+        }
+        callback(null, {
+          data,
+          status: res.status,
+          headers: res.headers,
+          res,
+        });
+      });
+    };
+  }
+}
+
+function normalizeConfig(app) {
+  const config = app.config.httpclient;
+
+  // compatibility
+  if (typeof config.keepAlive === 'boolean') {
+    config.httpAgent.keepAlive = config.keepAlive;
+    config.httpsAgent.keepAlive = config.keepAlive;
+  }
+  if (config.timeout) {
+    config.timeout = ms(config.timeout);
+    config.httpAgent.timeout = config.timeout;
+    config.httpsAgent.timeout = config.timeout;
+  }
+  // compatibility httpclient.freeSocketKeepAliveTimeout => httpclient.freeSocketTimeout
+  if (config.freeSocketKeepAliveTimeout && !config.freeSocketTimeout) {
+    config.freeSocketTimeout = config.freeSocketKeepAliveTimeout;
+    delete config.freeSocketKeepAliveTimeout;
+  }
+  if (config.freeSocketTimeout) {
+    config.freeSocketTimeout = ms(config.freeSocketTimeout);
+    config.httpAgent.freeSocketTimeout = config.freeSocketTimeout;
+    config.httpsAgent.freeSocketTimeout = config.freeSocketTimeout;
+  } else {
+    // compatibility agent.freeSocketKeepAliveTimeout
+    if (config.httpAgent.freeSocketKeepAliveTimeout && !config.httpAgent.freeSocketTimeout) {
+      config.httpAgent.freeSocketTimeout = config.httpAgent.freeSocketKeepAliveTimeout;
+      delete config.httpAgent.freeSocketKeepAliveTimeout;
+    }
+    if (config.httpsAgent.freeSocketKeepAliveTimeout && !config.httpsAgent.freeSocketTimeout) {
+      config.httpsAgent.freeSocketTimeout = config.httpsAgent.freeSocketKeepAliveTimeout;
+      delete config.httpsAgent.freeSocketKeepAliveTimeout;
+    }
+  }
+
+  if (typeof config.maxSockets === 'number') {
+    config.httpAgent.maxSockets = config.maxSockets;
+    config.httpsAgent.maxSockets = config.maxSockets;
+  }
+  if (typeof config.maxFreeSockets === 'number') {
+    config.httpAgent.maxFreeSockets = config.maxFreeSockets;
+    config.httpsAgent.maxFreeSockets = config.maxFreeSockets;
+  }
+
+  if (config.httpAgent.timeout < 30000) {
+    app.coreLogger.warn('[ee:httpclient] config.httpclient.httpAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
+      config.httpAgent.timeout);
+    config.httpAgent.timeout = 30000;
+  }
+  if (config.httpsAgent.timeout < 30000) {
+    app.coreLogger.warn('[ee:httpclient] config.httpclient.httpsAgent.timeout(%s) can\'t below 30000, auto reset to 30000',
+      config.httpsAgent.timeout);
+    config.httpsAgent.timeout = 30000;
+  }
+
+  if (typeof config.request.timeout === 'string') {
+    config.request.timeout = ms(config.request.timeout);
+  }
+}
+
+module.exports = HttpClient;

package/lib/logger.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const debug = require('debug')('ee-core:logger');
+const Loggers = require('egg-logger').EggLoggers;
+const assert = require('assert');
+
+class Logger {
+  constructor (config) {
+    debug('Loaded logger');
+    assert(Object.keys(config).length != 0, `logger config is null`);
+    this.eggLogger = this.init(config);
+  }
+
+  /**
+   * 单例
+   */
+  static getInstance (config = {}) {
+    if (typeof this.instance === 'object') {
+      return this.instance.eggLogger;
+    }
+
+    this.instance = new Logger(config);
+
+    // 返回egg-logger实例
+    return this.instance.eggLogger;
+  }
+
+  /**
+   * 初始化模块
+   */
+  init(config) {
+    const loggerConfig = config.logger;
+    loggerConfig.type = 'application'; // application、agent
+
+    if (config.env === 'prod' && loggerConfig.level === 'DEBUG' && !loggerConfig.allowDebugAtProd) {
+      loggerConfig.level = 'INFO';
+    }
+
+    const loggers = new Loggers(config);
+
+    loggers.coreLogger.info('[ee-core:logger] init all loggers with options: %j', loggerConfig);
+
+    return loggers;
+  };
+}
+
+module.exports = Logger;

package/lib/socket/io.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const IoServer = require('socket.io');
+const IoClient = require('socket.io-client');
+//const socketServer = require('./socketServer');
+const socketClient = require('./socketClient');
+
+const EeSocket = {
+  getServer: () => {
+    //return socketServer.getInstance();
+  },
+  getClient: () => {
+    return socketClient.getInstance();
+  }
+}
+
+
+module.exports = {
+  IoServer,
+  IoClient,
+  EeSocket
+};

package/lib/socket/ipcServer.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const debug = require('debug')('ee-core:ipcServer');
+const EggConsoleLogger = require('egg-logger').EggConsoleLogger;
+const is = require('is-type-of');
+const { ipcMain } = require('electron');
+const path = require('path');
+const fs = require('fs');
+const globby = require('globby');
+const utils = require('../../core/lib/utils');
+const wrap = require('../../utils/wrap');
+const utility = require('utility');
+
+class IpcServer {
+  constructor (app) {
+
+    this.app = app;
+    this.consoleLogger = new EggConsoleLogger();
+    this.consoleLogger.info('[ee-core:socket:ipcMain] start ipcMain');
+    this.register();
+  }
+
+  register () {
+    this.consoleLogger.info('[ee-core:socket:ipcMain] register channels');
+
+    const self = this;
+    // 遍历方法
+    const files = (process.env.EE_TYPESCRIPT === 'true' && utils.extensions['.ts'])
+    ? [ '**/*.(js|ts)', '!**/*.d.ts' ]
+    : [ '**/*.js' ];
+    const directory = path.join(this.app.config.baseDir, 'controller');
+    const filepaths = globby.sync(files, { cwd: directory });
+    for (const filepath of filepaths) {
+      const fullpath = path.join(directory, filepath);
+      if (!fs.statSync(fullpath).isFile()) continue;
+
+      const properties = wrap.getProperties(filepath, {caseStyle: 'lower'});
+      const pathName = directory.split(/[/\\]/).slice(-1) + '.' + properties.join('.');
+    
+      let fileObj = utils.loadFile(fullpath);
+      const fns = {};
+      if (is.function(fileObj) && !is.generatorFunction(fileObj) && !is.class(fileObj) && !is.asyncFunction(fileObj)) {
+        //obj = obj(this.app);
+      }
+      if (is.class(fileObj)) {
+        let proto = fileObj.prototype;
+        //while (proto !== Object.prototype) {
+          const keys = Object.getOwnPropertyNames(proto);
+          for (const key of keys) {
+            if (key === 'constructor') {
+              continue;
+            }
+            const d = Object.getOwnPropertyDescriptor(proto, key);
+            if (is.function(d.value) && !fns.hasOwnProperty(key)) {
+              fns[key] = 1;
+            }
+          }
+          //proto = Object.getPrototypeOf(proto);
+        //}
+      }
+      if (is.object(fileObj)) {
+        const keys = Object.keys(fileObj);
+        for (const key of keys) {
+          if (is.function(fileObj[key])) {
+            const names = utility.getParamNames(fileObj[key]);
+            if (names[0] === 'next') {
+              throw new Error(`controller \`${prefix || ''}${key}\` should not use next as argument from file ${path}`);
+            }
+            fns[key] = 1;
+          }
+          // else if (is.object(fileObj[key])) {
+          //   ret[key] = wrapObject(obj[key], path, `${prefix || ''}${key}.`);
+          // }
+        }
+      }
+      // if (is.generatorFunction(obj) || is.asyncFunction(obj)) {      
+      // }
+
+      debug('register class %s fns %j', pathName, fns);
+
+      for (const key in fns) {
+        let channel = pathName + '.' + key;
+        debug('register channel %s', channel);
+        ipcMain.on(channel, async (event, params) => {
+          try {
+            // 找函数
+            const cmd = channel;
+            const args = params;
+            let fn = null;
+            if (is.string(cmd)) {
+              const actions = cmd.split('.');
+              let obj = self.app;
+              actions.forEach(key => {
+                obj = obj[key];
+                if (!obj) throw new Error(`class or function '${key}' not exists`);
+              });
+              fn = obj;
+            }
+            if (!fn) throw new Error('function not exists');
+            
+            const result = await fn.call(self.app, args, event);
+            event.reply(`${channel}`, result)
+          } catch (err) {
+            self.app.logger.error('[ee:socket:ipcMain] throw error:', err);
+          }
+        })
+      }
+    }
+  }
+}
+
+module.exports = IpcServer;

package/lib/socket/socketClient.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const assert = require('assert');
+const IoClient = require('socket.io-client');
+const constant = require('../constant');
+const EggConsoleLogger = require('egg-logger').EggConsoleLogger;
+
+class SocketClient {
+  constructor (port) {
+    this.consoleLogger = new EggConsoleLogger();
+    port = port ? port : this.getIpcPort();
+
+    assert(typeof port === 'number', 'port required, and must be a number');
+    this.consoleLogger.info('[ee-core:socket:client] start client');
+    
+    const url  = 'http://127.0.0.1:' + port;
+    this.consoleLogger.info('[ee-core:socket:client] url:', url);
+    this.client = IoClient(url);
+  }
+
+  static getInstance (port) {
+    if (typeof this.instance === 'object') {
+      return this.instance;
+    }
+    this.instance = new SocketClient(port);
+    return this.instance;
+  }
+
+  call (method = '', ...params) {
+    return new Promise((resolve, reject) => {
+      // 获取通信频道
+      const channel = constant.socketIo.channel.eggIoEe;
+      this.client.emit(channel, { cmd: method, params: params }, (response) => {
+        resolve(response);
+      });
+    });
+  }
+
+  getCoreDB () {
+    const coreDB = require('../storage/index').JsonDB.connection('system');
+    return coreDB;
+  }
+
+  getIpcPort () {
+    const cdb = this.getCoreDB();
+    const port = cdb.getItem('ipc_port');
+    return port;
+  }
+}
+
+module.exports = SocketClient;

package/lib/socket/socketServer.js

@@ -0,0 +1,70 @@
+'use strict';
+
+const assert = require('assert');
+const { Server } = require('socket.io');
+const constant = require('../constant');
+const EggConsoleLogger = require('egg-logger').EggConsoleLogger;
+const is = require('is-type-of');
+
+/**
+ * 类文件，顶部new egglogger 后，出现代码无法正常加载
+ */
+class SocketServer {
+  constructor (app) {
+    let port = process.env.EE_IPC_PORT ? parseInt(process.env.EE_IPC_PORT) : parseInt(this.getIpcPort());
+
+    assert(typeof port === 'number', 'port required, and must be a number');
+
+    this.app = app;
+    this.consoleLogger = new EggConsoleLogger();
+    this.consoleLogger.info('[ee-core:socket:server] start server, socket port is:', port);
+    this.io = new Server(port);
+    this.connec();
+  }
+
+  connec () {
+    this.consoleLogger.info('[ee-core:socket:server] connection .....');
+    this.io.on('connection', (socket) => {
+      const channel = constant.socketIo.channel.eggIoEe;
+      socket.on(channel, async (message, callback) => {
+        this.consoleLogger.info('[ee-core:socket:server] socket id:' + socket.id + ' message cmd: ' + message.cmd);
+
+        try {
+          // 找函数
+          const cmd = message.cmd;
+          const args = message.params;
+          let fn = null;
+          if (is.string(cmd)) {
+            const actions = cmd.split('.');
+            let obj = this.app;
+            actions.forEach(key => {
+              obj = obj[key];
+              if (!obj) throw new Error(`class or function '${key}' not exists`);
+            });
+            fn = obj;
+          }
+          if (!fn) throw new Error('function not exists');
+
+          const result = await fn.call(this.app, args);
+          callback(result);
+        } catch (err) {
+          this.app.logger.error('[ee:socket] throw error:', err);
+        }
+ 
+      });
+    });
+  }
+
+  getCoreDB () {
+    const coreDB = require('../storage/index').JsonDB.connection('system');
+    return coreDB;
+  }
+
+  getIpcPort () {
+    const cdb = this.getCoreDB();
+    const port = cdb.getItem('ipc_port');
+    return port;
+  }
+}
+
+module.exports = SocketServer;

package/lib/socket/start.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const socketServer = require('./socketServer');
+const ipcServer = require('./ipcServer');
+
+/**
+ * server
+ */
+ module.exports = (app) => {
+
+  // 启动 socket server
+  new socketServer(app);
+
+  // 启动 ipc server
+  new ipcServer(app);
+
+}
+

package/lib/storage/appStorage.js

@@ -0,0 +1,14 @@
+'use strict';
+
+class AppStorage  {
+  constructor() {
+    const Storage = require('./storage');
+    const sObj = Storage.getInstance('appData');
+
+    for (const attr of sObj) {
+      Object.assign(UserStorage.prototype, attr);
+    }
+  }
+}
+
+module.exports = AppStorage;

package/lib/storage/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const JsonDB = {};
+
+JsonDB.connection = function (database) {
+
+  // console.log('this::::::', this);
+  // todo
+  // if (typeof this.instance === 'object') {
+  //   return this.instance;
+  // }
+
+  const LowdbStorage = require('./lowdbStorage');
+  const storage = new LowdbStorage(database);
+
+  // this.instance = storage;
+  return storage;
+}
+
+module.exports = {
+  JsonDB
+};

package/lib/storage/lowdbStorage.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const lowdb = require('lowdb');
+const FileSync = require('lowdb/adapters/FileSync');
+const _ = require('lodash');
+const constant = require('../constant');
+
+class LowdbStorage {
+  constructor (name, opt = {}) {
+    assert(name, `db name ${name} Cannot be empty`);
+
+    this.name = name;
+
+    // 数据库key列表
+    this.storageKey = constant.storageKey;
+
+    const storageDir = this.getStorageDir();
+    if (!fs.existsSync(storageDir)) {
+      this.mkdir(storageDir);
+      this.chmodPath(storageDir, '777');
+    }
+
+    this.db = this.table(name);
+  }
+
+  /**
+   * 创建 table
+   */
+  table (name) {
+    assert(name, 'table name is required');
+
+    const dbFile = this.getFilePath(name);
+    const adapter = new FileSync(dbFile);
+    const db = lowdb(adapter);
+
+    assert(fs.existsSync(dbFile), `error: storage ${dbFile} not exists`);
+
+    return db;
+  }
+
+  /**
+   * 获取db文件名
+   */
+  getFileName (name) {
+    return name + ".json";
+  }
+
+  /**
+   * 获取db文件名
+   */
+  getFilePath (name) {
+    const storageDir = this.getStorageDir();
+    const dbFile = path.join(storageDir, this.getFileName(name));
+    return dbFile;
+  }
+
+  /**
+   * 获取数据存储路径
+   */
+  getStorageDir () {
+    let env = process.env.EE_SERVER_ENV;
+    const appDir = env === 'local' || env === 'unittest' ? process.env.EE_HOME : process.env.EE_APP_USER_DATA;
+    const storageDir = path.join(appDir, 'data');
+    return storageDir;
+  }
+
+  /**
+   * 为指定的 name 设置一个对应的值
+   */
+  setItem (key, value) {
+    assert(_.isString(key), `key must be a string`);
+    assert(key.length != 0, `key cannot be empty`);
+    assert(!this.storageKey.hasOwnProperty(key), `${key} is not allowed`);
+
+    let cacheKey = this.storageKey.cache;
+    if (!this.db.has(cacheKey).value()) {
+      this.db.set(cacheKey, {}).write();
+    }
+
+    let keyId = cacheKey + "." + key; 
+    this.db
+      .set(keyId, value)
+      .write();
+  
+    return true;
+  }
+  
+  /**
+   * 根据指定的名字 name 获取对应的值
+   */
+  getItem (key) {
+    assert(_.isString(key), `key must be a string`);
+    assert(key.length != 0, `key cannot be empty`);
+
+    let cacheKey = this.storageKey.cache;
+    let keyId = cacheKey + "." + key; 
+    const data = this.db
+      .get(keyId)
+      .value();
+  
+    return data;
+  }   
+
+  mkdir (dirpath, dirname) {
+    if (typeof dirname === 'undefined') {
+      if (fs.existsSync(dirpath)) {
+        return;
+      }
+      this.mkdir(dirpath, path.dirname(dirpath));
+    } else {
+      if (dirname !== path.dirname(dirpath)) {
+        this.mkdir(dirpath);
+        return;
+      }
+      if (fs.existsSync(dirname)) {
+        fs.mkdirSync(dirpath);
+      } else {
+        this.mkdir(dirname, path.dirname(dirname));
+        fs.mkdirSync(dirpath);
+      }
+    }
+  };
+  
+  chmodPath (path, mode) {
+    let files = [];
+    if (fs.existsSync(path)) {
+      files = fs.readdirSync(path);
+      files.forEach((file, index) => {
+        const curPath = path + '/' + file;
+        if (fs.statSync(curPath).isDirectory()) {
+          this.chmodPath(curPath, mode);
+        } else {
+          fs.chmodSync(curPath, mode);
+        }
+      });
+      fs.chmodSync(path, mode);
+    }
+  };
+}
+
+module.exports = LowdbStorage;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "ee-core",
+  "version": "1.0.0",
+  "description": "electron-egg core",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "bin": {
+    "ee-cli": "bin/tools.js"
+  },
+  "dependencies": {
+    "agentkeepalive": "^4.2.0",
+    "egg-errors": "^2.3.0",
+    "egg-logger": "^2.7.1",
+    "electron-is": "^3.0.0",
+    "electron-updater": "^4.6.1",
+    "get-port": "^5.1.1",
+    "globby": "^10.0.0",
+    "humanize-ms": "^1.2.1",
+    "is-type-of": "^1.2.1",
+    "koa": "^2.13.4",
+    "koa-convert": "^2.0.0",
+    "lodash": "^4.17.21",
+    "lowdb": "^1.0.0",
+    "socket.io": "^4.4.1",
+    "socket.io-client": "^4.4.1",
+    "unzip-crx-3": "^0.2.0",
+    "urllib": "^2.38.0",
+    "utility": "^1.17.0"
+  },
+  "devDependencies": {
+    "debug": "^4.3.3",
+    "fs-extra": "^10.0.0",
+    "uglify-js": "^3.14.5"
+  }
+}