refactor: changes after review

Author: nodkz

src/composeBull.ts

@@ -1,4 +1,8 @@
-import { schemaComposer, SchemaComposer } from 'graphql-compose';
+import {
+  schemaComposer,
+  SchemaComposer,
+  ObjectTypeComposerFieldConfigAsObjectDefinition,
+} from 'graphql-compose';
 import { Options } from './definitions';
 import { getQueueTC, getJobTC } from './types';
 import { createQueuesFC, createQueueKeysFC, createQueueFC, createJobFC } from './query';
@@ -19,22 +23,54 @@ import {
   createJobUpdateFC,
   createJobLogAddFC,
 } from './mutation';
-import { createMutationFC, predefineQueueArgs } from './helpers';
+import { createMutationFC, wrapQueueArgs } from './helpers';
 
 export function composeBull(opts: Options & { schemaComposer?: SchemaComposer<any> }) {
   const sc = opts?.schemaComposer || schemaComposer;
 
+  /**
+   * Compose several FC creator with middlewares
+   *  Eg. composeFC(sc, opts)(createQueueKeysFC, wrapQueueArgs, wrapOtherMiddleware)
+   *  Will work like the following code:
+   *    let fc = createQueueKeysFC(sc, opts);
+   *    fc = wrapQueueArgs(fc, sc, opts)
+   *    fc = wrapOtherMiddleware(fc, sc, opts)
+   *    return fc;
+   */
+  function composeFC(sc: SchemaComposer<any>, opts: Options) {
+    return (
+      creator: (
+        sc: SchemaComposer<any>,
+        opts: Options
+      ) => ObjectTypeComposerFieldConfigAsObjectDefinition<any, any>,
+      ...middlewares: ((
+        fc: ObjectTypeComposerFieldConfigAsObjectDefinition<any, any>,
+        sc: SchemaComposer<any>,
+        opts: Options
+      ) => ObjectTypeComposerFieldConfigAsObjectDefinition<any, any>)[]
+    ): ObjectTypeComposerFieldConfigAsObjectDefinition<any, any> => {
+      let fc = creator(sc, opts);
+      for (let i = 0; i < middlewares.length; i++) {
+        fc = middlewares[i](fc, sc, opts);
+      }
+      return fc;
+    };
+  }
+
+  const wrap = composeFC(sc, opts);
+
   return {
     QueueTC: getQueueTC(sc, opts),
     JobTC: getJobTC(sc, opts),
     queryFields: {
-      queueKeys: predefineQueueArgs(createQueueKeysFC(sc, opts), opts),
+      queueKeys: wrap(createQueueKeysFC, wrapQueueArgs),
       queues: predefineQueueArgs(createQueuesFC(sc, opts), opts),
       queue: predefineQueueArgs(createQueueFC(sc, opts), opts),
       job: predefineQueueArgs(createJobFC(sc, opts), opts),
     },
     mutationFields: {
-      queueClean: predefineQueueArgs(createMutationFC(createQueueCleanFC, sc, opts), opts),
+      queueClean: wrap(createQueueCleanFC, createMutationFC, predefineQueueArgs),
+      // queueClean: predefineQueueArgs(createMutationFC(createQueueCleanFC, sc, opts), opts),
       queueDrain: predefineQueueArgs(createMutationFC(createQueueDrainFC, sc, opts), opts),
       queuePause: predefineQueueArgs(createMutationFC(createQueuePauseFC, sc, opts), opts),
       queueResume: predefineQueueArgs(createMutationFC(createQueueResumeFC, sc, opts), opts),

src/definitions.ts

@@ -1,5 +1,5 @@
 import { ObjectTypeComposer } from 'graphql-compose';
-import Redis, { RedisOptions } from 'ioredis';
+import IORedis, { RedisOptions } from 'ioredis';
 
 export type Options = {
   typePrefix: string;
@@ -8,10 +8,5 @@ export type Options = {
     name: string;
     prefix: string;
   };
-  redis?:
-    | {
-        uri?: string;
-        opts?: RedisOptions;
-      }
-    | Redis.Redis;
+  redis?: RedisOptions | IORedis.Redis;
 };

src/helpers/getBullConnection.ts

@@ -1,22 +1,23 @@
 import { Options } from './../definitions';
 import Redis from 'ioredis';
 
-let connection: Redis.Redis;
+const connectionMap = new Map<Options['redis'], Redis.Redis>();
 
 export function getBullConnection(opts: Options): Redis.Redis {
+  let connection = connectionMap.get(opts.redis);
   if (connection) {
     return connection;
   }
 
-  if (opts.redis instanceof Redis) {
+  if (opts?.redis instanceof Redis) {
     connection = opts.redis;
-  } else if (opts?.redis?.uri) {
-    connection = new Redis(opts.redis.uri);
-  } else if (opts?.redis?.opts) {
-    connection = new Redis(opts.redis.opts);
+  } else if (opts?.redis) {
+    connection = new Redis(opts.redis);
   } else {
     connection = new Redis();
   }
 
+  connectionMap.set(opts.redis, connection);
+
   return connection;
 }

src/helpers/index.ts

@@ -3,4 +3,4 @@ export * from './queueTitles';
 export * from './MutationError';
 export * from './normalizePrefixGlob';
 export * from './wrapMutationFC';
-export * from './predefineQueueArgs';
+export * from './wrapQueueArgs';

src/helpers/predefineQueueArgs.ts

@@ -0,0 +1,30 @@
+import { Options } from '../definitions';
+import { ObjectTypeComposerFieldConfigAsObjectDefinition, SchemaComposer } from 'graphql-compose';
+
+export function wrapQueueArgs(
+  fieldConfig: ObjectTypeComposerFieldConfigAsObjectDefinition<any, any>,
+  sc: SchemaComposer<any>,
+  opts: Options
+): ObjectTypeComposerFieldConfigAsObjectDefinition<any, any> {
+  // remove args if they provided via config
+  if (opts?.queue?.name && fieldConfig.args?.queueName) {
+    delete fieldConfig.args.queueName;
+  }
+  if (opts?.queue?.prefix && fieldConfig.args?.prefix) {
+    delete fieldConfig.args.prefix;
+  }
+
+  // pass config props to sub resolve issue
+  if (opts?.queue?.name || opts?.queue?.prefix) {
+    const predifinedArgs = {} as Record<string, any>;
+    if (opts?.queue?.name) predifinedArgs.queueName = opts.queue?.name;
+    if (opts?.queue?.prefix) predifinedArgs.prefix = opts.queue?.prefix;
+
+    const subResolve = fieldConfig.resolve || (() => ({}));
+    fieldConfig.resolve = async (source, args, context, info) => {
+      return subResolve(source, { ...predifinedArgs, ...args }, context, info);
+    };
+  }
+
+  return fieldConfig;
+}