evaengine 0.11.2 → 1.0.1

package/{lib → src}/services/cache.js

@@ -1,35 +1,11 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.RedisStore = exports.RedisNamespaceStore = exports.NullStore = exports.Store = undefined;
-
-var _dec, _class;
-
-var _constitute = require('constitute');
-
-var _exceptions = require('./../exceptions');
-
-var _redis = require('./redis');
-
-var _redis2 = _interopRequireDefault(_redis);
-
-var _di = require('./../di');
-
-var _di2 = _interopRequireDefault(_di);
-
-var _config = require('./config');
-
-var _config2 = _interopRequireDefault(_config);
-
-var _interface = require('./interface');
-
-var _interface2 = _interopRequireDefault(_interface);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-let Store = exports.Store = class Store {
+import constitute from 'constitute';
+import { OperationUnsupportedException } from './../exceptions/index.js';
+import Redis from './redis.js';
+import DI from './../di.js';
+import Config from './config.js';
+import ServiceInterface from './interface.js';
+
+export class Store {
   getInstance() {
     return this;
   }
@@ -55,10 +31,11 @@ let Store = exports.Store = class Store {
   }
 
   tags() {
-    throw new _exceptions.UnsupportedOperationException('Not support tag feature');
+    throw new OperationUnsupportedException('Not support tag feature');
   }
-};
-let NullStore = exports.NullStore = class NullStore extends Store {
+}
+
+export class NullStore extends Store {
   namespace() {
     return this;
   }
@@ -66,8 +43,9 @@ let NullStore = exports.NullStore = class NullStore extends Store {
   tags() {
     return this;
   }
-};
-let RedisNamespaceStore = exports.RedisNamespaceStore = class RedisNamespaceStore extends Store {
+}
+
+export class RedisNamespaceStore extends Store {
   constructor(prefix, namespace, redis) {
     super();
     this.prefix = prefix;
@@ -96,7 +74,10 @@ let RedisNamespaceStore = exports.RedisNamespaceStore = class RedisNamespaceStor
   }
 
   set(key, value, minutes, mutex) {
-    const args = [this.key(key), JSON.stringify(value)];
+    const args = [
+      this.key(key),
+      JSON.stringify(value)
+    ];
     if (minutes) {
       args.push('ex', minutes * 60);
     }
@@ -110,20 +91,22 @@ let RedisNamespaceStore = exports.RedisNamespaceStore = class RedisNamespaceStor
   }
 
   flush() {
-    return this.redis.keys([this.prefix, this.namespace, '*'].join(':')).then(keys => {
-      if (keys.length) {
-        return this.redis.del(keys);
-      }
-      return 0;
-    });
+    return this.redis.keys([this.prefix, this.namespace, '*'].join(':'))
+      .then((keys) => {
+        if (keys.length) {
+          return this.redis.del(keys);
+        }
+        return 0;
+      });
   }
-};
-let RedisStore = exports.RedisStore = class RedisStore extends Store {
+}
+
+export class RedisStore extends Store {
   constructor(prefix, redis) {
     super();
     this.prefix = prefix;
     this.namespaceHandler = {};
-    this.redis = redis || _di2.default.get('redis').getInstance();
+    this.redis = redis || DI.get('redis').getInstance();
   }
 
   getInstance() {
@@ -155,7 +138,10 @@ let RedisStore = exports.RedisStore = class RedisStore extends Store {
   }
 
   set(key, value, minutes, mutex) {
-    const args = [this.key(key), JSON.stringify(value)];
+    const args = [
+      this.key(key),
+      JSON.stringify(value)
+    ];
     if (minutes) {
       args.push('ex', minutes * 60);
     }
@@ -171,9 +157,9 @@ let RedisStore = exports.RedisStore = class RedisStore extends Store {
   flush() {
     return this.redis.flushall();
   }
-};
-//eslint-disable-line new-cap
-let Cache = (_dec = (0, _constitute.Dependencies)(_config2.default, _redis2.default), _dec(_class = class Cache extends _interface2.default {
+}
+
+class Cache extends ServiceInterface {
   constructor(config) {
     super();
     this.config = config.get('cache');
@@ -182,7 +168,7 @@ let Cache = (_dec = (0, _constitute.Dependencies)(_config2.default, _redis2.defa
     this.store = null;
   }
 
-  setStore(store) {
+    setStore(store) {
     this.store = store;
     return this;
   }
@@ -194,7 +180,8 @@ let Cache = (_dec = (0, _constitute.Dependencies)(_config2.default, _redis2.defa
     if (this.store) {
       return this.store;
     }
-    this.store = this.driver === 'redis' ? new RedisStore(this.prefix) : new NullStore(this.prefix);
+    this.store = this.driver === 'redis' ?
+      new RedisStore(this.prefix) : new NullStore(this.prefix);
     return this.store;
   }
 
@@ -229,6 +216,8 @@ let Cache = (_dec = (0, _constitute.Dependencies)(_config2.default, _redis2.defa
   flush() {
     return this.getStore().flush();
   }
-}) || _class);
-exports.default = Cache;
-//# sourceMappingURL=cache.js.map
+}
+
+constitute.Dependencies(Config, Redis)(Cache);
+export default Cache;
+

package/src/services/config.js

@@ -0,0 +1,111 @@
+import _ from 'lodash';
+import { createRequire } from 'module';
+import constitute from 'constitute';
+import * as springConfigClient from 'cloud-config-client';
+import Env from './env.js';
+import EngineConfig from '../config/index.js';
+import ServiceInterface from './interface.js';
+
+const require = createRequire(import.meta.url);
+
+class Config extends ServiceInterface {
+  /**
+   * @param env {Env}
+   */
+  constructor(env) {
+    super();
+    this.env = env;
+    this.path = null;
+    this.mergedFiles = [];
+    this.config = null;
+  }
+
+    setPath(path) {
+    this.path = path;
+    return this;
+  }
+
+  /**
+   * Resolve configurations from Spring Cloud Config Server.
+   * @param endpoint
+   * @param name
+   * @param profiles
+   * @param label
+   * @returns {Promise.<void>}
+   */
+  async resolveSpringConfig({
+    endpoint,
+    name,
+    profiles,
+    label = 'master'
+  }) {
+    if (!this.config) {
+      this.config = this.loadConfigFromFiles();
+    }
+    const configRemote = await springConfigClient.load({
+      endpoint,
+      name,
+      profiles: _.isString(profiles) ? profiles.split(',') : [],
+      label
+    });
+    configRemote.forEach((key, value) => {
+      _.set(this.config, key, value);
+    });
+  }
+
+  get(key) {
+    if (this.config) {
+      return key ? Config.search(key, this.config) : this.config;
+    }
+    this.config = this.loadConfigFromFiles();
+    return key ? Config.search(key, this.config) : this.config;
+  }
+
+  loadConfigFromFiles() {
+    const env = this.env.get();
+    const configPath = this.path;
+    const pathDefault = `${configPath}/config.default.cjs`;
+    const pathEnv = `${configPath}/config.${env}.cjs`;
+    const pathLocal = `${configPath}/config.local.${env}.cjs`;
+
+
+    const configDefault = require(pathDefault);
+    this.mergedFiles.push(pathDefault);
+    const configEnv = require(pathEnv);
+    this.mergedFiles.push(pathEnv);
+    let configLocal = {};
+    try {
+      configLocal = require(pathLocal);
+      this.mergedFiles.push(pathLocal);
+    } catch {
+      configLocal = {};
+    }
+
+
+    return _.merge({}, EngineConfig, configDefault, configEnv, configLocal);
+  }
+
+  getMergedFiles() {
+    return this.mergedFiles;
+  }
+
+  reload() {
+    this.config = null;
+  }
+
+  /**
+   * @param {string} keyString
+   * @param {Object} target
+   * @returns {*}
+   */
+  static search(keyString, target) {
+    if (typeof keyString !== 'string') {
+      return target;
+    }
+    return _.get(target, keyString);
+  }
+}
+
+constitute.Dependencies(Env)(Config);
+export default Config;
+

package/src/services/env.js

@@ -0,0 +1,28 @@
+import ServiceInterface from './interface.js';
+
+let env = null;
+export const TYPES = {
+  PRODUCTION: 'production',
+  TEST: 'test',
+  DEVELOPMENT: 'development'
+};
+
+export default class Env extends ServiceInterface {
+  get() {
+    env = [TYPES.PRODUCTION, TYPES.TEST, TYPES.DEVELOPMENT].indexOf(process.env.NODE_ENV) > -1
+      ? process.env.NODE_ENV : TYPES.DEVELOPMENT;
+    return env;
+  }
+
+  isTest() {
+    return this.get() === TYPES.TEST;
+  }
+
+  isProduction() {
+    return this.get() === TYPES.PRODUCTION;
+  }
+
+  isDevelopment() {
+    return this.get() === TYPES.DEVELOPMENT;
+  }
+}

package/src/services/event_manager.js

@@ -0,0 +1,84 @@
+import constitute from 'constitute';
+import EventEmitter from 'events';
+import camelCase from 'lodash/camelCase.js';
+import { RuntimeException } from '../exceptions/index.js';
+import Logger from './logger.js';
+import ServiceInterface from './interface.js';
+
+/**
+ * A strict version of EventEmitter
+ * 1. listener must be a standard class
+ * 2. unregistered event not allow to emit
+ * 3. all events register and trigger will be recorded
+ */
+class EventManager extends ServiceInterface {
+  constructor(logger) {
+    super();
+    this.logger = logger;
+    this.emitter = new EventEmitter();
+    this.events = new Set();
+  }
+
+    getProto() {
+    return EventEmitter;
+  }
+
+  getAllowEvents() {
+    return this.events;
+  }
+
+  getEmitter() {
+    //TODO: 屏蔽写入
+    return this.emitter;
+  }
+
+  /**
+   * Allow to register a class such like
+   * class Foo { get prefix(){ return 'foo'} get actions() { return ['bar']} }
+   * @param ListenerClass
+   * @returns {EventManager}
+   */
+  addListener(ListenerClass) {
+    if (typeof ListenerClass !== 'function') {
+      throw new RuntimeException('Not a standard listener input');
+    }
+    const listener = new ListenerClass();
+    const { prefix, actions } = listener;
+    if (!prefix || !actions) {
+      throw new RuntimeException('Not a standard listener input');
+    }
+
+    const events = {};
+    const eventsCount = this.events.size;
+    for (const action of actions) {
+      events[[prefix, action, 'before'].join(':')] = camelCase(['before', action].join('_'));
+      events[[prefix, action, 'after'].join(':')] = camelCase(['after', action].join('_'));
+    }
+
+    //TODO: 用Set保存注册的事件
+    for (const [eventName, callback] of Object.entries(events)) {
+      this.events.add(eventName);
+      if (Reflect.has(listener, callback) === false) {
+        continue;
+      }
+      this.emitter.addListener(eventName, listener[callback]);
+    }
+
+    if (eventsCount + Object.keys(events).length !== this.events.size) {
+      throw new RuntimeException('Repeated event name has been registered, please check');
+    }
+
+    // this.logger.debug('Registered events', this.emitter.eventNames());
+    return this;
+  }
+
+  emit(eventName, callback) {
+    if (!this.events.has(eventName)) {
+      throw new RuntimeException(`Event ${eventName} not registered yet`);
+    }
+    return this.emitter.emit(eventName, callback);
+  }
+}
+
+constitute.Dependencies(Logger)(EventManager);
+export default EventManager;

package/src/services/http_client.js

@@ -0,0 +1,160 @@
+import constitute from 'constitute';
+import request from 'request-promise-native';
+import Config from './config.js';
+import Logger from './logger.js';
+import { HttpRequestLogicException, HttpRequestIOException } from '../exceptions/index.js';
+import ServiceInterface from './interface.js';
+
+export const deepClone = obj =>
+  JSON.parse(JSON.stringify(obj));
+
+const TOO_LONG_BODY = '____TLDR____';
+
+let debugFlag = false;
+/* eslint-disable */
+//Mod version of https://github.com/request/request-debug
+export const requestDebug = (logger, maxBodyLength = process.env.MAX_REQUEST_DEBUG_BODY || 3000) => {
+  if (debugFlag === true) {
+    return;
+  }
+
+  let proto = {};
+  let debugId = 0;
+  if (request.Request) {
+    proto = request.Request.prototype;
+  } else if (request.get && request.post) {
+    // The object returned by request.defaults() doesn't include the
+    // Request property, so do this horrible thing to get at it.  Per
+    // Wikipedia, port 4 is unassigned.
+    const req = request('http://localhost:4').on('error', () => {
+    });
+    proto = req.constructor.prototype;
+  } else {
+    throw new Error('Pass the object returned by require("request") to this function.');
+  }
+  if (proto._initBeforeDebug) {
+    return;
+  }
+
+  proto._initBeforeDebug = proto.init;
+
+  const ignoreDebug = (headers) => {
+    if (!headers || Object.keys(headers).length < 1) {
+      return {};
+    }
+    return Object.keys(headers)
+      .filter(key => !key.startsWith('x-debug'))
+      .reduce((res, key) => (res[key] = headers[key], res), {});
+  };
+
+  proto.init = function () {
+    if (this._debugId) {
+      return;
+    }
+    this.on('request', function (req) {
+      const data = {
+        headers: deepClone(this.headers)
+      };
+      if (this.body) {
+        data.body = maxBodyLength > 0 && this.body.toString().length < maxBodyLength ? this.body.toString('utf8') : TOO_LONG_BODY;
+      }
+
+      logger.verbose('[HTTP_REQUEST_%s] [%s %s] [REQ_HEADERS: %s] [REQ_BODY: %s]', this._debugId,
+        this.method.toUpperCase(), this.uri.href, JSON.stringify(data.headers), data.body || ''
+      );
+    }).on('response', function (res) {
+      if (this.callback) {
+        return;
+      }
+
+      const bodyLength = res.headers['content-length'] || (res.body ? res.body.toString().length : 0);
+      logger.verbose('[HTTP_RESPONSE_%s] [%s %s] [%s] [RES_HEADERS: %s] [RES_BODY: %s]', this._debugId,
+        this.method.toUpperCase(), this.uri.href, res.statusCode, JSON.stringify(ignoreDebug(res.headers)),
+        bodyLength > maxBodyLength ? TOO_LONG_BODY : res.body || ''
+      );
+    }).on('complete', function (res) {
+      if (!this.callback) {
+        return;
+      }
+
+      const bodyLength = res.headers['content-length'] || (res.body ? res.body.toString().length : 0);
+      logger.verbose('[HTTP_RESPONSE_%s] [%s %s] [%s] [RES_HEADERS: %s] [RES_BODY: %s]', this._debugId,
+        this.method.toUpperCase(), this.uri.href, res.statusCode, JSON.stringify(ignoreDebug(res.headers)),
+        bodyLength > maxBodyLength ? TOO_LONG_BODY : res.body || ''
+      );
+    }).on('redirect', function () {
+
+      logger.verbose('[HTTP_REDIRECT_%s] [%s %s] [%s] [RES_HEADERS: %s] [RES_BODY: %s]', this._debugId,
+        this.method.toUpperCase(), this.uri.href, this.response.statusCode, JSON.stringify(ignoreDebug(this.response.headers)), '');
+    });
+    this._debugId = ++debugId;
+    return proto._initBeforeDebug.apply(this, arguments);
+  };
+
+  debugFlag = true;
+};
+/* eslint-enable */
+
+class HttpClient extends ServiceInterface {
+  /**
+   * @param config {Config}
+   * @param logger {Logger}
+   */
+  constructor(config, logger) {
+    super();
+    this.config = config.get();
+    this.client = request;
+    requestDebug(logger);
+  }
+
+    getProto() {
+    return request;
+  }
+
+  getInstance() {
+    return this.client;
+  }
+
+  async request(params) {
+    try {
+      return await this.client(params);
+    } catch (e) {
+      const { statusCode } = e;
+      if (statusCode && statusCode >= 400 && statusCode < 500) {
+        throw new HttpRequestLogicException(e);
+      }
+      throw new HttpRequestIOException(e);
+    }
+  }
+
+  dumpRequest(req, asString = false) {
+    const getBody = (r) => {
+      if (r._json) {
+        return r.body;
+      }
+      return r.form(r.formData).body;
+    };
+    const dump = {
+      method: req.method,
+      protocol: req.uri && req.uri.protocol === 'https:' ? 'https' : 'http',
+      url: req.uri ? req.uri.href : null,
+      headers: req.headers,
+      body: req.req && (req._json || req.formData)
+        ? getBody(req) : null
+    };
+    return asString === true ? JSON.stringify(dump) : dump;
+  }
+
+  dumpResponse(res, asString = false) {
+    const dump = {
+      statusCode: res.statusCode,
+      statusMessage: res.statusMessage,
+      headers: res.headers,
+      body: res.body
+    };
+    return asString === true ? JSON.stringify(dump) : dump;
+  }
+}
+
+constitute.Dependencies(Config, Logger)(HttpClient);
+export default HttpClient;

package/src/services/index.js

@@ -0,0 +1,27 @@
+import Cache from './cache.js';
+import Config from './config.js';
+import Env from './env.js';
+import HttpClient from './http_client.js';
+import JsonWebToken from './jwt_token.js';
+import Logger from './logger.js';
+import Redis from './redis.js';
+import RestClient from './rest_client.js';
+import Namespace from './namespace.js';
+import Now from './now.js';
+import ValidatorBase from './joi.js';
+import EventManager from './event_manager.js';
+
+export {
+  Cache,
+  Config,
+  Env,
+  HttpClient,
+  JsonWebToken,
+  Logger,
+  Redis,
+  RestClient,
+  Namespace,
+  Now,
+  ValidatorBase,
+  EventManager
+};

package/src/services/interface.js

@@ -0,0 +1,5 @@
+export default class ServiceInterface {
+  getProto() {
+    return {};
+  }
+}

package/src/services/joi.js

@@ -0,0 +1,13 @@
+import Joi from 'joi';
+import ServiceInterface from './interface.js';
+
+export default class ValidatorBase extends ServiceInterface {
+  getProto() {
+    return Joi;
+  }
+
+  getJoi() {
+    return Joi;
+  }
+}
+

package/src/services/jwt_token.js

@@ -0,0 +1,89 @@
+import constitute from 'constitute';
+import jwt from 'jwt-simple';
+import Config from './config.js';
+import Redis from './redis.js';
+import ServiceInterface from './interface.js';
+
+class JsonWebToken extends ServiceInterface {
+  /**
+   * @param config {Config}
+   * @param redis {Redis}
+   */
+  constructor(config, redis) {
+    super();
+    this.redis = redis.getInstance();
+    this.config = config.get('token');
+  }
+
+    getProto() {
+    return jwt;
+  }
+
+  getRedis() {
+    return this.redis;
+  }
+
+  getPrefix() {
+    return this.config.prefix;
+  }
+
+  async save(uid, item) {
+    const toSaveItem = Object.assign({ uid }, item);
+    const tokenString = this.encode(toSaveItem);
+    const key = [this.getPrefix(), uid, tokenString.split('.').pop()].join(':');
+    //TODO 过期时间
+    await this.getRedis().set(key, JSON.stringify(toSaveItem));
+    return tokenString;
+  }
+
+  async find(tokenString) {
+    if (!tokenString) {
+      return { uid: null, expiredAt: 0 };
+    }
+    const parsedToken = this.decode(tokenString);
+    if (!parsedToken || !{}.hasOwnProperty.call(parsedToken, 'uid')) {
+      return { uid: null, expiredAt: 0 };
+    }
+    const key = [this.getPrefix(), parsedToken.uid, tokenString.split('.').pop()].join(':');
+    const storedToken = await this.redis.get(key);
+    if (!storedToken) {
+      return {
+        uid: parsedToken.uid,
+        expiredAt: 0
+      };
+    }
+    return JSON.parse(storedToken);
+  }
+
+  clear(tokenString) {
+    if (!tokenString) {
+      return true;
+    }
+    const key = this.getRedisKey(tokenString);
+    if (!key) {
+      return true;
+    }
+    return this.redis.del(key);
+  }
+
+  getRedisKey(tokenString, groupOnly = false) {
+    const parsedToken = this.decode(tokenString);
+    if (!parsedToken || !{}.hasOwnProperty.call(parsedToken, 'uid')) {
+      return '';
+    }
+    return groupOnly === true ?
+      [this.getPrefix(), parsedToken.uid].join(':') :
+      [this.getPrefix(), parsedToken.uid, tokenString.split('.').pop()].join(':');
+  }
+
+  encode(item, secret = this.config.secret) {
+    return jwt.encode(item, secret);
+  }
+
+  decode(str, secret = this.config.secret) {
+    return jwt.decode(str, secret);
+  }
+}
+
+constitute.Dependencies(Config, Redis)(JsonWebToken);
+export default JsonWebToken;