@withjoy/limiter 0.1.1 → 0.1.2

package/limiter.js

@@ -42,10 +42,8 @@ class Limiter {
 	// static pickDefaultBuckets(keys) { ... };
 
 	constructor(config) {
-		this._console = config.console;
 		this._config = config;
-		this._operationList = [];
-		this._limitdRedis = this.connect();
+		this._limitdRedisConnection = this.connect();
 	}
 
 	/*
@@ -67,10 +65,35 @@ class Limiter {
 				keyPrefix,
 			});
 		}
-		this._limitdRedis = connection;
 		return connection;
 	}
 
+	getLimiterProcessor(console) {
+		return new LimiterProcessor(console);
+	}
+
+	close() {
+		return new Promise((resolve, reject) => {
+			this._limitdRedisConnection.close((err, resp) => {
+				if (err) {
+					this._console.error(err);
+					return reject(err);
+				}
+				console.log("Connection closed");
+				resolve(resp);
+			});
+		});
+	}
+}
+
+class LimiterProcessor {
+	
+	constructor(console) {
+		this._console = console;
+		this._operationList = [];
+		this._limitdRedis = connection;
+	}
+
 	/*
 		Go through the log of things we did and do the opposite
 	*/
@@ -97,18 +120,6 @@ class Limiter {
 		this._operationList.push(op);
 	}
 
-	close() {
-		return new Promise((resolve, reject) => {
-			this._limitdRedis.close((err, resp) => {
-				if (err) {
-					this._console.error(err);
-					return reject(err);
-				}
-				console.log("Connection closed");
-				resolve(resp);
-			});
-		});
-	}
 	// promise wrapper for limitd lib put
 	_put(type, id, amount) {
 		return new Promise((resolve, reject) =>
@@ -173,12 +184,12 @@ Limiter.pickDefaultBuckets = function pickDefaultBuckets(keyArray) {
 	const buckets = {};
 	for (const key of keyArray) {
 		const bucket = defaultBuckets[key];
-		if (! bucket) {
+		if (!bucket) {
 			throw new Error(`Limiter.pickDefaultBuckets: no such bucket; "${key}"`);
 		}
 		buckets[key] = defaultBuckets[key];
 	}
 	return buckets;
-}
+};
 
 module.exports = Limiter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withjoy/limiter",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Api Rate limiter",
   "main": "limiter.js",
   "scripts": {

package/tests/limiter.test.js

@@ -19,12 +19,11 @@ const TEST_BUCKETS = {
 const limiterWithMockService = (succeeds = true, conforms = true) => {
 	let token_pile = 0;
 	const limiter = new Limiter({
-		console: console,
 		limitdUrl: "localhost:6379",
 		buckets: TEST_BUCKETS,
 	});
-
-	limiter._limitdRedis = new (class MockLimitd {
+	const limiterProcessor = limiter.getLimiterProcessor(console);
+	limiterProcessor._limitdRedis = new (class MockLimitd {
 		constructor(should_succeed, should_conform) {
 			this.should_succeed = should_succeed;
 			this.should_conform = should_conform;
@@ -52,38 +51,38 @@ const limiterWithMockService = (succeeds = true, conforms = true) => {
 			return token_pile;
 		}
 	})(succeeds, conforms);
-	return limiter;
+	return limiterProcessor;
 };
 
 test("perfrom limitd-redis testing with test bucket", async (done) => {
 	const limiter = new Limiter({
 		limitdUrl: "localhost:6379",
-		console: console,
 		buckets: {
 			test: { size: 3, per_second: 2 },
 		},
-	});
+	})
+	const limiterProcessor = limiter.getLimiterProcessor(console);
 	// take 2  # Conformant - Remaining: 1
-	const result1 = await limiter.transfer("test", "test-key", 2);
+	const result1 = await limiterProcessor.transfer("test", "test-key", 2);
 	expect(result1).toMatchObject({
 		conformant: true,
 		remaining: 1,
 		limit: 3,
 		delayed: false,
 	});
-	await expect(limiter.transfer("test", "test-key", 2)).rejects.toThrow(
+	await expect(limiterProcessor.transfer("test", "test-key", 2)).rejects.toThrow(
 		"Non Conformant"
 	);
 
 	// Put 1
-	const result3 = await limiter.transfer("test", "test-key", -1);
+	const result3 = await limiterProcessor.transfer("test", "test-key", -1);
 	expect(result3).toMatchObject({
 		remaining: 2,
 		limit: 3,
 	});
 
     //Now Conformant - Remaining: 2
-	const result4 = await limiter.transfer("test", "test-key", 2);
+	const result4 = await limiterProcessor.transfer("test", "test-key", 2);
 	expect(result4).toMatchObject({
 		conformant: true,
 		remaining: 0,
@@ -95,176 +94,176 @@ test("perfrom limitd-redis testing with test bucket", async (done) => {
 });
 
 test("Resolves to null if we aren't doing a real transfer", (done) => {
-	let limiter = limiterWithMockService();
-	limiter.transfer("a", "b", 0, null).then((result) => {
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor.transfer("a", "b", 0, null).then((result) => {
 		expect(result).toBe(null);
-		expect(limiter._limitdRedis._num_tokens()).toBe(0);
+		expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 		done();
 	});
 });
 
 test("Adds tokens if provided a negative token amount", (done) => {
-	let limiter = limiterWithMockService();
-	limiter.transfer("a", "b", -5).then((result) => {
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor.transfer("a", "b", -5).then((result) => {
 		expect(result).toMatchObject({});
-		expect(limiter._limitdRedis._num_tokens()).toBe(5);
+		expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
 		done();
 	});
 });
 
 test("Removes tokens if provided a positive token amount", (done) => {
-	let limiter = limiterWithMockService();
-	limiter.transfer("a", "b", 5).then((result) => {
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor.transfer("a", "b", 5).then((result) => {
 		expect(result).toMatchObject({ conformant: true });
-		expect(limiter._limitdRedis._num_tokens()).toBe(-5);
+		expect(limiterProcessor._limitdRedis._num_tokens()).toBe(-5);
 		done();
 	});
 });
 
 test("Reverts all taken tokens when revert is called", (done) => {
-	let limiter = limiterWithMockService();
-	limiter
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor
 		.transfer("a", "b", 5)
 		.then((result) => {
 			expect(result).toMatchObject({ conformant: true });
-			expect(limiter._limitdRedis._num_tokens()).toBe(-5);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(-5);
 		})
-		.then(() => limiter.revert())
+		.then(() => limiterProcessor.revert())
 		.then(() => {
-			expect(limiter._limitdRedis._num_tokens()).toBe(0);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 			done();
 		});
 });
 
 test("Reverts all given tokens when revert is called", (done) => {
-	let limiter = limiterWithMockService();
-	limiter
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor
 		.transfer("a", "b", -5)
 		.then((result) => {
 			expect(result).toMatchObject({});
-			expect(limiter._limitdRedis._num_tokens()).toBe(5);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
 		})
-		.then(() => limiter.revert())
+		.then(() => limiterProcessor.revert())
 		.then(() => {
-			expect(limiter._limitdRedis._num_tokens()).toBe(0);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 			done();
 		});
 });
 
 test("Reverts a series of actions when revert is called", (done) => {
-	let limiter = limiterWithMockService();
-	limiter
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor
 		.transfer("a", "b", -5)
 		.then((result) => {
 			expect(result).toMatchObject({});
-			expect(limiter._limitdRedis._num_tokens()).toBe(5);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
 		})
-		.then(() => limiter.transfer("a", "b", 2))
+		.then(() => limiterProcessor.transfer("a", "b", 2))
 		.then((result) => {
 			expect(result).toMatchObject({ conformant: true });
-			expect(limiter._limitdRedis._num_tokens()).toBe(3);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(3);
 		})
-		.then(() => limiter.revert())
+		.then(() => limiterProcessor.revert())
 		.then(() => {
-			expect(limiter._limitdRedis._num_tokens()).toBe(0);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 			done();
 		});
 });
 
 test("Properly executes a transferAll()", (done) => {
-	let limiter = limiterWithMockService();
-	limiter
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor
 		.transferAll([
 			["a", "b", -5],
 			["a", "b", 2],
 		])
 		.then((result) => {
 			expect(result).toMatchObject([{}, { conformant: true }]);
-			expect(limiter._limitdRedis._num_tokens()).toBe(3);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(3);
 		})
-		.then(() => limiter.revert())
+		.then(() => limiterProcessor.revert())
 		.then(() => {
-			expect(limiter._limitdRedis._num_tokens()).toBe(0);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 			done();
 		});
 });
 
 test("Errors from the underlying service are propagated (put)", () => {
-	let limiter = limiterWithMockService((succeeds = false));
-	let endsInFailure = limiter.transfer("a", "b", -5);
+	let limiterProcessor = 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 limiter = limiterWithMockService((succeeds = false));
-	let endsInFailure = limiter.transfer("a", "b", 5);
+	let limiterProcessor = 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 limiter = limiterWithMockService((succeeds = true), (conforms = false));
-	let endsInFailure = limiter.transfer("a", "b", 5);
+	let limiterProcessor = 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 limiter = limiterWithMockService();
-	limiter
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor
 		.transfer("emailRate", "b", -5)
 		.then((result) => {
 			expect(result).toBe(null);
-			expect(limiter._limitdRedis._num_tokens()).toBe(5);
-			limiter.succeeds = false; // somebody is playing games
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
+			limiterProcessor.succeeds = false; // somebody is playing games
 		})
-		.then(() => limiter.transfer("emailRate", "b", 2))
+		.then(() => limiterProcessor.transfer("emailRate", "b", 2))
 		.catch(() => "failed uniquely!") // do nothing!
 		.then((result) => {
 			expect(result).toBe("failed uniquely!");
-			expect(limiter._limitdRedis._num_tokens()).toBe(5);
-			limiter.succeeds = true; // for real this time
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
+			limiterProcessor.succeeds = true; // for real this time
 		})
-		.then(() => limiter.revert())
+		.then(() => limiterProcessor.revert())
 		.then(() => {
-			expect(limiter._limitdRedis._num_tokens()).toBe(0);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 			done();
 		});
 });
 
 test("Properly handles spamming revert() calls", (done) => {
-	let limiter = limiterWithMockService();
-	limiter
+	let limiterProcessor = limiterWithMockService();
+	limiterProcessor
 		.transfer("a", "b", -5)
 		.then((result) => {
 			expect(result).toMatchObject({});
-			expect(limiter._limitdRedis._num_tokens()).toBe(5);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(5);
 		})
-		.then(() => limiter.transfer("a", "b", 2))
+		.then(() => limiterProcessor.transfer("a", "b", 2))
 		.then((result) => {
 			expect(result).toMatchObject({ conformant: true });
-			expect(limiter._limitdRedis._num_tokens()).toBe(3);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(3);
 		})
 		.then(() =>
 			Promise.all([
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
-				limiter.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
+				limiterProcessor.revert(),
 			])
 		)
 		.then(() => {
-			expect(limiter._limitdRedis._num_tokens()).toBe(0);
+			expect(limiterProcessor._limitdRedis._num_tokens()).toBe(0);
 			done();
 		});
 });

package/tests/performTestWithTestPerMinute.js

@@ -6,12 +6,13 @@ async function performTestWithTestPerMinute() {
 		limitdUrl: "localhost:6379",
 		console: console,
 	});
+	const limiterProcessor = limiter.getLimiterProcessor(console);
 	// take 2  # Conformant - Remaining: 1
-	const result1 = await limiter.transfer("testPerMinute", "key", 2);
+	const result1 = await limiterProcessor.transfer("testPerMinute", "key", 2);
 	console.log("First Turn Take Result", result1);
 
 	//Now Conformant - Remaining: 1
-	const result2 = await limiter
+	const result2 = await limiterProcessor
 		.transfer("testPerMinute", "key", 2)
 		.catch((err) => {
 			console.log("Second Turn Take Error", err.message);
@@ -19,11 +20,11 @@ async function performTestWithTestPerMinute() {
 	console.log("Second Turn Take Result", result2);
 
 	// Put 1
-	const result3 = await limiter.transfer("testPerMinute", "key", -1);
+	const result3 = await limiterProcessor.transfer("testPerMinute", "key", -1);
 	console.log("Third Turn PUT Result", result3);
 
 	//Now Conformant - Remaining: 2
-	const result4 = await limiter.transfer("testPerMinute", "key", 2);
+	const result4 = await limiterProcessor.transfer("testPerMinute", "key", 2);
 	console.log("Fourth Turn Take Result", result4);
 	process.exit(1);
 }

package/tests/sanityCheck.js

@@ -9,10 +9,11 @@ const buckets = {
 
 var limiter = new Limiter({
 	limitdUrl: "localhost:6379",
-	console: console,
 	buckets,
 });
 
+var limiterProcessor = limiter.getLimiterProcessor(console);
+
 var callback = function (err) {
 	if (err) {
 		console.log(err);
@@ -29,4 +30,4 @@ var withdrawls = [
 	["emailRate", process.argv[2], parseInt(process.argv[3])],
 ];
 
-limiter.transferAll(withdrawls).then(() => callback(), callback);
+limiterProcessor.transferAll(withdrawls).then(() => callback(), callback);