shelving 1.73.1 → 1.73.2

package/constraint/QueryConstraints.d.ts

@@ -4,12 +4,6 @@ import { Sortable, SortConstraints } from "./SortConstraints.js";
 import { Constraint } from "./Constraint.js";
 import { FilterList } from "./FilterConstraint.js";
 import { SortKeys, SortList } from "./SortConstraint.js";
-/** Set of props for a query defined as an object. */
-export declare type QueryProps<T extends Data> = {
-    readonly filter?: FilterList<T>;
-    readonly sort?: SortList<T>;
-    readonly limit?: number | null;
-};
 /** Interface that combines Filterable, Sortable, Sliceable. */
 export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     /**
@@ -31,15 +25,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 QueryConstraints<T extends Data = Data> extends Constraint<T> implements Queryable<T> {
     readonly filters: FilterConstraints<T>;
     readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor({ filter, sort, limit }?: QueryProps<T>);
+    constructor(filters?: FilterList<T>, sorts?: SortList<T>, limit?: number | null);
     filter(...filters: FilterList<T>[]): this;
     get unfilter(): this;
     match(item: T): boolean;
@@ -49,7 +41,6 @@ export declare class QueryConstraints<T extends Data = Data> extends Constraint<
     after(item: T): this;
     before(item: T): this;
     max(limit: number | null): this;
-    query({ sort, limit, filter }: QueryProps<T>): this;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }

package/constraint/QueryConstraints.js

@@ -8,13 +8,12 @@ import { FilterConstraint } from "./FilterConstraint.js";
 // Instances to save resources for the default case (empty query).
 const EMPTY_FILTERS = new FilterConstraints(); // eslint-disable-line @typescript-eslint/no-explicit-any
 const EMPTY_SORTS = new SortConstraints(); // eslint-disable-line @typescript-eslint/no-explicit-any
-const EMPTY_PROPS = { filter: EMPTY_FILTERS, sort: EMPTY_SORTS, limit: null }; // eslint-disable-line @typescript-eslint/no-explicit-any
 /** Allows filtering, sorting, and limiting on a set of results. */
 export class QueryConstraints extends Constraint {
-    constructor({ filter = EMPTY_FILTERS, sort = EMPTY_SORTS, limit = null } = EMPTY_PROPS) {
+    constructor(filters = EMPTY_FILTERS, sorts = EMPTY_SORTS, limit = null) {
         super();
-        this.filters = filter instanceof FilterConstraints ? filter : new FilterConstraints(filter);
-        this.sorts = sort instanceof SortConstraints ? sort : new SortConstraints(sort);
+        this.filters = filters instanceof FilterConstraints ? filters : new FilterConstraints(filters);
+        this.sorts = sorts instanceof SortConstraints ? sorts : new SortConstraints(sorts);
         this.limit = limit;
     }
     // Implement `Filterable`
@@ -81,15 +80,6 @@ export class QueryConstraints extends Constraint {
             limit,
         };
     }
-    query({ sort, limit, filter }) {
-        return {
-            __proto__: Object.getPrototypeOf(this),
-            ...this,
-            filters: filter ? this.filters.filter(filter) : this.filters,
-            sorts: sort ? this.sorts.sort(sort) : this.sorts,
-            limit: limit !== undefined ? limit : this.limit,
-        };
-    }
     // Implement `Rule`
     transform(items) {
         const sorted = this.sorts.transform(this.filters.transform(items));
@@ -97,7 +87,7 @@ export class QueryConstraints extends Constraint {
     }
     // Implement toString()
     toString() {
-        return `{"filter":${this.filters.toString()}},"sort":${this.sorts.toString()},"limit":${this.limit}}`;
+        return `{"filters":${this.filters.toString()}},"sorts":${this.sorts.toString()},"limit":${this.limit}}`;
     }
 }
 function* _getAfterFilters(sorts, item) {

package/db/Collection.d.ts

@@ -1,5 +1,6 @@
-import type { QueryProps } from "../constraint/QueryConstraints.js";
 import type { Datas, Key } from "../util/data.js";
+import type { FilterList } from "../constraint/FilterConstraint.js";
+import type { SortList } from "../constraint/SortConstraint.js";
 import type { ItemData, AsyncItem, Item } from "./Item.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 import type { AsyncQuery, Query } from "./Query.js";
@@ -8,7 +9,7 @@ interface CollectionInterface<T extends Datas = Datas, K extends Key<T> = Key<T>
     readonly db: Database<T> | AsyncDatabase<T>;
     readonly collection: K;
     /** Create a query on this item's collection. */
-    query(query?: QueryProps<ItemData<T[K]>>): Query<T, K> | AsyncQuery<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Create a query on this item's collection. */
     item(id: string): Item<T, K> | AsyncItem<T, K>;
     /** Add an item to this collection. */
@@ -20,7 +21,7 @@ export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
-    query(query?: QueryProps<ItemData<T[K]>>): Query<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item(id: string): Item<T, K>;
     add(data: T[K]): string;
     toString(): K;
@@ -30,7 +31,7 @@ export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> =
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);
-    query(query?: QueryProps<ItemData<T[K]>>): AsyncQuery<T, K>;
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item(id: string): AsyncItem<T, K>;
     add(data: T[K]): Promise<string>;
     toString(): K;

package/db/Collection.js

@@ -4,8 +4,8 @@ export class Collection {
         this.db = db;
         this.collection = collection;
     }
-    query(query) {
-        return this.db.query(this.collection, query);
+    query(filters, sorts, limit) {
+        return this.db.query(this.collection, filters, sorts, limit);
     }
     item(id) {
         return this.db.item(this.collection, id);
@@ -23,8 +23,8 @@ export class AsyncCollection {
         this.db = db;
         this.collection = collection;
     }
-    query(query) {
-        return this.db.query(this.collection, query);
+    query(filters, sorts, limit) {
+        return this.db.query(this.collection, filters, sorts, limit);
     }
     item(id) {
         return this.db.item(this.collection, id);

package/db/Database.d.ts

@@ -1,17 +1,18 @@
 import type { Key, Datas } from "../util/data.js";
-import { ItemData } from "../db/Item.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { QueryProps } from "../constraint/QueryConstraints.js";
+import type { FilterList } from "../constraint/FilterConstraint.js";
+import type { SortList } from "../constraint/SortConstraint.js";
+import type { ItemData } from "../db/Item.js";
 import { Item, AsyncItem } from "./Item.js";
 import { Query, AsyncQuery } from "./Query.js";
-import { AsyncCollection, Collection } from "./Collection.js";
+import { Collection, AsyncCollection } from "./Collection.js";
 /** Database with a synchronous or asynchronous provider. */
 interface AbstractDatabase<T extends Datas> {
     readonly provider: Provider<T> | AsyncProvider<T>;
     /** Create a query on a collection in this database. */
     collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
     /** Create a query on a collection in this database. */
-    query<K extends Key<T>>(collection: K, query?: QueryProps<ItemData<T[K]>>): Query<T, K> | AsyncQuery<T, K>;
+    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Reference an item in a collection in this database. */
     item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
 }
@@ -20,7 +21,7 @@ export declare class Database<T extends Datas = Datas> implements AbstractDataba
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
     collection<K extends Key<T>>(collection: K): Collection<T, K>;
-    query<K extends Key<T>>(collection: K, query?: QueryProps<ItemData<T[K]>>): Query<T, K>;
+    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item<K extends Key<T>>(collection: K, id: string): Item<T, K>;
 }
 /** Database with a synchronous provider. */
@@ -28,7 +29,7 @@ export declare class AsyncDatabase<T extends Datas = Datas> implements AbstractD
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
     collection<K extends Key<T>>(collection: K): AsyncCollection<T, K>;
-    query<K extends Key<T>>(collection: K, query?: QueryProps<ItemData<T[K]>>): AsyncQuery<T, K>;
+    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item<K extends Key<T>>(collection: K, id: string): AsyncItem<T, K>;
 }
 export {};

package/db/Database.js

@@ -1,6 +1,6 @@
 import { Item, AsyncItem } from "./Item.js";
 import { Query, AsyncQuery } from "./Query.js";
-import { AsyncCollection, Collection } from "./Collection.js";
+import { Collection, AsyncCollection } from "./Collection.js";
 /** Database with a synchronous provider. */
 export class Database {
     constructor(provider) {
@@ -9,8 +9,8 @@ export class Database {
     collection(collection) {
         return new Collection(this, collection);
     }
-    query(collection, query) {
-        return new Query(this, collection, query);
+    query(collection, filters, sorts, limit) {
+        return new Query(this, collection, filters, sorts, limit);
     }
     item(collection, id) {
         return new Item(this, collection, id);
@@ -24,8 +24,8 @@ export class AsyncDatabase {
     collection(collection) {
         return new AsyncCollection(this, collection);
     }
-    query(collection, query) {
-        return new AsyncQuery(this, collection, query);
+    query(collection, filters, sorts, limit) {
+        return new AsyncQuery(this, collection, filters, sorts, limit);
     }
     item(collection, id) {
         return new AsyncItem(this, collection, id);

package/db/Item.js

@@ -1,4 +1,5 @@
 import { getData } from "../util/data.js";
+import { FilterConstraint } from "../constraint/FilterConstraint.js";
 import { DataUpdate } from "../update/DataUpdate.js";
 /** Reference to an item in a synchronous provider. */
 export class Item {
@@ -8,7 +9,7 @@ export class Item {
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, { filter: { id: this.id }, limit: 1 });
+        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
     }
     get exists() {
         return !!this.db.provider.getItem(this.collection, this.id);
@@ -43,7 +44,7 @@ export class AsyncItem {
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, { filter: { id: this.id }, limit: 1 });
+        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
     }
     get exists() {
         return this.db.provider.getItem(this.collection, this.id).then(Boolean);

package/db/Query.d.ts

@@ -2,7 +2,9 @@ import type { Dispatch } from "../util/function.js";
 import type { Key, Datas } from "../util/data.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Observable, Unsubscribe } from "../observe/Observable.js";
-import { QueryConstraints, QueryProps } from "../constraint/QueryConstraints.js";
+import type { FilterList } from "../constraint/FilterConstraint.js";
+import type { SortList } from "../constraint/SortConstraint.js";
+import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
 import type { ItemArray, ItemValue, ItemData } from "./Item.js";
 import type { AsyncDatabase, Database } from "./Database.js";
@@ -76,7 +78,7 @@ interface QueryInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> ext
 export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements QueryInterface<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
-    constructor(db: Database<T>, collection: K, props?: QueryProps<ItemData<T[K]>>);
+    constructor(db: Database<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): ItemArray<T[K]>;
     get count(): number;
     get exists(): boolean;
@@ -94,7 +96,7 @@ export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> e
 export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements QueryInterface<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
-    constructor(db: AsyncDatabase<T>, collection: K, props?: QueryProps<ItemData<T[K]>>);
+    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     closed?: boolean;
     get value(): Promise<ItemArray<T[K]>>;
     get count(): Promise<number>;

package/db/Query.js

@@ -4,8 +4,8 @@ import { countItems, hasItems } from "../util/iterate.js";
 import { DataUpdate } from "../update/DataUpdate.js";
 /** Reference to a set of items in a provider. */
 export class Query extends QueryConstraints {
-    constructor(db, collection, props) {
-        super(props);
+    constructor(db, collection, filters, sorts, limit) {
+        super(filters, sorts, limit);
         this.db = db;
         this.collection = collection;
     }
@@ -48,8 +48,8 @@ export class Query extends QueryConstraints {
 }
 /** Reference to a set of items in a provider. */
 export class AsyncQuery extends QueryConstraints {
-    constructor(db, collection, props) {
-        super(props);
+    constructor(db, collection, filters, sorts, limit) {
+        super(filters, sorts, limit);
         this.db = db;
         this.collection = collection;
     }

package/package.json

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

package/provider/BatchProvider.js

@@ -72,4 +72,4 @@ export class BatchProvider extends AsyncThroughProvider {
     }
 }
 const _getItemKey = (collection, id) => `${collection}/${id}`;
-const _getQueryKey = (collection, constraints) => `${collection}:${QueryConstraints.prototype.toString.call(constraints)}`;
+const _getQueryKey = (collection, constraints) => `${collection}?${QueryConstraints.prototype.toString.call(constraints)}`;

package/provider/DebugProvider.js

@@ -238,4 +238,4 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
     }
 }
 const _getItemKey = (collection, id) => `${collection}/${id}`;
-const _getQueryKey = (collection, constraints) => `${collection}:${QueryConstraints.prototype.toString.call(constraints)}`;
+const _getQueryKey = (collection, constraints) => `${collection}?${QueryConstraints.prototype.toString.call(constraints)}`;

package/provider/MemoryProvider.js

@@ -223,4 +223,4 @@ export class MemoryTable extends Subject {
 // When we're writing data, if there's no limit set the results don't need to be sorted (for performance).
 const _getWriteConstraints = (constraints) => (constraints.limit ? constraints : constraints.filters);
 // Queries that have no limit don't care about sorting either.
-const _getQueryKey = (query) => (query.limit ? `{filters:${query.filters.toString()}}` : QueryConstraints.prototype.toString.call(query));
+const _getQueryKey = (query) => (query.limit ? `"filters":${query.filters.toString()}}` : QueryConstraints.prototype.toString.call(query));