evaengine 0.11.2 → 1.0.1

package/src/middlewares/auth_kong.js

@@ -0,0 +1,28 @@
+import { UnauthorizedException } from '../exceptions/index.js';
+import wrapper from '../utils/wrapper.js';
+
+/**
+ * @returns {function()}
+ * @constructor
+ */
+function AuthKongMiddleware() {
+  return () => wrapper(async (req, res, next) => {
+    if (req.headers['x-anonymous-consumer'] === 'true') {
+      throw new UnauthorizedException('Authentication failed');
+    }
+    const uid = Number.parseInt(req.headers['x-consumer-custom-id'], 10);
+    const mobile = req.headers['x-consumer-custom-username'];
+    if (uid > 0) {
+      res.set('X-Uid', uid);
+      res.set('X-Mobile', mobile);
+      req.auth = {
+        uid,
+        mobile
+      };
+      return next();
+    }
+    throw new UnauthorizedException('Authentication failed, invalid UID');
+  });
+}
+
+export default AuthKongMiddleware;

package/src/middlewares/debug.js

@@ -0,0 +1,88 @@
+import morgan from 'morgan';
+import os from 'os';
+import constitute from 'constitute';
+import Logger from '../services/logger.js';
+
+/**
+ Log format:
+ NCSA Combined Log Format + extended fields
+
+ Nginx config as below
+
+ log_format upstream '$http_x_forwarded_for - $remote_user [$time_local] '
+ '"$request" $status $body_bytes_sent '
+ '"$http_referer" "$http_user_agent" '
+ '"$remote_addr" $host $request_time $upstream_response_time $scheme $server_port '
+ '$hostname $upstream_addr $http_x_device_id $sent_http_x_uid $sent_http_x_token '
+ '$sent_http_x_service_name $sent_http_x_b3_spanid $sent_http_x_b3_traceid '
+ '$sent_http_x_b3_parentspanid $sent_http_x_b3_sampled';
+ */
+
+morgan.token(
+  'host',
+  req =>
+    req.headers.host
+);
+
+morgan.token(
+  'real-ip',
+  req =>
+    req.headers['x-real-ip'] ||
+    req.headers['x-forwarded-for'] ||
+    req.ip ||
+    (req.connection && req.connection.remoteAddress)
+);
+
+morgan.token(
+  'port',
+  req =>
+    (req.headers.host && req.headers.host.split(':')[1]) || -1
+);
+
+const hostname = os.hostname();
+morgan.token('hostname', () => hostname);
+
+morgan.token(
+  'tokens',
+  (req, res) =>
+    [
+      res.getHeader('X-Uid') || '-',
+      res.getHeader('X-Token') || '-'
+    ].join(' ')
+);
+
+morgan.token(
+  'tracer',
+  (req, res) =>
+    [
+      res.getHeader('X-Service-Name') || '-',
+      res.getHeader('X-B3-SpanId') || '-',
+      res.getHeader('X-B3-TraceId') || '-',
+      res.getHeader('X-B3-ParentSpanId') || '-',
+      res.getHeader('X-B3-Sampled') || '-'
+    ].join(' ')
+);
+
+
+/**
+ * @param logger {Logger}
+ * @returns {function()}
+ * @constructor
+ */
+function DebugMiddleware(logger) {
+  return () =>
+    morgan(
+      ':real-ip - :remote-user [:date[clf]] ":method :url HTTP/:http-version" :status :res[content-length] ":referrer" ":user-agent" ' +
+      '":remote-addr" :host :response-time - :http-version :port :hostname - :tokens :tracer %s',
+      {
+        stream: {
+          write: (message) => {
+            logger.info(message);
+          }
+        }
+      }
+    );
+}
+
+constitute.Dependencies(Logger)(DebugMiddleware);
+export default DebugMiddleware;

package/src/middlewares/index.js

@@ -0,0 +1,18 @@
+import AuthMiddleware from './auth.js';
+import AuthKongMiddleware from './auth_kong.js';
+import DebugMiddleware from './debug.js';
+import SessionMiddleware from './session.js';
+import TraceMiddleware from './trace.js';
+import ViewCacheMiddleware from './view_cache.js';
+import ValidatorMiddleware from './validator.js';
+
+export {
+  AuthMiddleware,
+  AuthKongMiddleware,
+  DebugMiddleware,
+  SessionMiddleware,
+  TraceMiddleware,
+  ViewCacheMiddleware,
+  ValidatorMiddleware
+};
+

package/src/middlewares/providers.js

@@ -0,0 +1,73 @@
+import SessionMiddleware from '../middlewares/session.js';
+import AuthMiddleware from '../middlewares/auth.js';
+import AuthKongMiddleware from '../middlewares/auth_kong.js';
+import DebugMiddleware from '../middlewares/debug.js';
+import TraceMiddleware from '../middlewares/trace.js';
+import ViewCacheMiddleware from '../middlewares/view_cache.js';
+import ValidatorMiddleware from '../middlewares/validator.js';
+import DI from '../di.js';
+import { ServiceProvider } from '../services/providers.js';
+
+export class SessionMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'session';
+  }
+
+  register() {
+    DI.bindMethod(this.name, SessionMiddleware);
+  }
+}
+
+export class AuthMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'auth';
+  }
+
+  register() {
+    if (DI.get('config').get('token.provider') === 'kong') {
+      DI.bindMethod(this.name, AuthKongMiddleware);
+    } else {
+      DI.bindMethod(this.name, AuthMiddleware);
+    }
+  }
+}
+
+export class DebugMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'debug';
+  }
+
+  register() {
+    DI.bindMethod(this.name, DebugMiddleware);
+  }
+}
+
+export class ViewCacheMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'view_cache';
+  }
+
+  register() {
+    DI.bindMethod(this.name, ViewCacheMiddleware);
+  }
+}
+
+export class TraceMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'trace';
+  }
+
+  register() {
+    DI.bindMethod(this.name, TraceMiddleware);
+  }
+}
+
+export class ValidatorMiddlewareProvider extends ServiceProvider {
+  get name() {
+    return 'validator';
+  }
+
+  register() {
+    DI.bindMethod(this.name, ValidatorMiddleware);
+  }
+}

package/src/middlewares/session.js

@@ -0,0 +1,58 @@
+import session from 'express-session';
+import { RedisStore } from 'connect-redis';
+import constitute from 'constitute';
+import Config from '../services/config.js';
+import Redis from '../services/redis.js';
+import Namespace from '../services/namespace.js';
+
+let middleware = null;
+
+//Fix issue https://github.com/othiym23/node-continuation-local-storage/issues/29
+const clsifyMiddleware = (fn, ns) =>
+  (req, res, next) =>
+    fn.call(this, req, res, ns.bind(next));
+
+/**
+ * @param _config {Config}
+ * @param redis {Redis}
+ * @param namespace {Namespace}
+ * @returns {function()}
+ * @constructor
+ */
+function SessionMiddleware(_config, redis, namespace) {
+  return () => {
+    if (middleware) {
+      return middleware;
+    }
+    const Store = RedisStore;
+    let store = null;
+    const config = _config.get().session;
+
+    if (config.store) {
+      const RedisClient = new Store(Object.assign({}, config.store, {
+        client: config.store.client || redis.getInstance()
+      }));
+      RedisClient.client.on('error', (err) => {
+        throw err;
+      });
+      store = RedisClient;
+    } else {
+      store = new Store(Object.assign({}, { client: redis.getInstance() }));
+    }
+
+    middleware = session({
+      store,
+      cookie: Object.assign({}, _config.get().cookie),
+      secret: config.secret,
+      resave: config.resave,
+      saveUninitialized: config.saveUninitialized
+    });
+
+    return namespace.isEnabled() ?
+      clsifyMiddleware(middleware, namespace.use().getContext()) :
+      middleware;
+  };
+}
+constitute.Dependencies(Config, Redis, Namespace)(SessionMiddleware);
+
+export default SessionMiddleware;

package/{lib → src}/middlewares/trace.js

@@ -1,39 +1,14 @@
-'use strict';
+import onHeaders from 'on-headers';
+import constitute from 'constitute';
+import { randomString, getHostFullUrl, getHostPort, getHostIp, getMicroTimestamp } from '../utils/index.js';
+import Namespace from '../services/namespace.js';
+import Config from '../services/config.js';
+import Logger from '../services/logger.js';
+import HttpClient from '../services/http_client.js';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.tracerToZipkins = undefined;
+const hostIp = getHostIp();
 
-var _onHeaders = require('on-headers');
-
-var _onHeaders2 = _interopRequireDefault(_onHeaders);
-
-var _constitute = require('constitute');
-
-var _utils = require('../utils');
-
-var _namespace = require('../services/namespace');
-
-var _namespace2 = _interopRequireDefault(_namespace);
-
-var _config = require('../services/config');
-
-var _config2 = _interopRequireDefault(_config);
-
-var _logger = require('../services/logger');
-
-var _logger2 = _interopRequireDefault(_logger);
-
-var _http_client = require('../services/http_client');
-
-var _http_client2 = _interopRequireDefault(_http_client);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const hostIp = (0, _utils.getHostIp)();
-
-const tracerToZipkins = exports.tracerToZipkins = tracer => {
+export const tracerToZipkins = (tracer) => {
   if (!tracer) {
     return false;
   }
@@ -63,34 +38,44 @@ const tracerToZipkins = exports.tracerToZipkins = tracer => {
     name,
     timestamp,
     duration,
-    annotations: [{
-      endpoint,
-      timestamp,
-      value: 'sr'
-    }, {
-      endpoint,
-      timestamp: timestamp + duration,
-      value: 'ss'
-    }],
-    binaryAnnotations: [{
-      key: 'traceId',
-      value: traceId
-    }, {
-      key: 'spanId',
-      value: id
-    }, {
-      key: 'method',
-      value: method
-    }, {
-      key: 'url',
-      value: url
-    }, {
-      key: 'port',
-      value: port.toString()
-    }, {
-      key: 'statusCode',
-      value: statusCode.toString()
-    }]
+    annotations: [
+      {
+        endpoint,
+        timestamp,
+        value: 'sr'
+      },
+      {
+        endpoint,
+        timestamp: timestamp + duration,
+        value: 'ss'
+      }
+    ],
+    binaryAnnotations: [
+      {
+        key: 'traceId',
+        value: traceId
+      },
+      {
+        key: 'spanId',
+        value: id
+      },
+      {
+        key: 'method',
+        value: method
+      },
+      {
+        key: 'url',
+        value: url
+      },
+      {
+        key: 'port',
+        value: port.toString()
+      },
+      {
+        key: 'statusCode',
+        value: statusCode.toString()
+      }
+    ]
   };
 
   if (parentId) {
@@ -99,24 +84,27 @@ const tracerToZipkins = exports.tracerToZipkins = tracer => {
 
   const zipkins = [zipkin];
   if (queries && queries.length > 0) {
-    queries.forEach(element => {
+    queries.forEach((element) => {
       const { query, cost, finishedAt } = element;
       zipkins.push({
-        id: (0, _utils.randomString)(),
+        id: randomString(),
         parentId: id,
         traceId,
         name: 'sequelize',
         timestamp: finishedAt - cost,
         duration: cost,
-        annotations: [{
-          endpoint,
-          timestamp: finishedAt - cost,
-          value: 'cs'
-        }, {
-          endpoint,
-          timestamp: finishedAt,
-          value: 'cr'
-        }],
+        annotations: [
+          {
+            endpoint,
+            timestamp: finishedAt - cost,
+            value: 'cs'
+          },
+          {
+            endpoint,
+            timestamp: finishedAt,
+            value: 'cr'
+          }
+        ],
         binaryAnnotations: [{
           key: 'query',
           value: query
@@ -127,14 +115,15 @@ const tracerToZipkins = exports.tracerToZipkins = tracer => {
   return zipkins;
 };
 
+
 function TraceMiddleware(ns, config, logger, client) {
   const enabled = config.get('trace.enable');
   return name => (req, res, next) => {
-    const spanId = (0, _utils.randomString)();
+    const spanId = randomString();
     const traceId = req.get('X-B3-TraceId') || spanId;
     const parentId = req.get('X-B3-SpanId') || '';
     const startedAt = process.hrtime();
-    const timestamp = (0, _utils.getMicroTimestamp)();
+    const timestamp = getMicroTimestamp();
     const serviceName = name || config.get('app.name');
     //目前默认全部采样
     let sampled = enabled ? 1 : 0;
@@ -145,8 +134,8 @@ function TraceMiddleware(ns, config, logger, client) {
     const tracer = {
       serviceName,
       method: req.method,
-      url: (0, _utils.getHostFullUrl)(req),
-      port: (0, _utils.getHostPort)(req),
+      url: getHostFullUrl(req),
+      port: getHostPort(req),
       spanId,
       traceId,
       parentId,
@@ -164,22 +153,22 @@ function TraceMiddleware(ns, config, logger, client) {
       'X-B3-SpanId': spanId,
       'X-B3-TraceId': traceId,
       'X-B3-ParentSpanId': parentId,
-      'X-B3-Sampled': enabled ? 1 : 0
+      'X-B3-Sampled': sampled
     });
 
     if (sampled < 1) {
-      (0, _onHeaders2.default)(res, () => {
+      onHeaders(res, () => {
         const [seconds, nanoseconds] = process.hrtime(startedAt);
-        const duration = seconds * 1e3 + nanoseconds * 1e-6;
+        const duration = ((seconds * 1e3) + (nanoseconds * 1e-6));
         res.set('X-Response-Milliseconds', parseInt(duration, 10));
       });
       next();
       return;
     }
 
-    (0, _onHeaders2.default)(res, () => {
+    onHeaders(res, () => {
       const [seconds, nanoseconds] = process.hrtime(startedAt);
-      const duration = (seconds * 1e3 + nanoseconds * 1e-6) * 1000;
+      const duration = ((seconds * 1e3) + (nanoseconds * 1e-6)) * 1000;
       tracer.duration = parseInt(duration, 10);
       tracer.statusCode = res.statusCode;
       res.set('X-Response-Milliseconds', tracer.duration / 1000);
@@ -217,7 +206,7 @@ function TraceMiddleware(ns, config, logger, client) {
         url: api,
         method: 'POST',
         json: zipkins
-      }).catch(e => {
+      }).catch((e) => {
         logger.error('Error happened on sending tracing data', e);
       });
     };
@@ -235,7 +224,6 @@ function TraceMiddleware(ns, config, logger, client) {
   };
 }
 
-(0, _constitute.Dependencies)(_namespace2.default, _config2.default, _logger2.default, _http_client2.default)(TraceMiddleware); //eslint-disable-line new-cap
+constitute.Dependencies(Namespace, Config, Logger, HttpClient)(TraceMiddleware);
 
-exports.default = TraceMiddleware;
-//# sourceMappingURL=trace.js.map
+export default TraceMiddleware;

package/src/middlewares/validator.js

@@ -0,0 +1,50 @@
+import Joi from 'joi';
+import constitute from 'constitute';
+import wrapper from '../utils/wrapper.js';
+import { FormInvalidateException } from '../exceptions/index.js';
+import ValidatorBase from '../services/joi.js';
+
+const validate = (data, schema, options) => {
+  const validationOptions = Object.assign(
+    { abortEarly: false, allowUnknown: true },
+    options
+  );
+  if (schema && typeof schema.validateAsync === 'function') {
+    return schema.validateAsync(data, validationOptions);
+  }
+  return new Promise((resolve, reject) => {
+    Joi.validate(data, schema, validationOptions, (err, value) => {
+      if (err) reject(err);
+      else resolve(value);
+    });
+  });
+};
+
+/**
+ * @returns {function()}
+ * @constructor
+ */
+function ValidatorMiddleware(validatorBase) {
+  return (getSchema, options, validator) =>
+    wrapper(async (req, res, next) => {
+      const { query, body, path } = getSchema(validator || validatorBase.getJoi());
+      try {
+        if (query) {
+          await validate(req.query, query, options);
+        }
+        if (body) {
+          await validate(req.body, body, options);
+        }
+        if (path) {
+          await validate(req.params, path, options);
+        }
+        return next();
+      } catch (e) {
+        throw new FormInvalidateException(e);
+      }
+    });
+}
+
+constitute.Dependencies(ValidatorBase)(ValidatorMiddleware);
+
+export default ValidatorMiddleware;

package/src/middlewares/view_cache.js

@@ -0,0 +1,127 @@
+import constitute from 'constitute';
+import crypto from 'crypto';
+import util from 'util';
+import moment from 'moment-timezone';
+import Logger from '../services/logger.js';
+import Cache from '../services/cache.js';
+import wrapper from '../utils/wrapper.js';
+import { RuntimeException } from '../exceptions/index.js';
+
+export const defaultHashStrategy = obj => obj;
+
+export const defaultHeadersFilter = (res) => {
+  const headers = [];
+  ['Content-Type'].forEach((key) => {
+    const value = res.get(key);
+    if (value) {
+      headers.push([key, value]);
+    }
+  });
+  return headers;
+};
+
+export const requestToCacheKey = (req, hashStrategy) => {
+  const {
+    method,
+    originalUrl,
+    query: originQuery,
+    route,
+    uid = null //Custom rule
+  } = req;
+  const query = { ...originQuery };
+  delete query.flush;
+  if (hashStrategy && typeof hashStrategy !== 'function') {
+    throw new RuntimeException(`View cache hash strategy must be a function for ${originalUrl}`);
+  }
+  if (!route) {
+    throw new RuntimeException(`View cache middleware require route for ${originalUrl}`);
+  }
+  if (method.toLowerCase() !== 'get') {
+    throw new RuntimeException(`View cache middleware only support GET method of http request for ${originalUrl}`);
+  }
+  const { host = 'unknown' } = req.headers;
+  const [urlPath = ''] = originalUrl.split('?');
+  const key = [method, `/${host}`, urlPath].join('').replace(/:/g, '_').toLowerCase();
+  const strategy = hashStrategy || defaultHashStrategy;
+  const hash = crypto
+    .createHash('md5')
+    .update(JSON
+      .stringify(strategy({
+        method,
+        urlPath,
+        query,
+        uid
+      })))
+    .digest('hex');
+  return [key, hash].join(':');
+};
+
+
+/**
+ * @param {Cache} cache
+ * @param {Logger} logger
+ * @returns {function(*=)}
+ * @constructor
+ */
+function ViewCacheMiddleware(cache, logger) {
+  return (options = {}) => {
+    if (!util.isObject(options)) {
+      options = {
+        ttl: options
+      };
+    }
+    const {
+      ttl,
+      headersFilter,
+      namespace,
+      hashStrategy
+    } = Object.assign({
+      ttl: 60,
+      headersFilter: defaultHeadersFilter,
+      hashStrategy: defaultHashStrategy,
+      namespace: 'view'
+    }, options);
+    return wrapper(async (req, res, next) => {
+      const cacheKey = requestToCacheKey(req, hashStrategy);
+      const {
+        headers: cachedHeaders = [],
+        body: cachedBody
+      } = await cache.namespace(namespace).get(cacheKey)
+      || {
+        headers: [],
+        body: null
+      };
+      if (req.query.flush !== 'true' && cachedBody) {
+        logger.debug('View cache hit by key %s', cacheKey);
+        if (cachedHeaders.length > 0) {
+          cachedHeaders.forEach(([key, value]) => {
+            res.setHeader(key, value);
+          });
+        }
+        res.setHeader('X-View-Cache-Hit', cacheKey);
+        res.send(cachedBody);
+        return;
+      }
+      res.realSend = res.send;
+      res.send = (body) => {
+        logger.debug('View cache missed by key %s, creating...', cacheKey);
+        res.setHeader('X-View-Cache-Miss', cacheKey);
+        res.setHeader('X-View-Cache-Expire-At', moment().add(ttl, 'minute').format('YYYY-MM-DD HH:mm:ss Z'));
+        res.setHeader('X-View-Cache-Created-At', moment().format('YYYY-MM-DD HH:mm:ss Z'));
+        res.realSend(body);
+        const headers = headersFilter && typeof headersFilter === 'function' ?
+          headersFilter(res) : defaultHeadersFilter(res);
+        if (res.statusCode <= 500) {
+          cache.namespace(namespace).set(cacheKey, { headers, body }, ttl).catch((e) => {
+            logger.error('View cache set failed for %s', cacheKey, e);
+          });
+        }
+      };
+      next();
+    });
+  };
+}
+
+constitute.Dependencies(Cache, Logger)(ViewCacheMiddleware);
+
+export default ViewCacheMiddleware;