@withjoy/limiter 0.1.2 → 0.1.4-test

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/node_modules/lru-cache/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/limitd-redis/node_modules/lru-cache/README.md

@@ -0,0 +1,158 @@
+# lru cache
+
+A cache object that deletes the least-recently-used items.
+
+[![Build Status](https://travis-ci.org/isaacs/node-lru-cache.svg?branch=master)](https://travis-ci.org/isaacs/node-lru-cache) [![Coverage Status](https://coveralls.io/repos/isaacs/node-lru-cache/badge.svg?service=github)](https://coveralls.io/github/isaacs/node-lru-cache)
+
+## Installation:
+
+```javascript
+npm install lru-cache --save
+```
+
+## Usage:
+
+```javascript
+var LRU = require("lru-cache")
+  , options = { max: 500
+              , length: function (n, key) { return n * 2 + key.length }
+              , dispose: function (key, n) { n.close() }
+              , maxAge: 1000 * 60 * 60 }
+  , cache = LRU(options)
+  , otherCache = LRU(50) // sets just the max size
+
+cache.set("key", "value")
+cache.get("key") // "value"
+
+// non-string keys ARE fully supported
+// but note that it must be THE SAME object, not
+// just a JSON-equivalent object.
+var someObject = { a: 1 }
+cache.set(someObject, 'a value')
+// Object keys are not toString()-ed
+cache.set('[object Object]', 'a different value')
+assert.equal(cache.get(someObject), 'a value')
+// A similar object with same keys/values won't work,
+// because it's a different object identity
+assert.equal(cache.get({ a: 1 }), undefined)
+
+cache.reset()    // empty the cache
+```
+
+If you put more stuff in it, then items will fall out.
+
+If you try to put an oversized thing in it, then it'll fall out right
+away.
+
+## Options
+
+* `max` The maximum size of the cache, checked by applying the length
+  function to all values in the cache.  Not setting this is kind of
+  silly, since that's the whole purpose of this lib, but it defaults
+  to `Infinity`.
+* `maxAge` Maximum age in ms.  Items are not pro-actively pruned out
+  as they age, but if you try to get an item that is too old, it'll
+  drop it and return undefined instead of giving it to you.
+* `length` Function that is used to calculate the length of stored
+  items.  If you're storing strings or buffers, then you probably want
+  to do something like `function(n, key){return n.length}`.  The default is
+  `function(){return 1}`, which is fine if you want to store `max`
+  like-sized things.  The item is passed as the first argument, and
+  the key is passed as the second argumnet.
+* `dispose` Function that is called on items when they are dropped
+  from the cache.  This can be handy if you want to close file
+  descriptors or do other cleanup tasks when items are no longer
+  accessible.  Called with `key, value`.  It's called *before*
+  actually removing the item from the internal cache, so if you want
+  to immediately put it back in, you'll have to do that in a
+  `nextTick` or `setTimeout` callback or it won't do anything.
+* `stale` By default, if you set a `maxAge`, it'll only actually pull
+  stale items out of the cache when you `get(key)`.  (That is, it's
+  not pre-emptively doing a `setTimeout` or anything.)  If you set
+  `stale:true`, it'll return the stale value before deleting it.  If
+  you don't set this, then it'll return `undefined` when you try to
+  get a stale entry, as if it had already been deleted.
+* `noDisposeOnSet` By default, if you set a `dispose()` method, then
+  it'll be called whenever a `set()` operation overwrites an existing
+  key.  If you set this option, `dispose()` will only be called when a
+  key falls out of the cache, not when it is overwritten.
+
+## API
+
+* `set(key, value, maxAge)`
+* `get(key) => value`
+
+    Both of these will update the "recently used"-ness of the key.
+    They do what you think. `maxAge` is optional and overrides the
+    cache `maxAge` option if provided.
+
+    If the key is not found, `get()` will return `undefined`.
+
+    The key and val can be any value.
+
+* `peek(key)`
+
+    Returns the key value (or `undefined` if not found) without
+    updating the "recently used"-ness of the key.
+
+    (If you find yourself using this a lot, you *might* be using the
+    wrong sort of data structure, but there are some use cases where
+    it's handy.)
+
+* `del(key)`
+
+    Deletes a key out of the cache.
+
+* `reset()`
+
+    Clear the cache entirely, throwing away all values.
+
+* `has(key)`
+
+    Check if a key is in the cache, without updating the recent-ness
+    or deleting it for being stale.
+
+* `forEach(function(value,key,cache), [thisp])`
+
+    Just like `Array.prototype.forEach`.  Iterates over all the keys
+    in the cache, in order of recent-ness.  (Ie, more recently used
+    items are iterated over first.)
+
+* `rforEach(function(value,key,cache), [thisp])`
+
+    The same as `cache.forEach(...)` but items are iterated over in
+    reverse order.  (ie, less recently used items are iterated over
+    first.)
+
+* `keys()`
+
+    Return an array of the keys in the cache.
+
+* `values()`
+
+    Return an array of the values in the cache.
+
+* `length`
+
+    Return total length of objects in cache taking into account
+    `length` options function.
+
+* `itemCount`
+
+    Return total quantity of objects currently in cache. Note, that
+    `stale` (see options) items are returned as part of this item
+    count.
+
+* `dump()`
+
+    Return an array of the cache entries ready for serialization and usage
+    with 'destinationCache.load(arr)`.
+
+* `load(cacheEntriesArray)`
+
+    Loads another cache entries array, obtained with `sourceCache.dump()`,
+    into the cache. The destination cache is reset before loading new entries
+
+* `prune()`
+
+    Manually iterates over the entire cache proactively pruning old entries