@zingage/scheduling 1.1.0 → 1.2.0

package/README.md

@@ -1,5 +1,12 @@
 # @zingage/scheduling
 
+Helpers that decide when work runs in Node.js. The package has two parts:
+
+- [Time slicing](#time-slicing): collection helpers that yield to the event loop, so long synchronous work does not block it.
+- [Task collapsing and batching](#task-collapsing-and-batching): classes that decide which callers share work, how work is sent in batches, and when an owner can close.
+
+## Time slicing
+
 Cooperative collection helpers for synchronous work and generator callbacks in Node.js. Each helper defaults to a new independent budget with a 4 ms processing allowance.
 
 ```ts
@@ -23,7 +30,7 @@ await Promise.all([
 ]);
 ```
 
-## Budget semantics
+### Budget semantics
 
 The package measures elapsed time around synchronous callbacks and result accumulation. It subtracts that measured time from the budget. Waiting at a yield and unrelated work between measured steps do not consume the budget.
 
@@ -31,13 +38,13 @@ If A uses 1 ms and finishes, connected B gets the remaining 3 ms. If A exhausts
 
 One callback or iterator step cannot be interrupted. Nested helpers started inside a synchronous callback cannot interrupt that containing callback. Their work counts once toward a shared budget. Garbage collection and operating-system pauses inside a measured step count as elapsed processing time. This is not CPU-time accounting or a hard event-loop delay bound. Work outside the helpers does not count. `timeSlicedMap` and `timeSlicedForEach` also accept generator callbacks.
 
-## Synchronous callbacks
+### Synchronous callbacks
 
 Ordinary callbacks, predicates, key functions, and `measure` work must be synchronous. The types accept any result, including generic results such as `(item) => item`. TypeScript cannot reject a promise result without also rejecting generic results. So the rule is checked at runtime: if a non-generator callback returns a promise or other thenable (an object or function with a `then` method), the helper throws a `TypeError` before it uses the value. An `async` callback compiles, and throws on its first call. For async work, use a generator callback with `yield* waitFor(...)`.
 
 The constructor is `new TimeSliceBudget(sliceMs = DEFAULT_TIME_SLICE_MS, now = performance.now, yieldToEventLoop = setImmediate)`. `sliceMs` must be positive and finite. `now` must be a monotonic clock in milliseconds. The budget binds the clock to `performance` because Node's default clock requires that receiver. The default yield function is Node's promise-based `setImmediate`. A custom yield function must let the event loop advance; `Promise.resolve()` does not provide that behavior. Optionally pass a budget directly as each helper's last argument to share its allowance.
 
-## Helpers
+### Helpers
 
 | Helper                     | Result                                                                       |
 | -------------------------- | ---------------------------------------------------------------------------- |
@@ -55,7 +62,7 @@ All helpers accept synchronous iterables. Callbacks receive the item and its zer
 
 The package does not infer parent operations or use global budgets. It does not serialize mutations or impose ordering between concurrent calls. Backend consumers use this package. The former `time-sliced-map.ts` utility has been removed.
 
-## Generator callbacks
+### Generator callbacks
 
 `timeSlicedMap` and `timeSlicedForEach` finish each generator callback before starting the next item. Use `yield* waitFor(promise)` to suspend with an inferred result type:
 
@@ -76,7 +83,7 @@ The budget measures every `next()` and `throw()` call, including synchronous wor
 
 Generator callbacks may also yield promises directly, but their resumed values have type `unknown`. Use `waitFor` for typed values. A synchronous segment cannot be interrupted. Break expensive callbacks into smaller generator segments. Nested helpers share accounting, but cannot interrupt the synchronous segment that starts them.
 
-## Sorting
+### Sorting
 
 `timeSlicedSort(items, compare, budget?)` returns a new array and preserves the
 input order of values that compare equal. It uses a stable merge sort and checks
@@ -96,3 +103,175 @@ const sorted = await timeSlicedSort(
 
 For async sort keys, use generator callbacks with `timeSlicedMap` to load the
 keys, then pass a synchronous comparator to `timeSlicedSort`.
+
+## Task collapsing and batching
+
+These parts decide when work runs, which callers share it, and when an owner
+can close. None of them knows what the work is. Their owners supply that
+knowledge through callbacks. `@zingage/cache` uses them for its Store reads
+and producer calls.
+
+| Export                                              | What it does                                                               |
+| --------------------------------------------------- | -------------------------------------------------------------------------- |
+| [`CollapsedTaskCreator`](#collapsedtaskcreator)     | Lets requests with the same key share one pending task, with cancellation. |
+| [`wrapWithTaskCollapsing`](#wrapwithtaskcollapsing) | Wraps a task-starting function so that equal calls share a pending task.   |
+| [`Batcher`](#batcher)                               | Collects items and sends them to one `dispatch` function in batches.       |
+| [`PendingPromisesTracker`](#pendingpromisestracker) | Tracks promises until they settle, so that `close` can wait for them.      |
+
+The pieces compose like this:
+
+- A caller that sends each task at once uses a `CollapsedTaskCreator` alone.
+  It has nothing to batch.
+- A caller that sends tasks in bulk uses a `CollapsedTaskCreator` in front of
+  a `Batcher`. The creator decides which requests start new tasks. The
+  batcher groups the new tasks into calls.
+- A caller that never shares work, such as a cache that reads from its store,
+  uses a `Batcher` alone.
+
+`Batcher` and `wrapWithTaskCollapsing` accept a `Logger`. By default, they
+write to the [`debug`](https://www.npmjs.com/package/debug) namespaces
+`@zingage/scheduling:batcher` and `@zingage/scheduling:collapsed-task-creator`.
+A callback that breaks a contract of this package, for example a `dispatch`
+that returns the wrong number of results, causes a `SchedulingContractError`.
+
+### CollapsedTaskCreator
+
+A `CollapsedTaskCreator` takes a batch of task requests in one
+`startOrRideTasks` call. Each task request is an input plus an optional
+`AbortSignal`. For each one, the creator either starts a new task or rides a
+pending task with the same key.
+
+- `makeKey` derives each input's key. A key of `undefined` means the input
+  never shares work.
+- A task request rides a pending task only if the task started no more than
+  `collapseTasksMs` ago, has not settled, and is not cancelled.
+- The tasks that one call starts go to the owner's `schedule` callback in one
+  call. So a bulk caller's new inputs become one unit of work.
+- Each task has its own signal. It aborts only when every request on the task
+  is cancelled. A request without a signal can never be cancelled, so it keeps
+  the task alive.
+- The creator counts the requests that ride each task, for diagnostics.
+- `drain` waits until every task has settled, including tasks started while it
+  waits.
+
+The creator does not queue, batch, or limit work. The `schedule` callback owns
+that.
+
+### wrapWithTaskCollapsing
+
+`wrapWithTaskCollapsing` wraps a function that starts a task and returns a
+promise. A later call with the same arguments gets the pending task's promise
+instead of a new task, but only while the task still runs and only within
+`collapseTasksMs` of its start. It is a mix of memoizing, throttling, and
+promise sharing. It runs on `CollapsedTaskCreator`, with one task request per
+call.
+
+It does not support cancellation, so an individual caller cannot cancel a
+task that other callers share. Use `CollapsedTaskCreator` when you need
+cancellation.
+
+```ts
+import { wrapWithTaskCollapsing } from "@zingage/scheduling";
+
+const fetchUser = wrapWithTaskCollapsing(
+  async (id: string) => api.getUser(id),
+  1_000,
+  ([id]) => id,
+);
+```
+
+### PendingPromisesTracker
+
+An owner tracks each piece of accepted work, then drains the tracker in its
+`close`.
+
+- `track(promise)` tracks a promise until it settles. Tracking never creates
+  an unhandled rejection.
+- `run(start)` tracks before it calls `start`, and turns a synchronous throw
+  into a rejection.
+- `drain()` waits until no tracked promise is pending, including promises
+  tracked while it waits.
+
+The tracker has no closed state. Each owner decides what happens to work that
+arrives after its `close` starts, and in what order it drains its trackers.
+
+### Batcher
+
+`Batcher` collects units of work and sends them to one `dispatch` function in
+batches. It replaces [DataLoader](https://github.com/graphql/dataloader) in
+`@zingage/cache`.
+
+#### Same as DataLoader
+
+When no signal aborts and nobody calls `flush`, `close` or `dispatchNow`, a
+`Batcher` behaves like a DataLoader built with `cache: false`:
+
+- `enqueue` corresponds to `load`, or to `loadMany` for several items.
+- A batch opens with its first entry and schedules its own dispatch.
+- The default schedule is DataLoader's. The batch dispatches in a
+  `process.nextTick` that a resolved promise queues. So the batch takes every
+  entry from the current event-loop turn and from the promise jobs that the
+  turn queues.
+- `batchScheduleFn` replaces the default schedule, as in DataLoader. It
+  receives the batch's dispatch callback.
+- A batch takes entries until it holds `maxBatchSize` of them. The next entry
+  opens a new batch, with its own scheduled dispatch. A full batch does not
+  dispatch early.
+- `dispatch` returns a promise of one result per item, in order. An `Error`
+  in a result slot rejects only that item. A rejection, or a synchronous
+  throw, rejects every item in the batch with the same error.
+- A repeated input is sent again. The batcher never shares work between
+  items. `CollapsedTaskCreator` does that.
+
+[`batcher.dataloader.test.ts`](./src/batcher.dataloader.test.ts) holds
+DataLoader's own tests, ported to the batcher. The file header lists the
+tests that it leaves out, and why.
+
+#### Added to DataLoader
+
+- **Cancellation.** An item can carry an `AbortSignal`. When the signal
+  aborts while the item waits in a batch, the item leaves the batch and its
+  result rejects with the signal's reason. The item also frees its slot, so
+  that a later entry can join the batch. An item whose signal already
+  aborted is rejected at once and never queued. Work that has dispatched
+  always completes.
+- **`dispatchNow`.** It sends new items at once, without a batch. It can also
+  pull queued entries forward: the caller passes the handles that `enqueue`
+  returned, including handles from other callers. One `dispatchNow` call is
+  one `dispatch` call, which `maxBatchSize` never splits.
+- **`flush`.** It dispatches every pending batch now. It also drops
+  `batchScheduleFn`, so later batches use the default schedule. An owner
+  calls it when its shutdown starts, because its own schedule may stop
+  firing then.
+- **`close`.** It flushes, then resolves once no batch is pending and no
+  dispatch is running. It waits for work that a dispatch enqueues into the
+  same batcher. After `close`, `enqueue` and `dispatchNow` log a warning, but
+  the work still runs.
+- **Dispatch facts.** `dispatch` receives each item's queue wait in
+  milliseconds, and an `autoBatched` flag that says whether a batch or
+  `dispatchNow` sent the call.
+- **`preserveAsyncContext`.** When it is on, each batch dispatches in the
+  async context of the `enqueue` call that opened the batch. Use it when
+  `batchScheduleFn` runs its callbacks from an unrelated context, or when
+  `flush` must not run a batch in the closer's context.
+
+#### Not in the Batcher
+
+- **No cache.** The batcher has no `clear`, `clearAll`, `prime`,
+  `cacheKeyFn` or `cacheMap`. Its owner and `CollapsedTaskCreator` own
+  caching and work sharing.
+- **No `name` and no `batch: false`.** Use `maxBatchSize: 1` to send each item
+  alone.
+
+#### Known differences from DataLoader
+
+These differences remain on purpose. No test covers them.
+
+| Behavior                                                                               | DataLoader                                                         | Batcher                                                                         |
+| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------- |
+| Default `maxBatchSize`                                                                 | No limit                                                           | 20 (`DEFAULT_MAX_BATCH_SIZE`)                                                   |
+| A `maxBatchSize` that is not an integer, such as `1.5`                                 | Accepted                                                           | Throws a `TypeError`                                                            |
+| `dispatch` throws or rejects with a value that is not an `Error`                       | Rejects each load with that value                                  | Rejects each item with an `Error` whose `cause` is that value                   |
+| `dispatch` throws synchronously, or resolves with a value of the wrong shape or length | Rejects each load with DataLoader's own `TypeError` message        | Rejects each item with the original error, or with a `SchedulingContractError`  |
+| When results settle                                                                    | One microtask after the `dispatch` promise resolves                | About two microtasks later, because `Promise.try` adopts the `dispatch` promise |
+| `batchScheduleFn` runs its callback synchronously                                      | Strands the entry in a dispatched batch, so its load never settles | Schedules a call's batches only after all of the call's entries are in place    |

package/dist/batcher.d.ts

@@ -0,0 +1,231 @@
+import { type Logger } from "./logger.js";
+import { type PerformanceNow } from "./performance-now.js";
+/**
+ * Accumulation settings for a {@link Batcher}. An owner can expose them to its
+ * own users, for example as a cache's read batching options.
+ */
+export type BatchOptions = {
+    /**
+     * The most requests one automatic dispatch takes. Defaults to 20. A direct
+     * (non-automatic) dispatch is never split.
+     */
+    maxBatchSize?: number;
+    /**
+     * Schedules the dispatch of each new automatic batch. It receives the
+     * batch's dispatch callback. Defaults to the next tick after the current
+     * microtasks, so requests from one event-loop turn share a batch.
+     */
+    batchScheduleFn?: (dispatch: () => void) => void;
+    /**
+     * Runs each automatic batch in the async context of the `enqueue` call
+     * that opened it. Off by default, because the default schedule, and a
+     * `batchScheduleFn` built on Node's timers or promises, already run the
+     * batch in that context. Turn it on when `batchScheduleFn` runs its
+     * callbacks from an unrelated context, or when a batch that `flush` or
+     * `close` sends early must keep its first request's context instead of
+     * the closer's. It costs one `AsyncResource` per batch.
+     */
+    preserveAsyncContext?: boolean;
+};
+/** One unit of work that a caller gives to {@link Batcher.enqueue}. */
+export type BatchItem<Input> = {
+    readonly input: Input;
+    /**
+     * Cancels the item while it is queued. When it aborts, the item leaves the
+     * queue and its result rejects with the signal's reason. Omit it for work
+     * that can never be cancelled.
+     */
+    readonly signal?: AbortSignal | undefined;
+};
+/** One item as the batcher's `dispatch` receives it. */
+export type DispatchedItem<Input> = {
+    readonly input: Input;
+    /** Milliseconds from enqueue to dispatch. */
+    readonly queueWaitMs: number;
+};
+/** Facts about one dispatch call, the same for every item in it. */
+export type DispatchInfo = {
+    /**
+     * True when an automatic batch sent the items, false when `dispatchNow`
+     * sent them.
+     */
+    readonly autoBatched: boolean;
+};
+/**
+ * One automatic batch. Like a DataLoader batch, it gets its own scheduled
+ * dispatch when it is created, and it takes entries until it holds
+ * `maxBatchSize` queued entries or dispatches.
+ */
+type Batch<Input, Result> = {
+    /**
+     * Every entry that joined the batch, so the batch's dispatch can find the
+     * ones still queued. Emptied once the batch dispatches, so that a
+     * long-lived handle does not keep its settled siblings alive.
+     */
+    readonly entries: Entry<Input, Result>[];
+    /**
+     * The number of `entries` whose state is still `"queued"`. Until dispatch
+     * empties `entries`, it equals
+     * `entries.filter((e) => e.state === "queued").length`: an entry joins
+     * `entries` only in `#makeEntryInBatch`, which counts it, and it leaves the
+     * queued state only through `#setEntryState`, which uncounts it.
+     *
+     * It decides whether the open batch has room, so a cancelled entry, or one
+     * that `dispatchNow` sent, frees its slot for a new entry. The count is
+     * stored rather than computed because `enqueue` checks it once per entry.
+     * Computing it would cost one pass over the batch per entry, which is
+     * quadratic for a large batch, such as one with `maxBatchSize: Infinity`.
+     */
+    queuedCount: number;
+    /**
+     * Dispatches the batch. `batchScheduleFn` receives it, and `flush` and
+     * `#drain` call it, so every path that dispatches the batch runs in the
+     * same async context. With `preserveAsyncContext`, it is bound to the
+     * context of the `enqueue` call that opened the batch.
+     */
+    readonly dispatch: () => void;
+};
+/**
+ * One queued unit of work. `Batcher.enqueue` returns it as an opaque handle,
+ * which a caller passes back to `Batcher.dispatchNow`.
+ */
+type Entry<Input, Result> = {
+    readonly item: BatchItem<Input>;
+    /**
+     * The automatic batch that holds the entry. When the entry leaves the
+     * queued state, by cancellation or by `dispatchNow`, `#setEntryState`
+     * uses it to free the entry's slot in that batch.
+     */
+    readonly batch: Batch<Input, Result>;
+    /** `performance.now()` at enqueue, for the dispatch's queue wait. */
+    readonly enqueuedAt: PerformanceNow;
+    /**
+     * Makes each entry dispatch and settle at most once. An entry can be
+     * reached by its batch's dispatch, by `dispatchNow`, and by its signal's
+     * abort, in any order; each acts only on a `"queued"` entry.
+     */
+    state: "queued" | "running" | "settled";
+    readonly result: PromiseWithResolvers<Result>;
+    /**
+     * Removes the listener attached to the abort of the item's signal, if the
+     * item has a signal. Runs once, at settle.
+     */
+    cleanup: (() => void) | undefined;
+};
+export type Outcome<Result> = {
+    ok: true;
+    value: Result;
+} | {
+    ok: false;
+    error: unknown;
+};
+/** Settles `result` with `outcome`. */
+export declare function settleResult<Result>(result: PromiseWithResolvers<Result>, outcome: Outcome<Result>): void;
+/** The handle that {@link Batcher.enqueue} returns for one entry. */
+export type BatchHandle<Input, Result> = Entry<Input, Result>;
+/** What {@link Batcher.enqueue} returns for one item. */
+export type Enqueued<Input, Result> = {
+    readonly result: Promise<Result>;
+    /**
+     * The handle to pass to `dispatchNow`. Undefined only when `result` is
+     * already rejected: the item's signal had aborted before `enqueue`, so
+     * the item was never queued.
+     */
+    readonly handle: BatchHandle<Input, Result> | undefined;
+};
+/** The default `maxBatchSize`. */
+export declare const DEFAULT_MAX_BATCH_SIZE = 20;
+/**
+ * Queues work and dispatches it in batches. The batcher does not share work,
+ * and it knows nothing of `CollapsedTaskCreator`. To share work, compose the
+ * two: a creator's `schedule` enqueues one item per started task, for example
+ * `batcher.enqueue(toStart.map((view) => ({input: view, signal:
+ * view.signal})))`. Then `dispatch` receives each live view, and can read
+ * its `collapsedRequestCount` at dispatch time. For work that is never
+ * shared, such as a cache's reads from its store, use a batcher directly, so
+ * that each request gets its own entry.
+ *
+ * Entries wait in automatic batches, which follow DataLoader's rules. A new
+ * batch schedules its own dispatch with `batchScheduleFn` when it gets its
+ * first entry. Once it holds `maxBatchSize` queued entries, the next entry
+ * opens a new batch with its own scheduled dispatch. A full batch does not
+ * dispatch early: it waits for its own callback. A caller that wants its
+ * work run at once calls `dispatchNow` with its new items, and with the
+ * handles of queued entries it also waits for, such as entries from other
+ * callers' enqueues. That dispatch is never split, and its new items never
+ * wait in a batch.
+ *
+ * Cancellation removes a queued entry: when its item's signal aborts, the
+ * entry leaves the queue and its result rejects with the signal's reason.
+ * Dispatched work always completes.
+ *
+ * Shutdown has two steps, because an owner can still accept work after its
+ * shutdown starts:
+ *
+ * 1. `flush` sends every pending batch at once, and drops `batchScheduleFn`,
+ *    so later batches use the default schedule, which always fires. An owner
+ *    calls it when its shutdown starts, because its `batchScheduleFn` may
+ *    stop firing then.
+ * 2. `close` flushes too, and resolves once the batcher is idle. Then the
+ *    batcher is closed. An owner calls it after it stops accepting work. An
+ *    enqueue after that is a bug in the owner, so it logs a warning, but the
+ *    work still runs.
+ *
+ * Every entry's result settles, including on cancellation. So a caller that
+ * must hold a resource for an item's whole life acquires it before `enqueue`
+ * and releases it in a `.finally` on the item's result. The batcher has no
+ * hook for this.
+ */
+export declare class Batcher<Input, Result> {
+    #private;
+    constructor(options: BatchOptions & {
+        /**
+         * Runs one call for the given items. It resolves with one result or
+         * Error per item, in order. A rejection fails every item in the call.
+         */
+        dispatch: (items: readonly DispatchedItem<Input>[], info: DispatchInfo) => Promise<readonly (Result | Error)[]>;
+        /** Receives the warning for an enqueue after close. */
+        logger?: Logger;
+    });
+    /**
+     * Queues one entry per item, in order, and returns each item's result and
+     * handle.
+     *
+     * Each entry joins the open automatic batch, or opens a new one when that
+     * batch is full. An item whose signal already aborted is not queued: its
+     * result is rejected with the signal's reason, and it has no handle. The
+     * other items are not affected. After the batcher has closed, it also logs
+     * a warning.
+     */
+    enqueue(items: readonly BatchItem<Input>[]): Enqueued<Input, Result>[];
+    /**
+     * Dispatches the still-queued entries among `handles`, plus the new
+     * `items`, as one call, which is never split. It skips entries that are
+     * running or settled. A caller can pass handles from other callers'
+     * enqueues, so one dispatch covers all of the work it waits for.
+     *
+     * The new items never wait in a batch, so a `batchScheduleFn` cannot send
+     * them early. An item whose signal already aborted is rejected and not
+     * sent. Returns each item's result, in order. After close, it logs a
+     * warning when it gets items, as `enqueue` does.
+     *
+     * It drops repeated handles, because one call can hold the same handle
+     * more than once: two requests of a call that share one task get the same
+     * handle, and the entry must be sent once.
+     */
+    dispatchNow(handles: Iterable<BatchHandle<Input, Result>>, items?: readonly BatchItem<Input>[]): Promise<Result>[];
+    /**
+     * Dispatches every pending batch now, and drops `batchScheduleFn`, which
+     * the owner may stop during shutdown. Later batches use the default
+     * schedule. The batcher stays open: later enqueues do not warn.
+     */
+    flush(): void;
+    /**
+     * Flushes, then resolves when the batcher is idle. Then the batcher is
+     * closed, and later enqueues log a warning. Repeated calls return the same
+     * promise.
+     */
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=batcher.d.ts.map

package/dist/batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../src/batcher.ts"],"names":[],"mappings":"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"}