grafast 0.0.0 → 0.0.1-0.2

package/dist/engine/OutputPlan.d.ts

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

package/dist/engine/StepTracker.d.ts

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

package/dist/engine/executeBucket.d.ts

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

package/dist/engine/executeOutputPlan.d.ts

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

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

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

package/dist/envelop.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin as EnvelopPlugin } from "@envelop/core";
+export interface UseGrafastOptions {
+    explainAllowed?: boolean | string[];
+}
+export declare const useGrafast: (options?: UseGrafastOptions) => EnvelopPlugin;
+export declare const useMoreDetailedErrors: () => EnvelopPlugin;
+//# sourceMappingURL=envelop.d.ts.map

package/dist/envelop.js

@@ -0,0 +1 @@
+"use strict";!function(e,s){"object"==typeof exports&&"object"==typeof module?module.exports=s():"function"==typeof define&&define.amd?define([],s):"object"==typeof exports?exports.grafast=s():e.grafast=s()}(this,(()=>(this.webpackChunkgrafast=this.webpackChunkgrafast||[]).push([[764],{3837:(e,s,r)=>{Object.defineProperty(s,"__esModule",{value:!0}),s.useMoreDetailedErrors=s.useGrafast=void 0;const t=r(6587),n=r(6522),a=r(680);function o(e,s){if(!1===e||Array.isArray(e)&&0===e.length)return;const r=Array.isArray(s)?s.join(","):s;if(!r)return;const t=r.split(",");return!0===e||void 0===e?t:e.filter((e=>t.includes(e)))}s.useGrafast=(e={})=>{const{explainAllowed:s=!0}=e;return{async onExecute(e){const r=e.args.contextValue?.req?.headers["x-graphql-explain"],n=o(s,r);e.setExecuteFn((e=>(0,t.execute)(e,{grafast:{explain:n}})))},async onSubscribe(e){const r=e.args.contextValue,t=(r?.req?.headers||r?.request?.headers||r?.connectionParams)?.["x-graphql-explain"],n=o(s,t);e.setSubscribeFn((async e=>(0,a.subscribe)(e,{grafast:{explain:n}})))}}},s.useMoreDetailedErrors=()=>({onExecute:()=>({onExecuteDone({result:e}){"errors"in e&&e.errors&&(e.errors=e.errors.map((e=>{const s=e.toJSON();return Object.assign(s,{message:(0,n.stripAnsi)(s.message),extensions:{stack:(0,n.stripAnsi)(e.stack??"").split("\n")}})})))}})})}},e=>(3837,e(e.s=3837))])));

package/dist/error.d.ts

@@ -0,0 +1,13 @@
+export interface GrafastError extends Error {
+    originalError: Error;
+}
+export declare const $$error: unique symbol;
+export declare class _GrafastError extends Error implements GrafastError {
+    readonly originalError: Error;
+    extensions: Record<string, any>;
+    [$$error]: boolean;
+    constructor(originalError: Error, planId: number | null);
+}
+export declare function newGrafastError(error: Error, planId: number | null): _GrafastError;
+export declare function isGrafastError(value: any): value is GrafastError;
+//# sourceMappingURL=error.d.ts.map

package/dist/establishOperationPlan.d.ts

@@ -0,0 +1,9 @@
+import type { FragmentDefinitionNode, GraphQLSchema, OperationDefinitionNode } from "graphql";
+import { OperationPlan } from "./index.js";
+import type { BaseGraphQLContext, BaseGraphQLRootValue, BaseGraphQLVariables } from "./interfaces.js";
+declare type Fragments = {
+    [key: string]: FragmentDefinitionNode;
+};
+export declare function establishOperationPlan<TVariables extends BaseGraphQLVariables = BaseGraphQLVariables, TContext extends BaseGraphQLContext = BaseGraphQLContext, TRootValue extends BaseGraphQLRootValue = BaseGraphQLRootValue>(schema: GraphQLSchema, operation: OperationDefinitionNode, fragments: Fragments, variableValues: TVariables, context: TContext, rootValue: TRootValue): OperationPlan;
+export {};
+//# sourceMappingURL=establishOperationPlan.d.ts.map

package/dist/execute.d.ts

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

package/dist/exportAs.d.ts

@@ -0,0 +1,5 @@
+export declare function exportAs<T>(moduleName: string, thing: T, exportName: string): T;
+export declare function exportAsMany(moduleName: string, all: {
+    [key: string]: any;
+}): void;
+//# sourceMappingURL=exportAs.d.ts.map

package/dist/global.d.ts

@@ -0,0 +1,3 @@
+export declare function setDebug(newDebug: boolean): void;
+export declare function getDebug(): boolean;
+//# sourceMappingURL=global.d.ts.map

package/dist/grafastGraphql.d.ts

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

package/dist/grafastPrint.d.ts

@@ -0,0 +1,5 @@
+export declare function _grafastPrint(symbol: string | symbol | symbol[] | Record<symbol, any> | Map<any, any>, seen: Set<any>): string;
+export declare function grafastColor(text: string, n: number): string;
+export declare function grafastPrint(symbol: symbol | symbol[] | Record<symbol, any> | Map<any, any> | any): string;
+export declare function ansiPad(ansiString: string, targetLength: number, fill: string, position: "start" | "end"): string;
+//# sourceMappingURL=grafastPrint.d.ts.map

package/dist/graphqlCollectFields.d.ts

@@ -0,0 +1,12 @@
+import type { FieldNode, SelectionNode } from "graphql";
+import { GraphQLObjectType } from "graphql";
+import type { OperationPlan } from "./engine/OperationPlan.js";
+import type { __TrackedObjectStep } from "./steps/index.js";
+export declare function evalDirectiveArg<T = unknown>(selection: SelectionNode, directiveName: string, argumentName: string, variableValuesStep: __TrackedObjectStep): T | undefined;
+export interface SelectionSetDigest {
+    label: string | undefined;
+    fields: Map<string, FieldNode[]>;
+    deferred: SelectionSetDigest[];
+}
+export declare function graphqlCollectFields(operationPlan: OperationPlan, parentStepId: number, objectType: GraphQLObjectType, selections: readonly SelectionNode[], isMutation?: boolean, visitedFragments?: Set<string>, selectionSetDigest?: SelectionSetDigest): SelectionSetDigest;
+//# sourceMappingURL=graphqlCollectFields.d.ts.map

package/dist/graphqlMergeSelectionSets.d.ts

@@ -0,0 +1,4 @@
+import type { FieldNode, GraphQLObjectType, SelectionNode } from "graphql";
+import type { OperationPlan } from "./index.js";
+export declare function fieldSelectionsForType(operationPlan: OperationPlan, type: GraphQLObjectType, selections: ReadonlyArray<SelectionNode>, result?: Array<FieldNode>): ReadonlyArray<FieldNode>;
+//# sourceMappingURL=graphqlMergeSelectionSets.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { exportAsMany } from "./exportAs.js";
+import { grafastPrint } from "./grafastPrint.js";
+import { EnumPlans, FieldPlans, GrafastPlans, InputObjectPlans, InterfaceOrUnionPlans, makeGrafastSchema, ObjectPlans, ScalarPlans } from "./makeGrafastSchema.js";
+import { PrintPlanGraphOptions } from "./mermaid.js";
+import { defer, Deferred } from "./deferred.js";
+import { isDev, noop } from "./dev.js";
+import { OperationPlan } from "./engine/OperationPlan.js";
+import { GrafastError, isGrafastError } from "./error.js";
+import { execute } from "./execute.js";
+import { grafastGraphql, grafastGraphqlSync } from "./grafastGraphql.js";
+import { InputStep } from "./input.js";
+import { $$bypassGraphQL, $$concreteType, $$data, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, ArgumentApplyPlanResolver, ArgumentInputPlanResolver, BaseEventMap, BaseGraphQLArguments, BaseGraphQLContext, BaseGraphQLRootValue, BaseGraphQLVariables, EnumValueApplyPlanResolver, EventCallback, EventMapKey, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, FieldArgs, FieldInfo, FieldPlanResolver, GrafastArgumentExtensions, GrafastEnumValueExtensions, GrafastFieldExtensions, GrafastInputFieldExtensions, GrafastObjectTypeExtensions, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, GrafastValuesList, GraphileArgumentConfig, GraphileFieldConfig, GraphileFieldConfigArgumentMap, GraphileInputFieldConfig, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, InputObjectTypeInputPlanResolver, NodeIdCodec, NodeIdHandler, OutputPlanForType, PolymorphicData, PromiseOrDirect, ScalarPlanResolver, StepOptimizeOptions, StepStreamOptions, TypedEventEmitter } from "./interfaces.js";
+import { polymorphicWrap, resolveType } from "./polymorphic.js";
+import { assertListCapableStep, BaseStep, ExecutableStep, isExecutableStep, isListCapableStep, isModifierStep, isObjectLikeStep, isStreamableStep, ListCapableStep, ModifierStep, ObjectLikeStep, PolymorphicStep, StreamableStep, UnbatchedExecutableStep } from "./step.js";
+import { __InputListStep, __InputObjectStep, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedObjectStep, __ValueStep, access, AccessStep, ActualKeyByDesiredKey, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, debugPlans, deepEval, DeepEvalStep, each, EdgeCapableStep, EdgeStep, error, ErrorStep, filter, FilterPlanMemo, first, FirstStep, GraphQLItemHandler, graphqlItemHandler, GraphQLPolymorphicUnwrap, graphqlPolymorphicUnwrap, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, lambda, LambdaStep, last, LastStep, list, listen, ListenStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, loadMany, LoadManyCallback, loadManyCallback, LoadManyOptions, LoadManySingleRecordStep, LoadManyStep, loadOne, LoadOneCallback, loadOneCallback, LoadOneOptions, LoadOneStep, makeMapper, map, MapStep, node, NodeStep, object, ObjectPlanMeta, ObjectStep, operationPlan, PageInfoCapableStep, partitionByIndex, proxy, ProxyStep, reverse, reverseArray, ReverseStep, setter, SetterCapableStep, SetterStep, specFromNodeId } from "./steps/index.js";
+import { stringifyPayload } from "./stringifyPayload.js";
+import { stripAnsi } from "./stripAnsi.js";
+import { subscribe } from "./subscribe.js";
+import { arrayOfLength, arraysMatch, canRepresentAsIdentifier, evalSafeProperty, getEnumValueConfig, GraphileInputFieldConfigMap, GraphileInputObjectType, GraphileObjectType, inputObjectFieldSpec, InputObjectTypeSpec, isPromiseLike, isSafeObjectPropertyName, newGraphileFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, objectFieldSpec, objectSpec, ObjectTypeFields, ObjectTypeSpec, stepADependsOnStepB, stepAMayDependOnStepB, stepsAreInSamePhase } from "./utils.js";
+export { isAsyncIterable } from "iterall";
+export { __InputListStep, __InputObjectStep, __InputStaticLeafStep, __ItemStep, __ListTransformStep, __TrackedObjectStep, __ValueStep, $$bypassGraphQL, $$concreteType, $$data, $$eventEmitter, $$extensions, $$idempotent, $$verbatim, access, AccessStep, ActualKeyByDesiredKey, ArgumentApplyPlanResolver, ArgumentInputPlanResolver, arrayOfLength, arraysMatch, assertListCapableStep, BaseEventMap, BaseGraphQLArguments, BaseGraphQLContext, BaseGraphQLRootValue, BaseGraphQLVariables, BaseStep, canRepresentAsIdentifier, connection, ConnectionCapableStep, ConnectionStep, constant, ConstantStep, context, debugPlans, deepEval, DeepEvalStep, defer, Deferred, each, EdgeCapableStep, EdgeStep, EnumPlans, EnumValueApplyPlanResolver, error, ErrorStep, evalSafeProperty, EventCallback, EventMapKey, ExecutableStep, execute, ExecutionEventEmitter, ExecutionEventMap, ExecutionExtra, exportAsMany, FieldArgs, FieldInfo, FieldPlanResolver, FieldPlans, filter, FilterPlanMemo, first, FirstStep, getEnumValueConfig, grafastGraphql as grafast, GrafastArgumentExtensions, GrafastEnumValueExtensions, GrafastError, GrafastFieldExtensions, grafastGraphql, grafastGraphqlSync, GrafastInputFieldExtensions, GrafastObjectTypeExtensions, GrafastPlans, grafastPrint, GrafastResultsList, GrafastResultStreamList, GrafastSubscriber, grafastGraphqlSync as grafastSync, GrafastValuesList, GraphileArgumentConfig, GraphileFieldConfig, GraphileFieldConfigArgumentMap, GraphileInputFieldConfig, GraphileInputFieldConfigMap, GraphileInputObjectType, GraphileObjectType, GraphQLItemHandler, graphqlItemHandler, GraphQLPolymorphicUnwrap, graphqlPolymorphicUnwrap, graphqlResolver, GraphQLResolverStep, groupBy, GroupByPlanMemo, InputObjectFieldApplyPlanResolver, InputObjectFieldInputPlanResolver, inputObjectFieldSpec, InputObjectPlans, InputObjectTypeInputPlanResolver, InputObjectTypeSpec, InputStep, InterfaceOrUnionPlans, isDev, isExecutableStep, isGrafastError, isListCapableStep, isModifierStep, isObjectLikeStep, isPromiseLike, isSafeObjectPropertyName, isStreamableStep, lambda, LambdaStep, last, LastStep, list, ListCapableStep, listen, ListenStep, ListStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, loadMany, LoadManyCallback, loadManyCallback, LoadManyOptions, LoadManySingleRecordStep, LoadManyStep, loadOne, LoadOneCallback, loadOneCallback, LoadOneOptions, LoadOneStep, makeGrafastSchema, makeMapper, map, MapStep, ModifierStep, newGraphileFieldConfigBuilder, newInputObjectTypeBuilder, newObjectTypeBuilder, node, NodeIdCodec, NodeIdHandler, NodeStep, noop, object, objectFieldSpec, ObjectLikeStep, ObjectPlanMeta, ObjectPlans, objectSpec, ObjectStep, ObjectTypeFields, ObjectTypeSpec, OperationPlan, operationPlan, OutputPlanForType, PageInfoCapableStep, partitionByIndex, PolymorphicData, PolymorphicStep, polymorphicWrap, PrintPlanGraphOptions, PromiseOrDirect, proxy, ProxyStep, resolveType, reverse, reverseArray, ReverseStep, ScalarPlanResolver, ScalarPlans, setter, SetterCapableStep, SetterStep, specFromNodeId, stepADependsOnStepB, stepAMayDependOnStepB, StepOptimizeOptions, stepsAreInSamePhase, StepStreamOptions, StreamableStep, stringifyPayload, stripAnsi, subscribe, TypedEventEmitter, UnbatchedExecutableStep, };
+export { hookArgs } from "./args.js";
+//# sourceMappingURL=index.d.ts.map