grafast 0.0.0 → 0.0.1-0.2

package/dist/input.d.ts

@@ -0,0 +1,11 @@
+import type { GraphQLInputType, GraphQLType, ListTypeNode, NamedTypeNode, NonNullTypeNode, ValueNode } from "graphql";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import { __InputDynamicScalarStep } from "./steps/__inputDynamicScalar.js";
+import { __InputObjectStep } from "./steps/__inputObject.js";
+import type { ConstantStep } from "./steps/index.js";
+import { __InputListStep, __InputStaticLeafStep, __TrackedObjectStep } from "./steps/index.js";
+export declare type InputStep = __TrackedObjectStep | __InputListStep | __InputStaticLeafStep | __InputDynamicScalarStep | __InputObjectStep | ConstantStep<undefined>;
+export declare function assertInputStep(itemPlan: unknown): asserts itemPlan is InputStep;
+export declare function graphqlGetTypeForNode(operationPlan: OperationPlan, node: NamedTypeNode | ListTypeNode | NonNullTypeNode): GraphQLType;
+export declare function inputPlan(operationPlan: OperationPlan, inputType: GraphQLInputType, seenTypes: Set<GraphQLInputType>, rawInputValue: ValueNode | undefined, defaultValue?: ValueNode | undefined): InputStep;
+//# sourceMappingURL=input.d.ts.map

package/dist/inspect.d.ts

@@ -0,0 +1,4 @@
+export declare let inspect: (obj: any, options?: {
+    colors: boolean;
+}) => string;
+//# sourceMappingURL=inspect.d.ts.map

package/dist/interfaces.d.ts

@@ -0,0 +1,261 @@
+import type EventEmitter from "eventemitter3";
+import type { PluginHook } from "graphile-config";
+import type { ASTNode, ExecutionArgs, GraphQLArgument, GraphQLArgumentConfig, GraphQLField, GraphQLFieldConfig, GraphQLInputField, GraphQLInputFieldConfig, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLType } from "graphql";
+import type { Bucket, RequestContext } from "./bucket.js";
+import type { GrafastError } from "./error.js";
+import type { InputStep } from "./input.js";
+import type { ExecutableStep, ListCapableStep, ModifierStep } from "./step.js";
+import type { GraphileInputObjectType, GraphileObjectType } from "./utils.js";
+declare type PromiseOrValue<T> = T | Promise<T>;
+export interface GrafastOptions {
+    context?: Record<string, any> | (<TContext extends Record<string, any>>(ctx: GraphileConfig.GraphQLRequestContext, currentContext?: Partial<TContext>) => PromiseOrValue<Partial<TContext>>);
+    explain?: boolean | string[];
+}
+declare global {
+    namespace GraphileConfig {
+        interface GraphQLRequestContext {
+        }
+        interface Preset {
+            grafast?: GrafastOptions;
+        }
+        interface GrafastHooks {
+            args: PluginHook<(event: {
+                args: ExecutionArgs;
+                ctx: GraphileConfig.GraphQLRequestContext;
+                resolvedPreset: GraphileConfig.ResolvedPreset;
+            }) => PromiseOrValue<ExecutionArgs>>;
+        }
+        interface Plugin {
+            grafast?: {
+                hooks?: GrafastHooks;
+            };
+        }
+    }
+}
+export interface GrafastFieldExtensions {
+    plan?: FieldPlanResolver<any, any, any>;
+    subscribePlan?: FieldPlanResolver<any, any, any>;
+}
+export interface GrafastArgumentExtensions {
+    inputPlan?: ArgumentInputPlanResolver;
+    applyPlan?: ArgumentApplyPlanResolver;
+}
+export interface GrafastInputObjectTypeExtensions {
+    inputPlan?: InputObjectTypeInputPlanResolver;
+}
+export interface GrafastInputFieldExtensions {
+    inputPlan?: InputObjectFieldInputPlanResolver;
+    applyPlan?: InputObjectFieldApplyPlanResolver;
+}
+export interface GrafastObjectTypeExtensions {
+    Step?: {
+        new (...args: any[]): ExecutableStep;
+    };
+}
+export interface GrafastEnumTypeExtensions {
+}
+export interface GrafastEnumValueExtensions {
+    applyPlan?: EnumValueApplyPlanResolver<any>;
+}
+export interface GrafastScalarTypeExtensions {
+    plan?: ScalarPlanResolver;
+    inputPlan?: ScalarInputPlanResolver;
+    idempotent?: boolean;
+}
+declare module "graphql" {
+    interface GraphQLFieldExtensions<_TSource, _TContext, _TArgs = any> {
+        graphile?: GrafastFieldExtensions;
+    }
+    interface GraphQLArgumentExtensions {
+        graphile?: GrafastArgumentExtensions;
+    }
+    interface GraphQLInputObjectTypeExtensions {
+        graphile?: GrafastInputObjectTypeExtensions;
+    }
+    interface GraphQLInputFieldExtensions {
+        graphile?: GrafastInputFieldExtensions;
+    }
+    interface GraphQLObjectTypeExtensions<_TSource = any, _TContext = any> {
+        graphile?: GrafastObjectTypeExtensions;
+    }
+    interface GraphQLEnumTypeExtensions {
+        graphile?: GrafastEnumTypeExtensions;
+    }
+    interface GraphQLEnumValueExtensions {
+        graphile?: GrafastEnumValueExtensions;
+    }
+    interface GraphQLScalarTypeExtensions {
+        graphile?: GrafastScalarTypeExtensions;
+    }
+}
+export declare const $$grafastContext: unique symbol;
+export declare const $$planResults: unique symbol;
+export declare const $$id: unique symbol;
+export declare const $$verbatim: unique symbol;
+export declare const $$bypassGraphQL: unique symbol;
+export declare const $$data: unique symbol;
+export declare const $$extensions: unique symbol;
+export declare const $$concreteType: unique symbol;
+export declare const $$idempotent: unique symbol;
+export declare const $$eventEmitter: unique symbol;
+export declare const $$streamMore: unique symbol;
+export declare const $$proxy: unique symbol;
+export interface PolymorphicData<TType extends string = string, TData = any> {
+    [$$concreteType]: TType;
+    [$$data]?: TData;
+}
+export interface IndexByListItemStepId {
+    [listItemStepId: number]: number;
+}
+export declare type GrafastValuesList<T> = ReadonlyArray<T>;
+export declare type PromiseOrDirect<T> = PromiseLike<T> | T;
+export declare type GrafastResultsList<T> = ReadonlyArray<PromiseOrDirect<T>>;
+export declare type GrafastResultStreamList<T> = ReadonlyArray<AsyncIterable<PromiseOrDirect<T>> | GrafastError>;
+export declare type BaseGraphQLRootValue = any;
+export interface BaseGraphQLContext {
+}
+export interface BaseGraphQLVariables {
+    [key: string]: unknown;
+}
+export interface BaseGraphQLArguments {
+    [key: string]: any;
+}
+export declare type BaseGraphQLInputObject = BaseGraphQLArguments;
+export interface FieldArgs {
+    get(path?: string | string[]): ExecutableStep;
+    getRaw(path?: string | string[]): InputStep;
+    apply($target: ExecutableStep | ModifierStep, path?: string | string[]): void;
+}
+export interface FieldInfo {
+    field: GraphQLField<any, any, any>;
+    schema: GraphQLSchema;
+}
+export declare type FieldPlanResolver<_TArgs extends BaseGraphQLArguments, TParentStep extends ExecutableStep<any> | null, TResultStep extends ExecutableStep<any>> = ($parentPlan: TParentStep, args: FieldArgs, info: FieldInfo) => TResultStep | null;
+export declare type InputObjectFieldInputPlanResolver<TResultStep extends ExecutableStep<any> = ExecutableStep<any>> = (input: FieldArgs, info: {
+    schema: GraphQLSchema;
+    entity: GraphQLInputField;
+}) => TResultStep;
+export declare type InputObjectFieldApplyPlanResolver<TFieldStep extends ExecutableStep<any> | ModifierStep<any> = ExecutableStep<any> | ModifierStep<any>, TResultStep extends ModifierStep<ExecutableStep<any> | ModifierStep<any>> | null | void = ModifierStep<ExecutableStep<any> | ModifierStep<any>> | null | void> = ($fieldPlan: TFieldStep, input: FieldArgs, info: {
+    schema: GraphQLSchema;
+    entity: GraphQLInputField;
+}) => TResultStep;
+export declare type InputObjectTypeInputPlanResolver = (input: FieldArgs, info: {
+    schema: GraphQLSchema;
+    type: GraphQLInputObjectType;
+}) => ExecutableStep;
+export declare type ArgumentInputPlanResolver<TParentStep extends ExecutableStep<any> = ExecutableStep<any>, TResultStep extends ExecutableStep<any> = ExecutableStep<any>> = ($parentPlan: TParentStep, input: FieldArgs, info: {
+    schema: GraphQLSchema;
+    entity: GraphQLArgument;
+}) => TResultStep;
+export declare type ArgumentApplyPlanResolver<TParentStep extends ExecutableStep<any> = ExecutableStep<any>, TFieldStep extends ExecutableStep<any> | ModifierStep<any> = ExecutableStep<any> | ModifierStep<any>, TResultStep extends ExecutableStep | ModifierStep<ExecutableStep | ModifierStep> | null | void = ExecutableStep | ModifierStep<ExecutableStep | ModifierStep> | null | void> = ($parentPlan: TParentStep, $fieldPlan: TFieldStep, input: FieldArgs, info: {
+    schema: GraphQLSchema;
+    entity: GraphQLArgument;
+}) => TResultStep;
+export declare type ScalarPlanResolver<TParentStep extends ExecutableStep<any> = ExecutableStep<any>, TResultStep extends ExecutableStep<any> = ExecutableStep<any>> = ($parentPlan: TParentStep, info: {
+    schema: GraphQLSchema;
+}) => TResultStep;
+export declare type ScalarInputPlanResolver<TResultStep extends ExecutableStep<any> = ExecutableStep<any>> = ($inputValue: InputStep, info: {
+    schema: GraphQLSchema;
+    type: GraphQLScalarType;
+}) => TResultStep;
+export declare type EnumValueApplyPlanResolver<TParentStep extends ExecutableStep | ModifierStep = ExecutableStep | ModifierStep> = ($parent: TParentStep) => ModifierStep | void;
+declare type OutputPlanForNamedType<TType extends GraphQLType> = TType extends GraphileObjectType<any, infer TStep, any> ? TStep : ExecutableStep<any>;
+export declare type OutputPlanForType<TType extends GraphQLOutputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? ListCapableStep<any, OutputPlanForNamedType<U>> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> : TType extends GraphQLList<infer U> ? ListCapableStep<any, OutputPlanForNamedType<U>> : TType extends GraphQLNonNull<infer U> ? OutputPlanForNamedType<U> : OutputPlanForNamedType<TType>;
+declare type InputPlanForNamedType<TType extends GraphQLType> = TType extends GraphileInputObjectType<any, infer U, any> ? U : ModifierStep<any>;
+declare type InputPlanForType<TType extends GraphQLInputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? InputPlanForNamedType<U> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? InputPlanForNamedType<U> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? InputPlanForNamedType<U> : TType extends GraphQLList<infer U> ? InputPlanForNamedType<U> : TType extends GraphQLNonNull<infer U> ? InputPlanForNamedType<U> : InputPlanForNamedType<TType>;
+declare type InputTypeForNamedType<TType extends GraphQLType> = TType extends GraphQLScalarType<infer U> ? U : any;
+declare type InputTypeFor<TType extends GraphQLInputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? InputTypeForNamedType<U> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? InputTypeForNamedType<U> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? InputTypeForNamedType<U> : TType extends GraphQLList<infer U> ? InputTypeForNamedType<U> : TType extends GraphQLNonNull<infer U> ? InputTypeForNamedType<U> : InputTypeForNamedType<TType>;
+export declare type GraphileFieldConfig<TType extends GraphQLOutputType, TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any> | null, TFieldStep extends ExecutableStep<any>, TArgs extends BaseGraphQLArguments> = Omit<GraphQLFieldConfig<any, any>, "args" | "type"> & {
+    type: TType;
+    plan?: FieldPlanResolver<TArgs, TParentStep, TFieldStep>;
+    subscribePlan?: FieldPlanResolver<TArgs, TParentStep, TFieldStep>;
+    args?: GraphileFieldConfigArgumentMap<TType, TContext, TParentStep, TFieldStep>;
+};
+export declare type GraphileFieldConfigArgumentMap<_TType extends GraphQLOutputType, TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any> | null, TFieldStep extends ExecutableStep<any>> = {
+    [argName: string]: GraphileArgumentConfig<any, TContext, TParentStep, TFieldStep, any, any>;
+};
+export declare type GraphileArgumentConfig<TInputType extends GraphQLInputType, _TContext extends BaseGraphQLContext, _TParentStep extends ExecutableStep<any> | null, TFieldStep extends ExecutableStep<any>, _TArgumentStep extends TFieldStep extends ExecutableStep<any> ? ModifierStep<TFieldStep> | null : null, _TInput extends InputTypeFor<TInputType>> = Omit<GraphQLArgumentConfig, "type"> & {
+    type: TInputType;
+    inputPlan?: ArgumentInputPlanResolver<any>;
+    applyPlan?: ArgumentApplyPlanResolver<any, any>;
+};
+export declare type GraphileInputFieldConfig<TInputType extends GraphQLInputType, _TContext extends BaseGraphQLContext, _TParentStep extends ModifierStep<any>, _TResultStep extends InputPlanForType<TInputType>, _TInput extends InputTypeFor<TInputType>> = Omit<GraphQLInputFieldConfig, "type"> & {
+    type: TInputType;
+    inputPlan?: InputObjectFieldInputPlanResolver;
+    applyPlan?: InputObjectFieldApplyPlanResolver<any>;
+};
+export declare type TrackedArguments<TArgs extends BaseGraphQLArguments = BaseGraphQLArguments> = {
+    get<TKey extends keyof TArgs>(key: TKey): InputStep;
+};
+export interface StepStreamOptions {
+    initialCount: number;
+}
+export interface StepOptions {
+    stream: StepStreamOptions | null;
+}
+export interface StepOptimizeOptions {
+    stream: StepStreamOptions | null;
+}
+export declare type GrafastSubscriber<TTopics extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> = {
+    subscribe<TTopic extends keyof TTopics = keyof TTopics>(topic: TTopic): AsyncIterableIterator<TTopics[TTopic]>;
+};
+export interface NodeIdCodec<T = any> {
+    encode(value: T): string | null;
+    decode(value: string): T;
+}
+export declare type NodeIdHandler<TCodecs extends {
+    [key: string]: NodeIdCodec<any>;
+} = {
+    [key: string]: NodeIdCodec<any>;
+}, TCodecName extends keyof TCodecs = keyof TCodecs, TNodeStep extends ExecutableStep<any> = ExecutableStep<any>, TSpec = any> = {
+    typeName: string;
+    codecName: TCodecName & string;
+    match(specifier: TCodecs[TCodecName] extends NodeIdCodec<infer U> ? U : any): boolean;
+    plan($thing: TNodeStep): ExecutableStep<TCodecs[TCodecName] extends NodeIdCodec<infer U> ? U : any>;
+    getSpec(plan: ExecutableStep<TCodecs[TCodecName] extends NodeIdCodec<infer U> ? U : any>): TSpec;
+    get(spec: TSpec): TNodeStep;
+    deprecationReason?: string;
+};
+export declare type BaseEventMap = Record<string, any>;
+export declare type EventMapKey<TEventMap extends BaseEventMap> = string & keyof TEventMap;
+export declare type EventCallback<TPayload> = (params: TPayload) => void;
+export interface TypedEventEmitter<TEventMap extends BaseEventMap> extends EventEmitter<any, any> {
+    addListener<TEventName extends EventMapKey<TEventMap>>(eventName: TEventName, callback: EventCallback<TEventMap[TEventName]>): this;
+    on<TEventName extends EventMapKey<TEventMap>>(eventName: TEventName, callback: EventCallback<TEventMap[TEventName]>): this;
+    once<TEventName extends EventMapKey<TEventMap>>(eventName: TEventName, callback: EventCallback<TEventMap[TEventName]>): this;
+    removeListener<TEventName extends EventMapKey<TEventMap>>(eventName: TEventName, callback: EventCallback<TEventMap[TEventName]>): this;
+    off<TEventName extends EventMapKey<TEventMap>>(eventName: TEventName, callback: EventCallback<TEventMap[TEventName]>): this;
+    emit<TEventName extends EventMapKey<TEventMap>>(eventName: TEventName, params: TEventMap[TEventName]): boolean;
+}
+export declare type ExecutionEventMap = {
+    explainOperation: {
+        operation: Record<string, any> & {
+            type: string;
+            title: string;
+        };
+    };
+};
+export declare type ExecutionEventEmitter = TypedEventEmitter<ExecutionEventMap>;
+export interface ExecutionExtra {
+    meta: Record<string, unknown>;
+    eventEmitter: ExecutionEventEmitter | undefined;
+    _bucket: Bucket;
+    _requestContext: RequestContext;
+}
+export interface LocationDetails {
+    node: ASTNode | readonly ASTNode[];
+    parentTypeName: string | null;
+    fieldName: string | null;
+}
+export declare type JSONValue = boolean | number | string | null | JSONObject | JSONArray;
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+export interface JSONArray extends Array<JSONValue> {
+}
+export {};
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/makeGrafastSchema.d.ts

@@ -0,0 +1,52 @@
+import type { GraphQLFieldResolver, GraphQLScalarLiteralParser, GraphQLScalarSerializer, GraphQLScalarValueParser, GraphQLSchema } from "graphql";
+import type { ArgumentApplyPlanResolver, ArgumentInputPlanResolver, EnumValueApplyPlanResolver, FieldPlanResolver, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, ScalarPlanResolver } from "./interfaces.js";
+import type { ExecutableStep } from "./step.js";
+export declare type FieldPlans = FieldPlanResolver<any, any, any> | {
+    plan?: FieldPlanResolver<any, any, any>;
+    subscribePlan?: FieldPlanResolver<any, any, any>;
+    resolve?: GraphQLFieldResolver<any, any>;
+    subscribe?: GraphQLFieldResolver<any, any>;
+    args?: {
+        [argName: string]: {
+            input?: ArgumentInputPlanResolver;
+            apply?: ArgumentApplyPlanResolver;
+        };
+    };
+};
+export declare type ObjectPlans = {
+    __Step?: {
+        new (...args: any[]): ExecutableStep<any>;
+    };
+} & {
+    [fieldName: string]: FieldPlans;
+};
+export declare type InputObjectPlans = {
+    [fieldName: string]: {
+        input: InputObjectFieldInputPlanResolver;
+        apply: InputObjectFieldApplyPlanResolver;
+    };
+};
+export declare type InterfaceOrUnionPlans = {
+    __resolveType?: (o: unknown) => string;
+};
+export declare type ScalarPlans = {
+    serialize?: GraphQLScalarSerializer<any>;
+    parseValue?: GraphQLScalarValueParser<any>;
+    parseLiteral?: GraphQLScalarLiteralParser<any>;
+    plan?: ScalarPlanResolver<any, any>;
+};
+export declare type EnumPlans = {
+    [enumValueName: string]: EnumValueApplyPlanResolver | string | number | boolean | {
+        value?: unknown;
+        apply?: EnumValueApplyPlanResolver;
+    };
+};
+export interface GrafastPlans {
+    [typeName: string]: ObjectPlans | InputObjectPlans | InterfaceOrUnionPlans | ScalarPlans | EnumPlans;
+}
+export declare function makeGrafastSchema(details: {
+    typeDefs: string;
+    plans: GrafastPlans;
+    enableDeferStream: boolean;
+}): GraphQLSchema;
+//# sourceMappingURL=makeGrafastSchema.d.ts.map

package/dist/mermaid.d.ts

@@ -0,0 +1,15 @@
+import type { OperationPlan } from ".";
+import type { ExecutableStep } from "./step.js";
+export declare const COLORS: string[];
+export declare const mermaidEscape: (str: string) => string;
+export interface PrintPlanGraphOptions {
+    printPathRelations?: boolean;
+    includePaths?: boolean;
+    concise?: boolean;
+}
+export declare function printPlanGraph(operationPlan: OperationPlan, { concise, }: PrintPlanGraphOptions, { steps, }: {
+    steps: {
+        [stepId: number]: ExecutableStep;
+    };
+}): string;
+//# sourceMappingURL=mermaid.d.ts.map

package/dist/opPlan-input.d.ts

@@ -0,0 +1,6 @@
+import type { GraphQLField } from "graphql";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { FieldArgs, TrackedArguments } from "./interfaces.js";
+import { ExecutableStep } from "./step.js";
+export declare function withFieldArgsForArguments<T extends ExecutableStep, TParentStep extends ExecutableStep<any> = ExecutableStep<any>>(operationPlan: OperationPlan, parentPlan: TParentStep, $all: TrackedArguments, field: GraphQLField<any, any, any>, callback: (fieldArgs: FieldArgs) => T | null | undefined): Exclude<T, undefined | null | void> | TParentStep;
+//# sourceMappingURL=opPlan-input.d.ts.map

package/dist/polymorphic.d.ts

@@ -0,0 +1,6 @@
+import type { PolymorphicData } from "./interfaces.js";
+export declare function isPolymorphicData(data: unknown): data is PolymorphicData;
+export declare function assertPolymorphicData(data: unknown): asserts data is PolymorphicData;
+export declare function polymorphicWrap<TType extends string>(type: TType, data?: unknown): PolymorphicData<TType>;
+export declare function resolveType(o: unknown): string;
+//# sourceMappingURL=polymorphic.d.ts.map

package/dist/prepare.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutionArgs } from "graphql";
+import type { AsyncExecutionResult, ExecutionResult } from "graphql/execution/execute";
+import type { OperationPlan } from "./index.js";
+import type { PromiseOrDirect } from "./interfaces.js";
+export interface GrafastPrepareOptions {
+    explain?: boolean | string[];
+    asString?: boolean;
+}
+export declare function executePreemptive(operationPlan: OperationPlan, variableValues: any, context: any, rootValue: any, asString: boolean): PromiseOrDirect<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>>;
+export declare function grafastPrepare(args: ExecutionArgs, options?: GrafastPrepareOptions): PromiseOrDirect<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>>;
+//# sourceMappingURL=prepare.d.ts.map

package/dist/step.d.ts

@@ -0,0 +1,104 @@
+import type { GraphQLObjectType } from "graphql";
+import type { LayerPlan } from "./engine/LayerPlan.js";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { ExecutionExtra, GrafastResultsList, GrafastResultStreamList, GrafastValuesList, PromiseOrDirect, StepOptimizeOptions, StepOptions } from "./interfaces.js";
+import type { __ItemStep } from "./steps/index.js";
+export declare const $$deepDepSkip: unique symbol;
+export declare const $$noExec: unique symbol;
+declare function reallyAssertFinalized(plan: BaseStep): void;
+export declare const assertFinalized: typeof reallyAssertFinalized;
+export declare abstract class BaseStep {
+    readonly layerPlan: LayerPlan;
+    readonly opPlan: OperationPlan;
+    isArgumentsFinalized: boolean;
+    isFinalized: boolean;
+    debug: boolean;
+    hasSideEffects: boolean;
+    constructor();
+    toString(): string;
+    toStringMeta(): string | null;
+    finalize(): void;
+    destroy(): void;
+}
+export declare class ExecutableStep<TData = any> extends BaseStep {
+    static $$export: any;
+    isSyncAndSafe: boolean;
+    readonly dependencies: ReadonlyArray<ExecutableStep>;
+    readonly dependents: ReadonlyArray<{
+        step: ExecutableStep;
+        dependencyIndex: number;
+    }>;
+    readonly id: number;
+    isOptimized: boolean;
+    allowMultipleOptimizations: boolean;
+    _stepOptions: StepOptions;
+    polymorphicPaths: ReadonlySet<string>;
+    store: boolean;
+    metaKey: number | string | symbol;
+    constructor();
+    protected withMyLayerPlan<T>(callback: () => T): T;
+    protected getStep(id: number): ExecutableStep;
+    getDep(depId: number): ExecutableStep;
+    protected getDepDeep(depId: number): ExecutableStep;
+    toString(): string;
+    protected addDependency(step: ExecutableStep, skipDeduplication?: boolean): number;
+    deduplicate(_peers: readonly ExecutableStep[]): readonly ExecutableStep[];
+    deduplicatedWith(replacement: ExecutableStep): void;
+    optimize(_options: StepOptimizeOptions): ExecutableStep;
+    finalize(): void;
+    execute(values: ReadonlyArray<GrafastValuesList<any>>, extra: ExecutionExtra): PromiseOrDirect<GrafastResultsList<TData>>;
+    destroy(): void;
+}
+export declare abstract class UnbatchedExecutableStep<TData = any> extends ExecutableStep<TData> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    finalize(): void;
+    execute(values: ReadonlyArray<GrafastValuesList<any>>, extra: ExecutionExtra): PromiseOrDirect<GrafastResultsList<TData>>;
+    abstract unbatchedExecute(extra: ExecutionExtra, ...tuple: any[]): PromiseOrDirect<TData>;
+}
+export declare function isExecutableStep<TData = any>(step: unknown): step is ExecutableStep<TData>;
+export declare function assertExecutableStep<TData>(step: BaseStep): asserts step is ExecutableStep<TData>;
+export declare function isUnbatchedExecutableStep<TData = any>(step: unknown): step is UnbatchedExecutableStep<TData>;
+export declare type ObjectLikeStep<TData extends {
+    [key: string]: ExecutableStep<any>;
+} = {
+    [key: string]: ExecutableStep<any>;
+}> = ExecutableStep<{
+    [key in keyof TData]: TData[key] extends ExecutableStep<infer U> ? U : never;
+}> & {
+    get<TKey extends keyof TData>(key: TKey): ExecutableStep<TData[TKey]>;
+};
+export declare function isObjectLikeStep<TData extends {
+    [key: string]: ExecutableStep<any>;
+} = {
+    [key: string]: ExecutableStep<any>;
+}>(plan: ExecutableStep): plan is ObjectLikeStep<TData>;
+export declare type StreamableStep<TData> = ExecutableStep<ReadonlyArray<TData>> & {
+    stream(values: ReadonlyArray<GrafastValuesList<any>>, extra: ExecutionExtra, streamOptions: {
+        initialCount: number;
+    }): PromiseOrDirect<GrafastResultStreamList<TData>>;
+};
+export declare function isStreamableStep<TData>(plan: ExecutableStep<ReadonlyArray<TData>>): plan is StreamableStep<TData>;
+export declare type PolymorphicStep = ExecutableStep & {
+    planForType(objectType: GraphQLObjectType): ExecutableStep;
+};
+export declare function isPolymorphicStep(s: ExecutableStep): s is PolymorphicStep;
+export declare abstract class ModifierStep<TParentStep extends BaseStep = BaseStep> extends BaseStep {
+    protected readonly $parent: TParentStep;
+    static $$export: any;
+    readonly id: string;
+    constructor($parent: TParentStep);
+    toString(): string;
+    abstract apply(): void;
+}
+export declare function isModifierStep<TParentStep extends ExecutableStep | ModifierStep<any>>(plan: BaseStep): plan is ModifierStep<TParentStep>;
+export declare function assertModifierStep<TParentStep extends ExecutableStep | ModifierStep<any>>(plan: BaseStep, pathDescription: string): asserts plan is ModifierStep<TParentStep>;
+export interface ListCapableStep<TOutputData, TItemStep extends ExecutableStep<TOutputData> = ExecutableStep<TOutputData>> extends ExecutableStep<ReadonlyArray<any>> {
+    listItem(itemPlan: __ItemStep<this>): TItemStep;
+}
+export declare function isListCapableStep<TData, TItemStep extends ExecutableStep<TData>>(plan: ExecutableStep<ReadonlyArray<TData>>): plan is ListCapableStep<TData, TItemStep>;
+export declare function assertListCapableStep<TData, TItemStep extends ExecutableStep<TData>>(plan: ExecutableStep<ReadonlyArray<TData>>, pathDescription: string): asserts plan is ListCapableStep<TData, TItemStep>;
+export {};
+//# sourceMappingURL=step.d.ts.map

package/dist/steps/__inputDynamicScalar.d.ts

@@ -0,0 +1,18 @@
+import type { GraphQLScalarType, ListValueNode, ObjectValueNode } from "graphql";
+import type { ExecutionExtra } from "../interfaces.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class __InputDynamicScalarStep<TLeaf = any> extends UnbatchedExecutableStep<TLeaf> {
+    private value;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private variableNames;
+    constructor(inputType: GraphQLScalarType, value: ListValueNode | ObjectValueNode);
+    valueFromValues(variableValues: any[]): any;
+    unbatchedExecute: (extra: ExecutionExtra, ...variableValues: any[]) => TLeaf;
+    eval(): TLeaf;
+    evalIs(expectedValue: undefined | null | 0): boolean;
+}
+//# sourceMappingURL=__inputDynamicScalar.d.ts.map

package/dist/steps/__inputList.d.ts

@@ -0,0 +1,23 @@
+import type { GraphQLInputType, ValueNode } from "graphql";
+import { GraphQLList } from "graphql";
+import type { InputStep } from "../input.js";
+import { ExecutableStep } from "../step.js";
+import type { ConstantStep } from "./constant.js";
+export declare class __InputListStep extends ExecutableStep {
+    private readonly inputValues;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private itemCount;
+    constructor(inputType: GraphQLList<GraphQLInputType>, seenTypes: Set<GraphQLInputType>, inputValues: ValueNode | undefined);
+    optimize(): ConstantStep<null> | ConstantStep<any[]>;
+    execute(): any[];
+    unbatchedExecute: () => any;
+    at(index: number): InputStep | ConstantStep<undefined>;
+    eval(): any[] | null;
+    evalIs(value: null | undefined | 0): boolean;
+    evalLength(): number | null;
+}
+//# sourceMappingURL=__inputList.d.ts.map

package/dist/steps/__inputObject.d.ts

@@ -0,0 +1,24 @@
+import type { GraphQLInputObjectType, GraphQLInputType, ValueNode } from "graphql";
+import type { InputStep } from "../input.js";
+import type { ExecutionExtra } from "../interfaces.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class __InputObjectStep extends UnbatchedExecutableStep {
+    private inputObjectType;
+    private inputValues;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private inputFields;
+    constructor(inputObjectType: GraphQLInputObjectType, seenTypes: Set<GraphQLInputType>, inputValues: ValueNode | undefined);
+    optimize(): this | import("./constant.js").ConstantStep<null>;
+    finalize(): void;
+    unbatchedExecute(extra: ExecutionExtra, ...values: any[]): any;
+    get(attrName: string): InputStep;
+    eval(): any;
+    evalIs(value: null | undefined | 0): boolean;
+    evalIsEmpty(): boolean;
+    evalHas(attrName: string): boolean;
+}
+//# sourceMappingURL=__inputObject.d.ts.map

package/dist/steps/__inputStaticLeaf.d.ts

@@ -0,0 +1,15 @@
+import type { GraphQLLeafType, ValueNode } from "graphql";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedExecutableStep<TLeaf> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private readonly coercedValue;
+    constructor(inputType: GraphQLLeafType, value: ValueNode | undefined);
+    unbatchedExecute(): TLeaf;
+    eval(): TLeaf;
+    evalIs(expectedValue: unknown): boolean;
+}
+//# sourceMappingURL=__inputStaticLeaf.d.ts.map

package/dist/steps/__item.d.ts

@@ -0,0 +1,19 @@
+import type { ExecutableStep } from "../step.js";
+import { $$deepDepSkip, $$noExec, UnbatchedExecutableStep } from "../step.js";
+export declare class __ItemStep<TData> extends UnbatchedExecutableStep<TData> {
+    readonly depth: number;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    [$$noExec]: boolean;
+    transformStepId?: number;
+    constructor(parentPlan: ExecutableStep<TData> | ExecutableStep<TData[]>, depth?: number);
+    toStringMeta(): string;
+    [$$deepDepSkip](): ExecutableStep;
+    execute(): never;
+    unbatchedExecute(): never;
+    finalize(): void;
+}
+//# sourceMappingURL=__item.d.ts.map

package/dist/steps/__trackedObject.d.ts

@@ -0,0 +1,28 @@
+import type { Constraint } from "../constraints.js";
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+import { UnbatchedExecutableStep } from "../step.js";
+import type { __ValueStep } from "./__value.js";
+import type { AccessStep } from "./access.js";
+export declare class __TrackedObjectStep<TData = any> extends UnbatchedExecutableStep<TData> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private readonly value;
+    private readonly constraints;
+    private readonly path;
+    constructor(value: TData | undefined, valuePlan: __ValueStep<TData> | AccessStep<TData>, constraints: Constraint[], path?: Array<string | number>);
+    execute(values: [GrafastValuesList<TData>]): GrafastResultsList<TData>;
+    unbatchedExecute(extra: ExecutionExtra, v: TData): TData;
+    private getValuePlan;
+    get<TAttribute extends keyof TData & string>(attrName: TAttribute): __TrackedObjectStep<TData[TAttribute]>;
+    at<TIndex extends keyof TData & number>(index: TIndex): __TrackedObjectStep<TData[TIndex]>;
+    eval(): TData | undefined;
+    evalIs(expectedValue: unknown): boolean;
+    evalIsEmpty(): boolean;
+    evalHas(key: string): boolean;
+    evalLength(): number | null;
+    optimize(): import("../step.js").ExecutableStep<any>;
+}
+//# sourceMappingURL=__trackedObject.d.ts.map

package/dist/steps/__value.d.ts

@@ -0,0 +1,16 @@
+import { $$noExec, ExecutableStep } from "../step.js";
+import type { AccessStep } from "./access.js";
+export declare class __ValueStep<TData> extends ExecutableStep<TData> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    [$$noExec]: boolean;
+    constructor();
+    toStringMeta(): string | null;
+    execute(): never;
+    get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;
+    at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
+}
+//# sourceMappingURL=__value.d.ts.map