@withjoy/limiter 0.1.2 → 0.1.4-test

package/limitd-redis/test/validation.tests.js

@@ -0,0 +1,124 @@
+const assert = require('chai').assert;
+
+const { validateParams } = require('../lib/validation');
+
+describe('validation', () => {
+  describe('validateParameters', () => {
+
+    const buckets = {
+      user: {
+        size: 10
+      }
+    };
+
+    describe('when providing invalid parameters', () => {
+      const invalidParameterSets = [
+        {
+          result: {
+            message: 'params are required',
+            code: 101
+          }
+        }, {
+          params: {},
+          result: {
+            message: 'type is required',
+            code: 102
+          }
+        }, {
+          params: {
+            type: 'ip'
+          },
+          result: {
+            message: 'undefined bucket type ip',
+            code: 103
+          }
+        }, {
+          params: {
+            type: 'user'
+          },
+          result: {
+            message: 'key is required',
+            code: 104
+          }
+        }, {
+          params: {
+            type: 'user',
+            key: 'tenant|username',
+            configOverride: 5
+          },
+          result: {
+            message: 'configuration overrides must be an object',
+            code: 105
+          }
+        }, {
+          params: {
+            type: 'user',
+            key: 'tenant|username',
+            configOverride: {}
+          },
+          result: {
+            message: 'configuration overrides must provide either a size or interval',
+            code: 106
+          }
+        }
+      ];
+
+      invalidParameterSets.forEach(testcase => {
+        it(`Should return a validation error, code ${testcase.result.code}`, () => {
+          const result = validateParams(testcase.params, buckets);
+          assert.strictEqual(result.name, 'LimitdRedisValidationError');
+          assert.strictEqual(result.message, testcase.result.message);
+          assert.deepEqual(result.extra, { code: testcase.result.code });
+          assert.exists(result.stack);
+        });
+      });
+    });
+
+    describe('when providing valid parameters', () => {
+      const validParameterSerts = [
+        {
+          params: {
+            type: 'user',
+            key: 'tenant|username',
+          },
+          name: 'type and key params'
+        }, {
+          params: {
+            type: 'user',
+            key: 'tenant|username',
+            configOverride: {
+              size: 77
+            }
+          },
+          name: 'configOverride with size'
+        }, {
+          params: {
+            type: 'user',
+            key: 'tenant|username',
+            configOverride: {
+              per_hour: 300
+            }
+          },
+          name: 'configOverride with interval'
+        }, {
+          params: {
+            type: 'user',
+            key: 'tenant|username',
+            configOverride: {
+              size: 30,
+              per_hour: 300
+            }
+          },
+          name: 'configOverride with size and interval'
+        },
+      ];
+
+      validParameterSerts.forEach(testcase => {
+        it(`Should not cause a validation error for ${testcase.name}`, () => {
+          const result = validateParams(testcase.params, buckets);
+          assert.isUndefined(result);
+        });
+      });
+    });
+  });
+});

package/limiter.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var LimitdRedis = require("limitd-redis"); // name to redis matter
+var z = require('zod');
 
 const defaultBuckets = {
 	emailsByEventId: { size: 3000 },
@@ -37,13 +38,63 @@ class Operation {
 // global singleton
 let connection = null;
 
+const LIMITER_CIRCUIT_BREAKER_DEFAULTS = {
+	timeout: "0.50s",
+	maxFailures: 50,
+	cooldown: "1s",
+	maxCooldown: "3s",
+	name: "limitr",
+};
+
+const LIMITER_RETRY_DEFAULTS = {
+	retries: 3,
+	minTimeout: 10,
+	maxTimeout: 30,
+};
+
+/**
+ * Circuit Breaker configuration for limiter. derived from limitd-redis package
+ * https://github.com/auth0/limitd-redis/blob/03ba193fe436c5b887ff410d4f2623512ee5c9e2/lib/client.js#L11C1-L12C1
+ */
+const limiterCircuitBreakerConfig = z
+	.object({
+		timeout: z.coerce
+			.string()
+			.default(LIMITER_CIRCUIT_BREAKER_DEFAULTS.timeout),
+		maxFailures: z.coerce
+			.number()
+			.default(LIMITER_CIRCUIT_BREAKER_DEFAULTS.maxFailures),
+		cooldown: z.coerce
+			.string()
+			.default(LIMITER_CIRCUIT_BREAKER_DEFAULTS.cooldown),
+		maxCooldown: z.coerce
+			.string()
+			.default(LIMITER_CIRCUIT_BREAKER_DEFAULTS.maxCooldown),
+		name: z.coerce.string().default(LIMITER_CIRCUIT_BREAKER_DEFAULTS.name),
+	})
+	.strict()
+	.default(LIMITER_CIRCUIT_BREAKER_DEFAULTS);
+
+/**
+ * Limiter Retry configuration for limiter. derived from limitd-redis package
+ * https://github.com/auth0/limitd-redis/blob/03ba193fe436c5b887ff410d4f2623512ee5c9e2/lib/client.js#L22
+ */
+const limiterRetryConfig = z
+	.object({
+		retries: z.coerce.number().default(LIMITER_RETRY_DEFAULTS.retries),
+		minTimeout: z.coerce.number().default(LIMITER_RETRY_DEFAULTS.minTimeout),
+		maxTimeout: z.coerce.number().default(LIMITER_RETRY_DEFAULTS.maxTimeout),
+	})
+	.strict()
+	.default(LIMITER_RETRY_DEFAULTS);
+
 class Limiter {
 	// static defaultBuckets;
 	// static pickDefaultBuckets(keys) { ... };
 
 	constructor(config) {
 		this._config = config;
-		this._limitdRedisConnection = this.connect();
+		this._limitdRedisConnectionPromise = this.connect();
 	}
 
 	/*
@@ -52,29 +103,40 @@ class Limiter {
 			stub it to prevent a real connect from happening under Test Suite Conditions
 	*/
 	connect() {
-		let buckets = this._config.buckets || {};
-		buckets = {
-			...defaultBuckets,
-			...buckets,
-		};
-		const keyPrefix = this._config.keyPrefix || defaultRedisKeyPrefix;
-		if (!connection) {
-			connection = new LimitdRedis({
-				uri: this._config.limitdUrl,
-				buckets,
-				keyPrefix,
-			});
-		}
-		return connection;
+		return new Promise((resolve, reject) => {
+let buckets = this._config.buckets || {};
+			buckets = {
+				...defaultBuckets,
+				...buckets,
+			};
+			const keyPrefix = this._config.keyPrefix || defaultRedisKeyPrefix;
+			if (!connection) {
+				connection = new LimitdRedis({
+					uri: this._config.limitdUrl,
+					buckets,
+					keyPrefix,
+					circuitbreaker: this._config.circuitbreaker,
+					commandTimeout: this._config.commandTimeout,
+					retry: this._config.retry,
+				});
+				connection.db.on('ready', () => {
+					return resolve(connection);
+				});
+			} else {
+				return resolve(connection);
+			}
+		});
 	}
 
-	getLimiterProcessor(console) {
+	async getLimiterProcessor(console) {
+		await this._limitdRedisConnectionPromise;
 		return new LimiterProcessor(console);
 	}
 
 	close() {
-		return new Promise((resolve, reject) => {
-			this._limitdRedisConnection.close((err, resp) => {
+		return new Promise(async (resolve, reject) => {
+			const connectionPromise = await this._limitdRedisConnectionPromise;
+			connectionPromise.close((err, resp) => {
 				if (err) {
 					this._console.error(err);
 					return reject(err);
@@ -87,7 +149,7 @@ class Limiter {
 }
 
 class LimiterProcessor {
-	
+
 	constructor(console) {
 		this._console = console;
 		this._operationList = [];
@@ -191,5 +253,7 @@ Limiter.pickDefaultBuckets = function pickDefaultBuckets(keyArray) {
 	}
 	return buckets;
 };
+Limiter.limiterCircuitBreakerConfig = limiterCircuitBreakerConfig;
+Limiter.limiterRetryConfig = limiterRetryConfig;
 
 module.exports = Limiter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withjoy/limiter",
-  "version": "0.1.2",
+  "version": "0.1.4-test",
   "description": "Api Rate limiter",
   "main": "limiter.js",
   "scripts": {
@@ -10,7 +10,8 @@
   "author": "services@withjoy.com",
   "license": "MIT",
   "dependencies": {
-    "limitd-redis": "^5.1.1"
+    "limitd-redis": "file:./limitd-redis",
+    "zod": "^3.22.4"
   },
   "devDependencies": {
     "jest": "^24.9.0"

package/tests/limiter.test.js

@@ -16,13 +16,13 @@ const TEST_BUCKETS = {
     The limitd service is essentially a token bank
     that we can withdraw from (take) or deposit to (put)
 */
-const limiterWithMockService = (succeeds = true, conforms = true) => {
+const limiterWithMockService = async (succeeds = true, conforms = true) => {
 	let token_pile = 0;
 	const limiter = new Limiter({
 		limitdUrl: "localhost:6379",
 		buckets: TEST_BUCKETS,
 	});
-	const limiterProcessor = limiter.getLimiterProcessor(console);
+	const limiterProcessor = await limiter.getLimiterProcessor(console);
 	limiterProcessor._limitdRedis = new (class MockLimitd {
 		constructor(should_succeed, should_conform) {
 			this.should_succeed = should_succeed;
@@ -61,7 +61,7 @@ test("perfrom limitd-redis testing with test bucket", async (done) => {
 			test: { size: 3, per_second: 2 },
 		},
 	})
-	const limiterProcessor = limiter.getLimiterProcessor(console);
+	const limiterProcessor = await limiter.getLimiterProcessor(console);
 	// take 2  # Conformant - Remaining: 1
 	const result1 = await limiterProcessor.transfer("test", "test-key", 2);
 	expect(result1).toMatchObject({
@@ -93,8 +93,8 @@ test("perfrom limitd-redis testing with test bucket", async (done) => {
 	done();
 });
 
-test("Resolves to null if we aren't doing a real transfer", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Resolves to null if we aren't doing a real transfer", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor.transfer("a", "b", 0, null).then((result) => {
 		expect(result).toBe(null);
 		expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
@@ -102,8 +102,8 @@ test("Resolves to null if we aren't doing a real transfer", (done) => {
 	});
 });
 
-test("Adds tokens if provided a negative token amount", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Adds tokens if provided a negative token amount", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor.transfer("a", "b", -5).then((result) => {
 		expect(result).toMatchObject({});
 		expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
@@ -111,8 +111,8 @@ test("Adds tokens if provided a negative token amount", (done) => {
 	});
 });
 
-test("Removes tokens if provided a positive token amount", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Removes tokens if provided a positive token amount", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor.transfer("a", "b", 5).then((result) => {
 		expect(result).toMatchObject({ conformant: true });
 		expect(limiterProcessor._limitdRedis._num_tokens()).toBe(-5);
@@ -120,8 +120,8 @@ test("Removes tokens if provided a positive token amount", (done) => {
 	});
 });
 
-test("Reverts all taken tokens when revert is called", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Reverts all taken tokens when revert is called", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor
 		.transfer("a", "b", 5)
 		.then((result) => {
@@ -135,8 +135,8 @@ test("Reverts all taken tokens when revert is called", (done) => {
 		});
 });
 
-test("Reverts all given tokens when revert is called", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Reverts all given tokens when revert is called", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor
 		.transfer("a", "b", -5)
 		.then((result) => {
@@ -150,8 +150,8 @@ test("Reverts all given tokens when revert is called", (done) => {
 		});
 });
 
-test("Reverts a series of actions when revert is called", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Reverts a series of actions when revert is called", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor
 		.transfer("a", "b", -5)
 		.then((result) => {
@@ -170,8 +170,8 @@ test("Reverts a series of actions when revert is called", (done) => {
 		});
 });
 
-test("Properly executes a transferAll()", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Properly executes a transferAll()", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor
 		.transferAll([
 			["a", "b", -5],
@@ -188,26 +188,26 @@ test("Properly executes a transferAll()", (done) => {
 		});
 });
 
-test("Errors from the underlying service are propagated (put)", () => {
-	let limiterProcessor = limiterWithMockService((succeeds = false));
+test("Errors from the underlying service are propagated (put)", async () => {
+	let limiterProcessor = await limiterWithMockService((succeeds = false));
 	let endsInFailure = limiterProcessor.transfer("a", "b", -5);
 	return expect(endsInFailure).rejects.toThrow(PUT_FAILED);
 });
 
-test("Errors from the underlying service are propagated (take)", () => {
-	let limiterProcessor = limiterWithMockService((succeeds = false));
+test("Errors from the underlying service are propagated (take)", async () => {
+	let limiterProcessor = await limiterWithMockService((succeeds = false));
 	let endsInFailure = limiterProcessor.transfer("a", "b", 5);
 	return expect(endsInFailure).rejects.toThrow(TAKE_FAILED);
 });
 
-test("Non-conforming response results in an error", () => {
-	let limiterProcessor = limiterWithMockService((succeeds = true), (conforms = false));
+test("Non-conforming response results in an error", async () => {
+	let limiterProcessor = await limiterWithMockService((succeeds = true), (conforms = false));
 	let endsInFailure = limiterProcessor.transfer("a", "b", 5);
 	return expect(endsInFailure).rejects.toThrow("Non Conformant");
 });
 
-test("An operation that fails is not logged", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("An operation that fails is not logged", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor
 		.transfer("emailRate", "b", -5)
 		.then((result) => {
@@ -229,8 +229,8 @@ test("An operation that fails is not logged", (done) => {
 		});
 });
 
-test("Properly handles spamming revert() calls", (done) => {
-	let limiterProcessor = limiterWithMockService();
+test("Properly handles spamming revert() calls", async (done) => {
+	let limiterProcessor = await limiterWithMockService();
 	limiterProcessor
 		.transfer("a", "b", -5)
 		.then((result) => {

package/tests/performTestWithTestPerMinute.js

@@ -6,7 +6,7 @@ async function performTestWithTestPerMinute() {
 		limitdUrl: "localhost:6379",
 		console: console,
 	});
-	const limiterProcessor = limiter.getLimiterProcessor(console);
+	const limiterProcessor = await limiter.getLimiterProcessor(console);
 	// take 2  # Conformant - Remaining: 1
 	const result1 = await limiterProcessor.transfer("testPerMinute", "key", 2);
 	console.log("First Turn Take Result", result1);

package/tests/sanityCheck.js

@@ -2,32 +2,36 @@
 
 var Limiter = require("../limiter");
 
-const buckets = {
-	emails: { size: 10 },
-	emailRate: { size: 10, per_hour: 10 },
-};
-
-var limiter = new Limiter({
-	limitdUrl: "localhost:6379",
-	buckets,
-});
-
-var limiterProcessor = limiter.getLimiterProcessor(console);
-
-var callback = function (err) {
-	if (err) {
-		console.log(err);
-		process.exit(1);
-	}
-
-	process.exit(0);
-};
-
-var withdrawls = [
-	["emails", process.argv[2], -parseInt(process.argv[3])],
-	["emailRate", process.argv[2], -parseInt(process.argv[3])],
-	["emails", process.argv[2], parseInt(process.argv[3])],
-	["emailRate", process.argv[2], parseInt(process.argv[3])],
-];
-
-limiterProcessor.transferAll(withdrawls).then(() => callback(), callback);
+async function sanityCheck(){
+	const buckets = {
+		emails: { size: 10 },
+		emailRate: { size: 10, per_hour: 10 },
+	};
+
+	var limiter = new Limiter({
+		limitdUrl: "localhost:6379",
+		buckets,
+	});
+
+	const limiterProcessor = await limiter.getLimiterProcessor(console);
+
+	var callback = function (err) {
+		if (err) {
+			console.log(err);
+			process.exit(1);
+		}
+
+		process.exit(0);
+	};
+
+	var withdrawls = [
+		["emails", process.argv[2], -parseInt(process.argv[3])],
+		["emailRate", process.argv[2], -parseInt(process.argv[3])],
+		["emails", process.argv[2], parseInt(process.argv[3])],
+		["emailRate", process.argv[2], parseInt(process.argv[3])],
+	];
+
+	limiterProcessor.transferAll(withdrawls).then(() => callback(), callback);
+}
+
+sanityCheck();