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

package/dist/steps/connection.d.ts

@@ -1,23 +1,23 @@
-import type { ExecutionExtra, GrafastResultsList, InputStep } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { ExecutionDetails, GrafastResultsList, Maybe, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 type ParametersExceptFirst<F> = F extends (arg0: any, ...rest: infer R) => any ? R : never[];
 /**
  * Describes what a plan needs to implement in order to be suitable for
  * supplying what the `PageInfo` type requires.
  */
-export interface PageInfoCapableStep extends ExecutableStep {
-    hasNextPage(): ExecutableStep<boolean>;
-    hasPreviousPage(): ExecutableStep<boolean>;
-    startCursor(): ExecutableStep<string | null>;
-    endCursor(): ExecutableStep<string | null>;
+export interface PageInfoCapableStep extends Step {
+    hasNextPage(): Step<boolean>;
+    hasPreviousPage(): Step<boolean>;
+    startCursor(): Step<string | null>;
+    endCursor(): Step<string | null>;
 }
-export declare function assertPageInfoCapableStep($step: ExecutableStep | PageInfoCapableStep): asserts $step is PageInfoCapableStep;
+export declare function assertPageInfoCapableStep($step: Step | PageInfoCapableStep): asserts $step is PageInfoCapableStep;
 /**
  * Describes what a plan needs to implement in order to be suitable for
  * supplying what a ConnectionStep requires.
  */
-export interface ConnectionCapableStep<TItemStep extends ExecutableStep, TCursorStep extends ExecutableStep> extends ExecutableStep<ReadonlyArray<TItemStep extends ExecutableStep<infer U> ? U : any>> {
+export interface ConnectionCapableStep<TItemStep extends Step, TCursorStep extends Step> extends Step {
     /**
      * Clone the plan; it's recommended that you add `$connection` as a
      * dependency so that you can abort execution early in the case of errors
@@ -25,20 +25,19 @@ export interface ConnectionCapableStep<TItemStep extends ExecutableStep, TCursor
      */
     connectionClone($connection: ConnectionStep<TItemStep, TCursorStep, any, any>, ...args: any[]): ConnectionCapableStep<TItemStep, TCursorStep>;
     pageInfo($connection: ConnectionStep<TItemStep, TCursorStep, ConnectionCapableStep<TItemStep, TCursorStep>, any>): PageInfoCapableStep;
-    setFirst($plan: InputStep): void;
-    setLast($plan: InputStep): void;
-    setOffset($plan: InputStep): void;
-    parseCursor($plan: InputStep): TCursorStep | null | undefined;
-    setBefore($plan: TCursorStep): void;
-    setAfter($plan: TCursorStep): void;
+    setFirst($first: Step<Maybe<number>>): void;
+    setLast($last: Step<Maybe<number>>): void;
+    setOffset($offset: Step<Maybe<number>>): void;
+    parseCursor($cursor: Step<Maybe<string>>): TCursorStep;
+    setBefore($before: TCursorStep): void;
+    setAfter($after: TCursorStep): void;
+    items(): Step<ReadonlyArray<TItemStep extends Step<infer U> ? U : any>>;
 }
 /**
  * Handles GraphQL cursor pagination in a standard and consistent way
  * indepdenent of data source.
  */
-export declare class ConnectionStep<TItemStep extends ExecutableStep, TCursorStep extends ExecutableStep, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep = ExecutableStep> extends UnbatchedExecutableStep<unknown> {
-    readonly itemPlan?: (($item: TItemStep) => TNodeStep) | undefined;
-    readonly cursorPlan?: (($item: TItemStep) => ExecutableStep<string | null> | undefined) | undefined;
+export declare class ConnectionStep<TItemStep extends Step, TCursorStep extends Step, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TEdgeDataStep extends Step = TItemStep, TNodeStep extends Step = Step> extends UnbatchedStep<unknown> {
     static $$export: {
         moduleName: string;
         exportName: string;
@@ -50,18 +49,23 @@ export declare class ConnectionStep<TItemStep extends ExecutableStep, TCursorSte
     private _offsetDepId;
     private _beforeDepId;
     private _afterDepId;
-    constructor(subplan: TStep, itemPlan?: (($item: TItemStep) => TNodeStep) | undefined, cursorPlan?: (($item: TItemStep) => ExecutableStep<string | null> | undefined) | undefined);
+    /** Plan for data to associate with the edge */
+    readonly edgeDataPlan?: ($item: TItemStep) => TEdgeDataStep;
+    /** The node plan */
+    readonly itemPlan?: ($item: TItemStep) => TNodeStep;
+    readonly cursorPlan?: ($item: TItemStep) => Step<string | null> | undefined;
+    constructor(subplan: TStep, config?: ConnectionConfig<TItemStep, TEdgeDataStep, TNodeStep>);
     toStringMeta(): string;
-    getFirst(): InputStep | null;
-    setFirst($firstPlan: InputStep): void;
-    getLast(): InputStep | null;
-    setLast($lastPlan: InputStep): void;
-    getOffset(): InputStep | null;
-    setOffset($offsetPlan: InputStep): void;
+    getFirst(): Step<number | null | undefined> | null;
+    setFirst(first: Step<number | null | undefined> | number): void;
+    getLast(): Step<number | null | undefined> | null;
+    setLast(last: Step<number | null | undefined> | number): void;
+    getOffset(): Step<number | null | undefined> | null;
+    setOffset(offset: Step<number | null | undefined> | number): void;
     getBefore(): TCursorStep | null;
-    setBefore($beforePlan: InputStep): void;
+    setBefore($beforePlan: Step<string | null | undefined>): void;
     getAfter(): TCursorStep | null;
-    setAfter($afterPlan: InputStep): void;
+    setAfter($afterPlan: Step<string | null | undefined>): void;
     /**
      * This should not be called after the arguments have been finalized.
      */
@@ -91,20 +95,21 @@ export declare class ConnectionStep<TItemStep extends ExecutableStep, TCursorSte
      * to add a dependency to us, which is typically useful for adding validation
      * functions so that they are thrown "earlier", avoiding error bubbling.
      */
-    addValidation(callback: () => ExecutableStep): void;
-    edges(): ExecutableStep;
-    nodes(): TStep | import("./listTransform.js").__ListTransformStep<any, any, any, any>;
-    wrapEdge($edge: TItemStep): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
+    addValidation(callback: () => Step): void;
+    get(fieldName: string): Step<any> | undefined;
+    edges(): Step;
+    nodes(): import("./listTransform.js").__ListTransformStep<any, any, any, any> | TStep;
+    wrapEdge($edge: TItemStep): EdgeStep<TItemStep, TCursorStep, TStep, TEdgeDataStep, TNodeStep>;
     pageInfo(): PageInfoCapableStep;
-    execute(count: number): GrafastResultsList<Record<string, never>>;
+    execute({ count, }: ExecutionDetails): GrafastResultsList<Record<string, never>>;
     unbatchedExecute(): any;
 }
-export interface EdgeCapableStep<TNodeStep extends ExecutableStep> extends ExecutableStep {
+export interface EdgeCapableStep<TNodeStep extends Step> extends Step {
     node(): TNodeStep;
-    cursor(): ExecutableStep<string | null>;
+    cursor(): Step<string | null>;
 }
-export declare function assertEdgeCapableStep<TNodeStep extends ExecutableStep>($step: ExecutableStep | EdgeCapableStep<TNodeStep>): asserts $step is EdgeCapableStep<TNodeStep>;
-export declare class EdgeStep<TItemStep extends ExecutableStep, TCursorStep extends ExecutableStep, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep = ExecutableStep> extends UnbatchedExecutableStep implements EdgeCapableStep<TNodeStep> {
+export declare function assertEdgeCapableStep<TNodeStep extends Step>($step: Step | EdgeCapableStep<TNodeStep>): asserts $step is EdgeCapableStep<TNodeStep>;
+export declare class EdgeStep<TItemStep extends Step, TCursorStep extends Step, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TEdgeDataStep extends Step = TItemStep, TNodeStep extends Step = Step> extends UnbatchedStep implements EdgeCapableStep<TNodeStep> {
     private skipCursor;
     static $$export: {
         moduleName: string;
@@ -114,20 +119,29 @@ export declare class EdgeStep<TItemStep extends ExecutableStep, TCursorStep exte
     private connectionDepId;
     private readonly cursorDepId;
     private needCursor;
-    constructor($connection: ConnectionStep<TItemStep, TCursorStep, TStep, TNodeStep>, $item: TItemStep, skipCursor?: boolean);
+    constructor($connection: ConnectionStep<TItemStep, TCursorStep, TStep, TEdgeDataStep, TNodeStep>, $item: TItemStep, skipCursor?: boolean);
+    get(fieldName: string): Step<string | null> | TNodeStep | undefined;
     private getConnectionStep;
     private getItemStep;
+    data(): TEdgeDataStep;
     node(): TNodeStep;
-    cursor(): ExecutableStep<string | null>;
-    optimize(): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>;
+    cursor(): Step<string | null>;
+    optimize(): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep, Step<any>>;
     deduplicate(_peers: EdgeStep<any, any, any, any>[]): EdgeStep<TItemStep, TCursorStep, TStep, TNodeStep>[];
     deduplicatedWith(replacement: EdgeStep<any, any, any, any>): void;
-    unbatchedExecute(_extra: ExecutionExtra, record: any, cursor: any): any;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, record: any, cursor: any): any;
+}
+interface ConnectionConfig<TItemStep extends Step, TEdgeDataStep extends Step = TItemStep, TNodeStep extends Step = Step> {
+    nodePlan?: ($item: TItemStep) => TNodeStep;
+    edgeDataPlan?: ($item: TItemStep) => TEdgeDataStep;
+    cursorPlan?: ($item: TItemStep) => Step<string | null>;
 }
 /**
  * Wraps a collection fetch to provide the utilities for working with GraphQL
  * cursor connections.
  */
-export declare function connection<TItemStep extends ExecutableStep, TCursorStep extends ExecutableStep, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TNodeStep extends ExecutableStep = ExecutableStep>(step: TStep, itemPlan?: ($item: TItemStep) => TNodeStep, cursorPlan?: ($item: TItemStep) => ExecutableStep<string | null>): ConnectionStep<TItemStep, TCursorStep, TStep, TNodeStep>;
+export declare function connection<TItemStep extends Step, TCursorStep extends Step, TStep extends ConnectionCapableStep<TItemStep, TCursorStep>, TEdgeDataStep extends Step = TItemStep, TNodeStep extends Step = Step>(step: TStep, config?: ConnectionConfig<TItemStep, TEdgeDataStep, TNodeStep>): ConnectionStep<TItemStep, TCursorStep, TStep, TEdgeDataStep, TNodeStep>;
+export type ItemsStep<T extends Step<readonly any[]> | ConnectionCapableStep<any, any>> = T extends ConnectionCapableStep<any, any> ? ReturnType<T["items"]> : T;
+export declare function itemsOrStep<T extends Step<readonly any[]> | ConnectionCapableStep<any, any>>($step: T): Step<readonly any[]>;
 export {};
 //# sourceMappingURL=connection.d.ts.map

package/dist/steps/connection.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.connection = exports.EdgeStep = exports.assertEdgeCapableStep = exports.ConnectionStep = exports.assertPageInfoCapableStep = void 0;
+exports.EdgeStep = exports.ConnectionStep = void 0;
+exports.assertPageInfoCapableStep = assertPageInfoCapableStep;
+exports.assertEdgeCapableStep = assertEdgeCapableStep;
+exports.connection = connection;
+exports.itemsOrStep = itemsOrStep;
 const tslib_1 = require("tslib");
 const assert = tslib_1.__importStar(require("../assert.js"));
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
+const constant_js_1 = require("./constant.js");
 const each_js_1 = require("./each.js");
 function assertPageInfoCapableStep($step) {
     const $typed = $step;
@@ -15,22 +20,19 @@ function assertPageInfoCapableStep($step) {
         throw new Error(`Expected a PageInfoCapableStep, but found '${$step}'`);
     }
 }
-exports.assertPageInfoCapableStep = assertPageInfoCapableStep;
 const EMPTY_OBJECT = Object.freeze(Object.create(null));
 /**
  * Handles GraphQL cursor pagination in a standard and consistent way
  * indepdenent of data source.
  */
-class ConnectionStep extends step_js_1.UnbatchedExecutableStep {
+class ConnectionStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ConnectionStep",
     }; }
-    // TYPES: if subplan is `ConnectionCapableStep<EdgeCapableStep<any>>` then `itemPlan`/`cursorPlan` aren't needed; otherwise `cursorPlan` is required.
-    constructor(subplan, itemPlan, cursorPlan) {
+    // TYPES: if subplan is `ConnectionCapableStep<EdgeCapableStep<any>>` then `nodePlan`/`cursorPlan` aren't needed; otherwise `cursorPlan` is required.
+    constructor(subplan, config = {}) {
         super();
-        this.itemPlan = itemPlan;
-        this.cursorPlan = cursorPlan;
         this.isSyncAndSafe = true;
         // Pagination stuff
         this._firstDepId = null;
@@ -38,8 +40,12 @@ class ConnectionStep extends step_js_1.UnbatchedExecutableStep {
         this._offsetDepId = null;
         this._beforeDepId = undefined;
         this._afterDepId = undefined;
+        const { edgeDataPlan, nodePlan, cursorPlan } = config;
+        this.edgeDataPlan = edgeDataPlan;
+        this.itemPlan = nodePlan;
+        this.cursorPlan = cursorPlan;
         if (!cursorPlan) {
-            // ENHANCE: Assert that the `itemPlan` has a `.cursor()` method.
+            // ENHANCE: Assert that the `nodePlan` has a `.cursor()` method.
         }
         // This is a _soft_ reference to the plan; we're not adding it as a
         // dependency since we do not actually need it to execute; it's our
@@ -50,65 +56,75 @@ class ConnectionStep extends step_js_1.UnbatchedExecutableStep {
         return String(this.subplanId);
     }
     getFirst() {
-        return this._firstDepId != null
-            ? this.getDep(this._firstDepId)
-            : null;
+        return this.maybeGetDep(this._firstDepId);
     }
-    setFirst($firstPlan) {
+    setFirst(first) {
         if (this._firstDepId != null) {
             throw new Error(`${this}->setFirst already called`);
         }
-        this._firstDepId = this.addDependency($firstPlan);
+        const $first = typeof first === "number" ? (0, constant_js_1.constant)(first) : first;
+        this._firstDepId = this.addUnaryDependency({
+            step: $first,
+            nonUnaryMessage: () => `${this}.setFirst(...) must be passed a _unary_ step, but ${$first} is not unary. See: https://err.red/gud#connection`,
+        });
     }
     getLast() {
-        return this._lastDepId != null
-            ? this.getDep(this._lastDepId)
-            : null;
+        return this.maybeGetDep(this._lastDepId);
     }
-    setLast($lastPlan) {
+    setLast(last) {
         if (this._lastDepId != null) {
             throw new Error(`${this}->setLast already called`);
         }
-        this._lastDepId = this.addDependency($lastPlan);
+        const $last = typeof last === "number" ? (0, constant_js_1.constant)(last) : last;
+        this._lastDepId = this.addUnaryDependency({
+            step: $last,
+            nonUnaryMessage: () => `${this}.setLast(...) must be passed a _unary_ step, but ${$last} is not unary. See: https://err.red/gud#connection`,
+        });
     }
     getOffset() {
-        return this._offsetDepId != null
-            ? this.getDep(this._offsetDepId)
-            : null;
+        return this.maybeGetDep(this._offsetDepId);
     }
-    setOffset($offsetPlan) {
+    setOffset(offset) {
         if (this._offsetDepId != null) {
             throw new Error(`${this}->setOffset already called`);
         }
-        this._offsetDepId = this.addDependency($offsetPlan);
+        const $offset = typeof offset === "number" ? (0, constant_js_1.constant)(offset) : offset;
+        this._offsetDepId = this.addUnaryDependency({
+            step: $offset,
+            nonUnaryMessage: () => `${this}.setOffset(...) must be passed a _unary_ step, but ${$offset} is not unary. See: https://err.red/gud#connection`,
+        });
     }
     getBefore() {
-        return this._beforeDepId != null
-            ? this.getDep(this._beforeDepId)
-            : null;
+        return this.maybeGetDep(this._beforeDepId, true);
     }
     setBefore($beforePlan) {
+        if ($beforePlan instanceof constant_js_1.ConstantStep && $beforePlan.data == null) {
+            return;
+        }
         if (this._beforeDepId !== undefined) {
             throw new Error(`${this}->setBefore already called`);
         }
         const $parsedBeforePlan = this.getSubplan().parseCursor($beforePlan);
-        this._beforeDepId = $parsedBeforePlan
-            ? this.addDependency($parsedBeforePlan)
-            : null;
+        this._beforeDepId = this.addUnaryDependency({
+            step: $parsedBeforePlan,
+            nonUnaryMessage: () => `${this}.setBefore(...) must be passed a _unary_ step, but ${$parsedBeforePlan} (and presumably ${$beforePlan}) is not unary. See: https://err.red/gud#connection`,
+        });
     }
     getAfter() {
-        return this._afterDepId != null
-            ? this.getDep(this._afterDepId)
-            : null;
+        return this.maybeGetDep(this._afterDepId, true);
     }
     setAfter($afterPlan) {
+        if ($afterPlan instanceof constant_js_1.ConstantStep && $afterPlan.data == null) {
+            return;
+        }
         if (this._afterDepId !== undefined) {
             throw new Error(`${this}->setAfter already called`);
         }
         const $parsedAfterPlan = this.getSubplan().parseCursor($afterPlan);
-        this._afterDepId = $parsedAfterPlan
-            ? this.addDependency($parsedAfterPlan)
-            : null;
+        this._afterDepId = this.addUnaryDependency({
+            step: $parsedAfterPlan,
+            nonUnaryMessage: () => `${this}.setAfter(...) must be passed a _unary_ step, but ${$parsedAfterPlan} (and presumably ${$afterPlan}) is not unary. See: https://err.red/gud#connection`,
+        });
     }
     /**
      * This should not be called after the arguments have been finalized.
@@ -192,8 +208,18 @@ class ConnectionStep extends step_js_1.UnbatchedExecutableStep {
             this.addDependency(callback());
         });
     }
+    get(fieldName) {
+        switch (fieldName) {
+            case "edges":
+                return this.edges();
+            case "nodes":
+                return this.nodes();
+            case "pageInfo":
+                return this.pageInfo();
+        }
+    }
     edges() {
-        if (this.cursorPlan || this.itemPlan) {
+        if (this.cursorPlan || this.itemPlan || this.edgeDataPlan) {
             return (0, each_js_1.each)(this.cloneSubplanWithPagination(), ($intermediate) => this.wrapEdge($intermediate));
         }
         else {
@@ -213,8 +239,7 @@ class ConnectionStep extends step_js_1.UnbatchedExecutableStep {
         return new EdgeStep(this, $edge);
     }
     pageInfo() {
-        const plan = this.getStep(this.subplanId);
-        return plan.pageInfo(this);
+        return this.cloneSubplanWithPagination().pageInfo(this);
     }
     /*
   
@@ -225,7 +250,7 @@ class ConnectionStep extends step_js_1.UnbatchedExecutableStep {
       return constant(EMPTY_OBJECT, false);
     }
     */
-    execute(count) {
+    execute({ count, }) {
         // Fake execution; data actually comes from the child plans
         return (0, utils_js_1.arrayOfLength)(count, EMPTY_OBJECT);
     }
@@ -241,8 +266,7 @@ function assertEdgeCapableStep($step) {
         throw new Error(`Expected a EdgeCapableStep, but found '${$step}'`);
     }
 }
-exports.assertEdgeCapableStep = assertEdgeCapableStep;
-class EdgeStep extends step_js_1.UnbatchedExecutableStep {
+class EdgeStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "EdgeStep",
@@ -268,12 +292,24 @@ class EdgeStep extends step_js_1.UnbatchedExecutableStep {
         }
         this.connectionDepId = this.addDependency($connection);
     }
+    get(fieldName) {
+        switch (fieldName) {
+            case "node":
+                return this.node();
+            case "cursor":
+                return this.cursor();
+        }
+    }
     getConnectionStep() {
         return this.getDep(this.connectionDepId);
     }
     getItemStep() {
         return this.getDep(0);
     }
+    data() {
+        const $item = this.getItemStep();
+        return this.getConnectionStep().edgeDataPlan?.($item) ?? $item;
+    }
     node() {
         const $item = this.getItemStep();
         return this.getConnectionStep().itemPlan?.($item) ?? $item;
@@ -304,12 +340,29 @@ class EdgeStep extends step_js_1.UnbatchedExecutableStep {
     }
 }
 exports.EdgeStep = EdgeStep;
+let warned = false;
 /**
  * Wraps a collection fetch to provide the utilities for working with GraphQL
  * cursor connections.
  */
-function connection(step, itemPlan, cursorPlan) {
-    return new ConnectionStep(step, itemPlan, cursorPlan);
+function connection(step, config) {
+    if (typeof config === "function") {
+        if (!warned) {
+            warned = true;
+            console.warn(`The call signature for connection() has changed, arguments after the first argument should be specified via a config object`);
+        }
+        return connection(step, {
+            // eslint-disable-next-line prefer-rest-params
+            nodePlan: arguments[1],
+            // eslint-disable-next-line prefer-rest-params
+            cursorPlan: arguments[2],
+        });
+    }
+    return new ConnectionStep(step, config);
+}
+function itemsOrStep($step) {
+    return "items" in $step && typeof $step.items === "function"
+        ? $step.items()
+        : $step;
 }
-exports.connection = connection;
 //# sourceMappingURL=connection.js.map

package/dist/steps/constant.d.ts

@@ -1,9 +1,9 @@
-import type { GrafastResultsList } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { ExecutionDetails, GrafastResultsList, JSONValue } from "../interfaces.js";
+import { UnbatchedStep } from "../step.js";
 /**
  * Converts a constant value (e.g. a string/number/etc) into a plan
  */
-export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData> {
+export declare class ConstantStep<TData> extends UnbatchedStep<TData> {
     readonly data: TData;
     readonly isSensitive: boolean;
     static $$export: {
@@ -13,14 +13,14 @@ export declare class ConstantStep<TData> extends UnbatchedExecutableStep<TData>
     isSyncAndSafe: boolean;
     constructor(data: TData, isSensitive?: boolean);
     toStringMeta(): string;
+    planJSONExtra(): undefined | Record<string, JSONValue>;
     deduplicate(peers: readonly ConstantStep<any>[]): ConstantStep<any>[];
-    execute(count: number): GrafastResultsList<TData>;
-    eval(): TData;
-    evalIs(value: any): boolean;
-    evalIsEmpty(): boolean;
+    execute({ count }: ExecutionDetails): GrafastResultsList<TData>;
     unbatchedExecute(): TData;
     isNull(): boolean;
     isUndefined(): boolean;
+    get(key: string): ConstantStep<any>;
+    at(index: number): ConstantStep<any>;
 }
 /**
  * Call this as a template string or as a function. Only intended for handling

package/dist/steps/constant.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.constant = exports.ConstantStep = void 0;
+exports.ConstantStep = void 0;
+exports.constant = constant;
 const inspect_js_1 = require("../inspect.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
+const index_js_1 = require("./index.js");
 /**
  * Converts a constant value (e.g. a string/number/etc) into a plan
  */
-class ConstantStep extends step_js_1.UnbatchedExecutableStep {
+class ConstantStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ConstantStep",
@@ -17,32 +19,82 @@ class ConstantStep extends step_js_1.UnbatchedExecutableStep {
         this.data = data;
         this.isSensitive = isSensitive;
         this.isSyncAndSafe = true;
+        const t = typeof data;
+        if (data == null ||
+            t === "boolean" ||
+            t === "number" ||
+            (t === "string" && t.length < 200)) {
+            this.peerKey = t + "|" + String(data);
+        }
     }
     toStringMeta() {
         // ENHANCE: use nicer simplification
         return this.isSensitive
             ? `[HIDDEN]`
-            : (0, inspect_js_1.inspect)(this.data)
+            : (0, inspect_js_1.inspect)(this.data, {
+                compact: Infinity,
+                breakLength: Infinity,
+            })
                 .replace(/[\r\n]/g, " ")
+                .replaceAll("[Object: null prototype] ", "§")
                 .slice(0, 60);
     }
+    planJSONExtra() {
+        if (this.isSensitive)
+            return;
+        const data = this.data;
+        if (data === null) {
+            return {
+                constant: {
+                    type: "null",
+                },
+            };
+        }
+        else if (data === undefined ||
+            typeof data === "boolean" ||
+            typeof data === "number" ||
+            typeof data === "string") {
+            return {
+                constant: {
+                    type: typeof data,
+                },
+            };
+        }
+    }
     deduplicate(peers) {
         return peers.filter((p) => p.data === this.data);
     }
-    execute(count) {
+    execute({ count }) {
         return (0, utils_js_1.arrayOfLength)(count, this.data);
     }
+    /** @internal */
     eval() {
         return this.data;
     }
+    /** @internal */
     evalIs(value) {
         return this.data === value;
     }
+    /** @internal */
     evalIsEmpty() {
         return (typeof this.data === "object" &&
             this.data !== null &&
             Object.keys(this.data).length === 0);
     }
+    /** @internal */
+    evalLength() {
+        return Array.isArray(this.data) ? this.data.length : null;
+    }
+    /** @internal */
+    evalKeys() {
+        if (this.data == null || typeof this.data !== "object") {
+            return null;
+        }
+        else {
+            const data = this.data;
+            return Object.keys(data).filter((k) => data[k] !== undefined);
+        }
+    }
     unbatchedExecute() {
         return this.data;
     }
@@ -52,6 +104,18 @@ class ConstantStep extends step_js_1.UnbatchedExecutableStep {
     isUndefined() {
         return this.data === undefined;
     }
+    get(key) {
+        const value = typeof this.data === "object" &&
+            this.data !== null &&
+            Object.hasOwn(this.data, key)
+            ? this.data[key]
+            : undefined;
+        return constant(value);
+    }
+    at(index) {
+        const value = Array.isArray(this.data) ? this.data[index] : undefined;
+        return constant(value);
+    }
 }
 exports.ConstantStep = ConstantStep;
 function isTemplateStringsArray(data) {
@@ -64,9 +128,24 @@ function constant(data, isSecret) {
         if (data.length !== 1) {
             throw new Error("constant`...` doesn't currently support placeholders; please use 'constant(`...`)' instead");
         }
-        return new ConstantStep(data[0], false);
+        return constant(data[0], false);
+    }
+    const opPlan = (0, index_js_1.operationPlan)();
+    const makeConst = () => (0, index_js_1.operationPlan)().withRootLayerPlan(() => new ConstantStep(data, isSecret));
+    const t = typeof data;
+    if (data == null ||
+        t === "boolean" ||
+        t === "string" ||
+        t === "number" ||
+        t === "symbol") {
+        return opPlan.cacheStep(opPlan.contextStep, isSecret ? `constant-secret` : `constant`, data, makeConst);
+    }
+    else {
+        return makeConst();
     }
-    return new ConstantStep(data, isSecret);
 }
-exports.constant = constant;
+// Have to overwrite the getDepOrConstant method due to circular dependency
+step_js_1.Step.prototype.getDepOrConstant = function (depId, fallback) {
+    return this.maybeGetDep(depId) ?? constant(fallback, false);
+};
 //# sourceMappingURL=constant.js.map

package/dist/steps/each.d.ts

@@ -1,9 +1,9 @@
-import type { ExecutableStep, ListCapableStep } from "../step.js";
+import type { ListCapableStep, Step } from "../step.js";
 import { __ItemStep } from "./__item.js";
-import type { ConnectionCapableStep } from "./connection.js";
+import type { ConnectionCapableStep, ItemsStep } from "./connection.js";
 import type { __ListTransformStep } from "./listTransform.js";
 /**
  * Transforms a list by wrapping each element in the list with the given mapper.
  */
-export declare function each<TListStep extends ExecutableStep<readonly any[]> & Partial<ConnectionCapableStep<any, any>>, TResultItemStep extends ExecutableStep>(listStep: TListStep, mapper: (itemPlan: TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>) => TResultItemStep): __ListTransformStep<any, any, any, any>;
+export declare function each<TListStep extends (Step<readonly any[]> & Partial<ConnectionCapableStep<any, any>>) | ConnectionCapableStep<any, any>, TResultItemStep extends Step>(listStep: TListStep, mapper: (itemPlan: ItemsStep<TListStep> extends ListCapableStep<any, any> ? ReturnType<ItemsStep<TListStep>["listItem"]> : __ItemStep<any>) => TResultItemStep): __ListTransformStep<any, any, any, any>;
 //# sourceMappingURL=each.d.ts.map

package/dist/steps/each.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.each = void 0;
+exports.each = each;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const step_js_1 = require("../step.js");
@@ -43,7 +43,7 @@ function each(listStep, mapper) {
             const layerPlan = this.subroutineLayer;
             const rootStep = layerPlan.rootStep;
             if (rootStep instanceof __item_js_1.__ItemStep &&
-                rootStep.dependencies[0].layerPlan !== layerPlan) {
+                rootStep.getParentStep().layerPlan !== layerPlan) {
                 // We don't do anything; replace ourself with our parent
                 return this.getListStep();
             }
@@ -60,5 +60,4 @@ function each(listStep, mapper) {
             : null),
     });
 }
-exports.each = each;
 //# sourceMappingURL=each.js.map