shelving 1.7.1 → 1.10.1

package/db/Document.d.ts

@@ -1,13 +1,11 @@
 import { Data, Observable, Result, Observer, Unsubscriber, AsyncDispatcher, AsyncCatcher, AsyncEmptyDispatcher } from "../util";
 import type { Database } from "./Database";
 import { DocumentState } from "./DocumentState";
+import { Reference } from "./Reference";
 /**
  * Document reference: allows reading from / writing to a specific document in a database.
  */
-export declare class Document<T extends Data = Data> implements Observable<Result<T>> {
-    readonly db: Database;
-    readonly path: string;
-    readonly collection: string;
+export declare class Document<T extends Data = Data> extends Reference<T> implements Observable<Result<T>> {
     readonly id: string;
     constructor(db: Database, collection: string, id: string);
     /**
@@ -108,5 +106,4 @@ export declare class Document<T extends Data = Data> implements Observable<Resul
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
     delete(): void | Promise<void>;
-    toString(): string;
 }

package/db/Document.js

@@ -1,14 +1,13 @@
 import { throwAsync, isAsync } from "../util";
 import { DocumentState } from "./DocumentState";
-import { DocumentRequiredError } from "./errors";
+import { ReferenceRequiredError } from "./errors";
+import { Reference } from "./Reference";
 /**
  * Document reference: allows reading from / writing to a specific document in a database.
  */
-export class Document {
+export class Document extends Reference {
     constructor(db, collection, id) {
-        this.db = db;
-        this.path = `${collection}/${id}`;
-        this.collection = collection;
+        super(db, collection, `${collection}/${id}`);
         this.id = id;
     }
     /**
@@ -77,11 +76,11 @@ export class Document {
         if (isAsync(result))
             return result.then(r => {
                 if (!r)
-                    throw new DocumentRequiredError(this);
+                    throw new ReferenceRequiredError(this);
                 return r;
             });
         if (!result)
-            throw new DocumentRequiredError(this);
+            throw new ReferenceRequiredError(this);
         return result;
     }
     /**
@@ -130,8 +129,4 @@ export class Document {
     delete() {
         return this.db.provider.deleteDocument(this);
     }
-    // Implement toString()
-    toString() {
-        return this.path;
-    }
 }

package/db/DocumentState.d.ts

@@ -1,5 +1,5 @@
 import { State } from "../stream";
-import { Data, LOADING, Observer, Result, Unsubscriber } from "../util";
+import { Data, LOADING, Observer, Result, Transforms, Unsubscriber } from "../util";
 import type { Document } from "./Document";
 /**
  * Document state: stores the global state of a specific document.
@@ -10,7 +10,7 @@ export declare class DocumentState<T extends Data = Data> extends State<Result<T
     #private;
     static get<X extends Data>(ref: Document<X>): DocumentState<X>;
     static set<X extends Data>(ref: Document<X>, result: Result<X> | Promise<Result<X>>): void;
-    static update<X extends Data>(ref: Document<X>, data: Partial<X>): void;
+    static update<X extends Data>(ref: Document<X>, transforms: Transforms<X>): void;
     static start<X extends Data>(ref: Document<X>, observer?: Observer<Result<X>>): Unsubscriber;
     /** Whether we currently have an active realtime subscription, or not. */
     get started(): boolean;

package/db/DocumentState.js

@@ -45,11 +45,11 @@ export class DocumentState extends State {
         else
             __classPrivateFieldGet(this, _a, "f", _DocumentState_states)[key] = new DocumentState(ref, result);
     }
-    static update(ref, data) {
+    static update(ref, transforms) {
         const key = ref.toString();
         const state = __classPrivateFieldGet(this, _a, "f", _DocumentState_states)[key];
         if (state && !state.loading && !state.closed)
-            state.update(data);
+            state.update(transforms);
     }
     static start(ref, observer) {
         const key = ref.toString();

package/db/Documents.d.ts

@@ -3,13 +3,11 @@ import { Query, Queryable } from "../query";
 import type { Database } from "./Database";
 import { Document } from "./Document";
 import { DocumentsState } from "./DocumentsState";
+import { Reference } from "./Reference";
 /**
  * Documents reference: allows reading from / writing to a list of documents in a database, optionally with query filtering and sorting.
  */
-export declare class Documents<T extends Data = Data> implements Queryable<T>, Observable<Results<T>> {
-    readonly db: Database;
-    readonly path: string;
-    readonly collection: string;
+export declare class Documents<T extends Data = Data> extends Reference<T> implements Queryable<T>, Observable<Results<T>> {
     readonly query: Query<T>;
     constructor(db: Database, collection: string, query?: Query<T>);
     /**

package/db/Documents.js

@@ -1,17 +1,16 @@
-import { throwAsync, isAsync, countProps, getFirstProp, getLastProp, } from "../util";
+import { throwAsync, isAsync, countEntries, getFirstProp, getLastProp, } from "../util";
 import { Query } from "../query";
 import { Document } from "./Document";
 import { DocumentsState } from "./DocumentsState";
+import { Reference } from "./Reference";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const EMPTY_QUERY = new Query();
 /**
  * Documents reference: allows reading from / writing to a list of documents in a database, optionally with query filtering and sorting.
  */
-export class Documents {
+export class Documents extends Reference {
     constructor(db, collection, query = EMPTY_QUERY) {
-        this.db = db;
-        this.path = collection;
-        this.collection = collection;
+        super(db, collection, collection);
         this.query = query;
     }
     /**
@@ -74,7 +73,7 @@ export class Documents {
      */
     get asyncCount() {
         const results = this.db.provider.getDocuments(this);
-        return isAsync(results) ? results.then(countProps) : countProps(results);
+        return isAsync(results) ? results.then(countEntries) : countEntries(results);
     }
     /**
      * Get an array of string IDs for this set of documents (asynchronously).

package/db/MemoryProvider.d.ts

@@ -1,4 +1,4 @@
-import { Data, Result, Results, Unsubscriber, Observer } from "../util";
+import { Data, Result, Results, Unsubscriber, Observer, Transforms } from "../util";
 import type { Provider } from "./Provider";
 import type { Documents } from "./Documents";
 import type { Document } from "./Document";
@@ -16,12 +16,12 @@ export declare class MemoryProvider implements Provider {
     onDocument<X extends Data>(ref: Document<X>, observer: Observer<Result<X>>): Unsubscriber;
     addDocument<X extends Data>(ref: Documents<X>, data: X): string;
     setDocument<X extends Data>(ref: Document<X>, data: X): void;
-    updateDocument<X extends Data>(ref: Document<X>, data: Partial<X>): void;
+    updateDocument<X extends Data>(ref: Document<X>, transforms: Transforms<X>): void;
     deleteDocument<X extends Data>(ref: Document<X>): void;
     getDocuments<X extends Data>(ref: Documents<X>): Results<X>;
     onDocuments<X extends Data>(ref: Documents<X>, observer: Observer<Results<X>>): Unsubscriber;
     setDocuments<X extends Data>(ref: Documents<X>, data: X): void;
-    updateDocuments<X extends Data>(ref: Documents<X>, data: Partial<X>): void;
+    updateDocuments<X extends Data>(ref: Documents<X>, transforms: Transforms<X>): void;
     deleteDocuments<X extends Data>(ref: Documents<X>): void;
     reset(): void;
 }

package/db/MemoryProvider.js

@@ -10,8 +10,8 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _MemoryProvider_instances, _MemoryProvider_tables, _MemoryProvider_table, _Table_dispatchers, _Table_changes, _Table_results;
-import { randomId, objectFromEntries, updateProps, addItem, removeItem, dispatch, dispatchNext, thispatch, } from "../util";
-import { DocumentRequiredError } from "./errors";
+import { randomId, objectFromEntries, addItem, removeItem, dispatch, dispatchNext, thispatch, transformProps, } from "../util";
+import { ReferenceRequiredError } from "./errors";
 /**
  * Memory provider: fast in-memory store for data.
  *
@@ -52,13 +52,13 @@ export class MemoryProvider {
     setDocument(ref, data) {
         __classPrivateFieldGet(this, _MemoryProvider_instances, "m", _MemoryProvider_table).call(this, ref).set(ref.id, data);
     }
-    updateDocument(ref, data) {
+    updateDocument(ref, transforms) {
         const table = __classPrivateFieldGet(this, _MemoryProvider_instances, "m", _MemoryProvider_table).call(this, ref);
         const id = ref.id;
         const existing = table.result(id);
         if (!existing)
-            throw new DocumentRequiredError(ref);
-        table.set(id, updateProps(existing, data));
+            throw new ReferenceRequiredError(ref);
+        table.set(id, transformProps(existing, transforms));
     }
     deleteDocument(ref) {
         __classPrivateFieldGet(this, _MemoryProvider_instances, "m", _MemoryProvider_table).call(this, ref).set(ref.id, undefined);
@@ -113,11 +113,11 @@ export class MemoryProvider {
         for (const [id] of entries)
             table.set(id, data);
     }
-    updateDocuments(ref, data) {
+    updateDocuments(ref, transforms) {
         const table = __classPrivateFieldGet(this, _MemoryProvider_instances, "m", _MemoryProvider_table).call(this, ref);
         const entries = ref.query.apply(Object.entries(table.results()));
         for (const [id, existing] of entries)
-            table.set(id, updateProps(existing, data));
+            table.set(id, transformProps(existing, transforms));
     }
     deleteDocuments(ref) {
         const table = __classPrivateFieldGet(this, _MemoryProvider_instances, "m", _MemoryProvider_table).call(this, ref);

package/db/Provider.d.ts

@@ -1,4 +1,4 @@
-import type { Observer, Unsubscriber, Data, Result, Results } from "../util";
+import type { Observer, Unsubscriber, Data, Result, Results, Transforms } from "../util";
 import type { Document } from "./Document";
 import type { Documents } from "./Documents";
 /**
@@ -49,12 +49,12 @@ export interface Provider {
      * - If the document doesn't exist, throw an error.
      *
      * @param ref Document reference specifying which document to merge into.
-     * @param data Partial data to merge into the existing document.
+     * @param transforms Set of transforms to apply to the existing document.
      *
      * @return Nothing (possibly promised).
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    updateDocument<X extends Data>(ref: Document<X>, data: Partial<X>): void | Promise<void>;
+    updateDocument<X extends Data>(ref: Document<X>, transforms: Transforms<X>): void | Promise<void>;
     /**
      * Delete an existing document.
      * - If the document doesn't exist, throw an error.
@@ -95,11 +95,11 @@ export interface Provider {
      * Update all matching documents with the same partial value.
      *
      * @param ref Documents reference specifying which collection to update.
-     * @param data Partial data to merge into every matching document.
+     * @param transforms Set of transforms to apply to every matching document.
      *
      * @return Nothing (possibly promised).
      */
-    updateDocuments<X extends Data>(ref: Documents<X>, data: Partial<X>): void | Promise<void>;
+    updateDocuments<X extends Data>(ref: Documents<X>, transforms: Transforms<X>): void | Promise<void>;
     /**
      * Delete all matching documents.
      *

package/db/Reference.d.ts

@@ -0,0 +1,17 @@
+import { ObjectSchema, Validator } from "../schema";
+import { Data } from "../util";
+import type { Database } from "./Database";
+/**
+ * Reference: a location in a database
+ * - This class is a shared base for both `Document` and `Documents`
+ */
+export declare class Reference<T extends Data = Data> implements Validator<T> {
+    readonly db: Database;
+    readonly collection: string;
+    readonly path: string;
+    constructor(db: Database, collection: string, path: string);
+    /** Get the corresponding `ObjectSchema` for this reference. */
+    get schema(): ObjectSchema<T>;
+    validate(data: unknown): T;
+    toString(): string;
+}

package/db/Reference.js

@@ -0,0 +1,35 @@
+import { isFeedback } from "../feedback";
+import { ObjectSchema } from "../schema";
+import { assertInstance } from "../util";
+import { ReferenceValidationError } from "./errors";
+/**
+ * Reference: a location in a database
+ * - This class is a shared base for both `Document` and `Documents`
+ */
+export class Reference {
+    constructor(db, collection, path) {
+        this.db = db;
+        this.collection = collection;
+        this.path = path;
+    }
+    /** Get the corresponding `ObjectSchema` for this reference. */
+    get schema() {
+        const schema = this.db.schemas[this.collection];
+        assertInstance(schema, ObjectSchema);
+        return schema;
+    }
+    // Implement `Validator`
+    validate(data) {
+        const schema = this.schema;
+        try {
+            return schema.validate(data);
+        }
+        catch (thrown) {
+            throw isFeedback(thrown) ? new ReferenceValidationError(this, thrown) : thrown;
+        }
+    }
+    // Implement `toString()`
+    toString() {
+        return this.path;
+    }
+}

package/db/StateProvider.d.ts

@@ -1,4 +1,4 @@
-import { Data, Result, Results, Unsubscriber, Observer } from "../util";
+import { Data, Result, Results, Unsubscriber, Observer, Transforms } from "../util";
 import type { Document } from "./Document";
 import type { Documents } from "./Documents";
 import type { Provider } from "./Provider";
@@ -12,7 +12,7 @@ export declare class StateProvider implements Provider {
     onDocument<X extends Data>(ref: Document<X>, observer: Observer<Result<X>>): Unsubscriber;
     addDocument<X extends Data>(ref: Documents<X>, data: X): Promise<string>;
     setDocument<X extends Data>(ref: Document<X>, data: X): Promise<void>;
-    updateDocument<X extends Data>(ref: Document<X>, data: Partial<X>): Promise<void>;
+    updateDocument<X extends Data>(ref: Document<X>, transforms: Transforms<X>): Promise<void>;
     deleteDocument<X extends Data>(ref: Document<X>): Promise<void>;
     getDocuments<X extends Data>(ref: Documents<X>): Results<X> | Promise<Results<X>>;
     onDocuments<X extends Data>(ref: Documents<X>, observer: Observer<Results<X>>): Unsubscriber;

package/db/StateProvider.js

@@ -37,9 +37,9 @@ export class StateProvider {
         await __classPrivateFieldGet(this, _StateProvider_source, "f").setDocument(ref, data);
         DocumentState.set(ref, data);
     }
-    async updateDocument(ref, data) {
-        await __classPrivateFieldGet(this, _StateProvider_source, "f").updateDocument(ref, data);
-        DocumentState.update(ref, data);
+    async updateDocument(ref, transforms) {
+        await __classPrivateFieldGet(this, _StateProvider_source, "f").updateDocument(ref, transforms);
+        DocumentState.update(ref, transforms);
     }
     async deleteDocument(ref) {
         await __classPrivateFieldGet(this, _StateProvider_source, "f").deleteDocument(ref);

package/db/ValidationProvider.d.ts

@@ -1,4 +1,4 @@
-import { Data, Result, Results, Unsubscriber, Observer } from "../util";
+import { Data, Result, Results, Unsubscriber, Observer, Transforms } from "../util";
 import type { Provider } from "./Provider";
 import type { Document } from "./Document";
 import type { Documents } from "./Documents";
@@ -12,11 +12,11 @@ export declare class ValidationProvider implements Provider {
     onDocument<X extends Data>(ref: Document<X>, observer: Observer<Result>): Unsubscriber;
     addDocument<X extends Data>(ref: Documents<X>, data: X): string | Promise<string>;
     setDocument<X extends Data>(ref: Document<X>, data: X): void | Promise<void>;
-    updateDocument<X extends Data>(ref: Document<X>, data: Partial<X>): void | Promise<void>;
+    updateDocument<X extends Data>(ref: Document<X>, transforms: Transforms<X>): void | Promise<void>;
     deleteDocument<X extends Data>(ref: Document<X>): void | Promise<void>;
     getDocuments<X extends Data>(ref: Documents<X>): Results<X> | Promise<Results<X>>;
     onDocuments<X extends Data>(ref: Documents<X>, observer: Observer<Results<X>>): Unsubscriber;
     setDocuments<X extends Data>(ref: Documents<X>, data: X): void | Promise<void>;
-    updateDocuments<X extends Data>(ref: Documents<X>, data: Partial<X>): void | Promise<void>;
+    updateDocuments<X extends Data>(ref: Documents<X>, transforms: Transforms<X>): void | Promise<void>;
     deleteDocuments<X extends Data>(ref: Documents<X>): void | Promise<void>;
 }

package/db/ValidationProvider.js

@@ -10,11 +10,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _ValidationProvider_instances, _ValidationProvider_source, _ValidationProvider_awaitGetDocument, _ValidationProvider_awaitGetDocuments;
-import { isAsync } from "../util";
-import { ValidationError } from "../errors";
+import { isAsync, isObject, isTransform } from "../util";
 import { InvalidFeedback, isFeedback } from "../feedback";
-import { ObjectSchema, Schema } from "../schema";
 import { Stream } from "../stream";
+import { ReferenceValidationError } from "./errors";
 /**
  * Validation provider: validates any values that are read from or written a the source provider.
  */
@@ -28,10 +27,10 @@ export class ValidationProvider {
         const result = __classPrivateFieldGet(this, _ValidationProvider_source, "f").getDocument(ref);
         if (isAsync(result))
             return __classPrivateFieldGet(this, _ValidationProvider_instances, "m", _ValidationProvider_awaitGetDocument).call(this, ref, result);
-        return result ? validateData(ref, result) : undefined;
+        return validateResult(ref, result);
     }
     onDocument(ref, observer) {
-        const stream = Stream.derive(v => (v ? validateData(ref, v) : undefined));
+        const stream = Stream.derive(v => validateResult(ref, v));
         stream.subscribe(observer);
         return __classPrivateFieldGet(this, _ValidationProvider_source, "f").onDocument(ref, stream);
     }
@@ -41,8 +40,8 @@ export class ValidationProvider {
     setDocument(ref, data) {
         return __classPrivateFieldGet(this, _ValidationProvider_source, "f").setDocument(ref, validateData(ref, data));
     }
-    updateDocument(ref, data) {
-        return __classPrivateFieldGet(this, _ValidationProvider_source, "f").updateDocument(ref, validateData(ref, data, true));
+    updateDocument(ref, transforms) {
+        return __classPrivateFieldGet(this, _ValidationProvider_source, "f").updateDocument(ref, validateTransforms(ref, transforms));
     }
     deleteDocument(ref) {
         return __classPrivateFieldGet(this, _ValidationProvider_source, "f").deleteDocument(ref);
@@ -59,10 +58,10 @@ export class ValidationProvider {
         return __classPrivateFieldGet(this, _ValidationProvider_source, "f").onDocuments(ref, stream);
     }
     setDocuments(ref, data) {
-        return __classPrivateFieldGet(this, _ValidationProvider_source, "f").setDocuments(ref, validateData(ref, data));
+        return __classPrivateFieldGet(this, _ValidationProvider_source, "f").setDocuments(ref, ref.validate(data));
     }
-    updateDocuments(ref, data) {
-        return __classPrivateFieldGet(this, _ValidationProvider_source, "f").updateDocuments(ref, validateData(ref, data, true));
+    updateDocuments(ref, transforms) {
+        return __classPrivateFieldGet(this, _ValidationProvider_source, "f").updateDocuments(ref, validateTransforms(ref, transforms));
     }
     deleteDocuments(ref) {
         return __classPrivateFieldGet(this, _ValidationProvider_source, "f").deleteDocuments(ref);
@@ -70,41 +69,83 @@ export class ValidationProvider {
 }
 _ValidationProvider_source = new WeakMap(), _ValidationProvider_instances = new WeakSet(), _ValidationProvider_awaitGetDocument = async function _ValidationProvider_awaitGetDocument(ref, asyncResult) {
     const result = await asyncResult;
-    return result ? validateData(ref, result) : undefined;
+    return validateResult(ref, result);
 }, _ValidationProvider_awaitGetDocuments = async function _ValidationProvider_awaitGetDocuments(ref, asyncResult) {
     return validateResults(ref, await asyncResult);
 };
-function validateData(ref, data, partial) {
+/** Validate a set of data for a path. */
+function validateData(ref, data) {
+    return ref.schema.validate(data);
+}
+/** Validate a set of transforms for a path. */
+function validateTransforms(ref, unsafeTransforms) {
+    if (!isObject(unsafeTransforms))
+        throw new InvalidFeedback("Must be object", { value: unsafeTransforms });
+    const schema = ref.schema;
+    let changed = false;
+    let invalid = false;
+    const safeTransforms = {};
+    const details = {};
+    const validators = Object.entries(schema.props);
+    for (const [key, validator] of validators) {
+        const unsafeTransform = unsafeTransforms[key];
+        if (unsafeTransform === undefined) {
+            continue; // Skip undefined.
+        }
+        else if (isTransform(unsafeTransform)) {
+            safeTransforms[key] = unsafeTransform;
+        }
+        else {
+            try {
+                const safeTransform = validator.validate(unsafeTransform);
+                if (safeTransform !== unsafeTransform)
+                    changed = true;
+                safeTransforms[key] = safeTransform;
+            }
+            catch (feedback) {
+                invalid = true;
+                details[key] = feedback;
+            }
+        }
+    }
+    if (Object.keys(unsafeTransforms).length > validators.length)
+        changed = true;
+    if (invalid)
+        throw new InvalidFeedback("Invalid transforms", details);
+    return changed ? safeTransforms : unsafeTransforms;
+}
+/** Validate a result for a path. */
+function validateResult(ref, result) {
+    if (!result)
+        return undefined;
+    const schema = ref.schema;
     try {
-        const schema = ref.db.schemas[ref.collection];
-        return schema && schema instanceof ObjectSchema ? schema.validate(data, partial) : data;
+        schema.validate(result);
     }
-    catch (thrown) {
-        if (isFeedback(thrown))
-            throw new ValidationError(`Invalid ${partial ? "partial data" : "data"} for: "${ref.path}"`, thrown);
-        else
-            throw thrown;
+    catch (err) {
+        throw isFeedback(err) ? new ReferenceValidationError(ref, err) : err;
     }
 }
-/** Validate a set of documents at this path. */
+/** Validate a set of results for a path. */
 function validateResults(ref, results) {
+    const schema = ref.schema;
     const validated = {};
     const invalids = {};
     let invalid = false;
     for (const [id, data] of Object.entries(results)) {
         try {
-            const schema = ref.db.schemas[ref.collection];
-            validated[id] = schema && schema instanceof Schema ? schema.validate(data) : data;
+            validated[id] = schema.validate(data);
         }
         catch (thrown) {
-            if (isFeedback(thrown))
+            if (isFeedback(thrown)) {
                 invalids[id] = thrown;
+                invalid = true;
+            }
             else
                 throw thrown;
-            invalid = true;
         }
     }
     if (invalid)
-        throw new ValidationError(`Invalid documents for "${ref.path}"`, new InvalidFeedback("Invalid documents", invalids));
+        throw new ReferenceValidationError(ref, new InvalidFeedback("Invalid documents", invalids));
     return validated;
 }