@withjoy/limiter 0.1.7 → 0.2.1

package/README.md

@@ -24,16 +24,16 @@ Your client can use any subset of these Buckets, but when it does, the Best Prac
 However, for flexibility reasons, this is not strictly enforced.
 
 ## Why limitd-redis ?
-Although this package is available on npm, it's no longer actively maintained. We've observed bugs in the existing published version, but these issues have already been resolved in the [limitd-redis](https://github.com/auth0/limitd-redis) gitHub repository. To address this, we've imported the latest stable version(v7.8.1) from there github repository and using it locally in the limiter.
+Although this package is available on npm, it's no longer actively maintained. We've observed bugs in the existing published version, but these issues have already been resolved in the [limitd-redis](https://github.com/auth0/limitd-redis) gitHub repository. To address this, we've imported the latest stable version(v7.8.1) from there github repository and using it locally in the `limiter`.
 
 In case we need to update in the future, we can replace the "limitd-redis" directory with the latest version of [limitd-redis](https://github.com/auth0/limitd-redis) from their GitHub repository.
 
-Note: We need to add dependency from limitd-redis to limiter package json before publish. We are using limitd-redis as directly not package inside limiter. 
+Note: We need to add dependency from `limitd-redis` to `limiter` package json before publish. We are using `limitd-redis` as directly not package inside `limiter`.
 
 ## Testing:
 
 `npm run test` will run offline tests using a mock.
-`npm run sanity-check` will run against a limitd service configured to run with the test buckets.
+`npm run sanity-check` will run against a `limitd` service configured to run with the test buckets.
 
 
 ## Quick Test

package/limiter.js

@@ -89,12 +89,36 @@ const limiterRetryConfig = z
 	.strict()
 	.default(LIMITER_RETRY_DEFAULTS);
 
+// from  https://github.com/auth0/limitd-redis#buckets
+const limiterBucketConfig = z.object({
+	size: z.number(),
+	per_day: z.number().optional(),
+	per_hour: z.number().optional(),
+	per_minute: z.number().optional(),
+	per_second: z.number().optional(),
+	// and that's all we care about
+	//   we need more?  implement more of the `limitd-redis` schema
+});
+
+const limiterConfig = z
+	.object({
+		limitdUrl: z.string(),
+		// the rest are optional / have defaults
+		buckets: z.record(z.string(), limiterBucketConfig).optional(),
+		keyPrefix: z.string().default(defaultRedisKeyPrefix),
+		circuitbreaker: limiterCircuitBreakerConfig,
+		retry: limiterRetryConfig,
+		commandTimeout: z.number().default(30),
+	})
+	.strict();
+;
+
 class Limiter {
 	// static defaultBuckets;
 	// static pickDefaultBuckets(keys) { ... };
 
 	constructor(config) {
-		this._config = config;
+		this._config = limiterConfig.parse(config);
 		this._limitdRedisConnectionPromise = this.connect();
 	}
 
@@ -105,12 +129,12 @@ class Limiter {
 	*/
 	connect() {
 		return new Promise((resolve, reject) => {
-let buckets = this._config.buckets || {};
+			let buckets = this._config.buckets || {};
 			buckets = {
 				...defaultBuckets,
 				...buckets,
 			};
-			const keyPrefix = this._config.keyPrefix || defaultRedisKeyPrefix;
+			const keyPrefix = this._config.keyPrefix;
 			if (!connection) {
 				connection = new LimitdRedis({
 					uri: this._config.limitdUrl,
@@ -137,6 +161,9 @@ let buckets = this._config.buckets || {};
 	close() {
 		return new Promise(async (resolve, reject) => {
 			const connectionPromise = await this._limitdRedisConnectionPromise;
+			if (!connectionPromise) {
+				return resolve(null);
+			}
 			connectionPromise.close((err, resp) => {
 				if (err) {
 					this._console.error(err);
@@ -152,11 +179,26 @@ let buckets = this._config.buckets || {};
 class LimiterProcessor {
 
 	constructor(console) {
-		this._console = console;
+		this._console = this._normalizeConsole(console);
 		this._operationList = [];
 		this._limitdRedis = connection;
 	}
 
+	/**
+	 * Normalize logger interface to ensure .info method exists
+	 * Maps .log or .verbose to .info if .info doesn't exist
+	 *
+	 * TODO: Once we migrate to TypeScript and define a formal ILimiterLogger interface,
+	 * this normalization should no longer be needed. The interface will enforce the
+	 * required .info() and .error() methods at compile time.
+	 */
+	_normalizeConsole(console) {
+		if (!console.info) {
+			console.info = (console.log || console.verbose || (() => {})).bind(console);
+		}
+		return console;
+	}
+
 	/*
 		Go through the log of things we did and do the opposite
 	*/
@@ -254,7 +296,11 @@ Limiter.pickDefaultBuckets = function pickDefaultBuckets(keyArray) {
 	}
 	return buckets;
 };
+
+// schemas
 Limiter.limiterCircuitBreakerConfig = limiterCircuitBreakerConfig;
 Limiter.limiterRetryConfig = limiterRetryConfig;
+Limiter.limiterBucketConfig = limiterBucketConfig;
+Limiter.limiterConfig = limiterConfig;
 
 module.exports = Limiter;

package/package.json

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

package/tests/limiter.test.js

@@ -54,7 +54,109 @@ const limiterWithMockService = async (succeeds = true, conforms = true) => {
 	return limiterProcessor;
 };
 
-test("perfrom limitd-redis testing with test bucket", async (done) => {
+describe("Limiter", () => {
+	let limiter;
+	beforeEach(() => {
+		jest.spyOn(Limiter.prototype, "connect").mockImplementation(async () => Promise.resolve());
+	});
+	afterEach(async () => {
+		await limiter.close();
+		jest.restoreAllMocks();
+	});
+
+	describe("constructor", () => {
+		it('accepts maximal valid configuration', () => {
+			limiter = new Limiter({
+				limitdUrl: 'localhost:6379',
+				buckets: {
+					...TEST_BUCKETS,
+					perDay: { size: 11, per_day: 11 },
+					perMinute: { size: 21, per_minute: 21 },
+					perSecond: { size: 31, per_second: 31 },
+				},
+				keyPrefix: 'maximal:',
+				circuitbreaker: {
+					timeout: '41s',
+					maxFailures: 42,
+					cooldown: '43s',
+					maxCooldown: '44s',
+					name: 'maximal',
+				},
+				retry: {
+					retries: 51,
+					minTimeout: 52,
+					maxTimeout: 53,
+				},
+				commandTimeout: 61,
+			});
+			expect(limiter._config.limitdUrl).toBe('localhost:6379');
+			expect(limiter._config.buckets.perDay.size).toBe(11);
+			expect(limiter._config.keyPrefix).toBe('maximal:');
+			expect(limiter._config.circuitbreaker.timeout).toBe('41s');
+			expect(limiter._config.retry.retries).toBe(51);
+			expect(limiter._config.commandTimeout).toBe(61);
+		});
+
+		it("accepts minimum valid configuration", async () => {
+			limiter = new Limiter({
+				limitdUrl: 'localhost:6379',
+			});
+			expect(limiter._config.limitdUrl).toBe('localhost:6379');
+			expect(limiter._config.buckets).toBeUndefined();
+			expect(limiter._config.keyPrefix).toBe('limitdRedis:');
+			expect(limiter._config.circuitbreaker.timeout).toBe('0.50s');
+			expect(limiter._config.retry.retries).toBe(3);
+			expect(limiter._config.commandTimeout).toBe(30);
+		});
+
+		it("fails on invalid bucket configuration", () => {
+			expect(() => {
+				limiter = new Limiter({
+					limitdUrl: 'localhost:6379',
+					buckets: {
+						invalidBucket: { size: 'string' }, // Poisoning with an invalid size
+					},
+				});
+			}).toThrow(/"invalidBucket"/);
+		});
+
+		it("cannot fail on invalid circuitbreaker configuration", () => {
+			expect(() => {
+				limiter = new Limiter({
+					limitdUrl: 'localhost:6379',
+					circuitbreaker: {
+						timeout: 'still-valid',
+					},
+				});
+			}).not.toThrow();
+		});
+
+		it("fails on invalid retry configuration", () => {
+			expect(() => {
+				limiter = new Limiter({
+					limitdUrl: 'localhost:6379',
+					retry: {
+						retries: 'not-a-number', // Poisoning with an invalid number of retries
+						minTimeout: 52,
+						maxTimeout: 53,
+					},
+				});
+			}).toThrow(/"retries"/);
+		});
+
+		it("fails when limitdUrl is missing", () => {
+			expect(() => {
+				limiter = new Limiter({
+					buckets: {
+						emails: { size: 10 },
+					},
+				});
+			}).toThrow(/"limitdUrl"/);
+		});
+	});
+});
+
+test("perform limitd-redis testing with test bucket", async (done) => {
 	const limiter = new Limiter({
 		limitdUrl: "localhost:6379",
 		buckets: {