grafast 0.1.1-beta.11 → 0.1.1-beta.13

package/dist/engine/OperationPlan.js

@@ -170,10 +170,6 @@ class OperationPlan {
         this.operationType = operation.operation;
         this.phase = "plan";
         this.rootLayerPlan = new LayerPlan_js_1.LayerPlan(this, null, REASON_ROOT);
-        // This doesn't do anything, it only exists to align plans more closely
-        // with an older version of the planner (to reduce the diff).
-        const rootSelectionSetStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, newValueStepCallback);
-        this.rootLayerPlan.setRootStep(rootSelectionSetStep);
         // Set up the shared steps for variables, context and rootValue
         [this.variableValuesStep, this.trackedVariableValuesStep] = this.track(variableValues, this.variableValuesConstraints, this.operation.variableDefinitions);
         [this.contextStep, this.trackedContextStep] = this.track(context, this.contextConstraints);
@@ -399,7 +395,7 @@ class OperationPlan {
             typeName: this.queryType.name,
         }, locationDetails);
         this.rootOutputPlan = outputPlan;
-        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections);
+        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections, true);
         if (this.loc !== null)
             this.loc.pop();
     }
@@ -425,7 +421,7 @@ class OperationPlan {
             typeName: rootType.name,
         }, locationDetails);
         this.rootOutputPlan = outputPlan;
-        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections, true);
+        this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, this.trackedRootValueStep, rootType, this.operation.selectionSet.selections, true, true);
         if (this.loc !== null)
             this.loc.pop();
     }
@@ -440,7 +436,7 @@ class OperationPlan {
             throw new index_js_1.SafeError("No subscription type found in schema");
         }
         const selectionSet = this.operation.selectionSet;
-        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, graphqlCollectFields_js_1.graphqlCollectFields, null, this, this.trackedRootValueStep.id, rootType, selectionSet.selections);
+        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, graphqlCollectFields_js_1.graphqlCollectFields, null, this, this.trackedRootValueStep.id, rootType, selectionSet.selections, (0, graphqlCollectFields_js_1.newSelectionSetDigest)(false));
         if (groupedFieldSet.deferred !== undefined) {
             throw new index_js_1.SafeError("@defer forbidden on subscription root selection set");
         }
@@ -497,7 +493,7 @@ class OperationPlan {
             streamItemPlan = this.stepTracker.getStepById(streamItemPlan.id);
             const outputPlan = new OutputPlan_js_1.OutputPlan(subscriptionEventLayerPlan, this.rootValueStep, { mode: "root", typeName: rootType.name }, locationDetails);
             this.rootOutputPlan = outputPlan;
-            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections);
+            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections, false);
         }
         else {
             const subscribeStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => {
@@ -541,7 +537,7 @@ class OperationPlan {
             streamItemPlan = this.stepTracker.getStepById(streamItemPlan.id);
             const outputPlan = new OutputPlan_js_1.OutputPlan(subscriptionEventLayerPlan, this.rootValueStep, { mode: "root", typeName: rootType.name }, locationDetails);
             this.rootOutputPlan = outputPlan;
-            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections);
+            this.planSelectionSet(outputPlan, [], exports.POLYMORPHIC_ROOT_PATH, exports.POLYMORPHIC_ROOT_PATHS, streamItemPlan, rootType, selectionSet.selections, true);
         }
         if (this.loc !== null)
             this.loc.pop();
@@ -571,187 +567,208 @@ class OperationPlan {
     outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, groupedFieldSet) {
         // `__typename` shouldn't bump the mutation index since it has no side effects.
         let mutationIndex = -1;
+        const $sideEffect = outputPlan.layerPlan.latestSideEffectStep;
         for (const [responseKey, fieldNodes] of groupedFieldSet.fields.entries()) {
-            // All grouped fields are equivalent, as mandated by GraphQL validation rules. Thus we can take the first one.
-            const field = fieldNodes[0];
-            const fieldName = field.name.value;
-            const locationDetails = {
-                parentTypeName: objectType.name,
-                fieldName,
-                node: fieldNodes,
-            };
-            // explicit matches are the fastest: https://jsben.ch/ajZNf
-            if (fieldName === "__typename") {
-                outputPlan.addChild(objectType, responseKey, {
-                    type: "__typename",
-                    locationDetails,
-                });
-                continue;
-            }
-            else if (fieldName === "__schema" || fieldName === "__type") {
-                const variableNames = (0, utils_js_1.findVariableNamesUsed)(this, field);
-                outputPlan.addChild(objectType, responseKey, {
-                    type: "outputPlan",
-                    isNonNull: fieldName === "__schema",
-                    outputPlan: new OutputPlan_js_1.OutputPlan(outputPlan.layerPlan, this.rootValueStep, {
-                        mode: "introspection",
-                        field,
-                        variableNames,
-                        // PERF: if variableNames.length === 0 we should be able to optimize this!
-                        introspectionCacheByVariableValues: new lru_1.default({
-                            maxLength: 3,
-                        }),
-                    }, locationDetails),
-                    locationDetails,
-                });
-                continue;
-            }
-            const objectField = objectTypeFields[fieldName];
-            if (!objectField) {
-                // Field does not exist; this should have been caught by validation
-                // but the spec says to just skip it.
-                continue;
-            }
-            const fieldType = objectField.type;
-            const rawPlanResolver = objectField.extensions?.grafast?.plan;
-            if (rawPlanResolver?.constructor?.name === "AsyncFunction") {
-                throw new Error(`Plans must be synchronous, but this schema has an async function at '${objectType.name}.${fieldName}.plan': ${rawPlanResolver.toString()}`);
-            }
-            const namedReturnType = getNamedType(fieldType);
-            const resolvedResolver = objectField.resolve;
-            const subscriber = objectField.subscribe;
-            const usesDefaultResolver = resolvedResolver == null || resolvedResolver === defaultFieldResolver;
-            const resolver = usesDefaultResolver ? null : resolvedResolver;
-            // Apply a default plan to fields that do not have a plan nor a resolver.
-            const planResolver = rawPlanResolver ??
-                (usesDefaultResolver ? makeDefaultPlan(fieldName) : undefined);
-            /*
-             *  When considering resolvers on fields, there's three booleans to
-             *  consider:
-             *
-             *  - typeIsPlanned: Does the type the field is defined on expect a plan?
-             *    - NOTE: the root types (Query, Mutation, Subscription) implicitly
-             *      expect the "root plan"
-             *  - fieldHasPlan: Does the field define a `plan()` method?
-             *  - resultIsPlanned: Does the named type that the field returns (the
-             *    "named field type") expect a plan?
-             *    - NOTE: only object types, unions and interfaces may expect plans;
-             *      but not all of them do.
-             *    - NOTE: a union/interface expects a plan iff ANY of its object
-             *      types expect plans
-             *    - NOTE: if ANY object type in an interface/union expects a plan
-             *      then ALL object types within the interface/union must expect
-             *      plans.
-             *    - NOTE: scalars and enums never expect a plan.
-             *
-             *  These booleans impact:
-             *
-             *  - Whether there must be a `plan()` declaration and what the "parent"
-             *    argument is to the same
-             *    - If typeIsPlanned:
-             *      - Assert: `fieldHasPlan` must be true
-             *      - Pass through the parent plan
-             *    - Else, if resultIsPlanned:
-             *      - Assert: `fieldHasPlan` must be true
-             *      - Pass through a `__ValueStep` representing the parent value.
-             *    - Else, if fieldHasPlan:
-             *      - Pass through a `__ValueStep` representing the parent value.
-             *    - Else
-             *      - No action necessary.
-             *  - If the field may define `resolve()` and what the "parent" argument
-             *    is to the same
-             *    - If resultIsPlanned
-             *      - Assert: there must not be a `resolve()`
-             *      - Grafast provides pure resolver.
-             *    - Else if fieldHasPlan (which may be implied by typeIsPlanned
-             *      above)
-             *      - If `resolve()` is not set:
-             *        - grafast will return the value from the plan directly
-             *      - Otherwise:
-             *        - Grafast will wrap this resolver and will call `resolve()` (or
-             *          default resolver) with the plan result.  IMPORTANT: you may
-             *          want to use an `ObjectStep` so that the parent object is of
-             *          the expected shape; e.g. your plan might return
-             *          `object({username: $username})` for a `User.username` field.
-             *    - Else
-             *      - Leave `resolve()` untouched - do not even wrap it.
-             *      - (Failing that, use a __ValueStep and return the result
-             *        directly.)
-             */
-            if (resolver !== null) {
-                this.pure = false;
-            }
-            const resultIsPlanned = (0, utils_js_1.isTypePlanned)(this.schema, namedReturnType);
-            const fieldHasPlan = !!planResolver;
-            if (resultIsPlanned &&
-                !fieldHasPlan &&
-                !objectType.extensions?.grafast?.assertStep) {
-                throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; however this field has no plan() method to produce such a plan; please add 'extensions.grafast.plan' to this field.`);
-            }
-            if (resultIsPlanned && resolver) {
-                throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; this means that ${objectType.name}.${fieldName} is forbidden from defining a GraphQL resolver.`);
-            }
-            let step;
-            let haltTree = false;
-            const fieldLayerPlan = isMutation
-                ? new LayerPlan_js_1.LayerPlan(this, outputPlan.layerPlan, {
-                    type: "mutationField",
-                    mutationIndex: ++mutationIndex,
-                })
-                : outputPlan.layerPlan;
-            const objectFieldArgs = objectField.args;
-            const trackedArguments = objectFieldArgs.length > 0
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, objectFieldArgs, field)
-                : NO_ARGS;
-            const fieldPath = [...path, responseKey];
-            if (typeof planResolver === "function") {
-                ({ step, haltTree } = this.planField(fieldLayerPlan, fieldPath, polymorphicPaths, fieldNodes, planResolver, "autoApplyAfterParentPlan", parentStep, objectField, trackedArguments));
-            }
-            else {
-                // No plan resolver (or plan resolver fallback) so there must be a
-                // `resolve` method, so we'll feed the full parent step into the
-                // resolver.
-                assert.ok(resolver !== null, "GraphileInternalError<81652257-617a-4d1a-8306-903d0e3d2ddf>: The field has no resolver, so planResolver should exist (either as the field.plan or as the default plan resolver).");
-                // ENHANCEMENT: should we do `step = parentStep.object()` (i.e.
-                // `$pgSelectSingle.record()`) or similar for "opaque" steps to become
-                // suitable for consumption by resolvers?
-                // Maybe `parentStep.forResolver()` or `parentStep.hydrate()` or `parentStep.toFullObject()`?
-                step = parentStep;
-            }
-            if (resolver !== null) {
-                step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(fieldLayerPlan, polymorphicPaths, () => {
-                    const $args = (0, index_js_1.object)(field.arguments?.reduce((memo, arg) => {
-                        memo[arg.name.value] = trackedArguments.get(arg.name.value);
-                        return memo;
-                    }, Object.create(null)) ?? Object.create(null));
-                    return (0, graphqlResolver_js_1.graphqlResolver)(resolver, subscriber, step, $args, {
-                        fieldName,
-                        fieldNodes,
-                        fragments: this.fragments,
-                        operation: this.operation,
-                        parentType: objectType,
-                        returnType: fieldType,
-                        schema: this.schema,
+            let resolverEmulation = groupedFieldSet.resolverEmulation;
+            try {
+                // All grouped fields are equivalent, as mandated by GraphQL validation rules. Thus we can take the first one.
+                const field = fieldNodes[0];
+                const fieldName = field.name.value;
+                const locationDetails = {
+                    parentTypeName: objectType.name,
+                    fieldName,
+                    node: fieldNodes,
+                };
+                // explicit matches are the fastest: https://jsben.ch/ajZNf
+                if (fieldName === "__typename") {
+                    outputPlan.addChild(objectType, responseKey, {
+                        type: "__typename",
+                        locationDetails,
                     });
-                });
-            }
-            // May have changed due to deduplicate
-            step = this.stepTracker.getStepById(step.id);
-            if (haltTree) {
-                const isNonNull = isNonNullType(fieldType);
-                outputPlan.addChild(objectType, responseKey, {
-                    type: "outputPlan",
-                    outputPlan: new OutputPlan_js_1.OutputPlan(fieldLayerPlan, step, OUTPUT_PLAN_TYPE_NULL, locationDetails),
-                    isNonNull,
-                    locationDetails,
-                });
+                    continue;
+                }
+                else if (fieldName === "__schema" || fieldName === "__type") {
+                    const variableNames = (0, utils_js_1.findVariableNamesUsed)(this, field);
+                    outputPlan.addChild(objectType, responseKey, {
+                        type: "outputPlan",
+                        isNonNull: fieldName === "__schema",
+                        outputPlan: new OutputPlan_js_1.OutputPlan(outputPlan.layerPlan, this.rootValueStep, {
+                            mode: "introspection",
+                            field,
+                            variableNames,
+                            // PERF: if variableNames.length === 0 we should be able to optimize this!
+                            introspectionCacheByVariableValues: new lru_1.default({
+                                maxLength: 3,
+                            }),
+                        }, locationDetails),
+                        locationDetails,
+                    });
+                    continue;
+                }
+                const objectField = objectTypeFields[fieldName];
+                if (!objectField) {
+                    // Field does not exist; this should have been caught by validation
+                    // but the spec says to just skip it.
+                    continue;
+                }
+                const fieldType = objectField.type;
+                const rawPlanResolver = objectField.extensions?.grafast?.plan;
+                if (rawPlanResolver) {
+                    resolverEmulation = false;
+                }
+                if (rawPlanResolver?.constructor?.name === "AsyncFunction") {
+                    throw new Error(`Plans must be synchronous, but this schema has an async function at '${objectType.name}.${fieldName}.plan': ${rawPlanResolver.toString()}`);
+                }
+                const namedReturnType = getNamedType(fieldType);
+                const resolvedResolver = objectField.resolve;
+                const subscriber = objectField.subscribe;
+                const usesDefaultResolver = resolvedResolver == null || resolvedResolver === defaultFieldResolver;
+                const isPolymorphic = isUnionType(namedReturnType) || isInterfaceType(namedReturnType);
+                // We should use a resolver if:
+                // 1. they give us a non-default resolver
+                // 2. we're emulating resolvers AND the field is polymorphic
+                const resolver = resolvedResolver && !usesDefaultResolver
+                    ? resolvedResolver
+                    : resolverEmulation && isPolymorphic
+                        ? defaultFieldResolver
+                        : null;
+                // Apply a default plan to fields that do not have a plan nor a resolver.
+                const planResolver = rawPlanResolver ??
+                    (resolver ? undefined : makeDefaultPlan(fieldName));
+                /*
+                 *  When considering resolvers on fields, there's three booleans to
+                 *  consider:
+                 *
+                 *  - typeIsPlanned: Does the type the field is defined on expect a plan?
+                 *    - NOTE: the root types (Query, Mutation, Subscription) implicitly
+                 *      expect the "root plan"
+                 *  - fieldHasPlan: Does the field define a `plan()` method?
+                 *  - resultIsPlanned: Does the named type that the field returns (the
+                 *    "named field type") expect a plan?
+                 *    - NOTE: only object types, unions and interfaces may expect plans;
+                 *      but not all of them do.
+                 *    - NOTE: a union/interface expects a plan iff ANY of its object
+                 *      types expect plans
+                 *    - NOTE: if ANY object type in an interface/union expects a plan
+                 *      then ALL object types within the interface/union must expect
+                 *      plans.
+                 *    - NOTE: scalars and enums never expect a plan.
+                 *
+                 *  These booleans impact:
+                 *
+                 *  - Whether there must be a `plan()` declaration and what the "parent"
+                 *    argument is to the same
+                 *    - If typeIsPlanned:
+                 *      - Assert: `fieldHasPlan` must be true
+                 *      - Pass through the parent plan
+                 *    - Else, if resultIsPlanned:
+                 *      - Assert: `fieldHasPlan` must be true
+                 *      - Pass through a `__ValueStep` representing the parent value.
+                 *    - Else, if fieldHasPlan:
+                 *      - Pass through a `__ValueStep` representing the parent value.
+                 *    - Else
+                 *      - No action necessary.
+                 *  - If the field may define `resolve()` and what the "parent" argument
+                 *    is to the same
+                 *    - If resultIsPlanned
+                 *      - Assert: there must not be a `resolve()`
+                 *      - Grafast provides pure resolver.
+                 *    - Else if fieldHasPlan (which may be implied by typeIsPlanned
+                 *      above)
+                 *      - If `resolve()` is not set:
+                 *        - grafast will return the value from the plan directly
+                 *      - Otherwise:
+                 *        - Grafast will wrap this resolver and will call `resolve()` (or
+                 *          default resolver) with the plan result.  IMPORTANT: you may
+                 *          want to use an `ObjectStep` so that the parent object is of
+                 *          the expected shape; e.g. your plan might return
+                 *          `object({username: $username})` for a `User.username` field.
+                 *    - Else
+                 *      - Leave `resolve()` untouched - do not even wrap it.
+                 *      - (Failing that, use a __ValueStep and return the result
+                 *        directly.)
+                 */
+                if (resolver !== null) {
+                    this.pure = false;
+                    if (!rawPlanResolver) {
+                        resolverEmulation = true;
+                    }
+                }
+                const resultIsPlanned = (0, utils_js_1.isTypePlanned)(this.schema, namedReturnType);
+                const fieldHasPlan = !!planResolver;
+                if (resultIsPlanned &&
+                    !fieldHasPlan &&
+                    !objectType.extensions?.grafast?.assertStep) {
+                    throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; however this field has no plan() method to produce such a plan; please add 'extensions.grafast.plan' to this field.`);
+                }
+                if (resultIsPlanned && resolver) {
+                    throw new Error(`Field ${objectType.name}.${fieldName} returns a ${namedReturnType.name} which expects a plan to be available; this means that ${objectType.name}.${fieldName} is forbidden from defining a GraphQL resolver.`);
+                }
+                let step;
+                let haltTree = false;
+                const fieldLayerPlan = isMutation
+                    ? new LayerPlan_js_1.LayerPlan(this, outputPlan.layerPlan, {
+                        type: "mutationField",
+                        mutationIndex: ++mutationIndex,
+                    })
+                    : outputPlan.layerPlan;
+                const objectFieldArgs = objectField.args;
+                const trackedArguments = objectFieldArgs.length > 0
+                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, objectFieldArgs, field)
+                    : NO_ARGS;
+                const fieldPath = [...path, responseKey];
+                if (typeof planResolver === "function") {
+                    ({ step, haltTree } = this.planField(fieldLayerPlan, fieldPath, polymorphicPaths, fieldNodes, planResolver, "autoApplyAfterParentPlan", parentStep, objectField, trackedArguments));
+                }
+                else {
+                    // No plan resolver (or plan resolver fallback) so there must be a
+                    // `resolve` method, so we'll feed the full parent step into the
+                    // resolver.
+                    assert.ok(resolver !== null, "GraphileInternalError<81652257-617a-4d1a-8306-903d0e3d2ddf>: The field has no resolver, so planResolver should exist (either as the field.plan or as the default plan resolver).");
+                    // ENHANCEMENT: should we do `step = parentStep.object()` (i.e.
+                    // `$pgSelectSingle.record()`) or similar for "opaque" steps to become
+                    // suitable for consumption by resolvers?
+                    // Maybe `parentStep.forResolver()` or `parentStep.hydrate()` or `parentStep.toFullObject()`?
+                    step = parentStep;
+                }
+                if (resolver !== null) {
+                    step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(fieldLayerPlan, polymorphicPaths, () => {
+                        const $args = (0, index_js_1.object)(field.arguments?.reduce((memo, arg) => {
+                            memo[arg.name.value] = trackedArguments.get(arg.name.value);
+                            return memo;
+                        }, Object.create(null)) ?? Object.create(null));
+                        return (0, graphqlResolver_js_1.graphqlResolver)(resolver, subscriber, step, $args, {
+                            fieldName,
+                            fieldNodes,
+                            fragments: this.fragments,
+                            operation: this.operation,
+                            parentType: objectType,
+                            returnType: fieldType,
+                            schema: this.schema,
+                        });
+                    });
+                }
+                // May have changed due to deduplicate
+                step = this.stepTracker.getStepById(step.id);
+                if (haltTree) {
+                    const isNonNull = isNonNullType(fieldType);
+                    outputPlan.addChild(objectType, responseKey, {
+                        type: "outputPlan",
+                        outputPlan: new OutputPlan_js_1.OutputPlan(fieldLayerPlan, step, OUTPUT_PLAN_TYPE_NULL, locationDetails),
+                        isNonNull,
+                        locationDetails,
+                    });
+                }
+                else {
+                    this.planIntoOutputPlan(outputPlan, fieldLayerPlan, fieldPath, polymorphicPath, polymorphicPaths, 
+                    // If one field has a selection set, they all have a selection set (guaranteed by validation).
+                    field.selectionSet != null
+                        ? fieldNodes.flatMap((n) => n.selectionSet.selections)
+                        : undefined, objectType, responseKey, fieldType, step, locationDetails, resolverEmulation);
+                }
             }
-            else {
-                this.planIntoOutputPlan(outputPlan, fieldLayerPlan, fieldPath, polymorphicPath, polymorphicPaths, 
-                // If one field has a selection set, they all have a selection set (guaranteed by validation).
-                field.selectionSet != null
-                    ? fieldNodes.flatMap((n) => n.selectionSet.selections)
-                    : undefined, objectType, responseKey, fieldType, step, locationDetails);
+            finally {
+                outputPlan.layerPlan.latestSideEffectStep = $sideEffect;
             }
         }
         if (groupedFieldSet.deferred !== undefined) {
@@ -768,8 +785,14 @@ class OperationPlan {
                 // LOGGING: the location details should be tweaked to reference this
                 // fragment
                 outputPlan.locationDetails);
-                outputPlan.deferredOutputPlans.push(deferredOutputPlan);
-                this.processGroupedFieldSet(deferredOutputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, deferred);
+                const $sideEffect = deferredOutputPlan.layerPlan.latestSideEffectStep;
+                try {
+                    outputPlan.deferredOutputPlans.push(deferredOutputPlan);
+                    this.processGroupedFieldSet(deferredOutputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, deferred);
+                }
+                finally {
+                    deferredOutputPlan.layerPlan.latestSideEffectStep = $sideEffect;
+                }
             }
         }
     }
@@ -782,14 +805,14 @@ class OperationPlan {
      * @param selections - The GraphQL selections (fields, fragment spreads, inline fragments) to evaluate
      * @param isMutation - If true this selection set should be executed serially rather than in parallel (each field gets its own LayerPlan)
      */
-    planSelectionSet(outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, selections, isMutation = false) {
+    planSelectionSet(outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, selections, resolverEmulation, isMutation = false) {
         if (this.loc !== null) {
             this.loc.push(`planSelectionSet(${objectType.name} @ ${outputPlan.layerPlan.id} @ ${path.join(".")} @ ${polymorphicPath ?? ""})`);
         }
         if (index_js_1.isDev) {
             assertObjectType(objectType);
         }
-        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(outputPlan.layerPlan, polymorphicPaths, graphqlCollectFields_js_1.graphqlCollectFields, null, this, parentStep.id, objectType, selections, isMutation);
+        const groupedFieldSet = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(outputPlan.layerPlan, polymorphicPaths, graphqlCollectFields_js_1.graphqlCollectFields, null, this, parentStep.id, objectType, selections, (0, graphqlCollectFields_js_1.newSelectionSetDigest)(resolverEmulation), isMutation);
         const objectTypeFields = objectType.getFields();
         this.processGroupedFieldSet(outputPlan, path, polymorphicPath, polymorphicPaths, parentStep, objectType, objectTypeFields, isMutation, groupedFieldSet);
         if (this.loc !== null)
@@ -800,7 +823,7 @@ class OperationPlan {
     // Typically this is parentOutputPlan.layerPlan; but in the case of mutationFields it isn't.
     parentLayerPlan, 
     // This is the LAYER-RELATIVE path, not the absolute path! It resets!
-    path, polymorphicPath, polymorphicPaths, selections, parentObjectType, responseKey, fieldType, $step, locationDetails, listDepth = 0) {
+    path, polymorphicPath, polymorphicPaths, selections, parentObjectType, responseKey, fieldType, $step, locationDetails, resolverEmulation, listDepth = 0) {
         const nullableFieldType = getNullableType(fieldType);
         const isNonNull = nullableFieldType !== fieldType;
         if (isListType(nullableFieldType)) {
@@ -812,40 +835,58 @@ class OperationPlan {
                 locationDetails,
             });
             const $__item = this.itemStepForListStep(parentLayerPlan, $step, listDepth);
-            const $item = (0, step_js_1.isListCapableStep)($step)
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, $__item.polymorphicPaths, $step.listItem, $step, $__item)
-                : $__item;
-            this.planIntoOutputPlan(listOutputPlan, $item.layerPlan, path, polymorphicPath, polymorphicPaths, selections, null, null, nullableFieldType.ofType, $item, locationDetails, listDepth + 1);
+            const $sideEffect = $__item.layerPlan.latestSideEffectStep;
+            try {
+                const $item = (0, step_js_1.isListCapableStep)($step)
+                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, $__item.polymorphicPaths, $step.listItem, $step, $__item)
+                    : $__item;
+                this.planIntoOutputPlan(listOutputPlan, $item.layerPlan, path, polymorphicPath, polymorphicPaths, selections, null, null, nullableFieldType.ofType, $item, locationDetails, resolverEmulation, listDepth + 1);
+            }
+            finally {
+                $__item.layerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else if (isScalarType(nullableFieldType)) {
             const scalarPlanResolver = nullableFieldType.extensions?.grafast?.plan;
             if (scalarPlanResolver?.constructor?.name === "AsyncFunction") {
                 throw new Error(`Plans must be synchronous, but this schema has an async function at '${nullableFieldType.name}.plan': ${scalarPlanResolver.toString()}`);
             }
-            const $leaf = typeof scalarPlanResolver === "function"
-                ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, scalarPlanResolver, null, $step, this.scalarPlanInfo)
-                : $step;
-            parentOutputPlan.addChild(parentObjectType, responseKey, {
-                type: "outputPlan",
-                isNonNull,
-                outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $leaf, {
-                    mode: "leaf",
-                    // stepId: $leaf.id,
-                    graphqlType: nullableFieldType,
-                }, locationDetails),
-                locationDetails,
-            });
+            const $sideEffect = parentLayerPlan.latestSideEffectStep;
+            try {
+                const $leaf = typeof scalarPlanResolver === "function"
+                    ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, scalarPlanResolver, null, $step, this.scalarPlanInfo)
+                    : $step;
+                parentOutputPlan.addChild(parentObjectType, responseKey, {
+                    type: "outputPlan",
+                    isNonNull,
+                    outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $leaf, {
+                        mode: "leaf",
+                        // stepId: $leaf.id,
+                        graphqlType: nullableFieldType,
+                    }, locationDetails),
+                    locationDetails,
+                });
+            }
+            finally {
+                parentLayerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else if (isEnumType(nullableFieldType)) {
-            parentOutputPlan.addChild(parentObjectType, responseKey, {
-                type: "outputPlan",
-                isNonNull,
-                outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, {
-                    mode: "leaf",
-                    graphqlType: nullableFieldType,
-                }, locationDetails),
-                locationDetails,
-            });
+            const $sideEffect = parentLayerPlan.latestSideEffectStep;
+            try {
+                parentOutputPlan.addChild(parentObjectType, responseKey, {
+                    type: "outputPlan",
+                    isNonNull,
+                    outputPlan: new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, {
+                        mode: "leaf",
+                        graphqlType: nullableFieldType,
+                    }, locationDetails),
+                    locationDetails,
+                });
+            }
+            finally {
+                parentLayerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else if (isObjectType(nullableFieldType)) {
             if (index_js_1.isDev) {
@@ -893,18 +934,24 @@ class OperationPlan {
                     objectLayerPlan.setRootStep($step);
                 }
             }
-            const objectOutputPlan = new OutputPlan_js_1.OutputPlan(objectLayerPlan, $step, {
-                mode: "object",
-                deferLabel: undefined,
-                typeName: nullableFieldType.name,
-            }, locationDetails);
-            parentOutputPlan.addChild(parentObjectType, responseKey, {
-                type: "outputPlan",
-                outputPlan: objectOutputPlan,
-                isNonNull,
-                locationDetails,
-            });
-            this.planSelectionSet(objectOutputPlan, path, polymorphicPath, polymorphicPaths, $step, nullableFieldType, selections);
+            const $sideEffect = objectLayerPlan.latestSideEffectStep;
+            try {
+                const objectOutputPlan = new OutputPlan_js_1.OutputPlan(objectLayerPlan, $step, {
+                    mode: "object",
+                    deferLabel: undefined,
+                    typeName: nullableFieldType.name,
+                }, locationDetails);
+                parentOutputPlan.addChild(parentObjectType, responseKey, {
+                    type: "outputPlan",
+                    outputPlan: objectOutputPlan,
+                    isNonNull,
+                    locationDetails,
+                });
+                this.planSelectionSet(objectOutputPlan, path, polymorphicPath, polymorphicPaths, $step, nullableFieldType, selections, resolverEmulation);
+            }
+            finally {
+                objectLayerPlan.latestSideEffectStep = $sideEffect;
+            }
         }
         else {
             // Polymorphic
@@ -970,48 +1017,54 @@ class OperationPlan {
                 const polyBase = polymorphicPath ?? "";
                 const $oldStep = $step;
                 for (const type of allPossibleObjectTypes) {
-                    /* TODO: this $oldStep / $step dance turned out to be necessary
-                     * because `$step` was being replaced in the following query against
-                     * the pggql_test `polymorpic` schema; but I'm not sure this is the
-                     * right behavior - shouldn't deduplication have been temporarily
-                     * disabled during this?
-                     *
-                     * ```graphql
-                     * {
-                     *   allSingleTableItems {
-                     *     nodes {
-                     *       id
-                     *       type
-                     *       singleTableItemsByParentIdList {
-                     *         id
-                     *         position
-                     *       }
-                     *     }
-                     *   }
-                     * }
-                     * ```
-                     */
-                    const $step = this.stepTracker.getStepById($oldStep.id);
-                    // Bit of a hack, but saves passing it around through all the arguments
-                    const newPolymorphicPath = `${polyBase}>${type.name}`;
-                    polymorphicLayerPlan.reason.polymorphicPaths.add(newPolymorphicPath);
-                    const newPolymorphicPaths = new Set();
-                    newPolymorphicPaths.add(newPolymorphicPath);
-                    const $root = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, newPolymorphicPaths, $step.planForType, $step, type);
-                    const objectOutputPlan = new OutputPlan_js_1.OutputPlan(polymorphicLayerPlan, $root, {
-                        mode: "object",
-                        deferLabel: undefined,
-                        typeName: type.name,
-                    }, locationDetails);
-                    // find all selections compatible with `type`
-                    const fieldNodes = (0, graphqlMergeSelectionSets_js_1.fieldSelectionsForType)(this, type, selections);
-                    this.planSelectionSet(objectOutputPlan, path, newPolymorphicPath, newPolymorphicPaths, $root, type, fieldNodes, false);
-                    polymorphicOutputPlan.addChild(type, null, {
-                        type: "outputPlan",
-                        isNonNull,
-                        outputPlan: objectOutputPlan,
-                        locationDetails,
-                    });
+                    const $sideEffect = polymorphicLayerPlan.latestSideEffectStep;
+                    try {
+                        /* TODO: this $oldStep / $step dance turned out to be necessary
+                         * because `$step` was being replaced in the following query against
+                         * the pggql_test `polymorpic` schema; but I'm not sure this is the
+                         * right behavior - shouldn't deduplication have been temporarily
+                         * disabled during this?
+                         *
+                         * ```graphql
+                         * {
+                         *   allSingleTableItems {
+                         *     nodes {
+                         *       id
+                         *       type
+                         *       singleTableItemsByParentIdList {
+                         *         id
+                         *         position
+                         *       }
+                         *     }
+                         *   }
+                         * }
+                         * ```
+                         */
+                        const $step = this.stepTracker.getStepById($oldStep.id);
+                        // Bit of a hack, but saves passing it around through all the arguments
+                        const newPolymorphicPath = `${polyBase}>${type.name}`;
+                        polymorphicLayerPlan.reason.polymorphicPaths.add(newPolymorphicPath);
+                        const newPolymorphicPaths = new Set();
+                        newPolymorphicPaths.add(newPolymorphicPath);
+                        const $root = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(polymorphicLayerPlan, newPolymorphicPaths, $step.planForType, $step, type);
+                        const objectOutputPlan = new OutputPlan_js_1.OutputPlan(polymorphicLayerPlan, $root, {
+                            mode: "object",
+                            deferLabel: undefined,
+                            typeName: type.name,
+                        }, locationDetails);
+                        // find all selections compatible with `type`
+                        const fieldNodes = (0, graphqlMergeSelectionSets_js_1.fieldSelectionsForType)(this, type, selections);
+                        this.planSelectionSet(objectOutputPlan, path, newPolymorphicPath, newPolymorphicPaths, $root, type, fieldNodes, false);
+                        polymorphicOutputPlan.addChild(type, null, {
+                            type: "outputPlan",
+                            isNonNull,
+                            outputPlan: objectOutputPlan,
+                            locationDetails,
+                        });
+                    }
+                    finally {
+                        polymorphicLayerPlan.latestSideEffectStep = $sideEffect;
+                    }
                 }
             }
         }
@@ -1065,6 +1118,7 @@ class OperationPlan {
         // PERF: this should be handled in the parent?
         const parentStep = this.stepTracker.getStepById(rawParentStep.id);
         const previousStepCount = this.stepTracker.stepCount;
+        const previousSideEffectStep = layerPlan.latestSideEffectStep;
         if (this.loc !== null)
             this.loc.push(`planField(${path.join(".")})`);
         try {
@@ -1132,6 +1186,7 @@ class OperationPlan {
             }
             try {
                 this.stepTracker.purgeBackTo(previousStepCount);
+                layerPlan.latestSideEffectStep = previousSideEffectStep;
             }
             catch (e2) {
                 console.error(`Cleanup error occurred whilst trying to recover from field planning error: ${e2.stack}`);
@@ -1226,7 +1281,8 @@ class OperationPlan {
                 continue;
             for (const key in step) {
                 const val = step[key];
-                if (val instanceof index_js_1.ExecutableStep) {
+                if (key !== ("implicitSideEffectStep") &&
+                    val instanceof index_js_1.ExecutableStep) {
                     errors.push(new Error(`ERROR: ExecutableStep ${step} has illegal reference via property '${key}' to step ${val}. You must not reference steps directly, instead add the step as a dependency (\`depId = this.addDependency($step)\`) and use \`this.getDep(depId)\` to look the step up (or, if the step is not a dependency, store the step ID and use \`this.getStep(stepId)\` each time you need to reference it). Failure to comply could result in subtle breakage during optimisation.`));
                 }
             }
@@ -2190,15 +2246,17 @@ class OperationPlan {
             const sideEffectSteps = layerPlan.pendingSteps.filter((s) => s.hasSideEffects);
             const pending = new Set(layerPlan.pendingSteps);
             const processed = new Set();
+            let latestSideEffectStep = null;
             const processSideEffectPlan = (step) => {
                 if (processed.has(step) || isPrepopulatedStep(step)) {
                     return;
                 }
+                const sstep = (0, utils_js_1.sudo)(step);
                 processed.add(step);
                 pending.delete(step);
                 const sideEffectDeps = [];
                 const rest = [];
-                for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
+                for (const dep of sstep.dependencies) {
                     if (dep.layerPlan !== layerPlan) {
                         continue;
                     }
@@ -2221,6 +2279,13 @@ class OperationPlan {
                 for (const dep of rest) {
                     processSideEffectPlan(dep);
                 }
+                if (latestSideEffectStep !== null &&
+                    !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
+                    sstep.implicitSideEffectStep = latestSideEffectStep;
+                }
+                if (step.hasSideEffects) {
+                    latestSideEffectStep = step;
+                }
                 const phase = /*#__INLINE__*/ newLayerPlanPhase();
                 phase.checkTimeout = true;
                 phase.normalSteps = [{ step }];
@@ -2255,6 +2320,11 @@ class OperationPlan {
                 for (const step of nextSteps) {
                     processed.add(step);
                     pending.delete(step);
+                    const sstep = (0, utils_js_1.sudo)(step);
+                    if (latestSideEffectStep !== null &&
+                        !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
+                        sstep.implicitSideEffectStep = latestSideEffectStep;
+                    }
                     if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedExecutableStep)(step)) {
                         if (phase.unbatchedSyncAndSafeSteps !== undefined) {
                             phase.unbatchedSyncAndSafeSteps.push({
@@ -2289,6 +2359,11 @@ class OperationPlan {
                             if (readyToExecute(step)) {
                                 processed.add(step);
                                 pending.delete(step);
+                                const sstep = (0, utils_js_1.sudo)(step);
+                                if (latestSideEffectStep !== null &&
+                                    !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
+                                    sstep.implicitSideEffectStep = latestSideEffectStep;
+                                }
                                 foundOne = true;
                                 if (phase.unbatchedSyncAndSafeSteps !== undefined) {
                                     phase.unbatchedSyncAndSafeSteps.push({
@@ -2327,10 +2402,31 @@ class OperationPlan {
                 for (const dep of (0, utils_js_1.sudo)(step).dependencies) {
                     ensurePlanAvailableInLayer(dep, layerPlan);
                 }
+                if (step.implicitSideEffectStep) {
+                    ensurePlanAvailableInLayer(step.implicitSideEffectStep, layerPlan);
+                }
             }
             const $root = layerPlan.rootStep;
             if ($root) {
                 ensurePlanAvailableInLayer($root, layerPlan);
+                // If $root explicitly dependends on `layerPlan.parentSideEffectStep`
+                // then we should remove the implicit layerPlan dependency (e.g. so
+                // that if you `trap()` the error it does not interfere).
+                if (layerPlan.parentSideEffectStep) {
+                    if (layerPlan.parentSideEffectStep === $root ||
+                        layerPlan.parentSideEffectStep === $root.implicitSideEffectStep ||
+                        (0, utils_js_1.stepADependsOnStepB)($root, layerPlan.parentSideEffectStep)) {
+                        layerPlan.parentSideEffectStep = null;
+                    }
+                }
+            }
+            const $sideEffect = layerPlan.parentSideEffectStep;
+            if ($sideEffect) {
+                // We read it from the parent layer plan at newBucket time, but we
+                // don't need to actually scale it up/down.
+                //
+                // If parentSideEffectStep exists then parentLayerPlan must exist.
+                ensurePlanAvailableInLayer($sideEffect, layerPlan.parentLayerPlan);
             }
             // Copy polymorphic parentStepId
             if (layerPlan.reason.type === "polymorphic") {
@@ -2390,6 +2486,7 @@ class OperationPlan {
                 metaString: metaString ? (0, index_js_1.stripAnsi)(metaString) : metaString,
                 isUnary: step._isUnary,
                 bucketId: step.layerPlan.id,
+                implicitSideEffectStepId: step.implicitSideEffectStep?.id ?? null,
                 dependencyIds: sstep.dependencies.map((d) => d.id),
                 dependencyForbiddenFlags: sstep.dependencyForbiddenFlags.slice(),
                 dependencyOnReject: sstep.dependencyOnReject.map((or) => or ? String(or) : or),
@@ -2458,6 +2555,7 @@ class OperationPlan {
             return {
                 id: lp.id,
                 reason: printBucketReason(lp.reason),
+                parentSideEffectStepId: lp.parentSideEffectStep?.id ?? null,
                 copyStepIds: lp.copyStepIds,
                 phases: lp.phases.map(printPhase),
                 steps: lp.steps.map(printStep),