@verdant-web/store 2.7.6 → 2.7.7-next.0

package/dist/esm/queries/BaseQuery.js

@@ -1,132 +1,132 @@
-var _a;
-import { EventSubscriber } from '@verdant-web/common';
-import { Entity } from '../entities/Entity.js';
-import { Disposable } from '../utils/Disposable.js';
-import { filterResultSet } from './utils.js';
-export const ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
-export const UPDATE = Symbol('UPDATE');
-// export interface BaseQuery<T> {
-// 	subscribe(event: 'change', callback: (value: T) => void): () => void;
-// 	subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
-// 	subscribe(callback: (value: T) => void): () => void;
-// }
-export class BaseQuery extends Disposable {
-    constructor({ initial, context, collection, key, shouldUpdate, }) {
-        super();
-        this._internalUnsubscribes = [];
-        this._status = 'initial';
-        this._executionPromise = null;
-        this.setValue = (value) => {
-            this._rawValue = value;
-            this.subscribeToDeleteAndRestore(this._rawValue);
-            this._value = 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) {
-                        this._internalUnsubscribes.push(entity.subscribe('delete', this.refreshValue));
-                        this._internalUnsubscribes.push(entity.subscribe('restore', this.refreshValue));
-                    }
-                });
-            }
-            else if (value instanceof 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);
-            if (this._status === 'initial') {
-                this._status = 'initializing';
-            }
-            else if (this._status === 'ready') {
-                this._status = 'revalidating';
-            }
-            // no status change needed if already in a 'running' status.
-            this._executionPromise = this.run()
-                .then(() => this._value)
-                .catch((err) => {
-                if (err instanceof Error) {
-                    if (err.name === 'InvalidStateError' ||
-                        err.name === 'InvalidAccessError') {
-                        // possibly accessing db while it's closed. not much we can do.
-                        return this._value;
-                    }
-                }
-                throw err;
-            });
-            return this._executionPromise;
-        };
-        this[_a] = (handler) => {
-            this._allUnsubscribedHandler = handler;
-        };
-        this._rawValue = initial;
-        this._value = initial;
-        this._events = new 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;
-    }
-    subscribe(eventOrCallback, callback) {
-        // change subscription has special behavior...
-        if (callback === undefined && typeof eventOrCallback === 'function') {
-            // accessing for side effects... eh
-            this.resolved;
-            return this._events.subscribe('change', eventOrCallback);
-        }
-        else if (eventOrCallback === 'change' && callback !== undefined) {
-            // accessing for side effects... eh
-            this.resolved;
-            return this._events.subscribe('change', callback);
-        }
-        else if (eventOrCallback === 'statusChange' &&
-            typeof callback === 'function') {
-            return this._events.subscribe(eventOrCallback, callback);
-        }
-        else {
-            throw new Error('Invalid invocation of Query.subscribe');
-        }
-    }
-}
-_a = ON_ALL_UNSUBSCRIBED;
+var _a;
+import { EventSubscriber } from '@verdant-web/common';
+import { Entity } from '../entities/Entity.js';
+import { Disposable } from '../utils/Disposable.js';
+import { filterResultSet } from './utils.js';
+export const ON_ALL_UNSUBSCRIBED = Symbol('ON_ALL_UNSUBSCRIBED');
+export const UPDATE = Symbol('UPDATE');
+// export interface BaseQuery<T> {
+// 	subscribe(event: 'change', callback: (value: T) => void): () => void;
+// 	subscribe(event: 'statusChange', callback: (status: QueryStatus) => void): () => void;
+// 	subscribe(callback: (value: T) => void): () => void;
+// }
+export class BaseQuery extends Disposable {
+    constructor({ initial, context, collection, key, shouldUpdate, }) {
+        super();
+        this._internalUnsubscribes = [];
+        this._status = 'initial';
+        this._executionPromise = null;
+        this.setValue = (value) => {
+            this._rawValue = value;
+            this.subscribeToDeleteAndRestore(this._rawValue);
+            this._value = 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) {
+                        this._internalUnsubscribes.push(entity.subscribe('delete', this.refreshValue));
+                        this._internalUnsubscribes.push(entity.subscribe('restore', this.refreshValue));
+                    }
+                });
+            }
+            else if (value instanceof 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);
+            if (this._status === 'initial') {
+                this._status = 'initializing';
+            }
+            else if (this._status === 'ready') {
+                this._status = 'revalidating';
+            }
+            // no status change needed if already in a 'running' status.
+            this._executionPromise = this.run()
+                .then(() => this._value)
+                .catch((err) => {
+                if (err instanceof Error) {
+                    if (err.name === 'InvalidStateError' ||
+                        err.name === 'InvalidAccessError') {
+                        // possibly accessing db while it's closed. not much we can do.
+                        return this._value;
+                    }
+                }
+                throw err;
+            });
+            return this._executionPromise;
+        };
+        this[_a] = (handler) => {
+            this._allUnsubscribedHandler = handler;
+        };
+        this._rawValue = initial;
+        this._value = initial;
+        this._events = new 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;
+    }
+    subscribe(eventOrCallback, callback) {
+        // change subscription has special behavior...
+        if (callback === undefined && typeof eventOrCallback === 'function') {
+            // accessing for side effects... eh
+            this.resolved;
+            return this._events.subscribe('change', eventOrCallback);
+        }
+        else if (eventOrCallback === 'change' && callback !== undefined) {
+            // accessing for side effects... eh
+            this.resolved;
+            return this._events.subscribe('change', callback);
+        }
+        else if (eventOrCallback === 'statusChange' &&
+            typeof callback === 'function') {
+            return this._events.subscribe(eventOrCallback, callback);
+        }
+        else {
+            throw new Error('Invalid invocation of Query.subscribe');
+        }
+    }
+}
+_a = ON_ALL_UNSUBSCRIBED;
 //# sourceMappingURL=BaseQuery.js.map

package/dist/esm/queries/CollectionQueries.d.ts

@@ -1,55 +1,55 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { EntityStore } from '../entities/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 '../entities/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/esm/queries/CollectionQueries.js

@@ -1,88 +1,88 @@
-import { hashObject } from '@verdant-web/common';
-import { GetQuery } from './GetQuery.js';
-import { FindOneQuery } from './FindOneQuery.js';
-import { FindPageQuery } from './FindPageQuery.js';
-import { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import { FindAllQuery } from './FindAllQuery.js';
-import { UPDATE } from './BaseQuery.js';
-export class CollectionQueries {
-    constructor({ collection, cache, entities, context, documentManager, }) {
-        this.serializeIndex = (index) => {
-            if (!index)
-                return '';
-            return hashObject(index);
-        };
-        this.get = (id) => {
-            const key = `get:${this.collection}:${id}`;
-            return this.cache.getOrSet(key, () => new 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({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.findAll = ({ index, key: providedKey, } = {}) => {
-            const key = providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
-            return this.cache.getOrSet(key, () => new FindAllQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.findPage = ({ index, pageSize, page, key: providedKey, }) => {
-            const key = providedKey ||
-                `findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
-            return this.cache.getOrSet(key, () => new FindPageQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-                pageSize,
-                page,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        this.findAllInfinite = ({ index, pageSize, key: providedKey, }) => {
-            const key = providedKey ||
-                `findAllInfinite:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
-            return this.cache.getOrSet(key, () => new FindInfiniteQuery({
-                index,
-                collection: this.collection,
-                hydrate: this.hydrate,
-                context: this.context,
-                key,
-                pageSize,
-            }), (existing) => {
-                existing[UPDATE](index);
-            });
-        };
-        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);
-    }
-}
+import { hashObject } from '@verdant-web/common';
+import { GetQuery } from './GetQuery.js';
+import { FindOneQuery } from './FindOneQuery.js';
+import { FindPageQuery } from './FindPageQuery.js';
+import { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import { FindAllQuery } from './FindAllQuery.js';
+import { UPDATE } from './BaseQuery.js';
+export class CollectionQueries {
+    constructor({ collection, cache, entities, context, documentManager, }) {
+        this.serializeIndex = (index) => {
+            if (!index)
+                return '';
+            return hashObject(index);
+        };
+        this.get = (id) => {
+            const key = `get:${this.collection}:${id}`;
+            return this.cache.getOrSet(key, () => new 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({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.findAll = ({ index, key: providedKey, } = {}) => {
+            const key = providedKey || `findAll:${this.collection}:${this.serializeIndex(index)}`;
+            return this.cache.getOrSet(key, () => new FindAllQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.findPage = ({ index, pageSize, page, key: providedKey, }) => {
+            const key = providedKey ||
+                `findPage:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+            return this.cache.getOrSet(key, () => new FindPageQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+                pageSize,
+                page,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        this.findAllInfinite = ({ index, pageSize, key: providedKey, }) => {
+            const key = providedKey ||
+                `findAllInfinite:${this.collection}:${this.serializeIndex(index)}:${pageSize}`;
+            return this.cache.getOrSet(key, () => new FindInfiniteQuery({
+                index,
+                collection: this.collection,
+                hydrate: this.hydrate,
+                context: this.context,
+                key,
+                pageSize,
+            }), (existing) => {
+                existing[UPDATE](index);
+            });
+        };
+        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);
+    }
+}
 //# sourceMappingURL=CollectionQueries.js.map

package/dist/esm/queries/FindAllQuery.d.ts

@@ -1,12 +1,12 @@
-import { CollectionFilter } from '@verdant-web/common';
-import { BaseQuery, BaseQueryOptions, UPDATE } 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>;
-    [UPDATE]: (index: CollectionFilter | undefined) => void;
-}
+import { CollectionFilter } from '@verdant-web/common';
+import { BaseQuery, BaseQueryOptions, UPDATE } 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>;
+    [UPDATE]: (index: CollectionFilter | undefined) => void;
+}

package/dist/esm/queries/FindAllQuery.js

@@ -1,39 +1,39 @@
-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;
-};
-var _a;
-import { BaseQuery, UPDATE } from './BaseQuery.js';
-import { findAllOids } from './dbQueries.js';
-import { areIndexesEqual } from './utils.js';
-export class FindAllQuery extends BaseQuery {
-    constructor(_b) {
-        var { index, hydrate } = _b, rest = __rest(_b, ["index", "hydrate"]);
-        super(Object.assign({ initial: [] }, rest));
-        this.run = async () => {
-            const oids = await findAllOids({
-                collection: this.collection,
-                index: this.index,
-                context: this.context,
-            });
-            this.setValue(await Promise.all(oids.map(this.hydrate)));
-        };
-        this[_a] = (index) => {
-            if (areIndexesEqual(this.index, index))
-                return;
-            this.index = index;
-            this.execute();
-        };
-        this.index = index;
-        this.hydrate = hydrate;
-    }
-}
-_a = UPDATE;
+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;
+};
+var _a;
+import { BaseQuery, UPDATE } from './BaseQuery.js';
+import { findAllOids } from './dbQueries.js';
+import { areIndexesEqual } from './utils.js';
+export class FindAllQuery extends BaseQuery {
+    constructor(_b) {
+        var { index, hydrate } = _b, rest = __rest(_b, ["index", "hydrate"]);
+        super(Object.assign({ initial: [] }, rest));
+        this.run = async () => {
+            const oids = await findAllOids({
+                collection: this.collection,
+                index: this.index,
+                context: this.context,
+            });
+            this.setValue(await Promise.all(oids.map(this.hydrate)));
+        };
+        this[_a] = (index) => {
+            if (areIndexesEqual(this.index, index))
+                return;
+            this.index = index;
+            this.execute();
+        };
+        this.index = index;
+        this.hydrate = hydrate;
+    }
+}
+_a = UPDATE;
 //# sourceMappingURL=FindAllQuery.js.map