shelving 1.187.3 → 1.188.0

package/api/cache/APICache.d.ts

@@ -5,8 +5,8 @@ import { EndpointCache } from "./EndpointCache.js";
  * Cache of `EndpointCache` objects for multiple endpoints.
  * - Use `get(endpoint)` to retrieve or create the `EndpointCache` for a given endpoint, then `get(payload)` on that to get a specific `EndpointStore`.
  */
-export declare class APICache<P, R> implements Disposable {
-    private readonly _caches;
+export declare class APICache<P, R> implements AsyncDisposable {
+    private readonly _endpoints;
     readonly provider: APIProvider<P, R>;
     constructor(provider: APIProvider<P, R>);
     private _get;
@@ -17,8 +17,8 @@ export declare class APICache<P, R> implements Disposable {
     /** Invalidate all stores for an endpoint. */
     invalidateAll<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>): void;
     /** Trigger a refetch on a specific store for an endpoint. */
-    refetch<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP): void;
+    refresh<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>, payload: PP): void;
     /** Trigger a refetch on all stores for an endpoint. */
-    refetchAll<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>): void;
-    [Symbol.dispose](): void;
+    refreshAll<PP extends P, RR extends R>(endpoint: Endpoint<PP, RR>): void;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/api/cache/APICache.js

@@ -1,3 +1,4 @@
+import { awaitDispose } from "../../util/dispose.js";
 import { setMapItem } from "../../util/map.js";
 import { EndpointCache } from "./EndpointCache.js";
 /**
@@ -5,16 +6,16 @@ import { EndpointCache } from "./EndpointCache.js";
  * - Use `get(endpoint)` to retrieve or create the `EndpointCache` for a given endpoint, then `get(payload)` on that to get a specific `EndpointStore`.
  */
 export class APICache {
-    _caches = new Map();
+    _endpoints = new Map();
     provider;
     constructor(provider) {
         this.provider = provider;
     }
     _get(endpoint) {
-        return this._caches.get(endpoint);
+        return this._endpoints.get(endpoint);
     }
     get(endpoint) {
-        return this._get(endpoint) || setMapItem(this._caches, endpoint, new EndpointCache(endpoint, this.provider));
+        return this._get(endpoint) || setMapItem(this._endpoints, endpoint, new EndpointCache(endpoint, this.provider));
     }
     /** Invalidate a specific store for an endpoint. */
     invalidate(endpoint, payload) {
@@ -25,17 +26,16 @@ export class APICache {
         this._get(endpoint)?.invalidateAll();
     }
     /** Trigger a refetch on a specific store for an endpoint. */
-    refetch(endpoint, payload) {
-        this._get(endpoint)?.refetch(payload);
+    refresh(endpoint, payload) {
+        this._get(endpoint)?.refresh(payload);
     }
     /** Trigger a refetch on all stores for an endpoint. */
-    refetchAll(endpoint) {
-        this._get(endpoint)?.refetchAll();
-    }
-    // Implement Disposable.
-    [Symbol.dispose]() {
-        for (const cache of this._caches.values())
-            cache[Symbol.dispose]();
-        this._caches.clear();
+    refreshAll(endpoint) {
+        this._get(endpoint)?.refreshAll();
+    }
+    // Implement `AsyncDisposable`
+    [Symbol.asyncDispose]() {
+        return awaitDispose(...this._endpoints.values(), // Dispose all endpoints.
+        () => this._endpoints.clear());
     }
 }

package/api/cache/EndpointCache.d.ts

@@ -6,8 +6,8 @@ import { EndpointStore } from "../store/EndpointStore.js";
  * Cache of `EndpointStore` objects for a single endpoint, keyed by serialized payload.
  * - Use `get(payload)` to retrieve or create the `EndpointStore` for a given payload.
  */
-export declare class EndpointCache<P = unknown, R = unknown> implements Disposable {
-    private readonly _stores;
+export declare class EndpointCache<P = unknown, R = unknown> implements AsyncDisposable {
+    private readonly _endpoints;
     readonly endpoint: Endpoint<P, R>;
     readonly provider: APIProvider<P, R>;
     constructor(endpoint: Endpoint<P, R>, provider: APIProvider<P, R>);
@@ -18,8 +18,8 @@ export declare class EndpointCache<P = unknown, R = unknown> implements Disposab
     /** Invalidate all stores. */
     invalidateAll(): void;
     /** Trigger a refetch on a specific store. */
-    refetch(payload: P, caller?: AnyCaller): void;
+    refresh(payload: P, caller?: AnyCaller): Promise<void>;
     /** Trigger a refetch on all stores. */
-    refetchAll(): void;
-    [Symbol.dispose](): void;
+    refreshAll(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/api/cache/EndpointCache.js

@@ -1,3 +1,5 @@
+import { awaitValues } from "../../util/async.js";
+import { awaitDispose } from "../../util/dispose.js";
 import { setMapItem } from "../../util/map.js";
 import { EndpointStore } from "../store/EndpointStore.js";
 /**
@@ -5,7 +7,7 @@ import { EndpointStore } from "../store/EndpointStore.js";
  * - Use `get(payload)` to retrieve or create the `EndpointStore` for a given payload.
  */
 export class EndpointCache {
-    _stores = new Map();
+    _endpoints = new Map();
     endpoint;
     provider;
     constructor(endpoint, provider) {
@@ -15,7 +17,7 @@ export class EndpointCache {
     /** Get (or create) the `EndpointStore` for the given payload. */
     get(payload, caller = this.get) {
         const url = this.provider.renderURL(this.endpoint, payload, caller).href;
-        return this._stores.get(url) || setMapItem(this._stores, url, new EndpointStore(this.endpoint, payload, this.provider));
+        return this._endpoints.get(url) || setMapItem(this._endpoints, url, new EndpointStore(this.endpoint, payload, this.provider));
     }
     /** Invalidate a specific store. */
     invalidate(payload, caller = this.invalidate) {
@@ -23,22 +25,20 @@ export class EndpointCache {
     }
     /** Invalidate all stores. */
     invalidateAll() {
-        for (const store of this._stores.values())
+        for (const store of this._endpoints.values())
             store.invalidate();
     }
     /** Trigger a refetch on a specific store. */
-    refetch(payload, caller = this.invalidate) {
-        this.get(payload, caller)?.fetch();
+    async refresh(payload, caller = this.invalidate) {
+        await this.get(payload, caller)?.refresh();
     }
     /** Trigger a refetch on all stores. */
-    refetchAll() {
-        for (const store of this._stores.values())
-            store.fetch();
+    async refreshAll() {
+        await awaitValues(...this._endpoints.values().map(store => store.refresh()));
     }
-    // Implement Disposable.
-    [Symbol.dispose]() {
-        for (const store of this._stores.values())
-            store[Symbol.dispose]();
-        this._stores.clear();
+    // Implement `AsyncDisposable`
+    [Symbol.asyncDispose]() {
+        return awaitDispose(...this._endpoints.values(), // Dispose all endpoints.
+        () => this._endpoints.clear());
     }
 }

package/api/store/EndpointStore.d.ts

@@ -1,42 +1,10 @@
-import { Store } from "../../store/Store.js";
-import { NONE } from "../../util/constants.js";
+import { PayloadFetchStore } from "../../store/PayloadFetchStore.js";
 import type { Endpoint } from "../endpoint/Endpoint.js";
 import type { APIProvider } from "../provider/APIProvider.js";
-/**
- * Store object that loads a result from an API endpoint and manages its state.
- */
-export declare class EndpointStore<P, R> extends Store<R> implements Disposable {
+/** Store object that loads a result from an API endpoint and provider. */
+export declare class EndpointStore<P, R> extends PayloadFetchStore<P, R> {
     readonly provider: APIProvider<P, R>;
     readonly endpoint: Endpoint<P, R>;
-    private _payload;
-    /**
-     * The current payload set for this endpoint.
-     * - Value will only change if the new payload is not deeply equal to the current one.
-     * - If a new payload is set, it will abort any current in-flight request
-     */
-    get payload(): P;
-    set payload(next: P);
-    get loading(): boolean;
-    get value(): R;
-    set value(value: R | typeof NONE);
     constructor(endpoint: Endpoint<P, R>, payload: P, provider: APIProvider<P, R>);
-    /** Store the inflight fetch request. */
-    private _inflight;
-    /**
-     * Invalidate this endpoint, so that calls to `this.value` trigger a new fetch immediately.
-     */
-    invalidate(): void;
-    /**
-     * Fetch the result for this endpoint now.
-     * - Triggered automatically when someone reads `value` or `loading`
-     */
-    fetch(): Promise<void>;
-    /** Fetch the result if the current value is older than `maxAge` milliseconds. */
-    refreshStale(maxAge: number): void;
-    /** Abort any in-flight request now. */
-    private abort;
-    private _fetch;
-    [Symbol.dispose](): void;
+    protected _fetch(): Promise<R>;
 }
-/** Any endpoint store. */
-export type AnyEndpointStore = EndpointStore<any, any>;

package/api/store/EndpointStore.js

@@ -1,117 +1,16 @@
-import { Store } from "../../store/Store.js";
+import { PayloadFetchStore } from "../../store/PayloadFetchStore.js";
 import { NONE } from "../../util/constants.js";
-import { isDeepEqual } from "../../util/equal.js";
-const _CANCELLED = Symbol("EndpointStore/CANCELLED");
-const _TIMEOUT = Symbol("EndpointStore/TIMEOUT");
-/**
- * Store object that loads a result from an API endpoint and manages its state.
- */
-export class EndpointStore extends Store {
+/** Store object that loads a result from an API endpoint and provider. */
+export class EndpointStore extends PayloadFetchStore {
     provider;
     endpoint;
-    _payload;
-    /**
-     * The current payload set for this endpoint.
-     * - Value will only change if the new payload is not deeply equal to the current one.
-     * - If a new payload is set, it will abort any current in-flight request
-     */
-    get payload() {
-        return this._payload;
-    }
-    set payload(next) {
-        const current = this._payload;
-        // Did the payload actually change?
-        if (!isDeepEqual(current, next)) {
-            this._payload = next;
-            this.abort(); // Abort any in-flight requst now (as it would've been sent with the previous payload).
-            this.fetch();
-        }
-    }
-    // Override to possibly trigger a fetch when `this.loading` is read.
-    // This is because when we check `store.loading` in a component we are signalling intent that we wish to use that value.
-    get loading() {
-        const loading = super.loading;
-        if (loading)
-            this.fetch();
-        return loading;
-    }
-    // Override to possibly trigger a fetch when `this.value` is first read.
-    // This is because when we check `store.loading` in a component we are signalling intent that we wish to use that value.
-    get value() {
-        if (super.loading)
-            this.fetch();
-        return super.value;
-    }
-    set value(value) {
-        super.value = value;
-    }
     constructor(endpoint, payload, provider) {
-        super(NONE);
+        super(payload, NONE);
         this.endpoint = endpoint;
         this.provider = provider;
-        this.payload = payload;
-    }
-    /** Store the inflight fetch request. */
-    _inflight = undefined;
-    /**
-     * Invalidate this endpoint, so that calls to `this.value` trigger a new fetch immediately.
-     */
-    invalidate() {
-        this.abort();
-        // @todo Implement this by setting the _age_ to `undefined` instead, so that the current value continues to exist but is so old that it triggers a refetch.
-        // That means we need to have an age system built into this somehow, we can't just implement it in `useAPI()`
-        // Don't know if I like that.....
-        this.value = NONE;
-    }
-    /**
-     * Fetch the result for this endpoint now.
-     * - Triggered automatically when someone reads `value` or `loading`
-     */
-    fetch() {
-        // Re-use existing fetch if it exists.
-        if (this._inflight)
-            return this._inflight.promise;
-        // Create a new fetch.
-        const abort = new AbortController();
-        const promise = this._fetch(abort);
-        this._inflight = { abort, promise };
-        return promise;
-    }
-    /** Fetch the result if the current value is older than `maxAge` milliseconds. */
-    refreshStale(maxAge) {
-        if (this.age > maxAge)
-            void this.fetch();
-    }
-    /** Abort any in-flight request now. */
-    abort() {
-        if (this._inflight) {
-            const { abort } = this._inflight;
-            this._inflight = undefined;
-            abort.abort(_CANCELLED);
-        }
-    }
-    /** Fetch the result from the API endpoint now. */
-    async _fetch(abort) {
-        try {
-            const value = await this.provider.call(this.endpoint, this._payload, { signal: abort.signal });
-            this.reason = undefined;
-            this.value = value;
-        }
-        catch (thrown) {
-            console.error(thrown);
-            if (thrown === _CANCELLED)
-                return; // Cancelled on purpose.
-            else if (thrown === _TIMEOUT)
-                this.reason = "Timed out"; // Request timed out.
-            else
-                this.reason = thrown;
-        }
-        finally {
-            this._inflight = undefined;
-        }
     }
-    // Implement Disposable.
-    [Symbol.dispose]() {
-        this.abort();
+    // Override to fetch the value using the provider and endpoint.
+    _fetch() {
+        return this.provider.call(this.endpoint, this.payload.value, { signal: this.signal });
     }
 }

package/cloudflare/CloudflareKVProvider.d.ts

@@ -1,7 +1,7 @@
 import type { Collection } from "../db/collection/Collection.js";
 import { DBProvider } from "../db/provider/DBProvider.js";
 import type { Data } from "../util/data.js";
-import { type Item, type Items, type OptionalItem } from "../util/item.js";
+import { type Item, type Items, type ItemsSequence, type OptionalItem, type OptionalItemSequence } from "../util/item.js";
 import type { Query } from "../util/query.js";
 import type { Updates } from "../util/update.js";
 import type { KVNamespace } from "./types.js";
@@ -31,13 +31,13 @@ export declare class CloudflareKVProvider<I extends string = string, T extends D
     private readonly _kv;
     constructor(kv: KVNamespace);
     getItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
-    getItemSequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _id: II): AsyncIterable<OptionalItem<II, TT>>;
+    getItemSequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _id: II): OptionalItemSequence<II, TT>;
     addItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, data: TT): Promise<II>;
     setItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
     updateItem<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _id: II, _updates: Updates<Item<II, TT>>): Promise<void>;
     deleteItem<II extends I, TT extends T>({ name }: Collection<string, II, TT>, id: II): Promise<void>;
     getQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    getQuerySequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query?: Query<Item<II, TT>>): AsyncIterable<Items<II, TT>>;
+    getQuerySequence<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
     setQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query: Query<Item<II, TT>>, _data: TT): Promise<void>;
     updateQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query: Query<Item<II, TT>>, _updates: Updates<TT>): Promise<void>;
     deleteQuery<II extends I, TT extends T>(_collection: Collection<string, II, TT>, _query: Query<Item<II, TT>>): Promise<void>;

package/db/cache/CollectionCache.d.ts

@@ -11,7 +11,7 @@ import { QueryStore } from "../store/QueryStore.js";
  * - Use `getItem(id)` to retrieve or create the `ItemStore` for a given id.
  * - Use `getQuery(query)` to retrieve or create the `QueryStore` for a given query.
  */
-export declare class CollectionCache<I extends Identifier, T extends Data> implements Disposable {
+export declare class CollectionCache<I extends Identifier, T extends Data> implements AsyncDisposable {
     private readonly _items;
     private readonly _queries;
     readonly collection: Collection<string, I, T>;
@@ -23,15 +23,15 @@ export declare class CollectionCache<I extends Identifier, T extends Data> imple
     /** Get (or create) the `QueryStore` for the given query. */
     getQuery(query: Query<Item<I, T>>): QueryStore<I, T>;
     /** Refresh a specific item store. */
-    refreshItem(id: I): void;
+    refreshItem(id: I): Promise<void>;
     /** Refresh every cached item store. */
-    refreshItems(): void;
+    refreshItems(): Promise<void>;
     /** Refresh a specific query store. */
-    refreshQuery(query: Query<Item<I, T>>): void;
+    refreshQuery(query: Query<Item<I, T>>): Promise<void>;
     /** Refresh every cached query store. */
-    refreshQueries(): void;
+    refreshQueries(): Promise<void>;
     /** Refresh every cached store (items and queries). */
-    refreshAll(): void;
+    refreshAll(): Promise<void>;
     private _queryKey;
-    [Symbol.dispose](): void;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/db/cache/CollectionCache.js

@@ -1,3 +1,5 @@
+import { awaitValues } from "../../util/async.js";
+import { awaitDispose } from "../../util/dispose.js";
 import { setMapItem } from "../../util/map.js";
 import { ItemStore } from "../store/ItemStore.js";
 import { QueryStore } from "../store/QueryStore.js";
@@ -19,8 +21,7 @@ export class CollectionCache {
     }
     /** Get (or create) the `ItemStore` for the given id. */
     getItem(id) {
-        const key = String(id);
-        return this._items.get(key) || setMapItem(this._items, key, new ItemStore(this.collection, id, this.provider, this.memory));
+        return this._items.get(id) || setMapItem(this._items, id, new ItemStore(this.collection, id, this.provider, this.memory));
     }
     /** Get (or create) the `QueryStore` for the given query. */
     getQuery(query) {
@@ -28,35 +29,33 @@ export class CollectionCache {
         return this._queries.get(key) || setMapItem(this._queries, key, new QueryStore(this.collection, query, this.provider, this.memory));
     }
     /** Refresh a specific item store. */
-    refreshItem(id) {
-        this._items.get(String(id))?.refresh();
+    async refreshItem(id) {
+        await this._items.get(id)?.refresh();
     }
     /** Refresh every cached item store. */
-    refreshItems() {
-        for (const store of this._items.values())
-            store.refresh();
+    async refreshItems() {
+        await awaitValues(...this._items.values().map(store => store.refresh()));
     }
     /** Refresh a specific query store. */
-    refreshQuery(query) {
-        this._queries.get(this._queryKey(query))?.refresh();
+    async refreshQuery(query) {
+        await this._queries.get(this._queryKey(query))?.refresh();
     }
     /** Refresh every cached query store. */
-    refreshQueries() {
-        for (const store of this._queries.values())
-            store.refresh();
+    async refreshQueries() {
+        await awaitValues(...this._queries.values().map(store => store.refresh()));
     }
     /** Refresh every cached store (items and queries). */
-    refreshAll() {
-        this.refreshItems();
-        this.refreshQueries();
+    async refreshAll() {
+        await awaitValues(this.refreshItems(), this.refreshQueries());
     }
     _queryKey(query) {
         return JSON.stringify(query);
     }
-    // Implement Disposable.
-    [Symbol.dispose]() {
-        // Note: `ItemStore`/`QueryStore` are not themselves `Disposable`, so we only drop references.
-        this._items.clear();
-        this._queries.clear();
+    // Implement `AsyncDisposable`
+    [Symbol.asyncDispose]() {
+        return awaitDispose(...this._items.values(), // Dispose all items.
+        ...this._queries.values(), // Dispose all queries.
+        () => this._items.clear(), // Clear the items.
+        () => this._queries.clear());
     }
 }

package/db/cache/DBCache.d.ts

@@ -12,8 +12,8 @@ import { CollectionCache } from "./CollectionCache.js";
  * - Use `get(collection)` to retrieve or create the `CollectionCache` for a given collection,
  *   then `getItem(id)` / `getQuery(query)` on that to get a specific store.
  */
-export declare class DBCache<I extends Identifier = Identifier, T extends Data = Data> implements Disposable {
-    private readonly _caches;
+export declare class DBCache<I extends Identifier = Identifier, T extends Data = Data> implements AsyncDisposable {
+    private readonly _collections;
     readonly provider: DBProvider<I, T>;
     readonly memory: MemoryDBProvider<I, T> | undefined;
     constructor(provider: DBProvider<I, T>);
@@ -25,14 +25,14 @@ export declare class DBCache<I extends Identifier = Identifier, T extends Data =
     /** Get (or create) a `QueryStore` for a collection/query in one hop. */
     getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): QueryStore<II, TT>;
     /** Refresh a specific item store for a collection. */
-    refreshItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): void;
+    refreshItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<void>;
     /** Refresh every cached item store for a collection. */
-    refreshItems<II extends I, TT extends T>(collection: Collection<string, II, TT>): void;
+    refreshItems<II extends I, TT extends T>(collection: Collection<string, II, TT>): Promise<void>;
     /** Refresh a specific query store for a collection. */
-    refreshQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): void;
+    refreshQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<void>;
     /** Refresh every cached query store for a collection. */
-    refreshQueries<II extends I, TT extends T>(collection: Collection<string, II, TT>): void;
+    refreshQueries<II extends I, TT extends T>(collection: Collection<string, II, TT>): Promise<void>;
     /** Refresh every cached store (items and queries) for a collection. */
-    refreshAll<II extends I, TT extends T>(collection: Collection<string, II, TT>): void;
-    [Symbol.dispose](): void;
+    refreshAll<II extends I, TT extends T>(collection: Collection<string, II, TT>): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/db/cache/DBCache.js

@@ -1,3 +1,4 @@
+import { awaitDispose } from "../../util/dispose.js";
 import { setMapItem } from "../../util/map.js";
 import { getSource } from "../../util/source.js";
 import { CacheDBProvider } from "../provider/CacheDBProvider.js";
@@ -8,7 +9,7 @@ import { CollectionCache } from "./CollectionCache.js";
  *   then `getItem(id)` / `getQuery(query)` on that to get a specific store.
  */
 export class DBCache {
-    _caches = new Map();
+    _collections = new Map();
     provider;
     memory;
     constructor(provider) {
@@ -17,10 +18,10 @@ export class DBCache {
         this.memory = getSource(CacheDBProvider, provider)?.memory;
     }
     _get(collection) {
-        return this._caches.get(collection);
+        return this._collections.get(collection);
     }
     get(collection) {
-        return this._get(collection) || setMapItem(this._caches, collection, new CollectionCache(collection, this.provider, this.memory));
+        return this._get(collection) || setMapItem(this._collections, collection, new CollectionCache(collection, this.provider, this.memory));
     }
     /** Get (or create) an `ItemStore` for a collection/id in one hop. */
     getItem(collection, id) {
@@ -31,29 +32,28 @@ export class DBCache {
         return this.get(collection).getQuery(query);
     }
     /** Refresh a specific item store for a collection. */
-    refreshItem(collection, id) {
-        this._get(collection)?.refreshItem(id);
+    async refreshItem(collection, id) {
+        await this._get(collection)?.refreshItem(id);
     }
     /** Refresh every cached item store for a collection. */
-    refreshItems(collection) {
-        this._get(collection)?.refreshItems();
+    async refreshItems(collection) {
+        await this._get(collection)?.refreshItems();
     }
     /** Refresh a specific query store for a collection. */
-    refreshQuery(collection, query) {
-        this._get(collection)?.refreshQuery(query);
+    async refreshQuery(collection, query) {
+        await this._get(collection)?.refreshQuery(query);
     }
     /** Refresh every cached query store for a collection. */
-    refreshQueries(collection) {
-        this._get(collection)?.refreshQueries();
+    async refreshQueries(collection) {
+        await this._get(collection)?.refreshQueries();
     }
     /** Refresh every cached store (items and queries) for a collection. */
-    refreshAll(collection) {
-        this._get(collection)?.refreshAll();
-    }
-    // Implement Disposable.
-    [Symbol.dispose]() {
-        for (const cache of this._caches.values())
-            cache[Symbol.dispose]();
-        this._caches.clear();
+    async refreshAll(collection) {
+        await this._get(collection)?.refreshAll();
+    }
+    // Implement `AsyncDisposable`
+    async [Symbol.asyncDispose]() {
+        return awaitDispose(...this._collections.values(), // Dispose all collections.
+        () => this._collections.clear());
     }
 }

package/db/provider/CacheDBProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Data } from "../../util/data.js";
-import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
+import type { Identifier, Item, Items, ItemsSequence, OptionalItem, OptionalItemSequence } from "../../util/item.js";
 import type { Query } from "../../util/query.js";
 import type { Sourceable } from "../../util/source.js";
 import type { Updates } from "../../util/update.js";
@@ -12,14 +12,14 @@ export declare class CacheDBProvider<I extends Identifier, T extends Data> exten
     readonly memory: MemoryDBProvider<I, T>;
     constructor(source: DBProvider<I, T>, cache?: MemoryDBProvider<I, T>);
     getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
-    getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): AsyncIterable<OptionalItem<II, TT>>;
+    getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): OptionalItemSequence<II, TT>;
     addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
     setItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
     updateItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, updates: Updates<Item<II, TT>>): Promise<void>;
     deleteItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<void>;
     countQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<number>;
     getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): AsyncIterable<Items<II, TT>>;
+    getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
     setQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, data: TT): Promise<void>;
     updateQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
     deleteQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<void>;

package/db/provider/DBProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Data } from "../../util/data.js";
-import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
+import type { Identifier, Item, Items, ItemsSequence, OptionalItem, OptionalItemSequence } from "../../util/item.js";
 import type { Query } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";
 import type { Collection } from "../collection/Collection.js";
@@ -7,14 +7,14 @@ import type { Collection } from "../collection/Collection.js";
 export declare abstract class DBProvider<I extends Identifier = Identifier, T extends Data = Data> {
     abstract getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
     requireItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<Item<II, TT>>;
-    abstract getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): AsyncIterable<OptionalItem<II, TT>>;
+    abstract getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): OptionalItemSequence<II, TT>;
     abstract addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
     abstract setItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
     abstract updateItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, updates: Updates<Item<II, TT>>): Promise<void>;
     abstract deleteItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<void>;
     countQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<number>;
     abstract getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    abstract getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): AsyncIterable<Items<II, TT>>;
+    abstract getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
     abstract setQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, data: TT): Promise<void>;
     abstract updateQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
     abstract deleteQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<void>;

package/db/provider/DebugDBProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Data } from "../../util/data.js";
-import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
+import type { Identifier, Item, Items, ItemsSequence, OptionalItem, OptionalItemSequence } from "../../util/item.js";
 import type { Query } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";
 import type { Collection } from "../collection/Collection.js";
@@ -7,14 +7,14 @@ import { ThroughDBProvider } from "./ThroughDBProvider.js";
 /** Provider that logs operations to the console. */
 export declare class DebugDBProvider<I extends Identifier, T extends Data> extends ThroughDBProvider<I, T> {
     getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
-    getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): AsyncIterableIterator<OptionalItem<II, TT>>;
+    getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): OptionalItemSequence<II, TT>;
     addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
     setItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
     updateItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, updates: Updates<Item<II, TT>>): Promise<void>;
     deleteItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<void>;
     countQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<number>;
     getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
-    getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): AsyncIterableIterator<Items<II, TT>>;
+    getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
     setQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, data: TT): Promise<void>;
     updateQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
     deleteQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<void>;