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

package/dist/steps/__flag.d.ts

@@ -0,0 +1,65 @@
+import type { DataFromStep, ExecutionDetails, ExecutionEntryFlags, GrafastResultsList } from "../interfaces.js";
+import { $$deepDepSkip } from "../interfaces.js";
+import type { ListCapableStep } 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;
+export declare const TRAP_ERROR_OR_INHIBITED: ExecutionEntryFlags;
+declare const TRAP_VALUES: readonly ["NULL", "EMPTY_LIST", "PASS_THROUGH"];
+/** @defaultValue `'PASS_THROUGH'` */
+export type TrapValue = (typeof TRAP_VALUES)[number];
+/** `false` means pass-through; all others are literal */
+export type ResolvedTrapValue = false | null | undefined | readonly never[];
+export interface FlagStepOptions {
+    acceptFlags?: ExecutionEntryFlags;
+    onReject?: Error | null;
+    if?: Step<boolean>;
+    valueForInhibited?: TrapValue;
+    valueForError?: TrapValue;
+}
+export declare class __FlagStep<TStep extends Step> extends Step<DataFromStep<TStep>> {
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    private ifDep;
+    private forbiddenFlags;
+    private onRejectReturnValue;
+    private valueForInhibited;
+    private valueForError;
+    private canBeInlined;
+    constructor(step: TStep, options: FlagStepOptions);
+    toStringMeta(): string | null;
+    [$$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;
+}
+/**
+ * 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<TStep extends Step>($step: TStep, options?: {
+    if?: FlagStepOptions["if"];
+}): __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<TStep extends Step>($step: TStep, message: string, options?: {
+    if?: FlagStepOptions["if"];
+}): __FlagStep<TStep>;
+export declare function trap<TStep extends Step>($step: TStep, acceptFlags: ExecutionEntryFlags, options?: {
+    valueForInhibited?: FlagStepOptions["valueForInhibited"];
+    valueForError?: FlagStepOptions["valueForError"];
+    if?: FlagStepOptions["if"];
+}): __FlagStep<TStep>;
+export {};
+//# sourceMappingURL=__flag.d.ts.map

package/dist/steps/__flag.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const step_js_1 = require("../step.js");
+// PUBLIC FLAGS
+exports.TRAP_ERROR = interfaces_js_1.FLAG_ERROR;
+exports.TRAP_INHIBITED = interfaces_js_1.FLAG_INHIBITED;
+exports.TRAP_ERROR_OR_INHIBITED = (interfaces_js_1.FLAG_ERROR |
+    interfaces_js_1.FLAG_INHIBITED);
+function digestAcceptFlags(acceptFlags) {
+    const parts = [];
+    if ((acceptFlags & interfaces_js_1.FLAG_NULL) === 0) {
+        parts.push("rejectNull");
+    }
+    if ((acceptFlags & interfaces_js_1.FLAG_ERROR) !== 0) {
+        parts.push("trapError");
+    }
+    if ((acceptFlags & interfaces_js_1.FLAG_INHIBITED) !== 0) {
+        parts.push("trapInhibited");
+    }
+    return parts.join("&");
+}
+const TRAP_VALUES = [
+    "NULL",
+    "EMPTY_LIST",
+    "PASS_THROUGH",
+    // "UNDEFINED", // waiting for a need
+];
+const EMPTY_LIST = Object.freeze([]);
+function trim(string, length = 15) {
+    if (string.length > length) {
+        return string.substring(0, length - 2) + "…";
+    }
+    else {
+        return string;
+    }
+}
+function resolveTrapValue(tv) {
+    switch (tv) {
+        case "NULL":
+            return null;
+        case "EMPTY_LIST":
+            return EMPTY_LIST;
+        case "PASS_THROUGH":
+            return false;
+        default: {
+            const never = tv;
+            throw new Error(`TrapValue '${never}' not understood; please use one of: ${TRAP_VALUES.join(", ")}`);
+        }
+    }
+}
+class __FlagStep extends step_js_1.Step {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "__FlagStep",
+    }; }
+    constructor(step, options) {
+        super();
+        this.isSyncAndSafe = false;
+        this.ifDep = null;
+        const { acceptFlags = interfaces_js_1.DEFAULT_ACCEPT_FLAGS, onReject, if: $cond, valueForInhibited = "PASS_THROUGH", valueForError = "PASS_THROUGH", } = options;
+        this.forbiddenFlags = interfaces_js_1.ALL_FLAGS & ~acceptFlags;
+        this.onRejectReturnValue =
+            onReject == null ? error_js_1.$$inhibit : (0, error_js_1.flagError)(onReject, step.id);
+        this.valueForInhibited = resolveTrapValue(valueForInhibited);
+        this.valueForError = resolveTrapValue(valueForError);
+        this.canBeInlined =
+            !$cond &&
+                valueForInhibited === "PASS_THROUGH" &&
+                valueForError === "PASS_THROUGH" &&
+                // Can't PASS_THROUGH errors since they need to be converted into TRAPPED
+                // error.
+                // TODO: should we be handling this in Grafast core?
+                (acceptFlags & interfaces_js_1.FLAG_ERROR) === 0;
+        if (!this.canBeInlined) {
+            this.addDependency({ step, acceptFlags: interfaces_js_1.TRAPPABLE_FLAGS });
+            if ($cond) {
+                this.ifDep = this.addDependency($cond);
+            }
+        }
+        else {
+            this.addDependency({ step, acceptFlags, onReject });
+        }
+        if ((0, step_js_1.isListCapableStep)(step)) {
+            this.listItem = this._listItem;
+        }
+    }
+    toStringMeta() {
+        const acceptFlags = interfaces_js_1.ALL_FLAGS & ~this.forbiddenFlags;
+        const rej = this.onRejectReturnValue
+            ? trim(String(this.onRejectReturnValue))
+            : (0, inspect_js_1.inspect)(this.onRejectReturnValue);
+        const $if = this.ifDep !== null ? this.getDepOptions(this.ifDep).step : null;
+        return `${this.dependencies[0].id}, ${$if ? `if(${$if.id}), ` : ``}${digestAcceptFlags(acceptFlags)}, onReject: ${rej}`;
+    }
+    [interfaces_js_1.$$deepDepSkip]() {
+        return this.getDepOptions(0).step;
+    }
+    // Copied over listItem if the dependent step is a list capable step
+    _listItem($item) {
+        const $dep = this.dependencies[0];
+        return (0, step_js_1.isListCapableStep)($dep) ? $dep.listItem($item) : $item;
+    }
+    /** Return inlining instructions if we can be inlined. @internal */
+    inline(options) {
+        if (!this.canBeInlined) {
+            return null;
+        }
+        const step = this.dependencies[0];
+        const forbiddenFlags = this.dependencyForbiddenFlags[0];
+        const onReject = this.dependencyOnReject[0];
+        const acceptFlags = interfaces_js_1.ALL_FLAGS & ~forbiddenFlags;
+        if (
+        // TODO: this logic could be improved so that more flag checks were
+        // inlined, e.g. `trap(inhibitOnNull($foo), TRAP_INHIBIT)` should just
+        // become `$foo`.
+        //
+        // However, we must be careful that we don't optimize away flags, e.g.
+        // `trap(inhibitOnNull($foo), TRAP_INHIBIT, { if: $cond })` needs to see
+        // the inhibit flag to know what to do, so in this case we shouldn't be
+        // inlined. This may only apply to __FlagStep and might be something we
+        // want to optimize later.
+        options.onReject === undefined ||
+            options.onReject === onReject) {
+            if (options.acceptFlags === undefined ||
+                options.acceptFlags === interfaces_js_1.DEFAULT_ACCEPT_FLAGS ||
+                options.acceptFlags === acceptFlags ||
+                false) {
+                return { step, acceptFlags, onReject };
+            }
+        }
+        return null;
+    }
+    deduplicate(_peers) {
+        return _peers.filter((p) => {
+            // ifDep has already been tested by Grafast (it's a dependency)
+            if (p.forbiddenFlags !== this.forbiddenFlags)
+                return false;
+            if (p.onRejectReturnValue !== this.onRejectReturnValue)
+                return false;
+            if (p.valueForInhibited !== this.valueForInhibited)
+                return false;
+            if (p.valueForError !== this.valueForError)
+                return false;
+            if (p.canBeInlined !== this.canBeInlined)
+                return false;
+            return true;
+        });
+    }
+    execute(_details) {
+        throw new Error(`${this} not finalized?`);
+    }
+    finalize() {
+        if (this.canBeInlined) {
+            this.execute = this.passThroughExecute;
+        }
+        else {
+            this.execute = this.fancyExecute;
+        }
+        super.finalize();
+    }
+    fancyExecute(details) {
+        const dataEv = details.values[0];
+        const condEv = this.ifDep === null ? null : details.values[this.ifDep];
+        const { forbiddenFlags: thisForbiddenFlags, onRejectReturnValue, valueForError, valueForInhibited, } = this;
+        return details.indexMap((i) => {
+            const cond = condEv ? condEv.at(i) : true;
+            const forbiddenFlags = cond
+                ? thisForbiddenFlags
+                : interfaces_js_1.DEFAULT_FORBIDDEN_FLAGS;
+            // Search for "f2b3b1b3" for similar block
+            const flags = dataEv._flagsAt(i);
+            const disallowedFlags = flags & forbiddenFlags;
+            if (disallowedFlags) {
+                if (disallowedFlags & interfaces_js_1.FLAG_INHIBITED) {
+                    // We were already rejected, maintain this
+                    return error_js_1.$$inhibit;
+                }
+                else if (disallowedFlags & interfaces_js_1.FLAG_ERROR) {
+                    // We were already rejected, maintain this
+                    return (0, error_js_1.flagError)(dataEv.at(i));
+                }
+                else {
+                    // We weren't already inhibited
+                    return onRejectReturnValue;
+                }
+            }
+            else {
+                if (flags & interfaces_js_1.FLAG_ERROR && this.valueForError !== false) {
+                    return valueForError;
+                }
+                if (flags & interfaces_js_1.FLAG_INHIBITED && this.valueForInhibited !== false) {
+                    return valueForInhibited;
+                }
+                // Assume pass-through
+                return dataEv.at(i);
+            }
+        });
+    }
+    // Checks already performed via addDependency, just pass everything through. Should have been inlined!
+    passThroughExecute(details) {
+        const ev = details.values[0];
+        if (ev.isBatch) {
+            return ev.entries;
+        }
+        else {
+            const val = ev.value;
+            return details.indexMap(() => val);
+        }
+    }
+}
+exports.__FlagStep = __FlagStep;
+/**
+ * Example use case: get user by id, but id is null: no need to fetch the user
+ * since we know they won't exist.
+ */
+function inhibitOnNull($step, options) {
+    return new __FlagStep($step, {
+        ...options,
+        acceptFlags: interfaces_js_1.DEFAULT_ACCEPT_FLAGS & ~interfaces_js_1.FLAG_NULL,
+    });
+}
+/**
+ * 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.
+ */
+function assertNotNull($step, message, options) {
+    return new __FlagStep($step, {
+        ...options,
+        acceptFlags: interfaces_js_1.DEFAULT_ACCEPT_FLAGS & ~interfaces_js_1.FLAG_NULL,
+        onReject: new error_js_1.SafeError(message),
+    });
+}
+function trap($step, acceptFlags, options) {
+    return new __FlagStep($step, {
+        ...options,
+        acceptFlags: (acceptFlags & interfaces_js_1.TRAPPABLE_FLAGS) | interfaces_js_1.FLAG_NULL,
+    });
+}
+// Have to overwrite the getDep method due to circular dependency
+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 });
+    }
+};
+//# sourceMappingURL=__flag.js.map

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 { ExecutionExtra } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { UnbatchedExecutionExtra } from "../interfaces.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;
@@ -14,8 +14,6 @@ export declare class __InputDynamicScalarStep<TLeaf = any> extends UnbatchedExec
     private variableNames;
     constructor(inputType: GraphQLScalarType, value: ListValueNode | ObjectValueNode);
     valueFromValues(variableValues: any[]): any;
-    unbatchedExecute: (_extra: ExecutionExtra, ...variableValues: any[]) => TLeaf;
-    eval(): TLeaf;
-    evalIs(expectedValue: undefined | null | 0): boolean;
+    unbatchedExecute: (_extra: UnbatchedExecutionExtra, ...variableValues: any[]) => TLeaf;
 }
 //# 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;

package/dist/steps/__inputObject.d.ts

@@ -1,10 +1,10 @@
 import type { GraphQLInputObjectType } from "graphql";
-import type { ExecutionExtra, InputStep, NotVariableValueNode } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { AnyInputStep, NotVariableValueNode, UnbatchedExecutionExtra } from "../interfaces.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Implements `InputObjectStep`
  */
-export declare class __InputObjectStep<TInputType extends GraphQLInputObjectType = GraphQLInputObjectType> extends UnbatchedExecutableStep {
+export declare class __InputObjectStep<TInputType extends GraphQLInputObjectType = GraphQLInputObjectType> extends UnbatchedStep {
     private inputObjectType;
     private inputValues;
     static $$export: {
@@ -14,16 +14,12 @@ export declare class __InputObjectStep<TInputType extends GraphQLInputObjectType
     isSyncAndSafe: boolean;
     private inputFields;
     constructor(inputObjectType: TInputType, inputValues: NotVariableValueNode | undefined);
-    optimize(): this | import("./constant.js").ConstantStep<null>;
+    optimize(): import("./constant.js").ConstantStep<null> | this;
     finalize(): void;
-    unbatchedExecute(_extra: ExecutionExtra, ...values: any[]): any;
-    get(attrName: string): InputStep;
-    eval(): any;
-    evalIs(value: null | undefined | 0): boolean;
-    evalIsEmpty(): boolean;
-    evalHas(attrName: string): boolean;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, ...values: any[]): any;
+    get(attrName: string): AnyInputStep;
 }
 export type __InputObjectStepWithDollars<TInputType extends GraphQLInputObjectType = GraphQLInputObjectType> = __InputObjectStep<TInputType> & {
-    [key in keyof ReturnType<TInputType["getFields"]> & string as `$${key}`]: InputStep<ReturnType<TInputType["getFields"]>[key]["type"]>;
+    [key in keyof ReturnType<TInputType["getFields"]> & string as `$${key}`]: AnyInputStep;
 };
 //# sourceMappingURL=__inputObject.d.ts.map

package/dist/steps/__inputObject.js

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__InputObjectStep = void 0;
 const tslib_1 = require("tslib");
+const graphql = tslib_1.__importStar(require("graphql"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const input_js_1 = require("../input.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
 const constant_js_1 = require("./constant.js");
+const { Kind } = graphql;
 /**
  * Implements `InputObjectStep`
  */
-class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
+class __InputObjectStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__InputObjectStep",
@@ -53,8 +55,11 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
             if (dependencyIndex == null) {
                 throw new Error("inputFieldPlan has gone missing.");
             }
+            const teVal = tamedevil_1.default.identifier(`val${dependencyIndex}`);
             return (0, tamedevil_1.default) `\
-  resultValues${tamedevil_1.default.set(inputFieldName, true)} = ${tamedevil_1.default.identifier(`val${dependencyIndex}`)};`;
+  if (${teVal} !== undefined) {
+    resultValues${tamedevil_1.default.set(inputFieldName, true)} = ${teVal};
+  }`;
         }), "\n")}
   return resultValues;
 })`, (fn) => {
@@ -70,7 +75,9 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
                 throw new Error("inputFieldPlan has gone missing.");
             }
             const value = values[dependencyIndex];
-            resultValues[inputFieldName] = value;
+            if (value !== undefined) {
+                resultValues[inputFieldName] = value;
+            }
         }
         return resultValues;
     }
@@ -81,6 +88,7 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return step;
     }
+    /** @internal */
     eval() {
         if (this.inputValues?.kind === "NullValue") {
             return null;
@@ -92,6 +100,7 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return resultValues;
     }
+    /** @internal */
     evalIs(value) {
         if (value === undefined) {
             return this.inputValues === value;
@@ -106,11 +115,13 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
             throw new Error("__InputObjectStep cannot evalIs values other than null and undefined currently");
         }
     }
+    /** @internal */
     evalIsEmpty() {
         return (this.inputValues?.kind === "ObjectValue" &&
             this.inputValues.fields.length === 0);
     }
     // Written without consulting spec.
+    /** @internal */
     evalHas(attrName) {
         if (!this.inputValues) {
             return false;
@@ -123,6 +134,41 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return !this.inputFields[attrName].step.evalIs(undefined);
     }
+    /** @internal */
+    evalKeys() {
+        if (this.inputValues === undefined) {
+            return null;
+        }
+        else if (this.inputValues.kind === Kind.NULL) {
+            return null;
+        }
+        else if (this.inputValues.kind !== Kind.OBJECT) {
+            throw new Error("evalKeys must only be called for object types");
+        }
+        const keys = [];
+        const inputFieldKeys = Object.keys(this.inputFields);
+        for (let i = 0; i < inputFieldKeys.length; i++) {
+            const key = inputFieldKeys[i];
+            const inputFieldPlan = this.inputFields[key].step;
+            // This evalIs() is required. With __inputObject we know that it's an
+            // explicit input object (not variable) in the GraphQL document, but the
+            // values of each key may still be undefined if they're a variable that
+            // isn't supplied and has no default. In these cases we do not wish to
+            // return these keys (since the input object is not seen as having those
+            // keys set), but that will differ on an operation-to-operation basis,
+            // and thus we must evaluate whether or not they are undefined. Note that
+            // this implicitly adds constraints for these values; we do not need to
+            // explicitly add any constraint for the object itself because the
+            // document itself guarantees it will always be present.
+            //
+            // PERF: We should not need to .evalIs(undefined) for any input field
+            // that is declared as non-nullable, I think?
+            if (!inputFieldPlan.evalIs(undefined)) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
 }
 exports.__InputObjectStep = __InputObjectStep;
 //# sourceMappingURL=__inputObject.js.map

package/dist/steps/__inputStaticLeaf.d.ts

@@ -1,11 +1,11 @@
 import type { BooleanValueNode, EnumValueNode, FloatValueNode, GraphQLLeafType, IntValueNode, NullValueNode, StringValueNode } from "graphql";
-import { UnbatchedExecutableStep } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Implements `InputStaticLeafStep`
  *
  * @see __InputDynamicScalarStep
  */
-export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedExecutableStep<TLeaf> {
+export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedStep<TLeaf> {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -15,7 +15,5 @@ export declare class __InputStaticLeafStep<TLeaf = any> extends UnbatchedExecuta
     constructor(inputType: GraphQLLeafType, value: IntValueNode | FloatValueNode | StringValueNode | BooleanValueNode | NullValueNode | EnumValueNode | undefined);
     unbatchedExecute(): TLeaf;
     optimize(): import("./constant.js").ConstantStep<any>;
-    eval(): TLeaf;
-    evalIs(expectedValue: unknown): boolean;
 }
 //# sourceMappingURL=__inputStaticLeaf.d.ts.map