shelving 1.52.0 → 1.53.0

package/db/errors.d.ts

@@ -7,18 +7,6 @@ export declare class DocumentRequiredError<T extends Data> extends RequiredError
     ref: DatabaseDocument<T>;
     constructor(ref: DatabaseDocument<T>);
 }
-/** Thrown if an error occurs while reading a document. */
-export declare class DocumentReadError<T extends Data> extends Error {
-    error: Error;
-    ref: DatabaseDocument<T>;
-    constructor(error: Error, ref: DatabaseDocument<T>);
-}
-/** Thrown if an error occurs while writing a document. */
-export declare class DocumentWriteError<T extends Data> extends Error {
-    error: Error;
-    ref: DatabaseDocument<T>;
-    constructor(error: Error, ref: DatabaseDocument<T>);
-}
 /** Thrown if a document can't validate. */
 export declare class DocumentValidationError<T extends Data> extends ValidationError {
     ref: DatabaseDocument<T>;
@@ -29,18 +17,6 @@ export declare class QueryRequiredError<T extends Data> extends RequiredError {
     ref: DatabaseQuery<T>;
     constructor(ref: DatabaseQuery<T>);
 }
-/** Thrown if an error occurs while reading a query. */
-export declare class QueryReadError<T extends Data> extends Error {
-    error: Error;
-    ref: DatabaseQuery<T>;
-    constructor(error: Error, ref: DatabaseQuery<T>);
-}
-/** Thrown if an error occurs while writing a query. */
-export declare class QueryWriteError<T extends Data> extends Error {
-    error: Error;
-    ref: DatabaseQuery<T>;
-    constructor(error: Error, ref: DatabaseQuery<T>);
-}
 /** Thrown if a query can't validate a set of results. */
 export declare class QueryValidationError<T extends Data> extends ValidationError {
     ref: DatabaseQuery<T>;

package/db/errors.js

@@ -7,24 +7,6 @@ export class DocumentRequiredError extends RequiredError {
     }
 }
 DocumentRequiredError.prototype.name = "DocumentRequiredError";
-/** Thrown if an error occurs while reading a document. */
-export class DocumentReadError extends Error {
-    constructor(error, ref) {
-        super(`Error reading document ${ref.toString()}:\n${error.message}`);
-        this.error = error;
-        this.ref = ref;
-    }
-}
-DocumentReadError.prototype.name = "DocumentReadError";
-/** Thrown if an error occurs while writing a document. */
-export class DocumentWriteError extends Error {
-    constructor(error, ref) {
-        super(`Error writing document ${ref.toString()}:\n${error.message}`);
-        this.error = error;
-        this.ref = ref;
-    }
-}
-DocumentWriteError.prototype.name = "DocumentWriteError";
 /** Thrown if a document can't validate. */
 export class DocumentValidationError extends ValidationError {
     constructor(ref, feedback) {
@@ -41,24 +23,6 @@ export class QueryRequiredError extends RequiredError {
     }
 }
 QueryRequiredError.prototype.name = "QueryRequiredError";
-/** Thrown if an error occurs while reading a query. */
-export class QueryReadError extends Error {
-    constructor(error, ref) {
-        super(`Error reading query ${ref.toString()}:\n${error.message}`);
-        this.error = error;
-        this.ref = ref;
-    }
-}
-QueryReadError.prototype.name = "QueryReadError";
-/** Thrown if an error occurs while writing a query. */
-export class QueryWriteError extends Error {
-    constructor(error, ref) {
-        super(`Error writing query ${ref.toString()}:\n${error.message}`);
-        this.error = error;
-        this.ref = ref;
-    }
-}
-DocumentWriteError.prototype.name = "DocumentWriteError";
 /** Thrown if a query can't validate a set of results. */
 export class QueryValidationError extends ValidationError {
     constructor(ref, feedback) {

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.52.0",
+	"version": "1.53.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/ErrorProvider.d.ts

@@ -0,0 +1,32 @@
+import { DatabaseDocument, DatabaseQuery } from "../db/Database.js";
+import { Update } from "../update/Update.js";
+import { Data, Result } from "../util/data.js";
+import { Entries } from "../util/entry.js";
+import { Observer, Unsubscriber } from "../util/observable.js";
+import { ThroughProvider } from "./ThroughProvider.js";
+/** Provider that wraps errors thrown from deeper providers in `DatabaseReadError` and `DatabaseWriteError` etc to make it easier to see what read/write caused the error. */
+export declare class ErrorProvider extends ThroughProvider {
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T> | PromiseLike<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): string | PromiseLike<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): void | PromiseLike<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): void | PromiseLike<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): number | PromiseLike<number>;
+}
+/** Thrown if an error occurs while reading a query. */
+export declare class DatabaseReadError<T extends Data> extends Error {
+    readonly error: Error;
+    readonly ref: DatabaseDocument<T> | DatabaseQuery<T>;
+    constructor(error: Error, ref: DatabaseDocument<T> | DatabaseQuery<T>);
+}
+/** Thrown if an error occurs while writing a document. */
+export declare class DatabaseWriteError<T extends Data> extends Error {
+    readonly error: Error;
+    readonly ref: DatabaseDocument<T> | DatabaseQuery<T>;
+    constructor(error: Error, ref: DatabaseDocument<T> | DatabaseQuery<T>);
+}

package/provider/ErrorProvider.js

@@ -0,0 +1,175 @@
+import { isAsync } from "../index.js";
+import { ThroughObserver } from "../util/observable.js";
+import { ThroughProvider } from "./ThroughProvider.js";
+/** Provider that wraps errors thrown from deeper providers in `DatabaseReadError` and `DatabaseWriteError` etc to make it easier to see what read/write caused the error. */
+export class ErrorProvider extends ThroughProvider {
+    get(ref) {
+        try {
+            const result = super.get(ref);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseReadError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseReadError(err, ref);
+            throw err;
+        }
+    }
+    subscribe(ref, observer) {
+        return super.subscribe(ref, new DatabaseErrorObserver(ref, observer));
+    }
+    add(ref, data) {
+        try {
+            const result = super.add(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    set(ref, data) {
+        try {
+            const result = super.set(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    update(ref, updates) {
+        try {
+            const result = super.update(ref, updates);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    delete(ref) {
+        try {
+            const result = super.delete(ref);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    getQuery(ref) {
+        try {
+            const results = super.getQuery(ref);
+            return isAsync(results)
+                ? results.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseReadError(err, ref) : err;
+                })
+                : results;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseReadError(err, ref);
+            throw err;
+        }
+    }
+    subscribeQuery(ref, observer) {
+        return super.subscribeQuery(ref, new DatabaseErrorObserver(ref, observer));
+    }
+    setQuery(ref, data) {
+        try {
+            const result = super.setQuery(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    updateQuery(ref, updates) {
+        try {
+            const result = super.updateQuery(ref, updates);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    deleteQuery(ref) {
+        try {
+            const result = super.deleteQuery(ref);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+}
+/** Thrown if an error occurs while reading a query. */
+export class DatabaseReadError extends Error {
+    constructor(error, ref) {
+        super(`Error reading ${ref.toString()}:\n${error.message}`);
+        this.error = error;
+        this.ref = ref;
+    }
+}
+DatabaseReadError.prototype.name = "DatabaseReadError";
+/** Thrown if an error occurs while writing a document. */
+export class DatabaseWriteError extends Error {
+    constructor(error, ref) {
+        super(`Error writing ${ref.toString()}:\n${error.message}`);
+        this.error = error;
+        this.ref = ref;
+    }
+}
+DatabaseWriteError.prototype.name = "DocumentWriteError";
+/** Observer that wraps errors in subscriptions in `DatabaseReadError` */
+class DatabaseErrorObserver extends ThroughObserver {
+    constructor(ref, target) {
+        super(target);
+        this.ref = ref;
+    }
+    error(error) {
+        super.error(error instanceof Error ? new DatabaseReadError(error, this.ref) : error);
+    }
+}

package/provider/Provider.d.ts

@@ -40,7 +40,7 @@ export declare abstract class Provider {
      *
      * @throws Error If a `Update` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract set<T extends Data>(ref: DatabaseDocument<T>, value: T): void | PromiseLike<void>;
+    abstract set<T extends Data>(ref: DatabaseDocument<T>, data: T): void | PromiseLike<void>;
     /**
      * Update the data an existing document.
      *

package/provider/index.d.ts

@@ -4,3 +4,4 @@ export * from "./BatchProvider.js";
 export * from "./MemoryProvider.js";
 export * from "./ValidationProvider.js";
 export * from "./CacheProvider.js";
+export * from "./ErrorProvider.js";

package/provider/index.js

@@ -4,3 +4,4 @@ export * from "./BatchProvider.js";
 export * from "./MemoryProvider.js";
 export * from "./ValidationProvider.js";
 export * from "./CacheProvider.js";
+export * from "./ErrorProvider.js";