grafast 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/steps/remapKeys.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.remapKeys = exports.RemapKeysStep = void 0;
+exports.RemapKeysStep = void 0;
+exports.remapKeys = remapKeys;
 const tslib_1 = require("tslib");
 /* eslint-disable @typescript-eslint/ban-types */
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 function makeMapper(actualKeyByDesiredKey, callback) {
     const entries = Object.entries(actualKeyByDesiredKey);
     if (entries.every(([key, val]) => (0, tamedevil_1.isSafeObjectPropertyName)(key) && (0, tamedevil_1.isSafeObjectPropertyName)(val))) {
@@ -29,7 +31,7 @@ function makeMapper(actualKeyByDesiredKey, callback) {
  * A plan that returns an object resulting from extracting the given
  * `actualKey` from the input and storing it as the `desiredKey` in the output.
  */
-class RemapKeysStep extends step_js_1.UnbatchedExecutableStep {
+class RemapKeysStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "RemapKeysStep",
@@ -40,6 +42,10 @@ class RemapKeysStep extends step_js_1.UnbatchedExecutableStep {
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
         this.addDependency($plan);
+        this.peerKey = (0, utils_js_1.digestKeys)([
+            ...Object.keys(this.actualKeyByDesiredKey),
+            ...Object.values(this.actualKeyByDesiredKey),
+        ]);
     }
     toStringMeta() {
         return (chalk_1.default.bold.yellow(String(this.dependencies[0].id)) +
@@ -61,15 +67,17 @@ class RemapKeysStep extends step_js_1.UnbatchedExecutableStep {
         });
         super.finalize();
     }
-    execute(_count, values) {
-        return values[0].map(this.mapper);
+    execute({ count, values: [values0], }) {
+        return values0.isBatch
+            ? values0.entries.map(this.mapper)
+            : new Array(count).fill(this.mapper(values0.value));
     }
     unbatchedExecute(_extra, value) {
         return this.mapper(value);
     }
     deduplicate(peers) {
-        const myMap = JSON.stringify(this.actualKeyByDesiredKey);
-        return peers.filter((p) => JSON.stringify(p.actualKeyByDesiredKey) === myMap);
+        // Handled by peerKey
+        return peers;
     }
 }
 exports.RemapKeysStep = RemapKeysStep;
@@ -80,5 +88,4 @@ exports.RemapKeysStep = RemapKeysStep;
 function remapKeys($step, actualKeyByDesiredKey) {
     return new RemapKeysStep($step, actualKeyByDesiredKey);
 }
-exports.remapKeys = remapKeys;
 //# sourceMappingURL=remapKeys.js.map

package/dist/steps/reverse.d.ts

@@ -1,6 +1,6 @@
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Returns a reversed copy of the list.
  */
@@ -8,20 +8,20 @@ export declare function reverseArray<TData = any>(list: readonly TData[]): TData
 /**
  * Reverses a list.
  */
-export declare class ReverseStep<TData> extends UnbatchedExecutableStep<readonly TData[]> {
+export declare class ReverseStep<TData> extends UnbatchedStep<readonly TData[]> {
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    constructor(plan: ExecutableStep<readonly TData[]>);
-    execute(_count: number, values: [GrafastValuesList<TData[]>]): GrafastResultsList<TData[]>;
-    unbatchedExecute(_extra: ExecutionExtra, arr: TData[]): TData[];
+    constructor(plan: Step<readonly TData[]>);
+    execute({ indexMap, values: [values0], }: ExecutionDetails<[TData[]]>): GrafastResultsList<TData[]>;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, arr: TData[]): TData[];
     deduplicate(peers: ReverseStep<TData>[]): ReverseStep<TData>[];
 }
 /**
  * Reverses a list.
  */
-export declare function reverse<TData>(plan: ExecutableStep<readonly TData[]>): ReverseStep<TData>;
+export declare function reverse<TData>(plan: Step<readonly TData[]>): ReverseStep<TData>;
 //# sourceMappingURL=reverse.d.ts.map

package/dist/steps/reverse.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reverse = exports.ReverseStep = exports.reverseArray = void 0;
+exports.ReverseStep = void 0;
+exports.reverseArray = reverseArray;
+exports.reverse = reverse;
 const step_js_1 = require("../step.js");
 /**
  * Returns a reversed copy of the list.
@@ -16,11 +18,10 @@ function reverseArray(list) {
     }
     return newList;
 }
-exports.reverseArray = reverseArray;
 /**
  * Reverses a list.
  */
-class ReverseStep extends step_js_1.UnbatchedExecutableStep {
+class ReverseStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ReverseStep",
@@ -31,8 +32,11 @@ class ReverseStep extends step_js_1.UnbatchedExecutableStep {
         this.allowMultipleOptimizations = true;
         this.addDependency(plan);
     }
-    execute(_count, values) {
-        return values[0].map((arr) => (arr == null ? arr : reverseArray(arr)));
+    execute({ indexMap, values: [values0], }) {
+        return indexMap((i) => {
+            const arr = values0.at(i);
+            return arr == null ? arr : reverseArray(arr);
+        });
     }
     unbatchedExecute(_extra, arr) {
         return arr == null ? arr : reverseArray(arr);
@@ -46,7 +50,6 @@ exports.ReverseStep = ReverseStep;
  * Reverses a list.
  */
 function reverse(plan) {
-    return new ReverseStep(plan);
+    return plan.operationPlan.cacheStep(plan, "GrafastInternal:reverse()", "", () => new ReverseStep(plan));
 }
-exports.reverse = reverse;
 //# sourceMappingURL=reverse.js.map

package/dist/steps/setter.d.ts

@@ -1,27 +1,18 @@
-import type { BaseStep, ExecutableStep } from "../step.js";
-import { ModifierStep } from "../step.js";
-export interface SetterCapableStep<TPlans extends {
-    [key: string]: ExecutableStep;
-}> extends BaseStep {
-    set<TKey extends keyof TPlans>(key: TKey, value: TPlans[TKey]): void;
+import type { InputObjectTypeBakedInfo } from "../index.js";
+import { Modifier } from "./applyInput.js";
+export interface SetterCapable<TObj extends Record<string, any>> {
+    set<TKey extends keyof TObj>(key: TKey, value: TObj[TKey]): void;
 }
-export declare class SetterStep<TPlans extends {
-    [key: string]: ExecutableStep;
-} = {
-    [key: string]: ExecutableStep;
-}, TParentStep extends SetterCapableStep<TPlans> = SetterCapableStep<TPlans>> extends ModifierStep<TParentStep> {
+export declare class Setter<TObj extends Record<string, any> = Record<string, any>, TParent extends SetterCapable<TObj> = SetterCapable<TObj>> extends Modifier<TParent> {
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     private setters;
-    constructor($parent: TParentStep);
-    set<TKey extends keyof TPlans>(key: TKey, valuePlan: TPlans[TKey]): void;
+    constructor(parent: TParent);
+    set<TKey extends keyof TObj>(key: TKey, value: TObj[TKey]): void;
     apply(): void;
 }
-export declare function setter<TPlans extends {
-    [key: string]: ExecutableStep;
-} = {
-    [key: string]: ExecutableStep;
-}, TParentStep extends SetterCapableStep<TPlans> = SetterCapableStep<TPlans>>($parent: TParentStep): SetterStep<TPlans, TParentStep>;
+export declare function setter<TObj extends Record<string, any> = Record<string, any>, TParent extends SetterCapable<TObj> = SetterCapable<TObj>>(parent: TParent): Setter<TObj, TParent>;
+export declare function createObjectAndApplyChildren<TObj extends Record<string, any>>(_input: Record<string, any>, info: InputObjectTypeBakedInfo): TObj;
 //# sourceMappingURL=setter.d.ts.map

package/dist/steps/setter.js

@@ -1,28 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setter = exports.SetterStep = void 0;
-const step_js_1 = require("../step.js");
-class SetterStep extends step_js_1.ModifierStep {
+exports.Setter = void 0;
+exports.setter = setter;
+exports.createObjectAndApplyChildren = createObjectAndApplyChildren;
+const applyInput_js_1 = require("./applyInput.js");
+class Setter extends applyInput_js_1.Modifier {
     static { this.$$export = {
         moduleName: "grafast",
-        exportName: "SetterStep",
+        exportName: "Setter",
     }; }
-    constructor($parent) {
-        super($parent);
+    constructor(parent) {
+        super(parent);
         this.setters = new Map();
     }
-    set(key, valuePlan) {
-        this.setters.set(key, valuePlan);
+    set(key, value) {
+        this.setters.set(key, value);
     }
     apply() {
-        for (const [key, valuePlan] of this.setters.entries()) {
-            this.$parent.set(key, valuePlan);
+        for (const [key, value] of this.setters.entries()) {
+            this.parent.set(key, value);
         }
     }
 }
-exports.SetterStep = SetterStep;
-function setter($parent) {
-    return new SetterStep($parent);
+exports.Setter = Setter;
+function setter(parent) {
+    return new Setter(parent);
+}
+function createObjectAndApplyChildren(_input, info) {
+    const obj = Object.create(null);
+    info.applyChildren(setter({
+        set(key, value) {
+            obj[key] = value;
+        },
+    }));
+    return obj;
 }
-exports.setter = setter;
 //# sourceMappingURL=setter.js.map

package/dist/steps/sideEffect.d.ts

@@ -0,0 +1,28 @@
+import type { PromiseOrDirect, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Multistep, UnwrapMultistep } from "../multistep.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+/**
+ * Calls the given callback function for each tuple
+ */
+export declare class SideEffectStep<TIn, TOut> extends UnbatchedStep<TOut> {
+    private fn;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    private planDep;
+    constructor($plan: Step<TIn> | null | undefined, fn: (value: TIn) => PromiseOrDirect<TOut>);
+    toStringMeta(): any;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, value: TIn): PromiseOrDirect<TOut>;
+}
+/**
+ * A plan that takes the input `$plan` and feeds each value through the `fn`
+ * callback. Note: if you need to pass more than one value, pass a `ListStep`
+ * as the `$plan` argument.
+ */
+declare function sideEffect<const TInMultistep extends Multistep, TOut>(spec: TInMultistep, fn: (value: UnwrapMultistep<TInMultistep>) => PromiseOrDirect<TOut>): SideEffectStep<UnwrapMultistep<TInMultistep>, TOut>;
+export { sideEffect };
+//# sourceMappingURL=sideEffect.d.ts.map

package/dist/steps/sideEffect.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SideEffectStep = void 0;
+exports.sideEffect = sideEffect;
+const multistep_js_1 = require("../multistep.js");
+const step_js_1 = require("../step.js");
+/**
+ * Calls the given callback function for each tuple
+ */
+class SideEffectStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "SideEffectStep",
+    }; }
+    constructor($plan, fn) {
+        super();
+        this.fn = fn;
+        this.isSyncAndSafe = false;
+        this.allowMultipleOptimizations = false;
+        this.hasSideEffects = true;
+        this.planDep = $plan != null ? this.addDependency($plan) : null;
+    }
+    toStringMeta() {
+        return this.fn.displayName || this.fn.name;
+    }
+    unbatchedExecute(_extra, value) {
+        return this.fn(value);
+    }
+}
+exports.SideEffectStep = SideEffectStep;
+/**
+ * A plan that takes the input `$plan` and feeds each value through the `fn`
+ * callback. Note: if you need to pass more than one value, pass a `ListStep`
+ * as the `$plan` argument.
+ */
+function sideEffect(spec, fn) {
+    if (fn.length > 1) {
+        throw new Error("sideEffect callback should accept one argument, perhaps you forgot to destructure the arguments?");
+    }
+    const $in = (0, multistep_js_1.multistep)(spec);
+    const $result = new SideEffectStep($in, fn);
+    return $result;
+}
+//# sourceMappingURL=sideEffect.js.map

package/dist/stringifyPayload.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyPayload = void 0;
+exports.stringifyPayload = stringifyPayload;
 function stringifyPayload(payload, outputDataAsString) {
     if (!outputDataAsString || typeof payload.data !== "string") {
         return JSON.stringify(payload);
@@ -55,5 +55,4 @@ function stringifyPayload(payload, outputDataAsString) {
     str += "}";
     return str;
 }
-exports.stringifyPayload = stringifyPayload;
 //# sourceMappingURL=stringifyPayload.js.map

package/dist/stripAnsi.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripAnsi = exports.ANSI_REGEXP = void 0;
+exports.ANSI_REGEXP = void 0;
+exports.stripAnsi = stripAnsi;
 // Extracted from https://github.com/chalk/ansi-regex MIT license
 // Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 // Copyright (c) Benjie (https://twitter.com/benjie)
@@ -10,5 +11,4 @@ exports.ANSI_REGEXP =
 function stripAnsi(str) {
     return str.replace(exports.ANSI_REGEXP, "");
 }
-exports.stripAnsi = stripAnsi;
 //# sourceMappingURL=stripAnsi.js.map

package/dist/subscribe.d.ts

@@ -1,8 +1,14 @@
 import type { AsyncExecutionResult, ExecutionArgs, ExecutionResult } from "graphql";
 import type { PromiseOrValue } from "graphql/jsutils/PromiseOrValue";
+import type { GrafastExecutionArgs } from "./index.js";
+/**
+ * @deprecated Second and third parameters should be passed as part of args,
+ * specifically `resolvedPreset` and `outputDataAsString`.
+ */
+export declare function subscribe(args: ExecutionArgs, resolvedPreset: GraphileConfig.ResolvedPreset | undefined, outputDataAsString?: boolean): PromiseOrValue<AsyncGenerator<ExecutionResult | AsyncExecutionResult, void, void> | ExecutionResult>;
 /**
  * Use this instead of GraphQL.js' subscribe method and we'll automatically
  * run grafastPrepare for you and handle the result.
  */
-export declare function subscribe(args: ExecutionArgs, resolvedPreset?: GraphileConfig.ResolvedPreset, outputDataAsString?: boolean): PromiseOrValue<AsyncGenerator<ExecutionResult | AsyncExecutionResult, void, void> | ExecutionResult>;
+export declare function subscribe(args: GrafastExecutionArgs): PromiseOrValue<AsyncGenerator<ExecutionResult | AsyncExecutionResult, void, void> | ExecutionResult>;
 //# sourceMappingURL=subscribe.d.ts.map

package/dist/subscribe.js

@@ -1,14 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.subscribe = void 0;
-const config_js_1 = require("./config.js");
+exports.subscribe = subscribe;
 const execute_js_1 = require("./execute.js");
-/**
- * Use this instead of GraphQL.js' subscribe method and we'll automatically
- * run grafastPrepare for you and handle the result.
- */
-function subscribe(args, resolvedPreset = config_js_1.NULL_PRESET, outputDataAsString = false) {
-    return (0, execute_js_1.withGrafastArgs)(args, resolvedPreset, outputDataAsString);
+const middleware_js_1 = require("./middleware.js");
+function subscribe(args, legacyResolvedPreset, legacyOutputDataAsString) {
+    // TODO: remove legacy compatibility
+    if (legacyResolvedPreset !== undefined) {
+        args.resolvedPreset = legacyResolvedPreset;
+    }
+    if (legacyOutputDataAsString !== undefined) {
+        args.outputDataAsString = legacyOutputDataAsString;
+    }
+    const { resolvedPreset } = args;
+    const middleware = args.middleware === undefined && resolvedPreset != null
+        ? (0, middleware_js_1.getGrafastMiddleware)(resolvedPreset)
+        : (args.middleware ?? null);
+    if (args.middleware === undefined) {
+        args.middleware = middleware;
+    }
+    if (middleware !== null) {
+        return middleware.run("subscribe", { args }, subscribeMiddlewareCallback);
+    }
+    else {
+        return (0, execute_js_1.withGrafastArgs)(args);
+    }
 }
-exports.subscribe = subscribe;
+const subscribeMiddlewareCallback = (event) => (0, execute_js_1.withGrafastArgs)(event.args);
 //# sourceMappingURL=subscribe.js.map

package/dist/thereCanBeOnlyOne.js

@@ -6,7 +6,7 @@ if (globalAny[$$grafast] === true) {
     // Already warned
 }
 else if (globalAny[$$grafast]) {
-    console.trace(`WARNING: more than one version of the 'grafast' module has been instantiated - you must ensure there is exactly one grafast (e.g. using yarn "resolutions" or similar techniques). Try clearing your package lockfile and reinstalling. ${globalAny[$$grafast].stack}`);
+    console.trace(`WARNING: more than one version of the 'grafast' module has been instantiated - you must ensure there is exactly one grafast (e.g. using yarn "resolutions" or similar techniques). Try clearing your package lockfile and reinstalling.\n    ${String(globalAny[$$grafast].stack).replace(/\n/g, "\n    ")}`);
     globalAny[$$grafast] = true;
 }
 else {

package/dist/timeSource.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="node" />
 export declare const timeSource: import("perf_hooks").Performance | DateConstructor;
 //# sourceMappingURL=timeSource.d.ts.map

package/dist/utils.d.ts

@@ -1,9 +1,9 @@
-import type { ConstValueNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema } from "graphql";
+import type { ConstValueNode, DirectiveNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema, ValueNode } from "graphql";
 import * as graphql from "graphql";
 import type { Deferred } from "./deferred.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
-import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig, InputStep, OutputPlanForType } from "./interfaces.js";
-import type { ExecutableStep, ModifierStep } from "./step.js";
+import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig, OutputPlanForType } from "./interfaces.js";
+import type { Step } from "./step.js";
 /**
  * The parent object is used as the key in `GetValueStepId()`; for root level
  * fields it's possible that the parent will be null/undefined (in all other
@@ -21,7 +21,7 @@ export declare function isPromise<T>(t: T | Promise<T>): t is Promise<T>;
 /**
  * Is "thenable".
  */
-export declare function isPromiseLike<T>(t: T | Promise<T> | PromiseLike<T>): t is PromiseLike<T>;
+export declare function isPromiseLike<T>(t: T | PromiseLike<T>): t is PromiseLike<T>;
 /**
  * Is a promise that can be externally resolved.
  */
@@ -31,61 +31,62 @@ export declare function isDeferred<T>(t: T | Promise<T> | Deferred<T>): t is Def
  * values within them pass the `comparator` check (which defaults to `===`).
  */
 export declare function arraysMatch<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, comparator?: (val1: T, val2: T) => boolean): boolean;
-export type ObjectTypeFields<TContext extends Grafast.Context, TParentStep extends ExecutableStep> = {
-    [key: string]: GrafastFieldConfig<GraphQLOutputType, TContext, TParentStep, any, any>;
+export type ObjectTypeFields<TParentStep extends Step> = {
+    [key: string]: GrafastFieldConfig<GraphQLOutputType, TParentStep, any, any>;
 };
-export type ObjectTypeSpec<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>> = Omit<GraphQLObjectTypeConfig<any, TContext>, "fields"> & {
+export type ObjectTypeSpec<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>> = Omit<GraphQLObjectTypeConfig<any, Grafast.Context>, "fields"> & {
     fields: TFields | (() => TFields);
-    assertStep?: TParentStep extends ExecutableStep ? ((step: ExecutableStep) => asserts step is TParentStep) | {
+    assertStep?: TParentStep extends Step ? ((step: Step) => asserts step is TParentStep) | {
         new (...args: any[]): TParentStep;
     } : null;
 };
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function objectSpec<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>): GraphQLObjectTypeConfig<any, TContext>;
-export type GrafastObjectType<TContext extends Grafast.Context, TParentStep extends ExecutableStep, TFields extends ObjectTypeFields<TContext, TParentStep>> = graphql.GraphQLObjectType<TParentStep extends ExecutableStep<infer U> ? U : never, TContext> & {
+export declare function objectSpec<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>>(spec: ObjectTypeSpec<TParentStep, TFields>): GraphQLObjectTypeConfig<any, Grafast.Context>;
+export type GrafastObjectType<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>> = graphql.GraphQLObjectType<TParentStep extends Step<infer U> ? U : never> & {
     TParentStep: TParentStep;
     TFields: TFields;
 };
 /**
  * @remarks This is a mess because the first two generics need to be specified manually, but the latter one we want inferred.
  */
-export declare function newObjectTypeBuilder<TContext extends Grafast.Context, TParentStep extends ExecutableStep>(assertStep: TParentStep extends ExecutableStep ? ((step: ExecutableStep) => asserts step is TParentStep) | {
+export declare function newObjectTypeBuilder<TParentStep extends Step>(assertStep: TParentStep extends Step ? ((step: Step) => asserts step is TParentStep) | {
     new (...args: any[]): TParentStep;
-} : never): <TFields extends ObjectTypeFields<TContext, TParentStep>>(spec: ObjectTypeSpec<TContext, TParentStep, TFields>) => GrafastObjectType<TContext, TParentStep, TFields>;
+} : never): <TFields extends ObjectTypeFields<TParentStep>>(spec: ObjectTypeSpec<TParentStep, TFields>) => GrafastObjectType<TParentStep, TFields>;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function objectFieldSpec<TContext extends Grafast.Context, TSource extends ExecutableStep, TResult extends ExecutableStep = ExecutableStep, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(grafastSpec: GrafastFieldConfig<GraphQLOutputType, TContext, TSource, TResult, TArgs>, path: string): GraphQLFieldConfig<any, TContext, TArgs>;
+export declare function objectFieldSpec<TSource extends Step, TResult extends Step = Step, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(grafastSpec: GrafastFieldConfig<GraphQLOutputType, TSource, TResult, TArgs>, path: string): GraphQLFieldConfig<any, TArgs>;
 /**
  * "Constrainted identity function" for field configs.
  *
  * @see {@link https://kentcdodds.com/blog/how-to-write-a-constrained-identity-function-in-typescript}
  */
-export declare function newGrafastFieldConfigBuilder<TContext extends Grafast.Context, TParentStep extends ExecutableStep>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GrafastFieldConfig<TType, TContext, TParentStep, TFieldStep, TArgs>) => typeof config;
-export type GrafastInputFieldConfigMap<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>> = {
-    [key: string]: GrafastInputFieldConfig<GraphQLInputType, TContext, TParentStep, any, any>;
+export declare function newGrafastFieldConfigBuilder<TParentStep extends Step>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GrafastFieldConfig<TType, TParentStep, TFieldStep, TArgs>) => typeof config;
+export type GrafastInputFieldConfigMap<TParent> = {
+    [key: string]: GrafastInputFieldConfig<TParent, GraphQLInputType>;
 };
-export type InputObjectTypeSpec<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
-    fields: TFields | (() => TFields);
+export type InputObjectTypeSpec<TParent> = Omit<GraphQLInputObjectTypeConfig, "fields"> & {
+    fields: GrafastInputFieldConfigMap<TParent> | (() => GrafastInputFieldConfigMap<TParent>);
 };
-export type GrafastInputObjectType<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>, TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>> = graphql.GraphQLInputObjectType & {
-    TContext: TContext;
-    TParentStep: TParentStep;
-    TFields: TFields;
+export type GrafastInputObjectType<TParent> = graphql.GraphQLInputObjectType & {
+    TParent: TParent;
 };
-export declare function newInputObjectTypeBuilder<TContext extends Grafast.Context, TParentStep extends ModifierStep<any>>(): <TFields extends GrafastInputFieldConfigMap<TContext, TParentStep>>(spec: InputObjectTypeSpec<TContext, TParentStep, TFields>) => GrafastInputObjectType<TContext, TParentStep, TFields>;
+export declare function newInputObjectTypeBuilder<TParent = any>(): (spec: InputObjectTypeSpec<TParent>) => GrafastInputObjectType<TParent>;
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function inputObjectFieldSpec<TContext extends Grafast.Context, TParent extends ModifierStep<any>, TResult extends ModifierStep<TParent> = ModifierStep<TParent>, TInput extends InputStep = InputStep>(grafastSpec: GrafastInputFieldConfig<GraphQLInputType, TContext, TParent, TResult, TInput>, path: string): GraphQLInputFieldConfig;
+export declare function inputObjectFieldSpec<TParent>(grafastSpec: GrafastInputFieldConfig<TParent, GraphQLInputType>, path: string): GraphQLInputFieldConfig;
 declare module "graphql" {
     interface GraphQLEnumType {
         [$$valueConfigByValue]?: Record<string, GraphQLEnumValueConfig>;
     }
 }
 declare const $$valueConfigByValue: unique symbol;
+export declare function getEnumValueConfigs(enumType: graphql.GraphQLEnumType): {
+    [outputValue: string]: GraphQLEnumValueConfig | undefined;
+};
 /**
  * This would be equivalent to `enumType._valueLookup.get(outputValue)` except
  * that's not a public API so we have to do a bit of heavy lifting here. Since
@@ -93,46 +94,28 @@ declare const $$valueConfigByValue: unique symbol;
  * will go away so we use a weakmap.
  */
 export declare function getEnumValueConfig(enumType: graphql.GraphQLEnumType, outputValue: string): GraphQLEnumValueConfig | undefined;
-/**
- * It's a peculiarity of V8 that `{}` is twice as fast as
- * `Object.create(null)`, but `Object.create(sharedNull)` is the same speed as
- * `{}`. Hat tip to `@purge` for bringing this to my attention.
- *
- * @internal
- */
-export declare const sharedNull: any;
-/**
- * Prints out the stack trace to the current position with a message; useful
- * for debugging which code path has hit this line.
- *
- * @internal
- */
-export declare function stack(message: string, length?: number): void;
 /**
  * Ridiculously, this is faster than `new Array(length).fill(fill)`
- *
- * @internal
  */
 export declare function arrayOfLength(length: number, fill?: any): any[];
-/**
- * Builds an array of length `length` calling `fill` for each entry in the
- * list and storing the result.
- *
- * @internal
- */
-export declare function arrayOfLengthCb(length: number, fill: () => any): any[];
+export declare const valueNodeToStaticValue: typeof graphql.valueFromAST;
+export declare function findVariableNamesUsedInValueNode(valueNode: ValueNode, variableNames: Set<string>): void;
 /**
  * Given a FieldNode, recursively walks and finds all the variable references,
  * returning a list of the (unique) variable names used.
  */
 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;
+/**
+ * Returns `true` if the first argument depends on the second argument either
+ * directly or indirectly (via a chain of dependencies).
+ */
+export declare function stepADependsOnStepB(stepA: Step, stepB: Step): boolean;
 /**
  * Returns true if stepA is allowed to depend on stepB, false otherwise. (This
  * mostly relates to heirarchy.)
  */
-export declare function stepAMayDependOnStepB($a: ExecutableStep, $b: ExecutableStep): boolean;
+export declare function stepAMayDependOnStepB($a: Step, $b: Step): boolean;
 /**
  * For a regular GraphQL query with no `@stream`/`@defer`, the entire result is
  * calculated and then the output is generated and sent to the client at once.
@@ -160,13 +143,31 @@ export declare function stepAMayDependOnStepB($a: ExecutableStep, $b: Executable
  * approach. Once you have, you can use this function to help you, should you
  * need it.
  */
-export declare function stepsAreInSamePhase(ancestor: ExecutableStep, descendent: ExecutableStep): boolean;
+export declare function stepsAreInSamePhase(ancestor: Step, descendent: Step): boolean;
 export declare const canonicalJSONStringify: (o: object) => string;
 export declare function assertNotAsync(fn: any, name: string): void;
-export declare function hasItemPlan(step: ExecutableStep & {
-    itemPlan?: ($item: ExecutableStep) => ExecutableStep;
-}): step is ExecutableStep & {
-    itemPlan: ($item: ExecutableStep) => ExecutableStep;
+export declare function assertNotPromise<TVal>(value: TVal, fn: any, name: string): TVal;
+export declare function hasItemPlan(step: Step & {
+    itemPlan?: ($item: Step) => Step;
+}): step is Step & {
+    itemPlan: ($item: Step) => Step;
 };
+export declare function exportNameHint(obj: any, nameHint: string): void;
+export declare function isTuple<T extends readonly [...(readonly any[])]>(t: any | T): t is T;
+/**
+ * Turns an array of keys into a digest, avoiding conflicts.
+ * Symbols are treated as equivalent. (Theoretically faster
+ * than JSON.stringify().)
+ */
+export declare function digestKeys(keys: ReadonlyArray<string | number | symbol>): string;
+/**
+ * If the directive has the argument `argName`, return a step representing that
+ * arguments value, whether that be a step representing the relevant variable
+ * or a constant step representing the hardcoded value in the document.
+ *
+ * @remarks NOT SUITABLE FOR USAGE WITH LISTS OR OBJECTS! Does not evaluate
+ * internal variable usages e.g. `[1, $b, 3]`
+ */
+export declare function directiveArgument<T>(operationPlan: OperationPlan, directive: DirectiveNode, argName: string, expectedKind: graphql.Kind.INT | graphql.Kind.FLOAT | graphql.Kind.BOOLEAN | graphql.Kind.STRING): Step<T> | undefined;
 export {};
 //# sourceMappingURL=utils.d.ts.map