@depup/rate-limiter-flexible 9.1.1-depup.0

package/lib/RLWrapperBlackAndWhite.js

@@ -0,0 +1,195 @@
+const RateLimiterRes = require('./RateLimiterRes');
+
+module.exports = class RLWrapperBlackAndWhite {
+  constructor(opts = {}) {
+    this.limiter = opts.limiter;
+    this.blackList = opts.blackList;
+    this.whiteList = opts.whiteList;
+    this.isBlackListed = opts.isBlackListed;
+    this.isWhiteListed = opts.isWhiteListed;
+    this.runActionAnyway = opts.runActionAnyway;
+  }
+
+  get limiter() {
+    return this._limiter;
+  }
+
+  set limiter(value) {
+    if (typeof value === 'undefined') {
+      throw new Error('limiter is not set');
+    }
+
+    this._limiter = value;
+  }
+
+  get runActionAnyway() {
+    return this._runActionAnyway;
+  }
+
+  set runActionAnyway(value) {
+    this._runActionAnyway = typeof value === 'undefined' ? false : value;
+  }
+
+  get blackList() {
+    return this._blackList;
+  }
+
+  set blackList(value) {
+    this._blackList = Array.isArray(value) ? value : [];
+  }
+
+  get isBlackListed() {
+    return this._isBlackListed;
+  }
+
+  set isBlackListed(func) {
+    if (typeof func === 'undefined') {
+      func = () => false;
+    }
+    if (typeof func !== 'function') {
+      throw new Error('isBlackListed must be function');
+    }
+    this._isBlackListed = func;
+  }
+
+  get whiteList() {
+    return this._whiteList;
+  }
+
+  set whiteList(value) {
+    this._whiteList = Array.isArray(value) ? value : [];
+  }
+
+  get isWhiteListed() {
+    return this._isWhiteListed;
+  }
+
+  set isWhiteListed(func) {
+    if (typeof func === 'undefined') {
+      func = () => false;
+    }
+    if (typeof func !== 'function') {
+      throw new Error('isWhiteListed must be function');
+    }
+    this._isWhiteListed = func;
+  }
+
+  isBlackListedSomewhere(key) {
+    return this.blackList.indexOf(key) >= 0 || this.isBlackListed(key);
+  }
+
+  isWhiteListedSomewhere(key) {
+    return this.whiteList.indexOf(key) >= 0 || this.isWhiteListed(key);
+  }
+
+  getBlackRes() {
+    return new RateLimiterRes(0, Number.MAX_SAFE_INTEGER, 0, false);
+  }
+
+  getWhiteRes() {
+    return new RateLimiterRes(Number.MAX_SAFE_INTEGER, 0, 0, false);
+  }
+
+  rejectBlack() {
+    return Promise.reject(this.getBlackRes());
+  }
+
+  resolveBlack() {
+    return Promise.resolve(this.getBlackRes());
+  }
+
+  resolveWhite() {
+    return Promise.resolve(this.getWhiteRes());
+  }
+
+  consume(key, pointsToConsume = 1) {
+    let res;
+    if (this.isWhiteListedSomewhere(key)) {
+      res = this.resolveWhite();
+    } else if (this.isBlackListedSomewhere(key)) {
+      res = this.rejectBlack();
+    }
+
+    if (typeof res === 'undefined') {
+      return this.limiter.consume(key, pointsToConsume);
+    }
+
+    if (this.runActionAnyway) {
+      this.limiter.consume(key, pointsToConsume).catch(() => {});
+    }
+    return res;
+  }
+
+  block(key, secDuration) {
+    let res;
+    if (this.isWhiteListedSomewhere(key)) {
+      res = this.resolveWhite();
+    } else if (this.isBlackListedSomewhere(key)) {
+      res = this.resolveBlack();
+    }
+
+    if (typeof res === 'undefined') {
+      return this.limiter.block(key, secDuration);
+    }
+
+    if (this.runActionAnyway) {
+      this.limiter.block(key, secDuration).catch(() => {});
+    }
+    return res;
+  }
+
+  penalty(key, points) {
+    let res;
+    if (this.isWhiteListedSomewhere(key)) {
+      res = this.resolveWhite();
+    } else if (this.isBlackListedSomewhere(key)) {
+      res = this.resolveBlack();
+    }
+
+    if (typeof res === 'undefined') {
+      return this.limiter.penalty(key, points);
+    }
+
+    if (this.runActionAnyway) {
+      this.limiter.penalty(key, points).catch(() => {});
+    }
+    return res;
+  }
+
+  reward(key, points) {
+    let res;
+    if (this.isWhiteListedSomewhere(key)) {
+      res = this.resolveWhite();
+    } else if (this.isBlackListedSomewhere(key)) {
+      res = this.resolveBlack();
+    }
+
+    if (typeof res === 'undefined') {
+      return this.limiter.reward(key, points);
+    }
+
+    if (this.runActionAnyway) {
+      this.limiter.reward(key, points).catch(() => {});
+    }
+    return res;
+  }
+
+  get(key) {
+    let res;
+    if (this.isWhiteListedSomewhere(key)) {
+      res = this.resolveWhite();
+    } else if (this.isBlackListedSomewhere(key)) {
+      res = this.resolveBlack();
+    }
+
+    if (typeof res === 'undefined' || this.runActionAnyway) {
+      return this.limiter.get(key);
+    }
+
+    return res;
+  }
+
+  delete(key) {
+    return this.limiter.delete(key);
+  }
+};

package/lib/RLWrapperTimeouts.js

@@ -0,0 +1,82 @@
+const RateLimiterAbstract = require('./RateLimiterAbstract');
+const RateLimiterInsuredAbstract = require('./RateLimiterInsuredAbstract');
+
+module.exports = class RLWrapperTimeouts extends RateLimiterInsuredAbstract {
+  constructor(opts= {}) {
+    super(opts);
+    this.limiter = opts.limiter;
+    this.timeoutMs = opts.timeoutMs || 0;
+  }
+
+  get limiter() {
+    return this._limiter;
+  }
+
+  set limiter(limiter) {
+    if (!(limiter instanceof RateLimiterAbstract)) {
+      throw new TypeError('limiter must be an instance of RateLimiterAbstract');
+    }
+    this._limiter = limiter;
+    if (!this.insuranceLimiter && limiter instanceof RateLimiterInsuredAbstract) {
+      this.insuranceLimiter = limiter.insuranceLimiter;
+    }
+  }
+
+  get timeoutMs() {
+    return this._timeoutMs;
+  }
+
+  set timeoutMs(value) {
+    if (typeof value !== 'number' || value < 0) {
+      throw new TypeError('timeoutMs must be a non-negative number');
+    }
+    this._timeoutMs = value;
+  }
+
+  _run(funcName, params) {
+    return new Promise(async (resolve, reject) => {
+      const timeout = setTimeout(() => {
+        return reject(new Error('Operation timed out'));
+      }, this.timeoutMs);
+
+      await this.limiter[funcName](...params)
+        .then((result) => {
+          clearTimeout(timeout);
+          resolve(result);
+        })
+        .catch((err) => {
+          clearTimeout(timeout);
+          reject(err);
+        });
+    });
+  }
+
+  _consume(key, pointsToConsume = 1, options = {}) {
+    return this._run('consume', [key, pointsToConsume, options]);
+  }
+
+  _penalty(key, points = 1, options = {}) {
+    return this._run('penalty', [key, points, options]);
+  }
+
+  _reward(key, points = 1, options = {}) {
+    return this._run('reward', [key, points, options]);
+  }
+
+  _get(key, options = {}) {
+    return this._run('get', [key, options]);
+  }
+
+  _set(key, points, secDuration, options = {}) {
+    return this._run('set', [key, points, secDuration, options]);
+  }
+
+  _block(key, secDuration, options = {}) {
+    return this._run('block', [key, secDuration, options]);
+  }
+
+  _delete(key, options = {}) {
+    return this._run('delete', [key, options]);
+  }
+
+}

package/lib/RateLimiterAbstract.js

@@ -0,0 +1,125 @@
+module.exports = class RateLimiterAbstract {
+  /**
+   *
+   * @param opts Object Defaults {
+   *   points: 4, // Number of points
+   *   duration: 1, // Per seconds
+   *   blockDuration: 0, // Block if consumed more than points in current duration for blockDuration seconds
+   *   execEvenly: false, // Execute allowed actions evenly over duration
+   *   execEvenlyMinDelayMs: duration * 1000 / points, // ms, works with execEvenly=true option
+   *   keyPrefix: 'rlflx',
+   * }
+   */
+  constructor(opts = {}) {
+    this.points = opts.points;
+    this.duration = opts.duration;
+    this.blockDuration = opts.blockDuration;
+    this.execEvenly = opts.execEvenly;
+    this.execEvenlyMinDelayMs = opts.execEvenlyMinDelayMs;
+    this.keyPrefix = opts.keyPrefix;
+  }
+
+  get points() {
+    return this._points;
+  }
+
+  set points(value) {
+    this._points = value >= 0 ? value : 4;
+  }
+
+  get duration() {
+    return this._duration;
+  }
+
+  set duration(value) {
+    this._duration = typeof value === 'undefined' ? 1 : value;
+  }
+
+  get msDuration() {
+    return this.duration * 1000;
+  }
+
+  get blockDuration() {
+    return this._blockDuration;
+  }
+
+  set blockDuration(value) {
+    this._blockDuration = typeof value === 'undefined' ? 0 : value;
+  }
+
+  get msBlockDuration() {
+    return this.blockDuration * 1000;
+  }
+
+  get execEvenly() {
+    return this._execEvenly;
+  }
+
+  set execEvenly(value) {
+    this._execEvenly = typeof value === 'undefined' ? false : Boolean(value);
+  }
+
+  get execEvenlyMinDelayMs() {
+    return this._execEvenlyMinDelayMs;
+  }
+
+  set execEvenlyMinDelayMs(value) {
+    this._execEvenlyMinDelayMs = typeof value === 'undefined' ? Math.ceil(this.msDuration / this.points) : value;
+  }
+
+  get keyPrefix() {
+    return this._keyPrefix;
+  }
+
+  set keyPrefix(value) {
+    if (typeof value === 'undefined') {
+      value = 'rlflx';
+    }
+    if (typeof value !== 'string') {
+      throw new Error('keyPrefix must be string');
+    }
+    this._keyPrefix = value;
+  }
+
+  _getKeySecDuration(options = {}) {
+    return options && options.customDuration >= 0
+      ? options.customDuration
+      : this.duration;
+  }
+
+  getKey(key) {
+    return this.keyPrefix.length > 0 ? `${this.keyPrefix}:${key}` : key;
+  }
+
+  parseKey(rlKey) {
+    return rlKey.substring(this.keyPrefix.length);
+  }
+
+  consume() {
+    throw new Error("You have to implement the method 'consume'!");
+  }
+
+  penalty() {
+    throw new Error("You have to implement the method 'penalty'!");
+  }
+
+  reward() {
+    throw new Error("You have to implement the method 'reward'!");
+  }
+
+  get() {
+    throw new Error("You have to implement the method 'get'!");
+  }
+
+  set() {
+    throw new Error("You have to implement the method 'set'!");
+  }
+
+  block() {
+    throw new Error("You have to implement the method 'block'!");
+  }
+
+  delete() {
+    throw new Error("You have to implement the method 'delete'!");
+  }
+};