grafast 0.0.0 → 0.0.1-0.1

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/stringifyPayload.d.ts

@@ -0,0 +1,3 @@
+import type { JSONObject } from "./interfaces.js";
+export declare function stringifyPayload(payload: JSONObject, asString: boolean | undefined): string;
+//# sourceMappingURL=stringifyPayload.d.ts.map

package/dist/stripAnsi.d.ts

@@ -0,0 +1,3 @@
+export declare const ANSI_REGEXP: RegExp;
+export declare function stripAnsi(str: string): string;
+//# sourceMappingURL=stripAnsi.d.ts.map

package/dist/subscribe.d.ts

@@ -0,0 +1,4 @@
+import type { AsyncExecutionResult, ExecutionArgs, ExecutionResult } from "graphql";
+import type { PromiseOrValue } from "graphql/jsutils/PromiseOrValue";
+export declare function subscribe(args: ExecutionArgs, resolvedPreset?: GraphileConfig.ResolvedPreset, asString?: boolean): PromiseOrValue<AsyncGenerator<ExecutionResult | AsyncExecutionResult, void, void> | ExecutionResult>;
+//# sourceMappingURL=subscribe.d.ts.map

package/dist/utils.d.ts

@@ -0,0 +1,60 @@
+import type { FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema, ValueNode } from "graphql";
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLObjectType } from "graphql";
+import type { Deferred } from "./deferred.js";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { InputStep } from "./input.js";
+import type { BaseGraphQLArguments, BaseGraphQLContext, GraphileFieldConfig, GraphileInputFieldConfig, OutputPlanForType } from "./interfaces.js";
+import type { ExecutableStep, ModifierStep } from "./step.js";
+export declare const ROOT_VALUE_OBJECT: any;
+export declare function assertNullPrototype(object: Record<string, unknown>, description: string): void;
+export declare function defaultValueToValueNode(type: GraphQLInputType, defaultValue: unknown): ValueNode | undefined;
+export declare function isPromise<T>(t: T | Promise<T>): t is Promise<T>;
+export declare function isPromiseLike<T>(t: T | Promise<T> | PromiseLike<T>): t is PromiseLike<T>;
+export declare function isDeferred<T>(t: T | Promise<T> | Deferred<T>): t is Deferred<T>;
+export declare function arraysMatch<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, comparator?: (val1: T, val2: T) => boolean): boolean;
+export declare type ObjectTypeFields<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>> = {
+    [key: string]: GraphileFieldConfig<GraphQLOutputType, TContext, TParentStep, any, any>;
+};
+export declare type ObjectTypeSpec<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>, TFields extends ObjectTypeFields<TContext, TParentStep>> = Omit<GraphQLObjectTypeConfig<any, TContext>, "fields"> & {
+    fields: TFields | (() => TFields);
+};
+export declare function objectSpec<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>, TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>, Step: {
+    new (...args: any[]): TParentStep;
+} | null): GraphQLObjectTypeConfig<any, TContext>;
+export declare type GraphileObjectType<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>, TFields extends ObjectTypeFields<TContext, TParentStep>> = GraphQLObjectType<TParentStep extends ExecutableStep<infer U> ? U : never, TContext> & {
+    TParentStep: TParentStep;
+    TFields: TFields;
+};
+export declare function newObjectTypeBuilder<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>>(Step: {
+    new (...args: any[]): TParentStep;
+}): <TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>) => GraphileObjectType<TContext, TParentStep, TFields>;
+export declare function objectFieldSpec<TContext extends BaseGraphQLContext, TSource extends ExecutableStep<any>, TResult extends ExecutableStep<any> = ExecutableStep<any>, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(graphileSpec: GraphileFieldConfig<GraphQLOutputType, TContext, TSource, TResult, TArgs>): GraphQLFieldConfig<any, TContext, TArgs>;
+export declare function newGraphileFieldConfigBuilder<TContext extends BaseGraphQLContext, TParentStep extends ExecutableStep<any>>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GraphileFieldConfig<TType, TContext, TParentStep, TFieldStep, TArgs>) => typeof config;
+export declare type GraphileInputFieldConfigMap<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>> = {
+    [key: string]: GraphileInputFieldConfig<GraphQLInputType, TContext, TParentStep, any, any>;
+};
+export declare type InputObjectTypeSpec<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>, TFields extends GraphileInputFieldConfigMap<TContext, TParentStep>> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
+    fields: TFields | (() => TFields);
+};
+export declare type GraphileInputObjectType<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>, TFields extends GraphileInputFieldConfigMap<TContext, TParentStep>> = GraphQLInputObjectType & {
+    TContext: TContext;
+    TParentStep: TParentStep;
+    TFields: TFields;
+};
+export declare function newInputObjectTypeBuilder<TContext extends BaseGraphQLContext, TParentStep extends ModifierStep<any>>(): <TFields extends GraphileInputFieldConfigMap<TContext, TParentStep>>(spec: InputObjectTypeSpec<TContext, TParentStep, TFields>) => GraphileInputObjectType<TContext, TParentStep, TFields>;
+export declare function inputObjectFieldSpec<TContext extends BaseGraphQLContext, TParent extends ModifierStep<any>, TResult extends ModifierStep<TParent> = ModifierStep<TParent>, TInput extends InputStep = InputStep>(graphileSpec: GraphileInputFieldConfig<GraphQLInputType, TContext, TParent, TResult, TInput>): GraphQLInputFieldConfig;
+export declare function getEnumValueConfig(enumType: GraphQLEnumType, outputValue: unknown): GraphQLEnumValueConfig | undefined;
+export declare const sharedNull: any;
+export declare function stack(message: string, length?: number): void;
+export declare function arrayOfLength(length: number, fill?: any): any[];
+export declare function arrayOfLengthCb(length: number, fill: () => any): any[];
+export declare function findVariableNamesUsed(operationPlan: OperationPlan, field: FieldNode): string[];
+export declare function isTypePlanned(schema: GraphQLSchema, namedType: GraphQLNamedType): boolean;
+export declare function stepADependsOnStepB(stepA: ExecutableStep, stepB: ExecutableStep): boolean;
+export declare function stepAMayDependOnStepB($a: ExecutableStep, $b: ExecutableStep): boolean;
+export declare function stepsAreInSamePhase(ancestor: ExecutableStep, descendent: ExecutableStep): boolean;
+export declare const canonicalJSONStringify: (o: object) => string;
+export declare const isSafeObjectPropertyName: (key: string) => boolean;
+export declare const canRepresentAsIdentifier: (key: string) => boolean;
+export declare const evalSafeProperty: (key: string) => string;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,14 +1,65 @@
 {
   "name": "grafast",
-  "version": "0.0.0",
-  "description": "Coming 2023!",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.0.1-0.1",
+  "description": "Cutting edge GraphQL planning and execution engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "node": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./envelop": {
+      "types": "./dist/envelop.d.ts",
+      "node": "./dist/envelop.js",
+      "default": "./dist/envelop.js"
+    }
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/graphile/heart.git"
+  },
+  "keywords": [
+    "grafast",
+    "graphile",
+    "graphql",
+    "performance",
+    "fast",
+    "engine",
+    "graphqljs",
+    "execute",
+    "plan",
+    "planning",
+    "grafast",
+    "dataplanner",
+    "graphite"
+  ],
   "author": "Benjie Gillam <code@benjiegillam.com>",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "bugs": {
+    "url": "https://github.com/graphile/heart/issues"
+  },
+  "homepage": "https://grafast.org",
+  "engines": {
+    "node": ">=14.17"
+  },
+  "dependencies": {
+    "@graphile/lru": "^5.0.0-0.1"
+  },
+  "peerDependencies": {
+    "graphile-config": "^0.0.1-0.0",
+    "graphql": "*"
+  },
+  "peerDependenciesMeta": {
+    "graphile-config": {
+      "optional": true
+    }
+  },
   "files": [
-    "index.js"
-  ]
-}
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-console.log('Grafast is coming soon!')