grafast 0.0.1-0.2 → 0.0.1-0.21

package/dist/input.d.ts

@@ -4,7 +4,7 @@ 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 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;

package/dist/interfaces.d.ts

@@ -2,26 +2,29 @@ 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>;
+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>>);
+    context?: Record<string, any> | (<TContext extends Record<string, any>>(ctx: Partial<Grafast.RequestContext>, currentContext?: Partial<TContext>) => PromiseOrValue<Partial<TContext>>);
     explain?: boolean | string[];
 }
 declare global {
-    namespace GraphileConfig {
-        interface GraphQLRequestContext {
+    namespace Grafast {
+        interface RequestContext {
+        }
+        interface Context {
         }
+    }
+    namespace GraphileConfig {
         interface Preset {
             grafast?: GrafastOptions;
         }
         interface GrafastHooks {
             args: PluginHook<(event: {
                 args: ExecutionArgs;
-                ctx: GraphileConfig.GraphQLRequestContext;
+                ctx: Grafast.RequestContext;
                 resolvedPreset: GraphileConfig.ResolvedPreset;
             }) => PromiseOrValue<ExecutionArgs>>;
         }
@@ -50,6 +53,7 @@ export interface GrafastInputFieldExtensions {
 export interface GrafastObjectTypeExtensions {
     Step?: {
         new (...args: any[]): ExecutableStep;
+        displayName?: string;
     };
 }
 export interface GrafastEnumTypeExtensions {
@@ -100,6 +104,7 @@ 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 declare const $$safeError: unique symbol;
 export interface PolymorphicData<TType extends string = string, TData = any> {
     [$$concreteType]: TType;
     [$$data]?: TData;
@@ -107,84 +112,83 @@ export interface PolymorphicData<TType extends string = string, TData = any> {
 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 type GrafastValuesList<T> = ReadonlyArray<T>;
+export type PromiseOrDirect<T> = PromiseLike<T> | T;
+export type GrafastResultsList<T> = ReadonlyArray<PromiseOrDirect<T>>;
+export type GrafastResultStreamList<T> = ReadonlyArray<PromiseOrDirect<AsyncIterable<PromiseOrDirect<T>>> | PromiseLike<never>>;
+export type BaseGraphQLRootValue = any;
 export interface BaseGraphQLVariables {
     [key: string]: unknown;
 }
 export interface BaseGraphQLArguments {
     [key: string]: any;
 }
-export declare type BaseGraphQLInputObject = BaseGraphQLArguments;
+export type BaseGraphQLInputObject = BaseGraphQLArguments;
+export type TargetStepOrCallback = ExecutableStep | ModifierStep | ((indexOrFieldName: number | string) => TargetStepOrCallback);
 export interface FieldArgs {
     get(path?: string | string[]): ExecutableStep;
     getRaw(path?: string | string[]): InputStep;
-    apply($target: ExecutableStep | ModifierStep, path?: string | string[]): void;
+    apply($target: TargetStepOrCallback, 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: {
+export type FieldPlanResolver<_TArgs extends BaseGraphQLArguments, TParentStep extends ExecutableStep<any> | null, TResultStep extends ExecutableStep<any>> = ($parentPlan: TParentStep, args: FieldArgs, info: FieldInfo) => TResultStep | null;
+export 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: {
+export 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: {
+export 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: {
+export 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: {
+export 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: {
+export 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: {
+export 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"> & {
+export type EnumValueApplyPlanResolver<TParentStep extends ExecutableStep | ModifierStep = ExecutableStep | ModifierStep> = ($parent: TParentStep) => ModifierStep | void;
+type OutputPlanForNamedType<TType extends GraphQLType> = TType extends GraphileObjectType<any, infer TStep, any> ? TStep : ExecutableStep<any>;
+export 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>;
+type InputPlanForNamedType<TType extends GraphQLType> = TType extends GraphileInputObjectType<any, infer U, any> ? U : ModifierStep<any>;
+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>;
+type InputTypeForNamedType<TType extends GraphQLType> = TType extends GraphQLScalarType<infer U> ? U : any;
+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 type GraphileFieldConfig<TType extends GraphQLOutputType, TContext extends Grafast.Context, 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>> = {
+export type GraphileFieldConfigArgumentMap<_TType extends GraphQLOutputType, TContext extends Grafast.Context, 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"> & {
+export type GraphileArgumentConfig<TInputType extends GraphQLInputType, _TContext extends Grafast.Context, _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"> & {
+export type GraphileInputFieldConfig<TInputType extends GraphQLInputType, _TContext extends Grafast.Context, _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> = {
+export type TrackedArguments<TArgs extends BaseGraphQLArguments = BaseGraphQLArguments> = {
     get<TKey extends keyof TArgs>(key: TKey): InputStep;
 };
 export interface StepStreamOptions {
@@ -196,18 +200,18 @@ export interface StepOptions {
 export interface StepOptimizeOptions {
     stream: StepStreamOptions | null;
 }
-export declare type GrafastSubscriber<TTopics extends {
+export type GrafastSubscriber<TTopics extends {
     [key: string]: any;
 } = {
     [key: string]: any;
 }> = {
-    subscribe<TTopic extends keyof TTopics = keyof TTopics>(topic: TTopic): AsyncIterableIterator<TTopics[TTopic]>;
+    subscribe<TTopic extends keyof TTopics = keyof TTopics>(topic: TTopic): PromiseOrDirect<AsyncIterableIterator<TTopics[TTopic]>>;
 };
 export interface NodeIdCodec<T = any> {
     encode(value: T): string | null;
     decode(value: string): T;
 }
-export declare type NodeIdHandler<TCodecs extends {
+export type NodeIdHandler<TCodecs extends {
     [key: string]: NodeIdCodec<any>;
 } = {
     [key: string]: NodeIdCodec<any>;
@@ -220,9 +224,9 @@ export declare type NodeIdHandler<TCodecs extends {
     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 type BaseEventMap = Record<string, any>;
+export type EventMapKey<TEventMap extends BaseEventMap> = string & keyof TEventMap;
+export 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;
@@ -231,7 +235,7 @@ export interface TypedEventEmitter<TEventMap extends BaseEventMap> extends Event
     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 = {
+export type ExecutionEventMap = {
     explainOperation: {
         operation: Record<string, any> & {
             type: string;
@@ -239,7 +243,7 @@ export declare type ExecutionEventMap = {
         };
     };
 };
-export declare type ExecutionEventEmitter = TypedEventEmitter<ExecutionEventMap>;
+export type ExecutionEventEmitter = TypedEventEmitter<ExecutionEventMap>;
 export interface ExecutionExtra {
     meta: Record<string, unknown>;
     eventEmitter: ExecutionEventEmitter | undefined;
@@ -251,7 +255,7 @@ export interface LocationDetails {
     parentTypeName: string | null;
     fieldName: string | null;
 }
-export declare type JSONValue = boolean | number | string | null | JSONObject | JSONArray;
+export type JSONValue = boolean | number | string | null | JSONObject | JSONArray;
 export interface JSONObject {
     [key: string]: JSONValue;
 }

package/dist/makeGrafastSchema.d.ts

@@ -1,7 +1,7 @@
 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> | {
+export type FieldPlans = FieldPlanResolver<any, any, any> | {
     plan?: FieldPlanResolver<any, any, any>;
     subscribePlan?: FieldPlanResolver<any, any, any>;
     resolve?: GraphQLFieldResolver<any, any>;
@@ -13,29 +13,29 @@ export declare type FieldPlans = FieldPlanResolver<any, any, any> | {
         };
     };
 };
-export declare type ObjectPlans = {
+export type ObjectPlans = {
     __Step?: {
         new (...args: any[]): ExecutableStep<any>;
     };
 } & {
     [fieldName: string]: FieldPlans;
 };
-export declare type InputObjectPlans = {
+export type InputObjectPlans = {
     [fieldName: string]: {
         input: InputObjectFieldInputPlanResolver;
         apply: InputObjectFieldApplyPlanResolver;
     };
 };
-export declare type InterfaceOrUnionPlans = {
+export type InterfaceOrUnionPlans = {
     __resolveType?: (o: unknown) => string;
 };
-export declare type ScalarPlans = {
+export type ScalarPlans = {
     serialize?: GraphQLScalarSerializer<any>;
     parseValue?: GraphQLScalarValueParser<any>;
     parseLiteral?: GraphQLScalarLiteralParser<any>;
     plan?: ScalarPlanResolver<any, any>;
 };
-export declare type EnumPlans = {
+export type EnumPlans = {
     [enumValueName: string]: EnumValueApplyPlanResolver | string | number | boolean | {
         value?: unknown;
         apply?: EnumValueApplyPlanResolver;
@@ -47,6 +47,6 @@ export interface GrafastPlans {
 export declare function makeGrafastSchema(details: {
     typeDefs: string;
     plans: GrafastPlans;
-    enableDeferStream: boolean;
+    enableDeferStream?: boolean;
 }): GraphQLSchema;
 //# sourceMappingURL=makeGrafastSchema.d.ts.map

package/dist/polymorphic.d.ts

@@ -1,6 +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 polymorphicWrap<TType extends string, TData>(type: TType, data?: TData): PolymorphicData<TType, TData>;
 export declare function resolveType(o: unknown): string;
 //# sourceMappingURL=polymorphic.d.ts.map

package/dist/prepare.d.ts

@@ -2,10 +2,17 @@ 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";
+declare const $$contextPlanCache: unique symbol;
 export interface GrafastPrepareOptions {
     explain?: boolean | string[];
-    asString?: boolean;
+    outputDataAsString?: boolean;
+}
+export declare function executePreemptive(operationPlan: OperationPlan, variableValues: any, context: any, rootValue: any, outputDataAsString: boolean): PromiseOrDirect<ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>>;
+declare module "./engine/OperationPlan.js" {
+    interface OperationPlan {
+        [$$contextPlanCache]?: string;
+    }
 }
-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>>;
+export {};
 //# sourceMappingURL=prepare.d.ts.map

package/dist/step.d.ts

@@ -61,7 +61,7 @@ export declare abstract class UnbatchedExecutableStep<TData = any> extends Execu
 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 {
+export type ObjectLikeStep<TData extends {
     [key: string]: ExecutableStep<any>;
 } = {
     [key: string]: ExecutableStep<any>;
@@ -75,13 +75,13 @@ export declare function isObjectLikeStep<TData extends {
 } = {
     [key: string]: ExecutableStep<any>;
 }>(plan: ExecutableStep): plan is ObjectLikeStep<TData>;
-export declare type StreamableStep<TData> = ExecutableStep<ReadonlyArray<TData>> & {
+export 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 & {
+export type PolymorphicStep = ExecutableStep & {
     planForType(objectType: GraphQLObjectType): ExecutableStep;
 };
 export declare function isPolymorphicStep(s: ExecutableStep): s is PolymorphicStep;

package/dist/steps/connection.d.ts

@@ -2,7 +2,7 @@ import type { InputStep } from "../input.js";
 import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
-declare type ParametersExceptFirst<F> = F extends (arg0: any, ...rest: infer R) => any ? R : never[];
+type ParametersExceptFirst<F> = F extends (arg0: any, ...rest: infer R) => any ? R : never[];
 export interface PageInfoCapableStep extends ExecutableStep<any> {
     hasNextPage(): ExecutableStep<boolean>;
     hasPreviousPage(): ExecutableStep<boolean>;

package/dist/steps/filter.d.ts

@@ -1,6 +1,6 @@
 import type { ExecutableStep, ListCapableStep } from "../step.js";
 import type { __ItemStep } from "./__item.js";
 import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
-export declare type FilterPlanMemo = unknown[];
+export type FilterPlanMemo = unknown[];
 export declare function filter<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<boolean>>(listPlan: TListStep, filterCallback: ListTransformItemPlanCallback<TListStep, TItemStep>): __ListTransformStep<TListStep, TItemStep, FilterPlanMemo, TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>>;
 //# sourceMappingURL=filter.d.ts.map

package/dist/steps/graphqlResolver.d.ts

@@ -1,11 +1,12 @@
 import type { GraphQLFieldResolver, GraphQLNullableType, GraphQLOutputType, GraphQLResolveInfo } from "graphql";
 import type { __ItemStep, ObjectStep } from "../index.js";
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList, PolymorphicData } from "../interfaces.js";
+import type { ExecutionExtra, GrafastResultsList, GrafastResultStreamList, GrafastValuesList } from "../interfaces.js";
 import type { PolymorphicStep } from "../step.js";
 import { ExecutableStep, UnbatchedExecutableStep } from "../step.js";
-declare type ResolveInfoBase = Omit<GraphQLResolveInfo, "path" | "rootValue" | "variableValues">;
+type ResolveInfoBase = Omit<GraphQLResolveInfo, "path" | "rootValue" | "variableValues">;
 export declare class GraphQLResolverStep extends UnbatchedExecutableStep {
     private resolver;
+    private subscriber;
     private resolveInfoBase;
     private returnContextAndResolveInfo;
     static $$export: {
@@ -20,24 +21,17 @@ export declare class GraphQLResolverStep extends UnbatchedExecutableStep {
     private variableValuesDep;
     private rootValueDep;
     private isNotRoot;
-    constructor(resolver: GraphQLFieldResolver<any, any> & {
+    constructor(resolver: (GraphQLFieldResolver<any, any> & {
         displayName?: string;
-    }, $plan: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase, returnContextAndResolveInfo?: boolean);
-    toStringMeta(): string;
+    }) | null | undefined, subscriber: (GraphQLFieldResolver<any, any> & {
+        displayName?: string;
+    }) | null | undefined, $plan: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase, returnContextAndResolveInfo?: boolean);
+    toStringMeta(): string | null;
     deduplicate(peers: GraphQLResolverStep[]): GraphQLResolverStep[];
     unbatchedExecute(extra: ExecutionExtra, source: any, args: any, context: any, variableValues: any, rootValue: any): any;
+    unbatchedStream(extra: ExecutionExtra, source: any, args: any, context: any, variableValues: any, rootValue: any): any;
+    stream(values: ReadonlyArray<GrafastValuesList<any>>, extra: ExecutionExtra): Promise<GrafastResultStreamList<any>>;
 }
-export declare class GraphQLPolymorphicUnwrap extends UnbatchedExecutableStep {
-    static $$export: {
-        moduleName: string;
-        exportName: string;
-    };
-    isSyncAndSafe: boolean;
-    constructor($parent: ExecutableStep);
-    execute(values: [GrafastValuesList<PolymorphicData>]): any[];
-    unbatchedExecute(extra: ExecutionExtra, v: PolymorphicData): any;
-}
-export declare function graphqlPolymorphicUnwrap($parent: ExecutableStep): GraphQLPolymorphicUnwrap;
 export declare class GraphQLItemHandler extends ExecutableStep implements PolymorphicStep {
     static $$export: {
         moduleName: string;
@@ -47,7 +41,7 @@ export declare class GraphQLItemHandler extends ExecutableStep implements Polymo
     private nullableInnerType;
     isSyncAndSafe: boolean;
     constructor($parent: ExecutableStep, nullableType: GraphQLNullableType & GraphQLOutputType);
-    planForType(): GraphQLPolymorphicUnwrap;
+    planForType(): this;
     listItem($item: __ItemStep<any>): GraphQLItemHandler;
     private figureOutTheTypeOf;
     private actuallyWrapData;
@@ -60,6 +54,6 @@ export declare class GraphQLItemHandler extends ExecutableStep implements Polymo
     execute(values: [GrafastValuesList<any>]): GrafastResultsList<any>;
 }
 export declare function graphqlItemHandler($item: ExecutableStep, nullableType: GraphQLNullableType & GraphQLOutputType): GraphQLItemHandler;
-export declare function graphqlResolver(resolver: GraphQLFieldResolver<any, any>, $step: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase): ExecutableStep;
+export declare function graphqlResolver(resolver: GraphQLFieldResolver<any, any> | null | undefined, subscriber: GraphQLFieldResolver<any, any> | null | undefined, $step: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase): ExecutableStep;
 export {};
 //# sourceMappingURL=graphqlResolver.d.ts.map

package/dist/steps/groupBy.d.ts

@@ -1,5 +1,5 @@
 import type { ExecutableStep } from "../step.js";
 import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
-export declare type GroupByPlanMemo = Map<unknown, unknown[]>;
+export type GroupByPlanMemo = Map<unknown, unknown[]>;
 export declare function groupBy<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<number>>(listPlan: TListStep, mapper: ListTransformItemPlanCallback<TListStep, TItemStep>): __ListTransformStep<TListStep, TItemStep, GroupByPlanMemo, any>;
 //# sourceMappingURL=groupBy.d.ts.map

package/dist/steps/index.d.ts

@@ -1,8 +1,7 @@
 import type { OperationPlan } from "../index.js";
-import type { BaseGraphQLContext } from "../interfaces.js";
 import type { __ValueStep } from "./__value.js";
 export declare function operationPlan(): OperationPlan;
-export declare function context<TContext extends BaseGraphQLContext = BaseGraphQLContext>(): __ValueStep<TContext>;
+export declare function context<TContext extends Grafast.Context = Grafast.Context>(): __ValueStep<TContext>;
 export declare function debugPlans<T>(callback: () => T): T;
 export { access, AccessStep } from "./access.js";
 export { connection, ConnectionCapableStep, ConnectionStep, EdgeCapableStep, EdgeStep, PageInfoCapableStep, } from "./connection.js";
@@ -30,7 +29,7 @@ export { __ItemStep } from "./__item.js";
 export { __TrackedObjectStep } from "./__trackedObject.js";
 export { __ValueStep } from "./__value.js";
 export { deepEval, DeepEvalStep } from "./deepEval.js";
-export { GraphQLItemHandler, graphqlItemHandler, GraphQLPolymorphicUnwrap, graphqlPolymorphicUnwrap, graphqlResolver, GraphQLResolverStep, } from "./graphqlResolver.js";
+export { GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, } from "./graphqlResolver.js";
 export { loadMany, LoadManyCallback, loadManyCallback, LoadManyOptions, LoadManySingleRecordStep, LoadManyStep, } from "./loadMany.js";
 export { loadOne, LoadOneCallback, loadOneCallback, LoadOneOptions, LoadOneStep, } from "./loadOne.js";
 export { proxy, ProxyStep } from "./proxy.js";

package/dist/steps/lambda.d.ts

@@ -10,14 +10,14 @@ export declare class LambdaStep<TIn, TOut> extends UnbatchedExecutableStep<TOut>
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     private planDep;
-    constructor($plan: ExecutableStep<TIn> | null | undefined, fn: (value: TIn) => TOut);
+    constructor($plan: ExecutableStep<TIn> | null | undefined, fn: (value: TIn) => PromiseOrDirect<TOut>);
     toStringMeta(): any;
     deduplicate(peers: LambdaStep<any, any>[]): LambdaStep<TIn, TOut>[];
-    unbatchedExecute(extra: ExecutionExtra, value: TIn): PromiseOrDirect<TOut>;
+    unbatchedExecute(_extra: ExecutionExtra, value: TIn): PromiseOrDirect<TOut>;
 }
 declare function lambda<TIn extends [...any[]], TOut>(plans: {
     [Index in keyof TIn]: ExecutableStep<TIn[Index]>;
-}, fn: (value: TIn) => TOut, isSyncAndSafe?: boolean): LambdaStep<TIn, TOut>;
-declare function lambda<TIn, TOut>($plan: ExecutableStep<TIn> | null | undefined, fn: (value: TIn) => TOut, isSyncAndSafe?: boolean): LambdaStep<TIn, TOut>;
+}, fn: (value: TIn) => PromiseOrDirect<TOut>, isSyncAndSafe?: boolean): LambdaStep<TIn, TOut>;
+declare function lambda<TIn, TOut>($plan: ExecutableStep<TIn> | null | undefined, fn: (value: TIn) => PromiseOrDirect<TOut>, isSyncAndSafe?: boolean): LambdaStep<TIn, TOut>;
 export { lambda };
 //# sourceMappingURL=lambda.d.ts.map

package/dist/steps/list.d.ts

@@ -1,7 +1,7 @@
 import type { ExecutionExtra } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
-declare type UnwrapPlanTuple<TPlanTuple extends readonly ExecutableStep<any>[]> = [
+type UnwrapPlanTuple<TPlanTuple extends readonly ExecutableStep<any>[]> = [
     ...(TPlanTuple extends readonly ExecutableStep<infer U>[] ? readonly U[] : never)
 ];
 export declare class ListStep<TPlanTuple extends readonly ExecutableStep<any>[]> extends UnbatchedExecutableStep<UnwrapPlanTuple<TPlanTuple>> {

package/dist/steps/listTransform.d.ts

@@ -5,8 +5,8 @@ import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../i
 import type { ListCapableStep } from "../step.js";
 import { $$deepDepSkip, ExecutableStep } from "../step.js";
 import { __ItemStep } from "./__item.js";
-export declare type ListTransformReduce<TMemo, TItemPlanData> = (memo: TMemo, entireItemValue: unknown, itemPlanData: TItemPlanData) => TMemo;
-export declare type ListTransformItemPlanCallback<TListStep extends ExecutableStep<readonly any[]>, TDepsStep extends ExecutableStep> = (listItemPlan: TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>) => TDepsStep;
+export type ListTransformReduce<TMemo, TItemPlanData> = (memo: TMemo, entireItemValue: unknown, itemPlanData: TItemPlanData) => TMemo;
+export type ListTransformItemPlanCallback<TListStep extends ExecutableStep<readonly any[]>, TDepsStep extends ExecutableStep> = (listItemPlan: TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>) => TDepsStep;
 export interface ListTransformOptions<TListStep extends ExecutableStep<readonly any[]>, TDepsStep extends ExecutableStep, TMemo, TItemStep extends ExecutableStep | undefined = undefined> {
     listPlan: TListStep;
     itemPlanCallback: ListTransformItemPlanCallback<TListStep, TDepsStep>;

package/dist/steps/listen.d.ts

@@ -13,7 +13,7 @@ export declare class ListenStep<TTopics extends {
     isSyncAndSafe: boolean;
     private pubsubDep;
     private topicDep;
-    constructor(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics>> | GrafastSubscriber<TTopics>, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep);
+    constructor(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep);
     execute(): never;
     stream(values: readonly [
         GrafastValuesList<GrafastSubscriber<TTopics>>,
@@ -22,5 +22,5 @@ export declare class ListenStep<TTopics extends {
 }
 export declare function listen<TTopics extends {
     [topic: string]: any;
-}, TTopic extends keyof TTopics, TPayloadStep extends ExecutableStep>(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics>> | GrafastSubscriber<TTopics>, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep): ListenStep<TTopics, TTopic, TPayloadStep>;
+}, TTopic extends keyof TTopics, TPayloadStep extends ExecutableStep>(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep): ListenStep<TTopics, TTopic, TPayloadStep>;
 //# sourceMappingURL=listen.d.ts.map

package/dist/steps/loadMany.d.ts

@@ -1,11 +1,12 @@
 import type { __ItemStep } from "../index.js";
 import type { ExecutionExtra, GrafastResultsList, GrafastValuesList, PromiseOrDirect } from "../interfaces.js";
+import type { ListCapableStep } from "../step.js";
 import { ExecutableStep } from "../step.js";
 export interface LoadManyOptions<TData, TParams extends Record<string, any>> {
     attributes: ReadonlyArray<keyof TData> | null;
     params: Partial<TParams>;
 }
-export declare type LoadManyCallback<TSpec, TData, TParams extends Record<string, any>> = {
+export type LoadManyCallback<TSpec, TData, TParams extends Record<string, any>> = {
     (specs: ReadonlyArray<TSpec>, options: LoadManyOptions<TData, TParams>): PromiseOrDirect<ReadonlyArray<ReadonlyArray<TData>>>;
     displayName?: string;
 };
@@ -24,7 +25,7 @@ export declare class LoadManySingleRecordStep<TData> extends ExecutableStep<TDat
     optimize(): ExecutableStep<any>;
     execute([records]: [GrafastValuesList<TData>]): GrafastResultsList<TData>;
 }
-export declare class LoadManyStep<TSpec, TData, TParams extends Record<string, any>> extends ExecutableStep {
+export declare class LoadManyStep<TSpec, TData, TParams extends Record<string, any>> extends ExecutableStep implements ListCapableStep<TData, LoadManySingleRecordStep<TData>> {
     private load;
     static $$export: {
         moduleName: string;
@@ -36,7 +37,7 @@ export declare class LoadManyStep<TSpec, TData, TParams extends Record<string, a
     params: Partial<TParams>;
     constructor($spec: ExecutableStep<TSpec>, load: LoadManyCallback<TSpec, TData, TParams>);
     toStringMeta(): string;
-    listItem($item: __ItemStep<TData>): LoadManySingleRecordStep<unknown>;
+    listItem($item: __ItemStep<this>): LoadManySingleRecordStep<TData>;
     setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
     addAttributes(attributes: Set<keyof TData>): void;
     finalize(): void;

package/dist/steps/loadOne.d.ts

@@ -4,7 +4,7 @@ export interface LoadOneOptions<TData, TParams extends Record<string, any>> {
     attributes: ReadonlyArray<keyof TData> | null;
     params: Partial<TParams>;
 }
-export declare type LoadOneCallback<TSpec, TData, TParams extends Record<string, any>> = {
+export type LoadOneCallback<TSpec, TData, TParams extends Record<string, any>> = {
     (specs: ReadonlyArray<TSpec>, options: LoadOneOptions<TData, TParams>): PromiseOrDirect<ReadonlyArray<TData>>;
     displayName?: string;
 };

package/dist/steps/map.d.ts

@@ -1,7 +1,7 @@
 import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
-export declare type ActualKeyByDesiredKey = {
+export type ActualKeyByDesiredKey = {
     [desiredKey: string]: string;
 };
 export declare function makeMapper(actualKeyByDesiredKey: ActualKeyByDesiredKey): any;

package/dist/steps/node.d.ts

@@ -5,7 +5,6 @@ import { UnbatchedExecutableStep } from "../step.js";
 export declare class NodeStep<TCodecs extends {
     [key: string]: NodeIdCodec<any>;
 }> extends UnbatchedExecutableStep implements PolymorphicStep {
-    private codecs;
     private possibleTypes;
     static $$export: {
         moduleName: string;

package/dist/steps/object.d.ts

@@ -2,13 +2,13 @@ import type { ExecutionExtra } from "../interfaces.js";
 import type { ExecutableStep } from "../step.js";
 import { UnbatchedExecutableStep } from "../step.js";
 import type { SetterCapableStep } from "./setter.js";
-declare type DataFromStep<TStep extends ExecutableStep<any>> = TStep extends ExecutableStep<infer TData> ? TData : never;
-declare type DataFromPlans<TPlans extends {
+type DataFromStep<TStep extends ExecutableStep<any>> = TStep extends ExecutableStep<infer TData> ? TData : never;
+type DataFromPlans<TPlans extends {
     [key: string]: ExecutableStep<any>;
 }> = {
     [key in keyof TPlans]: DataFromStep<TPlans[key]>;
 };
-declare type Results<TPlans extends {
+type Results<TPlans extends {
     [key: string]: ExecutableStep<any>;
 }> = Array<[
     Array<DataFromPlans<TPlans>[keyof TPlans]>,