shelving 1.66.0 → 1.67.0

package/db/Database.d.ts

@@ -1,9 +1,7 @@
 import type { Validators, ValidatorType } from "../util/validate.js";
-import type { Key, Datas } from "../util/data.js";
+import type { Key, Datas, Entity } from "../util/data.js";
 import type { Provider } from "../provider/Provider.js";
-import type { SortKeys } from "../query/Sort.js";
-import type { FilterProps } from "../query/Filter.js";
-import { Entity } from "../util/data.js";
+import type { QueryProps } from "../query/Query.js";
 import { DocumentReference, QueryReference } from "./Reference.js";
 /**
  * Combines a database model and a provider.
@@ -17,7 +15,7 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     readonly provider: Provider;
     constructor(validators: V, provider: Provider);
     /** Create a query on a collection in this model. */
-    query<K extends Key<V>>(collection: K, filters?: FilterProps<Entity<ValidatorType<V[K]>>>, sorts?: SortKeys<Entity<ValidatorType<V[K]>>>, limit?: number | null): QueryReference<ValidatorType<V[K]>>;
+    query<K extends Key<V>>(collection: K, query?: QueryProps<Entity<ValidatorType<V[K]>>>): QueryReference<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DocumentReference<ValidatorType<V[K]>>;
     /**

package/db/Database.js

@@ -1,5 +1,3 @@
-import { Filters } from "../query/Filters.js";
-import { Sorts } from "../query/Sorts.js";
 import { DocumentReference, QueryReference } from "./Reference.js";
 /**
  * Combines a database model and a provider.
@@ -15,8 +13,9 @@ export class Database {
         this.provider = provider;
     }
     /** Create a query on a collection in this model. */
-    query(collection, filters, sorts, limit) {
-        return new QueryReference(this, this.validators[collection], collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
+    query(collection, query) {
+        const validator = this.validators[collection];
+        return new QueryReference(this, validator, collection, query);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {

package/db/Reference.d.ts

@@ -1,15 +1,11 @@
 import type { Data, OptionalData, Entity, OptionalEntity, Entities } from "../util/data.js";
 import type { Dispatch } from "../util/function.js";
-import type { SortKeys } from "../query/Sort.js";
 import { ImmutableArray } from "../util/array.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Validator } from "../util/validate.js";
-import { Query } from "../query/Query.js";
-import { Filters } from "../query/Filters.js";
-import { Sorts } from "../query/Sorts.js";
+import { Query, QueryProps } from "../query/Query.js";
 import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
-import { FilterProps } from "../query/Filter.js";
-import { Observable, Unsubscribe } from "../observe/Observable.js";
+import type { Observable, Unsubscribe } from "../observe/Observable.js";
 import type { Database } from "./Database.js";
 /** A refence to a location in a database. */
 export interface Reference {
@@ -21,7 +17,7 @@ export declare class QueryReference<T extends Data = Data> extends Query<Entity<
     readonly db: Database;
     readonly validator: Validator<T>;
     readonly collection: string;
-    constructor(db: Database, validator: Validator<T>, collection: string, filters?: Filters<Entity<T>>, sorts?: Sorts<Entity<T>>, limit?: number | null);
+    constructor(db: Database, validator: Validator<T>, collection: string, { sort, limit, ...filters }?: QueryProps<Entity<T>>);
     /** Reference a document in this query's collection. */
     doc(id: string): DocumentReference<T>;
     /**
@@ -104,7 +100,7 @@ export declare class DocumentReference<T extends Data = Data> implements Observa
     readonly id: string;
     constructor(db: Database, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: FilterProps<Entity<T>>, sorts?: SortKeys<Entity<T>>, limit?: number | null): QueryReference<T>;
+    query(query?: QueryProps<Entity<T>>): QueryReference<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional(): QueryReference<T>;
     /**

package/db/Reference.js

@@ -5,12 +5,11 @@ import { Sorts } from "../query/Sorts.js";
 import { callAsync } from "../util/async.js";
 import { countItems, hasItems } from "../util/iterate.js";
 import { DataUpdate } from "../update/DataUpdate.js";
-import { Filter } from "../query/Filter.js";
 import { RequiredError } from "../error/RequiredError.js";
 /** A query reference within a specific database. */
 export class QueryReference extends Query {
-    constructor(db, validator, collection, filters, sorts, limit) {
-        super(filters, sorts, limit);
+    constructor(db, validator, collection, { sort, limit, ...filters } = {}) {
+        super(Filters.on(filters), sort && Sorts.on(sort), limit);
         this.db = db;
         this.validator = validator;
         this.collection = collection;
@@ -127,12 +126,12 @@ export class DocumentReference {
         this.id = id;
     }
     /** Create a query on this document's collection. */
-    query(filters, sorts, limit) {
-        return new QueryReference(this.db, this.validator, this.collection, filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
+    query(query) {
+        return new QueryReference(this.db, this.validator, this.collection, query);
     }
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional() {
-        return new QueryReference(this.db, this.validator, this.collection, new Filters(new Filter("id", "IS", this.id)));
+        return new QueryReference(this.db, this.validator, this.collection, { id: this.id, limit: 1 });
     }
     /**
      * Does this document exist?

package/package.json

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

package/query/Filter.js

@@ -51,6 +51,26 @@ export class Filter extends Rule {
         return filterItems(items, this);
     }
     toString() {
-        return `${this.key}:${this.operator}:${JSON.stringify(this.value)}`;
+        return `"${_formatKey(this)}":${JSON.stringify(this.value)}`;
+    }
+}
+/** Convert a `Filter` */
+function _formatKey({ key, operator }) {
+    switch (operator) {
+        case "NOT":
+        case "OUT":
+            return `!${key}`;
+        case "CONTAINS":
+            return `${key}[]`;
+        case "LT":
+            return `${key}<`;
+        case "LTE":
+            return `${key}<=`;
+        case "GT":
+            return `${key}>`;
+        case "GTE":
+            return `${key}>=`;
+        default:
+            return key;
     }
 }

package/query/Query.d.ts

@@ -5,6 +5,11 @@ import { Sortable, Sorts } from "./Sorts.js";
 import { Rule } from "./Rule.js";
 import { FilterProps } from "./Filter.js";
 import { SortKey, SortKeys } from "./Sort.js";
+/** Set of props for a query defined as an object. */
+export declare type QueryProps<T extends Data> = FilterProps<T> & {
+    readonly sort?: SortKey<T> | ImmutableArray<SortKey<T>>;
+    readonly limit?: number | null;
+};
 /** Interface that combines Filterable, Sortable, Sliceable. */
 export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     /**
@@ -26,11 +31,13 @@ export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     readonly limit: number | null;
     /** Return a new instance of this class with a limit set. */
     max(max: number | null): this;
+    /** Return a new instance of this class with new filters, sorts, limits set. */
+    query(query: QueryProps<T>): this;
 }
 /** Allows filtering, sorting, and limiting on a set of results. */
 export declare class Query<T extends Data> extends Rule<T> implements Queryable<T> {
     /** Create a new `Query` object from a set of `QueryProps` */
-    static on<X extends Data>(filters?: FilterProps<X>, sorts?: SortKey<X> | ImmutableArray<SortKey<X>>, limit?: number | null): Query<X>;
+    static on<X extends Data>({ sort, limit, ...filters }: QueryProps<X>): Query<X>;
     readonly filters: Filters<T>;
     readonly sorts: Sorts<T>;
     readonly limit: number | null;
@@ -44,10 +51,10 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     sort(...keys: SortKeys<T>[]): this;
     get unsort(): this;
     rank(left: T, right: T): number;
-    /** Return a new instance of this class with a limit defined. */
-    max(limit: number | null): this;
     after(item: T): this;
     before(item: T): this;
+    max(limit: number | null): this;
+    query({ sort, limit, ...filters }: QueryProps<T>): this;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }

package/query/Query.js

@@ -17,32 +17,44 @@ export class Query extends Rule {
         this.limit = limit;
     }
     /** Create a new `Query` object from a set of `QueryProps` */
-    static on(filters, sorts, limit) {
-        return new Query(filters && Filters.on(filters), sorts && Sorts.on(sorts), limit);
+    static on({ sort, limit, ...filters }) {
+        return new Query(filters && Filters.on(filters), sort && Sorts.on(sort), limit);
     }
     filter(input, value) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: this.filters.filter(input, value) }; // eslint-disable-line @typescript-eslint/no-explicit-any
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: this.filters.filter(input, value), // eslint-disable-line @typescript-eslint/no-explicit-any
+        };
     }
     get unfilter() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: EMPTY_FILTERS };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: EMPTY_FILTERS,
+        };
     }
     match(item) {
         return this.filters.match(item);
     }
     // Implement `Sortable`
     sort(...keys) {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: this.sorts.sort(...keys) };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            sorts: this.sorts.sort(...keys),
+        };
     }
     get unsort() {
-        return { __proto__: Object.getPrototypeOf(this), ...this, sorts: EMPTY_SORTS };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            sorts: EMPTY_SORTS,
+        };
     }
     rank(left, right) {
         return this.sorts.rank(left, right);
     }
-    /** Return a new instance of this class with a limit defined. */
-    max(limit) {
-        return limit === this.limit ? this : { __proto__: Object.getPrototypeOf(this), ...this, limit };
-    }
     // Implement `Queryable`
     after(item) {
         const filters = [...this.filters];
@@ -52,7 +64,11 @@ export class Query extends Rule {
             const { key, direction } = sort;
             filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "GT" : "GTE") : sort === lastSort ? "LT" : "LTE", getProp(item, key)));
         }
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: new Filters(...filters),
+        };
     }
     before(item) {
         const filters = [...this.filters];
@@ -62,7 +78,27 @@ export class Query extends Rule {
             const { key, direction } = sort;
             filters.push(new Filter(key, direction === "ASC" ? (sort === lastSort ? "LT" : "LTE") : sort === lastSort ? "GT" : "GTE", getProp(item, key)));
         }
-        return { __proto__: Object.getPrototypeOf(this), ...this, filters: new Filters(...filters) };
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: new Filters(...filters),
+        };
+    }
+    max(limit) {
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            limit,
+        };
+    }
+    query({ sort, limit, ...filters }) {
+        return {
+            __proto__: Object.getPrototypeOf(this),
+            ...this,
+            filters: this.filters.filter(filters),
+            sorts: sort ? this.sorts.sort(sort) : this.sorts,
+            limit: limit !== undefined ? limit : this.limit,
+        };
     }
     // Implement `Rule`
     transform(items) {
@@ -71,6 +107,8 @@ export class Query extends Rule {
     }
     // Implement toString()
     toString() {
-        return `filters=${this.filters}&sorts=${this.sorts}${this.limit ? `&limit=${this.limit}` : ""}`;
+        const filters = this.filters.toString();
+        const sorts = this.sorts.toString();
+        return `{${filters}${sorts ? `${filters ? "," : ""}"sort":[${sorts}]` : ""}${typeof this.limit === "number" ? `${filters || sorts ? "," : ""}"limit":${this.limit}` : ""}}`;
     }
 }

package/query/Rules.js

@@ -18,8 +18,9 @@ export class Rules extends Rule {
     get size() {
         return this._rules.length;
     }
+    // Override to join the strings from the rules together with `,` commas.
     toString() {
-        return this._rules.map(toString).join(",");
+        return this._rules.map(String).join(",");
     }
     /** Clone this set of rules but add additional rules. */
     with(...rules) {

package/query/Sort.js

@@ -19,6 +19,6 @@ export class Sort extends Rule {
         return sortItems(items, this);
     }
     toString() {
-        return `${this.direction === "DESC" ? "!" : ""}${this.key}`;
+        return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
     }
 }