@getaster/data 0.0.0-stage → 0.1.0-preview.1

package/dist/composition/command.js

@@ -0,0 +1,57 @@
+import { computed, signal } from "@preact/signals-core";
+import { Lifetime } from "./lifetime.js";
+/** One guarded action shared by buttons, menus, shortcuts and direct callers. */
+export class Command {
+    #lifetime = new Lifetime();
+    #busy = signal(false);
+    #error = signal(undefined);
+    #result = signal(undefined);
+    #disposed = signal(false);
+    #options;
+    #pending;
+    label;
+    enabled;
+    reason;
+    busy = this.#busy;
+    error = this.#error;
+    result = this.#result;
+    constructor(options) {
+        this.#options = options;
+        this.label = options.label;
+        this.enabled = computed(() => !this.#disposed.value && !this.#busy.value && (options.enabled?.() ?? true));
+        this.reason = computed(() => this.#disposed.value ? "This action is closed." : this.#busy.value ? "Working…" : this.enabled.value ? undefined : options.reason?.() ?? "This action is unavailable.");
+    }
+    /** Concurrent callers join the same invocation; unavailable actions reject. */
+    execute() {
+        if (this.#disposed.peek())
+            return Promise.reject(new Error("This action is closed."));
+        if (this.#pending)
+            return this.#pending;
+        if (!this.enabled.value)
+            return Promise.reject(new Error(this.reason.value));
+        this.#busy.value = true;
+        this.#error.value = undefined;
+        const pending = Promise.resolve().then(() => {
+            this.#lifetime.signal.throwIfAborted();
+            return this.#options.run(this.#lifetime.signal);
+        }).then(value => {
+            if (!this.#lifetime.disposed)
+                this.#result.value = value;
+            return value;
+        }).catch((error) => {
+            if (!this.#lifetime.disposed)
+                this.#error.value = error;
+            throw error;
+        }).finally(() => {
+            this.#pending = undefined;
+            this.#busy.value = false;
+        });
+        this.#pending = pending;
+        return pending;
+    }
+    dispose() {
+        this.#disposed.value = true;
+        this.#lifetime.dispose();
+    }
+}
+export function command(options) { return new Command(options); }

package/dist/composition/lifetime.d.ts

@@ -0,0 +1,11 @@
+/** An explicit owner; borrowed resources are never registered here. */
+export declare class Lifetime {
+    #private;
+    get signal(): AbortSignal;
+    get disposed(): boolean;
+    defer(cleanup: () => void): void;
+    own<T extends {
+        dispose(): void;
+    }>(resource: T): T;
+    dispose(): void;
+}

package/dist/composition/lifetime.js

@@ -0,0 +1,33 @@
+/** An explicit owner; borrowed resources are never registered here. */
+export class Lifetime {
+    #abort = new AbortController();
+    #cleanups = [];
+    get signal() { return this.#abort.signal; }
+    get disposed() { return this.signal.aborted; }
+    defer(cleanup) {
+        if (this.disposed)
+            cleanup();
+        else
+            this.#cleanups.push(cleanup);
+    }
+    own(resource) {
+        this.defer(() => resource.dispose());
+        return resource;
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.#abort.abort();
+        const errors = [];
+        for (const cleanup of this.#cleanups.splice(0).reverse()) {
+            try {
+                cleanup();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length)
+            throw new AggregateError(errors, "Resource cleanup failed");
+    }
+}

package/dist/composition/sessions.d.ts

@@ -0,0 +1,64 @@
+import { type ReadonlySignal } from "@preact/signals-core";
+import { Lifetime } from "./lifetime.ts";
+import { SessionActivity, type InactivePolicy } from "./activity.ts";
+import { PageScope } from "../scope/scope.ts";
+export interface SessionDescriptor {
+    readonly key: string;
+    readonly type: string;
+    readonly inputs?: Readonly<Record<string, unknown>>;
+    readonly lazy?: boolean;
+    readonly inactive?: InactivePolicy;
+}
+export interface SessionResource {
+    dispose?(): void;
+    canClose?(signal: AbortSignal): boolean | Promise<boolean>;
+    setActive?(active: boolean): void;
+}
+export interface SessionMount {
+    readonly lifetime: Lifetime;
+    readonly scope: PageScope;
+    readonly activity: SessionActivity;
+}
+export interface KeyedSessionsOptions<D extends SessionDescriptor, T extends SessionResource> {
+    readonly create: (descriptor: D, mount: SessionMount) => T | Promise<T>;
+    readonly validate?: (descriptor: D) => void;
+    /** Validate immutable identity before any reconciliation mutations. */
+    readonly checkUpdate?: (previous: D, next: D) => void;
+    readonly update?: (resource: T, previous: D, next: D) => void;
+    readonly parentScope?: PageScope;
+    readonly activity?: SessionActivity;
+}
+export type SessionStatus = "idle" | "loading" | "ready" | "error" | "disposed";
+/** A bounded collection: only descriptors in the current reconciliation are retained. */
+export declare class KeyedSessions<D extends SessionDescriptor, T extends SessionResource> {
+    #private;
+    readonly options: KeyedSessionsOptions<D, T>;
+    readonly lifetime: Lifetime;
+    readonly sessions: ReadonlySignal<readonly KeyedSession<D, T>[]>;
+    constructor(options: KeyedSessionsOptions<D, T>);
+    get(key: string): KeyedSession<D, T> | undefined;
+    reconcile(descriptors: readonly D[]): void;
+    ensure(key: string): Promise<T>;
+    activate(key: string | undefined): void;
+    requestClose(key: string): Promise<boolean>;
+    /** Descriptor removal and owner disposal are unconditional, unlike user close. */
+    remove(key: string): void;
+    dispose(): void;
+}
+export declare class KeyedSession<D extends SessionDescriptor, T extends SessionResource> {
+    #private;
+    readonly options: KeyedSessionsOptions<D, T>;
+    readonly lifetime: Lifetime;
+    readonly scope: PageScope;
+    readonly activity: SessionActivity;
+    readonly status: ReadonlySignal<SessionStatus>;
+    readonly value: ReadonlySignal<T | undefined>;
+    readonly error: ReadonlySignal<unknown>;
+    get descriptor(): D;
+    constructor(descriptor: D, options: KeyedSessionsOptions<D, T>);
+    update(descriptor: D): void;
+    activate(active: boolean): void;
+    ensure(): Promise<T>;
+    requestClose(): Promise<boolean>;
+    dispose(): void;
+}

package/dist/composition/sessions.js

@@ -0,0 +1,209 @@
+import { signal } from "@preact/signals-core";
+import { Lifetime } from "./lifetime.js";
+import { SessionActivity } from "./activity.js";
+import { PageScope } from "../scope/scope.js";
+/** A bounded collection: only descriptors in the current reconciliation are retained. */
+export class KeyedSessions {
+    options;
+    lifetime = new Lifetime();
+    #entries = new Map();
+    #sessions = signal([]);
+    sessions = this.#sessions;
+    #active;
+    constructor(options) {
+        this.options = options;
+        this.lifetime.defer(() => {
+            const cleanup = new Lifetime();
+            for (const entry of this.#entries.values())
+                cleanup.defer(() => entry.dispose());
+            this.#entries.clear();
+            this.#sessions.value = [];
+            cleanup.dispose();
+        });
+    }
+    get(key) { return this.#entries.get(key); }
+    reconcile(descriptors) {
+        if (this.lifetime.disposed)
+            throw new Error("Sessions are disposed");
+        for (const descriptor of descriptors) {
+            if (!descriptor || typeof descriptor !== "object" || Array.isArray(descriptor))
+                throw new TypeError("Session descriptor must be a record");
+            if (typeof descriptor.key !== "string" || !descriptor.key.trim())
+                throw new TypeError("Session key must be a nonempty string");
+            if (typeof descriptor.type !== "string" || !descriptor.type.trim())
+                throw new TypeError("Session type must be a nonempty string");
+            if (descriptor.lazy !== undefined && typeof descriptor.lazy !== "boolean")
+                throw new TypeError("Session lazy must be a boolean");
+            if (descriptor.inactive !== undefined && descriptor.inactive !== "pause" && descriptor.inactive !== "continue")
+                throw new TypeError("Session inactive must be pause or continue");
+            if (descriptor.inputs !== undefined) {
+                const inputs = descriptor.inputs;
+                if (!inputs || typeof inputs !== "object" || (Object.getPrototypeOf(inputs) !== Object.prototype && Object.getPrototypeOf(inputs) !== null))
+                    throw new TypeError("Session inputs must be an ordinary record");
+            }
+        }
+        descriptors = descriptors.map(descriptor => Object.freeze({ ...descriptor, ...(descriptor.inputs ? { inputs: Object.freeze({ ...descriptor.inputs }) } : {}) }));
+        const keys = new Set();
+        for (const descriptor of descriptors) {
+            if (!descriptor.key || keys.has(descriptor.key))
+                throw new Error(`Duplicate or empty session key '${descriptor.key}'`);
+            keys.add(descriptor.key);
+            this.options.validate?.(descriptor);
+            const previous = this.#entries.get(descriptor.key)?.descriptor;
+            if (previous) {
+                if (previous.type !== descriptor.type)
+                    throw new Error(`Session '${descriptor.key}' cannot change type`);
+                if (previous.inactive !== descriptor.inactive)
+                    throw new Error(`Session '${descriptor.key}' cannot change inactive policy`);
+                if (this.options.checkUpdate)
+                    this.options.checkUpdate(previous, descriptor);
+                else
+                    for (const key of new Set([...Object.keys(previous.inputs ?? {}), ...Object.keys(descriptor.inputs ?? {})])) {
+                        if (!Object.is(previous.inputs?.[key], descriptor.inputs?.[key]))
+                            throw new Error(`Session '${descriptor.key}' cannot change immutable input '${key}'`);
+                    }
+            }
+        }
+        for (const key of this.#entries.keys())
+            if (!keys.has(key))
+                this.remove(key);
+        const ordered = descriptors.map(descriptor => {
+            let entry = this.#entries.get(descriptor.key);
+            if (entry)
+                entry.update(descriptor);
+            else {
+                entry = new KeyedSession(descriptor, this.options);
+                this.#entries.set(descriptor.key, entry);
+            }
+            return entry;
+        });
+        this.#sessions.value = ordered;
+        for (const entry of ordered) {
+            entry.activate(entry.descriptor.key === this.#active);
+            if (entry.descriptor.lazy === false)
+                void entry.ensure().catch(() => { });
+        }
+    }
+    ensure(key) {
+        const entry = this.#entries.get(key);
+        return entry ? entry.ensure() : Promise.reject(new Error(`Unknown session '${key}'`));
+    }
+    activate(key) {
+        if (key !== undefined && !this.#entries.has(key))
+            throw new Error(`Unknown session '${key}'`);
+        this.#active = key;
+        for (const entry of this.#entries.values())
+            entry.activate(entry.descriptor.key === key);
+    }
+    async requestClose(key) {
+        const entry = this.#entries.get(key);
+        if (!entry)
+            return false;
+        if (!await entry.requestClose())
+            return false;
+        if (this.#entries.get(key) !== entry)
+            return false;
+        this.remove(key);
+        return true;
+    }
+    /** Descriptor removal and owner disposal are unconditional, unlike user close. */
+    remove(key) {
+        const entry = this.#entries.get(key);
+        if (!entry)
+            return;
+        this.#entries.delete(key);
+        if (this.#active === key)
+            this.#active = undefined;
+        this.#sessions.value = this.#sessions.peek().filter(item => item !== entry);
+        entry.dispose();
+    }
+    dispose() { this.lifetime.dispose(); }
+}
+export class KeyedSession {
+    options;
+    lifetime = new Lifetime();
+    scope;
+    activity;
+    #status = signal("idle");
+    #value = signal(undefined);
+    #error = signal(undefined);
+    status = this.#status;
+    value = this.#value;
+    error = this.#error;
+    #descriptor;
+    #pending;
+    #closing;
+    #attempt;
+    get descriptor() { return this.#descriptor; }
+    constructor(descriptor, options) {
+        this.options = options;
+        this.#descriptor = descriptor;
+        this.lifetime.defer(() => {
+            this.#status.value = "disposed";
+            this.#value.value = undefined;
+            this.#attempt?.dispose();
+        });
+        this.scope = new PageScope(options.parentScope);
+        this.activity = this.lifetime.own(new SessionActivity({ ...(options.activity ? { parent: options.activity } : {}), inactive: descriptor.inactive ?? "pause", active: false }));
+    }
+    update(descriptor) {
+        const previous = this.#descriptor;
+        if (this.#value.peek())
+            this.options.update?.(this.#value.peek(), previous, descriptor);
+        this.#descriptor = descriptor;
+    }
+    activate(active) {
+        this.activity.setActive(active);
+        this.#value.peek()?.setActive?.(active);
+        if (active)
+            void this.ensure().catch(() => { });
+    }
+    ensure() {
+        if (this.lifetime.disposed)
+            return Promise.reject(new Error("Session is disposed"));
+        if (this.#pending)
+            return this.#pending;
+        if (this.#value.peek())
+            return Promise.resolve(this.#value.peek());
+        const attempt = this.#attempt = new Lifetime();
+        this.#status.value = "loading";
+        this.#error.value = undefined;
+        const initial = this.#descriptor;
+        const pending = Promise.resolve().then(() => {
+            attempt.signal.throwIfAborted();
+            return this.options.create(initial, { lifetime: attempt, scope: this.scope, activity: this.activity });
+        }).then(resource => {
+            attempt.defer(() => resource.dispose?.());
+            attempt.signal.throwIfAborted();
+            this.options.update?.(resource, initial, this.#descriptor);
+            resource.setActive?.(this.activity.active.peek());
+            this.#value.value = resource;
+            this.#status.value = "ready";
+            return resource;
+        }).catch(error => {
+            attempt.dispose();
+            if (!this.lifetime.disposed) {
+                this.#error.value = error;
+                this.#status.value = "error";
+            }
+            throw error;
+        }).finally(() => { this.#pending = undefined; });
+        this.#pending = pending;
+        return pending;
+    }
+    requestClose() {
+        if (this.#closing)
+            return this.#closing;
+        const pending = Promise.resolve().then(async () => {
+            if (this.lifetime.disposed)
+                return false;
+            // A started factory must finish before its resource's guard can be consulted.
+            const resource = this.#pending ? await this.#pending : this.#value.peek();
+            const accepted = await resource?.canClose?.(this.lifetime.signal) ?? true;
+            return accepted && !this.lifetime.disposed;
+        }).finally(() => { this.#closing = undefined; });
+        this.#closing = pending;
+        return pending;
+    }
+    dispose() { this.lifetime.dispose(); }
+}

package/dist/context.d.ts

@@ -0,0 +1,76 @@
+import { type ReadonlySignal } from "@preact/signals-core";
+import { type ChangeSet } from "./changes/changeset.ts";
+import { Collection, type CollectionOptions } from "./collection/collection.ts";
+import { Summary } from "./collection/summary.ts";
+import { Groups } from "./collection/groups.ts";
+import { Grouping, type GroupingOptions } from "./collection/grouping.ts";
+import { type Aggregate } from "./criteria/compile.ts";
+import type { Query } from "./criteria/ast.ts";
+import { ODataSource, type Deltas } from "./odata/source.ts";
+import type { Entity, Schema } from "./schema/model.ts";
+import { type KeyText } from "./store/keys.ts";
+import { RecordStore, type StoredRecord } from "./store/store.ts";
+import type { Transport } from "./transport.ts";
+export interface Saved {
+    readonly key: KeyText;
+    readonly record: StoredRecord;
+    /** What the save did, for undo and change logs. */
+    readonly change: ChangeSet;
+}
+/**
+ * One client's view of a service: the store, every live collection, and the
+ * writes that keep them in step. All writes go through here so sync sees them.
+ */
+export declare class DataContext {
+    #private;
+    readonly source: ODataSource;
+    readonly store: RecordStore;
+    /** The clock relative dates in queries are resolved against, at each fetch. */
+    readonly now: () => number;
+    constructor(source: ODataSource, options?: {
+        now?: () => number;
+    });
+    static connect(transport: Transport, options?: {
+        now?: () => number;
+    }): Promise<DataContext>;
+    get schema(): Schema;
+    /**
+     * A live collection. Given a signal, the collection follows it: each new
+     * query replaces the rows and loads again.
+     */
+    collection(query: Query | ReadonlySignal<Query>, options?: CollectionOptions): Collection;
+    /** Live group counts and aggregates of a query by one field; `dispose()` them when done. */
+    groups(query: Query | ReadonlySignal<Query>, field: string, aggregates?: readonly Aggregate[]): Groups;
+    /** A lazy hierarchy of grouped queries and paged leaf records. Dispose when done. */
+    grouping(query: Query | ReadonlySignal<Query>, fields: readonly string[], aggregates?: readonly Aggregate[], options?: GroupingOptions): Grouping;
+    /** Exact query totals; dispose when the consuming view closes. */
+    summary(query: Query | ReadonlySignal<Query>, aggregates?: readonly Aggregate[]): Summary;
+    /** Stops syncing a collection, and following its query. */
+    release(collection: Collection): void;
+    /**
+     * One record by key, for showing a foreign key's display value. A record
+     * that isn't in the store is fetched; lookups made in the same task share
+     * one request per set.
+     */
+    lookup(set: string, key: KeyText): ReadonlySignal<Entity | undefined>;
+    create(set: string, values: Entity, by?: object): Promise<Saved>;
+    /**
+     * Sends only `changes`, with `ifMatch` or else the stored record's ETag.
+     * `deltas` changes owned collections in the same request (deep update).
+     */
+    update(set: string, key: KeyText, changes: Entity, by?: object, ifMatch?: string, deltas?: Deltas): Promise<Saved>;
+    remove(set: string, key: KeyText, by?: object, ifMatch?: string): Promise<ChangeSet>;
+    /** Reads one record again; a record that's gone is removed. */
+    reload(set: string, key: KeyText, origin?: "fetch" | "external"): Promise<StoredRecord | undefined>;
+    /**
+     * Runs a change set, such as the inverse of an earlier save. `ifMatch`
+     * pins an update or delete to that version instead of the stored one.
+     */
+    run(change: ChangeSet, by?: object, ifMatch?: string): Promise<Saved | ChangeSet>;
+    /**
+     * Undoes a save. Given the `Saved`, the inverse is pinned to the version
+     * that save produced, so a change someone made since is a 412, not
+     * overwritten.
+     */
+    undo(saved: Saved | ChangeSet, by?: object): Promise<Saved | ChangeSet>;
+}

package/dist/context.js

@@ -0,0 +1,211 @@
+import { computed, effect, untracked } from "@preact/signals-core";
+import { creatable, invert, writable } from "./changes/changeset.js";
+import { Collection } from "./collection/collection.js";
+import { Summary } from "./collection/summary.js";
+import { Groups } from "./collection/groups.js";
+import { Grouping } from "./collection/grouping.js";
+import { sameQuery } from "./criteria/compile.js";
+import { ODataError } from "./odata/errors.js";
+import { ODataSource } from "./odata/source.js";
+import { keyFromText, keyText, keyValues } from "./store/keys.js";
+import { RecordStore } from "./store/store.js";
+/**
+ * One client's view of a service: the store, every live collection, and the
+ * writes that keep them in step. All writes go through here so sync sees them.
+ */
+export class DataContext {
+    source;
+    store;
+    #collections = new Set();
+    /** Stops a collection following its query signal. */
+    #following = new Map();
+    /** Keys asked for through `lookup` and not yet answered, by set. */
+    #wanted = new Map();
+    #requested = new Set();
+    /** The clock relative dates in queries are resolved against, at each fetch. */
+    now;
+    constructor(source, options = {}) {
+        this.source = source;
+        this.now = options.now ?? Date.now;
+        this.store = new RecordStore(source.schema);
+        this.store.subscribe((change) => {
+            for (const c of this.#collections)
+                c.apply(change);
+        });
+    }
+    static async connect(transport, options = {}) {
+        return new DataContext(await ODataSource.connect(transport), options);
+    }
+    get schema() {
+        return this.source.schema;
+    }
+    /**
+     * A live collection. Given a signal, the collection follows it: each new
+     * query replaces the rows and loads again.
+     */
+    collection(query, options) {
+        const following = "set" in query ? undefined : query;
+        const c = new Collection(this.store, this.source, following ? following.peek() : query, { now: this.now, ...options });
+        this.#collections.add(c);
+        if (following) {
+            this.#following.set(c, effect(() => {
+                const q = following.value;
+                untracked(() => !sameQuery(q, c.query) && c.setQuery(q));
+            }));
+        }
+        return c;
+    }
+    /** Live group counts and aggregates of a query by one field; `dispose()` them when done. */
+    groups(query, field, aggregates = []) {
+        return new Groups(this.store, this.source, query, field, aggregates, this.now);
+    }
+    /** A lazy hierarchy of grouped queries and paged leaf records. Dispose when done. */
+    grouping(query, fields, aggregates = [], options = {}) {
+        return new Grouping(this, query, fields, aggregates, options);
+    }
+    /** Exact query totals; dispose when the consuming view closes. */
+    summary(query, aggregates = []) {
+        return new Summary(this.store, this.source, query, aggregates, this.now);
+    }
+    /** Stops syncing a collection, and following its query. */
+    release(collection) {
+        this.#collections.delete(collection);
+        this.#following.get(collection)?.();
+        this.#following.delete(collection);
+    }
+    /**
+     * One record by key, for showing a foreign key's display value. A record
+     * that isn't in the store is fetched; lookups made in the same task share
+     * one request per set.
+     */
+    lookup(set, key) {
+        const id = `${set} ${key}`;
+        if (!this.store.get(set, key) && !this.#requested.has(id)) {
+            this.#requested.add(id);
+            let keys = this.#wanted.get(set);
+            if (!keys) {
+                keys = new Set();
+                this.#wanted.set(set, keys);
+                queueMicrotask(() => void this.#fetchWanted(set));
+            }
+            keys.add(key);
+        }
+        const record = this.store.record(set, key);
+        return computed(() => record.value?.entity);
+    }
+    async create(set, values, by) {
+        const type = this.schema.set(set).type;
+        const sent = creatable(type, values);
+        const record = await this.source.create(set, sent);
+        const key = this.store.put(set, record, save(by));
+        return { key, record, change: { kind: "create", set, values: sent } };
+    }
+    /**
+     * Sends only `changes`, with `ifMatch` or else the stored record's ETag.
+     * `deltas` changes owned collections in the same request (deep update).
+     */
+    async update(set, key, changes, by, ifMatch, deltas) {
+        const before = this.#require(set, key);
+        const record = await this.#guard(set, key, () => this.source.update(set, keyFromText(key), changes, ifMatch ?? before.etag, deltas));
+        this.store.put(set, record, save(by));
+        const fieldChanges = {};
+        for (const [name, to] of Object.entries(changes))
+            fieldChanges[name] = { from: before.entity[name] ?? null, to };
+        return { key, record, change: { kind: "update", set, key: keyFromText(key), changes: fieldChanges } };
+    }
+    async remove(set, key, by, ifMatch) {
+        const before = this.#require(set, key);
+        await this.#guard(set, key, () => this.source.delete(set, keyFromText(key), ifMatch ?? before.etag));
+        this.store.remove(set, key, save(by));
+        // A hidden field's `null` isn't what was stored, so an undo mustn't write it back.
+        const values = before.hidden ? Object.fromEntries(Object.entries(before.entity).filter(([f]) => !before.hidden.has(f))) : before.entity;
+        return { kind: "delete", set, key: keyFromText(key), values };
+    }
+    /** Reads one record again; a record that's gone is removed. */
+    async reload(set, key, origin = "fetch") {
+        try {
+            const record = await this.source.get(set, keyFromText(key));
+            this.store.put(set, record, { kind: origin });
+            return record;
+        }
+        catch (e) {
+            if (e instanceof ODataError && e.status === 404) {
+                this.store.remove(set, key, { kind: origin });
+                return undefined;
+            }
+            throw e;
+        }
+    }
+    /**
+     * Runs a change set, such as the inverse of an earlier save. `ifMatch`
+     * pins an update or delete to that version instead of the stored one.
+     */
+    async run(change, by, ifMatch) {
+        switch (change.kind) {
+            case "create":
+                return this.create(change.set, change.values, by);
+            case "update": {
+                const to = {};
+                for (const [name, c] of Object.entries(change.changes))
+                    to[name] = c.to;
+                const type = this.schema.set(change.set).type;
+                const key = keyText(change.key);
+                return this.update(change.set, key, writable(type, to), by, ifMatch);
+            }
+            case "delete":
+                return this.remove(change.set, keyText(change.key), by, ifMatch);
+        }
+    }
+    /**
+     * Undoes a save. Given the `Saved`, the inverse is pinned to the version
+     * that save produced, so a change someone made since is a 412, not
+     * overwritten.
+     */
+    undo(saved, by) {
+        const change = "change" in saved ? saved.change : saved;
+        const type = this.schema.set(change.set).type;
+        const created = "record" in saved ? keyValues(type, saved.record.entity) : undefined;
+        return this.run(invert(change, type, created), by, "record" in saved ? saved.record.etag : undefined);
+    }
+    async #fetchWanted(set) {
+        const keys = [...(this.#wanted.get(set) ?? [])];
+        this.#wanted.delete(set);
+        const type = this.schema.set(set).type;
+        const [keyField] = type.key;
+        try {
+            if (type.key.length === 1 && keyField !== undefined) {
+                const values = keys.map((k) => keyFromText(k)[0]);
+                const page = await this.source.query({ set, filter: { op: "in", field: keyField, values } }, { top: values.length });
+                this.store.putAll(set, page.records, { kind: "fetch" });
+            }
+            else {
+                await Promise.all(keys.map((k) => this.reload(set, k)));
+            }
+        }
+        catch {
+            // The records stay missing; a later lookup asks again.
+            for (const k of keys)
+                this.#requested.delete(`${set} ${k}`);
+        }
+    }
+    #require(set, key) {
+        const record = this.store.get(set, key);
+        if (!record)
+            throw new Error(`${set} ${key} isn't loaded`);
+        return record;
+    }
+    /** On 412 the stored record is refreshed, so the caller can show what changed. */
+    async #guard(set, key, write) {
+        try {
+            return await write();
+        }
+        catch (e) {
+            if (e instanceof ODataError && (e.status === 412 || e.status === 404))
+                await this.reload(set, key, "external");
+            throw e;
+        }
+    }
+}
+function save(by) {
+    return by ? { kind: "save", by } : { kind: "save" };
+}