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

package/dist/engine/OperationPlan.d.ts

@@ -1,16 +1,15 @@
 import type { FragmentDefinitionNode, GraphQLFieldMap, GraphQLObjectType, GraphQLSchema, GraphQLUnionType, OperationDefinitionNode } from "graphql";
 import type { Constraint } from "../constraints.js";
 import type { SelectionSetDigest } from "../graphqlCollectFields.js";
-import type { GrafastPlanJSON, ModifierStep } from "../index.js";
-import { __TrackedValueStep, __ValueStep, ExecutableStep } from "../index.js";
+import type { GrafastPlanJSON } from "../index.js";
+import { Step } from "../index.js";
 import { $$timeout, $$ts } from "../interfaces.js";
 import type { LayerPlanReasonSubroutine } from "./LayerPlan.js";
 import { LayerPlan } from "./LayerPlan.js";
 import { OutputPlan } from "./OutputPlan.js";
-import { StepTracker } from "./StepTracker.js";
 export declare const POLYMORPHIC_ROOT_PATH: null;
 export declare const POLYMORPHIC_ROOT_PATHS: ReadonlySet<string> | null;
-/** @internal */
+/** Beware: the list of phases may change over time... @experimental */
 export type OperationPlanPhase = "init" | "plan" | "validate" | "optimize" | "finalize" | "ready";
 export interface MetaByMetaKey {
     [metaKey: string | number | symbol]: Record<string, any>;
@@ -49,62 +48,12 @@ export declare class OperationPlan {
      * 7. ready
      *
      * Once in 'ready' state we can execute the plan.
-     *
-     * @internal
      */
     phase: OperationPlanPhase;
     /**
      * Gets updated as we work our way through the plan, useful for making errors more helpful.
      */
     loc: string[] | null;
-    /** @internal */
-    rootLayerPlan: LayerPlan;
-    /**
-     * Assigned during OperationPlan.planOperation(), guaranteed to exist after
-     * initialization.
-     *
-     * @internal
-     */
-    rootOutputPlan: OutputPlan;
-    private modifierStepCount;
-    private modifierDepthCount;
-    private modifierSteps;
-    /** @internal */
-    readonly stepTracker: StepTracker;
-    private maxDeduplicatedStepId;
-    private maxValidatedStepId;
-    /** Constraints based on evaluating variables. @internal */
-    readonly variableValuesConstraints: Constraint[];
-    /** Stores the actual variableValues. @internal */
-    readonly variableValuesStep: __ValueStep<{
-        [key: string]: any;
-    }>;
-    /** A step for accessing variableValues in a tracked manner (allowing eval). @internal */
-    readonly trackedVariableValuesStep: __TrackedValueStep<{
-        [key: string]: any;
-    }>;
-    /** Constraints based on evaluating context. @internal */
-    readonly contextConstraints: Constraint[];
-    /** Stores the actual value of the context. @internal */
-    readonly contextStep: __ValueStep<Grafast.Context>;
-    /** Allows accessing context in a tracked manner (allowing eval). @internal */
-    readonly trackedContextStep: __TrackedValueStep<{
-        [key: string]: any;
-    }>;
-    /** Constraints based on evaluating rootValue. @internal */
-    readonly rootValueConstraints: Constraint[];
-    /** Stores the actual value of rootValue. @internal */
-    readonly rootValueStep: __ValueStep<any>;
-    /** Allows accessing rootValue in a tracked manner (allowing eval). @internal */
-    readonly trackedRootValueStep: __TrackedValueStep<any>;
-    /** @internal */
-    makeMetaByMetaKey: () => MetaByMetaKey;
-    /**
-     * @internal
-     */
-    readonly itemStepIdByListStepId: {
-        [listStepId: number]: number | undefined;
-    };
     /**
      * If true, then this operation doesn't use (custom) resolvers.
      */
@@ -116,42 +65,13 @@ export declare class OperationPlan {
     private scalarPlanInfo;
     constructor(schema: GraphQLSchema, operation: OperationDefinitionNode, fragments: {
         [fragmentName: string]: FragmentDefinitionNode;
-    }, variableValues: {
+    }, variableValuesConstraints: Constraint[], variableValues: {
         [key: string]: any;
-    }, context: {
+    }, contextConstraints: Constraint[], context: {
         [key: string]: any;
-    }, rootValue: any, planningTimeout: number | null);
+    }, rootValueConstraints: Constraint[], rootValue: any, planningTimeout: number | null);
     private lap;
     private checkTimeout;
-    /**
-     * Called by the LayerPlan's constructor when it wants to get a new id to use.
-     *
-     * @internal
-     */
-    addLayerPlan(layerPlan: LayerPlan): number;
-    /**
-     * 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
-     */
-    _addStep(plan: ExecutableStep): number;
-    /**
-     * 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: ModifierStep<any>): string;
-    /** @internal Use plan.getStep(id) instead. */
-    getStep: (id: number, requestingStep: ExecutableStep) => ExecutableStep;
-    /**
-     * Get a plan without specifying who requested it; this disables all the
-     * caller checks. Only intended to be called from internal code.
-     *
-     * @internal
-     */
-    dangerouslyGetStep(id: number): ExecutableStep;
     private planOperation;
     /**
      * Plans a GraphQL query operation.
@@ -170,7 +90,7 @@ export declare class OperationPlan {
      * create one item plan per parent plan.
      */
     private itemStepForListStep;
-    processGroupedFieldSet(outputPlan: OutputPlan, path: readonly string[], polymorphicPath: string | null, polymorphicPaths: ReadonlySet<string> | null, parentStep: ExecutableStep, objectType: GraphQLObjectType, objectTypeFields: GraphQLFieldMap<any, any>, isMutation: boolean, groupedFieldSet: SelectionSetDigest): void;
+    processGroupedFieldSet(outputPlan: OutputPlan, path: readonly string[], polymorphicPath: string | null, polymorphicPaths: ReadonlySet<string> | null, parentStep: Step, objectType: GraphQLObjectType, objectTypeFields: GraphQLFieldMap<any, any>, isMutation: boolean, groupedFieldSet: SelectionSetDigest): void;
     /**
      *
      * @param outputPlan - The output plan that this selection set is being added to
@@ -181,6 +101,7 @@ export declare class OperationPlan {
      * @param isMutation - If true this selection set should be executed serially rather than in parallel (each field gets its own LayerPlan)
      */
     private planSelectionSet;
+    private internalDependency;
     private planIntoOutputPlan;
     private polymorphicLayerPlanByPathByLayerPlan;
     private getPolymorphicLayerPlan;
@@ -192,7 +113,6 @@ export declare class OperationPlan {
      * @see https://spec.graphql.org/draft/#CoerceArgumentValues()
      */
     private getTrackedArguments;
-    withModifiers<T>(cb: () => T): T;
     /**
      * Sets up tracking for the given value (variableValues, context, rootValue).
      */
@@ -204,13 +124,6 @@ export declare class OperationPlan {
     private validateSteps;
     private replaceStep;
     private processStep;
-    /**
-     * Process the given steps, either dependencies first (root to leaf) or
-     * dependents first (leaves to root).
-     *
-     * @internal
-     */
-    processSteps(actionDescription: string, order: "dependents-first" | "dependencies-first", isReadonly: boolean, callback: (plan: ExecutableStep) => ExecutableStep): void;
     /**
      * Peers are steps of the same type (but not the same step!) that are in
      * compatible layers and have the same dependencies. Peers must not have side
@@ -246,7 +159,6 @@ export declare class OperationPlan {
     private hoistAndDeduplicate;
     private hoistSteps;
     private pushDownSteps;
-    private getStepOptionsForStep;
     /**
      * Calls the 'optimize' method on a plan, which may cause the plan to
      * communicate with its (deep) dependencies, and even to replace itself with
@@ -258,6 +170,7 @@ export declare class OperationPlan {
      * know all our dependent's needs before we optimise ourself.
      */
     private optimizeSteps;
+    private inlineSteps;
     /** Finalizes each step */
     private finalizeSteps;
     private finalizeLayerPlans;
@@ -267,16 +180,29 @@ export declare class OperationPlan {
     private finalizeOutputPlans;
     private walkOutputPlans;
     generatePlanJSON(): GrafastPlanJSON;
-    finishSubroutine(subroutineStep: ExecutableStep, layerPlan: LayerPlan<LayerPlanReasonSubroutine>): void;
+    finishSubroutine(subroutineStep: Step, layerPlan: LayerPlan<LayerPlanReasonSubroutine>): void;
+    getStepsByMetaKey(metaKey: string | number | symbol): Step[];
+    getStepsByStepClass<TClass extends Step>(klass: {
+        new (...args: any[]): TClass;
+    }): TClass[];
+    private _cacheStepStoreByLayerPlanAndActionKey;
     /**
-     * HIGHLY EXPERIMENTAL!
+     * Cache a generated step by a given identifier (cacheKey) such that we don't
+     * 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.
      *
-     * @internal
+     * @experimental
      */
-    deleteLayerPlan(layerPlan: LayerPlan): void;
-    getStepsByMetaKey(metaKey: string | number | symbol): ExecutableStep[];
-    getStepsByStepClass<TClass extends ExecutableStep>(klass: {
-        new (...args: any[]): TClass;
-    }): TClass[];
+    cacheStep<T extends Step>(ownerStep: Step, actionKey: string, cacheKey: symbol | string | number | boolean | null | undefined, cb: () => T): T;
+    /**
+     * Clears the cache, typically due to side effects having taken place. Called
+     * from setting hasSideEffects on an ExecutableStep, among other places.
+     */
+    resetCache(): void;
+    withRootLayerPlan<T>(cb: () => T): T;
 }
 //# sourceMappingURL=OperationPlan.d.ts.map