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

package/dist/steps/applyInput.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Modifier = exports.ApplyInputStep = void 0;
+exports.inputArgsApply = inputArgsApply;
+exports.applyInput = applyInput;
+exports.isModifier = isModifier;
+exports.assertModifier = assertModifier;
+exports.isApplyableStep = isApplyableStep;
+const graphql_1 = require("graphql");
+const step_js_1 = require("../step.js");
+const index_js_1 = require("./index.js");
+let currentModifiers = [];
+let applyingModifiers = false;
+let inputArgsApplyDepth = 0;
+class ApplyInputStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "ApplyInputStep",
+    }; }
+    constructor(inputType, $value, getTargetFromParent) {
+        super();
+        this.inputType = inputType;
+        this.getTargetFromParent = getTargetFromParent;
+        this.isSyncAndSafe = true;
+        this.allowMultipleOptimizations = true;
+        this.valueDepId = this.addUnaryDependency($value);
+        if (!this._isUnary) {
+            throw new Error(`applyInput() must be unary`);
+        }
+        this._isUnaryLocked = true;
+    }
+    deduplicate(peers) {
+        return peers.filter((p) => p.inputType === this.inputType &&
+            p.getTargetFromParent === this.getTargetFromParent);
+    }
+    optimize() {
+        const $value = this.getDep(this.valueDepId);
+        if ($value instanceof index_js_1.ConstantStep) {
+            // Replace myself with a constant!
+            const { operationPlan: { schema }, inputType, getTargetFromParent, } = this;
+            const { data } = $value;
+            return (0, index_js_1.constant)(function applyInputConstant(parent) {
+                inputArgsApply(schema, inputType, parent, data, getTargetFromParent);
+            }, false);
+        }
+        return this;
+    }
+    unbatchedExecute(extra, value) {
+        const { getTargetFromParent } = this;
+        return (parentThing) => inputArgsApply(this.operationPlan.schema, this.inputType, parentThing, value, getTargetFromParent);
+    }
+}
+exports.ApplyInputStep = ApplyInputStep;
+function inputArgsApply(schema, inputType, parent, inputValue, getTargetFromParent) {
+    try {
+        inputArgsApplyDepth++;
+        const target = getTargetFromParent
+            ? getTargetFromParent(parent, inputValue)
+            : parent;
+        if (target != null) {
+            _inputArgsApply(schema, inputType, target, inputValue);
+        }
+    }
+    finally {
+        inputArgsApplyDepth--;
+    }
+    let l;
+    if (inputArgsApplyDepth === 0 && (l = currentModifiers.length) > 0) {
+        applyingModifiers = true;
+        try {
+            for (let i = l - 1; i >= 0; i--) {
+                currentModifiers[i].apply();
+            }
+        }
+        finally {
+            applyingModifiers = false;
+            currentModifiers = [];
+        }
+    }
+}
+function applyInput(inputType, $value, getTargetFromParent) {
+    const opPlan = (0, index_js_1.operationPlan)();
+    const { schema } = opPlan;
+    return opPlan.withRootLayerPlan(() => {
+        if ($value instanceof index_js_1.ConstantStep) {
+            // Replace us with a constant
+            const { data } = $value;
+            return (0, index_js_1.constant)(function applyInputConstant(parent) {
+                inputArgsApply(schema, inputType, parent, data, getTargetFromParent);
+            }, false);
+        }
+        else {
+            return new ApplyInputStep(inputType, $value, getTargetFromParent);
+        }
+    });
+}
+/*
+const defaultInputObjectTypeInputPlanResolver: InputObjectTypeInputPlanResolver =
+  (input, info) => {
+    const fields = info.type.getFields();
+    const obj: { [key: string]: ExecutableStep } = Object.create(null);
+    for (const fieldName in fields) {
+      obj[fieldName] = input.get(fieldName);
+    }
+    return object(obj);
+  };
+*/
+function _inputArgsApply(schema, inputType, target, inputValue) {
+    // PERF: we should have the plan generate a digest of `inputType` so that we
+    // can jump right to the relevant parts without too much traversal cost.
+    if (inputValue === undefined) {
+        return;
+    }
+    if ((0, graphql_1.isNonNullType)(inputType)) {
+        if (inputValue === null) {
+            throw new Error(`null value found in non-null position`);
+        }
+        _inputArgsApply(schema, inputType.ofType, target, inputValue);
+    }
+    else if ((0, graphql_1.isListType)(inputType)) {
+        if (inputValue == null)
+            return;
+        if (!Array.isArray(inputValue)) {
+            throw new Error(`Expected list in list position`);
+        }
+        for (const item of inputValue) {
+            const itemTarget = typeof target === "function" ? target() : target;
+            _inputArgsApply(schema, inputType.ofType, itemTarget, item);
+        }
+    }
+    else if (typeof target === "function") {
+        throw new Error("Functions may only be used as the target for list types (the function is called once per list item)");
+    }
+    else if ((0, graphql_1.isInputObjectType)(inputType)) {
+        if (inputValue === null) {
+            return;
+        }
+        const fields = inputType.getFields();
+        for (const [fieldName, field] of Object.entries(fields)) {
+            const val = inputValue[fieldName];
+            if (val === undefined)
+                continue;
+            if (field.extensions.grafast?.apply) {
+                const newTarget = field.extensions.grafast.apply(target, val, {
+                    schema,
+                    field,
+                    fieldName,
+                });
+                if (newTarget != null) {
+                    _inputArgsApply(schema, field.type, newTarget, val);
+                }
+            }
+        }
+    }
+    else if ((0, graphql_1.isScalarType)(inputType)) {
+        // if (inputType.extensions.grafast?.apply) {
+        // }
+    }
+    else if ((0, graphql_1.isEnumType)(inputType)) {
+        if (inputValue === null) {
+            return;
+        }
+        const values = inputType.getValues();
+        const value = values.find((v) => v.value === inputValue);
+        if (value) {
+            if (value.extensions.grafast?.apply) {
+                value.extensions.grafast.apply(target);
+            }
+        }
+        else {
+            throw new Error(`Couldn't find value in ${inputType} for ${inputValue}`);
+        }
+    }
+    else {
+        const never = inputType;
+        throw new Error(`Input type expected, but found ${never}`);
+    }
+}
+/**
+ * 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.
+ */
+class Modifier {
+    constructor(parent) {
+        this.parent = parent;
+        if (applyingModifiers) {
+            throw new Error(`Must not create new modifier whilst modifiers are being applied!`);
+        }
+        currentModifiers.push(this);
+    }
+}
+exports.Modifier = Modifier;
+function isModifier(plan) {
+    return plan instanceof Modifier;
+}
+function assertModifier(plan, pathDescription) {
+    if (!isModifier(plan)) {
+        throw new Error(`The plan returned from '${pathDescription}' should be a modifier plan, but it does not implement the 'apply' method.`);
+    }
+}
+function isApplyableStep(s) {
+    return typeof s.apply === "function";
+}
+//# sourceMappingURL=applyInput.js.map

package/dist/steps/applyTransforms.d.ts

@@ -1,9 +1,9 @@
-import { ExecutableStep } from "../step.js";
+import { Step } from "../step.js";
 /**
  * If you want to use a step that might represent a list and you need all of
  * the `listItem` transforms to have already taken place (e.g. you're going to
  * send the result to an external service) rather than processing them through
  * the GraphQL response, then you may need to call `applyTransforms` on it.
  */
-export declare function applyTransforms($step: ExecutableStep): ExecutableStep<any>;
+export declare function applyTransforms($step: Step): Step<any>;
 //# sourceMappingURL=applyTransforms.d.ts.map

package/dist/steps/applyTransforms.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyTransforms = exports.ApplyTransformsStep = void 0;
+exports.ApplyTransformsStep = void 0;
+exports.applyTransforms = applyTransforms;
 const tslib_1 = require("tslib");
 const assert = tslib_1.__importStar(require("../assert.js"));
 const dev_js_1 = require("../dev.js");
@@ -11,18 +12,20 @@ const error_js_1 = require("../error.js");
 const interfaces_js_1 = require("../interfaces.js");
 const step_js_1 = require("../step.js");
 const __item_js_1 = require("./__item.js");
+const connection_js_1 = require("./connection.js");
 /**
  * @internal
  */
-class ApplyTransformsStep extends step_js_1.ExecutableStep {
+class ApplyTransformsStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ApplyTransformsStep",
     }; }
-    constructor(listPlan) {
+    constructor($step) {
         super();
         // OPTIMIZE: if all the steps in the inner bucket are synchronous then theoretically we can be synchronous too
         this.isSyncAndSafe = false;
+        const listPlan = (0, connection_js_1.itemsOrStep)($step);
         this.addDependency(listPlan);
         // Plan this subroutine
         this.subroutineLayer = new LayerPlan_js_1.LayerPlan(this.operationPlan, this.layerPlan, {
@@ -65,7 +68,7 @@ class ApplyTransformsStep extends step_js_1.ExecutableStep {
             throw new Error("GrafastInternalError<b3a2bff9-15c6-47e2-aa82-19c862324f1a>: listItem layer plan has no rootStepId");
         }
         if (itemStep._isUnary) {
-            store.set(itemStepId, (0, executeBucket_js_1.unaryExecutionValue)(values0.at(0)));
+            store.set(itemStepId, (0, executeBucket_js_1.unaryExecutionValue)(values0.unaryValue()));
         }
         else {
             store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)([]));
@@ -167,5 +170,4 @@ function applyTransforms($step) {
         return $step;
     }
 }
-exports.applyTransforms = applyTransforms;
 //# sourceMappingURL=applyTransforms.js.map

package/dist/steps/bakedInput.d.ts

@@ -0,0 +1,23 @@
+import type { GraphQLInputObjectType, GraphQLInputType, GraphQLList, GraphQLSchema } from "graphql";
+import type { UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
+export declare class BakedInputStep<TData = any> extends UnbatchedStep<TData> {
+    private inputType;
+    static $$export: {
+        moduleName: string;
+        exportName: string;
+    };
+    isSyncAndSafe: boolean;
+    valueDepId: 0;
+    constructor(inputType: GraphQLInputObjectType | GraphQLList<any>, $value: Step);
+    deduplicate(peers: readonly BakedInputStep[]): BakedInputStep<any>[];
+    unbatchedExecute(extra: UnbatchedExecutionExtra, value: unknown): TData;
+}
+/**
+ * Takes a input type and matching value and performs runtime conversion of
+ * that type to the internal representation (if any).
+ */
+export declare function bakedInput<TArg = any>(inputType: GraphQLInputType, $value: Step): Step<any>;
+export declare function bakedInputRuntime(schema: GraphQLSchema, inputType: GraphQLInputType, value: unknown): unknown;
+//# sourceMappingURL=bakedInput.d.ts.map

package/dist/steps/bakedInput.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BakedInputStep = void 0;
+exports.bakedInput = bakedInput;
+exports.bakedInputRuntime = bakedInputRuntime;
+const graphql_1 = require("graphql");
+const step_js_1 = require("../step.js");
+const applyInput_js_1 = require("./applyInput.js");
+const index_js_1 = require("./index.js");
+class BakedInputStep extends step_js_1.UnbatchedStep {
+    static { this.$$export = {
+        moduleName: "grafast",
+        exportName: "BakedInputStep",
+    }; }
+    constructor(inputType, $value) {
+        super();
+        this.inputType = inputType;
+        this.isSyncAndSafe = true;
+        this.valueDepId = this.addUnaryDependency($value);
+        if (!this._isUnary) {
+            throw new Error(`bakedInput() must be unary`);
+        }
+        this._isUnaryLocked = true;
+    }
+    deduplicate(peers) {
+        return peers.filter((p) => p.inputType === this.inputType);
+    }
+    unbatchedExecute(extra, value) {
+        if (value == null)
+            return value;
+        return bakedInputRuntime(this.operationPlan.schema, this.inputType, value);
+    }
+}
+exports.BakedInputStep = BakedInputStep;
+/**
+ * Takes a input type and matching value and performs runtime conversion of
+ * that type to the internal representation (if any).
+ */
+function bakedInput(inputType, $value) {
+    const nullableInputType = (0, graphql_1.getNullableType)(inputType);
+    // Could have done this in `optimize()` but faster to do it here.
+    if ((0, graphql_1.isListType)(nullableInputType) ||
+        ((0, graphql_1.isInputObjectType)(nullableInputType) &&
+            typeof nullableInputType.extensions?.grafast?.baked === "function")) {
+        // Ooo, we're fancy! Do the thing!
+        return (0, index_js_1.operationPlan)().withRootLayerPlan(() => new BakedInputStep(nullableInputType, $value));
+    }
+    else {
+        // Nothing special, we just return the input.
+        return $value;
+    }
+}
+function bakedInputRuntime(schema, inputType, value) {
+    if (value == null)
+        return value;
+    const nullableInputType = (0, graphql_1.getNullableType)(inputType);
+    if ((0, graphql_1.isListType)(nullableInputType)) {
+        if (Array.isArray(value)) {
+            return value.map((v) => bakedInputRuntime(schema, nullableInputType.ofType, v));
+        }
+        else {
+            throw new Error(`Failed to process input for type ${inputType} - expected array`);
+        }
+    }
+    // Could have done this in `optimize()` but faster to do it here.
+    const baked = (0, graphql_1.isInputObjectType)(nullableInputType)
+        ? nullableInputType.extensions?.grafast?.baked
+        : null;
+    if (typeof baked !== "function") {
+        // Nothing special, we just return the input.
+        return value;
+    }
+    else {
+        // Ooo, we're fancy! Do the thing!
+        let applied = false;
+        const bakedObj = baked(value, {
+            type: nullableInputType,
+            schema,
+            applyChildren(parent) {
+                applied = true;
+                (0, applyInput_js_1.inputArgsApply)(schema, nullableInputType, parent, value, undefined);
+            },
+        });
+        if (!applied) {
+            (0, applyInput_js_1.inputArgsApply)(schema, nullableInputType, bakedObj, value, undefined);
+        }
+        return bakedObj;
+    }
+}
+//# sourceMappingURL=bakedInput.js.map

package/dist/steps/condition.d.ts

@@ -1,11 +1,12 @@
-import type { ExecutableStep, UnbatchedExecutionExtra } from "..";
-import { UnbatchedExecutableStep } from "../step.js";
+import type { UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
+import { UnbatchedStep } from "../step.js";
 declare const unaryOperators: readonly ["null", "not null", "exists", "not exists"];
 type UnaryOperator = (typeof unaryOperators)[number];
 declare const binaryOperators: readonly ["===", "!=="];
 type BinaryOperator = (typeof binaryOperators)[number];
 type Operator = UnaryOperator | BinaryOperator;
-export declare class ConditionStep extends UnbatchedExecutableStep<boolean> {
+export declare class ConditionStep extends UnbatchedStep<boolean> {
     private op;
     static $$export: {
         moduleName: string;
@@ -19,8 +20,7 @@ export declare class ConditionStep extends UnbatchedExecutableStep<boolean> {
     private makeUnbatchedExecute;
     unbatchedExecute(_extra: UnbatchedExecutionExtra, _value1: any, _value2: any): boolean;
 }
-type Step<T = any> = ExecutableStep<T>;
-type $Boolean = ExecutableStep<boolean>;
+type $Boolean = Step<boolean>;
 declare function condition(op: "null", step: Step): $Boolean;
 declare function condition(op: "not null", step: Step): $Boolean;
 declare function condition(op: "exists", step: Step): $Boolean;

package/dist/steps/condition.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.condition = exports.ConditionStep = void 0;
+exports.ConditionStep = void 0;
+exports.condition = condition;
 const step_js_1 = require("../step.js");
 const unaryOperators = ["null", "not null", "exists", "not exists"];
 const binaryOperators = ["===", "!=="];
-class ConditionStep extends step_js_1.UnbatchedExecutableStep {
+class ConditionStep extends step_js_1.UnbatchedStep {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ConditionStep",
@@ -90,5 +91,4 @@ function isNotEqual(_extra, value1, value2) {
 function condition(op, step1, step2) {
     return new ConditionStep(op, step1, step2);
 }
-exports.condition = condition;
 //# sourceMappingURL=condition.js.map

package/dist/steps/connection.d.ts

@@ -1,23 +1,23 @@
-import type { ExecutionDetails, GrafastResultsList, InputStep, UnbatchedExecutionExtra } 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,18 +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>, TEdgeDataStep extends ExecutableStep = TItemStep, TNodeStep extends ExecutableStep = ExecutableStep> extends UnbatchedExecutableStep<unknown> {
+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;
@@ -52,19 +53,19 @@ export declare class ConnectionStep<TItemStep extends ExecutableStep, TCursorSte
     readonly edgeDataPlan?: ($item: TItemStep) => TEdgeDataStep;
     /** The node plan */
     readonly itemPlan?: ($item: TItemStep) => TNodeStep;
-    readonly cursorPlan?: ($item: TItemStep) => ExecutableStep<string | null> | undefined;
+    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.
      */
@@ -94,21 +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;
-    get(fieldName: string): ExecutableStep<any> | undefined;
-    edges(): ExecutableStep;
+    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, }: 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>, TEdgeDataStep extends ExecutableStep = TItemStep, 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;
@@ -119,26 +120,28 @@ export declare class EdgeStep<TItemStep extends ExecutableStep, TCursorStep exte
     private readonly cursorDepId;
     private needCursor;
     constructor($connection: ConnectionStep<TItemStep, TCursorStep, TStep, TEdgeDataStep, TNodeStep>, $item: TItemStep, skipCursor?: boolean);
-    get(fieldName: string): ExecutableStep<string | null> | TNodeStep | undefined;
+    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, ExecutableStep<any>>;
+    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: UnbatchedExecutionExtra, record: any, cursor: any): any;
 }
-interface ConnectionConfig<TItemStep extends ExecutableStep, TEdgeDataStep extends ExecutableStep = TItemStep, TNodeStep extends ExecutableStep = ExecutableStep> {
+interface ConnectionConfig<TItemStep extends Step, TEdgeDataStep extends Step = TItemStep, TNodeStep extends Step = Step> {
     nodePlan?: ($item: TItemStep) => TNodeStep;
     edgeDataPlan?: ($item: TItemStep) => TEdgeDataStep;
-    cursorPlan?: ($item: TItemStep) => ExecutableStep<string | null>;
+    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>, TEdgeDataStep extends ExecutableStep = TItemStep, TNodeStep extends ExecutableStep = ExecutableStep>(step: TStep, config?: ConnectionConfig<TItemStep, TEdgeDataStep, TNodeStep>): ConnectionStep<TItemStep, TCursorStep, TStep, TEdgeDataStep, 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