Refactor to allow operator name reuse across types

Author: mattbretl

src/ConnectionArgFilterPlugin.js

@@ -7,51 +7,103 @@ module.exports = function ConnectionArgFilterPlugin(
   } = {}
 ) {
   builder.hook("build", build => {
-    const connectionFilterOperators = {};
-    return build.extend(build, {
-      connectionFilterOperators,
-      addConnectionFilterOperator(
-        defaultName,
-        description,
-        resolveType,
-        resolveWhereClause,
-        options = {}
+    const connectionFilterOperatorsByFieldType = {};
+    const connectionFilterOperatorsGlobal = {};
+
+    const addConnectionFilterOperator = (
+      defaultName,
+      description,
+      resolveType,
+      resolveWhereClause,
+      options = {}
+    ) => {
+      if (!defaultName) {
+        throw new Error(
+          `Missing argument 'defaultName' in call to 'addConnectionFilterOperator'`
+        );
+      }
+      if (!resolveType) {
+        throw new Error(
+          `Missing argument 'resolveType' for filter operator '${defaultName}'`
+        );
+      }
+      if (!resolveWhereClause) {
+        throw new Error(
+          `Missing argument 'resolveWhereClause' for filter operator '${defaultName}'`
+        );
+      }
+
+      // If `connectionFilterOperatorNames` is specified, override the operator name
+      const operatorName =
+        connectionFilterOperatorNames[defaultName] || defaultName;
+
+      // If `connectionFilterAllowedOperators` is specified and this operator isn't included, skip it
+      if (
+        connectionFilterAllowedOperators &&
+        !connectionFilterAllowedOperators.includes(operatorName)
       ) {
-        if (!defaultName) {
-          throw new Error("No filter operator defaultName specified");
-        }
-        const name = connectionFilterOperatorNames[defaultName] || defaultName;
-        if (connectionFilterOperators[name]) {
-          throw new Error(
-            "There is already a filter operator with the name '" + name + "'"
-          );
-        }
-        if (!resolveType) {
-          throw new Error(
-            "No filter operator type specified for '" + name + "'"
-          );
-        }
-        if (!resolveWhereClause) {
-          throw new Error(
-            "No filter operator where clause resolver specified for '" +
-              name +
-              "'"
-          );
-        }
-        if (
-          !connectionFilterAllowedOperators ||
-          connectionFilterAllowedOperators.includes(defaultName)
-        ) {
-          connectionFilterOperators[name] = {
-            name,
+        return;
+      }
+
+      if (connectionFilterOperatorsGlobal[operatorName]) {
+        throw new Error(
+          `Failed to register filter operator '${operatorName}' because this operator is already registered globally`
+        );
+      }
+
+      if (options.allowedFieldTypes) {
+        // Operator has an `allowedFieldTypes` whitelist
+        for (const fieldTypeName of options.allowedFieldTypes) {
+          // Ensure operator name hasn't already been registered for this field type
+          if (
+            connectionFilterOperatorsByFieldType[fieldTypeName] &&
+            connectionFilterOperatorsByFieldType[fieldTypeName][operatorName]
+          ) {
+            throw new Error(
+              `Failed to register filter operator '${operatorName}' because this operator is already registered for type '${fieldTypeName}'`
+            );
+          }
+
+          // Register operator for this field type
+          if (!connectionFilterOperatorsByFieldType[fieldTypeName]) {
+            connectionFilterOperatorsByFieldType[fieldTypeName] = {};
+          }
+          connectionFilterOperatorsByFieldType[fieldTypeName][operatorName] = {
             description,
             resolveType,
             resolveWhereClause,
             options,
           };
         }
-      },
+      } else {
+        // Operator does not have an `allowedFieldTypes` whitelist
+
+        // Ensure operator name hasn't been registered for any field type
+        Object.entries(connectionFilterOperatorsByFieldType).forEach(
+          ([fieldTypeName, operators]) => {
+            if (Object.keys(operators).includes(operatorName)) {
+              throw new Error(
+                `Failed to register global filter operator '${operatorName}' because this operator is already registered for type '${fieldTypeName}'`
+              );
+            }
+          }
+        );
+
+        // Register operator globally
+        connectionFilterOperatorsGlobal[operatorName] = {
+          description,
+          resolveType,
+          resolveWhereClause,
+          options,
+        };
+      }
+    };
+
+    return build.extend(build, {
+      addConnectionFilterOperator,
       connectionFilterAllowedFieldTypes,
+      connectionFilterOperatorsByFieldType,
+      connectionFilterOperatorsGlobal,
     });
   });
 

src/PgConnectionArgFilterPlugin.js

@@ -216,11 +216,14 @@ module.exports = function PgConnectionArgFilterPlugin(
         GraphQLList,
         GraphQLScalarType,
         GraphQLEnumType,
+        GraphQLString,
       },
       inflection,
+      pgGetGqlInputTypeByTypeIdAndModifier,
       pgSql: sql,
       connectionFilterAllowedFieldTypes,
-      connectionFilterOperators,
+      connectionFilterOperatorsByFieldType,
+      connectionFilterOperatorsGlobal,
     } = build;
 
     const getOrCreateFieldFilterTypeFromFieldType = (
@@ -246,19 +249,19 @@ module.exports = function PgConnectionArgFilterPlugin(
             } fields. All fields are combined with a logical ‘and.’`,
             fields: context => {
               const { fieldWithHooks } = context;
-              return Object.keys(connectionFilterOperators).reduce(
-                (memo, operatorName) => {
-                  const operator = connectionFilterOperators[operatorName];
-                  const allowedFieldTypes = operator.options.allowedFieldTypes;
-                  const fieldTypeIsAllowed =
-                    !allowedFieldTypes ||
-                    allowedFieldTypes.includes(namedTypeName);
+              const operators = Object.assign(
+                {},
+                connectionFilterOperatorsGlobal,
+                connectionFilterOperatorsByFieldType[namedTypeName]
+              );
+              return Object.entries(operators).reduce(
+                (memo, [operatorName, operator]) => {
                   const allowedListTypes = operator.options
                     .allowedListTypes || ["NonList"];
                   const listTypeIsAllowed = isListType
                     ? allowedListTypes.includes("List")
                     : allowedListTypes.includes("NonList");
-                  if (fieldTypeIsAllowed && listTypeIsAllowed) {
+                  if (listTypeIsAllowed) {
                     memo[operatorName] = fieldWithHooks(operatorName, {
                       description: operator.description,
                       type: operator.resolveType(fieldType),
@@ -355,7 +358,17 @@ module.exports = function PgConnectionArgFilterPlugin(
       pgType,
       pgTypeModifier
     ) => {
-      const operator = connectionFilterOperators[operatorName];
+      const fieldType = getNamedType(
+        pgGetGqlInputTypeByTypeIdAndModifier(pgType.id, pgTypeModifier) ||
+          GraphQLString
+      );
+      const operator =
+        connectionFilterOperatorsGlobal[operatorName] ||
+        (connectionFilterOperatorsByFieldType[fieldType.name] &&
+          connectionFilterOperatorsByFieldType[fieldType.name][operatorName]);
+      if (!operator) {
+        throw new Error(`Unable to resolve operator '${operatorName}'`);
+      }
       const inputResolver = operator.options.inputResolver;
       const val = operator.options.resolveWithRawInput
         ? input