evaengine 1.0.0 → 1.0.2

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;

package/src/services/jwt_token_kong.js

@@ -0,0 +1,75 @@
+import constitute from 'constitute';
+import jwt from 'jwt-simple';
+import _ from 'lodash';
+
+import { RuntimeException } from '../exceptions/index.js';
+import Config from './config.js';
+import RestClient from '../services/rest_client.js';
+import ServiceInterface from './interface.js';
+
+class KongJsonWebToken extends ServiceInterface {
+  /**
+   * @param config {Config}
+   * @param restClient {RestClient}
+   */
+  constructor(config, restClient) {
+    super();
+    this.restClient = restClient;
+    this.config = config.get('token');
+    if (!_.get(this.config, 'kong.endpoint')) {
+      throw new RuntimeException('config item `token.kong.endpoint` can not be null');
+    }
+  }
+
+    getProto() {
+    return jwt;
+  }
+
+  async save(uid, item) {
+    const toSaveItem = Object.assign({ uid }, item);
+    const tokenString = this.encode(toSaveItem);
+    await this.restClient.request({
+      url: `${this.config.kong.endpoint}/rbac/credentials`,
+      method: 'post',
+      body: {
+        custom_id: uid.toString(),
+        username: item.username || null,
+        key: tokenString,
+        expired_at: item.expiredAt ? item.expiredAt * 1000 : null
+      }
+    });
+    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 };
+    }
+    return parsedToken;
+  }
+
+  clear(tokenString) {
+    if (!tokenString) {
+      return true;
+    }
+    return this.restClient.request({
+      url: `${this.config.kong.endpoint}/rbac/credentials/${tokenString}`,
+      method: 'delete'
+    });
+  }
+
+  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, RestClient)(KongJsonWebToken);
+export default KongJsonWebToken;

package/src/services/logger.js

@@ -0,0 +1,148 @@
+import constitute from 'constitute';
+import moment from 'moment-timezone';
+import winston from 'winston';
+import { inspect } from 'util';
+import Env from './env.js';
+import Config from './config.js';
+import Namespace from './namespace.js';
+import ServiceInterface from './interface.js';
+
+
+class Logger extends ServiceInterface {
+  /**
+   * @param env {Env}
+   * @param config {Config}
+   * @param namespace {Namespace}
+   */
+  constructor(env, config, namespace) {
+    super();
+    this.env = env;
+    this.config = config;
+    this.namespace = namespace;
+
+    let level = env.isProduction() ? 'info' : 'debug';
+    if (process.env.LOG_LEVEL) {
+      level = process.env.LOG_LEVEL;
+    }
+    this.level = level;
+    winston.level = level;
+    this.instance = null;
+    this.label = null;
+    this.logfile = null;
+  }
+
+    getProto() {
+    return winston;
+  }
+
+  getWinston() {
+    return winston;
+  }
+
+  setLogFile(logfile) {
+    this.logfile = logfile;
+    return this;
+  }
+
+  setLabel(label) {
+    this.label = label;
+    return this;
+  }
+
+  setLevel(level) {
+    this.level = level;
+    return this;
+  }
+
+  /**
+   * @returns {winston.Logger}
+   */
+  getInstance() {
+    if (this.instance) {
+      return this.instance;
+    }
+    const logPath = this.logfile || this.config.get('logger.file');
+    this.instance = this.factory(logPath);
+    return this.instance;
+  }
+
+  /**
+   * @param logPath
+   * @param key
+   * @param level
+   * @returns {winston.Logger}
+   */
+  factory(logPath, key = 'global', level = this.level) {
+    const timestamp = () => moment().format();
+    return logPath ? winston.createLogger({
+      transports: [
+        new (winston.transports.Console)({
+          name: `${key}-console`,
+          timestamp,
+          level,
+          label: this.label
+        }),
+        new (winston.transports.File)({
+          name: `${key}-file`,
+          timestamp,
+          json: false,
+          level,
+          label: this.label,
+          filename: logPath
+        })
+      ]
+    }) : winston.createLogger({
+      transports: [
+        new (winston.transports.Console)({
+          name: `${key}-console`,
+          timestamp,
+          level,
+          label: this.label,
+          colorize: !this.env.isProduction(),
+          prettyPrint: !this.env.isProduction()
+        })
+      ]
+    });
+  }
+
+  populateTraceId(args) {
+    if (!this.namespace.get('tracer')) {
+      return args;
+    }
+    const { spanId, traceId } = this.namespace.get('tracer') || {};
+    if (spanId) {
+      args.push(spanId);
+    }
+    if (spanId !== traceId) {
+      args.push(traceId);
+    }
+    return args;
+  }
+
+  debug(...args) {
+    return this.getInstance().debug(...this.populateTraceId(args));
+  }
+
+  verbose(...args) {
+    return this.getInstance().verbose(...this.populateTraceId(args));
+  }
+
+  info(...args) {
+    return this.getInstance().info(...this.populateTraceId(args));
+  }
+
+  warn(...args) {
+    return this.getInstance().warn(...this.populateTraceId(args));
+  }
+
+  error(...args) {
+    return this.getInstance().error(...this.populateTraceId(args));
+  }
+
+  dump(obj) {
+    return this.debug(inspect(obj, { depth: null, colors: true }));
+  }
+}
+
+constitute.Dependencies(Env, Config, Namespace)(Logger);
+export default Logger;

package/src/services/namespace.js

@@ -0,0 +1,176 @@
+import constitute from 'constitute';
+import { createNamespace, getNamespace, destroyNamespace, reset } from 'continuation-local-storage';
+import Config from './config.js';
+import { OperationUnsupportedException } from '../exceptions/index.js';
+import ServiceInterface from './interface.js';
+
+const stores = {};
+
+export class Store {
+  get() {
+    return null;
+  }
+
+  set() {
+    return this;
+  }
+
+  bind() {
+    return this;
+  }
+
+  reset() {
+    return this;
+  }
+
+  active() {
+  }
+
+  run(callback) {
+    return callback();
+  }
+
+  bindEmitter() {
+    return this;
+  }
+
+  getContext() {
+    throw new OperationUnsupportedException('Not able to get namespace context when it be disabled');
+  }
+
+  createContext() {
+  }
+}
+
+export class NullStore extends Store {
+}
+
+export class NsStore extends Store {
+  constructor(name) {
+    super();
+    this.name = name;
+    createNamespace(name);
+  }
+
+  get(key) {
+    return getNamespace(this.name).get(key);
+  }
+
+  set(key, value) {
+    getNamespace(this.name).set(key, value);
+    return this;
+  }
+
+  bind(...args) {
+    return getNamespace(this.name).bind(...args);
+  }
+
+  active() {
+    return getNamespace(this.name).active();
+  }
+
+  run(...args) {
+    return getNamespace(this.name).run(...args);
+  }
+
+  bindEmitter(...args) {
+    return getNamespace(this.name).bindEmitter(...args);
+  }
+
+  getContext() {
+    return getNamespace(this.name);
+  }
+
+  createContext() {
+    return getNamespace(this.name).createContext();
+  }
+
+  reset() {
+    reset(this.name);
+    return this;
+  }
+}
+
+class Namespace extends ServiceInterface {
+  /**
+   * @param config {Config}
+   */
+  constructor(config) {
+    super();
+    this.config = config.get('namespace');
+    this.defaultName = config.defaultName || 'eva.ns';
+    this.store = null;
+    this.name = null;
+  }
+
+    isEnabled() {
+    return this.config.enable;
+  }
+
+  getDefaultName() {
+    return this.defaultName;
+  }
+
+  setDefaultName(name) {
+    this.defaultName = name;
+    return this;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  /**
+   * @returns {Store}
+   */
+  getStore() {
+    if ({}.hasOwnProperty.call(stores, this.name)) {
+      return stores[this.name];
+    }
+    stores[this.name] = this.config.enable === true ?
+      new NsStore(this.name) : new NullStore(this.name);
+    return stores[this.name];
+  }
+
+  destroy(name) {
+    destroyNamespace(name);
+    delete stores[name];
+    return this;
+  }
+
+  use(ns) {
+    this.name = ns || this.defaultName;
+    return this.getStore();
+  }
+
+  get(key) {
+    return this.use().get(key);
+  }
+
+  set(key, value) {
+    return this.use().set(key, value);
+  }
+
+  bind(...args) {
+    return this.use().bind(...args);
+  }
+
+  active() {
+    return this.use().active();
+  }
+
+  run(...args) {
+    return this.use().run(...args);
+  }
+
+  bindEmitter(...args) {
+    return this.use().bindEmitter(...args);
+  }
+
+  createContext() {
+    return this.use().createContext();
+  }
+}
+
+constitute.Dependencies(Config)(Namespace);
+export default Namespace;

package/src/services/now.js

@@ -0,0 +1,49 @@
+import constitute from 'constitute';
+import moment from 'moment-timezone';
+import { getTimestamp, getDatabaseDatetime } from '../utils/datetime.js';
+import Logger from './logger.js';
+import ServiceInterface from './interface.js';
+
+class Now extends ServiceInterface {
+  /**
+   * @param {Logger} logger
+   */
+  constructor(logger) {
+    super();
+    this.logger = logger;
+    this.now = null;
+  }
+
+    setNow(now) {
+    if (typeof now === 'number') {
+      this.now = now;
+    } else if (now instanceof moment) {
+      this.now = now.unix();
+    } else {
+      this.now = moment(now).unix();
+    }
+    this.logger.warn('Now has been force changed to %s', moment.unix(this.now));
+    return this;
+  }
+
+  clear() {
+    this.now = null;
+    return this;
+  }
+
+  getTimestamp() {
+    return this.now || getTimestamp();
+  }
+
+  getMoment() {
+    return this.now ? moment.unix(this.now) : moment();
+  }
+
+  getDatabaseDatetime() {
+    return this.now ? moment.unix(this.now).format('YYYY-MM-DD HH:mm:ss') : getDatabaseDatetime();
+  }
+}
+
+constitute.Dependencies(Logger)(Now);
+export default Now;
+

package/src/services/providers.js

@@ -0,0 +1,158 @@
+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 KongJsonWebToken from './jwt_token_kong.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';
+import DI from '../di.js';
+
+export class ServiceProvider {
+  constructor(engine) {
+    this.engine = engine;
+  }
+
+  get name() {
+    return 'default';
+  }
+
+  register() {
+  }
+}
+
+export class EnvProvider extends ServiceProvider {
+  get name() {
+    return 'env';
+  }
+
+  register() {
+    DI.bindClass(this.name, Env);
+  }
+}
+
+export class ConfigProvider extends ServiceProvider {
+  get name() {
+    return 'config';
+  }
+
+  register() {
+    const config = DI.get(Config);
+    config.setPath(this.engine.getMeta().configPath);
+    DI.bindClass(this.name, Config, [config]);
+  }
+}
+
+export class LoggerProvider extends ServiceProvider {
+  get name() {
+    return 'logger';
+  }
+
+  register() {
+    const logger = DI.get(Logger);
+    const { mode } = this.engine.getMeta();
+    const loggerLabel = mode === 'web' ? mode + this.engine.getMeta().port
+      : process.env.CLI_NAME || 'cli';
+    logger.setLabel(loggerLabel);
+    DI.bindClass(this.name, Logger, [logger]);
+  }
+}
+
+export class RedisProvider extends ServiceProvider {
+  get name() {
+    return 'redis';
+  }
+
+  register() {
+    DI.bindClass(this.name, Redis);
+  }
+}
+
+export class JsonWebTokenProvider extends ServiceProvider {
+  get name() {
+    return 'jwt';
+  }
+
+  register() {
+    if (DI.get('config').get('token.provider') === 'kong') {
+      DI.bindClass(this.name, KongJsonWebToken);
+    } else {
+      DI.bindClass(this.name, JsonWebToken);
+    }
+  }
+}
+
+export class HttpClientProvider extends ServiceProvider {
+  get name() {
+    return 'http_client';
+  }
+
+  register() {
+    DI.bindClass(this.name, HttpClient);
+  }
+}
+
+export class RestClientProvider extends ServiceProvider {
+  get name() {
+    return 'rest_client';
+  }
+
+  register() {
+    DI.bindClass(this.name, RestClient);
+  }
+}
+
+export class CacheProvider extends ServiceProvider {
+  get name() {
+    return 'cache';
+  }
+
+  register() {
+    DI.bindClass(this.name, Cache);
+  }
+}
+
+export class NamespaceProvider extends ServiceProvider {
+  get name() {
+    return 'namespace';
+  }
+
+  register() {
+    DI.bindClass(this.name, Namespace);
+  }
+}
+
+export class ValidatorBaseProvider extends ServiceProvider {
+  get name() {
+    return 'validator_base';
+  }
+
+  register() {
+    DI.bindClass(this.name, ValidatorBase);
+  }
+}
+
+export class EventManagerProvider extends ServiceProvider {
+  get name() {
+    return 'event_manager';
+  }
+
+  register() {
+    DI.bindClass(this.name, EventManager);
+  }
+}
+
+export class NowProvider extends ServiceProvider {
+  get name() {
+    return 'now';
+  }
+
+  register() {
+    DI.bindClass(this.name, Now);
+  }
+}