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

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,13 +20,12 @@ 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",
@@ -52,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.
@@ -225,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);
     }
     /*
   
@@ -253,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",
@@ -348,5 +360,9 @@ function connection(step, config) {
     }
     return new ConnectionStep(step, config);
 }
-exports.connection = connection;
+function itemsOrStep($step) {
+    return "items" in $step && typeof $step.items === "function"
+        ? $step.items()
+        : $step;
+}
 //# sourceMappingURL=connection.js.map

package/dist/steps/constant.d.ts

@@ -1,9 +1,9 @@
-import type { ExecutionDetails, 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,13 +13,9 @@ 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 }: ExecutionDetails): GrafastResultsList<TData>;
-    eval(): TData;
-    evalIs(value: any): boolean;
-    evalIsEmpty(): boolean;
-    evalLength(): number | null;
-    evalKeys(): ReadonlyArray<keyof TData & string> | null;
     unbatchedExecute(): TData;
     isNull(): boolean;
     isUndefined(): boolean;

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",
@@ -29,30 +31,61 @@ class ConstantStep extends step_js_1.UnbatchedExecutableStep {
         // 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 }) {
         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;
@@ -95,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");
@@ -60,5 +60,4 @@ function each(listStep, mapper) {
             : null),
     });
 }
-exports.each = each;
 //# sourceMappingURL=each.js.map

package/dist/steps/error.d.ts

@@ -1,6 +1,6 @@
 import type { ExecutionDetails, GrafastResultsList } from "../interfaces.js";
-import { UnbatchedExecutableStep } from "../step.js";
-export declare class ErrorStep<TError extends Error> extends UnbatchedExecutableStep<never> {
+import { UnbatchedStep } from "../step.js";
+export declare class ErrorStep<TError extends Error> extends UnbatchedStep<never> {
     static $$export: {
         moduleName: string;
         exportName: string;

package/dist/steps/error.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.error = exports.ErrorStep = void 0;
+exports.ErrorStep = void 0;
+exports.error = error;
 const error_js_1 = require("../error.js");
 const inspect_js_1 = require("../inspect.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
-class ErrorStep extends step_js_1.UnbatchedExecutableStep {
+class ErrorStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ErrorStep",
@@ -29,5 +30,4 @@ exports.ErrorStep = ErrorStep;
 function error(error) {
     return new ErrorStep(error);
 }
-exports.error = error;
 //# sourceMappingURL=error.js.map

package/dist/steps/filter.d.ts

@@ -1,10 +1,11 @@
-import type { ExecutableStep, ListCapableStep } from "../step.js";
+import type { ListCapableStep, Step } from "../step.js";
 import type { __ItemStep } from "./__item.js";
+import type { ConnectionCapableStep, ItemsStep } from "./connection.js";
 import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
 export type FilterPlanMemo = unknown[];
 /**
  * Filters a list plan to only include entries for which the `filterCallback`
  * plan results in a truthy value.
  */
-export declare function filter<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<boolean>>(listStep: TListStep, filterCallback: ListTransformItemPlanCallback<TListStep, TItemStep>): __ListTransformStep<TListStep, TItemStep, FilterPlanMemo, TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>>;
+export declare function filter<TListStep extends Step<readonly any[]> | ConnectionCapableStep<any, any>, TItemStep extends Step<boolean>>(listStep: TListStep, filterCallback: ListTransformItemPlanCallback<ItemsStep<TListStep>, TItemStep>): __ListTransformStep<TListStep, TItemStep, FilterPlanMemo, TListStep extends ListCapableStep<any, any> ? ReturnType<TListStep["listItem"]> : __ItemStep<any>>;
 //# sourceMappingURL=filter.d.ts.map

package/dist/steps/filter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filter = void 0;
+exports.filter = filter;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const step_js_1 = require("../step.js");
@@ -28,5 +28,4 @@ function filter(listStep, filterCallback) {
         meta: `filter:${chalk_1.default.yellow(listStep.id)}${filterCallback.name ? `/${filterCallback.name}` : ""}`,
     });
 }
-exports.filter = filter;
 //# sourceMappingURL=filter.js.map

package/dist/steps/first.d.ts

@@ -1,14 +1,15 @@
 import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
-import type { ExecutableStep } from "../step.js";
-import { UnbatchedExecutableStep } from "../step.js";
-export declare class FirstStep<TData> extends UnbatchedExecutableStep<TData> {
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+import type { ConnectionCapableStep } from "./connection.js";
+export declare class FirstStep<TData> extends UnbatchedStep<TData> {
     static $$export: {
         moduleName: string;
         exportName: string;
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    constructor(parentPlan: ExecutableStep<ReadonlyArray<TData>>);
+    constructor(parentPlan: Step<ReadonlyArray<TData>> | ConnectionCapableStep<Step<TData>, any>);
     execute({ indexMap, values: [values0], }: ExecutionDetails<[ReadonlyArray<TData>]>): GrafastResultsList<TData>;
     unbatchedExecute(_extra: UnbatchedExecutionExtra, list: any[]): any;
     deduplicate(peers: FirstStep<TData>[]): FirstStep<TData>[];
@@ -18,5 +19,5 @@ export declare class FirstStep<TData> extends UnbatchedExecutableStep<TData> {
  * A plan that resolves to the first entry in the list returned by the given
  * plan.
  */
-export declare function first<TData>(plan: ExecutableStep<ReadonlyArray<TData>>): FirstStep<TData>;
+export declare function first<TData>(plan: Step<ReadonlyArray<TData>> | ConnectionCapableStep<Step<TData>, any>): FirstStep<TData>;
 //# sourceMappingURL=first.d.ts.map

package/dist/steps/first.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.first = exports.FirstStep = void 0;
+exports.FirstStep = void 0;
+exports.first = first;
 const step_js_1 = require("../step.js");
+const connection_js_1 = require("./connection.js");
 const list_js_1 = require("./list.js");
-class FirstStep extends step_js_1.UnbatchedExecutableStep {
+class FirstStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "FirstStep",
@@ -12,7 +14,7 @@ class FirstStep extends step_js_1.UnbatchedExecutableStep {
         super();
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
-        this.addDependency(parentPlan);
+        this.addDependency((0, connection_js_1.itemsOrStep)(parentPlan));
     }
     execute({ indexMap, values: [values0], }) {
         return indexMap((i) => values0.at(i)?.[0]);
@@ -40,5 +42,4 @@ exports.FirstStep = FirstStep;
 function first(plan) {
     return plan.operationPlan.cacheStep(plan, "GrafastInternal:first()", "", () => new FirstStep(plan));
 }
-exports.first = first;
 //# sourceMappingURL=first.js.map

package/dist/steps/graphqlResolver.d.ts

@@ -1,4 +1,4 @@
 import type { GraphQLNullableType, GraphQLOutputType } from "graphql";
-import { ExecutableStep } from "../step.js";
-export declare function graphqlItemHandler($item: ExecutableStep, nullableType: GraphQLNullableType & GraphQLOutputType): GraphQLItemHandler;
+import { Step } from "../step.js";
+export declare function graphqlItemHandler($item: Step, nullableType: GraphQLNullableType & GraphQLOutputType): GraphQLItemHandler;
 //# sourceMappingURL=graphqlResolver.d.ts.map

package/dist/steps/graphqlResolver.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.graphqlResolver = exports.graphqlItemHandler = exports.GraphQLItemHandler = exports.GraphQLResolverStep = void 0;
+exports.GraphQLItemHandler = exports.GraphQLResolverStep = void 0;
+exports.graphqlItemHandler = graphqlItemHandler;
+exports.graphqlResolver = graphqlResolver;
 const tslib_1 = require("tslib");
 const graphql = tslib_1.__importStar(require("graphql"));
 const iterall_1 = require("iterall");
@@ -38,7 +40,7 @@ context, resolveInfo) {
  *
  * @internal
  */
-class GraphQLResolverStep extends step_js_1.UnbatchedExecutableStep {
+class GraphQLResolverStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "GraphQLResolverStep",
@@ -69,66 +71,54 @@ class GraphQLResolverStep extends step_js_1.UnbatchedExecutableStep {
             this.subscriber?.name ||
             null);
     }
-    unbatchedExecute(_extra, source, args, context, variableValues, rootValue) {
-        if (this.isNotRoot && source == null) {
-            return source;
-        }
-        const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
-            variableValues,
-            rootValue,
-            path: {
-                typename: this.resolveInfoBase.parentType.name,
-                key: this.resolveInfoBase.fieldName,
-                // ENHANCE: add full support for path (requires runtime indexes)
-                prev: undefined,
-            },
-        });
-        const data = this.resolver?.(source, args, context, resolveInfo);
-        if (this.returnContextAndResolveInfo) {
-            return dcr(data, context, resolveInfo);
+    unbatchedExecute(extra, source, args, context, variableValues, rootValue) {
+        if (!extra.stream) {
+            if (this.isNotRoot && source == null) {
+                return source;
+            }
+            const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
+                variableValues,
+                rootValue,
+                path: {
+                    typename: this.resolveInfoBase.parentType.name,
+                    key: this.resolveInfoBase.fieldName,
+                    // ENHANCE: add full support for path (requires runtime indexes)
+                    prev: undefined,
+                },
+            });
+            const data = this.resolver?.(source, args, context, resolveInfo);
+            if (this.returnContextAndResolveInfo) {
+                return dcr(data, context, resolveInfo);
+            }
+            else {
+                return flagErrorIfErrorAsync(data);
+            }
         }
         else {
-            return flagErrorIfErrorAsync(data);
-        }
-    }
-    unbatchedStream(_extra, source, args, context, variableValues, rootValue) {
-        if (this.isNotRoot) {
-            return Promise.reject(new Error(`Invalid non-root subscribe`));
-        }
-        if (this.subscriber == null) {
-            return Promise.reject(new Error(`Cannot subscribe to field`));
-        }
-        if (this.returnContextAndResolveInfo) {
-            return Promise.reject(new Error(`Subscription with returnContextAndResolveInfo is not supported`));
-        }
-        const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
-            // ENHANCE: add support for path
-            variableValues,
-            rootValue,
-        });
-        const data = this.subscriber(source, args, context, resolveInfo);
-        // TODO: should apply flagErrorIfError to each value data yields
-        return flagErrorIfErrorAsync(data);
-    }
-    async stream({ indexMap, values, extra, }) {
-        const depCount = this.dependencies.length;
-        return indexMap((i) => {
-            try {
-                const tuple = [];
-                for (let j = 0; j < depCount; j++) {
-                    tuple[j] = values[j].at(i);
-                }
-                return this.unbatchedStream(extra, ...tuple);
+            if (this.isNotRoot) {
+                return Promise.reject(new Error(`Invalid non-root subscribe`));
+            }
+            if (this.subscriber == null) {
+                return Promise.reject(new Error(`Cannot subscribe to field`));
             }
-            catch (e) {
-                return (0, index_js_1.flagError)(e);
+            if (this.returnContextAndResolveInfo) {
+                return Promise.reject(new Error(`Subscription with returnContextAndResolveInfo is not supported`));
             }
-        });
+            const resolveInfo = Object.assign(Object.create(this.resolveInfoBase), {
+                // ENHANCE: add support for path
+                variableValues,
+                rootValue,
+            });
+            // TODO: we also need to call the resolver on each result?
+            const data = this.subscriber(source, args, context, resolveInfo);
+            // TODO: should apply flagErrorIfError to each value data yields
+            return flagErrorIfErrorAsync(data);
+        }
     }
 }
 exports.GraphQLResolverStep = GraphQLResolverStep;
 /** @internal */
-class GraphQLItemHandler extends step_js_1.ExecutableStep {
+class GraphQLItemHandler extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "GraphQLItemHandler",
@@ -251,7 +241,6 @@ exports.GraphQLItemHandler = GraphQLItemHandler;
 function graphqlItemHandler($item, nullableType) {
     return new GraphQLItemHandler($item, nullableType);
 }
-exports.graphqlItemHandler = graphqlItemHandler;
 /**
  * Emulates what GraphQL does when calling a resolver, including handling of
  * polymorphism.
@@ -274,7 +263,6 @@ function graphqlResolver(resolver, subscriber, $step, $args, resolveInfoBase) {
         return $resolverResult;
     }
 }
-exports.graphqlResolver = graphqlResolver;
 function flagErrorIfError(data) {
     return data instanceof Error ? (0, index_js_1.flagError)(data) : data;
 }

package/dist/steps/groupBy.d.ts

@@ -1,4 +1,5 @@
-import type { ExecutableStep } from "../step.js";
+import type { Step } from "../step.js";
+import type { ConnectionCapableStep, ItemsStep } from "./connection.js";
 import type { __ListTransformStep, ListTransformItemPlanCallback } from "./listTransform.js";
 export type GroupByPlanMemo = Map<unknown, unknown[]>;
 /**
@@ -7,5 +8,5 @@ export type GroupByPlanMemo = Map<unknown, unknown[]>;
  * keys and the values are lists of the original entries that match these
  * grouping keys.
  */
-export declare function groupBy<TListStep extends ExecutableStep<readonly any[]>, TItemStep extends ExecutableStep<number>>(listStep: TListStep, mapper: ListTransformItemPlanCallback<TListStep, TItemStep>): __ListTransformStep<TListStep, TItemStep, GroupByPlanMemo, any>;
+export declare function groupBy<TListStep extends Step<readonly any[]> | ConnectionCapableStep<any, any>, TItemStep extends Step<number>>(listStep: TListStep, mapper: ListTransformItemPlanCallback<ItemsStep<TListStep>, TItemStep>): __ListTransformStep<TListStep, TItemStep, GroupByPlanMemo, any>;
 //# sourceMappingURL=groupBy.d.ts.map

package/dist/steps/groupBy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupBy = void 0;
+exports.groupBy = groupBy;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const step_js_1 = require("../step.js");
@@ -36,5 +36,4 @@ function groupBy(listStep, mapper) {
         meta: `groupBy:${chalk_1.default.yellow(listStep.id)}${mapper.name ? `/${mapper.name}` : ""}`,
     });
 }
-exports.groupBy = groupBy;
 //# sourceMappingURL=groupBy.js.map

package/dist/steps/index.d.ts

@@ -24,12 +24,12 @@ export { last, LastStep } from "./last.js";
 export { list, ListStep } from "./list.js";
 export { listen, ListenStep } from "./listen.js";
 export { __ListTransformStep, listTransform, ListTransformItemPlanCallback, ListTransformOptions, ListTransformReduce, } from "./listTransform.js";
-export { makeDecodeNodeId, node, nodeIdFromNode, NodeStep, specFromNodeId, } from "./node.js";
+export { makeDecodeNodeId, makeDecodeNodeIdRuntime, node, nodeIdFromNode, NodeStep, specFromNodeId, } from "./node.js";
 export { object, ObjectPlanMeta, ObjectStep } from "./object.js";
 export { partitionByIndex } from "./partitionByIndex.js";
 export { ActualKeyByDesiredKey, remapKeys, RemapKeysStep, } from "./remapKeys.js";
 export { reverse, reverseArray, ReverseStep } from "./reverse.js";
-export { setter, SetterCapableStep, SetterStep } from "./setter.js";
+export { createObjectAndApplyChildren, Setter, setter, SetterCapable, } from "./setter.js";
 export { sideEffect, SideEffectStep } from "./sideEffect.js";
 export { __InputListStep } from "./__inputList.js";
 export { __InputObjectStep, __InputObjectStepWithDollars, } from "./__inputObject.js";
@@ -37,7 +37,9 @@ export { __InputStaticLeafStep } from "./__inputStaticLeaf.js";
 export { __ItemStep } from "./__item.js";
 export { __TrackedValueStep, __TrackedValueStepWithDollars, } from "./__trackedValue.js";
 export { __ValueStep } from "./__value.js";
+export { applyInput, ApplyInputStep, assertModifier, isModifier, Modifier, } from "./applyInput.js";
 export { applyTransforms, ApplyTransformsStep } from "./applyTransforms.js";
+export { bakedInput, bakedInputRuntime, BakedInputStep } from "./bakedInput.js";
 export { condition, ConditionStep } from "./condition.js";
 export { GraphQLItemHandler, graphqlItemHandler, graphqlResolver, GraphQLResolverStep, } from "./graphqlResolver.js";
 export { LoadedRecordStep, loadMany, LoadManyCallback, loadManyCallback, loadOne, LoadOneCallback, loadOneCallback, LoadOptions, LoadStep, } from "./load.js";