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

package/dist/steps/__inputStaticLeaf.js

@@ -11,7 +11,7 @@ const { valueFromAST } = graphql;
  *
  * @see __InputDynamicScalarStep
  */
-class __InputStaticLeafStep extends step_js_1.UnbatchedExecutableStep {
+class __InputStaticLeafStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__InputStaticLeafStep",
@@ -32,9 +32,11 @@ class __InputStaticLeafStep extends step_js_1.UnbatchedExecutableStep {
     optimize() {
         return (0, constant_js_1.constant)(this.coercedValue, false);
     }
+    /** @internal */
     eval() {
         return this.coercedValue;
     }
+    /** @internal */
     evalIs(expectedValue) {
         return this.coercedValue === expectedValue;
     }

package/dist/steps/__item.d.ts

@@ -1,12 +1,13 @@
-import type { JSONValue } from "../index.js";
-import type { ExecutableStep } from "../step.js";
-import { $$deepDepSkip, $$noExec, UnbatchedExecutableStep } from "../step.js";
+import type { GrafastResultsList, JSONValue } from "../index.js";
+import { $$deepDepSkip } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { $$noExec, UnbatchedStep } from "../step.js";
 /**
  * An __ItemStep is an internal plan (users must never construct it
  * themselves!) that Grafast uses to refer to an individual item within a list
  * or stream.
  */
-export declare class __ItemStep<TData> extends UnbatchedExecutableStep<TData> {
+export declare class __ItemStep<TData> extends UnbatchedStep<TData> {
     readonly depth: number;
     static $$export: {
         moduleName: string;
@@ -14,16 +15,13 @@ export declare class __ItemStep<TData> extends UnbatchedExecutableStep<TData> {
     };
     isSyncAndSafe: boolean;
     [$$noExec]: boolean;
-    /**
-     * @internal
-     */
-    transformStepId?: number;
-    constructor(parentPlan: ExecutableStep<TData> | ExecutableStep<TData[]>, depth?: number);
+    constructor(parentPlan: Step<TData> | Step<TData[]>, depth?: number);
     toStringMeta(): string;
     planJSONExtra(): Record<string, JSONValue | undefined> | undefined;
-    [$$deepDepSkip](): ExecutableStep;
-    execute(): never;
-    unbatchedExecute(): never;
+    getParentStep(): Step;
+    [$$deepDepSkip](): Step;
+    execute(): GrafastResultsList<TData>;
+    unbatchedExecute(): TData;
     finalize(): void;
 }
 //# sourceMappingURL=__item.d.ts.map

package/dist/steps/__item.js

@@ -4,13 +4,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.__ItemStep = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
 /**
  * An __ItemStep is an internal plan (users must never construct it
  * themselves!) that Grafast uses to refer to an individual item within a list
  * or stream.
  */
-class __ItemStep extends step_js_1.UnbatchedExecutableStep {
+class __ItemStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__ItemStep",
@@ -21,6 +22,8 @@ class __ItemStep extends step_js_1.UnbatchedExecutableStep {
         this.isSyncAndSafe = true;
         this[_a] = true;
         this.addDependency(parentPlan);
+        this._isUnary = false;
+        this._isUnaryLocked = true;
     }
     toStringMeta() {
         return chalk_1.default.bold.yellow(String(this.dependencies[0].id));
@@ -30,7 +33,10 @@ class __ItemStep extends step_js_1.UnbatchedExecutableStep {
             transformStepId: this.transformStepId,
         };
     }
-    [(_a = step_js_1.$$noExec, step_js_1.$$deepDepSkip)]() {
+    getParentStep() {
+        return this.getDep(0);
+    }
+    [(_a = step_js_1.$$noExec, interfaces_js_1.$$deepDepSkip)]() {
         return this.getDep(0);
     }
     execute() {

package/dist/steps/__trackedValue.d.ts

@@ -1,8 +1,8 @@
 import type { GraphQLInputObjectType, GraphQLInputType, VariableDefinitionNode } from "graphql";
 import { GraphQLList, GraphQLNonNull } from "graphql";
 import type { Constraint } from "../constraints.js";
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
+import { UnbatchedStep } from "../step.js";
 import type { __ValueStep } from "./__value.js";
 import type { AccessStep } from "./access.js";
 /**
@@ -24,7 +24,7 @@ import type { AccessStep } from "./access.js";
  * change the query plan, but it can also be used within plan resolvers to
  * branch the logic of a plan based on something in these entities.
  */
-export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLInputType | ReadonlyArray<VariableDefinitionNode> | undefined = undefined> extends UnbatchedExecutableStep<TData> {
+export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLInputType | ReadonlyArray<VariableDefinitionNode> | undefined = undefined> extends UnbatchedStep<TData> {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -35,27 +35,16 @@ export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLI
      * entries such as `pgClient`.
      */
     private readonly value;
-    /**
-     * A reference to the relevant
-     * operationPlan.variableValuesConstraints/contextConstraints/rootValueConstraints.
-     *
-     * @internal
-     */
-    private readonly constraints;
     /**
      * The path that we are through the original value (the one that
      * `constraints` relates to).
      */
     private readonly path;
-    static withGraphQLType<TInputType extends GraphQLInputType, TData = any>(value: TData | undefined, valuePlan: __ValueStep<TData> | AccessStep<TData>, constraints: Constraint[], path: (string | number)[] | undefined, graphqlType: TInputType): __TrackedValueStepWithDollars<TData, TInputType>;
+    static withGraphQLType<TInputType extends GraphQLInputType, TData = any>(value: TData | undefined, valuePlan: __ValueStep<TData> | AccessStep<TData>, constraints: Constraint[], path: Array<string | number> | undefined, graphqlType: TInputType): __TrackedValueStepWithDollars<TData, TInputType>;
     private nullableGraphQLType;
     private variableDefinitions;
-    /**
-     * @internal
-     */
-    constructor(value: TData | undefined, valuePlan: __ValueStep<TData> | AccessStep<TData>, constraints: Constraint[], path?: Array<string | number>, graphqlTypeOrVariableDefinitions?: TInputType);
-    execute(_count: number, values: [GrafastValuesList<TData>]): GrafastResultsList<TData>;
-    unbatchedExecute(_extra: ExecutionExtra, v: TData): TData;
+    execute({ count, values: [values0], }: ExecutionDetails<[TData]>): GrafastResultsList<TData>;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, v: TData): TData;
     private getValuePlan;
     /**
      * Get the named property of an object.
@@ -65,44 +54,7 @@ export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLI
      * Get the entry at the given index in an array.
      */
     at<TIndex extends keyof TData & number>(index: TIndex): __TrackedValueStepWithDollars<TData[TIndex], TInputType extends GraphQLList<infer U> ? U & GraphQLInputType : TInputType extends GraphQLNonNull<GraphQLList<infer U>> ? U & GraphQLInputType : undefined>;
-    /**
-     * Evaluates the current value, and adds a constraint to the OpPlan to ensure
-     * that all future evaluations of this property will always return the same
-     * value.
-     *
-     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
-     *
-     * **WARNING**: this is the most expensive eval, if you need to eval, prefer evalIs, evalHas, etc instead.
-     */
-    eval(): TData | undefined;
-    /**
-     * Evaluates if the current value is equal to this specific value, and adds a
-     * constraint to the OpPlan to ensure that all future evaluations of this
-     * check will always return the same (boolean) result.
-     *
-     * Should only be used on scalars.
-     *
-     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
-     */
-    evalIs(expectedValue: unknown): boolean;
-    evalIsEmpty(): boolean;
-    /**
-     * Evaluates if the current value is an object with the given key, and adds a
-     * constraint to the OpPlan to ensure that all future evaluations of this
-     * check will always return the same (boolean) result.
-     *
-     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
-     */
-    evalHas(key: string): boolean;
-    /**
-     * Evaluates the length of the current value (assumed to be an array), and
-     * adds a constraint to the OpPlan to ensure that all future values will have
-     * the same length.
-     *
-     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
-     */
-    evalLength(): number | null;
-    optimize(): import("../step.js").ExecutableStep<any>;
+    optimize(): import("../step.js").Step<any> | import("./__flag.js").__FlagStep<import("../step.js").Step<any>>;
 }
 export type __TrackedValueStepWithDollars<TData = any, TInputType extends GraphQLInputType | undefined = undefined> = __TrackedValueStep<TData, TInputType> & (TInputType extends GraphQLInputObjectType ? {
     [key in keyof ReturnType<TInputType["getFields"]> & string as `$${key}`]: __TrackedValueStepWithDollars<TData extends {

package/dist/steps/__trackedValue.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.__TrackedValueStep = void 0;
 const graphql_1 = require("graphql");
+const index_js_1 = require("../index.js");
 const step_js_1 = require("../step.js");
 /**
  * Implements the `__TrackedValueStep(operationPlan, object, constraints, path)`
@@ -22,20 +23,21 @@ const step_js_1 = require("../step.js");
  * change the query plan, but it can also be used within plan resolvers to
  * branch the logic of a plan based on something in these entities.
  */
-class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
+class __TrackedValueStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__TrackedValueStep",
     }; }
     static withGraphQLType(value, valuePlan, constraints, path = [], graphqlType) {
-        return new __TrackedValueStep(value, valuePlan, constraints, path, graphqlType);
+        return (0, index_js_1.operationPlan)().withRootLayerPlan(() => new __TrackedValueStep(value, valuePlan, constraints, path, true, graphqlType));
     }
     /**
      * @internal
      */
-    constructor(value, valuePlan, constraints, path = [], graphqlTypeOrVariableDefinitions) {
+    constructor(value, valuePlan, constraints, path = [], isImmutable, graphqlTypeOrVariableDefinitions) {
         super();
         this.isSyncAndSafe = true;
+        this._isImmutable = isImmutable;
         this.addDependency(valuePlan);
         this.value = value;
         this.constraints = constraints;
@@ -79,15 +81,17 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
             }
         }
     }
-    execute(_count, values) {
+    execute({ count, values: [values0], }) {
         // We have only one dependency, return the value of that.
-        return values[0];
+        return values0.isBatch
+            ? values0.entries
+            : (0, index_js_1.arrayOfLength)(count, values0.value);
     }
     unbatchedExecute(_extra, v) {
         return v;
     }
     getValuePlan() {
-        return this.getDep(0);
+        return this.getDep(0, true);
     }
     /**
      * Get the named property of an object.
@@ -130,8 +134,11 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
             const type = getType(def.type);
             return __TrackedValueStep.withGraphQLType(newValue, newValuePlan, constraints, newPath, type);
         }
+        else if (this._isImmutable) {
+            return this.operationPlan.withRootLayerPlan(() => new __TrackedValueStep(newValue, newValuePlan, constraints, newPath, this._isImmutable));
+        }
         else {
-            return new __TrackedValueStep(newValue, newValuePlan, constraints, newPath);
+            return new __TrackedValueStep(newValue, newValuePlan, constraints, newPath, this._isImmutable);
         }
     }
     /**
@@ -150,8 +157,11 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
                 throw new Error(`'${this.nullableGraphQLType}' is not a list type, cannot access array index '${index}' on it`);
             }
         }
+        else if (this._isImmutable) {
+            return this.operationPlan.withRootLayerPlan(() => new __TrackedValueStep(newValue, newValuePlan, constraints, newPath, this._isImmutable));
+        }
         else {
-            return new __TrackedValueStep(newValue, newValuePlan, constraints, newPath);
+            return new __TrackedValueStep(newValue, newValuePlan, constraints, newPath, this._isImmutable);
         }
     }
     /**
@@ -162,6 +172,8 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
      * **WARNING**: avoid using this where possible, it causes OpPlans to split.
      *
      * **WARNING**: this is the most expensive eval, if you need to eval, prefer evalIs, evalHas, etc instead.
+     *
+     * @internal
      */
     eval() {
         const { path, value } = this;
@@ -180,6 +192,8 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
      * Should only be used on scalars.
      *
      * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     *
+     * @internal
      */
     evalIs(expectedValue) {
         const { value, path } = this;
@@ -192,6 +206,7 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
         });
         return pass;
     }
+    /** @internal */
     evalIsEmpty() {
         const { value, path } = this;
         const isEmpty = typeof value === "object" &&
@@ -210,6 +225,8 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
      * check will always return the same (boolean) result.
      *
      * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     *
+     * @internal
      */
     evalHas(key) {
         const { value, path } = this;
@@ -228,12 +245,56 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
         });
         return exists;
     }
+    /**
+     * Evaluates the keys of the current value, and adds a
+     * constraint to the OpPlan to ensure that all future evaluations of this
+     * check will always return the same result.
+     *
+     * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     *
+     * @internal
+     */
+    evalKeys() {
+        const { value, path } = this;
+        if (!(0, graphql_1.isInputObjectType)(this.nullableGraphQLType)) {
+            throw new Error("evalKeys must only be called for object types");
+        }
+        if (value == null) {
+            this.constraints.push({
+                type: "keys",
+                path,
+                keys: null,
+            });
+            return null;
+        }
+        const keys = [];
+        const keysOfType = Object.keys(this.nullableGraphQLType.getFields());
+        // NOTE: it's important that we loop through the fields in their defined
+        // order, this ensures the `keys` array always has consistent ordering.
+        for (let i = 0; i < keysOfType.length; i++) {
+            const key = keysOfType[i];
+            // NOTE: `key in value` would be more performant here, but we cannot trust
+            // users not to pass `{foo: undefined}` so we must do the more expensive
+            // `value[key] !== undefined` check.
+            if (value[key] !== undefined) {
+                keys.push(key);
+            }
+        }
+        this.constraints.push({
+            type: "keys",
+            path,
+            keys,
+        });
+        return keys;
+    }
     /**
      * Evaluates the length of the current value (assumed to be an array), and
      * adds a constraint to the OpPlan to ensure that all future values will have
      * the same length.
      *
      * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     *
+     * @internal
      */
     evalLength() {
         const { value, path } = this;

package/dist/steps/__value.d.ts

@@ -1,20 +1,21 @@
-import { $$noExec, ExecutableStep } from "../step.js";
+import type { GrafastResultsList } from "../index.js";
+import { $$noExec, Step } from "../step.js";
 import type { AccessStep } from "./access.js";
 /**
  * Implements `__ValueStep(operationPlan)` which is never executed; it's purely
  * internal - we populate the value as part of the algorithm - see
  * `GetValueStepId` and `PopulateValueStep`.
  */
-export declare class __ValueStep<TData> extends ExecutableStep<TData> {
+export declare class __ValueStep<TData> extends Step<TData> {
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     [$$noExec]: boolean;
-    constructor();
+    constructor(isImmutable: boolean);
     toStringMeta(): string | null;
-    execute(): never;
+    execute(): GrafastResultsList<TData>;
     get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;
     at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
 }

package/dist/steps/__value.js

@@ -9,16 +9,17 @@ const access_js_1 = require("./access.js");
  * internal - we populate the value as part of the algorithm - see
  * `GetValueStepId` and `PopulateValueStep`.
  */
-class __ValueStep extends step_js_1.ExecutableStep {
+class __ValueStep extends step_js_1.Step {
     static { _a = step_js_1.$$noExec; }
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__ValueStep",
     }; }
-    constructor() {
+    constructor(isImmutable) {
         super();
         this.isSyncAndSafe = true;
         this[_a] = true;
+        this._isImmutable = isImmutable;
     }
     toStringMeta() {
         switch (this) {
@@ -37,10 +38,10 @@ class __ValueStep extends step_js_1.ExecutableStep {
         throw new Error(`GrafastInternalError<7696a514-f452-4d47-92d3-85aeb5b23f48>: ${this} is a __ValueStep and thus must never execute`);
     }
     get(attrName) {
-        return (0, access_js_1.access)(this, [attrName]);
+        return this.cacheStep("get", attrName, () => (0, access_js_1.access)(this, [attrName]));
     }
     at(index) {
-        return (0, access_js_1.access)(this, [index]);
+        return this.cacheStep("at", index, () => (0, access_js_1.access)(this, [index]));
     }
 }
 exports.__ValueStep = __ValueStep;

package/dist/steps/access.d.ts

@@ -1,8 +1,6 @@
-import type { ExecutionExtra } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
-/** @internal */
-export declare const expressionSymbol: unique symbol;
+import type { UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Accesses a (potentially nested) property from the result of a plan.
  *
@@ -11,8 +9,8 @@ export declare const expressionSymbol: unique symbol;
  * preferably where the objects have null prototypes, and be sure to adhere to
  * the naming conventions detailed in assertSafeToAccessViaBraces.
  */
-export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
-    readonly fallback?: any;
+export declare class AccessStep<TData> extends UnbatchedStep<TData> {
+    readonly fallback?: any | undefined;
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -20,8 +18,10 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
     readonly path: (string | number | symbol)[];
-    constructor(parentPlan: ExecutableStep<unknown>, path: (string | number | symbol)[], fallback?: any);
+    private readonly hasSymbols;
+    constructor(parentPlan: Step<unknown>, path: (string | number | symbol)[], fallback?: any | undefined);
     toStringMeta(): string;
+    getParentStep(): Step<any> | import("./__flag.js").__FlagStep<Step<any>>;
     /**
      * Get the named property of an object.
      */
@@ -32,12 +32,12 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
     at<TIndex extends keyof TData>(index: TIndex): AccessStep<TData[TIndex]>;
     optimize(): AccessStep<TData>;
     finalize(): void;
-    unbatchedExecute(_extra: ExecutionExtra, ..._values: any[]): any;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, ..._values: any[]): any;
     deduplicate(peers: AccessStep<unknown>[]): AccessStep<TData>[];
 }
 /**
  * Access the property at path `path` in the value returned from `parentPlan`,
  * falling back to `fallback` if it were null-ish.
  */
-export declare function access<TData>(parentPlan: ExecutableStep<unknown>, path: (string | number | symbol)[] | string | number | symbol, fallback?: any): AccessStep<TData>;
+export declare function access<TData>(parentPlan: Step<unknown>, rawPath?: (string | number | symbol)[] | string | number | symbol, fallback?: any): AccessStep<TData>;
 //# sourceMappingURL=access.d.ts.map

package/dist/steps/access.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.access = exports.AccessStep = exports.expressionSymbol = void 0;
+exports.AccessStep = exports.expressionSymbol = void 0;
+exports.access = access;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const debug_1 = tslib_1.__importDefault(require("debug"));
 const tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
 const inspect_js_1 = require("../inspect.js");
 const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
 /** @internal */
 exports.expressionSymbol = Symbol("expression");
 const makeDestructureCache = Object.create(null);
@@ -100,8 +101,6 @@ return (_meta, value) => value?.${tamedevil_1.default.join(access, "?.")}${fallb
         });
     }
 }
-const debugAccessPlan = (0, debug_1.default)("grafast:AccessStep");
-const debugAccessPlanVerbose = debugAccessPlan.extend("verbose");
 /**
  * Accesses a (potentially nested) property from the result of a plan.
  *
@@ -110,7 +109,7 @@ const debugAccessPlanVerbose = debugAccessPlan.extend("verbose");
  * preferably where the objects have null prototypes, and be sure to adhere to
  * the naming conventions detailed in assertSafeToAccessViaBraces.
  */
-class AccessStep extends step_js_1.UnbatchedExecutableStep {
+class AccessStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "AccessStep",
@@ -120,13 +119,20 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         this.fallback = fallback;
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
+        this._isImmutable = parentPlan._isImmutable;
         this.path = path;
+        this.hasSymbols = this.path.some((k) => typeof k === "symbol");
+        this.peerKey =
+            (this.fallback === "undefined" ? "U" : "D") +
+                (this.hasSymbols ? "§" : ".") +
+                (0, utils_js_1.digestKeys)(this.path);
         this.addDependency(parentPlan);
     }
     toStringMeta() {
-        return `${chalk_1.default.bold.yellow(String(this.getDep(0).id))}.${this.path
-            .map((p) => String(p))
-            .join(".")}`;
+        return `${chalk_1.default.bold.yellow(String(this.getDepOptions(0).step.id))}.${this.path.map((p) => String(p)).join(".")}`;
+    }
+    getParentStep() {
+        return this.getDep(0);
     }
     /**
      * Get the named property of an object.
@@ -135,7 +141,7 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         if (typeof attrName !== "string") {
             throw new Error(`AccessStep::get can only be called with string values`);
         }
-        return new AccessStep(this.getDep(0), [...this.path, attrName]);
+        return access(this.getDep(0), [...this.path, attrName]);
     }
     /**
      * Get the entry at the given index in an array.
@@ -144,7 +150,7 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         if (typeof index !== "number") {
             throw new Error(`AccessStep::get can only be called with string values`);
         }
-        return new AccessStep(this.getDep(0), [...this.path, index]);
+        return access(this.getDep(0), [...this.path, index]);
     }
     // An access of an access can become a single access
     optimize() {
@@ -165,10 +171,23 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         throw new Error(`${this}: should have had unbatchedExecute method replaced`);
     }
     deduplicate(peers) {
-        const myPath = JSON.stringify(this.path);
-        const peersWithSamePath = peers.filter((p) => p.fallback === this.fallback && JSON.stringify(p.path) === myPath);
-        debugAccessPlanVerbose("%c deduplicate: peers with same path %o = %c", this, this.path, peersWithSamePath);
-        return peersWithSamePath;
+        if (peers.length === 0) {
+            return peers;
+        }
+        else if (!this.hasSymbols && this.fallback === undefined) {
+            // Rely entirely on peerKey
+            return peers;
+        }
+        else if (!this.hasSymbols) {
+            // Rely on peerKey for path, but check fallback
+            const { fallback } = this;
+            return peers.filter((p) => p.fallback === fallback);
+        }
+        else {
+            // Check both fallback and path
+            const { fallback, path } = this;
+            return peers.filter((p) => p.fallback === fallback && (0, utils_js_1.arraysMatch)(p.path, path));
+        }
     }
 }
 exports.AccessStep = AccessStep;
@@ -176,8 +195,22 @@ exports.AccessStep = AccessStep;
  * Access the property at path `path` in the value returned from `parentPlan`,
  * falling back to `fallback` if it were null-ish.
  */
-function access(parentPlan, path, fallback) {
-    return new AccessStep(parentPlan, Array.isArray(path) ? path : [path], fallback);
+function access(parentPlan, rawPath, fallback) {
+    const path = Array.isArray(rawPath)
+        ? rawPath
+        : rawPath != null
+            ? [rawPath]
+            : [];
+    if (typeof fallback === "undefined" &&
+        !path.some((k) => typeof k === "symbol")) {
+        const pathKey = (0, utils_js_1.digestKeys)(path);
+        if (parentPlan._isImmutable) {
+            return parentPlan.operationPlan.withRootLayerPlan(() => parentPlan.operationPlan.cacheStep(parentPlan, "GrafastInternal:access()", pathKey, () => new AccessStep(parentPlan, path)));
+        }
+        else {
+            return parentPlan.operationPlan.cacheStep(parentPlan, "GrafastInternal:access()", pathKey, () => new AccessStep(parentPlan, path));
+        }
+    }
+    return new AccessStep(parentPlan, path, fallback);
 }
-exports.access = access;
 //# sourceMappingURL=access.js.map

package/dist/steps/applyInput.d.ts

@@ -0,0 +1,44 @@
+import type { GraphQLInputType, GraphQLSchema } from "graphql";
+import type { AnyInputStep, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+import { ConstantStep } from "./index.js";
+export declare class ApplyInputStep<TParent extends object = any, TTarget extends object = TParent> extends UnbatchedStep<(arg: TParent) => void> {
+    private inputType;
+    private getTargetFromParent;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    allowMultipleOptimizations: boolean;
+    valueDepId: 0;
+    constructor(inputType: GraphQLInputType, $value: AnyInputStep, getTargetFromParent: ((parent: TParent, inputValue: any) => TTarget | undefined | (() => TTarget)) | undefined);
+    deduplicate(peers: readonly ApplyInputStep[]): ApplyInputStep<any, any>[];
+    optimize(): this | ConstantStep<(parent: TParent) => void>;
+    unbatchedExecute(extra: UnbatchedExecutionExtra, value: any): (parentThing: TParent) => void;
+}
+export declare function inputArgsApply<TArg extends object, TTarget extends object = TArg>(schema: GraphQLSchema, inputType: GraphQLInputType, parent: TArg, inputValue: unknown, getTargetFromParent: ((parent: TArg, inputValue: any) => TTarget | undefined | (() => TTarget)) | undefined): void;
+export declare function applyInput<TParent extends object = any, TTarget extends object = TParent>(inputType: GraphQLInputType, $value: AnyInputStep, getTargetFromParent?: (parent: TParent, inputValue: any) => TTarget | undefined): ConstantStep<(parent: TParent) => void> | ApplyInputStep<TParent, TTarget>;
+/**
+ * Modifiers modify their parent (which may be another modifier or anything
+ * else). First they gather all the requirements from their children (if any)
+ * being applied to them, then they apply themselves to their parent. This
+ * application is done through the `apply()` method.
+ */
+export declare abstract class Modifier<TParent> {
+    protected readonly parent: TParent;
+    static $$export: any;
+    constructor(parent: TParent);
+    /**
+     * In this method, you should apply the changes to your `this.parent` plan
+     */
+    abstract apply(): void;
+}
+export declare function isModifier<TParent>(plan: any): plan is Modifier<TParent>;
+export declare function assertModifier<TParent>(plan: any, pathDescription: string): asserts plan is Modifier<TParent>;
+export type ApplyableExecutableStep<TArg extends object = any, TData = any> = Step<TData> & {
+    apply($apply: Step<(arg: TArg) => void>): void;
+};
+export declare function isApplyableStep<TArg extends object = any, TData = any>(s: Step<TData>): s is ApplyableExecutableStep<TArg, TData>;
+//# sourceMappingURL=applyInput.d.ts.map