grafast 0.1.1-beta.20 → 0.1.1-beta.21

package/dist/engine/OperationPlan.js

@@ -14,12 +14,13 @@ const inspect_js_1 = require("../inspect.js");
 const interfaces_js_1 = require("../interfaces.js");
 const operationPlan_input_js_1 = require("../operationPlan-input.js");
 const step_js_1 = require("../step.js");
-const access_js_1 = require("../steps/access.js");
+const connection_js_1 = require("../steps/connection.js");
 const constant_js_1 = require("../steps/constant.js");
 const graphqlResolver_js_1 = require("../steps/graphqlResolver.js");
 const timeSource_js_1 = require("../timeSource.js");
 const utils_js_1 = require("../utils.js");
 const LayerPlan_js_1 = require("./LayerPlan.js");
+const defaultPlanResolver_js_1 = require("./lib/defaultPlanResolver.js");
 const withGlobalLayerPlan_js_1 = require("./lib/withGlobalLayerPlan.js");
 const lock_js_1 = require("./lock.js");
 const OutputPlan_js_1 = require("./OutputPlan.js");
@@ -55,7 +56,7 @@ const MAX_OPTIMIZATION_LOOPS = 10;
 const REASON_ROOT = Object.freeze({ type: "root" });
 const OUTPUT_PLAN_TYPE_NULL = Object.freeze({ mode: "null" });
 const OUTPUT_PLAN_TYPE_ARRAY = Object.freeze({ mode: "array" });
-const newValueStepCallback = () => new index_js_1.__ValueStep();
+const newValueStepCallback = (isImmutable) => new index_js_1.__ValueStep(isImmutable);
 const NO_ARGS = {
     get() {
         throw new Error(`This field doesn't have any arguments`);
@@ -89,13 +90,8 @@ class OperationPlan {
         this.loc = index_js_1.isDev
             ? []
             : null /* forbid loc in production */;
-        this.modifierStepCount = 0;
-        this.modifierDepthCount = 0;
-        this.modifierSteps = [];
         /** @internal */
         this.stepTracker = new StepTracker_js_1.StepTracker(this);
-        this.maxDeduplicatedStepId = -1;
-        this.maxValidatedStepId = -1;
         /**
          * @internal
          */
@@ -108,6 +104,8 @@ class OperationPlan {
         this.previousLap = this.startTime;
         this.laps = [];
         this.optimizeMeta = new Map();
+        /** @internal */
+        this.valueNodeToStaticValueCache = new Map();
         /** @internal Use plan.getStep(id) instead. */
         this.getStep = index_js_1.isDev
             ? (id, requestingStep) => {
@@ -320,21 +318,6 @@ class OperationPlan {
         }
         return this.stepTracker.addStep(plan);
     }
-    /**
-     * Adds a plan to the known steps and returns the number to use as the plan
-     * id. ONLY to be used from Step, user code should never call this directly.
-     *
-     * @internal
-     */
-    _addModifierStep(step) {
-        if (!["plan", "validate", "optimize"].includes(this.phase)) {
-            throw new Error(`Creating a step during the '${this.phase}' phase is forbidden.`);
-        }
-        const modifierStepId = `${this.modifierDepthCount}-${this
-            .modifierStepCount++}`;
-        this.modifierSteps.push(step);
-        return modifierStepId;
-    }
     /**
      * Get a plan without specifying who requested it; this disables all the
      * caller checks. Only intended to be called from internal code.
@@ -473,14 +456,10 @@ class OperationPlan {
             : NO_ARGS;
         if (subscriptionPlanResolver !== undefined) {
             // PERF: optimize this
-            const { haltTree, step: subscribeStep } = this.planField(this.rootLayerPlan, path, exports.POLYMORPHIC_ROOT_PATHS, fields, subscriptionPlanResolver, "autoApplyAfterParentSubscribePlan", this.trackedRootValueStep, fieldSpec, trackedArguments);
+            const { haltTree, step: subscribeStep } = this.planField(rootType.name, fieldName, this.rootLayerPlan, path, exports.POLYMORPHIC_ROOT_PATHS, subscriptionPlanResolver, "subscribePlan", this.trackedRootValueStep, fieldSpec, trackedArguments, true);
             if (haltTree) {
                 throw new index_js_1.SafeError("Failed to setup subscription");
             }
-            const stepOptions = {
-                stream: { initialCount: 0 },
-            };
-            subscribeStep._stepOptions = stepOptions;
             this.rootLayerPlan.setRootStep(subscribeStep);
             const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, this.rootLayerPlan, {
                 type: "subscription",
@@ -521,10 +500,8 @@ class OperationPlan {
                     },
                 });
             });
-            const stepOptions = {
-                stream: { initialCount: 0 },
-            };
-            subscribeStep._stepOptions = stepOptions;
+            subscribeStep._stepOptions.stream = {};
+            subscribeStep._stepOptions.walkIterable = true;
             this.rootLayerPlan.setRootStep(subscribeStep);
             const subscriptionEventLayerPlan = new LayerPlan_js_1.LayerPlan(this, this.rootLayerPlan, {
                 type: "subscription",
@@ -548,7 +525,7 @@ class OperationPlan {
      * Gets the item plan for a given parent list plan - this ensures we only
      * create one item plan per parent plan.
      */
-    itemStepForListStep(parentLayerPlan, listStep, depth = 0) {
+    itemStepForListStep(parentLayerPlan, listStep, depth, stream) {
         const itemStepId = this.itemStepIdByListStepId[listStep.id];
         if (itemStepId !== undefined) {
             return this.stepTracker.getStepById(itemStepId);
@@ -557,7 +534,7 @@ class OperationPlan {
         const layerPlan = new LayerPlan_js_1.LayerPlan(this, parentLayerPlan, {
             type: "listItem",
             parentStep: listStep,
-            stream: listStep._stepOptions.stream ?? undefined,
+            stream,
         });
         const itemPlan = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, listStep.polymorphicPaths, () => new index_js_1.__ItemStep(listStep, depth));
         layerPlan.setRootStep(itemPlan);
@@ -633,8 +610,7 @@ class OperationPlan {
                         ? defaultFieldResolver
                         : null;
                 // Apply a default plan to fields that do not have a plan nor a resolver.
-                const planResolver = rawPlanResolver ??
-                    (resolver ? undefined : makeDefaultPlan(fieldName));
+                const planResolver = rawPlanResolver ?? (resolver ? undefined : defaultPlanResolver_js_1.defaultPlanResolver);
                 /*
                  *  When considering resolvers on fields, there's three booleans to
                  *  consider:
@@ -717,8 +693,49 @@ class OperationPlan {
                     ? (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, this.getTrackedArguments, this, objectFieldArgs, field)
                     : NO_ARGS;
                 const fieldPath = [...path, responseKey];
+                let streamDetails = null;
+                const isList = isListType(getNullableType(fieldType));
+                if (isList) {
+                    // read the @stream directive, if present
+                    // TODO: Check SameStreamDirective still exists in @stream spec at release.
+                    /*
+                     * `SameStreamDirective`
+                     * (https://github.com/graphql/graphql-spec/blob/26fd78c4a89a79552dcc0c7e0140a975ce654400/spec/Section%205%20--%20Validation.md#L450-L458)
+                     * ensures that every field that has `@stream` must have the same
+                     * `@stream` arguments; so we can just check the first node in the
+                     * merged set to see our stream options. NOTE: if this changes before
+                     * release then we may need to find the stream with the largest
+                     * `initialCount` to figure what to do; something like:
+                     *
+                     *      const streamDirective = firstField.directives?.filter(
+                     *        (d) => d.name.value === "stream",
+                     *      ).sort(
+                     *        (a, z) => getArg(z, 'initialCount', 0) - getArg(a, 'initialCount', 0)
+                     *      )[0]
+                     */
+                    for (const n of fieldNodes) {
+                        const streamDirective = n.directives?.find((d) => d.name.value === "stream");
+                        if (streamDirective === undefined) {
+                            // Undo any previous stream details; the non-@stream wins.
+                            streamDetails = null;
+                            break;
+                        }
+                        else if (streamDetails !== null) {
+                            // Validation promises the values are the same
+                            continue;
+                        }
+                        else {
+                            // Create streamDetails
+                            streamDetails = this.withRootLayerPlan(() => ({
+                                initialCount: this.internalDependency((0, utils_js_1.directiveArgument)(this, streamDirective, "initialCount", graphql.Kind.INT) ?? (0, constant_js_1.constant)(0)),
+                                if: this.internalDependency((0, utils_js_1.directiveArgument)(this, streamDirective, "if", graphql.Kind.BOOLEAN) ?? (0, constant_js_1.constant)(true)),
+                                label: this.internalDependency((0, utils_js_1.directiveArgument)(this, streamDirective, "label", graphql.Kind.STRING) ?? (0, constant_js_1.constant)(undefined)),
+                            }));
+                        }
+                    }
+                }
                 if (typeof planResolver === "function") {
-                    ({ step, haltTree } = this.planField(fieldLayerPlan, fieldPath, polymorphicPaths, fieldNodes, planResolver, "autoApplyAfterParentPlan", parentStep, objectField, trackedArguments));
+                    ({ step, haltTree } = this.planField(objectType.name, fieldName, fieldLayerPlan, fieldPath, polymorphicPaths, planResolver, "plan", parentStep, objectField, trackedArguments, isList ? (streamDetails ?? false) : null));
                 }
                 else {
                     // No plan resolver (or plan resolver fallback) so there must be a
@@ -764,7 +781,7 @@ class OperationPlan {
                     // 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);
+                        : undefined, objectType, responseKey, fieldType, step, locationDetails, resolverEmulation, 0, streamDetails);
                 }
             }
             finally {
@@ -818,29 +835,54 @@ class OperationPlan {
         if (this.loc !== null)
             this.loc.pop();
     }
+    internalDependency($step) {
+        this.stepTracker.internalDependencies.add($step);
+        return $step;
+    }
     // Similar to the old 'planFieldReturnType'
     planIntoOutputPlan(parentOutputPlan, 
     // 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, resolverEmulation, listDepth = 0) {
+    path, polymorphicPath, polymorphicPaths, selections, parentObjectType, responseKey, fieldType, $step, locationDetails, resolverEmulation, listDepth, streamDetails) {
         const nullableFieldType = getNullableType(fieldType);
         const isNonNull = nullableFieldType !== fieldType;
         if (isListType(nullableFieldType)) {
-            const listOutputPlan = new OutputPlan_js_1.OutputPlan(parentLayerPlan, $step, OUTPUT_PLAN_TYPE_ARRAY, locationDetails);
+            const $list = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(parentLayerPlan, polymorphicPaths, connection_js_1.itemsOrStep, null, $step);
+            if ($list !== $step) {
+                $list._stepOptions.stream = $step._stepOptions.stream;
+            }
+            $list._stepOptions.walkIterable = true;
+            const listOutputPlan = new OutputPlan_js_1.OutputPlan(parentLayerPlan, $list, OUTPUT_PLAN_TYPE_ARRAY, locationDetails);
             parentOutputPlan.addChild(parentObjectType, responseKey, {
                 type: "outputPlan",
                 outputPlan: listOutputPlan,
                 isNonNull,
                 locationDetails,
             });
-            const $__item = this.itemStepForListStep(parentLayerPlan, $step, listDepth);
+            const stream = streamDetails
+                ? {
+                    // These are already marked as internal dependencies
+                    initialCountStepId: streamDetails.initialCount.id,
+                    ifStepId: streamDetails.if.id,
+                    labelStepId: streamDetails.label.id,
+                }
+                : undefined;
+            let $__item = this.itemStepForListStep(parentLayerPlan, $list, listDepth, stream);
             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);
+                let $item;
+                if ((0, step_js_1.isListCapableStep)($list)) {
+                    $item = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)($__item.layerPlan, $__item.polymorphicPaths, $list.listItem, $list, $__item);
+                    this.deduplicateSteps();
+                    // Refetch steps following deduplicate
+                    $__item = this.stepTracker.getStepById($__item.id);
+                    $item = this.stepTracker.getStepById($item.id);
+                }
+                else {
+                    $item = $__item;
+                }
+                this.planIntoOutputPlan(listOutputPlan, $item.layerPlan, path, polymorphicPath, polymorphicPaths, selections, null, null, nullableFieldType.ofType, $item, locationDetails, resolverEmulation, listDepth + 1, null);
             }
             finally {
                 $__item.layerPlan.latestSideEffectStep = $sideEffect;
@@ -894,8 +936,8 @@ class OperationPlan {
                 const stepAssertion = nullableFieldType.extensions?.grafast?.assertStep;
                 if (stepAssertion != null) {
                     try {
-                        if (stepAssertion === index_js_1.ExecutableStep ||
-                            stepAssertion.prototype instanceof index_js_1.ExecutableStep) {
+                        if (stepAssertion === index_js_1.Step ||
+                            stepAssertion.prototype instanceof index_js_1.Step) {
                             if (!($step instanceof stepAssertion)) {
                                 throw new Error(`Step mis-match: expected ${stepAssertion.name}, but instead found ${$step.constructor.name} (${$step})`);
                             }
@@ -1112,7 +1154,13 @@ class OperationPlan {
             return layerPlan;
         }
     }
-    planField(layerPlan, path, polymorphicPaths, fieldNodes, planResolver, applyAfterMode, rawParentStep, field, trackedArguments, deduplicate = true) {
+    planField(typeName, fieldName, layerPlan, path, polymorphicPaths, planResolver, applyAfterMode, rawParentStep, field, trackedArguments, 
+    // If 'true' this is a subscription rather than a stream
+    // If 'false' this is a list but it will never stream
+    // If 'null' this is neither subscribe field nor list field
+    // Otherwise, it's a list field that has the `@stream` directive applied
+    streamDetails, deduplicate = true) {
+        const coordinate = `${typeName}.${fieldName}`;
         // The step may have been de-duped whilst sibling steps were planned
         // PERF: this should be handled in the parent?
         const parentStep = this.stepTracker.getStepById(rawParentStep.id);
@@ -1121,7 +1169,8 @@ class OperationPlan {
         if (this.loc !== null)
             this.loc.push(`planField(${path.join(".")})`);
         try {
-            let step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, operationPlan_input_js_1.withFieldArgsForArguments, null, this, parentStep, trackedArguments, field, applyAfterMode, (fieldArgs) => planResolver(parentStep, fieldArgs, {
+            let step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, operationPlan_input_js_1.withFieldArgsForArguments, null, this, trackedArguments, field, parentStep, applyAfterMode, coordinate, (fieldArgs) => planResolver(parentStep, fieldArgs, {
+                fieldName,
                 field,
                 schema: this.schema,
             }));
@@ -1135,31 +1184,22 @@ class OperationPlan {
                 haltTree = true;
             }
             (0, step_js_1.assertExecutableStep)(step);
-            // TODO: Check SameStreamDirective still exists in @stream spec at release.
-            /*
-             * `SameStreamDirective`
-             * (https://github.com/graphql/graphql-spec/blob/26fd78c4a89a79552dcc0c7e0140a975ce654400/spec/Section%205%20--%20Validation.md#L450-L458)
-             * ensures that every field that has `@stream` must have the same
-             * `@stream` arguments; so we can just check the first node in the
-             * merged set to see our stream options. NOTE: if this changes before
-             * release then we may need to find the stream with the largest
-             * `initialCount` to figure what to do; something like:
-             *
-             *      const streamDirective = firstField.directives?.filter(
-             *        (d) => d.name.value === "stream",
-             *      ).sort(
-             *        (a, z) => getArg(z, 'initialCount', 0) - getArg(a, 'initialCount', 0)
-             *      )[0]
-             */
-            const streamDirective = fieldNodes[0].directives?.find((d) => d.name.value === "stream");
-            const stepOptions = {
-                stream: !haltTree && streamDirective
-                    ? {
-                        initialCount: Number((0, graphqlCollectFields_js_1.evalDirectiveArg)(fieldNodes[0], "stream", "initialCount", this.trackedVariableValuesStep, null)) || 0,
-                    }
-                    : null,
-            };
-            step._stepOptions = stepOptions;
+            if (streamDetails === true) {
+                // subscription
+                step._stepOptions.stream = {};
+                step._stepOptions.walkIterable = true;
+            }
+            else if (streamDetails === false) {
+                step._stepOptions.walkIterable = true;
+            }
+            else if (streamDetails != null) {
+                step._stepOptions.stream = {
+                    initialCountStepId: streamDetails.initialCount.id,
+                    ifStepId: streamDetails.if.id,
+                    labelStepId: streamDetails.label.id,
+                };
+                step._stepOptions.walkIterable = true;
+            }
             if (deduplicate) {
                 // Now that the field has been planned (including arguments, but NOT
                 // including selection set) we can deduplicate it to see if any of its
@@ -1193,7 +1233,6 @@ class OperationPlan {
             }
             const step = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(layerPlan, polymorphicPaths, index_js_1.error, null, e);
             const haltTree = true;
-            this.modifierSteps = [];
             // PERF: consider deleting all steps that were allocated during this. For
             // now we'll just rely on tree-shaking.
             return { step, haltTree };
@@ -1231,42 +1270,12 @@ class OperationPlan {
             },
         };
     }
-    withModifiers(cb) {
-        // Stash previous modifiers
-        const previousModifierDepthCount = this.modifierDepthCount++;
-        const previousCount = this.modifierStepCount;
-        const previousStack = this.modifierSteps.splice(0, this.modifierSteps.length);
-        this.modifierStepCount = 0;
-        let result;
-        let plansToApply;
-        try {
-            result = cb();
-        }
-        finally {
-            // Remove the modifier plans from operationPlan and sort them ready for application.
-            plansToApply = this.modifierSteps
-                .splice(0, this.modifierSteps.length)
-                .reverse();
-            // Restore previous modifiers
-            this.modifierStepCount = previousCount;
-            for (const mod of previousStack) {
-                this.modifierSteps.push(mod);
-            }
-            // Restore previous depth
-            this.modifierDepthCount = previousModifierDepthCount;
-        }
-        // Apply the plans.
-        for (let i = 0, l = plansToApply.length; i < l; i++) {
-            plansToApply[i].apply();
-        }
-        return result;
-    }
     /**
      * Sets up tracking for the given value (variableValues, context, rootValue).
      */
     track(value, constraints, variableDefinitions) {
-        const valueStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, newValueStepCallback);
-        const trackedObjectStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => new index_js_1.__TrackedValueStep(value, valueStep, constraints, [], variableDefinitions));
+        const valueStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, newValueStepCallback, null, variableDefinitions != null);
+        const trackedObjectStep = (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, () => new index_js_1.__TrackedValueStep(value, valueStep, constraints, [], variableDefinitions != null, variableDefinitions));
         return [valueStep, trackedObjectStep];
     }
     /**
@@ -1280,8 +1289,8 @@ class OperationPlan {
                 continue;
             for (const key in step) {
                 const val = step[key];
-                if (key !== ("implicitSideEffectStep") &&
-                    val instanceof index_js_1.ExecutableStep) {
+                if (key !== "implicitSideEffectStep" &&
+                    val instanceof index_js_1.Step) {
                     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.`));
                 }
             }
@@ -1421,7 +1430,24 @@ class OperationPlan {
             // call the function with an empty array; ignore the result.
             return EMPTY_ARRAY;
         }
-        const { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, layerPlan: layerPlan, constructor: stepConstructor, peerKey, } = (0, utils_js_1.sudo)(step);
+        // NOTE: Streams have no peers - we cannot reference the stream more than
+        // once (and we aim to not cache the stream because we want its entries to
+        // be garbage collected) - however if we're already fetching the list then
+        // we shouldn't fetch it again via stream... We should deduplicate a stream
+        // to return a non-stream.
+        if (step._stepOptions.stream != null) {
+            // TODO: remove this if block when we implement the new stream/defer -
+            // deduplicating a stream should be fine. (Not subscriptions though - may
+            // need a check for that!)
+            return EMPTY_ARRAY;
+        }
+        if (this.stepTracker.internalDependencies.has(step)) {
+            // PERF: we need to set up correct tracking, then internal deps can be deduped
+            return EMPTY_ARRAY;
+        }
+        const sstep = (0, utils_js_1.sudo)(step);
+        const { dependencies: deps, dependencyForbiddenFlags: flags, dependencyOnReject: onReject, layerPlan: layerPlan, constructor: stepConstructor, peerKey, } = sstep;
+        // const streamInitialCount = sstep._stepOptions.stream?.initialCount;
         const dependencyCount = deps.length;
         if (dependencyCount === 0) {
             let allPeers = null;
@@ -1430,7 +1456,10 @@ class OperationPlan {
                 if (possiblyPeer !== step &&
                     !possiblyPeer.hasSideEffects &&
                     possiblyPeer.layerPlan === layerPlan &&
-                    possiblyPeer.peerKey === peerKey) {
+                    possiblyPeer._stepOptions.stream == null &&
+                    possiblyPeer.peerKey === peerKey
+                // && possiblyPeer._stepOptions.stream?.initialCount === streamInitialCount
+                ) {
                     if (allPeers === null) {
                         allPeers = [possiblyPeer];
                     }
@@ -1457,8 +1486,11 @@ class OperationPlan {
                 if (peerDependencyIndex !== 0 ||
                     rawPossiblyPeer === step ||
                     rawPossiblyPeer.hasSideEffects ||
+                    rawPossiblyPeer._stepOptions.stream != null ||
                     rawPossiblyPeer.constructor !== stepConstructor ||
-                    rawPossiblyPeer.peerKey !== peerKey) {
+                    rawPossiblyPeer.peerKey !== peerKey
+                // || rawPossiblyPeer._stepOptions.stream?.initialCount !== streamInitialCount
+                ) {
                     continue;
                 }
                 const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
@@ -1508,8 +1540,11 @@ class OperationPlan {
                         if (peerDependencyIndex !== dependencyIndex ||
                             rawPossiblyPeer === step ||
                             rawPossiblyPeer.hasSideEffects ||
+                            rawPossiblyPeer._stepOptions.stream != null ||
                             rawPossiblyPeer.constructor !== stepConstructor ||
-                            rawPossiblyPeer.peerKey !== peerKey) {
+                            rawPossiblyPeer.peerKey !== peerKey
+                        // || rawPossiblyPeer._stepOptions.stream?.initialCount !== streamInitialCount
+                        ) {
                             continue;
                         }
                         const possiblyPeer = (0, utils_js_1.sudo)(rawPossiblyPeer);
@@ -1738,6 +1773,11 @@ class OperationPlan {
         if (this.isImmoveable(step)) {
             return step;
         }
+        if (step._isUnary) {
+            step._isUnaryLocked = true;
+            // Don't push unary steps down
+            return step;
+        }
         switch (step.layerPlan.reason.type) {
             case "root":
             case "subscription":
@@ -1915,7 +1955,14 @@ class OperationPlan {
         return { stepsAtMinDepth, equivalentSteps };
     }
     deduplicateStep(step) {
+        // Conditions applied to this step are now finalized, though we may still
+        // tell the step to do more stuff (like fetch extra data), it can no longer
+        // change its order, conditions, etc.
         step.isArgumentsFinalized = true;
+        // If a step is unary at this point, it must always remain unary.
+        if (step._isUnary) {
+            step._isUnaryLocked = true;
+        }
         if (step.deduplicate == null)
             return step;
         const result = this._deduplicateInnerLogic(step);
@@ -1934,6 +1981,10 @@ class OperationPlan {
             }
             winner.polymorphicPaths = polymorphicPaths;
         }
+        // Equivalent steps cannot be streaming; so we can no longer stream either.
+        if (equivalentSteps.length > 0) {
+            winner._stepOptions.stream = null;
+        }
         // Give the steps a chance to pass their responsibilities to the winner.
         if (winner !== step) {
             const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
@@ -1990,7 +2041,7 @@ class OperationPlan {
                 this.deduplicateStepsProcess(processed, start, dep);
             }
         }
-        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, this.deduplicateStep, this, step);
+        (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(step.layerPlan, step.polymorphicPaths, this.phase === "plan" ? this.deduplicateStep : this.hoistAndDeduplicate, this, step);
     }
     /**
      * Gives us a chance to replace nearly-duplicate plans with other existing
@@ -2044,27 +2095,6 @@ class OperationPlan {
     pushDownSteps() {
         this.processSteps("pushDown", "dependents-first", false, this.pushDown);
     }
-    getStepOptionsForStep(step) {
-        return step._stepOptions;
-        /*
-        // NOTE: streams can only be merged if their parameters are compatible
-        // (namely they need to have equivalent `initialCount`)
-        const streamLayerPlan = step.childLayerPlans.find(
-          (lp) => lp.reason.type === "stream",
-        );
-    
-        // PERF: if step isn't streamable, don't create a streamLayerPlan because
-        // there's no point (and then we can leverage better optimisations).
-    
-        return {
-          stream:
-            streamLayerPlan && isStreamableStep(step)
-              ? // && streamLayerPlan.parentStep === step
-                { initialCount: streamLayerPlan.reason.initialCount }
-              : null,
-        };
-        */
-    }
     /**
      * Calls the 'optimize' method on a plan, which may cause the plan to
      * communicate with its (deep) dependencies, and even to replace itself with
@@ -2082,7 +2112,7 @@ class OperationPlan {
             return step;
         }
         // We know if it's streaming or not based on the LayerPlan it's contained within.
-        const stepOptions = this.getStepOptionsForStep(step);
+        // const stepOptions = step._stepOptions;
         let meta;
         if (step.optimizeMetaKey !== undefined) {
             meta = this.optimizeMeta.get(step.optimizeMetaKey);
@@ -2093,7 +2123,11 @@ class OperationPlan {
         }
         const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
         const replacementStep = step.optimize({
-            ...stepOptions,
+            stream: step._stepOptions.stream
+                ? {
+                // We could add more details here, but for now we don't really need them?
+                }
+                : null,
             meta,
         });
         if (wasLocked)
@@ -2197,7 +2231,6 @@ class OperationPlan {
     /** Finalizes each step */
     finalizeSteps() {
         const initialStepCount = this.stepTracker.stepCount;
-        assert.strictEqual(this.modifierSteps.length, 0, "No modifier steps expected when performing finalizeSteps");
         for (const step of this.stepTracker.activeSteps) {
             const wasLocked = index_js_1.isDev && (0, lock_js_1.unlock)(step);
             step.finalize();
@@ -2330,7 +2363,7 @@ class OperationPlan {
                         !(0, utils_js_1.stepADependsOnStepB)(sstep, latestSideEffectStep)) {
                         sstep.implicitSideEffectStep = latestSideEffectStep;
                     }
-                    if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedExecutableStep)(step)) {
+                    if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedStep)(step)) {
                         if (phase.unbatchedSyncAndSafeSteps !== undefined) {
                             phase.unbatchedSyncAndSafeSteps.push({
                                 step,
@@ -2360,7 +2393,7 @@ class OperationPlan {
                 do {
                     foundOne = false;
                     for (const step of pending) {
-                        if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedExecutableStep)(step)) {
+                        if (step.isSyncAndSafe && (0, step_js_1.isUnbatchedStep)(step)) {
                             if (readyToExecute(step)) {
                                 processed.add(step);
                                 pending.delete(step);
@@ -2442,6 +2475,18 @@ class OperationPlan {
             if (layerPlan.reason.type === "listItem") {
                 const parentStep = layerPlan.reason.parentStep;
                 ensurePlanAvailableInLayer(parentStep, layerPlan.parentLayerPlan);
+                const stream = layerPlan.reason.stream;
+                if (stream != null) {
+                    if (stream.initialCountStepId) {
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.initialCountStepId), layerPlan.parentLayerPlan);
+                    }
+                    if (stream.ifStepId) {
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.ifStepId), layerPlan.parentLayerPlan);
+                    }
+                    if (stream.labelStepId) {
+                        ensurePlanAvailableInLayer(this.stepTracker.getStepById(stream.labelStepId), layerPlan.parentLayerPlan);
+                    }
+                }
             }
         }
         // Populate copyPlanIds for output plans' rootStepId
@@ -2501,6 +2546,9 @@ class OperationPlan {
                 isSyncAndSafe: step.isSyncAndSafe || undefined,
                 supportsUnbatched: typeof step.unbatchedExecute === "function" || undefined,
                 hasSideEffects: step.hasSideEffects || undefined,
+                stream: step._stepOptions.stream
+                    ? { initialCountStepId: step._stepOptions.stream.initialCountStepId }
+                    : undefined,
                 extra: step.planJSONExtra(),
             };
         }
@@ -2624,14 +2672,19 @@ class OperationPlan {
      * need to regenerate it on future calls, significantly reducing the load on
      * deduplication later.
      *
+     * Note: automatically extends the cached step into other (relevant)
+     * polymorphic paths; if this shouldn't be the case then don't use cacheStep
+     * and instead rely on deduplication as usual.
+     *
      * @experimental
      */
     cacheStep(ownerStep, actionKey, cacheKey, cb) {
         const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
+        const paths = (0, withGlobalLayerPlan_js_1.currentPolymorphicPaths)();
         const cache = (this._cacheStepStoreByLayerPlanAndActionKey[`${actionKey}|${layerPlan.id}|${ownerStep.id}`] ??= new Map());
         const cacheIt = () => {
             const stepToCache = cb();
-            if (!(stepToCache instanceof index_js_1.ExecutableStep)) {
+            if (!(stepToCache instanceof index_js_1.Step)) {
                 throw new Error(`The callback passed to cacheStep must always return an ExecutableStep; but this call from ${ownerStep} returned instead ${(0, inspect_js_1.inspect)(stepToCache)}`);
             }
             cache.set(cacheKey, stepToCache.id);
@@ -2642,7 +2695,20 @@ class OperationPlan {
         }
         const cachedStepId = cache.get(cacheKey);
         const cachedStep = this.stepTracker.stepById[cachedStepId];
-        return cachedStep ?? cacheIt();
+        if (cachedStep) {
+            // Fix poly paths
+            if (paths && cachedStep.polymorphicPaths) {
+                const polymorphicPaths = new Set([
+                    ...cachedStep.polymorphicPaths,
+                    ...paths,
+                ]);
+                cachedStep.polymorphicPaths = polymorphicPaths;
+            }
+            return cachedStep;
+        }
+        else {
+            return cacheIt();
+        }
     }
     /**
      * Clears the cache, typically due to side effects having taken place. Called
@@ -2651,13 +2717,11 @@ class OperationPlan {
     resetCache() {
         this._cacheStepStoreByLayerPlanAndActionKey = Object.create(null);
     }
+    withRootLayerPlan(cb) {
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.rootLayerPlan, exports.POLYMORPHIC_ROOT_PATHS, cb);
+    }
 }
 exports.OperationPlan = OperationPlan;
-function makeDefaultPlan(fieldName) {
-    return ($step) => typeof $step.get === "function"
-        ? $step.get(fieldName)
-        : (0, access_js_1.access)($step, [fieldName]);
-}
 function makeMetaByMetaKeysFactory(allMetaKeysList) {
     const l = allMetaKeysList.length;
     // Optimize the common cases