grafast 0.0.0 → 0.0.1-0.2

package/dist/steps/access.d.ts

@@ -0,0 +1,24 @@
+import type { ExecutionExtra } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare const expressionSymbol: unique symbol;
+export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
+    readonly fallback?: any;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    readonly path: (string | number | symbol)[];
+    constructor(parentPlan: ExecutableStep<unknown>, path: (string | number | symbol)[], fallback?: any);
+    toStringMeta(): string;
+    get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;
+    at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
+    optimize(): AccessStep<TData>;
+    finalize(): void;
+    unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
+    deduplicate(peers: AccessStep<unknown>[]): AccessStep<TData>[];
+}
+export declare function access<TData>(parentPlan: ExecutableStep<unknown>, path: (string | number | symbol)[] | string | number | symbol, fallback?: any): AccessStep<TData>;
+//# sourceMappingURL=access.d.ts.map

package/dist/steps/connection.d.ts

@@ -0,0 +1,84 @@
+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[];
+export interface PageInfoCapableStep extends ExecutableStep<any> {
+    hasNextPage(): ExecutableStep<boolean>;
+    hasPreviousPage(): ExecutableStep<boolean>;
+    startCursor(): ExecutableStep<string | null>;
+    endCursor(): ExecutableStep<string | null>;
+}
+export interface ConnectionCapableStep<TItemStep extends ExecutableStep<any>, TCursorStep extends ExecutableStep<any>> extends ExecutableStep<ReadonlyArray<TItemStep extends ExecutableStep<infer U> ? U : any>> {
+    connectionClone($connection: ConnectionStep<TItemStep, TCursorStep, any, any>, ...args: any[]): ConnectionCapableStep<TItemStep, TCursorStep>;
+    pageInfo($connection: ConnectionStep<TItemStep, TCursorStep, ConnectionCapableStep<TItemStep, TCursorStep>, any>): PageInfoCapableStep;
+    setFirst($plan: InputStep): void;
+    setLast($plan: InputStep): void;
+    setOffset($plan: InputStep): void;
+    parseCursor($plan: InputStep): TCursorStep | null | undefined;
+    setBefore($plan: TCursorStep): void;
+    setAfter($plan: TCursorStep): void;
+}
+export declare class ConnectionStep<TItemStep extends ExecutableStep<any>, TCursorStep extends ExecutableStep<any>, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep<any> = ExecutableStep<any>> extends UnbatchedExecutableStep<unknown> {
+    readonly itemPlan?: (($item: TItemStep) => TNodeStep) | undefined;
+    readonly cursorPlan?: (($item: TItemStep) => ExecutableStep<string | null> | undefined) | undefined;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private subplanId;
+    private _firstDepId;
+    private _lastDepId;
+    private _offsetDepId;
+    private _beforeDepId;
+    private _afterDepId;
+    constructor(subplan: TStep, itemPlan?: (($item: TItemStep) => TNodeStep) | undefined, cursorPlan?: (($item: TItemStep) => ExecutableStep<string | null> | undefined) | undefined);
+    toStringMeta(): string;
+    getFirst(): InputStep | null;
+    setFirst($firstPlan: InputStep): void;
+    getLast(): InputStep | null;
+    setLast($lastPlan: InputStep): void;
+    getOffset(): InputStep | null;
+    setOffset($offsetPlan: InputStep): void;
+    getBefore(): TCursorStep | null;
+    setBefore($beforePlan: InputStep): void;
+    getAfter(): TCursorStep | null;
+    setAfter($afterPlan: InputStep): void;
+    getSubplan(): TStep;
+    cloneSubplanWithoutPagination(...args: ParametersExceptFirst<TStep["connectionClone"]>): TStep;
+    cloneSubplanWithPagination(...args: ParametersExceptFirst<TStep["connectionClone"]> | []): TStep;
+    edges(): TStep | import("./listTransform.js").__ListTransformStep<any, any, any, any>;
+    nodes(): TStep | import("./listTransform.js").__ListTransformStep<any, any, any, any>;
+    wrapEdge($edge: TItemStep): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
+    pageInfo(): PageInfoCapableStep;
+    execute(values: Array<GrafastValuesList<any>>): GrafastResultsList<Record<string, never>>;
+    unbatchedExecute(): any;
+}
+export interface EdgeCapableStep<TNodeStep extends ExecutableStep<any>> extends ExecutableStep<any> {
+    node(): TNodeStep;
+    cursor(): ExecutableStep<string | null>;
+}
+export declare class EdgeStep<TItemStep extends ExecutableStep<any>, TCursorStep extends ExecutableStep<any>, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep<any> = ExecutableStep<any>> extends UnbatchedExecutableStep implements EdgeCapableStep<TNodeStep> {
+    private skipCursor;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private connectionDepId;
+    private readonly cursorDepId;
+    private needCursor;
+    constructor($connection: ConnectionStep<TItemStep, TCursorStep, TStep, TNodeStep>, $item: TItemStep, skipCursor?: boolean);
+    private getConnectionStep;
+    private getItemStep;
+    node(): TNodeStep;
+    cursor(): ExecutableStep<string | null>;
+    optimize(): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
+    deduplicate(_peers: EdgeStep<any, any, any, any>[]): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>[];
+    deduplicatedWith(replacement: EdgeStep<any, any, any, any>): void;
+    unbatchedExecute(extra: ExecutionExtra, record: any, cursor: any): any;
+}
+export declare function connection<TItemStep extends ExecutableStep<any>, TCursorStep extends ExecutableStep<any>, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep<any> = ExecutableStep<any>>(step: TStep, itemPlan?: ($item: TItemStep) => TNodeStep, cursorPlan?: ($item: TItemStep) => ExecutableStep<string | null>): ConnectionStep<TItemStep, TCursorStep, TStep, TNodeStep>;
+export {};
+//# sourceMappingURL=connection.d.ts.map

package/dist/steps/constant.d.ts

@@ -0,0 +1,20 @@
+import type { GrafastResultsList } from "../interfaces.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData> {
+    private data;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    constructor(data: TData);
+    execute(values: [[undefined]]): GrafastResultsList<TData>;
+    eval(): TData;
+    evalIs(value: any): boolean;
+    evalIsEmpty(): boolean;
+    unbatchedExecute(): TData;
+    isNull(): boolean;
+}
+export declare function constant(strings: TemplateStringsArray & [string]): ConstantStep<string>;
+export declare function constant<TData>(data: TData): ConstantStep<TData>;
+//# sourceMappingURL=constant.d.ts.map

package/dist/steps/deepEval.d.ts

@@ -0,0 +1,19 @@
+import type { LayerPlanReasonSubroutine } from "../engine/LayerPlan.js";
+import { LayerPlan } from "../engine/LayerPlan.js";
+import type { GrafastError } from "../error.js";
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+import type { ListCapableStep } from "../step.js";
+import { ExecutableStep } from "../step.js";
+export declare class DeepEvalStep extends ExecutableStep {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    itemStepId: number;
+    subroutineLayer: LayerPlan<LayerPlanReasonSubroutine>;
+    constructor(listPlan: ListCapableStep<any, any>);
+    execute(values: [GrafastValuesList<any[] | null | undefined | GrafastError>], extra: ExecutionExtra): Promise<GrafastResultsList<any[]>>;
+}
+export declare function deepEval($step: ExecutableStep): ExecutableStep<any>;
+//# sourceMappingURL=deepEval.d.ts.map

package/dist/steps/each.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutableStep, ListCapableStep } from "../step.js";
+import { __ItemStep } from "./__item.js";
+import type { __ListTransformStep } from "./listTransform.js";
+export declare function each<TListStep extends ExecutableStep<readonly any[]>, TResultItemStep extends ExecutableStep<any>>(listPlan: TListStep, mapper: (itemPlan: TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>) => TResultItemStep): __ListTransformStep<any, any, any, any>;
+//# sourceMappingURL=each.d.ts.map

package/dist/steps/error.d.ts

@@ -0,0 +1,15 @@
+import type { GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class ErrorStep<TError extends Error> extends UnbatchedExecutableStep<never> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    error: TError;
+    constructor(error: TError);
+    execute(values: GrafastValuesList<any>): GrafastResultsList<any>;
+    unbatchedExecute(): any;
+}
+export declare function error<TError extends Error>(error: TError): ErrorStep<TError>;
+//# sourceMappingURL=error.d.ts.map

package/dist/steps/filter.d.ts

@@ -0,0 +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 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/first.d.ts

@@ -0,0 +1,18 @@
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class FirstStep<TData> extends UnbatchedExecutableStep<TData> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    constructor(parentPlan: ExecutableStep<ReadonlyArray<TData>>);
+    execute(values: GrafastValuesList<[ReadonlyArray<TData>]>): GrafastResultsList<TData>;
+    unbatchedExecute(extra: ExecutionExtra, list: any[]): any;
+    deduplicate(peers: FirstStep<TData>[]): FirstStep<TData>[];
+    optimize(): ExecutableStep<any> | this;
+}
+export declare function first<TData>(plan: ExecutableStep<ReadonlyArray<TData>>): FirstStep<TData>;
+//# sourceMappingURL=first.d.ts.map

package/dist/steps/graphqlResolver.d.ts

@@ -0,0 +1,65 @@
+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 { PolymorphicStep } from "../step.js";
+import { ExecutableStep, UnbatchedExecutableStep } from "../step.js";
+declare type ResolveInfoBase = Omit<GraphQLResolveInfo, "path" | "rootValue" | "variableValues">;
+export declare class GraphQLResolverStep extends UnbatchedExecutableStep {
+    private resolver;
+    private resolveInfoBase;
+    private returnContextAndResolveInfo;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    private planDep;
+    private argsDep;
+    private contextDep;
+    private variableValuesDep;
+    private rootValueDep;
+    private isNotRoot;
+    constructor(resolver: GraphQLFieldResolver<any, any> & {
+        displayName?: string;
+    }, $plan: ExecutableStep, $args: ObjectStep, resolveInfoBase: ResolveInfoBase, returnContextAndResolveInfo?: boolean);
+    toStringMeta(): string;
+    deduplicate(peers: GraphQLResolverStep[]): GraphQLResolverStep[];
+    unbatchedExecute(extra: ExecutionExtra, source: any, args: any, context: any, variableValues: any, rootValue: any): 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;
+        exportName: string;
+    };
+    private abstractType?;
+    private nullableInnerType;
+    isSyncAndSafe: boolean;
+    constructor($parent: ExecutableStep, nullableType: GraphQLNullableType & GraphQLOutputType);
+    planForType(): GraphQLPolymorphicUnwrap;
+    listItem($item: __ItemStep<any>): GraphQLItemHandler;
+    private figureOutTheTypeOf;
+    private actuallyWrapData;
+    private polymorphicWrapData;
+    wrapListData(data: unknown, context: unknown, resolveInfo: GraphQLResolveInfo): ({
+        data: {};
+        context: unknown;
+        resolveInfo: GraphQLResolveInfo;
+    } | null | undefined)[] | null;
+    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 {};
+//# sourceMappingURL=graphqlResolver.d.ts.map

package/dist/steps/groupBy.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutableStep } from "../step.js";
+import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
+export declare 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

@@ -0,0 +1,37 @@
+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 debugPlans<T>(callback: () => T): T;
+export { access, AccessStep } from "./access.js";
+export { connection, ConnectionCapableStep, ConnectionStep, EdgeCapableStep, EdgeStep, PageInfoCapableStep, } from "./connection.js";
+export { constant, ConstantStep } from "./constant.js";
+export { each } from "./each.js";
+export { error, ErrorStep } from "./error.js";
+export { filter, FilterPlanMemo } from "./filter.js";
+export { first, FirstStep } from "./first.js";
+export { groupBy, GroupByPlanMemo } from "./groupBy.js";
+export { lambda, LambdaStep } from "./lambda.js";
+export { last, LastStep } from "./last.js";
+export { list, ListStep } from "./list.js";
+export { listen, ListenStep } from "./listen.js";
+export { __ListTransformStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, } from "./listTransform.js";
+export { ActualKeyByDesiredKey, makeMapper, map, MapStep } from "./map.js";
+export { node, NodeStep, specFromNodeId } from "./node.js";
+export { object, ObjectPlanMeta, ObjectStep } from "./object.js";
+export { partitionByIndex } from "./partitionByIndex.js";
+export { reverse, reverseArray, ReverseStep } from "./reverse.js";
+export { setter, SetterCapableStep, SetterStep } from "./setter.js";
+export { __InputListStep } from "./__inputList.js";
+export { __InputObjectStep } from "./__inputObject.js";
+export { __InputStaticLeafStep } from "./__inputStaticLeaf.js";
+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 { loadMany, LoadManyCallback, loadManyCallback, LoadManyOptions, LoadManySingleRecordStep, LoadManyStep, } from "./loadMany.js";
+export { loadOne, LoadOneCallback, loadOneCallback, LoadOneOptions, LoadOneStep, } from "./loadOne.js";
+export { proxy, ProxyStep } from "./proxy.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/steps/lambda.d.ts

@@ -0,0 +1,23 @@
+import type { ExecutionExtra, PromiseOrDirect } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class LambdaStep<TIn, TOut> extends UnbatchedExecutableStep<TOut> {
+    private fn;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    private planDep;
+    constructor($plan: ExecutableStep<TIn> | null | undefined, fn: (value: TIn) => TOut);
+    toStringMeta(): any;
+    deduplicate(peers: LambdaStep<any, any>[]): LambdaStep<TIn, 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>;
+export { lambda };
+//# sourceMappingURL=lambda.d.ts.map

package/dist/steps/last.d.ts

@@ -0,0 +1,17 @@
+import type { ExecutionExtra } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare class LastStep<TData> extends UnbatchedExecutableStep<TData> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    constructor(parentPlan: ExecutableStep<ReadonlyArray<TData>>);
+    unbatchedExecute: (extra: ExecutionExtra, list: ReadonlyArray<TData>) => TData;
+    deduplicate(peers: LastStep<TData>[]): LastStep<TData>[];
+    optimize(): ExecutableStep<any> | this;
+}
+export declare function last<TData>(plan: ExecutableStep<ReadonlyArray<TData>>): LastStep<TData>;
+//# sourceMappingURL=last.d.ts.map

package/dist/steps/list.d.ts

@@ -0,0 +1,24 @@
+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>[]> = [
+    ...(TPlanTuple extends readonly ExecutableStep<infer U>[] ? readonly U[] : never)
+];
+export declare class ListStep<TPlanTuple extends readonly ExecutableStep<any>[]> extends UnbatchedExecutableStep<UnwrapPlanTuple<TPlanTuple>> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    constructor(list: readonly [...TPlanTuple]);
+    toStringMeta(): string;
+    tupleToTuple(results: Array<UnwrapPlanTuple<TPlanTuple>>, tuple: UnwrapPlanTuple<TPlanTuple>): UnwrapPlanTuple<TPlanTuple>;
+    execute(values: any[][]): Array<UnwrapPlanTuple<TPlanTuple>>;
+    unbatchedExecute(extra: ExecutionExtra, ...values: any[]): UnwrapPlanTuple<TPlanTuple>;
+    deduplicate(peers: ListStep<TPlanTuple>[]): ListStep<TPlanTuple>[];
+    at<TIndex extends keyof TPlanTuple>(index: TIndex): TPlanTuple[TIndex];
+}
+export declare function list<TPlanTuple extends ExecutableStep<any>[]>(list: TPlanTuple): ListStep<TPlanTuple>;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/dist/steps/listTransform.d.ts

@@ -0,0 +1,45 @@
+import type { LayerPlanReasonSubroutine } from "../engine/LayerPlan.js";
+import { LayerPlan } from "../engine/LayerPlan.js";
+import type { GrafastError } from "../error.js";
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+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 interface ListTransformOptions<TListStep extends ExecutableStep<readonly any[]>, TDepsStep extends ExecutableStep, TMemo, TItemStep extends ExecutableStep | undefined = undefined> {
+    listPlan: TListStep;
+    itemPlanCallback: ListTransformItemPlanCallback<TListStep, TDepsStep>;
+    initialState(): TMemo;
+    reduceCallback: ListTransformReduce<TMemo, TDepsStep extends ExecutableStep<infer U> ? U : never>;
+    listItem?(itemPlan: ExecutableStep<any>): TItemStep;
+    finalizeCallback?(data: TMemo): TMemo;
+    meta?: string;
+    optimize?: (this: __ListTransformStep<TListStep, TDepsStep, TMemo, TItemStep>) => ExecutableStep;
+}
+export declare class __ListTransformStep<TListStep extends ExecutableStep<readonly any[]>, TDepsStep extends ExecutableStep, TMemo, TItemStep extends ExecutableStep | undefined = undefined> extends ExecutableStep<TMemo> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private listPlanDepId;
+    itemPlanCallback: ListTransformItemPlanCallback<TListStep, TDepsStep>;
+    initialState: () => TMemo;
+    reduceCallback: ListTransformReduce<TMemo, TDepsStep extends ExecutableStep<infer U> ? U : never>;
+    finalizeCallback?: (data: TMemo) => TMemo;
+    listItem?: (itemPlan: __ItemStep<this>) => TItemStep;
+    private meta;
+    itemStepId: number;
+    subroutineLayer: LayerPlan<LayerPlanReasonSubroutine>;
+    constructor(options: ListTransformOptions<TListStep, TDepsStep, TMemo, TItemStep>);
+    toStringMeta(): string | null;
+    getListStep(): TListStep;
+    [$$deepDepSkip](): TListStep;
+    dangerouslyGetListPlan(): TListStep;
+    deduplicate(peers: __ListTransformStep<any, any, any, any>[]): __ListTransformStep<TListStep, TDepsStep, TMemo, TItemStep>[];
+    optimize(): ExecutableStep;
+    execute(values: [GrafastValuesList<any[] | null | undefined | GrafastError>], extra: ExecutionExtra): Promise<GrafastResultsList<TMemo>>;
+}
+export declare function listTransform<TListStep extends ExecutableStep<readonly any[]>, TDepsStep extends ExecutableStep, TMemo, TItemStep extends ExecutableStep | undefined = undefined>(options: ListTransformOptions<TListStep, TDepsStep, TMemo, TItemStep>): __ListTransformStep<TListStep, TDepsStep, TMemo, TItemStep>;
+//# sourceMappingURL=listTransform.d.ts.map

package/dist/steps/listen.d.ts

@@ -0,0 +1,26 @@
+import type { GrafastResultStreamList, GrafastSubscriber, GrafastValuesList } from "../interfaces.js";
+import type { StreamableStep } from "../step.js";
+import { ExecutableStep } from "../step.js";
+import type { __ItemStep } from "./__item.js";
+export declare class ListenStep<TTopics extends {
+    [topic: string]: any;
+}, TTopic extends keyof TTopics, TPayloadStep extends ExecutableStep> extends ExecutableStep<TTopics[TTopic]> implements StreamableStep<TTopics[TTopic]> {
+    itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private pubsubDep;
+    private topicDep;
+    constructor(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics>> | GrafastSubscriber<TTopics>, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep);
+    execute(): never;
+    stream(values: readonly [
+        GrafastValuesList<GrafastSubscriber<TTopics>>,
+        GrafastValuesList<TTopic>
+    ]): GrafastResultStreamList<TTopics[TTopic]>;
+}
+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>;
+//# sourceMappingURL=listen.d.ts.map

package/dist/steps/loadMany.d.ts

@@ -0,0 +1,46 @@
+import type { __ItemStep } from "../index.js";
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList, PromiseOrDirect } from "../interfaces.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>> = {
+    (specs: ReadonlyArray<TSpec>, options: LoadManyOptions<TData, TParams>): PromiseOrDirect<ReadonlyArray<ReadonlyArray<TData>>>;
+    displayName?: string;
+};
+export declare function loadManyCallback<TSpec, TData, TParams extends Record<string, any>>(callback: LoadManyCallback<TSpec, TData, TParams>): LoadManyCallback<TSpec, TData, TParams>;
+export declare class LoadManySingleRecordStep<TData> extends ExecutableStep<TData> {
+    private sourceDescription?;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    attributes: Set<keyof TData>;
+    constructor($data: ExecutableStep<TData>, sourceDescription?: string | undefined);
+    toStringMeta(): string | null;
+    get(attr: keyof TData & (string | number)): import("./access.js").AccessStep<unknown>;
+    optimize(): ExecutableStep<any>;
+    execute([records]: [GrafastValuesList<TData>]): GrafastResultsList<TData>;
+}
+export declare class LoadManyStep<TSpec, TData, TParams extends Record<string, any>> extends ExecutableStep {
+    private load;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    loadOptions: LoadManyOptions<TData, TParams> | null;
+    loadOptionsKey: string;
+    attributes: Set<keyof TData>;
+    params: Partial<TParams>;
+    constructor($spec: ExecutableStep<TSpec>, load: LoadManyCallback<TSpec, TData, TParams>);
+    toStringMeta(): string;
+    listItem($item: __ItemStep<TData>): LoadManySingleRecordStep<unknown>;
+    setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
+    addAttributes(attributes: Set<keyof TData>): void;
+    finalize(): void;
+    execute([specs]: [GrafastValuesList<TSpec>], extra: ExecutionExtra): PromiseOrDirect<GrafastResultsList<ReadonlyArray<TData>>>;
+}
+export declare function loadMany<TSpec, TData, TParams extends Record<string, any>>($spec: ExecutableStep<TSpec>, load: LoadManyCallback<TSpec, TData, TParams>): LoadManyStep<TSpec, TData, TParams>;
+//# sourceMappingURL=loadMany.d.ts.map

package/dist/steps/loadOne.d.ts

@@ -0,0 +1,30 @@
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList, PromiseOrDirect } from "../interfaces.js";
+import { ExecutableStep } from "../step.js";
+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>> = {
+    (specs: ReadonlyArray<TSpec>, options: LoadOneOptions<TData, TParams>): PromiseOrDirect<ReadonlyArray<TData>>;
+    displayName?: string;
+};
+export declare function loadOneCallback<TSpec, TData, TParams extends Record<string, any>>(callback: LoadOneCallback<TSpec, TData, TParams>): LoadOneCallback<TSpec, TData, TParams>;
+export declare class LoadOneStep<TSpec, TData, TParams extends Record<string, any>> extends ExecutableStep {
+    private load;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    loadOptions: LoadOneOptions<TData, TParams> | null;
+    loadOptionsKey: string;
+    attributes: Set<keyof TData>;
+    params: Partial<TParams>;
+    constructor($spec: ExecutableStep<TSpec>, load: LoadOneCallback<TSpec, TData, TParams>);
+    toStringMeta(): string;
+    get(attr: keyof TData & (string | number)): import("./access.js").AccessStep<unknown>;
+    setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
+    finalize(): void;
+    execute([specs]: [GrafastValuesList<TSpec>], extra: ExecutionExtra): PromiseOrDirect<GrafastResultsList<TData>>;
+}
+export declare function loadOne<TSpec, TData, TParams extends Record<string, any>>($spec: ExecutableStep<TSpec>, load: LoadOneCallback<TSpec, TData, TParams>): LoadOneStep<TSpec, TData, TParams>;
+//# sourceMappingURL=loadOne.d.ts.map

package/dist/steps/map.d.ts

@@ -0,0 +1,26 @@
+import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
+import type { ExecutableStep } from "../step.js";
+import { UnbatchedExecutableStep } from "../step.js";
+export declare type ActualKeyByDesiredKey = {
+    [desiredKey: string]: string;
+};
+export declare function makeMapper(actualKeyByDesiredKey: ActualKeyByDesiredKey): any;
+export declare class MapStep extends UnbatchedExecutableStep {
+    private actualKeyByDesiredKey;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    private mapper;
+    constructor($plan: ExecutableStep, actualKeyByDesiredKey: ActualKeyByDesiredKey);
+    toStringMeta(): string;
+    execute(values: GrafastValuesList<any[]>): GrafastResultsList<any>;
+    unbatchedExecute(extra: ExecutionExtra, value: any): any;
+    deduplicate(peers: MapStep[]): MapStep[];
+}
+export declare function map($step: ExecutableStep, actualKeyByDesiredKey: {
+    [desiredKey: string]: string;
+}): MapStep;
+//# sourceMappingURL=map.d.ts.map

package/dist/steps/node.d.ts

@@ -0,0 +1,30 @@
+import type { GraphQLObjectType } from "graphql";
+import type { ExecutionExtra, NodeIdCodec, NodeIdHandler, PolymorphicData } from "../interfaces.js";
+import type { ExecutableStep, PolymorphicStep } from "../step.js";
+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;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    private specPlanDep;
+    constructor(codecs: TCodecs, possibleTypes: {
+        [typeName: string]: NodeIdHandler<TCodecs>;
+    }, $id: ExecutableStep<string>);
+    planForType(type: GraphQLObjectType): ExecutableStep;
+    private getTypeNameFromSpecifier;
+    unbatchedExecute: (extra: ExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
+}
+export declare function node<TCodecs extends {
+    [key: string]: NodeIdCodec<any>;
+}>(codecs: TCodecs, possibleTypes: {
+    [typeName: string]: NodeIdHandler<TCodecs>;
+}, $id: ExecutableStep<string>): NodeStep<TCodecs>;
+export declare function specFromNodeId(codec: NodeIdCodec<any>, handler: NodeIdHandler<any>, $id: ExecutableStep<string>): any;
+//# sourceMappingURL=node.d.ts.map

package/dist/steps/object.d.ts

@@ -0,0 +1,49 @@
+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 {
+    [key: string]: ExecutableStep<any>;
+}> = {
+    [key in keyof TPlans]: DataFromStep<TPlans[key]>;
+};
+declare type Results<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+}> = Array<[
+    Array<DataFromPlans<TPlans>[keyof TPlans]>,
+    DataFromPlans<TPlans>
+]>;
+export interface ObjectPlanMeta<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+}> {
+    results: Results<TPlans>;
+}
+export declare class ObjectStep<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+} = {
+    [key: string]: ExecutableStep<any>;
+}> extends UnbatchedExecutableStep<DataFromPlans<TPlans>> implements SetterCapableStep<TPlans> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    private keys;
+    constructor(obj: TPlans);
+    set<TKey extends keyof TPlans>(key: TKey, plan: TPlans[TKey]): void;
+    getStepForKey<TKey extends keyof TPlans>(key: TKey, allowMissing?: boolean): TKey extends keyof TPlans ? TPlans[TKey] : null;
+    toStringMeta(): string;
+    tupleToObjectJIT(): (extra: ExecutionExtra, ...tuple: Array<DataFromPlans<TPlans>[keyof TPlans]>) => DataFromPlans<TPlans>;
+    finalize(): void;
+    execute(values: Array<Array<DataFromPlans<TPlans>[keyof TPlans]>>, extra: ExecutionExtra): Array<DataFromPlans<TPlans>>;
+    unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
+    deduplicate(peers: ObjectStep<any>[]): ObjectStep<TPlans>[];
+    get<TKey extends keyof TPlans>(key: TKey): TPlans[TKey];
+}
+export declare function object<TPlans extends {
+    [key: string]: ExecutableStep<any>;
+}>(obj: TPlans): ObjectStep<TPlans>;
+export {};
+//# sourceMappingURL=object.d.ts.map