resolved mergo conflicts from dev

Author: evanmcneely

.eslintrc.json

@@ -19,10 +19,12 @@
     },
     "plugins": ["import", "prettier"],
     "rules": {
-        
+        "no-plusplus": [2, {
+            "allowForLoopAfterthoughts": true
+        }],
         "prettier/prettier": [
             "error"
         ]
     }, 
-    "ignorePatterns": ["jest.config.js"]
+    "ignorePatterns": ["jest.config.ts"]
 }

jest.config.js

@@ -0,0 +1,11 @@
+import type { Config } from '@jest/types';
+
+const config: Config.InitialOptions = {
+    verbose: true,
+    roots: ['./test'],
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    moduleFileExtensions: ['js', 'ts'],
+};
+
+export default config;

jest.config.ts

@@ -3,10 +3,11 @@
     "version": "1.0.0",
     "description": "A GraphQL rate limiting library using query complexity analysis.",
     "main": "index.js",
+    "type": "module",
     "scripts": {
         "test": "jest --passWithNoTests",
         "lint": "eslint src test",
-        "lint:fix": "eslint --fix src test",
+        "lint:fix": "eslint --fix src test @types",
         "prettier": "prettier --write .",
         "prepare": "husky install"
     },
@@ -25,9 +26,10 @@
         "@babel/core": "^7.17.12",
         "@babel/preset-env": "^7.17.12",
         "@babel/preset-typescript": "^7.17.12",
+        "@types/ioredis": "^4.28.10",
+        "@types/ioredis-mock": "^5.6.0",
         "@types/express": "^4.17.13",
         "@types/jest": "^27.5.1",
-        "@types/redis-mock": "^0.17.1",
         "@typescript-eslint/eslint-plugin": "^5.24.0",
         "@typescript-eslint/parser": "^5.24.0",
         "babel-jest": "^28.1.0",
@@ -42,8 +44,8 @@
         "jest": "^28.1.0",
         "lint-staged": "^12.4.1",
         "prettier": "2.6.2",
-        "redis-mock": "^0.56.3",
         "ts-jest": "^28.0.2",
+        "ts-node": "^10.8.0",
         "typescript": "^4.6.4"
     },
     "lint-staged": {
@@ -52,7 +54,7 @@
     },
     "dependencies": {
         "graphql": "^16.5.0",
-        "ioredis": "^5.0.5",
-        "redis": "^4.1.0"
+        "ioredis": "^5.0.5"
+
     }
 }

package-lock.json

@@ -40,4 +40,6 @@ interface TokenBucketOptions {
 }
 
 // TODO: This will be a union type where we can specify Option types for other Rate Limiters
-type RateLimiterOptions = TokenBucketOptions;
+// Record<string, never> represents the empty object for alogorithms that don't require settings
+// and might be able to be removed in the future.
+type RateLimiterOptions = TokenBucketOptions | Record<string, never>;

package.json

@@ -21,7 +21,8 @@ import getQueryTypeComplexity from '../analysis/typeComplexityAnalysis';
  * Defaults to {mutation: 10, object: 1, field: 0, connection: 2}
  * @returns {RequestHandler} express middleware that computes the complexity of req.query and calls the next middleware
  * if the query is allowed or sends a 429 status if the request is blocked
- * @throws ValidationError if GraphQL Schema is invalid
+ * FIXME: How about the specific GraphQLError?
+ * @throws ValidationError if GraphQL Schema is invalid.
  */
 export function expressRateLimiter(
     rateLimiterAlgo: RateLimiterSelection,

src/@types/rateLimit.d.ts

@@ -43,15 +43,67 @@ class TokenBucket implements RateLimiter {
         timestamp: number,
         tokens = 1
     ): Promise<RateLimiterResponse> {
-        throw Error(`TokenBucket.processRequest not implemented, ${this}`);
+        // set the expiry of key-value pairs in the cache to 24 hours
+        const keyExpiry = 86400000;
+
+        // attempt to get the value for the uuid from the redis cache
+        const bucketJSON = await this.client.get(uuid);
+
+        // if the response is null, we need to create a bucket for the user
+        if (bucketJSON === null) {
+            const newUserBucket: RedisBucket = {
+                // conditionally set tokens depending on how many are requested comapred to the capacity
+                tokens: tokens > this.capacity ? this.capacity : this.capacity - tokens,
+                timestamp,
+            };
+            // reject the request, not enough tokens could even be in the bucket
+            if (tokens > this.capacity) {
+                await this.client.setex(uuid, keyExpiry, JSON.stringify(newUserBucket));
+                return { success: false, tokens: this.capacity };
+            }
+            await this.client.setex(uuid, keyExpiry, JSON.stringify(newUserBucket));
+            return { success: true, tokens: newUserBucket.tokens };
+        }
+
+        // parse the returned string from redis and update their token budget based on the time lapse between queries
+        const bucket: RedisBucket = await JSON.parse(bucketJSON);
+        bucket.tokens = this.calculateTokenBudgetFromTimestamp(bucket, timestamp);
+
+        const updatedUserBucket = {
+            // conditionally set tokens depending on how many are requested comapred to the bucket
+            tokens: bucket.tokens < tokens ? bucket.tokens : bucket.tokens - tokens,
+            timestamp,
+        };
+        if (bucket.tokens < tokens) {
+            // reject the request, not enough tokens in bucket
+            await this.client.setex(uuid, keyExpiry, JSON.stringify(updatedUserBucket));
+            return { success: false, tokens: bucket.tokens };
+        }
+        await this.client.setex(uuid, keyExpiry, JSON.stringify(updatedUserBucket));
+        return { success: true, tokens: updatedUserBucket.tokens };
     }
 
     /**
      * Resets the rate limiter to the intial state by clearing the redis store.
      */
-    reset(): void {
-        throw Error(`TokenBucket.reset not implemented, ${this}`);
+    public reset(): void {
+        this.client.flushall();
     }
+
+    /**
+     * Calculates the tokens a user bucket should have given the time lapse between requests.
+     */
+    private calculateTokenBudgetFromTimestamp = (
+        bucket: RedisBucket,
+        timestamp: number
+    ): number => {
+        const timeSinceLastQueryInSeconds: number = Math.floor(
+            (timestamp - bucket.timestamp) / 1000 // 1000 ms in a second
+        );
+        const tokensToAdd = timeSinceLastQueryInSeconds * this.refillRate;
+        const updatedTokenCount = bucket.tokens + tokensToAdd;
+        return updatedTokenCount > this.capacity ? this.capacity : updatedTokenCount;
+    };
 }
 
 export default TokenBucket;