added descriptive error handling to middleware setup

Author: evanmcneely

src/analysis/buildTypeWeights.ts

@@ -417,22 +417,28 @@ function buildTypeWeightsFromSchema(
     typeWeightsConfig: TypeWeightConfig = defaultTypeWeightsConfig,
     enforceBoundedLists = false
 ): TypeWeightObject {
-    if (!schema) throw new Error('Missing Argument: schema is required');
+    try {
+        if (!schema) throw new Error('Missing Argument: schema is required');
 
-    //  Merge the provided type weights with the default to account for missing values
-    const typeWeights: TypeWeightSet = {
-        ...defaultTypeWeightsConfig,
-        ...typeWeightsConfig,
-    };
+        //  Merge the provided type weights with the default to account for missing values
+        const typeWeights: TypeWeightSet = {
+            ...defaultTypeWeightsConfig,
+            ...typeWeightsConfig,
+        };
 
-    // Confirm that any custom weights are non-negative
-    Object.entries(typeWeights).forEach((value: [string, number]) => {
-        if (value[1] < 0) {
-            throw new Error(`Type weights cannot be negative. Received: ${value[0]}: ${value[1]} `);
-        }
-    });
+        // Confirm that any custom weights are non-negative
+        Object.entries(typeWeights).forEach((value: [string, number]) => {
+            if (value[1] < 0) {
+                throw new Error(
+                    `Type weights cannot be negative. Received: ${value[0]}: ${value[1]} `
+                );
+            }
+        });
 
-    return parseTypes(schema, typeWeights, enforceBoundedLists);
+        return parseTypes(schema, typeWeights, enforceBoundedLists);
+    } catch (err) {
+        throw new Error(`Error in expressGraphQLRateLimiter when parsing schema object: ${err}`);
+    }
 }
 
 export default buildTypeWeightsFromSchema;

src/middleware/index.ts

@@ -46,11 +46,15 @@ export default function expressGraphQLRateLimiter(
         enforceBoundedLists: middlewareConfig.enforceBoundedLists || false,
         depthLimit: middlewareConfig.depthLimit || Infinity,
     };
+    if (middlewareSetup.depthLimit <= 1) {
+        throw new Error(
+            `Error in expressGraphQLRateLimiter: depthLimit cannot be less than or equal to 1`
+        );
+    }
     /**
      * build the type weight object, create the redis client and instantiate the ratelimiter
      * before returning the express middleware that calculates query complexity and throttles the requests
      */
-    // FIXME: Error handling
     const typeWeightObject = buildTypeWeightsFromSchema(
         schema,
         middlewareSetup.typeWeights,

src/middleware/rateLimiterSetup.ts

@@ -19,31 +19,45 @@ export default function setupRateLimiter(
     client: Redis,
     keyExpiry: number
 ) {
-    switch (rateLimiter.type) {
-        case 'TOKEN_BUCKET':
-            return new TokenBucket(rateLimiter.capacity, rateLimiter.refillRate, client, keyExpiry);
-            break;
-        case 'LEAKY_BUCKET':
-            throw new Error('Leaky Bucket algonithm has not be implemented.');
-        case 'FIXED_WINDOW':
-            return new FixedWindow(rateLimiter.capacity, rateLimiter.windowSize, client, keyExpiry);
-        case 'SLIDING_WINDOW_LOG':
-            return new SlidingWindowLog(
-                rateLimiter.windowSize,
-                rateLimiter.capacity,
-                client,
-                keyExpiry
-            );
-        case 'SLIDING_WINDOW_COUNTER':
-            return new SlidingWindowCounter(
-                rateLimiter.windowSize,
-                rateLimiter.capacity,
-                client,
-                keyExpiry
-            );
-            break;
-        default:
-            // typescript should never let us invoke this function with anything other than the options above
-            throw new Error('Selected rate limiting algorithm is not suppported');
+    try {
+        switch (rateLimiter.type) {
+            case 'TOKEN_BUCKET':
+                return new TokenBucket(
+                    rateLimiter.capacity,
+                    rateLimiter.refillRate,
+                    client,
+                    keyExpiry
+                );
+                break;
+            case 'LEAKY_BUCKET':
+                throw new Error('Leaky Bucket algonithm has not be implemented.');
+            case 'FIXED_WINDOW':
+                return new FixedWindow(
+                    rateLimiter.capacity,
+                    rateLimiter.windowSize,
+                    client,
+                    keyExpiry
+                );
+            case 'SLIDING_WINDOW_LOG':
+                return new SlidingWindowLog(
+                    rateLimiter.windowSize,
+                    rateLimiter.capacity,
+                    client,
+                    keyExpiry
+                );
+            case 'SLIDING_WINDOW_COUNTER':
+                return new SlidingWindowCounter(
+                    rateLimiter.windowSize,
+                    rateLimiter.capacity,
+                    client,
+                    keyExpiry
+                );
+                break;
+            default:
+                // typescript should never let us invoke this function with anything other than the options above
+                throw new Error('Selected rate limiting algorithm is not suppported');
+        }
+    } catch (err) {
+        throw new Error(`Error in expressGraphQLRateLimiter setting up rate-limiter: ${err}`);
     }
 }

src/utils/redis.ts

@@ -9,9 +9,13 @@ const clients: Redis[] = [];
 export function connect(options: RedisOptions): Redis {
     // TODO: Figure out what other options we should set (timeouts, etc)
     // TODO: pass on connection error
-    const client: Redis = new Redis(options);
-    clients.push(client);
-    return client;
+    try {
+        const client: Redis = new Redis(options);
+        clients.push(client);
+        return client;
+    } catch (err) {
+        throw new Error(`Error in expressGraphQLRateLimiter when connecting to redis: ${err}`);
+    }
 }
 
 /**