shelving 1.135.0 → 1.136.0

package/api/Resource.d.ts

@@ -2,7 +2,7 @@ import type { Validator } from "../util/validate.js";
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions..
  *
- * @param name The name of the resource.
+ * @param name The name of the resource, e.g. `getUser`.
  * @param payload The `Validator` the resource's payload must conform to (defaults to `undefined` if not specified).
  * @param returns The `Validator` the resource's returned value must conform to (defaults to `undefined` if not specified).
  */
@@ -27,7 +27,7 @@ export declare class Resource<P = undefined, R = void> implements Validator<R> {
      * Validate a result for this resource.
      *
      * @returns The validated result for this resource.
-     * @throws ValidationError if the result could not be validated.
+     * @throws ValueError if the result could not be validated.
      */
     validate(unsafeResult: unknown): R;
 }

package/api/Resource.js

@@ -1,10 +1,10 @@
-import { ValidationError } from "../error/ValidationError.js";
+import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { UNDEFINED } from "../util/validate.js";
 /**
  * An abstract API resource definition, used to specify types for e.g. serverless functions..
  *
- * @param name The name of the resource.
+ * @param name The name of the resource, e.g. `getUser`.
  * @param payload The `Validator` the resource's payload must conform to (defaults to `undefined` if not specified).
  * @param returns The `Validator` the resource's returned value must conform to (defaults to `undefined` if not specified).
  */
@@ -33,7 +33,7 @@ export class Resource {
      * Validate a result for this resource.
      *
      * @returns The validated result for this resource.
-     * @throws ValidationError if the result could not be validated.
+     * @throws ValueError if the result could not be validated.
      */
     validate(unsafeResult) {
         try {
@@ -41,7 +41,7 @@ export class Resource {
         }
         catch (thrown) {
             if (thrown instanceof Feedback)
-                throw new ValidationError("Invalid result for resource", thrown);
+                throw new ValueError(`Invalid result for resource "${this.name}"`, { received: unsafeResult, caller: this.validate });
             throw thrown;
         }
     }

package/db/ItemStore.js

@@ -1,6 +1,7 @@
-import { NotFoundError } from "../error/NotFoundError.js";
+import { RequiredError } from "../error/RequiredError.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { OptionalDataStore } from "../store/DataStore.js";
+import { getGetter } from "../util/class.js";
 import { NONE } from "../util/constants.js";
 import { getItem } from "../util/item.js";
 import { runSequence } from "../util/sequence.js";
@@ -14,7 +15,13 @@ export class ItemStore extends OptionalDataStore {
     get data() {
         const item = this.value;
         if (!item)
-            throw new NotFoundError(`Item must exist in "${this.collection}"`, this.id);
+            throw new RequiredError(`Item does not exist in collection "${this.collection}"`, {
+                store: this,
+                provider: this.provider,
+                collection: this.collection,
+                id: this.id,
+                caller: getGetter(this, "data"),
+            });
         return item;
     }
     /** Set the data of this store. */

package/db/Provider.js

@@ -1,23 +1,34 @@
-import { NotFoundError } from "../error/NotFoundError.js";
-import { countArray, getOptionalFirstItem } from "../util/array.js";
+import { RequiredError } from "../error/RequiredError.js";
+import { countArray } from "../util/array.js";
+import { getFirstItem } from "../util/iterate.js";
 /** Provider with a fully synchronous interface */
 export class Provider {
     requireItem(collection, id) {
         const item = this.getItem(collection, id);
         if (!item)
-            throw new NotFoundError(`Item must exist in "${collection}"`, id);
+            throw new RequiredError(`Item does not exist in collection "${collection}"`, {
+                provider: this,
+                collection,
+                id,
+                caller: this.getItem,
+            });
         return item;
     }
     countQuery(collection, query) {
         return countArray(this.getQuery(collection, query));
     }
     getFirst(collection, query) {
-        return getOptionalFirstItem(this.getQuery(collection, { ...query, $limit: 1 }));
+        return getFirstItem(this.getQuery(collection, { ...query, $limit: 1 }));
     }
     requireFirst(collection, query) {
         const first = this.getFirst(collection, query);
         if (!first)
-            throw new NotFoundError(`First item must exist in "${collection}"`, query);
+            throw new RequiredError(`First item does not exist in collection "${collection}"`, {
+                provider: this,
+                collection,
+                query,
+                caller: this.requireFirst,
+            });
         return first;
     }
 }
@@ -26,19 +37,29 @@ export class AsyncProvider {
     async requireItem(collection, id) {
         const item = await this.getItem(collection, id);
         if (!item)
-            throw new NotFoundError(`Item must exist in "${collection}"`, id);
+            throw new RequiredError(`Item does not exist in collection "${collection}"`, {
+                provider: this,
+                collection,
+                id,
+                caller: this.requireItem,
+            });
         return item;
     }
     async countQuery(collection, query) {
         return countArray(await this.getQuery(collection, query));
     }
     async getFirst(collection, query) {
-        return getOptionalFirstItem(await this.getQuery(collection, { ...query, $limit: 1 }));
+        return getFirstItem(await this.getQuery(collection, { ...query, $limit: 1 }));
     }
     async requireFirst(collection, query) {
         const first = await this.getFirst(collection, query);
         if (!first)
-            throw new NotFoundError(`First item must exist in "${collection}"`, query);
+            throw new RequiredError(`First item does not exist in collection "${collection}"`, {
+                provider: this,
+                collection,
+                query,
+                caller: this.requireFirst,
+            });
         return first;
     }
 }

package/db/QueryStore.js

@@ -1,7 +1,7 @@
-import { collection, query } from "firebase/firestore";
-import { NotFoundError } from "../error/NotFoundError.js";
+import { RequiredError } from "../error/RequiredError.js";
 import { ArrayStore } from "../store/ArrayStore.js";
 import { BooleanStore } from "../store/BooleanStore.js";
+import { getGetter } from "../util/class.js";
 import { NONE } from "../util/constants.js";
 import { getAfterQuery, getLimit } from "../util/query.js";
 import { runSequence } from "../util/sequence.js";
@@ -21,14 +21,26 @@ export class QueryStore extends ArrayStore {
     get first() {
         const first = this.optionalFirst;
         if (!first)
-            throw new NotFoundError(`First item must exist in "${collection}"`, query);
+            throw new RequiredError(`First item does not exist in collection "${this.collection}"`, {
+                store: this,
+                provider: this.provider,
+                collection: this.collection,
+                query: this.query,
+                caller: getGetter(this, "first"),
+            });
         return first;
     }
     /** Get the last item in this store. */
     get last() {
         const last = this.optionalLast;
         if (!last)
-            throw new NotFoundError(`Last item must exist in "${collection}"`, query);
+            throw new RequiredError(`Last item does not exist in collection "${this.collection}"`, {
+                store: this,
+                provider: this.provider,
+                collection: this.collection,
+                query: this.query,
+                caller: getGetter(this, "first"),
+            });
         return last;
     }
     constructor(collection, query, provider, memory) {

package/db/ValidationProvider.js

@@ -1,4 +1,4 @@
-import { ValidationError as ConflictError } from "../error/ValidationError.js";
+import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { KEY } from "../schema/KeySchema.js";
 import { updateData } from "../util/update.js";
@@ -16,12 +16,12 @@ export class ValidationProvider extends ThroughProvider {
         return this.schemas[collection];
     }
     getItem(collection, id) {
-        return _validateItem(collection, super.getItem(collection, id), this.getSchema(collection));
+        return _validateItem(collection, super.getItem(collection, id), this.getSchema(collection), this.getItem);
     }
     async *getItemSequence(collection, id) {
         const schema = this.getSchema(collection);
-        for await (const unsafeItem of super.getItemSequence(collection, id))
-            yield _validateItem(collection, unsafeItem, schema);
+        for await (const item of super.getItemSequence(collection, id))
+            yield _validateItem(collection, item, schema, this.getItemSequence);
     }
     addItem(collection, data) {
         return super.addItem(collection, validateData(data, this.getSchema(collection).props));
@@ -40,7 +40,7 @@ export class ValidationProvider extends ThroughProvider {
         return super.countQuery(collection, query);
     }
     getQuery(collection, query) {
-        return _validateItems(collection, super.getQuery(collection, query), this.getSchema(collection));
+        return _validateItems(collection, super.getQuery(collection, query), this.getSchema(collection), this.getQuery);
     }
     setQuery(collection, query, data) {
         super.setQuery(collection, query, this.getSchema(collection).validate(data));
@@ -54,8 +54,8 @@ export class ValidationProvider extends ThroughProvider {
     }
     async *getQuerySequence(collection, query) {
         const schema = this.getSchema(collection);
-        for await (const unsafeItems of super.getQuerySequence(collection, query))
-            yield _validateItems(collection, unsafeItems, schema);
+        for await (const items of super.getQuerySequence(collection, query))
+            yield _validateItems(collection, items, schema, this.getQuerySequence);
     }
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
@@ -70,12 +70,12 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         return this.schemas[collection];
     }
     async getItem(collection, id) {
-        return _validateItem(collection, await super.getItem(collection, id), this.getSchema(collection));
+        return _validateItem(collection, await super.getItem(collection, id), this.getSchema(collection), this.getItem);
     }
     async *getItemSequence(collection, id) {
         const schema = this.getSchema(collection);
-        for await (const unsafeItem of super.getItemSequence(collection, id))
-            yield _validateItem(collection, unsafeItem, schema);
+        for await (const item of super.getItemSequence(collection, id))
+            yield _validateItem(collection, item, schema, this.getItemSequence);
     }
     addItem(collection, data) {
         return super.addItem(collection, validateData(data, this.getSchema(collection).props));
@@ -94,12 +94,12 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         return super.countQuery(collection, query);
     }
     async getQuery(collection, query) {
-        return _validateItems(collection, await super.getQuery(collection, query), this.getSchema(collection));
+        return _validateItems(collection, await super.getQuery(collection, query), this.getSchema(collection), this.getQuery);
     }
     async *getQuerySequence(collection, query) {
         const schema = this.getSchema(collection);
-        for await (const unsafeItems of super.getQuerySequence(collection, query))
-            yield _validateItems(collection, unsafeItems, schema);
+        for await (const items of super.getQuerySequence(collection, query))
+            yield _validateItems(collection, items, schema, this.getQuerySequence);
     }
     setQuery(collection, query, data) {
         return super.setQuery(collection, query, validateData(data, this.getSchema(collection).props));
@@ -112,39 +112,39 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         return super.deleteQuery(collection, query);
     }
 }
-function _validateItem(collection, unsafeItem, schema) {
-    if (!unsafeItem)
+function _validateItem(collection, item, schema, caller) {
+    if (!item)
         return undefined;
     try {
-        return validateData(unsafeItem, { id: KEY, ...schema.props });
+        return validateData(item, { id: KEY, ...schema.props });
     }
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ConflictError(`Invalid data for "${collection}"`, thrown.message);
+        throw new ValueError(`Invalid data for "${collection}"`, { collection, item, cause: thrown, caller });
     }
 }
 /**
  * Validate a set of entities for this query reference.
- * @throws `ConflictError` if one or more items did not validate (conflict because the program is not in an expected state).
+ * @throws `ValueError` if one or more items did not validate (conflict because the program is not in an expected state).
  */
-function _validateItems(collection, unsafeEntities, schema) {
-    return Array.from(_yieldValidItems(collection, unsafeEntities, { id: KEY, ...schema.props }));
+function _validateItems(collection, items, schema, caller) {
+    return Array.from(_yieldValidItems(collection, items, { id: KEY, ...schema.props }, caller));
 }
-function* _yieldValidItems(collection, unsafeEntities, validators) {
+function* _yieldValidItems(collection, items, validators, caller) {
     let invalid = false;
-    const messages = {};
-    for (const unsafeItem of unsafeEntities) {
+    const feedbacks = {};
+    for (const item of items) {
         try {
-            yield validateData(unsafeItem, validators);
+            yield validateData(item, validators);
         }
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
             invalid = true;
-            messages[unsafeItem.id] = thrown.message;
+            feedbacks[item.id] = thrown;
         }
     }
     if (invalid)
-        throw new ConflictError(`Invalid data for "${collection}"`, messages);
+        throw new ValueError(`Invalid data for "${collection}"`, { collection, items, cause: feedbacks, caller });
 }

package/error/AssertionError.d.ts

@@ -0,0 +1,8 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/**
+ * Thrown when a value is we're asserting something to be true, but it isn't.
+ * - Usually thrown from `assertX()` functions, e.g. `assertString()` and `assertNumber()`
+ */
+export declare class AssertionError extends BaseError {
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/AssertionError.js

@@ -0,0 +1,12 @@
+import { BaseError } from "./BaseError.js";
+/**
+ * Thrown when a value is we're asserting something to be true, but it isn't.
+ * - Usually thrown from `assertX()` functions, e.g. `assertString()` and `assertNumber()`
+ */
+export class AssertionError extends BaseError {
+    constructor(message, options) {
+        super(message, { caller: AssertionError, ...options });
+    }
+}
+AssertionError.prototype.name = "AssertionError";
+AssertionError.prototype.message = "Assertion failed";

package/error/BaseError.d.ts

@@ -0,0 +1,19 @@
+import type { AnyConstructor } from "../util/class.js";
+import type { AnyFunction } from "../util/function.js";
+/** Options for `BaseError` that provide additional helpful error functionality. */
+export interface BaseErrorOptions extends ErrorOptions {
+    /**
+     * Provide additional named contextual data that should be attached to the `Error` instance.
+     * - The fields `cause:` and `caller:` are ignored.
+     * - `received` and `expected` are recommended for values.
+     */
+    [key: string]: unknown;
+    /** Modify the stack to trim off lines after a certain calling function. */
+    caller?: AnyFunction | AnyConstructor | undefined;
+}
+/** An error that provides additional helpful functionality. */
+export declare abstract class BaseError extends Error {
+    /** Provide additional named contextual data that should be attached to the `Error` instance. */
+    [key: string]: unknown;
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/BaseError.js

@@ -0,0 +1,18 @@
+/** An error that provides additional helpful functionality. */
+export class BaseError extends Error {
+    constructor(message, options) {
+        if (options) {
+            super(message, options);
+            const { cause, caller = BaseError, ...rest } = options;
+            for (const [key, value] of Object.entries(rest))
+                this[key] = value;
+            Error.captureStackTrace(this, caller);
+        }
+        else {
+            super(message);
+            Error.captureStackTrace(this, BaseError);
+        }
+    }
+}
+BaseError.prototype.name = "BaseError";
+BaseError.prototype.message = "Unknown error";

package/error/NetworkError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/** Thrown in the event of network issues e.g. the user's internet connection is down, or the server is down. */
+export declare class NetworkError extends BaseError {
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/NetworkError.js

@@ -0,0 +1,9 @@
+import { BaseError } from "./BaseError.js";
+/** Thrown in the event of network issues e.g. the user's internet connection is down, or the server is down. */
+export class NetworkError extends BaseError {
+    constructor(message, options) {
+        super(message, { caller: NetworkError, ...options });
+    }
+}
+NetworkError.prototype.name = "NetworkError";
+NetworkError.prototype.message = "Network error";

package/error/RequestError.d.ts

@@ -0,0 +1,32 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/** Options for a `RequestError` */
+interface RequestErrorOptions extends BaseErrorOptions {
+    code?: number;
+}
+/** Error thrown when a request isn't well-formed. */
+export declare class RequestError extends BaseError {
+    /** The corresponding HTTP status code for this error, in the range `400-499` */
+    code: number;
+    constructor(message?: string, options?: RequestErrorOptions);
+}
+/** Thrown if an operation failed because the user is not logged in, or the login information is not well-formed. */
+export declare class UnauthorizedError extends RequestError {
+    readonly code: number;
+    constructor(message?: string, options?: RequestErrorOptions);
+}
+/** Thrown if the requested content is not found. */
+export declare class NotFoundError extends RequestError {
+    readonly code = 404;
+    constructor(message?: string, options?: RequestErrorOptions);
+}
+/** Error thrown when a request is is valid and well-formed, but its actual data is not. */
+export declare class UnprocessableError extends RequestError {
+    readonly code: number;
+    constructor(message?: string, options?: RequestErrorOptions);
+}
+/** Thrown if an operation failed because the user is logged in, but does not have sufficient privileges to access this content. */
+export declare class ForbiddenError extends RequestError {
+    readonly code: number;
+    constructor(message?: string, options?: RequestErrorOptions);
+}
+export {};

package/error/RequestError.js

@@ -0,0 +1,50 @@
+import { BaseError } from "./BaseError.js";
+/** Error thrown when a request isn't well-formed. */
+export class RequestError extends BaseError {
+    /** The corresponding HTTP status code for this error, in the range `400-499` */
+    code;
+    constructor(message = RequestError.prototype.message, options) {
+        super(message, { caller: RequestError, ...options });
+        this.code = options?.code || 400;
+    }
+}
+RequestError.prototype.name = "RequestError";
+RequestError.prototype.message = "Invalid request";
+/** Thrown if an operation failed because the user is not logged in, or the login information is not well-formed. */
+export class UnauthorizedError extends RequestError {
+    code = 401;
+    constructor(message = UnauthorizedError.prototype.message, options) {
+        super(message, { caller: UnauthorizedError, code: 401, ...options });
+    }
+}
+UnauthorizedError.prototype.name = "UnauthorizedError";
+UnauthorizedError.prototype.message = "Authorization is required";
+/** Thrown if the requested content is not found. */
+export class NotFoundError extends RequestError {
+    code = 404;
+    constructor(message = NotFoundError.prototype.message, options) {
+        super(message, { caller: NotFoundError, code: 404, ...options });
+        Error.captureStackTrace(this, NotFoundError);
+    }
+}
+NotFoundError.prototype.name = "NotFoundError";
+NotFoundError.prototype.message = "Cannot find requested content";
+/** Error thrown when a request is is valid and well-formed, but its actual data is not. */
+export class UnprocessableError extends RequestError {
+    code = 422;
+    constructor(message = UnprocessableError.prototype.message, options) {
+        super(message, { caller: UnprocessableError, code: 422, ...options });
+        Error.captureStackTrace(this, UnprocessableError);
+    }
+}
+UnprocessableError.prototype.name = "UnprocessableError";
+UnprocessableError.prototype.message = "Input data is invalid";
+/** Thrown if an operation failed because the user is logged in, but does not have sufficient privileges to access this content. */
+export class ForbiddenError extends RequestError {
+    code = 403;
+    constructor(message = ForbiddenError.prototype.message, options) {
+        super(message, { caller: ForbiddenError, code: 403, ...options });
+    }
+}
+ForbiddenError.prototype.name = "ForbiddenError";
+ForbiddenError.prototype.message = "Insufficient privileges to access this content";

package/error/RequiredError.d.ts

@@ -0,0 +1,8 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/**
+ * Thrown when something is required but not supplied.
+ * - Usually thrown from `requireX()` functions, e.g. `requireString()` and `requireNumber()`
+ */
+export declare class RequiredError extends BaseError {
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/RequiredError.js

@@ -0,0 +1,12 @@
+import { BaseError } from "./BaseError.js";
+/**
+ * Thrown when something is required but not supplied.
+ * - Usually thrown from `requireX()` functions, e.g. `requireString()` and `requireNumber()`
+ */
+export class RequiredError extends BaseError {
+    constructor(message, options) {
+        super(message, { caller: RequiredError, ...options });
+    }
+}
+RequiredError.prototype.name = "RequiredError";
+RequiredError.prototype.message = "Value is required";

package/error/UnexpectedError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/** Thrown when something is wrong or unexpected. */
+export declare class UnexpectedError extends BaseError {
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/UnexpectedError.js

@@ -0,0 +1,9 @@
+import { BaseError } from "./BaseError.js";
+/** Thrown when something is wrong or unexpected. */
+export class UnexpectedError extends BaseError {
+    constructor(message, options) {
+        super(message, { caller: UnexpectedError, ...options });
+    }
+}
+UnexpectedError.prototype.name = "UnexpectedError";
+UnexpectedError.prototype.message = "Unexpected error";

package/error/UnimplementedError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/** Error thrown when functionality is called but is not implemented by an interface. */
+export declare class UnimplementedError extends BaseError {
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/UnimplementedError.js

@@ -0,0 +1,9 @@
+import { BaseError } from "./BaseError.js";
+/** Error thrown when functionality is called but is not implemented by an interface. */
+export class UnimplementedError extends BaseError {
+    constructor(message, options) {
+        super(message, { caller: UnimplementedError, ...options });
+    }
+}
+UnimplementedError.prototype.name = "UnimplementedError";
+UnimplementedError.prototype.message = "Not implemented";

package/error/ValueError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError, type BaseErrorOptions } from "./BaseError.js";
+/** Thrown when a value is wrong or unexpected. */
+export declare class ValueError extends BaseError {
+    constructor(message?: string, options?: BaseErrorOptions);
+}

package/error/ValueError.js

@@ -0,0 +1,9 @@
+import { BaseError } from "./BaseError.js";
+/** Thrown when a value is wrong or unexpected. */
+export class ValueError extends BaseError {
+    constructor(message, options) {
+        super(message, { caller: ValueError, ...options });
+    }
+}
+ValueError.prototype.name = "ValueError";
+ValueError.prototype.message = "Invalid value";

package/error/index.d.ts

@@ -1,8 +1,8 @@
-export * from "./CodedError.js";
-export * from "./ConflictError.js";
-export * from "./ConnectionError.js";
-export * from "./ForbiddenError.js";
-export * from "./UnauthorizedError.js";
-export * from "./NotFoundError.js";
-export * from "./NotImplementedError.js";
-export * from "./ValidationError.js";
+export * from "./BaseError.js";
+export * from "./AssertionError.js";
+export * from "./NetworkError.js";
+export * from "./RequestError.js";
+export * from "./RequiredError.js";
+export * from "./UnexpectedError.js";
+export * from "./UnimplementedError.js";
+export * from "./ValueError.js";

package/error/index.js

@@ -1,8 +1,8 @@
-export * from "./CodedError.js";
-export * from "./ConflictError.js";
-export * from "./ConnectionError.js";
-export * from "./ForbiddenError.js";
-export * from "./UnauthorizedError.js";
-export * from "./NotFoundError.js";
-export * from "./NotImplementedError.js";
-export * from "./ValidationError.js";
+export * from "./BaseError.js";
+export * from "./AssertionError.js";
+export * from "./NetworkError.js";
+export * from "./RequestError.js";
+export * from "./RequiredError.js";
+export * from "./UnexpectedError.js";
+export * from "./UnimplementedError.js";
+export * from "./ValueError.js";

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +1,6 @@
 import { addDoc, arrayRemove, arrayUnion, collection, deleteDoc, doc, documentId, getCount, getDoc, getDocs, increment, limit, orderBy, query, setDoc, updateDoc, where, } from "firebase/firestore/lite";
 import { AsyncProvider } from "../../db/Provider.js";
-import { NotImplementedError } from "../../error/NotImplementedError.js";
+import { UnimplementedError } from "../../error/UnimplementedError.js";
 import { getItem } from "../../util/item.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
@@ -76,7 +76,7 @@ export class FirestoreLiteProvider extends AsyncProvider {
         return _getOptionalItem(snapshot);
     }
     getItemSequence() {
-        throw new NotImplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async addItem(c, data) {
         const reference = await addDoc(collection(this._firestore, c), data);
@@ -100,7 +100,7 @@ export class FirestoreLiteProvider extends AsyncProvider {
         return snapshot.docs.map(_getItem);
     }
     getQuerySequence() {
-        throw new NotImplementedError("FirestoreLiteProvider does not support realtime subscriptions");
+        throw new UnimplementedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(c, q, data) {
         const snapshot = await getDocs(_getQuery(this._firestore, c, q));