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

package/dist/step.js

@@ -1,7 +1,16 @@
 "use strict";
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertListCapableStep = exports.isListCapableStep = exports.assertModifierStep = exports.isModifierStep = exports.ModifierStep = exports.isPolymorphicStep = exports.isStreamableStep = exports.isListLikeStep = exports.isObjectLikeStep = exports.isUnbatchedExecutableStep = exports.assertExecutableStep = exports.isExecutableStep = exports.UnbatchedExecutableStep = exports.ExecutableStep = exports.BaseStep = exports.assertFinalized = exports.$$noExec = void 0;
+exports.isExecutableStep = exports.UnbatchedExecutableStep = exports.ExecutableStep = exports.UnbatchedStep = exports.Step = exports.assertFinalized = exports.$$noExec = void 0;
+exports.isStep = isStep;
+exports.assertStep = assertStep;
+exports.isUnbatchedStep = isUnbatchedStep;
+exports.isObjectLikeStep = isObjectLikeStep;
+exports.isListLikeStep = isListLikeStep;
+exports.isPolymorphicStep = isPolymorphicStep;
+exports.isListCapableStep = isListCapableStep;
+exports.assertListCapableStep = assertListCapableStep;
+exports.assertExecutableStep = assertExecutableStep;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
@@ -41,66 +50,21 @@ function reallyAssertFinalized(plan) {
 }
 // Optimise this away in production.
 exports.assertFinalized = !dev_js_1.isDev ? dev_js_1.noop : reallyAssertFinalized;
-/**
- * The base abstract plan type; you should not extend this directly - instead
- * use an ExecutableStep (for use when planning output fields) or a
- * ModifierStep (for use when planning arguments/input fields).
- *
- * @remarks
- *
- * Though it might seem that ModifierStep should be used for all inputs
- * (arguments, input objects), this is not the case. When planning an output
- * field, all inputs to it (including arguments, parent plan, context, etc)
- * should be other executable plans. The only time that ModifierStep is used is
- * when writing specific plans as part of the argument or input field
- * definitions themself; even in these cases the inputs to these plan resolvers
- * will be ExecutablePlans.
- */
-class BaseStep {
-    static { _a = interfaces_js_1.$$subroutine; }
-    constructor() {
-        this[_a] = null;
-        this.isArgumentsFinalized = false;
-        this.isFinalized = false;
-        this.debug = (0, global_js_1.getDebug)();
-        const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
-        this.layerPlan = layerPlan;
-        this.operationPlan = layerPlan.operationPlan;
-        this._isUnary = true;
-        this._isUnaryLocked = false;
-    }
-    toString() {
-        const meta = this.toStringMeta();
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}`);
-    }
-    /**
-     * This metadata will be merged into toString when referencing this plan.
-     */
-    toStringMeta() {
-        return null;
-    }
-    planJSONExtra() {
-        return undefined;
-    }
-    finalize() {
-        if (!this.isFinalized) {
-            this.isFinalized = true;
-        }
-        else {
-            throw new Error(`Step ${this} has already been finalized - do not call \`finalize()\` from user code!`);
-        }
-    }
-    destroy() { }
-}
-exports.BaseStep = BaseStep;
 /**
  * Executable plans are the plans associated with leaves on the GraphQL tree,
  * they must be able to execute to return values.
  */
-class ExecutableStep extends BaseStep {
-    static { _b = lock_js_1.$$unlock; }
+class Step {
+    static { _a = interfaces_js_1.$$subroutine, _b = lock_js_1.$$unlock; }
     constructor() {
-        super();
+        this[_a] = null;
+        /**
+         * For input values, set `true` if it comes from variables/arguments since
+         * they cannot be modified (even by mutations), set `false` otherwise.
+         *
+         * @internal
+         */
+        this._isImmutable = false;
         /** @internal */
         this[_b] = undefined;
         /**
@@ -119,6 +83,14 @@ class ExecutableStep extends BaseStep {
          * @experimental
          */
         this.peerKey = null;
+        this.isArgumentsFinalized = false;
+        this.isFinalized = false;
+        this.debug = (0, global_js_1.getDebug)();
+        const layerPlan = (0, withGlobalLayerPlan_js_1.currentLayerPlan)();
+        this.layerPlan = layerPlan;
+        this.operationPlan = layerPlan.operationPlan;
+        this._isUnary = true;
+        this._isUnaryLocked = false;
         this.implicitSideEffectStep = null;
         this.hasSideEffects ??= false;
         let hasSideEffects = false;
@@ -177,15 +149,28 @@ class ExecutableStep extends BaseStep {
         this.dependents = [];
         this.isOptimized = false;
         this.allowMultipleOptimizations = false;
-        this._stepOptions = { stream: null };
+        this._stepOptions = { stream: null, walkIterable: false };
         this.store = true;
         this.polymorphicPaths = (0, withGlobalLayerPlan_js_1.currentPolymorphicPaths)();
         // Important: MUST come after `this.layerPlan = ...`
         this.id = this.layerPlan._addStep(this);
     }
+    /**
+     * Generally you should only use this once the dependencies of a step are
+     * established, if you use it beforehand and it returns `true` then adding a
+     * non-unary dependency later will result in an error.
+     */
+    getAndFreezeIsUnary() {
+        this._isUnaryLocked = true;
+        return this._isUnary;
+    }
     withMyLayerPlan(callback) {
         return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, callback);
     }
+    /** @experimental */
+    withLayerPlan(callback) {
+        return (0, withGlobalLayerPlan_js_1.withGlobalLayerPlan)(this.layerPlan, this.polymorphicPaths, callback);
+    }
     getStep(id) {
         return this.layerPlan.getStep(id, this);
     }
@@ -196,12 +181,25 @@ class ExecutableStep extends BaseStep {
         const acceptFlags = interfaces_js_1.ALL_FLAGS & ~forbiddenFlags;
         return { step, acceptFlags, onReject };
     }
-    getDep(_depId) {
+    getDep(_depId, _throwOnFlagged = false) {
         // This gets replaced when `__FlagStep` is loaded. Were we on ESM we could
         // just put the code here, but since we're not we have to avoid the
         // circular dependency.
         throw new Error(`Grafast failed to load correctly`);
     }
+    maybeGetDep(depId, throwOnFlagged = false) {
+        return depId == null
+            ? null
+            : throwOnFlagged
+                ? this.getDep(depId, true)
+                : this.getDep(depId);
+    }
+    getDepOrConstant(_depId, _fallback) {
+        // This gets replaced when `constant` is loaded. Were we on ESM we could
+        // just put the code here, but since we're not we have to avoid the
+        // circular dependency.
+        throw new Error(`Grafast failed to load correctly`);
+    }
     /**
      * Like getDep, except it skips over __ItemStep and similar steps to get to
      * where the parent really is.
@@ -237,15 +235,22 @@ class ExecutableStep extends BaseStep {
         catch (e) {
             // Ignore
         }
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${this.layerPlan.id === 0 ? "" : chalk_1.default.grey(`{${this.layerPlan.id}}`)}${this._isUnary ? "➊" : ""}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, {
-            colors: true,
-        })}]`);
+        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${this.layerPlan.id === 0 ? "" : chalk_1.default.grey(`{${this.layerPlan.id}}`)}${this._isUnary ? "➊" : ""}${this._stepOptions.stream != null ? "@s" : ""}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, { colors: true })}]`);
+    }
+    /**
+     * This metadata will be merged into toString when referencing this plan.
+     */
+    toStringMeta() {
+        return null;
+    }
+    planJSONExtra() {
+        return undefined;
     }
     canAddDependency(step) {
         return (0, utils_js_1.stepAMayDependOnStepB)(this, step);
     }
     addDependency(stepOrOptions) {
-        const options = stepOrOptions instanceof ExecutableStep
+        const options = stepOrOptions instanceof Step
             ? { step: stepOrOptions, skipDeduplication: false }
             : stepOrOptions;
         if (options.step.layerPlan.id > this.layerPlan.id) {
@@ -260,9 +265,7 @@ class ExecutableStep extends BaseStep {
      * directly.
      */
     addUnaryDependency(stepOrOptions) {
-        const options = stepOrOptions instanceof ExecutableStep
-            ? { step: stepOrOptions }
-            : stepOrOptions;
+        const options = stepOrOptions instanceof Step ? { step: stepOrOptions } : stepOrOptions;
         if (options.step.layerPlan.id > this.layerPlan.id) {
             throw new Error(`Cannot add dependency ${options.step} to ${this} since the former is in a deeper layerPlan (creates a catch-22)`);
         }
@@ -286,7 +289,12 @@ class ExecutableStep extends BaseStep {
             this.execute.constructor.name === "AsyncFunction") {
             throw new Error(`${this} claims to be synchronous, however the execute method is asynchronous`);
         }
-        super.finalize();
+        if (!this.isFinalized) {
+            this.isFinalized = true;
+        }
+        else {
+            throw new Error(`Step ${this} has already been finalized - do not call \`finalize()\` from user code!`);
+        }
     }
     /**
      * This function will be called with 'execution details', an object containing:
@@ -329,10 +337,10 @@ class ExecutableStep extends BaseStep {
         this.optimize = throwDestroyed;
         this.finalize = throwDestroyed;
         this.execute = throwDestroyed;
-        super.destroy();
     }
 }
-exports.ExecutableStep = ExecutableStep;
+exports.Step = Step;
+exports.ExecutableStep = Step;
 function _buildOptimizedExecuteV2Expression(depCount, isSyncAndSafe) {
     const identifiers = [];
     for (let i = 0; i < depCount; i++) {
@@ -396,13 +404,13 @@ function buildOptimizedExecute(depCount, isSyncAndSafe, callback) {
         callback(fn);
     });
 }
-class UnbatchedExecutableStep extends ExecutableStep {
+class UnbatchedStep extends Step {
     static { this.$$export = {
         moduleName: "grafast",
-        exportName: "UnbatchedExecutableStep",
+        exportName: "UnbatchedStep",
     }; }
     finalize() {
-        if (this.execute === UnbatchedExecutableStep.prototype.execute) {
+        if (this.execute === UnbatchedStep.prototype.execute) {
             // If they've not replaced 'execute', use our optimized form
             buildOptimizedExecute(this.dependencies.length, this.isSyncAndSafe, (fn) => {
                 this.execute = fn;
@@ -412,9 +420,13 @@ class UnbatchedExecutableStep extends ExecutableStep {
     }
     execute({ indexMap, values, extra, }) {
         console.warn(`${this} didn't call 'super.finalize()' in the finalize method.`);
+        const depCount = this.dependencies.length;
         return indexMap((i) => {
             try {
-                const tuple = values.map((list) => list.at(i));
+                const tuple = [];
+                for (let j = 0; j < depCount; j++) {
+                    tuple[j] = values[j].at(i);
+                }
                 return this.unbatchedExecute(extra, ...tuple);
             }
             catch (e) {
@@ -423,81 +435,41 @@ class UnbatchedExecutableStep extends ExecutableStep {
         });
     }
 }
-exports.UnbatchedExecutableStep = UnbatchedExecutableStep;
-function isExecutableStep(step) {
-    return (step instanceof BaseStep &&
-        "execute" in step &&
-        typeof step.execute === "function");
+exports.UnbatchedStep = UnbatchedStep;
+exports.UnbatchedExecutableStep = UnbatchedStep;
+function isStep(step) {
+    return step instanceof Step;
 }
-exports.isExecutableStep = isExecutableStep;
-function assertExecutableStep(step) {
-    if (!isExecutableStep(step)) {
-        throw new Error(`Expected an executable step, but received something else: ${(0, inspect_js_1.inspect)(step)}`);
+function assertStep(step) {
+    if (!isStep(step)) {
+        throw new Error(`Expected a step, but received something else: ${(0, inspect_js_1.inspect)(step)}`);
     }
 }
-exports.assertExecutableStep = assertExecutableStep;
-function isUnbatchedExecutableStep(step) {
-    return (isExecutableStep(step) &&
-        typeof step.unbatchedExecute === "function");
+function isUnbatchedStep(step) {
+    return isStep(step) && typeof step.unbatchedExecute === "function";
 }
-exports.isUnbatchedExecutableStep = isUnbatchedExecutableStep;
 function isObjectLikeStep(plan) {
     return "get" in plan && typeof plan.get === "function";
 }
-exports.isObjectLikeStep = isObjectLikeStep;
 function isListLikeStep(plan) {
     return "at" in plan && typeof plan.at === "function";
 }
-exports.isListLikeStep = isListLikeStep;
-function isStreamableStep(plan) {
-    return typeof plan.stream === "function";
-}
-exports.isStreamableStep = isStreamableStep;
 function isPolymorphicStep(s) {
     return ("planForType" in s &&
         typeof s.planForType === "function");
 }
-exports.isPolymorphicStep = isPolymorphicStep;
-/**
- * Modifier plans modify their parent plan (which may be another ModifierStep
- * or an ExecutableStep). First they gather all the requirements from their
- * children (if any) being applied to them, then they apply themselves to their
- * parent plan. This application is done through the `apply()` method.
- *
- * Modifier plans do not use dependencies.
- */
-class ModifierStep extends BaseStep {
-    constructor($parent) {
-        super();
-        this.$parent = $parent;
-        this.id = this.layerPlan._addModifierStep(this);
-    }
-    toString() {
-        const meta = this.toStringMeta();
-        return chalk_1.default.bold.blue(`${this.constructor.name.replace(/Step$/, "")}${meta != null && meta.length ? chalk_1.default.grey(`<${meta}>`) : ""}[${(0, inspect_js_1.inspect)(this.id, {
-            colors: true,
-        })}]`);
-    }
-}
-exports.ModifierStep = ModifierStep;
-function isModifierStep(plan) {
-    return "apply" in plan && typeof plan.apply === "function";
-}
-exports.isModifierStep = isModifierStep;
-function assertModifierStep(plan, pathDescription) {
-    if (!isModifierStep(plan)) {
-        throw new Error(`The plan returned from '${pathDescription}' should be a modifier plan, but it does not implement the 'apply' method.`);
-    }
-}
-exports.assertModifierStep = assertModifierStep;
 function isListCapableStep(plan) {
     return "listItem" in plan && typeof plan.listItem === "function";
 }
-exports.isListCapableStep = isListCapableStep;
 function assertListCapableStep(plan, pathDescription) {
     if (!isListCapableStep(plan)) {
         throw new Error(`The plan returned from '${pathDescription}' should be a list capable plan, but ${plan} does not implement the 'listItem' method.`);
     }
 }
-exports.assertListCapableStep = assertListCapableStep;
+/** @deprecated Use isStep instead */
+exports.isExecutableStep = isStep;
+/** @deprecated Use isStep instead */
+function assertExecutableStep(step) {
+    return assertStep(step);
+}
 //# sourceMappingURL=step.js.map

package/dist/steps/__flag.d.ts

@@ -1,7 +1,7 @@
-import type { ExecutionDetails, ExecutionEntryFlags, GrafastResultsList } from "../interfaces.js";
+import type { DataFromStep, ExecutionDetails, ExecutionEntryFlags, GrafastResultsList } from "../interfaces.js";
 import { $$deepDepSkip } from "../interfaces.js";
 import type { ListCapableStep } from "../step.js";
-import { ExecutableStep } from "../step.js";
+import { Step } from "../step.js";
 import type { __ItemStep } from "./__item.js";
 export declare const TRAP_ERROR: ExecutionEntryFlags;
 export declare const TRAP_INHIBITED: ExecutionEntryFlags;
@@ -14,11 +14,11 @@ export type ResolvedTrapValue = false | null | undefined | readonly never[];
 export interface FlagStepOptions {
     acceptFlags?: ExecutionEntryFlags;
     onReject?: Error | null;
-    if?: ExecutableStep<boolean>;
+    if?: Step<boolean>;
     valueForInhibited?: TrapValue;
     valueForError?: TrapValue;
 }
-export declare class __FlagStep<TData> extends ExecutableStep<TData> {
+export declare class __FlagStep<TStep extends Step> extends Step<DataFromStep<TStep>> {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -30,13 +30,13 @@ export declare class __FlagStep<TData> extends ExecutableStep<TData> {
     private valueForInhibited;
     private valueForError;
     private canBeInlined;
-    constructor(step: ExecutableStep, options: FlagStepOptions);
+    constructor(step: TStep, options: FlagStepOptions);
     toStringMeta(): string | null;
-    [$$deepDepSkip](): ExecutableStep;
-    listItem?: ($item: __ItemStep<ListCapableStep<unknown, ExecutableStep<unknown>>>) => ExecutableStep;
-    _listItem($item: __ItemStep<ListCapableStep<unknown, ExecutableStep<unknown>>>): ExecutableStep<unknown>;
-    deduplicate(_peers: readonly ExecutableStep<any>[]): readonly ExecutableStep<any>[];
-    execute(_details: ExecutionDetails<[data: TData, cond?: boolean]>): GrafastResultsList<TData>;
+    [$$deepDepSkip](): Step;
+    listItem?: ($item: __ItemStep<ListCapableStep<unknown, Step<unknown>>>) => Step;
+    _listItem($item: __ItemStep<ListCapableStep<unknown, Step<unknown>>>): Step<unknown>;
+    deduplicate(_peers: readonly Step<any>[]): readonly Step<any>[];
+    execute(_details: ExecutionDetails<[data: DataFromStep<TStep>, cond?: boolean]>): GrafastResultsList<DataFromStep<TStep>>;
     finalize(): void;
     private fancyExecute;
     private passThroughExecute;
@@ -45,21 +45,21 @@ export declare class __FlagStep<TData> extends ExecutableStep<TData> {
  * Example use case: get user by id, but id is null: no need to fetch the user
  * since we know they won't exist.
  */
-export declare function inhibitOnNull<T>($step: ExecutableStep<T>, options?: {
+export declare function inhibitOnNull<TStep extends Step>($step: TStep, options?: {
     if?: FlagStepOptions["if"];
-}): __FlagStep<T>;
+}): __FlagStep<TStep>;
 /**
  * Example use case: expecting a node ID that represents a User, but get one
  * that represents a Post instead: throw error to tell user they've sent invalid
  * data.
  */
-export declare function assertNotNull<T>($step: ExecutableStep<T>, message: string, options?: {
+export declare function assertNotNull<TStep extends Step>($step: TStep, message: string, options?: {
     if?: FlagStepOptions["if"];
-}): __FlagStep<T>;
-export declare function trap<T>($step: ExecutableStep<T>, acceptFlags: ExecutionEntryFlags, options?: {
+}): __FlagStep<TStep>;
+export declare function trap<TStep extends Step>($step: TStep, acceptFlags: ExecutionEntryFlags, options?: {
     valueForInhibited?: FlagStepOptions["valueForInhibited"];
     valueForError?: FlagStepOptions["valueForError"];
     if?: FlagStepOptions["if"];
-}): __FlagStep<T>;
+}): __FlagStep<TStep>;
 export {};
 //# sourceMappingURL=__flag.d.ts.map

package/dist/steps/__flag.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trap = exports.assertNotNull = exports.inhibitOnNull = exports.__FlagStep = exports.TRAP_ERROR_OR_INHIBITED = exports.TRAP_INHIBITED = exports.TRAP_ERROR = void 0;
+exports.__FlagStep = exports.TRAP_ERROR_OR_INHIBITED = exports.TRAP_INHIBITED = exports.TRAP_ERROR = void 0;
+exports.inhibitOnNull = inhibitOnNull;
+exports.assertNotNull = assertNotNull;
+exports.trap = trap;
 const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
 const interfaces_js_1 = require("../interfaces.js");
@@ -52,7 +55,7 @@ function resolveTrapValue(tv) {
         }
     }
 }
-class __FlagStep extends step_js_1.ExecutableStep {
+class __FlagStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__FlagStep",
@@ -223,7 +226,6 @@ function inhibitOnNull($step, options) {
         acceptFlags: interfaces_js_1.DEFAULT_ACCEPT_FLAGS & ~interfaces_js_1.FLAG_NULL,
     });
 }
-exports.inhibitOnNull = inhibitOnNull;
 /**
  * Example use case: expecting a node ID that represents a User, but get one
  * that represents a Post instead: throw error to tell user they've sent invalid
@@ -236,21 +238,22 @@ function assertNotNull($step, message, options) {
         onReject: new error_js_1.SafeError(message),
     });
 }
-exports.assertNotNull = assertNotNull;
 function trap($step, acceptFlags, options) {
     return new __FlagStep($step, {
         ...options,
         acceptFlags: (acceptFlags & interfaces_js_1.TRAPPABLE_FLAGS) | interfaces_js_1.FLAG_NULL,
     });
 }
-exports.trap = trap;
 // Have to overwrite the getDep method due to circular dependency
-step_js_1.ExecutableStep.prototype.getDep = function (depId) {
+step_js_1.Step.prototype.getDep = function (depId, throwOnFlagged = false) {
     const { step, acceptFlags, onReject } = this.getDepOptions(depId);
     if (acceptFlags === interfaces_js_1.DEFAULT_ACCEPT_FLAGS && onReject == null) {
         return step;
     }
     else {
+        if (throwOnFlagged) {
+            throw new Error(`When retrieving dependency ${step} of ${this}, the dependency is flagged as ${digestAcceptFlags(acceptFlags)}/onReject=${String(onReject)}. Please use \`this.getDepOptions(depId)\` instead, and handle the flags`);
+        }
         // Return a __FlagStep around options.step so that all the options are preserved.
         return new __FlagStep(step, { acceptFlags, onReject });
     }

package/dist/steps/__inputDefault.d.ts

@@ -0,0 +1,14 @@
+import type { UnbatchedExecutionExtra } from "../interfaces.js";
+import { UnbatchedStep } from "../step.js";
+import type { __TrackedValueStep } from "./__trackedValue.js";
+export declare class __InputDefaultStep extends UnbatchedStep {
+    private defaultValue;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    constructor($variableValue: __TrackedValueStep, defaultValue: unknown);
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, variableValue: unknown): unknown;
+}
+//# sourceMappingURL=__inputDefault.d.ts.map

package/dist/steps/__inputDefault.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__InputDefaultStep = void 0;
+const step_js_1 = require("../step.js");
+class __InputDefaultStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "__InputDefaultStep",
+    }; }
+    constructor($variableValue, defaultValue) {
+        super();
+        this.defaultValue = defaultValue;
+        this.isSyncAndSafe = true;
+        this.addUnaryDependency($variableValue);
+    }
+    unbatchedExecute(_extra, variableValue) {
+        return variableValue === undefined ? this.defaultValue : variableValue;
+    }
+    /** @internal */
+    eval() {
+        const $variable = this.getDep(0);
+        const variableValue = $variable.eval();
+        return variableValue === undefined ? this.defaultValue : variableValue;
+    }
+    /** @internal */
+    evalIs(value) {
+        if (value === undefined) {
+            return false;
+        }
+        else {
+            const $variable = this.getDep(0);
+            return $variable.evalIs(undefined)
+                ? this.defaultValue === value
+                : $variable.evalIs(value);
+        }
+    }
+    /** @internal */
+    evalLength() {
+        const $variable = this.getDep(0);
+        return $variable.evalIs(undefined)
+            ? Array.isArray(this.defaultValue)
+                ? this.defaultValue.length
+                : null
+            : $variable.evalLength();
+    }
+}
+exports.__InputDefaultStep = __InputDefaultStep;
+//# sourceMappingURL=__inputDefault.js.map

package/dist/steps/__inputDynamicScalar.d.ts

@@ -1,10 +1,10 @@
 import type { GraphQLScalarType, ListValueNode, ObjectValueNode } from "graphql";
 import type { UnbatchedExecutionExtra } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Handles "leaves" (scalars)
  */
-export declare class __InputDynamicScalarStep<TLeaf = any> extends UnbatchedExecutableStep<TLeaf> {
+export declare class __InputDynamicScalarStep<TLeaf = any> extends UnbatchedStep<TLeaf> {
     private value;
     static $$export: {
         moduleName: string;
@@ -15,7 +15,5 @@ export declare class __InputDynamicScalarStep<TLeaf = any> extends UnbatchedExec
     constructor(inputType: GraphQLScalarType, value: ListValueNode | ObjectValueNode);
     valueFromValues(variableValues: any[]): any;
     unbatchedExecute: (_extra: UnbatchedExecutionExtra, ...variableValues: any[]) => TLeaf;
-    eval(): TLeaf;
-    evalIs(expectedValue: undefined | null | 0): boolean;
 }
 //# sourceMappingURL=__inputDynamicScalar.d.ts.map

package/dist/steps/__inputDynamicScalar.js

@@ -9,7 +9,7 @@ const { Kind } = graphql;
 /**
  * Handles "leaves" (scalars)
  */
-class __InputDynamicScalarStep extends step_js_1.UnbatchedExecutableStep {
+class __InputDynamicScalarStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__InputDynamicScalarStep",
@@ -106,10 +106,12 @@ class __InputDynamicScalarStep extends step_js_1.UnbatchedExecutableStep {
         };
         return convert(this.value);
     }
+    /** @internal */
     eval() {
-        const variableValues = this.variableNames.map((variableName, i) => this.getDep(i).eval());
+        const variableValues = this.variableNames.map((variableName, i) => this.getDep(i, true).eval());
         return this.valueFromValues(variableValues);
     }
+    /** @internal */
     evalIs(expectedValue) {
         if (expectedValue === undefined ||
             expectedValue === null ||

package/dist/steps/__inputList.d.ts

@@ -1,12 +1,11 @@
 import type { GraphQLInputType } from "graphql";
 import * as graphql from "graphql";
-import type { InputStep, NotVariableValueNode } from "../interfaces.js";
-import { ExecutableStep } from "../step.js";
-import type { ConstantStep } from "./constant.js";
+import type { AnyInputStep, NotVariableValueNode } from "../interfaces.js";
+import { Step } from "../step.js";
 /**
  * Implements `__InputListStep`.
  */
-export declare class __InputListStep<TInputType extends graphql.GraphQLList<GraphQLInputType> = graphql.GraphQLList<GraphQLInputType>> extends ExecutableStep {
+export declare class __InputListStep<TInputType extends graphql.GraphQLList<GraphQLInputType> = graphql.GraphQLList<GraphQLInputType>> extends Step {
     private readonly inputValues;
     static $$export: {
         moduleName: string;
@@ -15,12 +14,9 @@ export declare class __InputListStep<TInputType extends graphql.GraphQLList<Grap
     isSyncAndSafe: boolean;
     private itemCount;
     constructor(inputType: TInputType, inputValues: NotVariableValueNode | undefined);
-    optimize(): ExecutableStep;
+    optimize(): Step;
     execute(): any[];
     unbatchedExecute: () => any;
-    at(index: number): InputStep | ConstantStep<undefined>;
-    eval(): any[] | null;
-    evalIs(value: null | undefined | 0): boolean;
-    evalLength(): number | null;
+    at(index: number): AnyInputStep;
 }
 //# sourceMappingURL=__inputList.d.ts.map

package/dist/steps/__inputList.js

@@ -12,7 +12,7 @@ const { GraphQLList, Kind } = graphql;
 /**
  * Implements `__InputListStep`.
  */
-class __InputListStep extends step_js_1.ExecutableStep {
+class __InputListStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__InputListStep",
@@ -66,6 +66,7 @@ class __InputListStep extends step_js_1.ExecutableStep {
         (0, input_js_1.assertInputStep)(itemPlan);
         return itemPlan;
     }
+    /** @internal */
     eval() {
         if (this.inputValues?.kind === "NullValue") {
             return null;
@@ -79,6 +80,7 @@ class __InputListStep extends step_js_1.ExecutableStep {
         }
         return list;
     }
+    /** @internal */
     evalIs(value) {
         if (value === undefined) {
             return this.inputValues === value;
@@ -90,6 +92,7 @@ class __InputListStep extends step_js_1.ExecutableStep {
             throw new Error("__InputListStep cannot evalIs values other than null and undefined currently");
         }
     }
+    /** @internal */
     evalLength() {
         if (this.inputValues === undefined) {
             return null;