grafast 0.0.1-0.1 → 0.0.1-0.2

package/dist/engine/LayerPlan.d.ts

@@ -0,0 +1,80 @@
+import type { Bucket } from "../bucket.js";
+import type { ExecutableStep, ModifierStep, UnbatchedExecutableStep } from "../step";
+import type { OperationPlan } from "./OperationPlan";
+export interface LayerPlanReasonRoot {
+    type: "root";
+}
+export interface LayerPlanReasonNullableField {
+    type: "nullableBoundary";
+    parentStep: ExecutableStep;
+}
+export interface LayerPlanReasonListItem {
+    type: "listItem";
+    parentStep: ExecutableStep;
+    stream?: {
+        initialCount: number;
+        label?: string;
+    };
+}
+export interface LayerPlanReasonSubscription {
+    type: "subscription";
+}
+export interface LayerPlanReasonMutationField {
+    type: "mutationField";
+}
+export interface LayerPlanReasonDefer {
+    type: "defer";
+    label?: string;
+}
+export interface LayerPlanReasonPolymorphic {
+    type: "polymorphic";
+    typeNames: string[];
+    parentStep: ExecutableStep;
+}
+export interface LayerPlanReasonSubroutine {
+    type: "subroutine";
+    parentStep: ExecutableStep;
+}
+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 type LayerPlanReason = LayerPlanReasonRoot | LayerPlanReasonNullableField | LayerPlanReasonListItem | LayerPlanReasonSubscription | LayerPlanReasonMutationField | LayerPlanReasonDefer | LayerPlanReasonPolymorphic | LayerPlanReasonSubroutine;
+export declare type HasParent<A extends LayerPlanReason> = A extends any ? A extends {
+    parentStep: ExecutableStep;
+} ? A : never : never;
+export declare type LayerPlanReasonsWithParentStep = HasParent<LayerPlanReason>;
+export interface LayerPlanPhase {
+    normalSteps?: Array<{
+        step: ExecutableStep;
+    }>;
+    unbatchedSyncAndSafeSteps?: Array<{
+        step: UnbatchedExecutableStep;
+        scratchpad: any;
+    }>;
+    _allSteps: ExecutableStep[];
+}
+export declare class LayerPlan<TReason extends LayerPlanReason = LayerPlanReason> {
+    readonly operationPlan: OperationPlan;
+    parentLayerPlan: LayerPlan | null;
+    readonly reason: TReason;
+    polymorphicPaths: ReadonlySet<string>;
+    id: number;
+    readonly rootStep: ExecutableStep | null;
+    copyPlanIds: number[];
+    children: LayerPlan[];
+    steps: ExecutableStep[];
+    pendingSteps: ExecutableStep[];
+    phases: Array<LayerPlanPhase>;
+    ancestry: LayerPlan[];
+    constructor(operationPlan: OperationPlan, parentLayerPlan: LayerPlan | null, reason: TReason, polymorphicPaths: ReadonlySet<string>);
+    toString(): string;
+    print(depth?: number): string;
+    setRootStep($root: ExecutableStep): void;
+    getStep(id: number, requestingStep: ExecutableStep): ExecutableStep;
+    _addStep(step: ExecutableStep): number;
+    _addModifierStep(step: ModifierStep<any>): string;
+    makeNewBucketCallback(inner: string): typeof this.newBucket;
+    finalize(): void;
+    newBucket(parentBucket: Bucket): Bucket | null;
+}
+//# sourceMappingURL=LayerPlan.d.ts.map

package/dist/engine/OperationPlan.d.ts

@@ -0,0 +1,120 @@
+import type { FragmentDefinitionNode, GraphQLObjectType, GraphQLSchema, GraphQLUnionType, OperationDefinitionNode } from "graphql";
+import type { Constraint } from "../constraints.js";
+import type { ModifierStep } from "../index.js";
+import { __TrackedObjectStep, __ValueStep, ExecutableStep } from "../index.js";
+import type { PrintPlanGraphOptions } from "../mermaid.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 = "";
+export declare type OperationPlanPhase = "init" | "plan" | "validate" | "optimize" | "finalize" | "ready";
+export interface MetaByMetaKey {
+    [metaKey: string | number | symbol]: Record<string, any>;
+}
+export declare class OperationPlan {
+    readonly schema: GraphQLSchema;
+    readonly operation: OperationDefinitionNode;
+    readonly fragments: {
+        [fragmentName: string]: FragmentDefinitionNode;
+    };
+    readonly variableValues: {
+        [key: string]: any;
+    };
+    readonly context: {
+        [key: string]: any;
+    };
+    readonly rootValue: any;
+    readonly queryType: GraphQLObjectType;
+    readonly mutationType: GraphQLObjectType | null;
+    readonly subscriptionType: GraphQLObjectType | null;
+    readonly unionsContainingObjectType: {
+        [objectTypeName: string]: ReadonlyArray<GraphQLUnionType>;
+    };
+    private operationType;
+    phase: OperationPlanPhase;
+    loc: string[] | null;
+    rootLayerPlan: LayerPlan;
+    rootOutputPlan: OutputPlan;
+    private modifierStepCount;
+    private modifierDepthCount;
+    private modifierSteps;
+    readonly stepTracker: StepTracker;
+    private maxDeduplicatedStepId;
+    private maxValidatedStepId;
+    readonly variableValuesConstraints: Constraint[];
+    readonly variableValuesStep: __ValueStep<{
+        [key: string]: any;
+    }>;
+    readonly trackedVariableValuesStep: __TrackedObjectStep<{
+        [key: string]: any;
+    }>;
+    readonly contextConstraints: Constraint[];
+    readonly contextStep: __ValueStep<{
+        [key: string]: any;
+    }>;
+    readonly trackedContextStep: __TrackedObjectStep<{
+        [key: string]: any;
+    }>;
+    readonly rootValueConstraints: Constraint[];
+    readonly rootValueStep: __ValueStep<any>;
+    readonly trackedRootValueStep: __TrackedObjectStep<any>;
+    makeMetaByMetaKey: () => MetaByMetaKey;
+    readonly itemStepIdByListStepId: {
+        [listStepId: number]: number | undefined;
+    };
+    pure: boolean;
+    constructor(schema: GraphQLSchema, operation: OperationDefinitionNode, fragments: {
+        [fragmentName: string]: FragmentDefinitionNode;
+    }, variableValues: {
+        [key: string]: any;
+    }, context: {
+        [key: string]: any;
+    }, rootValue: any);
+    addLayerPlan(layerPlan: LayerPlan): number;
+    _addStep(plan: ExecutableStep): number;
+    _addModifierStep(step: ModifierStep<any>): string;
+    getStep: (id: number, requestingStep: ExecutableStep) => ExecutableStep;
+    dangerouslyGetStep(id: number): ExecutableStep;
+    private planOperation;
+    private planQuery;
+    private planMutation;
+    private planSubscription;
+    private itemStepForListStep;
+    private planSelectionSet;
+    private planIntoOutputPlan;
+    private polymorphicLayerPlanByPathByLayerPlan;
+    private getPolymorphicLayerPlan;
+    private planField;
+    private getTrackedArguments;
+    withModifiers<T>(cb: () => T): T;
+    private track;
+    private validateSteps;
+    private replaceStep;
+    processSteps(actionDescription: string, fromStepId: number, order: "dependents-first" | "dependencies-first", callback: (plan: ExecutableStep<any>) => ExecutableStep<any>): void;
+    private getPeers;
+    private isImmoveable;
+    private hoistStep;
+    private pushDown;
+    private _deduplicateInnerLogic;
+    private deduplicateStep;
+    private deduplicateSteps;
+    private hoistSteps;
+    private pushDownSteps;
+    private getStepOptionsForStep;
+    private optimizeStep;
+    private optimizeSteps;
+    private finalizeSteps;
+    private finalizeLayerPlans;
+    private optimizeOutputPlans;
+    private finalizeOutputPlans;
+    private walkOutputPlans;
+    printPlanGraph(options?: PrintPlanGraphOptions): string;
+    finishSubroutine(subroutineStep: ExecutableStep, layerPlan: LayerPlan<LayerPlanReasonSubroutine>): void;
+    deleteLayerPlan(layerPlan: LayerPlan): void;
+    getStepsByMetaKey(metaKey: string | number | symbol): ExecutableStep[];
+    getStepsByStepClass<TClass extends ExecutableStep>(klass: {
+        new (...args: any[]): TClass;
+    }): TClass[];
+}
+//# sourceMappingURL=OperationPlan.d.ts.map

package/dist/engine/OutputPlan.d.ts

@@ -0,0 +1,84 @@
+import type LRU from "@graphile/lru";
+import type { FieldNode, GraphQLEnumType, GraphQLObjectType, GraphQLScalarType } from "graphql";
+import { GraphQLError } from "graphql";
+import type { Bucket } from "../bucket.js";
+import type { JSONValue, LocationDetails } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import type { PayloadRoot } from "./executeOutputPlan.js";
+import type { LayerPlan } from "./LayerPlan.js";
+export declare type OutputPlanTypeIntrospection = {
+    mode: "introspection";
+    field: FieldNode;
+    variableNames: string[];
+    introspectionCacheByVariableValues: LRU<string, JSONValue>;
+};
+export declare type OutputPlanTypeRoot = {
+    mode: "root";
+    typeName: string;
+};
+export declare type OutputPlanTypeObject = {
+    mode: "object";
+    typeName: string;
+    deferLabel: string | undefined;
+};
+export declare type OutputPlanTypePolymorphicObject = {
+    mode: "polymorphic";
+    typeNames: string[];
+    deferLabel: string | undefined;
+};
+export declare type OutputPlanTypeArray = {
+    mode: "array";
+};
+export declare type OutputPlanTypeLeaf = {
+    mode: "leaf";
+    serialize: GraphQLScalarType["serialize"];
+    graphqlType: GraphQLScalarType | GraphQLEnumType;
+};
+export declare type OutputPlanTypeNull = {
+    mode: "null";
+};
+export declare type OutputPlanType = OutputPlanTypeRoot | OutputPlanTypeObject | OutputPlanTypePolymorphicObject | OutputPlanTypeLeaf | OutputPlanTypeNull | OutputPlanTypeArray | OutputPlanTypeIntrospection;
+export declare type OutputPlanKeyValueOutputPlan = {
+    type: "outputPlan";
+    outputPlan: OutputPlan;
+    isNonNull: boolean;
+    locationDetails: LocationDetails;
+};
+export declare type OutputPlanKeyValueTypeName = {
+    type: "__typename";
+    locationDetails: LocationDetails;
+};
+export declare type OutputPlanKeyValue = OutputPlanKeyValueOutputPlan | OutputPlanKeyValueTypeName;
+export declare type OutputPlanKeyValueOutputPlanWithCachedBits = OutputPlanKeyValueOutputPlan & {
+    layerPlanId: number;
+};
+export declare class OutputPlan<TType extends OutputPlanType = OutputPlanType> {
+    layerPlan: LayerPlan;
+    readonly type: TType;
+    readonly locationDetails: LocationDetails;
+    readonly rootStep: ExecutableStep;
+    private processRoot;
+    keys: {
+        [key: string]: OutputPlanKeyValueTypeName | OutputPlanKeyValueOutputPlanWithCachedBits;
+    };
+    child: OutputPlan | null;
+    childIsNonNull: boolean;
+    childByTypeName: {
+        [typeName: string]: OutputPlan<OutputPlanTypeObject>;
+    };
+    deferredOutputPlans: OutputPlan<OutputPlanTypeObject | OutputPlanTypePolymorphicObject>[];
+    constructor(layerPlan: LayerPlan, rootStep: ExecutableStep, type: TType, locationDetails: LocationDetails);
+    print(): string;
+    toString(): string;
+    addChild(type: GraphQLObjectType | null, key: string | null, child: OutputPlanKeyValue): void;
+    getLayerPlans(layerPlans?: Set<LayerPlan<import("./LayerPlan.js").LayerPlanReason>>): Set<LayerPlan>;
+    makeNextStepByLayerPlan(): Record<number, any[]>;
+    execute(this: OutputPlan, _root: PayloadRoot, _mutablePath: Array<string | number>, _bucket: Bucket, _bucketIndex: number): JSONValue;
+    executeString(this: OutputPlan, _root: PayloadRoot, _mutablePath: Array<string | number>, _bucket: Bucket, _bucketIndex: number): string;
+    optimize(): void;
+    finalize(): void;
+}
+export declare function coerceError(error: Error, locationDetails: LocationDetails, path: ReadonlyArray<string | number>): GraphQLError;
+export declare function nonNullError(locationDetails: LocationDetails, path: readonly (string | number)[]): GraphQLError;
+export declare function getChildBucketAndIndex(childOutputPlan: OutputPlan, outputPlan: OutputPlan | null, bucket: Bucket, bucketIndex: number, arrayIndex?: number | null): [Bucket, number] | null;
+//# sourceMappingURL=OutputPlan.d.ts.map

package/dist/engine/StepTracker.d.ts

@@ -0,0 +1,35 @@
+import type { OperationPlan } from "../index.js";
+import type { ExecutableStep } from "../step";
+import type { LayerPlan, LayerPlanReasonsWithParentStep } from "./LayerPlan";
+import type { OutputPlan } from "./OutputPlan";
+export declare class StepTracker {
+    private readonly operationPlan;
+    stepCount: number;
+    activeSteps: Set<ExecutableStep<any>>;
+    stepById: {
+        [stepId: number]: ExecutableStep;
+    };
+    private aliasesById;
+    stepsWithNoDependencies: Set<ExecutableStep<any>>;
+    outputPlansByRootStep: Map<ExecutableStep<any>, Set<OutputPlan<import("./OutputPlan").OutputPlanType>>>;
+    layerPlansByRootStep: Map<ExecutableStep<any>, Set<LayerPlan<import("./LayerPlan").LayerPlanReason>>>;
+    layerPlansByParentStep: Map<ExecutableStep<any>, Set<LayerPlan<LayerPlanReasonsWithParentStep>>>;
+    layerPlans: Array<LayerPlan | null>;
+    allOutputPlans: OutputPlan[];
+    constructor(operationPlan: OperationPlan);
+    private assertPhaseNot;
+    addStep($step: ExecutableStep): number;
+    addLayerPlan(layerPlan: LayerPlan): number;
+    addOutputPlan(outputPlan: OutputPlan): void;
+    deleteLayerPlan(layerPlan: LayerPlan): void;
+    getStepById(id: number): ExecutableStep;
+    getStepById(id: number, allowUnset: true): ExecutableStep | null;
+    addStepDependency($dependent: ExecutableStep, $dependency: ExecutableStep): number;
+    setOutputPlanRootStep(outputPlan: OutputPlan, $dependency: ExecutableStep): void;
+    setLayerPlanRootStep(layerPlan: LayerPlan, $dependency: ExecutableStep): void;
+    replaceStep($original: ExecutableStep, $replacement: ExecutableStep): void;
+    treeShakeSteps(): void;
+    private isNotNeeded;
+    private eradicate;
+}
+//# sourceMappingURL=StepTracker.d.ts.map

package/dist/engine/executeBucket.d.ts

@@ -0,0 +1,5 @@
+import type { Bucket, RequestContext } from "../bucket.js";
+import type { PromiseOrDirect } from "../interfaces.js";
+export declare function executeBucket(bucket: Bucket, requestContext: RequestContext): PromiseOrDirect<void>;
+export declare function newBucket(spec: Pick<Bucket, "layerPlan" | "store" | "size" | "hasErrors" | "polymorphicPathList">): Bucket;
+//# sourceMappingURL=executeBucket.d.ts.map

package/dist/engine/executeOutputPlan.d.ts

@@ -0,0 +1,42 @@
+import type { GraphQLError } from "graphql";
+import type { Bucket, RequestContext } from "../bucket.js";
+import type { JSONValue } from "../interfaces.js";
+import type { OutputPlan } from "./OutputPlan.js";
+export declare type OutputPath = Array<string | number>;
+export interface OutputStream {
+    asyncIterable: AsyncIterableIterator<any>;
+}
+export interface PayloadRoot {
+    insideGraphQL: boolean;
+    errors: GraphQLError[];
+    queue: Array<SubsequentPayloadSpec>;
+    streams: Array<SubsequentStreamSpec>;
+    variables: {
+        [key: string]: any;
+    };
+}
+export interface OutputPlanContext {
+    requestContext: RequestContext;
+    root: PayloadRoot;
+    path: ReadonlyArray<string | number>;
+}
+export interface SubsequentPayloadSpec {
+    root: PayloadRoot;
+    path: ReadonlyArray<string | number>;
+    bucket: Bucket;
+    bucketIndex: number;
+    outputPlan: OutputPlan;
+    label: string | undefined;
+}
+export interface SubsequentStreamSpec {
+    root: PayloadRoot;
+    path: ReadonlyArray<string | number>;
+    bucket: Bucket;
+    bucketIndex: number;
+    outputPlan: OutputPlan;
+    label: string | undefined;
+    stream: AsyncIterableIterator<any>;
+    startIndex: number;
+}
+export declare function executeOutputPlan(ctx: OutputPlanContext, outputPlan: OutputPlan, bucket: Bucket, bucketIndex: number, asString: boolean): JSONValue;
+//# sourceMappingURL=executeOutputPlan.d.ts.map

package/dist/engine/lib/withGlobalLayerPlan.d.ts

@@ -0,0 +1,5 @@
+import type { LayerPlan } from "../LayerPlan";
+export declare function withGlobalLayerPlan<T>(layerPlan: LayerPlan, polymorphicPaths: ReadonlySet<string>, callback: () => T): T;
+export declare function currentLayerPlan(): LayerPlan;
+export declare function currentPolymorphicPaths(): ReadonlySet<string>;
+//# sourceMappingURL=withGlobalLayerPlan.d.ts.map