grafast 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/engine/LayerPlan.d.ts

@@ -1,5 +1,5 @@
 import type { Bucket } from "../bucket.js";
-import type { ExecutableStep, ModifierStep, UnbatchedExecutableStep } from "../step";
+import type { Step } from "../step";
 import type { OperationPlan } from "./OperationPlan";
 /** Non-branching, non-deferred */
 export interface LayerPlanReasonRoot {
@@ -15,7 +15,12 @@ export interface LayerPlanReasonNullableField {
      *
      * Also needed for execution (see `executeBucket`).
      */
-    parentStep: ExecutableStep;
+    parentStep: Step;
+}
+export interface LayerPlanReasonListItemStream {
+    initialCountStepId?: number;
+    ifStepId?: number;
+    labelStepId?: number;
 }
 /** Non-branching, non-deferred */
 export interface LayerPlanReasonListItem {
@@ -27,12 +32,11 @@ export interface LayerPlanReasonListItem {
      *
      * Also needed for execution (see `executeBucket`).
      */
-    parentStep: ExecutableStep;
-    /** If this listItem is to be streamed, the configuration for that streaming */
-    stream?: {
-        initialCount: number;
-        label?: string;
-    };
+    parentStep: Step;
+    /**
+     * If this listItem is to be streamed, the configuration for that streaming.
+     */
+    stream?: LayerPlanReasonListItemStream;
 }
 /** Non-branching, deferred */
 export interface LayerPlanReasonSubscription {
@@ -55,59 +59,22 @@ export interface LayerPlanReasonPolymorphic {
     /**
      * Needed for execution (see `executeBucket`).
      */
-    parentStep: ExecutableStep;
+    parentStep: Step;
     polymorphicPaths: Set<string>;
 }
 /** Non-branching, non-deferred */
 export interface LayerPlanReasonSubroutine {
     type: "subroutine";
-    parentStep: ExecutableStep;
+    parentStep: Step;
 }
-export declare function isBranchingLayerPlan(layerPlan: LayerPlan<any>): boolean;
-export declare function isDeferredLayerPlan(layerPlan: LayerPlan<any>): boolean;
-export declare function isPolymorphicLayerPlan(layerPlan: LayerPlan<any>): boolean;
+export declare function isBranchingLayerPlan(layerPlan: LayerPlan): boolean;
+export declare function isDeferredLayerPlan(layerPlan: LayerPlan): boolean;
+export declare function isPolymorphicLayerPlan(layerPlan: LayerPlan): boolean;
 export type LayerPlanReason = LayerPlanReasonRoot | LayerPlanReasonNullableField | LayerPlanReasonListItem | LayerPlanReasonSubscription | LayerPlanReasonMutationField | LayerPlanReasonDefer | LayerPlanReasonPolymorphic | LayerPlanReasonSubroutine;
 export type HasParent<A extends LayerPlanReason> = A extends any ? A extends {
-    parentStep: ExecutableStep;
+    parentStep: Step;
 } ? A : never : never;
 export type LayerPlanReasonsWithParentStep = HasParent<LayerPlanReason>;
-/** @internal */
-export interface LayerPlanPhase {
-    /**
-     * If true, we should check before the layer plan executes to see if the
-     * execution has already timed out.
-     *
-     * @see {@link RequestTools.stopTime}
-     */
-    checkTimeout: boolean;
-    /**
-     * A list of steps that can be ran in parallel at this point, since all
-     * their previous dependencies have already been satisfied.
-     */
-    normalSteps: Array<{
-        step: ExecutableStep;
-    }> | undefined;
-    /**
-     * A list of 'isSyncAndSafe' steps with unbatchedExecute methods that can be
-     * ran once the `normalSteps` have completed; they must only depend on steps
-     * that have already been executed before them (including previous
-     * unbatchedSyncAndSafeSteps in the same list).
-     */
-    unbatchedSyncAndSafeSteps: Array<{
-        step: UnbatchedExecutableStep;
-        /**
-         * Store the result of the step here if you want - useful to avoid lookups
-         * and when there's no storage. HIGHLY VOLATILE, will not survive a tick!
-         */
-        scratchpad: any;
-    }> | undefined;
-    /**
-     * Optimization - a digest of all steps in normalSteps and unbatchedSyncAndSafeSteps
-     *
-     * @internal
-     */
-    _allSteps: ExecutableStep[];
-}
 /**
  * A LayerPlan represents (via "reason") either the root (root), when something
  * happens at a later time (mutationField, defer), when plurality changes
@@ -138,58 +105,6 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
     parentLayerPlan: LayerPlan | null;
     readonly reason: TReason;
     id: number;
-    /**
-     * Every layer plan has a "root step" that shapes the value the layer
-     * returns. Note that this step may be dependent on other steps included in
-     * the LayerPlan, or could be provided externally.
-     *
-     * The root step is different for different layer step reasons:
-     *
-     * - root: the `operationPlan.rootValue`
-     * - listItem: the `__ItemStep`
-     * - stream: also the `__ItemStep`
-     * - subscription: also the `__ItemStep`
-     * - mutationField: the result plan of the mutation field
-     * - defer: the parent layer's rootStep (defer always results in an object, unless an error occurs)
-     * - polymorphic: the plan for the particular type
-     * - subroutine: the result (returned) plan of the subroutine
-     *
-     * @internal
-     */
-    readonly rootStep: ExecutableStep | null;
-    /**
-     * Which plans the results for which are available in a parent bucket need to
-     * be "copied across" to this bucket because plans in this bucket still
-     * reference them?
-     *
-     * @internal
-     */
-    copyStepIds: number[];
-    /** @internal */
-    children: LayerPlan[];
-    /** @internal */
-    steps: ExecutableStep[];
-    /** @internal */
-    pendingSteps: ExecutableStep[];
-    /**
-     * Describes the order in which the steps within this LayerPlan are executed.
-     *
-     * Special attention must be paid to steps that have side effects.
-     *
-     * @internal
-     */
-    phases: Array<LayerPlanPhase>;
-    /**
-     * The list of layerPlans that steps added to this LayerPlan may depend upon.
-     * Note this includes self, so it has one more entry than `depth`.
-     *
-     * ```
-     * this.ancestry[this.depth] === this;
-     * ```
-     *
-     * @internal
-     */
-    ancestry: LayerPlan[];
     /** How "deep" this layer plan is (how many ancestors it has). The root layer plan has a depth of 0. */
     depth: number;
     /** The depth at which a "defer boundary" occurs (OperationPlan.getPeers cannot pass a defer boundary), or 0. */
@@ -198,17 +113,12 @@ export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason
      * An optimization for OperationPlan.getPeers; this tracks the steps in this
      * layer plan, grouped by their step class.
      */
-    stepsByConstructor: Map<Function, Set<ExecutableStep>>;
+    stepsByConstructor: Map<Function, Set<Step>>;
     constructor(operationPlan: OperationPlan, parentLayerPlan: LayerPlan | null, reason: TReason);
     toString(): string;
     print(depth?: number): string;
-    setRootStep($root: ExecutableStep): void;
-    /** @internal Use plan.getStep(id) instead. */
-    getStep(id: number, requestingStep: ExecutableStep): ExecutableStep;
-    /** @internal */
-    _addStep(step: ExecutableStep): number;
-    /** @internal */
-    _addModifierStep(step: ModifierStep<any>): string;
+    _hasSetRootStep: boolean;
+    setRootStep($root: Step): void;
     finalize(): void;
     newBucket(parentBucket: Bucket): Bucket | null;
 }