evaengine 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evaengine",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "EvaEngine for Node.js, a micro service development engine",
   "license": "MIT",
   "type": "module",
@@ -12,8 +12,7 @@
   "scripts": {
     "prestart": "node src/index.js",
     "prepublish": "npm run test",
-    "ava": "cross-env LOG_LEVEL=error NODE_ENV=test ava --verbose --serial",
-    "test": "nyc -a --reporter=lcov --reporter=text --reporter=html npm run ava",
+    "test": "LOG_LEVEL=error NODE_ENV=test node --import ./test/bootstrap.js --test --test-concurrency=1 --experimental-test-coverage \"test/di.js\" \"test/engine.js\" \"test/error_handlers.js\" \"test/index.js\" \"test/exceptions/index.js\" \"test/entities/index.js\" \"test/commands/make_entity.js\" \"test/middlewares/*.js\" \"test/services/*.js\" \"test/swagger/index.js\" \"test/utils/*.js\"",
     "lint": "eslint src test index.js",
     "build": "node --check src/index.js",
     "ci:check": "npm run lint && npm run build",
@@ -38,31 +37,6 @@
     "lint"
   ],
   "author": "AlloVince",
-  "ava": {
-    "files": [
-      "test/**/*.js",
-      "!test/bootstrap.js",
-      "!test/_*/**/*.js",
-      "!test/swagger/_*/**/*.js"
-    ],
-    "source": [
-      "src/**/*.js"
-    ],
-    "failFast": false,
-    "tap": false,
-    "require": [
-      "./test/bootstrap.js"
-    ]
-  },
-  "nyc": {
-    "require": [],
-    "include": [
-      "src/**/*.js"
-    ],
-    "exclude": [
-      "src/config/index.js"
-    ]
-  },
   "dependencies": {
     "acorn": "^8.18.0",
     "app-root-path": "^3.1.0",
@@ -73,24 +47,15 @@
     "doctrine": "^3.0.0",
     "express": "^5.2.1",
     "express-session": "^1.19.0",
-    "glob": "^13.0.6",
     "ioredis": "^5.11.1",
     "joi": "^18.2.3",
     "js-yaml": "^5.2.2",
     "jwt-simple": "^0.5.6",
-    "later": "^1.2.0",
     "lodash": "^4.18.1",
-    "mkdirp": "^3.0.1",
-    "moment": "^2.30.1",
     "moment-timezone": "^0.6.3",
     "morgan": "^1.11.0",
-    "mysql": "^2.18.1",
     "mysql2": "^3.23.2",
     "node-mocks-http": "~1.18.1",
-    "on-headers": "^1.1.0",
-    "pug": "^3.0.4",
-    "request": "^2.88.2",
-    "request-promise-native": "^1.0.9",
     "sequelize": "^6.37.8",
     "swagger-ui-dist": "^5.32.11",
     "winston": "^3.19.0",
@@ -104,15 +69,10 @@
     "@semantic-release/github": "^11.0.0",
     "@semantic-release/npm": "^12.0.0",
     "@semantic-release/release-notes-generator": "^14.0.0",
-    "ava": "^8.0.1",
     "conventional-changelog-conventionalcommits": "^8.0.0",
-    "cross-env": "^10.1.0",
     "eslint": "^9.39.5",
     "eslint-plugin-import": "^2.32.0",
     "globals": "^17.8.0",
-    "is-type-of": "^2.2.0",
-    "nock": "^14.0.17",
-    "nyc": "^18.0.0",
     "pre-commit": "^2.0.0",
     "semantic-release": "^25.0.8"
   }

package/src/commands/make_entity.js

@@ -1,7 +1,7 @@
-import _ from 'lodash';
+import groupBy from 'lodash/groupBy.js';
+import template from 'lodash/template.js';
 import Sequelize from 'sequelize';
 import fs from 'fs';
-import * as mkdirp from 'mkdirp';
 import Command from './interface.js';
 import DI from '../di.js';
 import Entities from '../entities/index.js';
@@ -55,7 +55,7 @@ CREATE ALGORITHM=UNDEFINED SQL SECURITY DEFINER VIEW view_${tableName}
     const entities = new Entities(entityPath);
 
     logger.info('Start generate db views to %s', file);
-    mkdirp.sync(path);
+    fs.mkdirSync(path, { recursive: true });
     const models = Object.values(entities.getInstance().models);
     const sql = [];
     models.forEach((model) => {
@@ -202,7 +202,7 @@ export class MakeEntity extends Command {
     if (!rawIndexes) {
       return [];
     }
-    rawIndexes = _.groupBy(rawIndexes, 'Key_name');
+    rawIndexes = groupBy(rawIndexes, 'Key_name');
     return Object.entries(rawIndexes).filter(([key]) => key !== 'PRIMARY').map(([name, columns]) => {
       const index = columns[0].Non_unique !== 1 ? { name, unique: true } : { name };
       index.fields = columns.map(c => c.Column_name);
@@ -239,8 +239,8 @@ export class MakeEntity extends Command {
     const schemaPath = `${path}/schemas`;
     const entityTemplate = fs.readFileSync(`${import.meta.dirname}/../../template/entity.ejs`, 'utf8');
     const schemaTemplate = fs.readFileSync(`${import.meta.dirname}/../../template/schema.ejs`, 'utf8');
-    mkdirp.sync(path);
-    mkdirp.sync(schemaPath);
+    fs.mkdirSync(path, { recursive: true });
+    fs.mkdirSync(schemaPath, { recursive: true });
 
     logger.info('Start generate DB schemas to dir %s', path);
 
@@ -269,7 +269,7 @@ export class MakeEntity extends Command {
         fs.accessSync(entityFile);
         logger.info('Entity file %s generate skipped, already exists by %s', table, entityFile);
       } catch {
-        fs.writeFileSync(entityFile, _.template(entityTemplate)({ table }));
+        fs.writeFileSync(entityFile, template(entityTemplate)({ table }));
         logger.info('Entity file %s generated as %s', table, entityFile);
       }
 
@@ -279,7 +279,7 @@ export class MakeEntity extends Command {
       } catch {
         logger.info('Schema file %s generated as %s', table, schemaFile);
       }
-      fs.writeFileSync(schemaFile, _.template(schemaTemplate)({
+      fs.writeFileSync(schemaFile, template(schemaTemplate)({
         columns,
         table,
         indexes,
@@ -438,8 +438,8 @@ export class MakeGraphql extends Command {
     const mappingContent = JSON.parse(fs.readFileSync(mappingFile, 'utf8'));
     const getMappedTableName = tableName =>
       (mappingContent[tableName] ? mappingContent[tableName] : tableName);
-    mkdirp.sync(path);
-    mkdirp.sync(schemaPath);
+    fs.mkdirSync(path, { recursive: true });
+    fs.mkdirSync(schemaPath, { recursive: true });
 
     logger.info('Start generate GraphQL schemas to dir %s', path);
 
@@ -474,7 +474,7 @@ export class MakeGraphql extends Command {
       } catch {
         logger.info('Graphql schema file %s generated as %s', tableName, schemaFile);
       }
-      fs.writeFileSync(schemaFile, _.template(schemaTemplate)({
+      fs.writeFileSync(schemaFile, template(schemaTemplate)({
         tableName,
         mappedTableName,
         columns,

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';
@@ -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)
   );
 };
 

package/src/utils/request_client.js

@@ -0,0 +1,179 @@
+/**
+ * A request-promise-native compatible HTTP client built on the global fetch.
+ *
+ * Keeps the option object and error shape used by the legacy `request`
+ * ecosystem so callers of HttpClient/RestClient see no interface change:
+ * - resolves with the response body (or the full response with
+ *   `resolveWithFullResponse`)
+ * - rejects with an error carrying `.name` (`StatusCodeError`/`RequestError`),
+ *   `.statusCode`, `.response` and `.request`
+ * - supports `url`, `method`, `headers`, `body`, `json`, `qs`, `form`,
+ *   `formData`, `simple`, `resolveWithFullResponse` and `timeout`
+ */
+
+const MAX_BODY_LENGTH = parseInt(process.env.MAX_REQUEST_DEBUG_BODY, 10) || 3000;
+const TOO_LONG_BODY = '____TLDR____';
+
+let debugId = 0;
+
+const toPlainHeaders = (headers = {}) => {
+  const result = {};
+  Object.entries(headers).forEach(([key, value]) => {
+    result[key] = String(value);
+  });
+  return result;
+};
+
+const buildQueryString = (qs) => {
+  if (qs === undefined || qs === null) {
+    return '';
+  }
+  if (typeof qs === 'string') {
+    return qs.startsWith('?') ? qs : `?${qs}`;
+  }
+  return `?${new URLSearchParams(qs).toString()}`;
+};
+
+const buildBody = (params) => {
+  if (params.formData) {
+    const form = new FormData();
+    Object.entries(params.formData).forEach(([key, value]) => {
+      form.append(key, value);
+    });
+    return { body: form, contentType: null };
+  }
+  if (params.form) {
+    return {
+      body: new URLSearchParams(params.form).toString(),
+      contentType: 'application/x-www-form-urlencoded'
+    };
+  }
+  //The legacy `json` option also accepts a value used as the JSON body
+  if (params.json !== undefined && params.json !== false && params.json !== true) {
+    return { body: JSON.stringify(params.json), contentType: 'application/json' };
+  }
+  if (params.json === true && params.body !== undefined) {
+    return { body: JSON.stringify(params.body), contentType: 'application/json' };
+  }
+  return { body: params.body, contentType: null };
+};
+
+const truncateBody = (body) => {
+  if (typeof body !== 'string') {
+    return body ? String(body) : '';
+  }
+  return body.length > MAX_BODY_LENGTH ? TOO_LONG_BODY : body;
+};
+
+/**
+ * Create a request-promise-native compatible callable client.
+ * @param {Logger} [logger] when given, verbose request/response logs are emitted
+ * @returns {function}
+ */
+export const createRequestClient = (logger) => {
+  const request = (params = {}) => new Promise((resolve, reject) => {
+    const {
+      url,
+      method: rawMethod = 'GET',
+      headers = {},
+      resolveWithFullResponse = false,
+      simple = true,
+      timeout = 0,
+      qs
+    } = params;
+
+    const method = String(rawMethod).toUpperCase();
+    const targetUrl = `${url}${buildQueryString(qs)}`;
+    const { body, contentType } = buildBody(params);
+
+    const requestHeaders = toPlainHeaders(headers);
+    if (contentType
+      && !Object.keys(requestHeaders).some(key => key.toLowerCase() === 'content-type')) {
+      requestHeaders['Content-Type'] = contentType;
+    }
+
+    const abortController = new AbortController();
+    const timer = timeout > 0
+      ? setTimeout(() => abortController.abort(new Error('Request timed out')), timeout)
+      : null;
+
+    const requestForDump = {
+      method,
+      uri: {
+        protocol: new URL(targetUrl).protocol,
+        href: targetUrl
+      },
+      headers: requestHeaders,
+      req: {},
+      _json: params.json !== undefined && params.json !== false
+        ? true : body !== undefined,
+      formData: params.formData || null,
+      body: params.formData
+        ? new URLSearchParams(params.formData).toString()
+        : body
+    };
+
+    const id = ++debugId;
+    if (logger) {
+      logger.verbose('[HTTP_REQUEST_%s] [%s %s] [REQ_HEADERS: %s] [REQ_BODY: %s]', id,
+        method, targetUrl, JSON.stringify(requestHeaders), truncateBody(body));
+    }
+
+    fetch(targetUrl, {
+      method,
+      headers: requestHeaders,
+      body,
+      signal: abortController.signal,
+      redirect: 'follow'
+    }).then(async (response) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      const rawBody = await response.text();
+      let parsedBody = rawBody;
+      if (params.json !== undefined && params.json !== false) {
+        try {
+          parsedBody = JSON.parse(rawBody);
+        } catch {
+          parsedBody = rawBody;
+        }
+      }
+
+      const responseForDump = {
+        statusCode: response.status,
+        statusMessage: response.statusText,
+        headers: toPlainHeaders(Object.fromEntries(response.headers.entries())),
+        body: parsedBody,
+        request: requestForDump
+      };
+
+      if (logger) {
+        logger.verbose('[HTTP_RESPONSE_%s] [%s %s] [%s] [RES_HEADERS: %s] [RES_BODY: %s]', id,
+          method, targetUrl, response.status, JSON.stringify(responseForDump.headers),
+          truncateBody(parsedBody));
+      }
+
+      if (response.status >= 400 && simple) {
+        const error = new Error(`Response status ${response.status}`);
+        error.name = 'StatusCodeError';
+        error.statusCode = response.status;
+        error.response = responseForDump;
+        error.request = requestForDump;
+        reject(error);
+        return;
+      }
+
+      resolve(resolveWithFullResponse ? responseForDump : parsedBody);
+    }).catch((err) => {
+      if (timer) {
+        clearTimeout(timer);
+      }
+      const error = new Error(err.message);
+      error.name = 'RequestError';
+      error.request = requestForDump;
+      reject(error);
+    });
+  });
+
+  return request;
+};