evaengine 1.0.0 → 1.0.1

package/src/services/cache.js

@@ -0,0 +1,223 @@
+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;
+  }
+
+  has() {
+    return Promise.resolve(false);
+  }
+
+  get() {
+    return Promise.resolve(null);
+  }
+
+  set() {
+    return Promise.resolve(this);
+  }
+
+  del() {
+    return Promise.resolve(this);
+  }
+
+  flush() {
+    return Promise.resolve(true);
+  }
+
+  tags() {
+    throw new OperationUnsupportedException('Not support tag feature');
+  }
+}
+
+export class NullStore extends Store {
+  namespace() {
+    return this;
+  }
+
+  tags() {
+    return this;
+  }
+}
+
+export class RedisNamespaceStore extends Store {
+  constructor(prefix, namespace, redis) {
+    super();
+    this.prefix = prefix;
+    this.namespace = namespace;
+    this.redis = redis;
+  }
+
+  getInstance() {
+    return this.redis;
+  }
+
+  has(key) {
+    return this.redis.exists(this.key(key)).then(res => res > 0);
+  }
+
+  key(key) {
+    return this.prefix ? [this.prefix, this.namespace, key].join(':') : key;
+  }
+
+  get(key) {
+    return this.redis.get(this.key(key)).then(res => JSON.parse(res));
+  }
+
+  del(key) {
+    return this.redis.del(this.key(key));
+  }
+
+  set(key, value, minutes, mutex) {
+    const args = [
+      this.key(key),
+      JSON.stringify(value)
+    ];
+    if (minutes) {
+      args.push('ex', minutes * 60);
+    }
+    if (mutex) {
+      const m = mutex.toUpperCase();
+      if (m === 'NX' || m === 'XX') {
+        args.push(m);
+      }
+    }
+    return this.redis.set(...args);
+  }
+
+  flush() {
+    return this.redis.keys([this.prefix, this.namespace, '*'].join(':'))
+      .then((keys) => {
+        if (keys.length) {
+          return this.redis.del(keys);
+        }
+        return 0;
+      });
+  }
+}
+
+export class RedisStore extends Store {
+  constructor(prefix, redis) {
+    super();
+    this.prefix = prefix;
+    this.namespaceHandler = {};
+    this.redis = redis || DI.get('redis').getInstance();
+  }
+
+  getInstance() {
+    return this.redis;
+  }
+
+  namespace(namespace) {
+    if ({}.hasOwnProperty.call(this.namespaceHandler, namespace)) {
+      return this.namespaceHandler[namespace];
+    }
+    this.namespaceHandler[namespace] = new RedisNamespaceStore(this.prefix, namespace, this.redis);
+    return this.namespaceHandler[namespace];
+  }
+
+  has(key) {
+    return this.redis.exists(this.key(key));
+  }
+
+  key(key) {
+    return this.prefix ? [this.prefix, key].join(':') : key;
+  }
+
+  get(key) {
+    return this.redis.get(this.key(key)).then(res => JSON.parse(res));
+  }
+
+  del(key) {
+    return this.redis.del(this.key(key));
+  }
+
+  set(key, value, minutes, mutex) {
+    const args = [
+      this.key(key),
+      JSON.stringify(value)
+    ];
+    if (minutes) {
+      args.push('ex', minutes * 60);
+    }
+    if (mutex) {
+      const m = mutex.toUpperCase();
+      if (m === 'NX' || m === 'XX') {
+        args.push(m);
+      }
+    }
+    return this.redis.set(...args);
+  }
+
+  flush() {
+    return this.redis.flushall();
+  }
+}
+
+class Cache extends ServiceInterface {
+  constructor(config) {
+    super();
+    this.config = config.get('cache');
+    this.prefix = this.config.prefix || 'eva';
+    this.driver = this.config.driver;
+    this.store = null;
+  }
+
+    setStore(store) {
+    this.store = store;
+    return this;
+  }
+
+  /**
+   * @returns {Store}
+   */
+  getStore() {
+    if (this.store) {
+      return this.store;
+    }
+    this.store = this.driver === 'redis' ?
+      new RedisStore(this.prefix) : new NullStore(this.prefix);
+    return this.store;
+  }
+
+  setPrefix(prefix) {
+    this.prefix = prefix;
+  }
+
+  getPrefix() {
+    return this.prefix;
+  }
+
+  namespace(...args) {
+    return this.getStore().namespace(...args);
+  }
+
+  has(key) {
+    return this.getStore().has(key);
+  }
+
+  get(key) {
+    return this.getStore().get(key);
+  }
+
+  set(...args) {
+    return this.getStore().set(...args);
+  }
+
+  del(...args) {
+    return this.getStore().del(...args);
+  }
+
+  flush() {
+    return this.getStore().flush();
+  }
+}
+
+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;
+  }
+}
+