@verdant-web/store 2.0.1 → 2.0.2

package/dist/cjs/queries2/BaseQuery.d.ts

@@ -1,39 +1,39 @@
-import { Disposable } from '../utils/Disposable.js';
-import { Context } from '../context.js';
-export type BaseQueryEvents = {
-    change: (value: any) => void;
-};
-export type BaseQueryOptions<T> = {
-    context: Context;
-    initial: T;
-    collection: string;
-    key: string;
-    shouldUpdate?: (updatedCollections: string[]) => boolean;
-};
-export type QueryStatus = 'initial' | 'running' | 'ready';
-export declare const ON_ALL_UNSUBSCRIBED: unique symbol;
-export declare const UPDATE: unique symbol;
-export declare abstract class BaseQuery<T> extends Disposable {
-    private _rawValue;
-    private _value;
-    private _events;
-    private _internalUnsubscribes;
-    private _allUnsubscribedHandler?;
-    private _status;
-    private _executionPromise;
-    protected context: Context;
-    readonly collection: string;
-    readonly key: string;
-    constructor({ initial, context, collection, key, shouldUpdate, }: BaseQueryOptions<T>);
-    get current(): T;
-    get resolved(): Promise<T>;
-    get subscribed(): boolean;
-    get status(): QueryStatus;
-    subscribe: (callback: (value: T) => void) => () => void;
-    protected setValue: (value: T) => void;
-    protected refreshValue: () => void;
-    private subscribeToDeleteAndRestore;
-    execute: () => Promise<T>;
-    protected abstract run(): Promise<void>;
-    [ON_ALL_UNSUBSCRIBED]: (handler: (query: BaseQuery<T>) => void) => void;
-}
+import { Disposable } from '../utils/Disposable.js';
+import { Context } from '../context.js';
+export type BaseQueryEvents = {
+    change: (value: any) => void;
+};
+export type BaseQueryOptions<T> = {
+    context: Context;
+    initial: T;
+    collection: string;
+    key: string;
+    shouldUpdate?: (updatedCollections: string[]) => boolean;
+};
+export type QueryStatus = 'initial' | 'running' | 'ready';
+export declare const ON_ALL_UNSUBSCRIBED: unique symbol;
+export declare const UPDATE: unique symbol;
+export declare abstract class BaseQuery<T> extends Disposable {
+    private _rawValue;
+    private _value;
+    private _events;
+    private _internalUnsubscribes;
+    private _allUnsubscribedHandler?;
+    private _status;
+    private _executionPromise;
+    protected context: Context;
+    readonly collection: string;
+    readonly key: string;
+    constructor({ initial, context, collection, key, shouldUpdate, }: BaseQueryOptions<T>);
+    get current(): T;
+    get resolved(): Promise<T>;
+    get subscribed(): boolean;
+    get status(): QueryStatus;
+    subscribe: (callback: (value: T) => void) => () => void;
+    protected setValue: (value: T) => void;
+    protected refreshValue: () => void;
+    private subscribeToDeleteAndRestore;
+    execute: () => Promise<T>;
+    protected abstract run(): Promise<void>;
+    [ON_ALL_UNSUBSCRIBED]: (handler: (query: BaseQuery<T>) => void) => void;
+}

package/dist/cjs/queries2/BaseQuery.js

@@ -1,99 +1,99 @@
-"use strict";
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseQuery = exports.UPDATE = exports.ON_ALL_UNSUBSCRIBED = void 0;
-const common_1 = require("@verdant-web/common");
-const utils_js_1 = require("./utils.js");
-const Entity_js_1 = require("../reactives/Entity.js");
-const Disposable_js_1 = require("../utils/Disposable.js");
-exports.ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
-exports.UPDATE = Symbol('UPDATE');
-class BaseQuery extends Disposable_js_1.Disposable {
-    constructor({ initial, context, collection, key, shouldUpdate, }) {
-        super();
-        this._internalUnsubscribes = [];
-        this._status = 'initial';
-        this._executionPromise = null;
-        this.subscribe = (callback) => {
-            // accessing for side effects... eh
-            this.resolved;
-            return this._events.subscribe('change', callback);
-        };
-        this.setValue = (value) => {
-            this._rawValue = value;
-            this.subscribeToDeleteAndRestore(this._rawValue);
-            this._value = (0, utils_js_1.filterResultSet)(value);
-            this._status = 'ready';
-            this._events.emit('change', this._value);
-        };
-        // re-applies filtering if results have changed
-        this.refreshValue = () => {
-            this.setValue(this._rawValue);
-        };
-        this.subscribeToDeleteAndRestore = (value) => {
-            var _b;
-            while (this._internalUnsubscribes.length) {
-                (_b = this._internalUnsubscribes.pop()) === null || _b === void 0 ? void 0 : _b();
-            }
-            if (Array.isArray(value)) {
-                value.forEach((entity) => {
-                    if (entity instanceof Entity_js_1.Entity) {
-                        this._internalUnsubscribes.push(entity.subscribe('delete', this.refreshValue));
-                        this._internalUnsubscribes.push(entity.subscribe('restore', this.refreshValue));
-                    }
-                });
-            }
-            else if (value instanceof Entity_js_1.Entity) {
-                this._internalUnsubscribes.push(value.subscribe('delete', this.refreshValue));
-                this._internalUnsubscribes.push(value.subscribe('restore', () => {
-                    this.refreshValue();
-                }));
-            }
-        };
-        this.execute = () => {
-            this.context.log('debug', 'Executing query', this.key);
-            this._status = 'running';
-            this._executionPromise = this.run().then(() => this._value);
-            return this._executionPromise;
-        };
-        this[_a] = (handler) => {
-            this._allUnsubscribedHandler = handler;
-        };
-        this._rawValue = initial;
-        this._value = initial;
-        this._events = new common_1.EventSubscriber((event) => {
-            var _b;
-            if (event === 'change')
-                (_b = this._allUnsubscribedHandler) === null || _b === void 0 ? void 0 : _b.call(this, this);
-        });
-        this.context = context;
-        this.key = key;
-        this.collection = collection;
-        const shouldUpdateFn = shouldUpdate ||
-            ((collections) => collections.includes(collection));
-        this.addDispose(this.context.entityEvents.subscribe('collectionsChanged', (collections) => {
-            if (shouldUpdateFn(collections)) {
-                this.context.log('info', 'Updating query', this.key);
-                this.execute();
-            }
-        }));
-    }
-    get current() {
-        return this._value;
-    }
-    get resolved() {
-        var _b;
-        if (this.status === 'ready')
-            return Promise.resolve(this._value);
-        return (_b = this._executionPromise) !== null && _b !== void 0 ? _b : this.execute();
-    }
-    get subscribed() {
-        return this._events.totalSubscriberCount() > 0;
-    }
-    get status() {
-        return this._status;
-    }
-}
-exports.BaseQuery = BaseQuery;
-_a = exports.ON_ALL_UNSUBSCRIBED;
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseQuery = exports.UPDATE = exports.ON_ALL_UNSUBSCRIBED = void 0;
+const common_1 = require("@verdant-web/common");
+const utils_js_1 = require("./utils.js");
+const Entity_js_1 = require("../reactives/Entity.js");
+const Disposable_js_1 = require("../utils/Disposable.js");
+exports.ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
+exports.UPDATE = Symbol('UPDATE');
+class BaseQuery extends Disposable_js_1.Disposable {
+    constructor({ initial, context, collection, key, shouldUpdate, }) {
+        super();
+        this._internalUnsubscribes = [];
+        this._status = 'initial';
+        this._executionPromise = null;
+        this.subscribe = (callback) => {
+            // accessing for side effects... eh
+            this.resolved;
+            return this._events.subscribe('change', callback);
+        };
+        this.setValue = (value) => {
+            this._rawValue = value;
+            this.subscribeToDeleteAndRestore(this._rawValue);
+            this._value = (0, utils_js_1.filterResultSet)(value);
+            this._status = 'ready';
+            this._events.emit('change', this._value);
+        };
+        // re-applies filtering if results have changed
+        this.refreshValue = () => {
+            this.setValue(this._rawValue);
+        };
+        this.subscribeToDeleteAndRestore = (value) => {
+            var _b;
+            while (this._internalUnsubscribes.length) {
+                (_b = this._internalUnsubscribes.pop()) === null || _b === void 0 ? void 0 : _b();
+            }
+            if (Array.isArray(value)) {
+                value.forEach((entity) => {
+                    if (entity instanceof Entity_js_1.Entity) {
+                        this._internalUnsubscribes.push(entity.subscribe('delete', this.refreshValue));
+                        this._internalUnsubscribes.push(entity.subscribe('restore', this.refreshValue));
+                    }
+                });
+            }
+            else if (value instanceof Entity_js_1.Entity) {
+                this._internalUnsubscribes.push(value.subscribe('delete', this.refreshValue));
+                this._internalUnsubscribes.push(value.subscribe('restore', () => {
+                    this.refreshValue();
+                }));
+            }
+        };
+        this.execute = () => {
+            this.context.log('debug', 'Executing query', this.key);
+            this._status = 'running';
+            this._executionPromise = this.run().then(() => this._value);
+            return this._executionPromise;
+        };
+        this[_a] = (handler) => {
+            this._allUnsubscribedHandler = handler;
+        };
+        this._rawValue = initial;
+        this._value = initial;
+        this._events = new common_1.EventSubscriber((event) => {
+            var _b;
+            if (event === 'change')
+                (_b = this._allUnsubscribedHandler) === null || _b === void 0 ? void 0 : _b.call(this, this);
+        });
+        this.context = context;
+        this.key = key;
+        this.collection = collection;
+        const shouldUpdateFn = shouldUpdate ||
+            ((collections) => collections.includes(collection));
+        this.addDispose(this.context.entityEvents.subscribe('collectionsChanged', (collections) => {
+            if (shouldUpdateFn(collections)) {
+                this.context.log('info', 'Updating query', this.key);
+                this.execute();
+            }
+        }));
+    }
+    get current() {
+        return this._value;
+    }
+    get resolved() {
+        var _b;
+        if (this.status === 'ready')
+            return Promise.resolve(this._value);
+        return (_b = this._executionPromise) !== null && _b !== void 0 ? _b : this.execute();
+    }
+    get subscribed() {
+        return this._events.totalSubscriberCount() > 0;
+    }
+    get status() {
+        return this._status;
+    }
+}
+exports.BaseQuery = BaseQuery;
+_a = exports.ON_ALL_UNSUBSCRIBED;
 //# sourceMappingURL=BaseQuery.js.map

package/dist/cjs/queries2/CollectionQueries.d.ts

@@ -1,55 +1,55 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { EntityStore } from '../reactives/EntityStore.js';
-import { GetQuery } from './GetQuery.js';
-import { QueryCache } from './QueryCache.js';
-import { FindOneQuery } from './FindOneQuery.js';
-import { FindPageQuery } from './FindPageQuery.js';
-import { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import { FindAllQuery } from './FindAllQuery.js';
-import { DocumentManager } from '../DocumentManager.js';
-import { ObjectEntity } from '../index.js';
-export declare class CollectionQueries<T extends ObjectEntity<any, any>, Init, Filter extends CollectionFilter> {
-    private cache;
-    private collection;
-    private hydrate;
-    private context;
-    private documentManager;
-    put: (init: Init, options?: {
-        undoable?: boolean;
-    }) => Promise<T>;
-    delete: (id: string, options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    deleteAll: (ids: string[], options?: {
-        undoable?: boolean;
-    }) => Promise<void>;
-    constructor({ collection, cache, entities, context, documentManager, }: {
-        collection: string;
-        cache: QueryCache;
-        entities: EntityStore;
-        context: Context;
-        documentManager: DocumentManager<any>;
-    });
-    private serializeIndex;
-    get: (id: string) => GetQuery<T>;
-    findOne: ({ index, key: providedKey, }?: {
-        index?: Filter | undefined;
-        key?: string | undefined;
-    }) => FindOneQuery<T>;
-    findAll: ({ index, key: providedKey, }?: {
-        index?: Filter | undefined;
-        key?: string | undefined;
-    }) => FindAllQuery<T>;
-    findPage: ({ index, pageSize, page, key: providedKey, }: {
-        index?: Filter | undefined;
-        pageSize: number;
-        page: number;
-        key?: string | undefined;
-    }) => FindPageQuery<T>;
-    findAllInfinite: ({ index, pageSize, key: providedKey, }: {
-        index?: Filter | undefined;
-        pageSize: number;
-        key?: string | undefined;
-    }) => FindInfiniteQuery<T>;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { EntityStore } from '../reactives/EntityStore.js';
+import { GetQuery } from './GetQuery.js';
+import { QueryCache } from './QueryCache.js';
+import { FindOneQuery } from './FindOneQuery.js';
+import { FindPageQuery } from './FindPageQuery.js';
+import { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import { FindAllQuery } from './FindAllQuery.js';
+import { DocumentManager } from '../DocumentManager.js';
+import { ObjectEntity } from '../index.js';
+export declare class CollectionQueries<T extends ObjectEntity<any, any>, Init, Filter extends CollectionFilter> {
+    private cache;
+    private collection;
+    private hydrate;
+    private context;
+    private documentManager;
+    put: (init: Init, options?: {
+        undoable?: boolean;
+    }) => Promise<T>;
+    delete: (id: string, options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    deleteAll: (ids: string[], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    constructor({ collection, cache, entities, context, documentManager, }: {
+        collection: string;
+        cache: QueryCache;
+        entities: EntityStore;
+        context: Context;
+        documentManager: DocumentManager<any>;
+    });
+    private serializeIndex;
+    get: (id: string) => GetQuery<T>;
+    findOne: ({ index, key: providedKey, }?: {
+        index?: Filter | undefined;
+        key?: string | undefined;
+    }) => FindOneQuery<T>;
+    findAll: ({ index, key: providedKey, }?: {
+        index?: Filter | undefined;
+        key?: string | undefined;
+    }) => FindAllQuery<T>;
+    findPage: ({ index, pageSize, page, key: providedKey, }: {
+        index?: Filter | undefined;
+        pageSize: number;
+        page: number;
+        key?: string | undefined;
+    }) => FindPageQuery<T>;
+    findAllInfinite: ({ index, pageSize, key: providedKey, }: {
+        index?: Filter | undefined;
+        pageSize: number;
+        key?: string | undefined;
+    }) => FindInfiniteQuery<T>;
+}

package/dist/cjs/queries2/CollectionQueries.js

@@ -1,83 +1,83 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CollectionQueries = void 0;
-const common_1 = require("@verdant-web/common");
-const GetQuery_js_1 = require("./GetQuery.js");
-const FindOneQuery_js_1 = require("./FindOneQuery.js");
-const FindPageQuery_js_1 = require("./FindPageQuery.js");
-const FindInfiniteQuery_js_1 = require("./FindInfiniteQuery.js");
-const FindAllQuery_js_1 = require("./FindAllQuery.js");
-class CollectionQueries {
-    constructor({ collection, cache, entities, context, documentManager, }) {
-        this.serializeIndex = (index) => {
-            if (!index)
-                return '';
-            return (0, common_1.hashObject)(index);
-        };
-        this.get = (id) => {
-            const key = `get:${this.collection}:${id}`;
-            return this.cache.getOrSet(key, () => new GetQuery_js_1.GetQuery({
-                id,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }));
-        };
-        this.findOne = ({ index, key: providedKey, } = {}) => {
-            const key = providedKey || `findOne:${this.collection}:${this.serializeIndex(index)}`;
-            return this.cache.getOrSet(key, () => new FindOneQuery_js_1.FindOneQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }));
-        };
-        this.findAll = ({ index, key: providedKey, } = {}) => {
-            const key = providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
-            return this.cache.getOrSet(key, () => new FindAllQuery_js_1.FindAllQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }));
-        };
-        this.findPage = ({ index, pageSize, page, key: providedKey, }) => {
-            const key = providedKey ||
-                `findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
-            return this.cache.set(new FindPageQuery_js_1.FindPageQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-                pageSize,
-                page,
-            }));
-        };
-        this.findAllInfinite = ({ index, pageSize, key: providedKey, }) => {
-            const key = providedKey ||
-                `findAllInfinite:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
-            return this.cache.getOrSet(key, () => new FindInfiniteQuery_js_1.FindInfiniteQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-                pageSize,
-            }));
-        };
-        this.cache = cache;
-        this.collection = collection;
-        this.hydrate = entities.get;
-        this.context = context;
-        this.documentManager = documentManager;
-        this.put = this.documentManager.create.bind(this.documentManager, this.collection);
-        this.delete = this.documentManager.delete.bind(this.documentManager, this.collection);
-        this.deleteAll = this.documentManager.deleteAllFromCollection.bind(this.documentManager, this.collection);
-    }
-}
-exports.CollectionQueries = CollectionQueries;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionQueries = void 0;
+const common_1 = require("@verdant-web/common");
+const GetQuery_js_1 = require("./GetQuery.js");
+const FindOneQuery_js_1 = require("./FindOneQuery.js");
+const FindPageQuery_js_1 = require("./FindPageQuery.js");
+const FindInfiniteQuery_js_1 = require("./FindInfiniteQuery.js");
+const FindAllQuery_js_1 = require("./FindAllQuery.js");
+class CollectionQueries {
+    constructor({ collection, cache, entities, context, documentManager, }) {
+        this.serializeIndex = (index) => {
+            if (!index)
+                return '';
+            return (0, common_1.hashObject)(index);
+        };
+        this.get = (id) => {
+            const key = `get:${this.collection}:${id}`;
+            return this.cache.getOrSet(key, () => new GetQuery_js_1.GetQuery({
+                id,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }));
+        };
+        this.findOne = ({ index, key: providedKey, } = {}) => {
+            const key = providedKey || `findOne:${this.collection}:${this.serializeIndex(index)}`;
+            return this.cache.getOrSet(key, () => new FindOneQuery_js_1.FindOneQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }));
+        };
+        this.findAll = ({ index, key: providedKey, } = {}) => {
+            const key = providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
+            return this.cache.getOrSet(key, () => new FindAllQuery_js_1.FindAllQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }));
+        };
+        this.findPage = ({ index, pageSize, page, key: providedKey, }) => {
+            const key = providedKey ||
+                `findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+            return this.cache.set(new FindPageQuery_js_1.FindPageQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+                pageSize,
+                page,
+            }));
+        };
+        this.findAllInfinite = ({ index, pageSize, key: providedKey, }) => {
+            const key = providedKey ||
+                `findAllInfinite:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+            return this.cache.getOrSet(key, () => new FindInfiniteQuery_js_1.FindInfiniteQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+                pageSize,
+            }));
+        };
+        this.cache = cache;
+        this.collection = collection;
+        this.hydrate = entities.get;
+        this.context = context;
+        this.documentManager = documentManager;
+        this.put = this.documentManager.create.bind(this.documentManager, this.collection);
+        this.delete = this.documentManager.delete.bind(this.documentManager, this.collection);
+        this.deleteAll = this.documentManager.deleteAllFromCollection.bind(this.documentManager, this.collection);
+    }
+}
+exports.CollectionQueries = CollectionQueries;
 //# sourceMappingURL=CollectionQueries.js.map

package/dist/cjs/queries2/FindAllQuery.d.ts

@@ -1,11 +1,11 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
-export declare class FindAllQuery<T> extends BaseQuery<T[]> {
-    private index;
-    private hydrate;
-    constructor({ index, hydrate, ...rest }: {
-        index?: CollectionFilter;
-        hydrate: (oid: string) => Promise<T>;
-    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
-    protected run: () => Promise<void>;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions } from './BaseQuery.js';
+export declare class FindAllQuery<T> extends BaseQuery<T[]> {
+    private index;
+    private hydrate;
+    constructor({ index, hydrate, ...rest }: {
+        index?: CollectionFilter;
+        hydrate: (oid: string) => Promise<T>;
+    } & Omit<BaseQueryOptions<T[]>, 'initial'>);
+    protected run: () => Promise<void>;
+}

package/dist/cjs/queries2/FindAllQuery.js

@@ -1,34 +1,34 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FindAllQuery = void 0;
-const dbQueries_js_1 = require("./dbQueries.js");
-const BaseQuery_js_1 = require("./BaseQuery.js");
-class FindAllQuery extends BaseQuery_js_1.BaseQuery {
-    constructor(_a) {
-        var { index, hydrate } = _a, rest = __rest(_a, ["index", "hydrate"]);
-        super(Object.assign({ initial: [] }, rest));
-        this.run = async () => {
-            const oids = await (0, dbQueries_js_1.findAllOids)({
-                collection: this.collection,
-                index: this.index,
-                context: this.context,
-            });
-            this.setValue(await Promise.all(oids.map(this.hydrate)));
-        };
-        this.index = index;
-        this.hydrate = hydrate;
-    }
-}
-exports.FindAllQuery = FindAllQuery;
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindAllQuery = void 0;
+const dbQueries_js_1 = require("./dbQueries.js");
+const BaseQuery_js_1 = require("./BaseQuery.js");
+class FindAllQuery extends BaseQuery_js_1.BaseQuery {
+    constructor(_a) {
+        var { index, hydrate } = _a, rest = __rest(_a, ["index", "hydrate"]);
+        super(Object.assign({ initial: [] }, rest));
+        this.run = async () => {
+            const oids = await (0, dbQueries_js_1.findAllOids)({
+                collection: this.collection,
+                index: this.index,
+                context: this.context,
+            });
+            this.setValue(await Promise.all(oids.map(this.hydrate)));
+        };
+        this.index = index;
+        this.hydrate = hydrate;
+    }
+}
+exports.FindAllQuery = FindAllQuery;
 //# sourceMappingURL=FindAllQuery.js.map