@withjoy/limiter 0.1.3 → 0.1.5

package/limitd-redis/lib/utils.js

@@ -0,0 +1,116 @@
+const ms = require('ms');
+const _ = require('lodash');
+const LRU = require('lru-cache');
+
+const INTERVAL_TO_MS = {
+  'per_second': ms('1s'),
+  'per_minute': ms('1m'),
+  'per_hour': ms('1h'),
+  'per_day': ms('1d')
+};
+
+const INTERVAL_SHORTCUTS = Object.keys(INTERVAL_TO_MS);
+
+function normalizeTemporals(params) {
+  const type = _.pick(params, [
+    'per_interval',
+    'interval',
+    'size',
+    'unlimited',
+    'skip_n_calls'
+  ]);
+
+  INTERVAL_SHORTCUTS.forEach(intervalShortcut => {
+    if (!params[intervalShortcut]) { return; }
+    type.interval = INTERVAL_TO_MS[intervalShortcut];
+    type.per_interval = params[intervalShortcut];
+  });
+
+  if (typeof type.size === 'undefined') {
+    type.size = type.per_interval;
+  }
+
+  if (type.per_interval) {
+    type.ttl = ((type.size * type.interval) / type.per_interval) / 1000;
+    type.ms_per_interval = type.per_interval / type.interval;
+    type.drip_interval = type.interval / type.per_interval;
+  }
+
+  return type;
+}
+
+function normalizeType(params) {
+  const type = normalizeTemporals(params);
+
+  type.overridesMatch = {};
+  type.overrides = _.reduce(params.overrides || params.override, (result, overrideDef, name) => {
+    const override = normalizeTemporals(overrideDef);
+    override.name = name;
+    if (overrideDef.until && !(overrideDef.until instanceof Date)) {
+      overrideDef.until = new Date(overrideDef.until);
+    }
+    override.until = overrideDef.until;
+    if (overrideDef.match) {
+      // TODO: Allow more flags
+      override.match = new RegExp(overrideDef.match, 'i');
+    }
+
+    if (!override.until || override.until >= new Date()) {
+      if (override.match) {
+        type.overridesMatch[name] = override;
+      } else {
+        result[name] = override;
+      }
+    }
+
+    return result;
+  }, {});
+
+  if (Object.keys(type.overridesMatch).length > 0) {
+    type.overridesCache = new LRU({ max: 50 });
+  }
+
+  return type;
+}
+
+/**
+ * Load the buckets configuration.
+ *
+ * @param {Object.<string, type>} bucketsConfig The buckets configuration.
+ * @memberof LimitDB
+ */
+function buildBuckets(bucketsConfig) {
+  return _.reduce(bucketsConfig, (result, bucket, name) => {
+    result[name] = normalizeType(bucket);
+    return result;
+  }, {});
+}
+
+function buildBucket(bucket) {
+  return normalizeType(bucket);
+}
+
+function functionOrFalse(fun) {
+  return !!(fun && fun.constructor && fun.call && fun.apply)
+    ? fun
+    : false
+}
+
+function randomBetween(min, max) {
+  if (min > max) {
+    let tmp = max;
+    max = min;
+    min = tmp;
+  }
+  return Math.random() * (max-min) + min;
+}
+
+module.exports = {
+  buildBuckets,
+  buildBucket,
+  INTERVAL_SHORTCUTS,
+  normalizeTemporals,
+  normalizeType,
+  functionOrFalse,
+  randomBetween
+};

package/limitd-redis/lib/validation.js

@@ -0,0 +1,64 @@
+const { INTERVAL_SHORTCUTS } = require('./utils');
+
+class LimitdRedisValidationError extends Error {
+  constructor(msg, extra) {
+    super();
+    this.name = this.constructor.name;
+    this.message = msg;
+    Error.captureStackTrace(this, this.constructor);
+    if (extra) {
+      this.extra = extra;
+    }
+  }
+}
+
+function validateParams(params, buckets) {
+  if (typeof params !== 'object') {
+    return new LimitdRedisValidationError('params are required', { code: 101 });
+  }
+
+  if (typeof params.type !== 'string') {
+    return new LimitdRedisValidationError('type is required', { code: 102 });
+  }
+
+  if (typeof buckets[params.type] === 'undefined') {
+    return new LimitdRedisValidationError(`undefined bucket type ${params.type}`, { code: 103 });
+  }
+
+  if (typeof params.key !== 'string') {
+    return new LimitdRedisValidationError('key is required', { code: 104 });
+  }
+
+  if (typeof params.configOverride !== 'undefined') {
+    try {
+      validateOverride(params.configOverride);
+    } catch (error) {
+      return error;
+    }
+  }
+}
+
+function validateOverride(configOverride) {
+  if (typeof configOverride !== 'object') {
+    throw new LimitdRedisValidationError('configuration overrides must be an object', { code: 105 });
+  }
+
+  // If size is provided, nothing more is strictly required
+  // (as in the case of static bucket configurations)
+  if (typeof configOverride.size === 'number') {
+    return;
+  }
+
+  const interval = Object.keys(configOverride)
+    .find(key => INTERVAL_SHORTCUTS.indexOf(key) > -1);
+
+  // If size is not provided, we *must* have a interval specified
+  if (typeof interval === 'undefined') {
+    throw new LimitdRedisValidationError('configuration overrides must provide either a size or interval', { code: 106 });
+  }
+}
+
+module.exports = {
+  validateParams,
+  LimitdRedisValidationError,
+};

package/limitd-redis/opslevel.yml

@@ -0,0 +1,6 @@
+---
+version: 1
+repository:
+  owner: platform_core_services
+  tier:
+  tags: