grafast 0.1.1-beta.20 → 0.1.1-beta.21

package/dist/input.js

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inputStep = exports.graphqlGetTypeForNode = exports.assertInputStep = void 0;
+exports.assertInputStep = assertInputStep;
+exports.graphqlGetTypeForNode = graphqlGetTypeForNode;
+exports.inputStep = inputStep;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const inspect_js_1 = require("./inspect.js");
+const __inputDefault_js_1 = require("./steps/__inputDefault.js");
 const __inputDynamicScalar_js_1 = require("./steps/__inputDynamicScalar.js");
 const __inputObject_js_1 = require("./steps/__inputObject.js");
 const index_js_1 = require("./steps/index.js");
+const utils_js_1 = require("./utils.js");
 const { assertScalarType, GraphQLError, GraphQLList, GraphQLNonNull, isInputType, isLeafType, isInputObjectType, Kind, } = graphql;
 function assertInputStep(itemPlan) {
     if (itemPlan instanceof index_js_1.__TrackedValueStep)
@@ -19,7 +23,6 @@ function assertInputStep(itemPlan) {
         return;
     throw new Error(`Expected an InputStep, but found ${itemPlan}`);
 }
-exports.assertInputStep = assertInputStep;
 function graphqlGetTypeForNode(operationPlan, node) {
     switch (node.kind) {
         case Kind.NAMED_TYPE: {
@@ -41,7 +44,6 @@ function graphqlGetTypeForNode(operationPlan, node) {
         }
     }
 }
-exports.graphqlGetTypeForNode = graphqlGetTypeForNode;
 /**
  * Returns a plan for the given `rawInputValue` AST node which could be a
  * variable or a literal, and could be nested so that a variable (or more than
@@ -49,14 +51,21 @@ exports.graphqlGetTypeForNode = graphqlGetTypeForNode;
  *
  * @internal
  */
-function inputStep(operationPlan, inputType, rawInputValue, defaultValue = undefined) {
-    // This prevents recursion
-    if (rawInputValue === undefined && defaultValue === undefined) {
-        return (0, index_js_1.constant)(undefined);
+function inputStep(operationPlan, inputType, inputValue, defaultValue = undefined) {
+    const { valueNodeToStaticValueCache } = operationPlan;
+    if (inputValue === undefined) {
+        // Definitely can't be or contain a variable!
+        if (defaultValue === undefined) {
+            return (0, index_js_1.constant)(undefined);
+        }
+        else {
+            return valueNodeToCachedStaticValueConstantStep(valueNodeToStaticValueCache, defaultValue, inputType);
+        }
     }
     const isObj = isInputObjectType(inputType);
-    let inputValue = rawInputValue;
-    if (inputValue?.kind === "Variable") {
+    if (inputValue.kind === "Variable") {
+        // Note: this is the only other place where `defaultValue` might be used
+        // we know `inputValue` is not a variable.
         const variableName = inputValue.name.value;
         const variableDefinition = operationPlan.operation.variableDefinitions?.find((def) => def.variable.name.value === variableName);
         if (!variableDefinition) {
@@ -68,17 +77,27 @@ function inputStep(operationPlan, inputType, rawInputValue, defaultValue = undef
         if (!isInputType(variableType)) {
             throw new Error(`Expected varible type to be an input type`);
         }
-        return inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue);
+        const variableWillDefinitelyBeSet = variableType instanceof GraphQLNonNull ||
+            variableDefinition.defaultValue != null;
+        return inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue, variableWillDefinitelyBeSet);
     }
-    // Note: past here we know whether `defaultValue` will be used or not because
-    // we know `inputValue` is not a variable.
-    inputValue = inputValue ?? defaultValue;
-    if (inputType instanceof GraphQLNonNull) {
+    else if (inputType instanceof GraphQLNonNull) {
         const innerType = inputType.ofType;
+        if (inputValue.kind === Kind.NULL) {
+            throw new Error(`Null found in non-null position; this should have been prevented by validation.`);
+        }
         const valuePlan = inputStep(operationPlan, innerType, inputValue, undefined);
         return inputNonNullPlan(operationPlan, valuePlan);
     }
+    else if (inputValue.kind === Kind.NULL) {
+        return (0, index_js_1.constant)(null);
+    }
     else if (inputType instanceof GraphQLList) {
+        const variableNames = new Set();
+        (0, utils_js_1.findVariableNamesUsedInValueNode)(inputValue, variableNames);
+        if (variableNames.size === 0) {
+            return valueNodeToCachedStaticValueConstantStep(valueNodeToStaticValueCache, inputValue, inputType);
+        }
         return new index_js_1.__InputListStep(inputType, inputValue);
     }
     else if (isLeafType(inputType)) {
@@ -100,7 +119,6 @@ function inputStep(operationPlan, inputType, rawInputValue, defaultValue = undef
         throw new Error(`Unsupported type in inputPlan: '${(0, inspect_js_1.inspect)(never)}'`);
     }
 }
-exports.inputStep = inputStep;
 function doTypesMatch(variableType, expectedType) {
     if (variableType instanceof GraphQLNonNull &&
         expectedType instanceof GraphQLNonNull) {
@@ -118,36 +136,57 @@ function doTypesMatch(variableType, expectedType) {
         return variableType === expectedType;
     }
 }
-function inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue = undefined) {
+/**
+ * Returns a step representing a variable's value.
+ *
+ * @param operationPlan -
+ * @param variableName -
+ * @param variableType -
+ * @param inputType -
+ * @param defaultValue -
+ * @param variableWillDefinitelyBeSet - If `true` the variable is either
+ * non-null _or_ it has a default value (including null). In this case, the
+ * variable will never be `undefined` and thus an input position's defaultValue
+ * will never be invoked where it is used.
+ */
+function inputVariablePlan(operationPlan, variableName, variableType, inputType, defaultValue, variableWillDefinitelyBeSet) {
     if (variableType instanceof GraphQLNonNull &&
         !(inputType instanceof GraphQLNonNull)) {
         const unwrappedVariableType = variableType.ofType;
-        return inputVariablePlan(operationPlan, variableName, unwrappedVariableType, inputType, defaultValue);
+        return inputVariablePlan(operationPlan, variableName, unwrappedVariableType, inputType, defaultValue, variableWillDefinitelyBeSet);
     }
     const typesMatch = doTypesMatch(variableType, inputType);
     if (!typesMatch) {
         // REF: https://spec.graphql.org/draft/#IsVariableUsageAllowed()
         if (inputType instanceof GraphQLNonNull &&
             !(variableType instanceof GraphQLNonNull)) {
-            const variablePlan = inputVariablePlan(operationPlan, variableName, variableType, inputType.ofType, defaultValue);
-            if (variablePlan.evalIs(null) || variablePlan.evalIs(undefined)) {
+            const variablePlan = inputVariablePlan(operationPlan, variableName, variableType, inputType.ofType, defaultValue, variableWillDefinitelyBeSet);
+            // TODO: find a way to do this without doing eval. For example: track list of variables that may not be nullish.
+            if (variablePlan.evalIs(null) ||
+                (!variableWillDefinitelyBeSet && variablePlan.evalIs(undefined))) {
                 throw new GraphQLError(`Expected non-null value of type ${inputType.ofType.toString()}`);
             }
             return variablePlan;
         }
         throw new Error("Expected variable and input types to match");
     }
-    const variableValuePlan = operationPlan.trackedVariableValuesStep.get(variableName);
-    if (defaultValue === undefined || !variableValuePlan.evalIs(undefined)) {
-        // There's no default value, or we know for sure that our variable will be
-        // set (even if null) and thus the default will not be used; use the variable.
-        return variableValuePlan;
+    const $variableValue = operationPlan.trackedVariableValuesStep.get(variableName);
+    if (defaultValue === undefined) {
+        // There's no default value and thus the default will not be used; use the variable.
+        return $variableValue;
+    }
+    else if (variableWillDefinitelyBeSet) {
+        // The variable will DEFINITELY be set (even if it is set to null, possibly
+        // by a default), so the input position's default value will never apply.
+        return $variableValue;
     }
     else {
-        // `defaultValue` is NOT undefined, and we know variableValue is
-        // `undefined` (and always will be); we're going to loop back and pretend
-        // that no value was passed in the first place (instead of the variable):
-        return inputStep(operationPlan, inputType, undefined, defaultValue);
+        // Here:
+        // - the variable is nullable, optional, and has no default value
+        // - the input position has a default value
+        // We thus need a step that results in `variableValue === undefined ? defaultValue : variableValue`
+        const runtimeDefaultValue = (0, utils_js_1.valueNodeToStaticValue)(defaultValue, inputType);
+        return new __inputDefault_js_1.__InputDefaultStep($variableValue, runtimeDefaultValue);
     }
 }
 /**
@@ -156,4 +195,12 @@ function inputVariablePlan(operationPlan, variableName, variableType, inputType,
 function inputNonNullPlan(_operationPlan, innerPlan) {
     return innerPlan;
 }
+function valueNodeToCachedStaticValueConstantStep(cache, valueNode, inputType) {
+    let step = cache.get(valueNode);
+    if (!step) {
+        step = (0, index_js_1.constant)((0, utils_js_1.valueNodeToStaticValue)(valueNode, inputType), false);
+        cache.set(valueNode, step);
+    }
+    return step;
+}
 //# sourceMappingURL=input.js.map

package/dist/inspect.d.ts

@@ -1,5 +1,10 @@
-export declare let inspect: (obj: any, options?: {
-    colors?: boolean;
-    depth?: number;
-}) => string;
+export declare let inspect: {
+    (obj: any, options?: {
+        colors?: boolean;
+        depth?: number;
+        compact?: boolean | number;
+        breakLength?: number;
+    }): string;
+    custom: symbol;
+};
 //# sourceMappingURL=inspect.d.ts.map

package/dist/inspect.js

@@ -8,13 +8,13 @@ try {
     }
 }
 catch {
-    exports.inspect = (obj) => {
+    exports.inspect = Object.assign((obj) => {
         return Array.isArray(obj) ||
             !obj ||
             Object.getPrototypeOf(obj) === null ||
             Object.getPrototypeOf(obj) === Object.prototype
             ? String(JSON.stringify(obj))
             : String(obj);
-    };
+    }, { custom: Symbol.for("nodejs.util.inspect.custom") });
 }
 //# sourceMappingURL=inspect.js.map

package/dist/interfaces.d.ts

@@ -3,12 +3,15 @@ import type { Middleware } from "graphile-config";
 import type { ASTNode, ExecutionArgs, FragmentDefinitionNode, GraphQLArgs, GraphQLArgument, GraphQLArgumentConfig, GraphQLField, GraphQLFieldConfig, GraphQLInputField, GraphQLInputFieldConfig, GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLNonNull, GraphQLOutputType, GraphQLScalarType, GraphQLSchema, GraphQLType, OperationDefinitionNode, Source, ValueNode, VariableNode } from "graphql";
 import type { ObjMap } from "graphql/jsutils/ObjMap.js";
 import type { Constraint } from "./constraints.js";
+import type { LayerPlanReasonListItemStream } from "./engine/LayerPlan.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
 import type { FlaggedValue, SafeError } from "./error.js";
-import type { ExecutableStep, ListCapableStep, ModifierStep, StreamableStep } from "./step.js";
+import type { ListCapableStep, Step } from "./step.js";
+import type { __InputDefaultStep } from "./steps/__inputDefault.js";
 import type { __InputDynamicScalarStep } from "./steps/__inputDynamicScalar.js";
-import type { __InputListStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __TrackedValueStep, __TrackedValueStepWithDollars, ConstantStep } from "./steps/index.js";
-import type { GrafastInputObjectType, GrafastObjectType } from "./utils.js";
+import type { ApplyableExecutableStep } from "./steps/applyInput.js";
+import type { __InputListStep, __InputObjectStepWithDollars, __InputStaticLeafStep, __TrackedValueStepWithDollars, ConstantStep, ObjectStep } from "./steps/index.js";
+import type { GrafastObjectType } from "./utils.js";
 export interface GrafastTimeouts {
     /**
      * How many milliseconds should we allow for planning. Remember: planning is
@@ -139,10 +142,13 @@ export interface PolymorphicData<TType extends string = string, TData = any> {
 export interface IndexByListItemStepId {
     [listItemStepId: number]: number;
 }
-export type GrafastValuesList<T> = ReadonlyArray<T>;
+export type GrafastValuesList<TData> = ReadonlyArray<TData>;
 export type PromiseOrDirect<T> = PromiseLike<T> | T;
-export type GrafastResultsList<T> = ReadonlyArray<PromiseOrDirect<T | FlaggedValue<Error> | FlaggedValue<null>>>;
-export type GrafastResultStreamList<T> = ReadonlyArray<PromiseOrDirect<AsyncIterable<PromiseOrDirect<T | FlaggedValue<Error> | FlaggedValue<null>>> | null> | PromiseLike<never>>;
+export type ExecutionResultValue<T> = T | FlaggedValue<Error> | FlaggedValue<null>;
+export type GrafastResultsList<TData> = ReadonlyArray<PromiseOrDirect<ExecutionResultValue<TData>>>;
+export type GrafastResultStreamList<TStreamItem> = ReadonlyArray<PromiseOrDirect<AsyncIterable<PromiseOrDirect<ExecutionResultValue<TStreamItem>>>> | PromiseLike<never>>;
+export type AwaitedExecutionResults<TData> = ReadonlyArray<PromiseOrDirect<ExecutionResultValue<TData> | AsyncIterable<PromiseOrDirect<ExecutionResultValue<TData extends ReadonlyArray<infer UStreamItem> ? UStreamItem : never>>>>>;
+export type ExecutionResults<TData> = PromiseOrDirect<AwaitedExecutionResults<TData>> | PromiseLike<never>;
 export type BaseGraphQLRootValue = any;
 export interface BaseGraphQLVariables {
     [key: string]: unknown;
@@ -151,17 +157,27 @@ export interface BaseGraphQLArguments {
     [key: string]: any;
 }
 export type BaseGraphQLInputObject = BaseGraphQLArguments;
-export type TargetStepOrCallback = ExecutableStep | ModifierStep | ((indexOrFieldName: number | string) => TargetStepOrCallback);
 export type FieldArgs = {
-    /** Gets the value, evaluating the `inputPlan` at each field if appropriate */
-    get(path?: string | ReadonlyArray<string | number>): ExecutableStep;
-    /** Gets the value *without* calling any `inputPlan`s */
-    getRaw(path?: string | ReadonlyArray<string | number>): AnyInputStep;
+    /** @deprecated Use bakedInput() step instead. */
+    get?: never;
+    getRaw(path?: string | ReadonlyArray<string | number>): AnyInputStep | ObjectStep<{
+        [argName: string]: AnyInputStep;
+    }>;
+    typeAt(path: string | ReadonlyArray<string | number>): GraphQLInputType;
     /** This also works (without path) to apply each list entry against $target */
-    apply($target: ExecutableStep | ModifierStep | (() => ModifierStep), path?: string | ReadonlyArray<string | number>): void;
+    apply<TArg extends object>($target: ApplyableExecutableStep<TArg>, path?: string | ReadonlyArray<string | number>, getTargetFromParent?: (parent: TArg, inputValue: any) => object | undefined): void;
+    apply<TArg extends object>($target: ApplyableExecutableStep<TArg>, getTargetFromParent: (parent: TArg, inputValue: any) => object | undefined, justTargetFromParent?: never): void;
 } & AnyInputStepDollars;
-export type InputStep<TInputType extends GraphQLInputType = GraphQLInputType> = GraphQLInputType extends TInputType ? AnyInputStep : TInputType extends GraphQLNonNull<infer U> ? Exclude<InputStep<U & GraphQLInputType>, ConstantStep<undefined>> : TInputType extends GraphQLList<GraphQLInputType> ? __InputListStep<TInputType> | __TrackedValueStep<any, TInputType> | ConstantStep<undefined> : TInputType extends GraphQLInputObjectType ? __TrackedValueStepWithDollars<any, TInputType> | __InputObjectStepWithDollars<TInputType> | ConstantStep<undefined> : AnyInputStep;
-export type AnyInputStep = __TrackedValueStepWithDollars<any, GraphQLInputType> | __InputListStep | __InputStaticLeafStep | __InputDynamicScalarStep | __InputObjectStepWithDollars<GraphQLInputObjectType> | ConstantStep<undefined>;
+export type FieldArg = {
+    /** @deprecated Use bakedInput() step instead. */
+    get?: never;
+    getRaw(path?: string | ReadonlyArray<string | number>): AnyInputStep;
+    typeAt(path: string | ReadonlyArray<string | number>): GraphQLInputType;
+    /** This also works (without path) to apply each list entry against $target */
+    apply<TArg extends object>($target: ApplyableExecutableStep<TArg>, path?: string | ReadonlyArray<string | number>, getTargetFromParent?: (parent: TArg, inputValue: any) => object | undefined): void;
+    apply<TArg extends object>($target: ApplyableExecutableStep<TArg>, getTargetFromParent: (parent: TArg, inputValue: any) => object | undefined, justTargetFromParent?: never): void;
+};
+export type AnyInputStep = __TrackedValueStepWithDollars<any, GraphQLInputType> | __InputListStep | __InputStaticLeafStep | __InputDynamicScalarStep | __InputObjectStepWithDollars<GraphQLInputObjectType> | __InputDefaultStep | ConstantStep<any>;
 export type AnyInputStepWithDollars = AnyInputStep & AnyInputStepDollars;
 /**
  * Lies to make it easier to write TypeScript code like
@@ -172,6 +188,7 @@ export type AnyInputStepDollars = {
     [key in string as `$${key}`]: AnyInputStepWithDollars;
 };
 export interface FieldInfo {
+    fieldName: string;
     field: GraphQLField<any, any, any>;
     schema: GraphQLSchema;
 }
@@ -192,52 +209,36 @@ export interface FieldInfo {
  * We're using `TrackedObject<...>` so we can later consider caching these
  * executions.
  */
-export type FieldPlanResolver<_TArgs extends BaseGraphQLArguments, TParentStep extends ExecutableStep | null, TResultStep extends ExecutableStep> = ($parentPlan: TParentStep, args: FieldArgs, info: FieldInfo) => TResultStep | null;
-/**
- * Fields on input objects can have plans; the plan resolver is passed a parent plan
- * (from an argument, or from a parent input object) or null if none, and an
- * input plan that represents the value the user will pass to this field. The
- * resolver must return either a ModifierStep or null.
- */
-export type InputObjectFieldInputPlanResolver<TResultStep extends ExecutableStep = ExecutableStep> = (input: FieldArgs, info: {
+export type FieldPlanResolver<_TArgs extends BaseGraphQLArguments, TParentStep extends Step | null, TResultStep extends Step | null> = ($parentPlan: TParentStep, args: FieldArgs, info: FieldInfo) => TResultStep;
+export type InputObjectFieldApplyResolver<TParent> = (target: TParent, input: any, // Don't use unknown here, otherwise users can't easily cast it
+info: {
     schema: GraphQLSchema;
-    entity: GraphQLInputField;
-}) => TResultStep;
-export type InputObjectFieldApplyPlanResolver<TFieldStep extends ExecutableStep | ModifierStep<any> = ExecutableStep | ModifierStep<any>, TResultStep extends ModifierStep<ExecutableStep | ModifierStep<any>> | null | void = ModifierStep<ExecutableStep | ModifierStep<any>> | null | void> = ($fieldPlan: TFieldStep, input: FieldArgs, info: {
-    schema: GraphQLSchema;
-    entity: GraphQLInputField;
-}) => TResultStep;
-export type InputObjectTypeInputPlanResolver = (input: FieldArgs, info: {
+    fieldName: string;
+    field: GraphQLInputField;
+}) => any;
+export type InputObjectTypeBakedInfo = {
     schema: GraphQLSchema;
     type: GraphQLInputObjectType;
-}) => ExecutableStep;
-/**
- * Arguments can have plans; the plan resolver is passed the parent plan (the
- * plan that represents the _parent_ field of the field the arg is defined on),
- * the field plan (the plan that represents the field the arg is defined on)
- * and an input plan that represents the value the user will pass to this
- * argument. The resolver must return either a ModifierStep or null.
- */
-export type ArgumentInputPlanResolver<TParentStep extends ExecutableStep = ExecutableStep, TResultStep extends ExecutableStep = ExecutableStep> = ($parentPlan: TParentStep, input: FieldArgs, info: {
-    schema: GraphQLSchema;
-    entity: GraphQLArgument;
-}) => TResultStep;
-export type ArgumentApplyPlanResolver<TParentStep extends ExecutableStep = ExecutableStep, TFieldStep extends ExecutableStep | ModifierStep<any> = ExecutableStep | ModifierStep<any>, TResultStep extends ExecutableStep | ModifierStep<ExecutableStep | ModifierStep> | null | void = ExecutableStep | ModifierStep<ExecutableStep | ModifierStep> | null | void> = ($parentPlan: TParentStep, $fieldPlan: TFieldStep, input: FieldArgs, info: {
+    applyChildren(val: any): void;
+};
+export type InputObjectTypeBakedResolver = (input: Record<string, any>, info: InputObjectTypeBakedInfo) => any;
+export type ArgumentApplyPlanResolver<TParentStep extends Step = Step, TFieldStep extends Step = Step> = ($parentPlan: TParentStep, $fieldPlan: TFieldStep, input: FieldArg, info: {
     schema: GraphQLSchema;
-    entity: GraphQLArgument;
-}) => TResultStep;
+    arg: GraphQLArgument;
+    argName: string;
+}) => void;
 /**
  * GraphQLScalarTypes can have plans, these are passed the field plan and must
  * return an executable plan.
  */
-export type ScalarPlanResolver<TParentStep extends ExecutableStep = ExecutableStep, TResultStep extends ExecutableStep = ExecutableStep> = ($parentPlan: TParentStep, info: {
+export type ScalarPlanResolver<TParentStep extends Step = Step, TResultStep extends Step = Step> = ($parentPlan: TParentStep, info: {
     schema: GraphQLSchema;
 }) => TResultStep;
 /**
  * GraphQLScalarTypes can have plans, these are passed the field plan and must
  * return an executable plan.
  */
-export type ScalarInputPlanResolver<TResultStep extends ExecutableStep = ExecutableStep> = ($inputValue: InputStep, info: {
+export type ScalarInputPlanResolver<TResultStep extends Step = Step> = ($inputValue: AnyInputStep, info: {
     schema: GraphQLSchema;
     type: GraphQLScalarType;
 }) => TResultStep;
@@ -250,48 +251,46 @@ export type ScalarInputPlanResolver<TResultStep extends ExecutableStep = Executa
  *
  * @experimental
  */
-export type EnumValueApplyPlanResolver<TParentStep extends ExecutableStep | ModifierStep = ExecutableStep | ModifierStep> = ($parent: TParentStep) => ModifierStep | void;
-type OutputPlanForNamedType<TType extends GraphQLType> = TType extends GrafastObjectType<any, infer TStep, any> ? TStep : ExecutableStep;
-export type OutputPlanForType<TType extends GraphQLOutputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLList<infer U> ? ListCapableStep<any, OutputPlanForNamedType<U>> | ExecutableStep<ReadonlyArray<any>> : TType extends GraphQLNonNull<infer U> ? OutputPlanForNamedType<U> : OutputPlanForNamedType<TType>;
-type InputPlanForNamedType<TType extends GraphQLType> = TType extends GrafastInputObjectType<any, infer U, any> ? U : ModifierStep<any>;
-type InputPlanForType<TType extends GraphQLInputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? InputPlanForNamedType<U> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? InputPlanForNamedType<U> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? InputPlanForNamedType<U> : TType extends GraphQLList<infer U> ? InputPlanForNamedType<U> : TType extends GraphQLNonNull<infer U> ? InputPlanForNamedType<U> : InputPlanForNamedType<TType>;
-type InputTypeForNamedType<TType extends GraphQLType> = TType extends GraphQLScalarType<infer U> ? U : any;
-type InputTypeFor<TType extends GraphQLInputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? InputTypeForNamedType<U> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? InputTypeForNamedType<U> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? InputTypeForNamedType<U> : TType extends GraphQLList<infer U> ? InputTypeForNamedType<U> : TType extends GraphQLNonNull<infer U> ? InputTypeForNamedType<U> : InputTypeForNamedType<TType>;
+export type EnumValueApplyResolver<TParent = any> = (parent: TParent) => void;
+type OutputPlanForNamedType<TType extends GraphQLType> = TType extends GrafastObjectType<infer TStep, any> ? TStep : Step;
+export type OutputPlanForType<TType extends GraphQLOutputType> = TType extends GraphQLNonNull<GraphQLList<GraphQLNonNull<infer U>>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | Step<ReadonlyArray<any>> : TType extends GraphQLNonNull<GraphQLList<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | Step<ReadonlyArray<any>> : TType extends GraphQLList<GraphQLNonNull<infer U>> ? ListCapableStep<any, OutputPlanForNamedType<U>> | Step<ReadonlyArray<any>> : TType extends GraphQLList<infer U> ? ListCapableStep<any, OutputPlanForNamedType<U>> | Step<ReadonlyArray<any>> : TType extends GraphQLNonNull<infer U> ? OutputPlanForNamedType<U> : OutputPlanForNamedType<TType>;
 /**
  * Basically GraphQLFieldConfig but with an easy to access `plan` method.
  */
-export type GrafastFieldConfig<TType extends GraphQLOutputType, TContext extends Grafast.Context, TParentStep extends ExecutableStep | null, TFieldStep extends ExecutableStep, // TODO: should be OutputPlanForType<TType>, but that results in everything thinking it should be a ListStep
+export type GrafastFieldConfig<TType extends GraphQLOutputType, TParentStep extends Step | null, TFieldStep extends Step, // TODO: should be OutputPlanForType<TType>, but that results in everything thinking it should be a ListStep
 TArgs extends BaseGraphQLArguments> = Omit<GraphQLFieldConfig<any, any>, "args" | "type"> & {
     type: TType;
     plan?: FieldPlanResolver<TArgs, TParentStep, TFieldStep>;
     subscribePlan?: FieldPlanResolver<TArgs, TParentStep, TFieldStep>;
-    args?: GrafastFieldConfigArgumentMap<TType, TContext, TParentStep, TFieldStep>;
+    args?: GrafastFieldConfigArgumentMap;
 };
 /**
  * Basically GraphQLFieldConfigArgumentMap but allowing for args to have plans.
  */
-export type GrafastFieldConfigArgumentMap<_TType extends GraphQLOutputType, TContext extends Grafast.Context, TParentStep extends ExecutableStep | null, TFieldStep extends ExecutableStep> = {
-    [argName: string]: GrafastArgumentConfig<any, TContext, TParentStep, TFieldStep, any, any>;
+export type GrafastFieldConfigArgumentMap = {
+    [argName: string]: GrafastArgumentConfig;
 };
 /**
  * Basically GraphQLArgumentConfig but allowing for a plan.
  */
-export type GrafastArgumentConfig<TInputType extends GraphQLInputType = GraphQLInputType, _TContext extends Grafast.Context = Grafast.Context, _TParentStep extends ExecutableStep | null = ExecutableStep | null, TFieldStep extends ExecutableStep = ExecutableStep, _TArgumentStep extends TFieldStep extends ExecutableStep ? ModifierStep<TFieldStep> | null : null = TFieldStep extends ExecutableStep ? ModifierStep<TFieldStep> | null : null, _TInput extends InputTypeFor<TInputType> = InputTypeFor<TInputType>> = Omit<GraphQLArgumentConfig, "type"> & {
+export type GrafastArgumentConfig<TInputType extends GraphQLInputType = GraphQLInputType, _TContext extends Grafast.Context = Grafast.Context, _TParentStep extends Step | null = Step | null> = Omit<GraphQLArgumentConfig, "type"> & {
     type: TInputType;
-    inputPlan?: ArgumentInputPlanResolver<any>;
     applyPlan?: ArgumentApplyPlanResolver<any, any>;
-    autoApplyAfterParentPlan?: boolean;
-    autoApplyAfterParentSubscribePlan?: boolean;
+    applySubscribePlan?: ArgumentApplyPlanResolver<any, any>;
+    inputPlan?: never;
+    autoApplyAfterParentPlan?: never;
+    autoApplyAfterParentSubscribePlan?: never;
 };
 /**
  * Basically GraphQLInputFieldConfig but allowing for the field to have a plan.
  */
-export type GrafastInputFieldConfig<TInputType extends GraphQLInputType, _TContext extends Grafast.Context, _TParentStep extends ModifierStep<any>, _TResultStep extends InputPlanForType<TInputType>, _TInput extends InputTypeFor<TInputType>> = Omit<GraphQLInputFieldConfig, "type"> & {
+export type GrafastInputFieldConfig<TParent = any, TInputType extends GraphQLInputType = GraphQLInputType> = Omit<GraphQLInputFieldConfig, "type"> & {
     type: TInputType;
-    inputPlan?: InputObjectFieldInputPlanResolver;
-    applyPlan?: InputObjectFieldApplyPlanResolver<any>;
-    autoApplyAfterParentInputPlan?: boolean;
-    autoApplyAfterParentApplyPlan?: boolean;
+    apply?: InputObjectFieldApplyResolver<TParent>;
+    inputPlan?: never;
+    applyPlan?: never;
+    autoApplyAfterParentInputPlan?: never;
+    autoApplyAfterParentApplyPlan?: never;
 };
 /**
  * The args passed to a field plan resolver, the values are plans.
@@ -302,8 +301,7 @@ export type TrackedArguments<TArgs extends BaseGraphQLArguments = BaseGraphQLArg
 /**
  * `@stream` directive meta.
  */
-export interface StepStreamOptions {
-    initialCount: number;
+export interface StepStreamOptions extends LayerPlanReasonListItemStream {
 }
 /**
  * Additional details about the planning for a field; currently only relates to
@@ -314,12 +312,23 @@ export interface StepOptions {
      * Details for the `@stream` directive.
      */
     stream: StepStreamOptions | null;
+    /**
+     * Should we walk an iterable if presented. This is important because we
+     * don't want to walk things like Map/Set except if we're doing it as part of
+     * a list step.
+     */
+    walkIterable: boolean;
 }
 /**
  * Options passed to the `optimize` method of a plan to give more context.
  */
 export interface StepOptimizeOptions {
-    stream: StepStreamOptions | null;
+    /**
+     * If null, this step will not stream. If non-null, this step _might_ stream,
+     * but it's not guaranteed - it may be dependent on user variables, e.g. the
+     * `if` parameter.
+     */
+    stream: null | {};
     meta: Record<string, unknown> | undefined;
 }
 /**
@@ -348,7 +357,7 @@ export interface NodeIdCodec<T = any> {
  * Determines if a NodeID relates to a given object type, and also relates to
  * encoding the NodeID for that type.
  */
-export type NodeIdHandler<TCodec extends NodeIdCodec<any> = NodeIdCodec<any>, TNodeStep extends ExecutableStep = ExecutableStep, TSpec = any> = {
+export type NodeIdHandler<TIdentifiers extends readonly any[] = readonly any[], TCodec extends NodeIdCodec<any> = NodeIdCodec<any>, TNodeStep extends Step = Step, TSpec = any> = {
     /**
      * The name of the object type this handler is for.
      */
@@ -361,11 +370,16 @@ export type NodeIdHandler<TCodec extends NodeIdCodec<any> = NodeIdCodec<any>, TN
      * Returns true if the given decoded Node ID value represents this type.
      */
     match(specifier: TCodec extends NodeIdCodec<infer U> ? U : any): boolean;
+    /**
+     * Returns the underlying identifiers extracted from the decoded NodeID
+     * value.
+     */
+    getIdentifiers(value: TCodec extends NodeIdCodec<infer U> ? U : any): TIdentifiers;
     /**
      * Returns a plan that returns the value ready to be encoded. When the result
      * of this plan is fed into `match`, it should return `true`.
      */
-    plan($thing: TNodeStep): ExecutableStep<TCodec extends NodeIdCodec<infer U> ? U : any>;
+    plan($thing: TNodeStep): Step<TCodec extends NodeIdCodec<infer U> ? U : any>;
     /**
      * Returns a specification based on the Node ID, this can be in any format
      * you like. It is intended to then be fed into `get` or handled in your own
@@ -373,7 +387,7 @@ export type NodeIdHandler<TCodec extends NodeIdCodec<any> = NodeIdCodec<any>, TN
      * referencing a node without actually fetching it - e.g. allowing you to
      * delete a node by its ID without first fetching it.)
      */
-    getSpec(plan: ExecutableStep<TCodec extends NodeIdCodec<infer U> ? U : any>): TSpec;
+    getSpec(plan: Step<TCodec extends NodeIdCodec<infer U> ? U : any>): TSpec;
     /**
      * Combined with `getSpec`, this forms the recprocal of `plan`; i.e.
      * `get(getSpec( plan(node) ))` should return a plan that results in the
@@ -416,6 +430,7 @@ export interface ExecutionExtraBase {
 export interface ExecutionExtra extends ExecutionExtraBase {
 }
 export interface UnbatchedExecutionExtra extends ExecutionExtraBase {
+    stream: ExecutionDetailsStream | null;
 }
 /**
  * A bitwise number representing a number of flags:
@@ -447,19 +462,26 @@ export type ExecutionValue<TData = any> = BatchExecutionValue<TData> | UnaryExec
 interface ExecutionValueBase<TData = any> {
     at(i: number): TData;
     isBatch: boolean;
+    /** Returns this.value for a unary execution value; throws if non-unary */
+    unaryValue(): TData;
 }
 export interface BatchExecutionValue<TData = any> extends ExecutionValueBase<TData> {
     isBatch: true;
     entries: ReadonlyArray<TData>;
-    value?: never;
+    /** Always throws, since this should only be called on unary execution values */
+    unaryValue(): never;
 }
 export interface UnaryExecutionValue<TData = any> extends ExecutionValueBase<TData> {
     isBatch: false;
     value: TData;
-    entries?: never;
+    /** Same as getting .value */
+    unaryValue(): TData;
 }
 export type IndexMap = <T>(callback: (i: number) => T) => ReadonlyArray<T>;
 export type IndexForEach = (callback: (i: number) => any) => void;
+export interface ExecutionDetailsStream {
+    initialCount: number;
+}
 export interface ExecutionDetails<TDeps extends readonly [...any[]] = readonly [...any[]]> {
     count: number;
     indexMap: IndexMap;
@@ -471,9 +493,7 @@ export interface ExecutionDetails<TDeps extends readonly [...any[]] = readonly [
         map: ReadonlyArray<ExecutionValue<TDeps[number]>>["map"];
     };
     extra: ExecutionExtra;
-}
-export interface StreamDetails<TDeps extends readonly [...any[]] = readonly [...any[]]> extends ExecutionDetails<TDeps> {
-    streamOptions: StepStreamOptions;
+    stream: ExecutionDetailsStream | null;
 }
 export interface LocationDetails {
     node: ASTNode | readonly ASTNode[];
@@ -482,8 +502,8 @@ export interface LocationDetails {
     /** This should only be null for the root selection */
     fieldName: string | null;
 }
-export type UnwrapPlanTuple</* const */ TIn extends readonly ExecutableStep[]> = {
-    [Index in keyof TIn]: TIn[Index] extends ExecutableStep<infer U> ? U : never;
+export type UnwrapPlanTuple</* const */ TIn extends readonly Step[]> = {
+    [Index in keyof TIn]: DataFromStep<TIn[Index]>;
 };
 export type NotVariableValueNode = Exclude<ValueNode, VariableNode>;
 export type StreamMaybeMoreableArray<T = any> = Array<T> & {
@@ -499,14 +519,20 @@ export interface GrafastArgs extends GraphQLArgs {
 }
 export type Maybe<T> = T | null | undefined;
 export * from "./planJSONInterfaces.js";
-export interface AddDependencyOptions {
-    step: ExecutableStep;
+export interface AddDependencyOptions<TStep extends Step = Step> {
+    step: TStep;
     skipDeduplication?: boolean;
     /** @defaultValue `FLAG_NULL` */
     acceptFlags?: ExecutionEntryFlags;
-    onReject?: null | Error | undefined;
+    onReject?: Maybe<Error>;
+    nonUnaryMessage?: ($dependent: Step, $dependency: Step) => string;
 }
-export type DataFromStep<TStep extends ExecutableStep> = TStep extends ExecutableStep<infer TData> ? TData : never;
+export interface DependencyOptions<TStep extends Step = Step> {
+    step: TStep;
+    acceptFlags: ExecutionEntryFlags;
+    onReject: Maybe<Error>;
+}
+export type DataFromStep<TStep extends Step> = TStep extends Step<infer TData> ? TData : never;
 export interface GrafastExecutionArgs extends ExecutionArgs {
     resolvedPreset?: GraphileConfig.ResolvedPreset;
     middleware?: Middleware<GraphileConfig.GrafastMiddleware> | null;
@@ -543,12 +569,7 @@ export interface EstablishOperationPlanEvent {
 }
 export interface ExecuteStepEvent {
     args: GrafastExecutionArgs;
-    step: ExecutableStep;
+    step: Step;
     executeDetails: ExecutionDetails;
 }
-export interface StreamStepEvent {
-    args: GrafastExecutionArgs;
-    step: StreamableStep<unknown>;
-    streamDetails: StreamDetails;
-}
 //# sourceMappingURL=interfaces.d.ts.map