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

package/dist/engine/executeBucket.js

@@ -11,8 +11,6 @@ const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
 const timeSource_js_1 = require("../timeSource.js");
 const utils_js_1 = require("../utils.js");
-/** Path to use when there's no polymorphic paths. */
-const NO_POLY_PATH = "";
 const timeoutError = Object.freeze(new error_js_1.SafeError("Execution timeout exceeded, please simplify or add limits to your request.", Object.freeze({ [interfaces_js_1.$$timeout]: true })));
 function noop() {
     /*noop*/
@@ -66,7 +64,6 @@ function executeBucket(bucket, requestContext) {
     const { middleware } = args;
     const { metaByMetaKey, size, store, layerPlan: { phases, children: childLayerPlans }, } = bucket;
     const phaseCount = phases.length;
-    let sideEffectStepsWithErrors = null;
     // Like a `for(i = 0; i < phaseCount; i++)` loop with some `await`s in it, except it does promise
     // handling manually so that it can complete synchronously (no promises) if
     // possible.
@@ -83,7 +80,6 @@ function executeBucket(bucket, requestContext) {
          */
         let indexesPendingLoopOver = [];
         let executePromises = null;
-        let sideEffectSteps = null;
         let executePromiseResultIndex = null;
         const resultList = [];
         if (phase.checkTimeout &&
@@ -107,14 +103,6 @@ function executeBucket(bucket, requestContext) {
             const normalSteps = phase.normalSteps;
             for (let normalStepIndex = 0, l = normalSteps.length; normalStepIndex < l; normalStepIndex++) {
                 const step = normalSteps[normalStepIndex].step;
-                if (step.hasSideEffects) {
-                    if (sideEffectSteps === null) {
-                        sideEffectSteps = [step];
-                    }
-                    else {
-                        sideEffectSteps.push(step);
-                    }
-                }
                 try {
                     const r = executeStep(step);
                     if ((0, utils_js_1.isPromiseLike)(r)) {
@@ -144,24 +132,6 @@ function executeBucket(bucket, requestContext) {
                 }
             }
         }
-        const handleSideEffectSteps = () => {
-            if (!sideEffectStepsWithErrors) {
-                sideEffectStepsWithErrors = bucket.polymorphicPathList.reduce((memo, path) => {
-                    memo[path ?? NO_POLY_PATH] = [];
-                    return memo;
-                }, Object.create(null));
-            }
-            for (const step of sideEffectSteps) {
-                if (step.polymorphicPaths) {
-                    for (const path of step.polymorphicPaths) {
-                        sideEffectStepsWithErrors[path].push(step);
-                    }
-                }
-                else {
-                    sideEffectStepsWithErrors[NO_POLY_PATH].push(step);
-                }
-            }
-        };
         const next = () => {
             return nextPhase(phaseIndex + 1);
         };
@@ -340,10 +310,6 @@ function executeBucket(bucket, requestContext) {
                             bucket.setResult(finishedStep, dataIndex, error, interfaces_js_1.FLAG_ERROR);
                         }
                     }
-                    if ((bucket.flagUnion & interfaces_js_1.FLAG_ERROR) === interfaces_js_1.FLAG_ERROR &&
-                        sideEffectSteps) {
-                        handleSideEffectSteps();
-                    }
                     return promises ? Promise.all(promises) : undefined;
                 })
                     .then(null, (e) => {
@@ -359,9 +325,6 @@ function executeBucket(bucket, requestContext) {
                 });
             }
             else {
-                if ((bucket.flagUnion & interfaces_js_1.FLAG_ERROR) === interfaces_js_1.FLAG_ERROR && sideEffectSteps) {
-                    handleSideEffectSteps();
-                }
                 return promises ? Promise.all(promises) : undefined;
             }
         };
@@ -392,18 +355,30 @@ function executeBucket(bucket, requestContext) {
                     bucket.store.set(step.id, batchExecutionValue((0, utils_js_1.arrayOfLength)(size)));
                 }
             }
-            outerLoop: for (let dataIndex = 0; dataIndex < size; dataIndex++) {
-                if (sideEffectStepsWithErrors) {
-                    const currentPolymorphicPath = bucket.polymorphicPathList[dataIndex];
-                    for (const dep of sideEffectStepsWithErrors[currentPolymorphicPath ?? NO_POLY_PATH]) {
-                        const depExecutionValue = bucket.store.get(dep.id);
-                        const depFlags = depExecutionValue._flagsAt(dataIndex);
-                        if ((depFlags & interfaces_js_1.FLAG_POLY_SKIPPED) === interfaces_js_1.FLAG_POLY_SKIPPED) {
-                            /* noop */
-                        }
-                        else if ((depFlags & interfaces_js_1.FLAG_ERROR) === interfaces_js_1.FLAG_ERROR) {
-                            for (let allStepsIndex = executedLength; allStepsIndex < allStepsLength; allStepsIndex++) {
-                                const step = _allSteps[allStepsIndex];
+            for (let dataIndex = 0; dataIndex < size; dataIndex++) {
+                stepLoop: for (let allStepsIndex = executedLength; allStepsIndex < allStepsLength; allStepsIndex++) {
+                    const step = (0, utils_js_1.sudo)(_allSteps[allStepsIndex]);
+                    // Unary steps only need to be processed once
+                    if (step._isUnary && dataIndex !== 0) {
+                        continue;
+                    }
+                    // Check if the side effect errored
+                    const $sideEffect = step.implicitSideEffectStep;
+                    if ($sideEffect) {
+                        let currentPolymorphicPath;
+                        if ($sideEffect.polymorphicPaths === null ||
+                            (currentPolymorphicPath =
+                                bucket.polymorphicPathList[dataIndex]) === null ||
+                            $sideEffect.polymorphicPaths.has(currentPolymorphicPath)) {
+                            const depExecutionValue = bucket.store.get($sideEffect.id);
+                            if (depExecutionValue === undefined) {
+                                throw new Error(`GrafastInternalError<fcc8d302-ac66-40e8-aaea-ee2c7e2b30b2>: failed to get result for side effect ${$sideEffect} which impacts ${step}`);
+                            }
+                            const depFlags = depExecutionValue._flagsAt(dataIndex);
+                            if (depFlags & interfaces_js_1.FLAG_POLY_SKIPPED) {
+                                /* noop */
+                            }
+                            else if (depFlags & interfaces_js_1.FLAG_ERROR) {
                                 if (step._isUnary) {
                                     // COPY the unary value
                                     bucket.store.set(step.id, depExecutionValue);
@@ -413,17 +388,10 @@ function executeBucket(bucket, requestContext) {
                                     const depVal = depExecutionValue.at(dataIndex);
                                     bucket.setResult(step, dataIndex, depVal, depFlags);
                                 }
+                                continue stepLoop;
                             }
-                            continue outerLoop;
                         }
                     }
-                }
-                stepLoop: for (let allStepsIndex = executedLength; allStepsIndex < allStepsLength; allStepsIndex++) {
-                    const step = (0, utils_js_1.sudo)(_allSteps[allStepsIndex]);
-                    // Unary steps only need to be processed once
-                    if (step._isUnary && dataIndex !== 0) {
-                        continue;
-                    }
                     try {
                         const deps = [];
                         const extra = extras[allStepsIndex];
@@ -630,7 +598,7 @@ function executeBucket(bucket, requestContext) {
         let newSize = 0;
         const stepPolymorphicPaths = step.polymorphicPaths;
         const legitDepsCount = (0, utils_js_1.sudo)(step).dependencies.length;
-        let dependencies = sideEffectStepsWithErrors
+        let dependencies = step.implicitSideEffectStep
             ? dependenciesIncludingSideEffects.slice(0, legitDepsCount)
             : dependenciesIncludingSideEffects;
         // OPTIM: if unariesIncludingSideEffects.some(isGrafastError) then shortcut execution because everything fails
@@ -762,8 +730,11 @@ function executeBucket(bucket, requestContext) {
             const dependencies = _rawDependencies;
             let needsFiltering = false;
             const defaultForbiddenFlags = (0, utils_js_1.sudo)(step).defaultForbiddenFlags;
-            const addDependency = (step, forbiddenFlags, onReject) => {
-                const executionValue = store.get(step.id);
+            const addDependency = ($dep, forbiddenFlags, onReject) => {
+                const executionValue = store.get($dep.id);
+                if (executionValue === undefined) {
+                    throw new Error(`GrafastInternalError<d9e9eb37-4251-4659-a545-4730826ecf0e>: ${$dep} data couldn't be found, but required by ${step} (with side effect ${step.implicitSideEffectStep})!`);
+                }
                 _rawDependencies.push(executionValue);
                 _rawForbiddenFlags.push(forbiddenFlags);
                 _rawOnReject.push(onReject);
@@ -774,27 +745,15 @@ function executeBucket(bucket, requestContext) {
             };
             const sstep = (0, utils_js_1.sudo)(step);
             const depCount = sstep.dependencies.length;
-            if (depCount > 0 || sideEffectStepsWithErrors !== null) {
+            if (depCount > 0) {
                 for (let i = 0, l = depCount; i < l; i++) {
                     const $dep = sstep.dependencies[i];
                     addDependency($dep, sstep.dependencyForbiddenFlags[i], sstep.dependencyOnReject[i]);
                 }
-                if (sideEffectStepsWithErrors !== null) {
-                    if (sstep.polymorphicPaths) {
-                        for (const path of sstep.polymorphicPaths) {
-                            for (const sideEffectStep of sideEffectStepsWithErrors[path]) {
-                                // TODO: revisit this, feels like we might be adding the same
-                                // effect multiple times if it matches multiple paths.
-                                addDependency(sideEffectStep, defaultForbiddenFlags, undefined);
-                            }
-                        }
-                    }
-                    else {
-                        for (const sideEffectStep of sideEffectStepsWithErrors[NO_POLY_PATH]) {
-                            addDependency(sideEffectStep, defaultForbiddenFlags, undefined);
-                        }
-                    }
-                }
+            }
+            const $sideEffect = step.implicitSideEffectStep;
+            if ($sideEffect) {
+                addDependency($sideEffect, defaultForbiddenFlags, undefined);
             }
             if (dev_js_1.isDev &&
                 step.layerPlan.reason.type === "polymorphic" &&

package/dist/error.d.ts

@@ -1,4 +1,16 @@
+import type { ExecutionEntryFlags } from "./interfaces.js";
 import { $$safeError } from "./interfaces.js";
+declare const $$flagged: unique symbol;
+/**
+ * Wrapper for errors to return (rather than throw or reject) from user code.
+ */
+export interface FlaggedValue<TValue = any> {
+    [$$flagged]: true;
+    flags: ExecutionEntryFlags;
+    value: TValue;
+    planId: number | null;
+    toString(): string;
+}
 export declare const $$inhibit: FlaggedValue<null>;
 /**
  * Used to wrap error values to have Grafast treat them as if they were
@@ -15,4 +27,5 @@ export declare class SafeError<TExtensions extends Record<string, any> | undefin
     constructor(message: string, extensions?: TExtensions, errorOptions?: ErrorOptions);
 }
 export declare function isSafeError(error: Error): error is SafeError;
+export {};
 //# sourceMappingURL=error.d.ts.map

package/dist/grafastGraphql.d.ts

@@ -1,15 +1,15 @@
 import type { AsyncExecutionResult, ExecutionResult } from "graphql";
 import type { PromiseOrValue } from "graphql/jsutils/PromiseOrValue";
 import type { GrafastArgs } from "./interfaces.js";
-/**
- * @deprecated Second and third parameters should be passed as part of args,
- * specifically `resolvedPreset` and `requestContext`.
- */
-export declare function grafast(args: GrafastArgs, legacyResolvedPreset?: GraphileConfig.ResolvedPreset, legacyCtx?: Partial<Grafast.RequestContext>): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
 /**
  * A replacement for GraphQL.js' `graphql` method that calls Grafast's
  * execute instead
  */
 export declare function grafast(args: GrafastArgs): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
+/**
+ * @deprecated Second and third parameters should be passed as part of args,
+ * specifically `resolvedPreset` and `requestContext`.
+ */
+export declare function grafast(args: GrafastArgs, legacyResolvedPreset?: GraphileConfig.ResolvedPreset | undefined, legacyCtx?: Partial<Grafast.RequestContext> | undefined): PromiseOrValue<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, undefined>>;
 export declare function grafastSync(args: GrafastArgs, legacyResolvedPreset?: GraphileConfig.ResolvedPreset, legacyRequestContext?: Partial<Grafast.RequestContext>): ExecutionResult;
 //# sourceMappingURL=grafastGraphql.d.ts.map

package/dist/graphqlCollectFields.d.ts

@@ -1,4 +1,10 @@
 import type { DirectiveNode } from "graphql";
 import type { __TrackedValueStep } from "./steps/index.js";
 export declare function evalDirectiveArgDirect<T = unknown>(directive: DirectiveNode, argumentName: string, variableValuesStep: __TrackedValueStep, defaultValue: T): T | undefined;
+export declare function newSelectionSetDigest(resolverEmulation: boolean): {
+    label: undefined;
+    fields: Map<any, any>;
+    deferred: undefined;
+    resolverEmulation: boolean;
+};
 //# sourceMappingURL=graphqlCollectFields.d.ts.map

package/dist/graphqlCollectFields.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphqlCollectFields = exports.evalDirectiveArgDirect = exports.evalDirectiveArg = void 0;
+exports.graphqlCollectFields = exports.newSelectionSetDigest = exports.evalDirectiveArgDirect = exports.evalDirectiveArg = void 0;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const error_js_1 = require("./error.js");
@@ -100,6 +100,7 @@ const processFragment = (operationPlan, parentStepId, objectType, isMutation, se
             label,
             fields: new Map(),
             deferred: undefined,
+            resolverEmulation: selectionSetDigest.resolverEmulation,
         }
         : null;
     if (deferredDigest !== null) {
@@ -110,8 +111,17 @@ const processFragment = (operationPlan, parentStepId, objectType, isMutation, se
             selectionSetDigest.deferred.push(deferredDigest);
         }
     }
-    graphqlCollectFields(operationPlan, parentStepId, objectType, fragmentSelectionSet.selections, isMutation, visitedFragments, deferredDigest ?? selectionSetDigest);
+    graphqlCollectFields(operationPlan, parentStepId, objectType, fragmentSelectionSet.selections, deferredDigest ?? selectionSetDigest, isMutation, visitedFragments);
 };
+function newSelectionSetDigest(resolverEmulation) {
+    return {
+        label: undefined,
+        fields: new Map(),
+        deferred: undefined,
+        resolverEmulation,
+    };
+}
+exports.newSelectionSetDigest = newSelectionSetDigest;
 /**
  * Implements the `GraphQLCollectFields` algorithm - like `CollectFields` the
  * GraphQL spec, but modified such that access to variables is tracked.
@@ -120,13 +130,9 @@ const processFragment = (operationPlan, parentStepId, objectType, isMutation, se
  *
  * @internal
  */
-function graphqlCollectFields(operationPlan, parentStepId, objectType, selections, isMutation = false, 
+function graphqlCollectFields(operationPlan, parentStepId, objectType, selections, selectionSetDigest, isMutation = false, 
 // This is significantly faster than an array or a Set
-visitedFragments = Object.create(null), selectionSetDigest = {
-    label: undefined,
-    fields: new Map(),
-    deferred: undefined,
-}) {
+visitedFragments = Object.create(null)) {
     // const objectTypeFields = objectType.getFields();
     const trackedVariableValuesStep = operationPlan.trackedVariableValuesStep;
     for (let i = 0, l = selections.length; i < l; i++) {

package/dist/interfaces.d.ts

@@ -83,6 +83,10 @@ export declare const $$data: unique symbol;
  * example details of the plan or SQL queries or similar that were executed.
  */
 export declare const $$extensions: unique symbol;
+/**
+ * The "GraphQLObjectType" type name, useful when dealing with polymorphism.
+ */
+export declare const $$concreteType: unique symbol;
 /**
  * Set this key on a type if that type's serialization is idempotent (that is
  * to say `serialize(serialize(thing)) === serialize(thing)`). This means we
@@ -399,6 +403,20 @@ export interface ExecutionExtra extends ExecutionExtraBase {
 }
 export interface UnbatchedExecutionExtra extends ExecutionExtraBase {
 }
+/**
+ * A bitwise number representing a number of flags:
+ *
+ * - 0: normal execution value
+ * - 1: errored (trappable)
+ * - 2: null (trappable)
+ * - 4: inhibited (trappable)
+ * - 8: disabled due to polymorphism (untrappable)
+ * - 16: stopped (untrappable) - e.g. due to fatal (unrecoverable) error
+ * - 32: ...
+ */
+export type ExecutionEntryFlags = number & {
+    readonly tsBrand?: unique symbol;
+};
 export declare const NO_FLAGS: ExecutionEntryFlags;
 export declare const FLAG_ERROR: ExecutionEntryFlags;
 export declare const FLAG_NULL: ExecutionEntryFlags;

package/dist/interfaces.js

@@ -28,8 +28,6 @@ exports.$$data = Symbol("data");
 exports.$$extensions = Symbol("extensions");
 /**
  * The "GraphQLObjectType" type name, useful when dealing with polymorphism.
- *
- * @internal
  */
 exports.$$concreteType = Symbol("concreteType");
 /**

package/dist/mermaid.js

@@ -137,7 +137,7 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
                 pp(stepById[plan.dependencyIds[0]].polymorphicPaths) === polyPaths
                 ? ""
                 : `\n${polyPaths}`;
-            const planString = `${planName}[${plan.id}${`∈${plan.bucketId}`}]${meta ? `\n<${meta}>` : ""}${polyPathsIfDifferent}`;
+            const planString = `${planName}[${plan.id}${`∈${plan.bucketId}`}]${plan.isUnary ? " ➊" : ""}${meta ? `\n<${meta}>` : ""}${polyPathsIfDifferent}`;
             const [lBrace, rBrace] = plan.stepClass === "__ItemStep"
                 ? ["[/", "\\]"]
                 : plan.isSyncAndSafe
@@ -267,6 +267,18 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
     const stepToString = (step) => {
         return `${step.stepClass.replace(/Step$/, "")}${step.bucketId === 0 ? "" : `{${step.bucketId}}`}${step.metaString ? `<${step.metaString}>` : ""}[${step.id}]`;
     };
+    let firstSideEffect = true;
+    sortedSteps.forEach((step) => {
+        if (step.implicitSideEffectStepId) {
+            if (firstSideEffect) {
+                graph.push("");
+                graph.push("    %% implicit side effects");
+                firstSideEffect = false;
+            }
+            const sideEffectStep = stepById[step.implicitSideEffectStepId];
+            graph.push(`    ${planId(sideEffectStep)} -.-o ${planId(step)}`);
+        }
+    });
     graph.push("");
     if (!concise && !skipBuckets)
         graph.push("    subgraph Buckets");
@@ -278,17 +290,18 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
             (layerPlan.reason.type === "polymorphic"
                 ? `\n${layerPlan.reason.typeNames}`
                 : ``);
-        const outputMapStuff = [];
         if (!skipBuckets) {
-            graph.push(`    Bucket${layerPlan.id}(${(0, exports.mermaidEscape)(`Bucket ${layerPlan.id}${raisonDEtre}${layerPlan.copyStepIds.length > 0
+            graph.push(`    Bucket${layerPlan.id}(${(0, exports.mermaidEscape)(`Bucket ${layerPlan.id}${raisonDEtre}${layerPlan.parentSideEffectStepId != null
+                ? `\nParent side effect step: ${stepById[layerPlan.parentSideEffectStepId].id}`
+                : ""}${layerPlan.copyStepIds.length > 0
                 ? `\nDeps: ${layerPlan.copyStepIds
                     .map((pId) => stepById[pId].id)
-                    .join(", ")}\n`
+                    .join(", ")}`
                 : ""}${layerPlan.reason.type === "polymorphic"
-                ? pp(layerPlan.reason.polymorphicPaths)
-                : ""}${layerPlan.rootStepId != null && layerPlan.reason.type !== "root"
+                ? "\n" + pp(layerPlan.reason.polymorphicPaths)
+                : ""}\n${layerPlan.rootStepId != null && layerPlan.reason.type !== "root"
                 ? `\nROOT ${stepToString(stepById[layerPlan.rootStepId])}`
-                : ""}${startSteps(layerPlan)}\n${outputMapStuff.join("\n")}`)}):::bucket`);
+                : ""}${startSteps(layerPlan)}`)}):::bucket`);
         }
         graph.push(`    classDef bucket${layerPlan.id} stroke:${color(layerPlan.id)}`);
         graph.push(`    class ${[`Bucket${layerPlan.id}`, ...steps.map(planId)].join(",")} bucket${layerPlan.id}`);
@@ -302,10 +315,6 @@ concise = false, skipBuckets = global.grafastExplainMermaidSkipBuckets ?? false,
             }
         }
     }
-    const isUnary = (step) => step.isUnary;
-    graph.push(`\
-    classDef unary fill:#fafffa,borderWidth:8px
-    class ${sortedSteps.filter(isUnary).map(planId)} unary`);
     if (!concise && !skipBuckets)
         graph.push("    end");
     const graphString = graph.join("\n");

package/dist/operationPlan-input.js

@@ -310,7 +310,14 @@ function withFieldArgsForArguments(operationPlan, $parent, $all, field, applyAft
                 if (mode === "apply" &&
                     (!subpath || (Array.isArray(subpath) && subpath.length === 0))) {
                     if (isInputObjectType(nullableEntityType)) {
-                        for (const fieldName of Object.keys(nullableEntityType.getFields())) {
+                        if (!("evalKeys" in $input)) {
+                            throw new Error(`GrafastInternalError<d782160e-7a99-4a12-b690-435c1ab7b676>: Expected ${$input} to be a __InputObjectStep or __TrackedValueStep (i.e. to have 'evalKeys')`);
+                        }
+                        const keys = $input.evalKeys();
+                        if (keys == null) {
+                            return;
+                        }
+                        for (const fieldName of keys) {
                             const $target = typeof targetStepOrCallback === "function"
                                 ? targetStepOrCallback()
                                 : targetStepOrCallback;

package/dist/planJSONInterfaces.d.ts

@@ -8,6 +8,7 @@ export interface GrafastPlanStepJSONv1 {
     metaString: string | null;
     isUnary: boolean;
     bucketId: string | number;
+    implicitSideEffectStepId: string | number | null;
     dependencyIds: ReadonlyArray<string | number>;
     dependencyForbiddenFlags: ReadonlyArray<ExecutionEntryFlags>;
     dependencyOnReject: ReadonlyArray<string | null | undefined>;
@@ -69,6 +70,7 @@ export interface GrafastPlanBucketReasonSubroutineJSONv1 {
 export interface GrafastPlanBucketJSONv1 {
     id: number;
     reason: GrafastPlanBucketReasonJSONv1;
+    parentSideEffectStepId: string | number | null;
     copyStepIds: ReadonlyArray<string | number>;
     steps: ReadonlyArray<GrafastPlanStepJSONv1>;
     rootStepId: string | number | null;

package/dist/prepare.js

@@ -152,7 +152,7 @@ function outputBucket(outputPlan, rootBucket, rootBucketIndex, requestContext, p
         childBucketIndex = rootBucketIndex;
     }
     else {
-        const c = (0, OutputPlan_js_1.getChildBucketAndIndex)(outputPlan, null, rootBucket, rootBucketIndex, null);
+        const c = (0, OutputPlan_js_1.getChildBucketAndIndex)(outputPlan.layerPlan, null, rootBucket, rootBucketIndex, null);
         if (!c) {
             throw new Error(`GrafastInternalError<8bbf56c1-8e2a-4ee9-b5fc-724fd0ee222b>: could not find relevant bucket for output plan`);
         }
@@ -250,11 +250,11 @@ function executePreemptive(args, operationPlan, variableValues, context, rootVal
             releaseUnusedIterators(rootBucket, rootBucketIndex, null);
             // Something major went wrong!
             const errors = [
-                new GraphQLError(bucketRootValue.originalError.message, operationPlan.rootOutputPlan.locationDetails.node, // node
+                new GraphQLError(bucketRootValue.message, operationPlan.rootOutputPlan.locationDetails.node, // node
                 undefined, // source
                 null, // positions
                 null, // path
-                bucketRootValue.originalError, // originalError
+                bucketRootValue, // originalError
                 null),
             ];
             const payload = Object.create(null);

package/dist/step.d.ts

@@ -27,11 +27,6 @@ export declare abstract class BaseStep {
     isArgumentsFinalized: boolean;
     isFinalized: boolean;
     debug: boolean;
-    /**
-     * Set this true for plans that implement mutations; this will prevent them
-     * from being tree-shaken.
-     */
-    hasSideEffects: boolean;
     constructor();
     toString(): string;
     /**
@@ -113,6 +108,11 @@ export declare class ExecutableStep<TData = any> extends BaseStep {
      * Like `metaKey` but for the optimize phase
      */
     optimizeMetaKey: number | string | symbol | undefined;
+    /**
+     * Set this true for plans that implement mutations; this will prevent them
+     * from being tree-shaken.
+     */
+    hasSideEffects: boolean;
     constructor();
     protected withMyLayerPlan<T>(callback: () => T): T;
     protected getStep(id: number): ExecutableStep;

package/dist/step.js

@@ -63,7 +63,6 @@ class BaseStep {
         this.isArgumentsFinalized = false;
         this.isFinalized = false;
         this.debug = (0, global_js_1.getDebug)();
-        this.hasSideEffects = false;
         const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
         this.layerPlan = layerPlan;
         this.operationPlan = layerPlan.operationPlan;
@@ -108,6 +107,57 @@ class ExecutableStep extends BaseStep {
          * (default = ALL_FLAGS & ~FLAG_NULL)
          */
         this.defaultForbiddenFlags = interfaces_js_1.DEFAULT_FORBIDDEN_FLAGS;
+        this.implicitSideEffectStep = null;
+        this.hasSideEffects ??= false;
+        let hasSideEffects = false;
+        const stepTracker = this.layerPlan.operationPlan.stepTracker;
+        Object.defineProperty(this, "hasSideEffects", {
+            get() {
+                return hasSideEffects;
+            },
+            set(value) {
+                /**
+                 * If steps were created after this step, an this step doesn't depend
+                 * on them, then it's no longer safe to change hasSideEffects.
+                 */
+                let nonDependentSteps = null;
+                const maxStepId = stepTracker.stepCount - 1;
+                if (this.id === maxStepId) {
+                    // All good - no more steps were created
+                }
+                else {
+                    // If the step created them during initialization and is dependent on
+                    // them, that's fine too.
+                    for (let id = this.id + 1; id <= maxStepId; id++) {
+                        const step = stepTracker.getStepById(id);
+                        if ((0, utils_js_1.stepADependsOnStepB)(this, step))
+                            continue;
+                        if (nonDependentSteps === null) {
+                            nonDependentSteps = [step];
+                        }
+                        else {
+                            nonDependentSteps.push(step);
+                        }
+                    }
+                }
+                if (nonDependentSteps === null) {
+                    hasSideEffects = value;
+                    if (value === true) {
+                        this.layerPlan.latestSideEffectStep = this;
+                    }
+                    else if (value !== true && hasSideEffects === true) {
+                        throw new Error(`Cannot mark ${this} as having no side effects after having set it to have side effects.`);
+                    }
+                }
+                else {
+                    throw new Error(`Attempted to mark ${this} as having side effects, but other non-dependent steps (${nonDependentSteps
+                        .map(String)
+                        .join(", ")}) have already been created.`);
+                }
+            },
+            enumerable: true,
+            configurable: false,
+        });
         this.dependencies = [];
         this.dependencyForbiddenFlags = [];
         this.dependencyOnReject = [];
@@ -117,6 +167,7 @@ class ExecutableStep extends BaseStep {
         this._stepOptions = { stream: null };
         this.store = true;
         this.polymorphicPaths = (0, withGlobalLayerPlan_js_1.currentPolymorphicPaths)();
+        // Important: MUST come after `this.layerPlan = ...`
         this.id = this.layerPlan._addStep(this);
     }
     withMyLayerPlan(callback) {
@@ -163,7 +214,7 @@ class ExecutableStep extends BaseStep {
         catch (e) {
             // Ignore
         }
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${this.layerPlan.id === 0 ? "" : chalk_1.default.grey(`{${this.layerPlan.id}}`)}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, {
+        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${this.layerPlan.id === 0 ? "" : chalk_1.default.grey(`{${this.layerPlan.id}}`)}${this._isUnary ? "➊" : ""}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, {
             colors: true,
         })}]`);
     }

package/dist/steps/__flag.d.ts

@@ -1,5 +1,6 @@
 import type { ExecutionDetails, ExecutionEntryFlags, GrafastResultsList } from "../interfaces.js";
 import { $$deepDepSkip } from "../interfaces.js";
+import type { ListCapableStep } from "../step.js";
 import { ExecutableStep } from "../step.js";
 import type { __ItemStep } from "./__item.js";
 export declare const TRAP_ERROR: ExecutionEntryFlags;
@@ -32,8 +33,8 @@ export declare class __FlagStep<TData> extends ExecutableStep<TData> {
     constructor(step: ExecutableStep, options: FlagStepOptions);
     toStringMeta(): string | null;
     [$$deepDepSkip](): ExecutableStep;
-    listItem?: ($item: __ItemStep<this>) => ExecutableStep;
-    _listItem($item: __ItemStep<this>): ExecutableStep<unknown>;
+    listItem?: ($item: __ItemStep<ListCapableStep<unknown, ExecutableStep<unknown>>>) => ExecutableStep;
+    _listItem($item: __ItemStep<ListCapableStep<unknown, ExecutableStep<unknown>>>): ExecutableStep<unknown>;
     deduplicate(_peers: readonly ExecutableStep<any>[]): readonly ExecutableStep<any>[];
     execute(_details: ExecutionDetails<[data: TData, cond?: boolean]>): GrafastResultsList<TData>;
     finalize(): void;

package/dist/steps/__inputObject.d.ts

@@ -22,6 +22,7 @@ export declare class __InputObjectStep<TInputType extends GraphQLInputObjectType
     evalIs(value: null | undefined | 0): boolean;
     evalIsEmpty(): boolean;
     evalHas(attrName: string): boolean;
+    evalKeys(): ReadonlyArray<keyof TInputType & string> | null;
 }
 export type __InputObjectStepWithDollars<TInputType extends GraphQLInputObjectType = GraphQLInputObjectType> = __InputObjectStep<TInputType> & {
     [key in keyof ReturnType<TInputType["getFields"]> & string as `$${key}`]: InputStep<ReturnType<TInputType["getFields"]>[key]["type"]>;