Don't wrapPlans() fields that use resolver emulation only (#2875)

Author: benjie

.changeset/lemon-cats-greet.md

@@ -0,0 +1,13 @@
+---
+"graphile-utils": patch
+---
+
+`wrapPlans()` now refuses to wrap the plan for a field that both has no plan and
+either has a `resolve()` or `subscribe()` method (i.e. resolver emulation will
+be used). This is done by simply skipping wrapping the resolver, and emitting a
+warning to the console. This is a breaking fix as fields that may have
+previously had the default plan resolver wrapped may no longer do so, but should
+not impact anyone running a "pure" PostGraphile/Grafast schema (it only impacts
+you if you are using traditional (non-plan) resolvers, e.g. via
+`extendSchema()`, and you're also using `wrapPlans()` to target these same
+fields).

graphile-build/graphile-utils/src/makeWrapPlansPlugin.ts

@@ -141,14 +141,34 @@ export function wrapPlans<T>(
           if (!planWrapper) {
             return field;
           }
-          const { plan: oldPlan = defaultPlanResolver } = field;
+          const { plan: oldPlan, resolve, subscribe } = field;
+
+          if (!oldPlan) {
+            if (resolve) {
+              console.warn(
+                `[WARNING]: \`wrapPlans(...)\` refusing to wrap ${Self.name}.${fieldName} since it has no plan and it has a resolver.`,
+              );
+              return field;
+            } else if (subscribe) {
+              console.warn(
+                `[WARNING]: \`wrapPlans(...)\` refusing to wrap ${Self.name}.${fieldName} since it has no plan and it has a subscription resolver.`,
+              );
+              return field;
+            } else {
+              console.warn(
+                `[WARNING]: \`wrapPlans(...)\` wrapping default plan resolver for ${Self.name}.${fieldName}; if resolver emulation is in use then things may go awry`,
+              );
+            }
+          }
+
           const typeName = Self.name;
           return {
             ...field,
             plan: EXPORTABLE(
               (
                 ExecutableStep,
                 autoApplyFieldArgs,
+                defaultPlanResolver,
                 fieldName,
                 inspect,
                 isExecutableStep,
@@ -164,7 +184,10 @@ export function wrapPlans<T>(
                         planParams.slice(overrideParams.length),
                       ),
                     ] as typeof planParams;
-                    const $prev = oldPlan.apply(this, args);
+                    const $prev = (oldPlan ?? defaultPlanResolver).apply(
+                      this,
+                      args,
+                    );
                     if (!($prev instanceof ExecutableStep)) {
                       console.error(
                         `Wrapped a plan function at ${typeName}.${fieldName}, but that function did not return a step!\n${String(
@@ -205,6 +228,7 @@ export function wrapPlans<T>(
               [
                 ExecutableStep,
                 autoApplyFieldArgs,
+                defaultPlanResolver,
                 fieldName,
                 inspect,
                 isExecutableStep,