grafast 0.1.1-beta.21 → 0.1.1-beta.22

package/dist/steps/load.d.ts

@@ -1,4 +1,4 @@
-import type { __ItemStep, ExecutionDetails } from "../index.js";
+import type { ExecutionDetails } from "../index.js";
 import type { GrafastResultsList, Maybe, PromiseOrDirect } from "../interfaces.js";
 import type { Multistep, UnwrapMultistep } from "../multistep.js";
 import { Step } from "../step.js";
@@ -7,26 +7,27 @@ export interface LoadOptions<TItem, TParams extends Record<string, any>, TUnaryS
     attributes: ReadonlyArray<keyof TItem>;
     params: Partial<TParams>;
 }
-type LoadCallback<TSpec, TItem, TData extends TItem | ReadonlyArray<TItem>, TParams extends Record<string, any>, TUnarySpec = never> = {
-    (specs: ReadonlyArray<TSpec>, options: LoadOptions<TItem, TParams, TUnarySpec>): PromiseOrDirect<ReadonlyArray<Maybe<TData>>>;
+type LoadCallback<TSpec, TItem, TData extends Maybe<TItem> | Maybe<ReadonlyArray<Maybe<TItem>>>, // loadMany
+TParams extends Record<string, any>, TUnarySpec = never> = {
+    (specs: ReadonlyArray<TSpec>, options: LoadOptions<TItem, TParams, TUnarySpec>): PromiseOrDirect<ReadonlyArray<TData>>;
     displayName?: string;
 };
-export type LoadOneCallback<TSpec, TItem, TParams extends Record<string, any>, TUnarySpec = never> = LoadCallback<TSpec, TItem, TItem, TParams, TUnarySpec>;
-export type LoadManyCallback<TSpec, TItem, TParams extends Record<string, any>, TUnarySpec = never> = LoadCallback<TSpec, TItem, ReadonlyArray<TItem>, TParams, TUnarySpec>;
+export type LoadOneCallback<TSpec, TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>, TUnarySpec = never> = LoadCallback<TSpec, TItem, TData, TParams, TUnarySpec>;
+export type LoadManyCallback<TSpec, TItem, TData extends Maybe<ReadonlyArray<Maybe<TItem>>> = Maybe<ReadonlyArray<Maybe<TItem>>>, TParams extends Record<string, any> = Record<string, any>, TUnarySpec = never> = LoadCallback<TSpec, TItem, TData, TParams, TUnarySpec>;
 /**
  * A TypeScript Identity Function to help you strongly type your
  * LoadOneCallback.
  */
-export declare function loadOneCallback<TSpec, TItem, TParams extends Record<string, any>, TUnarySpec = never>(callback: LoadOneCallback<TSpec, TItem, TParams, TUnarySpec>): LoadOneCallback<TSpec, TItem, TParams, TUnarySpec>;
+export declare function loadOneCallback<TSpec, TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>, TUnarySpec = never>(callback: LoadOneCallback<TSpec, TItem, TData, TParams, TUnarySpec>): LoadOneCallback<TSpec, TItem, TData, TParams, TUnarySpec>;
 /**
  * A TypeScript Identity Function to help you strongly type your
  * LoadManyCallback.
  */
-export declare function loadManyCallback<TSpec, TItem, TParams extends Record<string, any>, TUnarySpec = never>(callback: LoadManyCallback<TSpec, TItem, TParams, TUnarySpec>): LoadManyCallback<TSpec, TItem, TParams, TUnarySpec>;
+export declare function loadManyCallback<TSpec, TItem, TData extends Maybe<ReadonlyArray<Maybe<TItem>>> = Maybe<ReadonlyArray<Maybe<TItem>>>, TParams extends Record<string, any> = Record<string, any>, TUnarySpec = never>(callback: LoadManyCallback<TSpec, TItem, TData, TParams, TUnarySpec>): LoadManyCallback<TSpec, TItem, TData, TParams, TUnarySpec>;
 /**
  * You shouldn't create instances of this yourself - use `loadOne` or `loadMany` instead.
  */
-export declare class LoadedRecordStep<TItem, TParams extends Record<string, any> = Record<string, any>> extends Step<TItem> {
+export declare class LoadedRecordStep<TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>> extends Step<TData> {
     private isSingle;
     private sourceDescription;
     private ioEquivalence;
@@ -37,15 +38,18 @@ export declare class LoadedRecordStep<TItem, TParams extends Record<string, any>
     isSyncAndSafe: boolean;
     attributes: Set<keyof TItem>;
     params: Partial<TParams>;
-    constructor($data: Step<TItem>, isSingle: boolean, sourceDescription: string, ioEquivalence: Record<string, Step>);
+    constructor($data: Step<TData>, isSingle: boolean, sourceDescription: string, ioEquivalence: Record<string, Step>);
     toStringMeta(): string;
     get(attr: keyof TItem & (string | number)): Step<any>;
     private _getInner;
     setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
+    deduplicate(peers: LoadedRecordStep<any, any>[]): LoadedRecordStep<any, any, Record<string, any>>[];
+    deduplicatedWith(replacement: LoadedRecordStep<any, any>): void;
     optimize(): Step<any> | import("./__flag.js").__FlagStep<Step<any>>;
-    execute({ count, values: [values0], }: ExecutionDetails<[TItem]>): GrafastResultsList<TItem>;
+    execute({ count, values: [values0], }: ExecutionDetails<[TData]>): GrafastResultsList<TData>;
 }
-export declare class LoadStep<const TMultistep extends Multistep, TItem, TData extends TItem | ReadonlyArray<TItem>, TParams extends Record<string, any>, const TUnaryMultistep extends Multistep = never> extends Step {
+export declare class LoadStep<const TMultistep extends Multistep, TItem, TData extends Maybe<TItem> | Maybe<ReadonlyArray<Maybe<TItem>>>, // loadMany
+TParams extends Record<string, any>, const TUnaryMultistep extends Multistep = never> extends Step<TData> {
     private ioEquivalence;
     private load;
     static $$export: {
@@ -61,28 +65,30 @@ export declare class LoadStep<const TMultistep extends Multistep, TItem, TData e
     constructor(spec: TMultistep, unarySpec: TUnaryMultistep | null, ioEquivalence: IOEquivalence<TMultistep>, load: LoadCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>);
     toStringMeta(): string;
     private makeAccessMap;
-    listItem($item: __ItemStep<TItem>): LoadedRecordStep<TItem, TParams>;
-    single(): TData extends ReadonlyArray<any> ? never : LoadedRecordStep<TItem, TParams>;
+    listItem($item: Step): LoadedRecordStep<TItem, TData extends Maybe<readonly (infer U)[]> ? U extends Maybe<TItem> ? U : never : never, TParams>;
+    single(): TData extends Maybe<TItem> ? LoadedRecordStep<TItem, TData, TParams> : never;
     setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
     addAttributes(attributes: Set<keyof TItem>): void;
+    deduplicate(peers: readonly LoadStep<any, any, any, any, any>[]): LoadStep<any, any, any, any, any>[];
+    deduplicatedWith(replacement: LoadStep<any, any, any, any, any>): void;
     finalize(): void;
     execute({ count, values: [values0, values1], extra, }: ExecutionDetails<[
         UnwrapMultistep<TMultistep>,
         UnwrapMultistep<TUnaryMultistep>
-    ]>): PromiseOrDirect<GrafastResultsList<Maybe<TData>>>;
+    ]>): PromiseOrDirect<GrafastResultsList<TData>>;
 }
-export declare function loadMany<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, ReadonlyArray<TItem>, TParams, UnwrapMultistep<TUnaryMultistep>>;
-export declare function loadMany<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, ReadonlyArray<TItem>, TParams, UnwrapMultistep<TUnaryMultistep>>;
-export declare function loadMany<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, ReadonlyArray<TItem>, TParams, UnwrapMultistep<TUnaryMultistep>>;
-export declare function loadMany<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, ReadonlyArray<TItem>, TParams, UnwrapMultistep<TUnaryMultistep>>;
+export declare function loadMany<const TMultistep extends Multistep, TItem, TData extends Maybe<ReadonlyArray<Maybe<TItem>>> = Maybe<ReadonlyArray<Maybe<TItem>>>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>;
+export declare function loadMany<const TMultistep extends Multistep, TItem, TData extends Maybe<ReadonlyArray<Maybe<TItem>>> = Maybe<ReadonlyArray<Maybe<TItem>>>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>;
+export declare function loadMany<const TMultistep extends Multistep, TItem, TData extends Maybe<ReadonlyArray<Maybe<TItem>>> = Maybe<ReadonlyArray<Maybe<TItem>>>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>;
+export declare function loadMany<const TMultistep extends Multistep, TItem, TData extends Maybe<ReadonlyArray<Maybe<TItem>>> = Maybe<ReadonlyArray<Maybe<TItem>>>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadManyCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadStep<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>;
 type IOEquivalence<TMultistep extends Multistep> = null | string | (UnwrapMultistep<TMultistep> extends readonly [...(readonly any[])] ? {
     [key in Exclude<keyof UnwrapMultistep<TMultistep>, keyof any[]>]: string | null;
 } : UnwrapMultistep<TMultistep> extends Record<string, any> ? {
     [key in keyof UnwrapMultistep<TMultistep>]?: string | null;
 } : never);
-export declare function loadOne<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TParams>;
-export declare function loadOne<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TParams>;
-export declare function loadOne<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TParams>;
-export declare function loadOne<const TMultistep extends Multistep, TItem, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TParams>;
+export declare function loadOne<const TMultistep extends Multistep, TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TData, TParams>;
+export declare function loadOne<const TMultistep extends Multistep, TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TData, TParams>;
+export declare function loadOne<const TMultistep extends Multistep, TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TData, TParams>;
+export declare function loadOne<const TMultistep extends Multistep, TItem, TData extends Maybe<TItem> = Maybe<TItem>, TParams extends Record<string, any> = Record<string, any>, const TUnaryMultistep extends Multistep = never>(spec: TMultistep, unarySpec: TUnaryMultistep | null, ioEquivalence: IOEquivalence<TMultistep>, loadCallback: LoadOneCallback<UnwrapMultistep<TMultistep>, TItem, TData, TParams, UnwrapMultistep<TUnaryMultistep>>): LoadedRecordStep<TItem, TData, TParams>;
 export {};
 //# sourceMappingURL=load.d.ts.map

package/dist/steps/load.js

@@ -10,6 +10,9 @@ const multistep_js_1 = require("../multistep.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
 const access_js_1 = require("./access.js");
+const nextTick = typeof process !== "undefined" && typeof process.nextTick === "function"
+    ? (cb) => process.nextTick(cb)
+    : (cb) => setTimeout(cb, 0);
 /**
  * A TypeScript Identity Function to help you strongly type your
  * LoadOneCallback.
@@ -67,6 +70,17 @@ class LoadedRecordStep extends step_js_1.Step {
         }
         this.params[paramKey] = value;
     }
+    deduplicate(peers) {
+        return peers.filter((p) => p.isSingle === this.isSingle &&
+            p.sourceDescription === this.sourceDescription &&
+            (0, utils_js_1.recordsMatch)(p.ioEquivalence, this.ioEquivalence) &&
+            (0, utils_js_1.recordsMatch)(p.params, this.params));
+    }
+    deduplicatedWith(replacement) {
+        for (const attr of this.attributes) {
+            replacement.attributes.add(attr);
+        }
+    }
     optimize() {
         const $source = this.getDepDeep(0);
         if ($source instanceof LoadStep) {
@@ -161,6 +175,16 @@ class LoadStep extends step_js_1.Step {
             this.attributes.add(attribute);
         }
     }
+    deduplicate(peers) {
+        return peers.filter((p) => p.load === this.load &&
+            ioEquivalenceMatches(p.ioEquivalence, this.ioEquivalence) &&
+            (0, utils_js_1.recordsMatch)(p.params, this.params));
+    }
+    deduplicatedWith(replacement) {
+        for (const attr of this.attributes) {
+            replacement.attributes.add(attr);
+        }
+    }
     finalize() {
         // Find all steps of this type that use the same callback and have
         // equivalent params and then match their list of attributes together.
@@ -242,7 +266,7 @@ class LoadStep extends step_js_1.Step {
                 meta.loadBatchesByLoad.set(this.load, loadBatches);
                 // Guaranteed by the metaKey to be equivalent for all entries sharing the same `meta`. Note equivalent is not identical; key order may change.
                 const loadOptions = this.loadOptions;
-                process.nextTick(() => {
+                nextTick(() => {
                     // Don't allow adding anything else to the batch
                     meta.loadBatchesByLoad.delete(this.load);
                     executeBatches(loadBatches, this.load, {
@@ -340,4 +364,26 @@ function loadOne(spec, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoE
         return load(spec, null, null, loadCallbackOrIoEquivalenceOrUnarySpec).single();
     }
 }
+function ioEquivalenceMatches(io1, io2) {
+    if (io1 === io2)
+        return true;
+    if (io1 == null)
+        return false;
+    if (io2 == null)
+        return false;
+    if (typeof io1 === "string")
+        return false;
+    if (typeof io2 === "string")
+        return false;
+    if (Array.isArray(io1)) {
+        if (!Array.isArray(io2))
+            return false;
+        return (0, utils_js_1.arraysMatch)(io1, io2);
+    }
+    else {
+        if (Array.isArray(io2))
+            return false;
+        return (0, utils_js_1.recordsMatch)(io1, io2);
+    }
+}
 //# sourceMappingURL=load.js.map

package/dist/steps/node.d.ts

@@ -1,6 +1,5 @@
-import type { GraphQLObjectType } from "graphql";
-import type { Maybe, NodeIdHandler, PolymorphicData, UnbatchedExecutionExtra } from "../interfaces.js";
-import type { PolymorphicStep, Step } from "../step.js";
+import type { Maybe, NodeIdHandler, UnbatchedExecutionExtra } from "../interfaces.js";
+import type { Step } from "../step.js";
 import { UnbatchedStep } from "../step.js";
 /**
  * A plan to get a Node by its global object identifier (string). Accepts an
@@ -8,7 +7,10 @@ import { UnbatchedStep } from "../step.js";
  * typeNames supported and their details (codec to use, how to find the record,
  * etc), and finally the Node id string plan.
  */
-export declare class NodeStep extends UnbatchedStep implements PolymorphicStep {
+export declare class NodeStep extends UnbatchedStep<{
+    __typename: string;
+    specifier: any;
+} | null> {
     private possibleTypes;
     static $$export: {
         moduleName: string;
@@ -16,13 +18,14 @@ export declare class NodeStep extends UnbatchedStep implements PolymorphicStep {
     };
     isSyncAndSafe: boolean;
     allowMultipleOptimizations: boolean;
-    private specPlanDep;
     constructor(possibleTypes: {
         [typeName: string]: NodeIdHandler;
     }, $id: Step<string | null | undefined>);
-    planForType(type: GraphQLObjectType): Step;
     private getTypeNameFromSpecifier;
-    unbatchedExecute: (_extra: UnbatchedExecutionExtra, specifier: any) => PolymorphicData<string, ReadonlyArray<any>> | null;
+    unbatchedExecute(_extra: UnbatchedExecutionExtra, specifier: any): {
+        __typename: string;
+        specifier: any;
+    } | null;
 }
 /**
  * A plan to get a Node by its global object identifier (string). Accepts an

package/dist/steps/node.js

@@ -8,10 +8,7 @@ exports.makeDecodeNodeIdRuntime = makeDecodeNodeIdRuntime;
 exports.makeDecodeNodeId = makeDecodeNodeId;
 const dev_js_1 = require("../dev.js");
 const inspect_js_1 = require("../inspect.js");
-const polymorphic_js_1 = require("../polymorphic.js");
 const step_js_1 = require("../step.js");
-const access_js_1 = require("./access.js");
-const constant_js_1 = require("./constant.js");
 const lambda_js_1 = require("./lambda.js");
 /**
  * A plan to get a Node by its global object identifier (string). Accepts an
@@ -29,23 +26,8 @@ class NodeStep extends step_js_1.UnbatchedStep {
         this.possibleTypes = possibleTypes;
         this.isSyncAndSafe = true;
         this.allowMultipleOptimizations = true;
-        this.unbatchedExecute = (_extra, specifier) => {
-            const typeName = specifier
-                ? this.getTypeNameFromSpecifier(specifier)
-                : null;
-            return typeName ? (0, polymorphic_js_1.polymorphicWrap)(typeName) : null;
-        };
         const decodeNodeId = makeDecodeNodeId(Object.values(possibleTypes));
-        this.specPlanDep = this.addDependency(decodeNodeId($id));
-    }
-    planForType(type) {
-        const spec = this.possibleTypes[type.name];
-        if (spec !== undefined) {
-            return spec.get(spec.getSpec((0, access_js_1.access)(this.getDep(this.specPlanDep), [spec.codec.name])));
-        }
-        else {
-            return (0, constant_js_1.constant)(null);
-        }
+        this.addDependency(decodeNodeId($id));
     }
     getTypeNameFromSpecifier(specifier) {
         for (const [typeName, typeSpec] of Object.entries(this.possibleTypes)) {
@@ -59,6 +41,10 @@ class NodeStep extends step_js_1.UnbatchedStep {
         }
         return null;
     }
+    unbatchedExecute(_extra, specifier) {
+        const __typename = specifier != null ? this.getTypeNameFromSpecifier(specifier) : null;
+        return __typename != null ? { __typename, specifier } : null;
+    }
 }
 exports.NodeStep = NodeStep;
 /**

package/dist/steps/object.js

@@ -5,6 +5,7 @@ exports.ObjectStep = void 0;
 exports.object = object;
 const tslib_1 = require("tslib");
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
+const dev_js_1 = require("../dev.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
 const constant_js_1 = require("./constant.js");
@@ -200,7 +201,11 @@ ${inner}
     get(key) {
         const index = this.keys.indexOf(key);
         if (index < 0) {
-            throw new Error(`This ObjectStep doesn't have key '${String(key)}'; supported keys: '${this.keys.join("', '")}'`);
+            if (dev_js_1.isDev) {
+                // TODO: move this to diagnostics
+                console.warn(`${this} doesn't have key '${String(key)}'; supported keys: '${this.keys.join("', '")}'`);
+            }
+            return (0, constant_js_1.constant)(undefined);
         }
         return this.getDepOptions(index).step;
     }

package/dist/steps/proxy.d.ts

@@ -1,5 +1,4 @@
 import type { ExecutionDetails, GrafastResultsList, UnbatchedExecutionExtra } from "../interfaces.js";
-import { $$proxy } from "../interfaces.js";
 import type { Step } from "../step.js";
 import { UnbatchedStep } from "../step.js";
 /**
@@ -21,11 +20,6 @@ export declare class ProxyStep<T> extends UnbatchedStep<T> {
     unbatchedExecute(_extra: UnbatchedExecutionExtra, value: T): T;
     stream: undefined;
 }
-declare module "../step.js" {
-    interface Step {
-        [$$proxy]?: any;
-    }
-}
 /**
  * @experimental
  *

package/dist/steps/proxy.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProxyStep = void 0;
 exports.proxy = proxy;
-const interfaces_js_1 = require("../interfaces.js");
+const constants_js_1 = require("../constants.js");
 const step_js_1 = require("../step.js");
 const utils_js_1 = require("../utils.js");
 /**
@@ -53,7 +53,7 @@ function makeProxyHandler($toStep) {
             }
             // DO optimize the proxy-ness away, so execution doesn't need to be proxied
             if (p === "optimize") {
-                delete $proxy[interfaces_js_1.$$proxy];
+                delete $proxy[constants_js_1.$$proxy];
                 return () => [$proxy];
             }
             if (p in $proxy) {
@@ -111,7 +111,7 @@ function makeProxyHandler($toStep) {
 function proxy($step, $actualDep = $step) {
     const $proxy = new ProxyStep($step, $actualDep);
     const proxy = new Proxy($proxy, makeProxyHandler($step)); // Lie.
-    $proxy[interfaces_js_1.$$proxy] = proxy;
+    $proxy[constants_js_1.$$proxy] = proxy;
     return proxy;
 }
 //# sourceMappingURL=proxy.js.map

package/dist/steps/remapKeys.d.ts

@@ -19,7 +19,7 @@ export declare class RemapKeysStep extends UnbatchedStep {
     private mapper;
     constructor($plan: Step, actualKeyByDesiredKey: ActualKeyByDesiredKey);
     toStringMeta(): string;
-    optimize(): Step<any> | this;
+    optimize(): Step;
     finalize(): void;
     execute({ count, values: [values0], }: ExecutionDetails): GrafastResultsList<any>;
     unbatchedExecute(_extra: UnbatchedExecutionExtra, value: any): any;

package/dist/steps/remapKeys.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RemapKeysStep = void 0;
 exports.remapKeys = remapKeys;
 const tslib_1 = require("tslib");
-/* eslint-disable @typescript-eslint/ban-types */
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const tamedevil_1 = tslib_1.__importStar(require("tamedevil"));
 const step_js_1 = require("../step.js");

package/dist/utils.d.ts

@@ -1,8 +1,9 @@
-import type { ConstValueNode, DirectiveNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLOutputType, GraphQLSchema, ValueNode } from "graphql";
+import type { ConstValueNode, DirectiveNode, FieldNode, GraphQLEnumValueConfig, GraphQLFieldConfig, GraphQLInputFieldConfig, GraphQLInputObjectTypeConfig, GraphQLInputType, GraphQLNamedType, GraphQLObjectTypeConfig, GraphQLSchema, ValueNode } from "graphql";
 import * as graphql from "graphql";
 import type { Deferred } from "./deferred.js";
+import type { LayerPlan, LayerPlanReasonDefer, LayerPlanReasonListItem, LayerPlanReasonSubscription } from "./engine/LayerPlan.js";
 import type { OperationPlan } from "./engine/OperationPlan.js";
-import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig, OutputPlanForType } from "./interfaces.js";
+import type { BaseGraphQLArguments, GrafastFieldConfig, GrafastInputFieldConfig } from "./interfaces.js";
 import type { Step } from "./step.js";
 /**
  * The parent object is used as the key in `GetValueStepId()`; for root level
@@ -31,14 +32,31 @@ export declare function isDeferred<T>(t: T | Promise<T> | Deferred<T>): t is Def
  * values within them pass the `comparator` check (which defaults to `===`).
  */
 export declare function arraysMatch<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, comparator?: (val1: T, val2: T) => boolean): boolean;
+/**
+ * Returns true if map1 and map2 have the same keys, and every matching entry
+ * value within them pass the `comparator` check (which defaults to `===`).
+ */
+export declare function mapsMatch<TKey, TVal>(map1: ReadonlyMap<TKey, TVal>, map2: ReadonlyMap<TKey, TVal>, comparator?: (k: TKey, val1: TVal | undefined, val2: TVal | undefined) => boolean): boolean;
+/**
+ * Returns true if record1 and record2 are equivalent, i.e. every value within
+ * them pass the `comparator` check (which defaults to `===`).
+ *
+ * Currently keys are ignored (`record[key] = undefined` is treated the same as
+ * `record[key]` being unset), but this may not always be the case.
+ */
+export declare function recordsMatch<TRecord extends {
+    readonly [k: string | symbol | number]: any;
+}>(record1: TRecord, record2: TRecord, comparator?: (k: keyof TRecord, val1: TRecord[typeof k], val2: TRecord[typeof k]) => boolean): boolean;
+export declare function setsMatch(s1: ReadonlySet<string> | null, s2: ReadonlySet<string> | null): boolean;
 export type ObjectTypeFields<TParentStep extends Step> = {
-    [key: string]: GrafastFieldConfig<GraphQLOutputType, TParentStep, any, any>;
+    [key: string]: GrafastFieldConfig<TParentStep, any, any>;
 };
 export type ObjectTypeSpec<TParentStep extends Step, TFields extends ObjectTypeFields<TParentStep>> = Omit<GraphQLObjectTypeConfig<any, Grafast.Context>, "fields"> & {
     fields: TFields | (() => TFields);
     assertStep?: TParentStep extends Step ? ((step: Step) => asserts step is TParentStep) | {
         new (...args: any[]): TParentStep;
     } : null;
+    planType?: ($specifier: Step) => TParentStep;
 };
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
@@ -57,13 +75,13 @@ export declare function newObjectTypeBuilder<TParentStep extends Step>(assertSte
 /**
  * Saves us having to write `extensions: {grafast: {...}}` everywhere.
  */
-export declare function objectFieldSpec<TSource extends Step, TResult extends Step = Step, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments>(grafastSpec: GrafastFieldConfig<GraphQLOutputType, TSource, TResult, TArgs>, path: string): GraphQLFieldConfig<any, TArgs>;
+export declare function objectFieldSpec<TSource extends Step, TArgs extends BaseGraphQLArguments = BaseGraphQLArguments, TResult extends Step = Step>(grafastSpec: GrafastFieldConfig<TSource, TArgs, TResult>, path: string): GraphQLFieldConfig<any, Grafast.Context, TArgs>;
 /**
  * "Constrainted identity function" for field configs.
  *
  * @see {@link https://kentcdodds.com/blog/how-to-write-a-constrained-identity-function-in-typescript}
  */
-export declare function newGrafastFieldConfigBuilder<TParentStep extends Step>(): <TType extends GraphQLOutputType, TFieldStep extends OutputPlanForType<TType>, TArgs extends BaseGraphQLArguments>(config: GrafastFieldConfig<TType, TParentStep, TFieldStep, TArgs>) => typeof config;
+export declare function newGrafastFieldConfigBuilder<TParentStep extends Step>(): <TArgs extends BaseGraphQLArguments = BaseGraphQLArguments, TFieldStep extends Step = Step>(config: GrafastFieldConfig<TParentStep, TArgs, TFieldStep>) => typeof config;
 export type GrafastInputFieldConfigMap<TParent> = {
     [key: string]: GrafastInputFieldConfig<TParent, GraphQLInputType>;
 };
@@ -116,6 +134,9 @@ export declare function stepADependsOnStepB(stepA: Step, stepB: Step): boolean;
  * mostly relates to heirarchy.)
  */
 export declare function stepAMayDependOnStepB($a: Step, $b: Step): boolean;
+export declare function stepAShouldTryAndInlineIntoStepB($a: Step, $b: Step): boolean;
+export declare function pathsFromAncestorToTargetLayerPlan(ancestor: LayerPlan, lp: LayerPlan): readonly LayerPlan[][];
+export declare function layerPlanHeirarchyContains(lp: LayerPlan, targetLp: LayerPlan): boolean;
 /**
  * For a regular GraphQL query with no `@stream`/`@defer`, the entire result is
  * calculated and then the output is generated and sent to the client at once.
@@ -144,6 +165,7 @@ export declare function stepAMayDependOnStepB($a: Step, $b: Step): boolean;
  * need it.
  */
 export declare function stepsAreInSamePhase(ancestor: Step, descendent: Step): boolean;
+export declare function isPhaseTransitionLayerPlan(layerPlan: LayerPlan): layerPlan is LayerPlan<LayerPlanReasonListItem> | LayerPlan<LayerPlanReasonDefer> | LayerPlan<LayerPlanReasonSubscription>;
 export declare const canonicalJSONStringify: (o: object) => string;
 export declare function assertNotAsync(fn: any, name: string): void;
 export declare function assertNotPromise<TVal>(value: TVal, fn: any, name: string): TVal;