@withjoy/limiter 0.1.1 → 0.1.3

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._limitdRedisConnectionPromise = this.connect();
 	}
 
 	/*
@@ -54,21 +52,54 @@ 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 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,
+				});
+				connection.db.on('ready', () => {
+					return resolve(connection);
+				});
+			} else {
+				return resolve(connection);
+			}
+		});
+	}
+
+	async getLimiterProcessor(console) {
+		await this._limitdRedisConnectionPromise;
+		return new LimiterProcessor(console);
+	}
+
+	close() {
+		return new Promise(async (resolve, reject) => {
+			const connectionPromise = await this._limitdRedisConnectionPromise;
+			connectionPromise.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;
-		return connection;
 	}
 
 	/*
@@ -97,18 +128,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 +192,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.3",
   "description": "Api Rate limiter",
   "main": "limiter.js",
   "scripts": {

package/tests/limiter.test.js

@@ -16,15 +16,14 @@ 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({
-		console: console,
 		limitdUrl: "localhost:6379",
 		buckets: TEST_BUCKETS,
 	});
-
-	limiter._limitdRedis = new (class MockLimitd {
+	const limiterProcessor = await 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 = await 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,
@@ -94,177 +93,177 @@ 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 limiter = limiterWithMockService();
-	limiter.transfer("a", "b", 0, null).then((result) => {
+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(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) => {
+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(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) => {
+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(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
+test("Reverts all taken tokens when revert is called", async (done) => {
+	let limiterProcessor = await 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
+test("Reverts all given tokens when revert is called", async (done) => {
+	let limiterProcessor = await 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
+test("Reverts a series of actions when revert is called", async (done) => {
+	let limiterProcessor = await 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
+test("Properly executes a transferAll()", async (done) => {
+	let limiterProcessor = await 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);
+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 limiter = limiterWithMockService((succeeds = false));
-	let endsInFailure = limiter.transfer("a", "b", 5);
+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 limiter = limiterWithMockService((succeeds = true), (conforms = false));
-	let endsInFailure = limiter.transfer("a", "b", 5);
+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 limiter = limiterWithMockService();
-	limiter
+test("An operation that fails is not logged", async (done) => {
+	let limiterProcessor = await 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
+test("Properly handles spamming revert() calls", async (done) => {
+	let limiterProcessor = await 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 = await 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

@@ -2,31 +2,36 @@
 
 var Limiter = require("../limiter");
 
-const buckets = {
-	emails: { size: 10 },
-	emailRate: { size: 10, per_hour: 10 },
-};
-
-var limiter = new Limiter({
-	limitdUrl: "localhost:6379",
-	console: console,
-	buckets,
-});
-
-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])],
-];
-
-limiter.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();