shelving 1.181.0 → 1.181.2

package/api/provider/MockAPIProvider.d.ts

@@ -12,14 +12,19 @@ export type MockAPICall = {
     readonly response: Response;
     readonly result: unknown;
 };
-/** Construction options for a `MockAPIProvider`. */
-export interface MockAPIProviderOptions extends ClientAPIProviderOptions {
+/**
+ * Construction options for a `MockAPIProvider`
+ * - Same as options for a normal `ClientAPIProvider`, but with an optional URL.
+ */
+export interface MockAPIProviderOptions extends Omit<ClientAPIProviderOptions, "url"> {
+    /** Optional URL, defaults to `"https://api.mock.com"` */
+    url?: ClientAPIProviderOptions["url"];
 }
 /** Provider that logs API calls without sending network requests. */
 export declare class MockAPIProvider extends ClientAPIProvider {
     readonly calls: MockAPICall[];
     readonly handler: RequestHandler;
-    constructor(handler: RequestHandler, options?: MockAPIProviderOptions);
+    constructor(handler: RequestHandler, { url, ...options }?: MockAPIProviderOptions);
     /**
      * Log a `fetch()` call without using the network.
      * - If `getResult` is configured, its return value is returned as-is (no schema validation).

package/api/provider/MockAPIProvider.js

@@ -4,8 +4,8 @@ import { ClientAPIProvider } from "./ClientAPIProvider.js";
 export class MockAPIProvider extends ClientAPIProvider {
     calls = [];
     handler;
-    constructor(handler, options = { url: "https://api.mock.com" }) {
-        super(options);
+    constructor(handler, { url = "https://api.mock.com", ...options } = {}) {
+        super({ url, ...options });
         this.handler = handler;
     }
     /**

package/api/provider/MockEndpointAPIProvider.d.ts

@@ -1,6 +1,10 @@
 import { type EndpointHandlers } from "../endpoint/util.js";
 import { MockAPIProvider, type MockAPIProviderOptions } from "./MockAPIProvider.js";
-export interface MockEndpointAPIProviderOptions<C> extends MockAPIProviderOptions {
+/**
+ * Construction options for a `MockAPIProvider`
+ * - Same as options for a normal `MockAPIProviderOptions`, but with a `context` property for the endpoints.
+ */
+export interface MockEndpointAPIProviderOptions<C = void> extends MockAPIProviderOptions {
     context: C;
 }
 /**

package/db/collection/Collection.d.ts

@@ -1,27 +1,38 @@
 import { DataSchema } from "../../schema/DataSchema.js";
 import { NumberSchema } from "../../schema/NumberSchema.js";
 import type { Schema, Schemas } from "../../schema/Schema.js";
+import type { ImmutableArray } from "../../util/array.js";
 import type { Data } from "../../util/data.js";
 import type { Identifier, Item } from "../../util/item.js";
 /** Default identifier schema (integer). */
 export declare const ID: NumberSchema;
 /** Declarative definition of a database collection/table. */
-export declare class Collection<K extends string, I extends Identifier, T extends Data> extends DataSchema<T> {
+export declare class Collection<N extends string, I extends Identifier, T extends Data> extends DataSchema<T> {
     /** Collection name (used as the table/collection key). */
-    readonly name: K;
+    readonly name: N;
     /** Schema for the identifier type. */
     readonly id: Schema<I>;
     /** Schema for a complete item (id + data). */
     readonly item: DataSchema<Item<I, T>>;
-    constructor(name: K, id: Schema<I>, data: Schemas<T> | DataSchema<T>);
+    constructor(name: N, id: Schema<I>, data: Schemas<T> | DataSchema<T>);
 }
 /** Shortcut factory for creating a Collection. */
 export declare function COLLECTION<K extends string, I extends Identifier, T extends Data>(name: K, id: Schema<I>, data: Schemas<T> | DataSchema<T>): Collection<K, I, T>;
-/** A readonly array of Collection instances, possibly with a standardised `Identifier`. */
-export type Collections<I extends Identifier = Identifier> = ReadonlyArray<Collection<string, I, Data>>;
-/** Extract the union of collection key strings from a Collections type. */
-export type CollectionKeys<C extends Collections> = C[number]["name"];
-/** Convert a Collections array type to a Database-style object mapping. */
+/** Any collection object, possibly with a standardised `Identifier` type. */
+export type AnyCollection<I extends Identifier = Identifier> = Collection<string, I, Data>;
+/** Extract the string name from a `Collection` instance. */
+export type CollectionName<C extends AnyCollection> = C extends Collection<infer N, infer _I, infer _T> ? N : never;
+/** Extract the `Identifier` type from a `Collection` instance. */
+export type CollectionIdentifier<C extends AnyCollection> = C extends Collection<infer _N, infer I, infer _T> ? I : never;
+/** Extract the `Data` type from a `Collection` instance. */
+export type CollectionData<C extends AnyCollection> = C extends Collection<infer _N, infer _I, infer T> ? T : never;
+/** Extract the `Item` type from a `Collection` instance. */
+export type CollectionItem<C extends AnyCollection> = C extends Collection<infer _N, infer I, infer T> ? Item<I, T> : never;
+/** A readonly array of Collection instances, possibly with a standardised `Identifier` type. */
+export type Collections<I extends Identifier = Identifier> = ImmutableArray<AnyCollection<I>>;
+/** Extract the union of string collection names from a `Collections` type. */
+export type CollectionNames<C extends Collections> = C[number]["name"];
+/** Convert a `Collections` array type to a Database-style object mapping in `{ name: data }` format. */
 export type CollectionsDatabase<C extends Collections> = {
-    [E in C[number] as E extends Collection<infer K, any, any> ? K : never]: E extends Collection<string, any, infer T> ? T : never;
+    [E in C[number] as E extends Collection<infer N, Identifier, Data> ? N : never]: E extends Collection<string, Identifier, infer T> ? T : never;
 };

package/db/provider/ValidationDBProvider.js

@@ -1,70 +1,85 @@
 import { ValueError } from "../../error/ValueError.js";
 import { PARTIAL } from "../../schema/DataSchema.js";
 import { getNamedMessage } from "../../util/error.js";
-import { validateData } from "../../util/validate.js";
 import { ThroughDBProvider } from "./ThroughDBProvider.js";
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export class ValidationDBProvider extends ThroughDBProvider {
     async getItem(collection, id) {
-        return _validateItem(collection.name, await super.getItem(collection, id), collection.id, collection, this.getItem);
+        return _validateItem(collection, await super.getItem(collection, id), this.getItem);
     }
     async *getItemSequence(collection, id) {
         for await (const item of super.getItemSequence(collection, id))
-            yield _validateItem(collection.name, item, collection.id, collection, this.getItemSequence);
+            yield _validateItem(collection, item, this.getItemSequence);
     }
-    addItem(collection, data) {
-        return super.addItem(collection, validateData(data, collection.props));
+    async addItem(collection, data) {
+        return _validateIdentifier(collection, await super.addItem(collection, collection.validate(data)), this.addItem);
     }
     setItem(collection, id, data) {
-        return super.setItem(collection, id, validateData(data, collection.props));
+        return super.setItem(collection, id, collection.validate(data));
     }
     updateItem(collection, id, updates) {
-        return super.updateItem(collection, id, _validateUpdates(collection.name, updates, collection, this.updateItem));
+        return super.updateItem(collection, id, _validateUpdates(collection, updates, this.updateItem));
     }
     countQuery(collection, query) {
         return super.countQuery(collection, query);
     }
     async getQuery(collection, query) {
-        return _validateItems(collection.name, await super.getQuery(collection, query), collection.id, collection, this.getQuery);
+        return _validateItems(collection, await super.getQuery(collection, query), this.getQuery);
     }
     async *getQuerySequence(collection, query) {
         for await (const items of super.getQuerySequence(collection, query))
-            yield _validateItems(collection.name, items, collection.id, collection, this.getQuerySequence);
+            yield _validateItems(collection, items, this.getQuerySequence);
     }
     setQuery(collection, query, data) {
         return super.setQuery(collection, query, collection.validate(data));
     }
     updateQuery(collection, query, updates) {
-        return super.updateQuery(collection, query, _validateUpdates(collection.name, updates, collection, this.updateQuery));
+        return super.updateQuery(collection, query, _validateUpdates(collection, updates, this.updateQuery));
     }
     deleteQuery(collection, query) {
         return super.deleteQuery(collection, query);
     }
 }
-function _validateItem(collection, item, identifier, schema, caller) {
+/**
+ * Validate a returned `id` for a collection item.
+ */
+function _validateIdentifier(collection, id, caller) {
+    try {
+        return collection.id.validate(id);
+    }
+    catch (thrown) {
+        if (typeof thrown !== "string")
+            throw thrown;
+        throw new ValueError(`Invalid identifier for "${collection}"\n${thrown}`, { received: id, caller });
+    }
+}
+function _validateItem(collection, //
+item, caller) {
     if (!item)
         return undefined;
     try {
-        return validateData(item, { id: identifier, ...schema.props });
+        return collection.item.validate(item);
     }
     catch (thrown) {
         if (typeof thrown !== "string")
             throw thrown;
-        throw new ValueError(`Invalid data for "${collection}"\n${thrown}`, { item, caller });
+        throw new ValueError(`Invalid data for "${collection}"\n${thrown}`, { received: item, caller });
     }
 }
 /**
  * Validate a set of entities for this query reference.
  * @throws `ValueError` if one or more items did not validate (conflict because the program is not in an expected state).
  */
-function _validateItems(collection, items, identifier, schema, caller) {
-    return Array.from(_yieldValidItems(collection, items, { id: identifier, ...schema.props }, caller));
+function _validateItems(collection, //
+items, caller) {
+    return Array.from(_yieldValidItems(collection, items, caller));
 }
-function* _yieldValidItems(collection, items, validators, caller) {
+function* _yieldValidItems(collection, //
+items, caller) {
     const messages = [];
     for (const item of items) {
         try {
-            yield validateData(item, validators);
+            yield collection.item.validate(item);
         }
         catch (thrown) {
             if (typeof thrown !== "string")
@@ -73,15 +88,16 @@ function* _yieldValidItems(collection, items, validators, caller) {
         }
     }
     if (messages.length)
-        throw new ValueError(`Invalid data for "${collection}"\n${messages.join("\n")}`, { items, caller });
+        throw new ValueError(`Invalid data for "${collection}"\n${messages.join("\n")}`, { received: items, caller });
 }
-function _validateUpdates(collection, updates, schema, caller) {
+function _validateUpdates(collection, //
+updates, caller) {
     try {
-        return validateData(updates, PARTIAL(schema).props);
+        return PARTIAL(collection).validate(updates);
     }
     catch (thrown) {
         if (typeof thrown !== "string")
             throw thrown;
-        throw new ValueError(`Invalid updates for "${collection}"\n${thrown}`, { updates, caller });
+        throw new ValueError(`Invalid updates for "${collection}"\n${thrown}`, { received: updates, caller });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "shelving",
-	"version": "1.181.0",
+	"version": "1.181.2",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"repository": {
 		"type": "git",