evaengine 1.0.2 → 1.0.4

package/src/di.js

@@ -4,6 +4,11 @@ import { ServiceProvider } from './services/providers.js';
 
 let container = new constitute.Container();
 let bound = {};
+let boundKind = {};
+
+const BIND_CLASS = 'class';
+const BIND_VALUE = 'value';
+const BIND_METHOD = 'method';
 
 export default class DI {
   static getContainer() {
@@ -19,15 +24,19 @@ export default class DI {
       return container.constitute(service);
     }
 
-    if (!bound[service]) {
+    if (!Object.prototype.hasOwnProperty.call(bound, service)) {
       throw new RuntimeException(`Service ${service} not bound yet`);
     }
+    if (boundKind[service] === BIND_VALUE) {
+      return bound[service];
+    }
     return container.constitute(bound[service]);
   }
 
   static bindClass(...args) {
     if (typeof args[0] === 'string') {
       [, bound[args[0]]] = args;
+      boundKind[args[0]] = BIND_CLASS;
     }
     return container.bindClass(...args);
   }
@@ -35,6 +44,7 @@ export default class DI {
   static bindValue(...args) {
     if (typeof args[0] === 'string') {
       [, bound[args[0]]] = args;
+      boundKind[args[0]] = BIND_VALUE;
     }
     return container.bindValue(...args);
   }
@@ -42,6 +52,7 @@ export default class DI {
   static bindMethod(...args) {
     if (typeof args[0] === 'string') {
       bound[args[0]] = args[0];
+      boundKind[args[0]] = BIND_METHOD;
     }
     return container.bindMethod(...args);
   }
@@ -49,6 +60,7 @@ export default class DI {
   static reset() {
     container = new constitute.Container();
     bound = {};
+    boundKind = {};
   }
 
   /**

package/src/engine.js

@@ -3,13 +3,13 @@ import http from 'http';
 import https from 'https';
 import path from 'path';
 import yargs from 'yargs/yargs';
-import later from 'later';
 import moment from 'moment-timezone';
 import packageJson from '../package.json' with { type: 'json' };
 import DI from './di.js';
 import * as ServiceProviders from './services/providers.js';
 import * as MiddlewareProviders from './middlewares/providers.js';
 import { StandardException, RuntimeException } from './exceptions/index.js';
+import { parseCron, setCronInterval } from './utils/cron.js';
 
 moment.tz.setDefault(process.env.TZ ? process.env.TZ : 'Asia/Shanghai');
 
@@ -21,8 +21,7 @@ export const MODES = {
 export {
   DI,
   express,
-  yargs,
-  later
+  yargs
 };
 
 let app = null;
@@ -116,7 +115,6 @@ export default class EvaEngine {
     this.namespace = namespace || DI.get('namespace');
     this.logger.info('Engine started, Meta:', this.meta);
     this.logger.debug('Engine config files loaded:', this.config.getMergedFiles());
-    later.date.localTime();
   }
 
   /**
@@ -301,7 +299,11 @@ export default class EvaEngine {
 
   clearCrontabs() {
     this.crontabJobHandlers.forEach((handler) => {
-      clearInterval(handler);
+      if (handler && typeof handler.clear === 'function') {
+        handler.clear();
+      } else {
+        clearInterval(handler);
+      }
     });
     this.crontabJobHandlers = [];
   }
@@ -514,7 +516,8 @@ export default class EvaEngine {
     }
     this.registerServiceProviders(EvaEngine.getServiceProvidersForCLI());
     this.logger.debug('Bound services', Object.keys(DI.getBound()));
-    this.logger.info('Cron job using %s Timezone', later.date.isUTC ? 'UTC' : 'Local');
+    //Cron jobs run in local time, matching the previous later.date.localTime() default
+    this.logger.info('Cron job using %s Timezone', 'Local');
     const [commandName, ...options] = commandString.split(' ');
     if (Object.keys(this.commands).includes(commandName) === false) {
       throw new RuntimeException(`Command ${commandName} not registered`);
@@ -523,14 +526,14 @@ export default class EvaEngine {
     const command = new this.commands[commandName](argv);
 
     let i = 1;
-    const schedule = later.parse.cron(sequence, useSeconds);
-    const handler = later.setInterval(async() => {
+    const schedule = parseCron(sequence, useSeconds);
+    const handler = setCronInterval(async() => {
       this.logger.info('Cron job [%s] | Round %d | started with params %j', commandName, i, argv);
       //Let job crash if any exception happen
       await command.run();
       this.logger.info('Cron job [%s] | Round %d | finished', commandName, i);
       i += 1;
-    }, schedule); //第二个参数为True表示支持秒
+    }, schedule); //useSeconds 为 True 时启用秒级字段
     this.logger.info('Cron job [%s] with sequence [%s] registered as %j', commandString, sequence, schedule);
     this.crontabJobHandlers.push(handler);
   }

package/src/index.js

@@ -1,5 +1,4 @@
 import constitute from 'constitute';
-import * as mysql from 'mysql';
 import sequelize from 'sequelize';
 import Joi from 'joi';
 import EvaEngine, * as engine from './engine.js';
@@ -39,8 +38,7 @@ const core = {
   dependencies: {
     Joi,
     constitute,
-    sequelize,
-    mysql
+    sequelize
   },
   exceptions,
   middlewares,

package/src/middlewares/session.js

@@ -1,6 +1,7 @@
 import session from 'express-session';
 import { RedisStore } from 'connect-redis';
 import constitute from 'constitute';
+import DI from '../di.js';
 import Config from '../services/config.js';
 import Redis from '../services/redis.js';
 import Namespace from '../services/namespace.js';
@@ -33,7 +34,11 @@ function SessionMiddleware(_config, redis, namespace) {
         client: config.store.client || redis.getInstance()
       }));
       RedisClient.client.on('error', (err) => {
-        throw err;
+        try {
+          DI.get('logger').error('Session Redis store error:', err);
+        } catch {
+          console.error('Session Redis store error:', err);
+        }
       });
       store = RedisClient;
     } else {

package/src/middlewares/trace.js

@@ -1,4 +1,3 @@
-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';
@@ -8,6 +7,32 @@ import HttpClient from '../services/http_client.js';
 
 const hostIp = getHostIp();
 
+/**
+ * Execute a listener when a response is about to write headers.
+ * Inlined from the on-headers package (MIT), limited to the behavior trace middleware needs.
+ * @param {object} res
+ * @param {function} listener
+ */
+const onHeaders = (res, listener) => {
+  if (!res) {
+    throw new TypeError('argument res is required');
+  }
+  if (typeof listener !== 'function') {
+    throw new TypeError('argument listener must be a function');
+  }
+
+  const prevWriteHead = res.writeHead;
+  let fired = false;
+
+  res.writeHead = function writeHead() {
+    if (!fired) {
+      fired = true;
+      listener.call(this);
+    }
+    return prevWriteHead.apply(this, arguments);
+  };
+};
+
 export const tracerToZipkins = (tracer) => {
   if (!tracer) {
     return false;

package/src/middlewares/view_cache.js

@@ -24,9 +24,10 @@ export const requestToCacheKey = (req, hashStrategy) => {
     method,
     originalUrl,
     query: originQuery,
-    route,
-    uid = null //Custom rule
+    route
   } = req;
+  //Prefer uid resolved by auth middleware, keep req.uid as custom rule fallback
+  const uid = (req.auth && req.auth.uid) || req.uid || null;
   const query = { ...originQuery };
   delete query.flush;
   if (hashStrategy && typeof hashStrategy !== 'function') {

package/src/services/config.js

@@ -1,4 +1,7 @@
-import _ from 'lodash';
+import get from 'lodash/get.js';
+import isString from 'lodash/isString.js';
+import merge from 'lodash/merge.js';
+import set from 'lodash/set.js';
 import { createRequire } from 'module';
 import constitute from 'constitute';
 import * as springConfigClient from 'cloud-config-client';
@@ -37,7 +40,7 @@ class Config extends ServiceInterface {
     endpoint,
     name,
     profiles,
-    label = 'master'
+    label = 'main'
   }) {
     if (!this.config) {
       this.config = this.loadConfigFromFiles();
@@ -45,11 +48,11 @@ class Config extends ServiceInterface {
     const configRemote = await springConfigClient.load({
       endpoint,
       name,
-      profiles: _.isString(profiles) ? profiles.split(',') : [],
+      profiles: isString(profiles) ? profiles.split(',') : [],
       label
     });
     configRemote.forEach((key, value) => {
-      _.set(this.config, key, value);
+      set(this.config, key, value);
     });
   }
 
@@ -82,7 +85,7 @@ class Config extends ServiceInterface {
     }
 
 
-    return _.merge({}, EngineConfig, configDefault, configEnv, configLocal);
+    return merge({}, EngineConfig, configDefault, configEnv, configLocal);
   }
 
   getMergedFiles() {
@@ -91,6 +94,7 @@ class Config extends ServiceInterface {
 
   reload() {
     this.config = null;
+    this.mergedFiles = [];
   }
 
   /**
@@ -102,7 +106,7 @@ class Config extends ServiceInterface {
     if (typeof keyString !== 'string') {
       return target;
     }
-    return _.get(target, keyString);
+    return get(target, keyString);
   }
 }
 

package/src/services/http_client.js

@@ -1,100 +1,10 @@
 import constitute from 'constitute';
-import request from 'request-promise-native';
 import Config from './config.js';
 import Logger from './logger.js';
+import { createRequestClient } from '../utils/request_client.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}
@@ -103,12 +13,11 @@ class HttpClient extends ServiceInterface {
   constructor(config, logger) {
     super();
     this.config = config.get();
-    this.client = request;
-    requestDebug(logger);
+    this.client = createRequestClient(logger);
   }
 
     getProto() {
-    return request;
+    return this.client;
   }
 
   getInstance() {

package/src/services/jwt_token_kong.js

@@ -1,6 +1,6 @@
 import constitute from 'constitute';
 import jwt from 'jwt-simple';
-import _ from 'lodash';
+import get from 'lodash/get.js';
 
 import { RuntimeException } from '../exceptions/index.js';
 import Config from './config.js';
@@ -16,7 +16,7 @@ class KongJsonWebToken extends ServiceInterface {
     super();
     this.restClient = restClient;
     this.config = config.get('token');
-    if (!_.get(this.config, 'kong.endpoint')) {
+    if (!get(this.config, 'kong.endpoint')) {
       throw new RuntimeException('config item `token.kong.endpoint` can not be null');
     }
   }

package/src/services/redis.js

@@ -1,5 +1,6 @@
 import Ioredis from 'ioredis';
 import constitute from 'constitute';
+import DI from '../di.js';
 import Config from './config.js';
 import ServiceInterface from './interface.js';
 
@@ -45,7 +46,14 @@ class Redis extends ServiceInterface {
     this.client = new Ioredis(Object.assign({
       enableOfflineQueue: true //make redis connect failings throw error
     }, this.options || this.config.get('redis')));
-    this.client.on('error', () => {});
+    this.client.on('error', (err) => {
+      try {
+        DI.get('logger').error('Redis client error:', err);
+      } catch {
+        //Logger not bound yet, keep the error visible on stderr
+        console.error('Redis client error:', err);
+      }
+    });
     return this.client;
   }
 }

package/src/swagger/index.js

@@ -6,7 +6,6 @@ import assert from 'assert';
 import merge from 'lodash/merge.js';
 import * as doctrine from 'doctrine';
 import * as acorn from 'acorn';
-import { glob } from 'glob';
 import * as yaml from 'js-yaml';
 import Entitles from '../entities/index.js';
 import { RuntimeException, StandardException } from '../exceptions/index.js';
@@ -161,10 +160,6 @@ export class Fragment {
       };
     }
 
-    if (!this.isUnknown()) {
-      return {};
-    }
-
     if (this.isException()) {
       if (!this.getParentFragment()) {
         return {};
@@ -417,7 +412,7 @@ export class ExSwagger {
    * @returns {Promise|Array.<string>}
    */
   static async scanFiles(path, options = {}) {
-    return glob(path, options);
+    return fs.globSync(path, options);
   }
 
   /**

package/src/utils/cron.js

@@ -0,0 +1,208 @@
+/**
+ * Minimal cron expression parser and scheduler.
+ * Replaces the unmaintained `later` package with Node built-ins.
+ *
+ * Supports 5-field (minute hour day-of-month month day-of-week) and
+ * 6-field (with a leading seconds) expressions. Each field accepts
+ * wildcard, step, single value, range, range-with-step and
+ * comma-separated lists. All times are interpreted in local time,
+ * matching the previous `later.date.localTime()` default.
+ */
+
+const FIELD_BOUNDS = {
+  second: [0, 59],
+  minute: [0, 59],
+  hour: [0, 23],
+  dayOfMonth: [1, 31],
+  month: [1, 12],
+  dayOfWeek: [0, 7]
+};
+
+const FIELD_ORDER = [
+  'second', 'minute', 'hour', 'dayOfMonth', 'month', 'dayOfWeek'
+];
+
+const parseField = (field, min, max) => {
+  const values = new Set();
+  for (const token of field.split(',')) {
+    if (token === '*') {
+      for (let value = min; value <= max; value += 1) {
+        values.add(value);
+      }
+      continue;
+    }
+    if (token.includes('/')) {
+      const [base, stepToken] = token.split('/');
+      const step = Number.parseInt(stepToken, 10);
+      if (Number.isNaN(step) || step < 1) {
+        throw new Error(`Invalid cron step "${stepToken}" in "${field}"`);
+      }
+      let start = min;
+      let end = max;
+      if (base !== '*') {
+        if (base.includes('-')) {
+          [start, end] = base.split('-').map(v => Number.parseInt(v, 10));
+        } else {
+          start = Number.parseInt(base, 10);
+        }
+      }
+      if (Number.isNaN(start) || start < min || start > max
+        || Number.isNaN(end) || end < min || end > max || start > end) {
+        throw new Error(`Invalid cron value in "${field}"`);
+      }
+      for (let value = start; value <= end; value += step) {
+        values.add(value);
+      }
+      continue;
+    }
+    if (token.includes('-')) {
+      const [start, end] = token.split('-').map(v => Number.parseInt(v, 10));
+      if (Number.isNaN(start) || Number.isNaN(end)
+        || start < min || end > max || start > end) {
+        throw new Error(`Invalid cron range in "${field}"`);
+      }
+      for (let value = start; value <= end; value += 1) {
+        values.add(value);
+      }
+      continue;
+    }
+    const value = Number.parseInt(token, 10);
+    if (Number.isNaN(value) || value < min || value > max) {
+      throw new Error(`Invalid cron value "${token}" in "${field}"`);
+    }
+    values.add(value);
+  }
+  return values;
+};
+
+/**
+ * Parse a cron expression into a schedule of Sets.
+ * @param {string} expression
+ * @param {boolean} [useSeconds=false]
+ * @returns {Object}
+ */
+export const parseCron = (expression, useSeconds = false) => {
+  const parts = String(expression).trim().split(/\s+/);
+  const names = useSeconds ? FIELD_ORDER : FIELD_ORDER.slice(1);
+  if (parts.length !== names.length) {
+    throw new Error(
+      `Cron expression must contain ${names.length} fields, got ${parts.length}: "${expression}"`
+    );
+  }
+  const schedule = {};
+  names.forEach((name, index) => {
+    const [min, max] = FIELD_BOUNDS[name];
+    schedule[name] = parseField(parts[index], min, max);
+  });
+  if (schedule.dayOfWeek) {
+    if (schedule.dayOfWeek.has(7)) {
+      schedule.dayOfWeek.delete(7);
+      schedule.dayOfWeek.add(0);
+    }
+  }
+  return schedule;
+};
+
+const matches = (schedule, date) => {
+  if (schedule.second && !schedule.second.has(date.getSeconds())) {
+    return false;
+  }
+  if (schedule.minute && !schedule.minute.has(date.getMinutes())) {
+    return false;
+  }
+  if (schedule.hour && !schedule.hour.has(date.getHours())) {
+    return false;
+  }
+  if (schedule.dayOfMonth && !schedule.dayOfMonth.has(date.getDate())) {
+    return false;
+  }
+  if (schedule.month && !schedule.month.has(date.getMonth() + 1)) {
+    return false;
+  }
+  if (schedule.dayOfWeek && !schedule.dayOfWeek.has(date.getDay())) {
+    return false;
+  }
+  return true;
+};
+
+/**
+ * Compute the next run date strictly after `from` that matches the schedule.
+ * @param {Object} schedule
+ * @param {Date} [from=new Date()]
+ * @returns {Date}
+ */
+export const getNextRun = (schedule, from = new Date()) => {
+  const stepMs = schedule.second ? 1000 : 60000;
+  let current = new Date(Math.floor(from.getTime() / stepMs) * stepMs + stepMs);
+  const deadline = from.getTime() + 366 * 24 * 3600 * 1000;
+
+  while (current.getTime() <= deadline) {
+    if (matches(schedule, current)) {
+      return current;
+    }
+    //Fast-forward coarse fields so unschedulable expressions stay fast
+    if (schedule.month && !schedule.month.has(current.getMonth() + 1)) {
+      current = new Date(current.getFullYear(), current.getMonth() + 1, 1, 0, 0, 0, 0);
+      continue;
+    }
+    if (schedule.dayOfMonth && !schedule.dayOfMonth.has(current.getDate())) {
+      current.setDate(current.getDate() + 1);
+      current.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (schedule.dayOfWeek && !schedule.dayOfWeek.has(current.getDay())) {
+      current.setDate(current.getDate() + 1);
+      current.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (schedule.hour && !schedule.hour.has(current.getHours())) {
+      current.setHours(current.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+    if (schedule.minute && !schedule.minute.has(current.getMinutes())) {
+      current.setMinutes(current.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    if (schedule.second && !schedule.second.has(current.getSeconds())) {
+      current.setSeconds(current.getSeconds() + 1, 0);
+      continue;
+    }
+    current = new Date(current.getTime() + stepMs);
+  }
+
+  throw new Error('Cron expression has no match within the next year');
+};
+
+const MAX_TIMEOUT = 2147483647;
+
+/**
+ * Run `callback` on `schedule` until the returned handle is cleared.
+ * @param {function} callback
+ * @param {Object} schedule
+ * @returns {{clear: function}}
+ */
+export const setCronInterval = (callback, schedule) => {
+  let timer = null;
+
+  const scheduleNext = () => {
+    const nextRun = getNextRun(schedule, new Date());
+    const delay = Math.max(0, nextRun.getTime() - Date.now());
+    timer = setTimeout(() => {
+      scheduleNext();
+      if (delay <= MAX_TIMEOUT) {
+        callback();
+      }
+    }, Math.min(delay, MAX_TIMEOUT));
+  };
+
+  scheduleNext();
+
+  return {
+    clear() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+  };
+};

package/src/utils/pagination.js

@@ -39,7 +39,7 @@ const toPaginationUrl = (query, req) => {
   }
   return toUrl(
     scheme, host, requestPath,
-    Object.assign(req.query, query)
+    Object.assign({}, req.query, query)
   );
 };