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

package/dist/steps/__inputObject.d.ts

@@ -1,10 +1,10 @@
 import type { GraphQLInputObjectType } from "graphql";
-import type { InputStep, NotVariableValueNode, UnbatchedExecutionExtra } 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,17 +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: UnbatchedExecutionExtra, ...values: any[]): any;
-    get(attrName: string): InputStep;
-    eval(): any;
-    evalIs(value: null | undefined | 0): boolean;
-    evalIsEmpty(): boolean;
-    evalHas(attrName: string): boolean;
-    evalKeys(): ReadonlyArray<keyof TInputType & string> | null;
+    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

@@ -12,7 +12,7 @@ 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",
@@ -55,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) => {
@@ -72,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;
     }
@@ -83,6 +88,7 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return step;
     }
+    /** @internal */
     eval() {
         if (this.inputValues?.kind === "NullValue") {
             return null;
@@ -94,6 +100,7 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return resultValues;
     }
+    /** @internal */
     evalIs(value) {
         if (value === undefined) {
             return this.inputValues === value;
@@ -108,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;
@@ -125,6 +134,7 @@ class __InputObjectStep extends step_js_1.UnbatchedExecutableStep {
         }
         return !this.inputFields[attrName].step.evalIs(undefined);
     }
+    /** @internal */
     evalKeys() {
         if (this.inputValues === undefined) {
             return null;

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

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,13 +1,13 @@
 import type { GrafastResultsList, JSONValue } from "../index.js";
 import { $$deepDepSkip } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { $$noExec, UnbatchedExecutableStep } from "../step.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;
@@ -15,11 +15,11 @@ export declare class __ItemStep<TData> extends UnbatchedExecutableStep<TData> {
     };
     isSyncAndSafe: boolean;
     [$$noExec]: boolean;
-    constructor(parentPlan: ExecutableStep<TData> | ExecutableStep<TData[]>, depth?: number);
+    constructor(parentPlan: Step<TData> | Step<TData[]>, depth?: number);
     toStringMeta(): string;
     planJSONExtra(): Record<string, JSONValue | undefined> | undefined;
-    getParentStep(): ExecutableStep;
-    [$$deepDepSkip](): ExecutableStep;
+    getParentStep(): Step;
+    [$$deepDepSkip](): Step;
     execute(): GrafastResultsList<TData>;
     unbatchedExecute(): TData;
     finalize(): void;

package/dist/steps/__item.js

@@ -11,7 +11,7 @@ const step_js_1 = require("../step.js");
  * 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",

package/dist/steps/__trackedValue.d.ts

@@ -2,7 +2,7 @@ import type { GraphQLInputObjectType, GraphQLInputType, VariableDefinitionNode }
 import { GraphQLList, GraphQLNonNull } from "graphql";
 import type { Constraint } from "../constraints.js";
 import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.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;
@@ -40,7 +40,7 @@ export declare class __TrackedValueStep<TData = any, TInputType extends GraphQLI
      * `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;
     execute({ count, values: [values0], }: ExecutionDetails<[TData]>): GrafastResultsList<TData>;
@@ -54,52 +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 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.
-     */
-    evalKeys(): ReadonlyArray<keyof TData & string> | null;
-    /**
-     * 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

@@ -23,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;
@@ -90,7 +91,7 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
         return v;
     }
     getValuePlan() {
-        return this.getDep(0);
+        return this.getDep(0, true);
     }
     /**
      * Get the named property of an object.
@@ -133,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);
         }
     }
     /**
@@ -153,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);
         }
     }
     /**
@@ -165,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;
@@ -183,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;
@@ -195,6 +206,7 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
         });
         return pass;
     }
+    /** @internal */
     evalIsEmpty() {
         const { value, path } = this;
         const isEmpty = typeof value === "object" &&
@@ -213,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;
@@ -237,6 +251,8 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
      * check will always return the same result.
      *
      * **WARNING**: avoid using this where possible, it causes OpPlans to split.
+     *
+     * @internal
      */
     evalKeys() {
         const { value, path } = this;
@@ -277,6 +293,8 @@ class __TrackedValueStep extends step_js_1.UnbatchedExecutableStep {
      * 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,19 +1,19 @@
 import type { GrafastResultsList } from "../index.js";
-import { $$noExec, ExecutableStep } from "../step.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(): GrafastResultsList<TData>;
     get<TAttr extends keyof TData>(attrName: TAttr): AccessStep<TData[TAttr]>;

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) {

package/dist/steps/access.d.ts

@@ -1,6 +1,6 @@
 import type { UnbatchedExecutionExtra } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Accesses a (potentially nested) property from the result of a plan.
  *
@@ -9,8 +9,8 @@ import { UnbatchedExecutableStep } from "../step.js";
  * 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;
@@ -19,8 +19,9 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<TData> {
     allowMultipleOptimizations: boolean;
     readonly path: (string | number | symbol)[];
     private readonly hasSymbols;
-    constructor(parentPlan: ExecutableStep<unknown>, path: (string | number | symbol)[], fallback?: any);
+    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.
      */
@@ -38,5 +39,5 @@ export declare class AccessStep<TData> extends UnbatchedExecutableStep<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>, rawPath?: (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,6 +1,7 @@
 "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 tamedevil_1 = tslib_1.__importDefault(require("tamedevil"));
@@ -108,7 +109,7 @@ return (_meta, value) => value?.${tamedevil_1.default.join(access, "?.")}${fallb
  * 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",
@@ -118,6 +119,7 @@ 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 =
@@ -127,9 +129,10 @@ class AccessStep extends step_js_1.UnbatchedExecutableStep {
         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.
@@ -201,9 +204,13 @@ function access(parentPlan, rawPath, fallback) {
     if (typeof fallback === "undefined" &&
         !path.some((k) => typeof k === "symbol")) {
         const pathKey = (0, utils_js_1.digestKeys)(path);
-        return parentPlan.operationPlan.cacheStep(parentPlan, "GrafastInternal:access()", pathKey, () => new AccessStep(parentPlan, 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