grafast 0.1.1-beta.21 → 0.1.1-beta.23

package/dist/engine/OperationPlan.d.ts

@@ -1,11 +1,14 @@
-import type { FragmentDefinitionNode, GraphQLFieldMap, GraphQLObjectType, GraphQLSchema, GraphQLUnionType, OperationDefinitionNode } from "graphql";
+import type { FragmentDefinitionNode, GraphQLField, GraphQLObjectType, GraphQLOutputType, GraphQLSchema, GraphQLUnionType, OperationDefinitionNode } from "graphql";
+import { $$timeout, $$ts } from "../constants.js";
 import type { Constraint } from "../constraints.js";
-import type { SelectionSetDigest } from "../graphqlCollectFields.js";
 import type { GrafastPlanJSON } from "../index.js";
 import { Step } from "../index.js";
-import { $$timeout, $$ts } from "../interfaces.js";
+import type { FieldPlanResolver, LocationDetails, TrackedArguments } from "../interfaces.js";
+import type { ApplyAfterModeArg } from "../operationPlan-input.js";
+import type { GrafastOperationOptions } from "../prepare.js";
 import type { LayerPlanReasonSubroutine } from "./LayerPlan.js";
 import { LayerPlan } from "./LayerPlan.js";
+import type { ProcessGroupedFieldSetDetails, StreamDetails } from "./OperationPlanTypes.js";
 import { OutputPlan } from "./OutputPlan.js";
 export declare const POLYMORPHIC_ROOT_PATH: null;
 export declare const POLYMORPHIC_ROOT_PATHS: ReadonlySet<string> | null;
@@ -27,7 +30,6 @@ export declare class OperationPlan {
         [key: string]: any;
     };
     readonly rootValue: any;
-    private readonly planningTimeout;
     readonly [$$timeout]: undefined;
     readonly [$$ts]: undefined;
     readonly queryType: GraphQLObjectType;
@@ -63,13 +65,16 @@ export declare class OperationPlan {
     private laps;
     private optimizeMeta;
     private scalarPlanInfo;
+    private frozenPlanningPaths;
+    private readonly planningTimeout;
+    private readonly maxPlanningDepth;
     constructor(schema: GraphQLSchema, operation: OperationDefinitionNode, fragments: {
         [fragmentName: string]: FragmentDefinitionNode;
     }, variableValuesConstraints: Constraint[], variableValues: {
         [key: string]: any;
     }, contextConstraints: Constraint[], context: {
         [key: string]: any;
-    }, rootValueConstraints: Constraint[], rootValue: any, planningTimeout: number | null);
+    }, rootValueConstraints: Constraint[], rootValue: any, options: GrafastOperationOptions);
     private lap;
     private checkTimeout;
     private planOperation;
@@ -85,12 +90,19 @@ export declare class OperationPlan {
      * Implements the `PlanOpPlanSubscription` algorithm.
      */
     private planSubscription;
+    private getCombinedLayerPlanForLayerPlans;
     /**
      * Gets the item plan for a given parent list plan - this ensures we only
      * create one item plan per parent plan.
      */
     private itemStepForListStep;
-    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;
+    processGroupedFieldSet(details: ProcessGroupedFieldSetDetails): Generator<() => {
+        haltTree: boolean;
+        step: Step;
+    }, void, {
+        step: Step<any>;
+        haltTree: boolean;
+    }>;
     /**
      *
      * @param outputPlan - The output plan that this selection set is being added to
@@ -101,11 +113,35 @@ 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 planningQueue;
+    private planningQueueByPlanningPath;
+    private queueNextLayer;
+    private planPending;
+    withLocLpSE(loc: string[] | null, layerPlan: LayerPlan, layerPlanLatestSideEffect: Step | null, cb: () => void): void;
+    private mutateTodos;
     private internalDependency;
+    private planFieldReturnType;
     private planIntoOutputPlan;
-    private polymorphicLayerPlanByPathByLayerPlan;
-    private getPolymorphicLayerPlan;
-    private planField;
+    handlePlanningError(details: {
+        outputPlan: OutputPlan;
+        layerPlan: LayerPlan;
+        objectType: GraphQLObjectType | null;
+        responseKey: string | null;
+        positionType: GraphQLOutputType;
+        locationDetails: LocationDetails;
+        err: Error;
+    }): void;
+    private polymorphicPlanObjectType;
+    planFieldBatch: PlanFieldBatch | null;
+    private batchPlanField;
+    private processPlanField;
+    _realPlanField(planFieldDetails: PlanFieldDetails): {
+        step: Step<unknown>;
+        haltTree: boolean;
+    } | {
+        step: import("../index.js").ErrorStep<any>;
+        haltTree: boolean;
+    };
     /**
      * A replacement for GraphQL's
      * `CoerceArgumentValues` that factors in tracked variables.
@@ -156,6 +192,7 @@ export declare class OperationPlan {
      * our child plans would be expecting.
      */
     private deduplicateSteps;
+    private _deduplicateStepsInner;
     private hoistAndDeduplicate;
     private hoistSteps;
     private pushDownSteps;
@@ -185,19 +222,17 @@ export declare class OperationPlan {
     getStepsByStepClass<TClass extends Step>(klass: {
         new (...args: any[]): TClass;
     }): TClass[];
-    private _cacheStepStoreByLayerPlanAndActionKey;
+    private _cacheStepStoreByActionKeyByLayerPlan;
+    private _immutableCacheStepStoreAndActionKey;
     /**
      * 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.
-     *
      * @experimental
      */
     cacheStep<T extends Step>(ownerStep: Step, actionKey: string, cacheKey: symbol | string | number | boolean | null | undefined, cb: () => T): T;
+    _cacheStep<T extends Step>(store: StepCache, ownerStep: Step, actionKey: string, cacheKey: any, cb: () => T): T;
     /**
      * Clears the cache, typically due to side effects having taken place. Called
      * from setting hasSideEffects on an ExecutableStep, among other places.
@@ -205,4 +240,32 @@ export declare class OperationPlan {
     resetCache(): void;
     withRootLayerPlan<T>(cb: () => T): T;
 }
+type StepCache = Record<string, Map<any, any> | undefined>;
+interface PlanFieldDetails {
+    typeName: string;
+    fieldName: string;
+    layerPlan: LayerPlan;
+    path: readonly string[];
+    polymorphicPaths: ReadonlySet<string> | null;
+    planningPath: string;
+    planResolver: FieldPlanResolver;
+    applyAfterMode: ApplyAfterModeArg;
+    rawParentStep: Step;
+    field: GraphQLField<any, any>;
+    trackedArguments: TrackedArguments;
+    streamDetails: StreamDetails | true | false | null;
+}
+type PlanFieldBatchResult = {
+    error: Error;
+} | {
+    error?: never;
+    haltTree: boolean;
+    step: Step;
+};
+interface PlanFieldBatch {
+    complete: boolean;
+    batch: Array<PlanFieldDetails>;
+    results: Array<PlanFieldBatchResult>;
+}
+export {};
 //# sourceMappingURL=OperationPlan.d.ts.map