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

package/dist/steps/listTransform.js

@@ -1,14 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listTransform = exports.__ListTransformStep = void 0;
+exports.__ListTransformStep = void 0;
+exports.listTransform = listTransform;
 const tslib_1 = require("tslib");
 const assert = tslib_1.__importStar(require("../assert.js"));
 const dev_js_1 = require("../dev.js");
 const executeBucket_js_1 = require("../engine/executeBucket.js");
 const LayerPlan_js_1 = require("../engine/LayerPlan.js");
 const withGlobalLayerPlan_js_1 = require("../engine/lib/withGlobalLayerPlan.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");
 /**
  * **Experimental.**
  *
@@ -18,7 +21,7 @@ const __item_js_1 = require("./__item.js");
  * It's recommended that you don't use this directly, please use one of the
  * functions that uses this under the hood such as `filter()`.
  */
-class __ListTransformStep extends step_js_1.ExecutableStep {
+class __ListTransformStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "__ListTransformStep",
@@ -27,8 +30,14 @@ class __ListTransformStep extends step_js_1.ExecutableStep {
         super();
         // OPTIMIZE: if all the steps in the inner bucket are synchronous then theoretically we can be synchronous too
         this.isSyncAndSafe = false;
-        const { listStep, itemPlanCallback, initialState, reduceCallback, finalizeCallback, listItem, meta, optimize, connectionClone, } = options;
+        const { listStep: rawListStep, itemPlanCallback, initialState, reduceCallback, finalizeCallback, listItem, meta, optimize, connectionClone, } = options;
+        const listStep = (0, connection_js_1.itemsOrStep)(rawListStep);
         this.listStepDepId = this.addDependency(listStep);
+        // PERF: This is just so we can populate getListStep() correctly... Ideally we could mark this as a "plan-time-only" dependency.
+        this.rawListStepDepId =
+            rawListStep === listStep
+                ? this.listStepDepId
+                : this.addDependency(rawListStep);
         this.itemPlanCallback = itemPlanCallback;
         this.initialState = initialState;
         this.reduceCallback = reduceCallback;
@@ -68,13 +77,13 @@ class __ListTransformStep extends step_js_1.ExecutableStep {
         return this.meta;
     }
     getListStep() {
-        return this.getDep(this.listStepDepId);
+        return this.getDepOptions(this.rawListStepDepId).step;
     }
-    [step_js_1.$$deepDepSkip]() {
+    [interfaces_js_1.$$deepDepSkip]() {
         return this.getListStep();
     }
     dangerouslyGetListPlan() {
-        return this.dependencies[this.listStepDepId];
+        return this.dependencies[this.rawListStepDepId];
     }
     deduplicate(peers) {
         return peers.filter((peer) => peer.itemPlanCallback === this.itemPlanCallback &&
@@ -88,33 +97,49 @@ class __ListTransformStep extends step_js_1.ExecutableStep {
     optimize() {
         return this;
     }
-    async execute(_count, values, extra) {
+    async execute({ indexForEach, indexMap, values, extra, }) {
         const bucket = extra._bucket;
         const childLayerPlan = this.subroutineLayer;
-        const copyStepIds = childLayerPlan.copyStepIds;
+        const { copyStepIds, rootStep } = childLayerPlan;
+        if (rootStep === null) {
+            throw new Error(`rootStep of ${childLayerPlan} must not be null.`);
+        }
         const store = new Map();
         const polymorphicPathList = [];
         const iterators = [];
         const map = new Map();
         let size = 0;
         // ENHANCE: do this better!
-        const itemStepId = this.operationPlan.dangerouslyGetStep(this.itemStepId).id;
+        const itemStep = this.operationPlan.dangerouslyGetStep(this.itemStepId);
+        const itemStepId = itemStep.id;
         if (itemStepId == null) {
             throw new Error("GrafastInternalError<b3a2bff9-15c6-47e2-aa82-19c862324f1a>: listItem layer plan has no rootStepId");
         }
-        store.set(itemStepId, []);
-        // Prepare store with an empty list for each copyPlanId
-        for (const planId of copyStepIds) {
-            store.set(planId, []);
-            if (!bucket.store.has(planId)) {
-                throw new Error(`GrafastInternalError<14f2b4c6-f951-44d6-ad6b-2eace3330b84>: plan '${planId}' (${this.operationPlan.dangerouslyGetStep(planId)}) listed in copyStepIds but not available in parent bucket for ${this}`);
+        const listStepValue = values[this.listStepDepId];
+        if (itemStep._isUnary) {
+            const list = listStepValue.unaryValue();
+            store.set(itemStepId, (0, executeBucket_js_1.unaryExecutionValue)(Array.isArray(list) ? list[0] : list));
+        }
+        else {
+            store.set(itemStepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+        }
+        for (const stepId of copyStepIds) {
+            const ev = bucket.store.get(stepId);
+            if (!ev) {
+                throw new Error(`GrafastInternalError<2be5c2c6-a7f8-4002-93a0-6ace5a89a962>: unary step '${stepId}' (${this.operationPlan.dangerouslyGetStep(stepId)}) listed in copyStepIds but not available in parent bucket for ${this}`);
+            }
+            if (ev.isBatch) {
+                // Prepare store with an empty list for each copyPlanId
+                store.set(stepId, (0, executeBucket_js_1.batchExecutionValue)([]));
+            }
+            else {
+                store.set(stepId, ev);
             }
         }
-        const listValues = values[this.listStepDepId];
         // We'll typically be creating more listItem bucket entries than we
         // have parent buckets, so we must "multiply up" the store entries.
-        for (let originalIndex = 0; originalIndex < listValues.length; originalIndex++) {
-            const list = listValues[originalIndex];
+        indexForEach((originalIndex) => {
+            const list = listStepValue.at(originalIndex);
             if (Array.isArray(list)) {
                 const newIndexes = [];
                 map.set(originalIndex, newIndexes);
@@ -126,27 +151,34 @@ class __ListTransformStep extends step_js_1.ExecutableStep {
                     // Copying across the iterators because we do NOT call outputBucket,
                     // so we need to ensure any streams are cleaned up.
                     iterators[newIndex] = bucket.iterators[originalIndex];
-                    store.get(itemStepId)[newIndex] = list[j];
+                    const ev = store.get(itemStepId);
+                    if (ev.isBatch) {
+                        ev._setResult(newIndex, list[j], 0);
+                    }
                     for (const planId of copyStepIds) {
-                        store.get(planId)[newIndex] =
-                            bucket.store.get(planId)[originalIndex];
+                        const ev = store.get(planId);
+                        if (ev.isBatch) {
+                            const orig = bucket.store.get(planId);
+                            ev._setResult(newIndex, orig.at(originalIndex), orig._flagsAt(originalIndex));
+                        }
                     }
                 }
             }
-        }
+        });
         if (size > 0) {
             const childBucket = (0, executeBucket_js_1.newBucket)({
                 layerPlan: childLayerPlan,
                 size,
                 store,
-                hasErrors: bucket.hasErrors,
+                flagUnion: bucket.flagUnion,
                 polymorphicPathList,
                 iterators,
             }, bucket.metaByMetaKey);
             await (0, executeBucket_js_1.executeBucket)(childBucket, extra._requestContext);
         }
-        const depResults = store.get(childLayerPlan.rootStep.id);
-        return listValues.map((list, originalIndex) => {
+        const depResults = store.get(rootStep.id);
+        return indexMap((originalIndex) => {
+            const list = listStepValue.at(originalIndex);
             if (list == null) {
                 return list;
             }
@@ -156,7 +188,7 @@ class __ListTransformStep extends step_js_1.ExecutableStep {
                 console.warn(`Either list or values was not an array when processing ${this}`);
                 return null;
             }
-            const values = indexes.map((idx) => depResults[idx]);
+            const values = indexes.map((idx) => depResults.at(idx));
             if (dev_js_1.isDev) {
                 assert.strictEqual(list.length, values.length, "GrafastInternalError<c85b6936-d406-4801-9c6b-625a567d32ff>: The list and values length must match for a __ListTransformStep");
             }
@@ -181,5 +213,4 @@ exports.__ListTransformStep = __ListTransformStep;
 function listTransform(options) {
     return new __ListTransformStep(options);
 }
-exports.listTransform = listTransform;
 //# sourceMappingURL=listTransform.js.map

package/dist/steps/listen.d.ts

@@ -1,6 +1,5 @@
-import type { GrafastResultStreamList, GrafastSubscriber, GrafastValuesList } from "../interfaces.js";
-import type { StreamableStep } from "../step.js";
-import { ExecutableStep } from "../step.js";
+import type { ExecutionDetails, GrafastResultStreamList, GrafastSubscriber } from "../interfaces.js";
+import { Step } from "../step.js";
 import type { __ItemStep } from "./__item.js";
 /**
  * Subscribes to the given `pubsubOrPlan` to get realtime updates on a given
@@ -9,7 +8,7 @@ import type { __ItemStep } from "./__item.js";
  */
 export declare class ListenStep<TTopics extends {
     [topic: string]: any;
-}, TTopic extends keyof TTopics, TPayloadStep extends ExecutableStep> extends ExecutableStep<TTopics[TTopic]> implements StreamableStep<TTopics[TTopic]> {
+}, TTopic extends keyof TTopics, TPayloadStep extends Step> extends Step<TTopics[TTopic][]> {
     itemPlan: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep;
     static $$export: {
         moduleName: string;
@@ -24,12 +23,8 @@ export declare class ListenStep<TTopics extends {
      * The plan that will tell us which topic we're subscribing to.
      */
     private topicDep;
-    constructor(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep);
-    execute(): never;
-    stream(count: number, values: readonly [
-        GrafastValuesList<GrafastSubscriber<TTopics>>,
-        GrafastValuesList<TTopic>
-    ]): GrafastResultStreamList<TTopics[TTopic]>;
+    constructor(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep);
+    execute({ indexMap, values, stream, }: ExecutionDetails<readonly [GrafastSubscriber<TTopics>, TTopic]>): GrafastResultStreamList<TTopics[TTopic]>;
 }
 /**
  * Subscribes to the given `pubsubOrPlan` to get realtime updates on a given
@@ -38,5 +33,5 @@ export declare class ListenStep<TTopics extends {
  */
 export declare function listen<TTopics extends {
     [topic: string]: any;
-}, TTopic extends keyof TTopics, TPayloadStep extends ExecutableStep>(pubsubOrPlan: ExecutableStep<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: ExecutableStep<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep): ListenStep<TTopics, TTopic, TPayloadStep>;
+}, TTopic extends keyof TTopics, TPayloadStep extends Step>(pubsubOrPlan: Step<GrafastSubscriber<TTopics> | null> | GrafastSubscriber<TTopics> | null, topicOrPlan: Step<TTopic> | string, itemPlan?: (itemPlan: __ItemStep<TTopics[TTopic]>) => TPayloadStep): ListenStep<TTopics, TTopic, TPayloadStep>;
 //# sourceMappingURL=listen.d.ts.map

package/dist/steps/listen.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listen = exports.ListenStep = void 0;
+exports.ListenStep = void 0;
+exports.listen = listen;
 const dev_js_1 = require("../dev.js");
 const index_js_1 = require("../index.js");
 const step_js_1 = require("../step.js");
@@ -10,7 +11,7 @@ const constant_js_1 = require("./constant.js");
  * topic (`topicOrPlan`), mapping the resulting event via the `itemPlan`
  * callback.
  */
-class ListenStep extends step_js_1.ExecutableStep {
+class ListenStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "ListenStep",
@@ -26,15 +27,14 @@ class ListenStep extends step_js_1.ExecutableStep {
         this.pubsubDep = this.addDependency($pubsub);
         this.topicDep = this.addDependency($topic);
     }
-    execute() {
-        throw new Error("ListenStep cannot be executed, it can only be streamed");
-    }
-    stream(count, values) {
-        const pubsubs = values[this.pubsubDep];
-        const topics = values[this.topicDep];
-        const result = [];
-        for (let i = 0; i < count; i++) {
-            const pubsub = pubsubs[i];
+    execute({ indexMap, values, stream, }) {
+        if (!stream) {
+            throw new Error("ListenStep must be streamed, never merely executed");
+        }
+        const pubsubValue = values[this.pubsubDep];
+        const topicValue = values[this.topicDep];
+        return indexMap((i) => {
+            const pubsub = pubsubValue.at(i);
             if (!pubsub) {
                 throw new index_js_1.SafeError("Subscription not supported", dev_js_1.isDev
                     ? {
@@ -42,10 +42,9 @@ class ListenStep extends step_js_1.ExecutableStep {
                     }
                     : {});
             }
-            const topic = topics[i];
-            result[i] = pubsub.subscribe(topic);
-        }
-        return result;
+            const topic = topicValue.at(i);
+            return pubsub.subscribe(topic);
+        });
     }
 }
 exports.ListenStep = ListenStep;
@@ -57,5 +56,4 @@ exports.ListenStep = ListenStep;
 function listen(pubsubOrPlan, topicOrPlan, itemPlan) {
     return new ListenStep(pubsubOrPlan, topicOrPlan, itemPlan);
 }
-exports.listen = listen;
 //# sourceMappingURL=listen.js.map

package/dist/steps/load.d.ts

@@ -1,32 +1,32 @@
-import type { __ItemStep } from "../index.js";
-import type { ExecutionExtra, GrafastResultsList, GrafastValuesList, Maybe, PromiseOrDirect } from "../interfaces.js";
-import { ExecutableStep } from "../step.js";
-export interface LoadOptions<TItem, TParams extends Record<string, any>> {
+import type { __ItemStep, ExecutionDetails } from "../index.js";
+import type { GrafastResultsList, Maybe, PromiseOrDirect } from "../interfaces.js";
+import type { Multistep, UnwrapMultistep } from "../multistep.js";
+import { Step } from "../step.js";
+export interface LoadOptions<TItem, TParams extends Record<string, any>, TUnarySpec = never> {
+    unary: TUnarySpec;
     attributes: ReadonlyArray<keyof TItem>;
     params: Partial<TParams>;
 }
-type LoadCallback<TSpec, TItem, TData extends TItem | ReadonlyArray<TItem>, TParams extends Record<string, any>> = {
-    (specs: ReadonlyArray<TSpec>, options: LoadOptions<TItem, TParams>): PromiseOrDirect<ReadonlyArray<Maybe<TData>>>;
+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>>>;
     displayName?: string;
 };
-export type LoadOneCallback<TSpec, TItem, TParams extends Record<string, any>> = LoadCallback<TSpec, TItem, TItem, TParams>;
-export type LoadManyCallback<TSpec, TItem, TParams extends Record<string, any>> = LoadCallback<TSpec, TItem, ReadonlyArray<TItem>, TParams>;
+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>;
 /**
  * A TypeScript Identity Function to help you strongly type your
  * LoadOneCallback.
  */
-export declare function loadOneCallback<TSpec, TItem, TParams extends Record<string, any>>(callback: LoadOneCallback<TSpec, TItem, TParams>): LoadOneCallback<TSpec, TItem, TParams>;
+export declare function loadOneCallback<TSpec, TItem, TParams extends Record<string, any>, TUnarySpec = never>(callback: LoadOneCallback<TSpec, TItem, TParams, TUnarySpec>): LoadOneCallback<TSpec, TItem, TParams, TUnarySpec>;
 /**
  * A TypeScript Identity Function to help you strongly type your
  * LoadManyCallback.
  */
-export declare function loadManyCallback<TSpec, TItem, TParams extends Record<string, any>>(callback: LoadManyCallback<TSpec, TItem, TParams>): LoadManyCallback<TSpec, TItem, TParams>;
+export declare function loadManyCallback<TSpec, TItem, TParams extends Record<string, any>, TUnarySpec = never>(callback: LoadManyCallback<TSpec, TItem, TParams, TUnarySpec>): LoadManyCallback<TSpec, TItem, TParams, TUnarySpec>;
 /**
  * You shouldn't create instances of this yourself - use `loadOne` or `loadMany` instead.
- *
- * @internal
  */
-export declare class LoadedRecordStep<TItem, TParams extends Record<string, any>> extends ExecutableStep<TItem> {
+export declare class LoadedRecordStep<TItem, TParams extends Record<string, any> = Record<string, any>> extends Step<TItem> {
     private isSingle;
     private sourceDescription;
     private ioEquivalence;
@@ -37,43 +37,52 @@ export declare class LoadedRecordStep<TItem, TParams extends Record<string, any>
     isSyncAndSafe: boolean;
     attributes: Set<keyof TItem>;
     params: Partial<TParams>;
-    constructor($data: ExecutableStep<TItem>, isSingle: boolean, sourceDescription: string, ioEquivalence: Record<string, ExecutableStep>);
+    constructor($data: Step<TItem>, isSingle: boolean, sourceDescription: string, ioEquivalence: Record<string, Step>);
     toStringMeta(): string;
-    get(attr: keyof TItem & (string | number)): ExecutableStep<any>;
+    get(attr: keyof TItem & (string | number)): Step<any>;
+    private _getInner;
     setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
-    optimize(): ExecutableStep<any>;
-    execute(_count: number, [records]: [GrafastValuesList<TItem>]): GrafastResultsList<TItem>;
+    optimize(): Step<any> | import("./__flag.js").__FlagStep<Step<any>>;
+    execute({ count, values: [values0], }: ExecutionDetails<[TItem]>): GrafastResultsList<TItem>;
 }
-export declare class LoadStep<TSpec, TItem, TData extends TItem | ReadonlyArray<TItem>, TParams extends Record<string, any>> extends ExecutableStep {
+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 {
+    private ioEquivalence;
     private load;
-    private ioEquivalence?;
     static $$export: {
         moduleName: string;
         exportName: string;
     };
-    loadOptions: LoadOptions<TItem, TParams> | null;
+    isSyncAndSafe: boolean;
+    loadOptions: Omit<LoadOptions<TItem, TParams, UnwrapMultistep<TUnaryMultistep>>, "unary"> | null;
     loadOptionsKey: string;
     attributes: Set<keyof TItem>;
     params: Partial<TParams>;
-    constructor($spec: ExecutableStep<TSpec>, load: LoadCallback<TSpec, TItem, TData, TParams>, ioEquivalence?: string | { [key in keyof TSpec]?: string | null | undefined; } | null | undefined);
+    unaryDepId: number | null;
+    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<this>): LoadedRecordStep<TItem, TParams>;
+    listItem($item: __ItemStep<TItem>): LoadedRecordStep<TItem, TParams>;
     single(): TData extends ReadonlyArray<any> ? never : LoadedRecordStep<TItem, TParams>;
     setParam<TParamKey extends keyof TParams>(paramKey: TParamKey, value: TParams[TParamKey]): void;
     addAttributes(attributes: Set<keyof TItem>): void;
     finalize(): void;
-    execute(count: number, [specs]: [GrafastValuesList<TSpec>], extra: ExecutionExtra): PromiseOrDirect<GrafastResultsList<Maybe<TData>>>;
+    execute({ count, values: [values0, values1], extra, }: ExecutionDetails<[
+        UnwrapMultistep<TMultistep>,
+        UnwrapMultistep<TUnaryMultistep>
+    ]>): PromiseOrDirect<GrafastResultsList<Maybe<TData>>>;
 }
-export declare function loadMany<TSpec, TItem, TParams extends Record<string, any> = Record<string, any>>($spec: ExecutableStep<TSpec>, loadCallback: LoadManyCallback<TSpec, TItem, TParams>): LoadStep<TSpec, TItem, ReadonlyArray<TItem>, TParams>;
-export declare function loadMany<TSpec, TItem, TParams extends Record<string, any> = Record<string, any>>($spec: ExecutableStep<TSpec>, ioEquivalence: null | string | (TSpec extends [...any[]] ? {
-    [key in keyof TSpec]: string | null;
-} : TSpec extends Record<string, any> ? {
-    [key in keyof TSpec]?: string | null;
-} : never), loadCallback: LoadManyCallback<TSpec, TItem, TParams>): LoadStep<TSpec, TItem, ReadonlyArray<TItem>, TParams>;
-export declare function loadOne<TSpec, TItem, TParams extends Record<string, any> = Record<string, any>>($spec: ExecutableStep<TSpec>, loadCallback: LoadOneCallback<TSpec, TItem, TParams>): LoadedRecordStep<TItem, TParams>;
-export declare function loadOne<const TSpec, TItem, TParams extends Record<string, any> = Record<string, any>>($spec: ExecutableStep<TSpec>, ioEquivalence: null | string | {
-    [key in keyof TSpec]?: string | null;
-}, loadCallback: LoadOneCallback<TSpec, TItem, TParams>): LoadedRecordStep<TItem, TParams>;
+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>>;
+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 {};
 //# sourceMappingURL=load.d.ts.map

package/dist/steps/load.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadOne = exports.loadMany = exports.LoadStep = exports.LoadedRecordStep = exports.loadManyCallback = exports.loadOneCallback = void 0;
+exports.LoadStep = exports.LoadedRecordStep = void 0;
+exports.loadOneCallback = loadOneCallback;
+exports.loadManyCallback = loadManyCallback;
+exports.loadMany = loadMany;
+exports.loadOne = loadOne;
 const index_js_1 = require("../index.js");
+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");
@@ -12,7 +17,6 @@ const access_js_1 = require("./access.js");
 function loadOneCallback(callback) {
     return callback;
 }
-exports.loadOneCallback = loadOneCallback;
 /**
  * A TypeScript Identity Function to help you strongly type your
  * LoadManyCallback.
@@ -20,15 +24,12 @@ exports.loadOneCallback = loadOneCallback;
 function loadManyCallback(callback) {
     return callback;
 }
-exports.loadManyCallback = loadManyCallback;
 const idByLoad = new WeakMap();
 let loadCounter = 0;
 /**
  * You shouldn't create instances of this yourself - use `loadOne` or `loadMany` instead.
- *
- * @internal
  */
-class LoadedRecordStep extends step_js_1.ExecutableStep {
+class LoadedRecordStep extends step_js_1.Step {
     static { this.$$export = {
         moduleName: "grafast",
         exportName: "LoadedRecordStep",
@@ -49,6 +50,9 @@ class LoadedRecordStep extends step_js_1.ExecutableStep {
         return this.sourceDescription ?? null;
     }
     get(attr) {
+        return this.cacheStep("get", attr, () => this._getInner(attr));
+    }
+    _getInner(attr) {
         // Allow auto-collapsing of the waterfall by knowing keys are equivalent
         if (this.operationPlan.phase === "plan" &&
             this.ioEquivalence[attr]) {
@@ -81,23 +85,32 @@ class LoadedRecordStep extends step_js_1.ExecutableStep {
         return this.getDep(0);
     }
     // This'll never be called, due to `optimize` above.
-    execute(_count, [records]) {
-        return records;
+    execute({ count, values: [values0], }) {
+        return values0.isBatch
+            ? values0.entries
+            : (0, utils_js_1.arrayOfLength)(count, values0.value);
     }
 }
 exports.LoadedRecordStep = LoadedRecordStep;
-class LoadStep extends step_js_1.ExecutableStep {
+class LoadStep extends step_js_1.Step {
     /* implements ListCapableStep<TItem, LoadedRecordStep<TItem, TParams>> */
     static { this.$$export = { moduleName: "grafast", exportName: "LoadStep" }; }
-    constructor($spec, load, ioEquivalence) {
+    constructor(spec, unarySpec, ioEquivalence, load) {
         super();
-        this.load = load;
         this.ioEquivalence = ioEquivalence;
+        this.load = load;
+        this.isSyncAndSafe = false;
         this.loadOptions = null;
         this.loadOptionsKey = "";
         this.attributes = new Set();
         this.params = Object.create(null);
+        this.unaryDepId = null;
+        const $spec = (0, multistep_js_1.multistep)(spec, "load");
         this.addDependency($spec);
+        const $unarySpec = unarySpec == null ? null : (0, multistep_js_1.multistep)(unarySpec, "loadUnary");
+        if ($unarySpec) {
+            this.unaryDepId = this.addUnaryDependency($unarySpec);
+        }
     }
     toStringMeta() {
         return this.load.displayName || this.load.name;
@@ -112,7 +125,7 @@ class LoadStep extends step_js_1.ExecutableStep {
             map[this.ioEquivalence] = $spec;
             return map;
         }
-        else if (Array.isArray(this.ioEquivalence)) {
+        else if ((0, utils_js_1.isTuple)(this.ioEquivalence)) {
             for (let i = 0, l = this.ioEquivalence.length; i < l; i++) {
                 const key = this.ioEquivalence[i];
                 map[key] = (0, step_js_1.isListLikeStep)($spec) ? $spec.at(i) : (0, access_js_1.access)($spec, [i]);
@@ -181,8 +194,9 @@ class LoadStep extends step_js_1.ExecutableStep {
             idByLoad.set(this.load, loadId);
         }
         this.metaKey = `LoadStep|${loadId}|${this.loadOptionsKey}`;
+        super.finalize();
     }
-    execute(count, [specs], extra) {
+    execute({ count, values: [values0, values1], extra, }) {
         const meta = extra.meta;
         let cache = meta.cache;
         if (!cache) {
@@ -190,9 +204,10 @@ class LoadStep extends step_js_1.ExecutableStep {
             meta.cache = cache;
         }
         const batch = new Map();
+        const unary = values1?.isBatch === false ? values1.value : undefined;
         const results = [];
         for (let i = 0; i < count; i++) {
-            const spec = specs[i];
+            const spec = values0.at(i);
             if (cache.has(spec)) {
                 results.push(cache.get(spec));
             }
@@ -227,11 +242,14 @@ class LoadStep extends step_js_1.ExecutableStep {
                 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;
-                setTimeout(() => {
+                process.nextTick(() => {
                     // Don't allow adding anything else to the batch
                     meta.loadBatchesByLoad.delete(this.load);
-                    executeBatches(loadBatches, this.load, loadOptions);
-                }, 0);
+                    executeBatches(loadBatches, this.load, {
+                        ...loadOptions,
+                        unary: unary,
+                    });
+                });
             }
             return (async () => {
                 const loadResults = await deferred;
@@ -286,25 +304,40 @@ async function executeBatches(loadBatches, load, loadOptions) {
         }
     }
 }
-function load($spec, ioEquivalence, loadCallback) {
-    return new LoadStep($spec, loadCallback, ioEquivalence);
+function load(spec, unarySpec, ioEquivalence, loadCallback) {
+    return new LoadStep(spec, unarySpec, ioEquivalence, loadCallback);
 }
-function loadMany($spec, loadCallbackOrIoEquivalence, loadCallbackOnly) {
+function loadMany(spec, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoEquivalence, loadCallbackOnly) {
     if (loadCallbackOnly) {
-        return load($spec, loadCallbackOrIoEquivalence, loadCallbackOnly);
+        return load(spec, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoEquivalence, loadCallbackOnly);
+    }
+    // At most 3 arguments
+    else if ((0, multistep_js_1.isMultistep)(loadCallbackOrIoEquivalenceOrUnarySpec)) {
+        return load(spec, loadCallbackOrIoEquivalenceOrUnarySpec, null, loadCallbackOrIoEquivalence);
+    }
+    // Unary step is definitely null; 3 arguments
+    else if (loadCallbackOrIoEquivalence) {
+        return load(spec, null, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoEquivalence);
     }
+    // 2 arguments
     else {
-        return load($spec, null, loadCallbackOrIoEquivalence);
+        return load(spec, null, null, loadCallbackOrIoEquivalenceOrUnarySpec);
     }
 }
-exports.loadMany = loadMany;
-function loadOne($spec, loadCallbackOrIoEquivalence, loadCallbackOnly) {
+function loadOne(spec, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoEquivalence, loadCallbackOnly) {
     if (loadCallbackOnly) {
-        return load($spec, loadCallbackOrIoEquivalence, loadCallbackOnly).single();
+        return load(spec, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoEquivalence, loadCallbackOnly).single();
+    }
+    // At most 3 arguments
+    else if ((0, multistep_js_1.isMultistep)(loadCallbackOrIoEquivalenceOrUnarySpec)) {
+        return load(spec, loadCallbackOrIoEquivalenceOrUnarySpec, null, loadCallbackOrIoEquivalence).single();
+    }
+    // Unary step is definitely null; 3 arguments
+    else if (loadCallbackOrIoEquivalence) {
+        return load(spec, null, loadCallbackOrIoEquivalenceOrUnarySpec, loadCallbackOrIoEquivalence).single();
     }
     else {
-        return load($spec, null, loadCallbackOrIoEquivalence).single();
+        return load(spec, null, null, loadCallbackOrIoEquivalenceOrUnarySpec).single();
     }
 }
-exports.loadOne = loadOne;
 //# sourceMappingURL=load.js.map