@verdant-web/store 2.0.1 → 2.0.3

package/dist/esm/queries2/dbQueries.js

@@ -1,120 +1,120 @@
-import { createOid } from '@verdant-web/common';
-import { getRange } from './ranges.js';
-function getStore(db, collection, write) {
-    return db
-        .transaction(collection, write ? 'readwrite' : 'readonly')
-        .objectStore(collection);
-}
-export async function findOneOid({ collection, index, context, }) {
-    const store = getStore(context.documentDb, collection);
-    const source = index ? store.index(index.where) : store;
-    const range = getRange(context.schema, collection, index);
-    const direction = (index === null || index === void 0 ? void 0 : index.order) === 'desc' ? 'prev' : 'next';
-    const request = source.openCursor(range, direction);
-    const result = await new Promise((resolve, reject) => {
-        request.onsuccess = () => {
-            const cursor = request.result;
-            if (cursor) {
-                resolve(createOid(collection, cursor.primaryKey.toString()));
-            }
-            else {
-                resolve(null);
-            }
-        };
-        request.onerror = () => {
-            var _a;
-            if (((_a = request.error) === null || _a === void 0 ? void 0 : _a.name) === 'InvalidStateError') {
-                context.log('error', `findOne query failed with InvalidStateError`, request.error);
-                resolve(null);
-            }
-            else {
-                reject(request.error);
-            }
-        };
-    });
-    return result;
-}
-export async function findAllOids({ collection, index, context, }) {
-    const store = getStore(context.documentDb, collection);
-    const source = index ? store.index(index.where) : store;
-    const range = getRange(context.schema, collection, index);
-    const direction = (index === null || index === void 0 ? void 0 : index.order) === 'desc' ? 'prev' : 'next';
-    const request = source.openCursor(range, direction);
-    const result = await new Promise((resolve, reject) => {
-        const results = new Set();
-        request.onsuccess = () => {
-            const cursor = request.result;
-            if (cursor) {
-                results.add(createOid(collection, cursor.primaryKey.toString()));
-                cursor.continue();
-            }
-            else {
-                resolve(Array.from(results));
-            }
-        };
-        request.onerror = () => {
-            var _a;
-            if (((_a = request.error) === null || _a === void 0 ? void 0 : _a.name) === 'InvalidStateError') {
-                context.log('error', `findAll query failed with InvalidStateError`, request.error);
-                resolve([]);
-            }
-            else {
-                reject(request.error);
-            }
-        };
-    });
-    return result;
-}
-export async function findPageOfOids({ collection, index, context, limit, offset, }) {
-    const store = getStore(context.documentDb, collection);
-    const source = index ? store.index(index.where) : store;
-    const range = getRange(context.schema, collection, index);
-    const direction = (index === null || index === void 0 ? void 0 : index.order) === 'desc' ? 'prev' : 'next';
-    const request = source.openCursor(range, direction);
-    let hasDoneOffset = !offset;
-    let hasNextPage = false;
-    let visited = 0;
-    const result = await new Promise((resolve, reject) => {
-        const results = new Set();
-        request.onsuccess = () => {
-            visited++;
-            const cursor = request.result;
-            if (cursor) {
-                if (offset && !hasDoneOffset) {
-                    cursor.advance(offset);
-                    hasDoneOffset = true;
-                }
-                else {
-                    if (limit && results.size < limit) {
-                        results.add(createOid(collection, cursor.primaryKey.toString()));
-                    }
-                    if (limit && visited > limit) {
-                        hasNextPage = true;
-                        resolve(Array.from(results));
-                    }
-                    else {
-                        cursor.continue();
-                    }
-                }
-            }
-            else {
-                resolve(Array.from(results));
-            }
-        };
-        request.onerror = () => {
-            var _a;
-            if (((_a = request.error) === null || _a === void 0 ? void 0 : _a.name) === 'InvalidStateError') {
-                context.log('error', `find query failed with InvalidStateError`, request.error);
-                resolve([]);
-            }
-            else {
-                reject(request.error);
-            }
-        };
-    });
-    return {
-        result: result,
-        hasNextPage,
-    };
-}
+import { createOid } from '@verdant-web/common';
+import { getRange } from './ranges.js';
+function getStore(db, collection, write) {
+    return db
+        .transaction(collection, write ? 'readwrite' : 'readonly')
+        .objectStore(collection);
+}
+export async function findOneOid({ collection, index, context, }) {
+    const store = getStore(context.documentDb, collection);
+    const source = index ? store.index(index.where) : store;
+    const range = getRange(context.schema, collection, index);
+    const direction = (index === null || index === void 0 ? void 0 : index.order) === 'desc' ? 'prev' : 'next';
+    const request = source.openCursor(range, direction);
+    const result = await new Promise((resolve, reject) => {
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor) {
+                resolve(createOid(collection, cursor.primaryKey.toString()));
+            }
+            else {
+                resolve(null);
+            }
+        };
+        request.onerror = () => {
+            var _a;
+            if (((_a = request.error) === null || _a === void 0 ? void 0 : _a.name) === 'InvalidStateError') {
+                context.log('error', `findOne query failed with InvalidStateError`, request.error);
+                resolve(null);
+            }
+            else {
+                reject(request.error);
+            }
+        };
+    });
+    return result;
+}
+export async function findAllOids({ collection, index, context, }) {
+    const store = getStore(context.documentDb, collection);
+    const source = index ? store.index(index.where) : store;
+    const range = getRange(context.schema, collection, index);
+    const direction = (index === null || index === void 0 ? void 0 : index.order) === 'desc' ? 'prev' : 'next';
+    const request = source.openCursor(range, direction);
+    const result = await new Promise((resolve, reject) => {
+        const results = new Set();
+        request.onsuccess = () => {
+            const cursor = request.result;
+            if (cursor) {
+                results.add(createOid(collection, cursor.primaryKey.toString()));
+                cursor.continue();
+            }
+            else {
+                resolve(Array.from(results));
+            }
+        };
+        request.onerror = () => {
+            var _a;
+            if (((_a = request.error) === null || _a === void 0 ? void 0 : _a.name) === 'InvalidStateError') {
+                context.log('error', `findAll query failed with InvalidStateError`, request.error);
+                resolve([]);
+            }
+            else {
+                reject(request.error);
+            }
+        };
+    });
+    return result;
+}
+export async function findPageOfOids({ collection, index, context, limit, offset, }) {
+    const store = getStore(context.documentDb, collection);
+    const source = index ? store.index(index.where) : store;
+    const range = getRange(context.schema, collection, index);
+    const direction = (index === null || index === void 0 ? void 0 : index.order) === 'desc' ? 'prev' : 'next';
+    const request = source.openCursor(range, direction);
+    let hasDoneOffset = !offset;
+    let hasNextPage = false;
+    let visited = 0;
+    const result = await new Promise((resolve, reject) => {
+        const results = new Set();
+        request.onsuccess = () => {
+            visited++;
+            const cursor = request.result;
+            if (cursor) {
+                if (offset && !hasDoneOffset) {
+                    cursor.advance(offset);
+                    hasDoneOffset = true;
+                }
+                else {
+                    if (limit && results.size < limit) {
+                        results.add(createOid(collection, cursor.primaryKey.toString()));
+                    }
+                    if (limit && visited > limit) {
+                        hasNextPage = true;
+                        resolve(Array.from(results));
+                    }
+                    else {
+                        cursor.continue();
+                    }
+                }
+            }
+            else {
+                resolve(Array.from(results));
+            }
+        };
+        request.onerror = () => {
+            var _a;
+            if (((_a = request.error) === null || _a === void 0 ? void 0 : _a.name) === 'InvalidStateError') {
+                context.log('error', `find query failed with InvalidStateError`, request.error);
+                resolve([]);
+            }
+            else {
+                reject(request.error);
+            }
+        };
+    });
+    return {
+        result: result,
+        hasNextPage,
+    };
+}
 //# sourceMappingURL=dbQueries.js.map

package/dist/esm/queries2/keys.d.ts

@@ -1,10 +1,10 @@
-export interface QueryParams {
-    collection: string;
-    range: IDBKeyRange | IDBValidKey | undefined;
-    index?: string;
-    direction?: IDBCursorDirection;
-    limit?: number;
-    single?: boolean;
-    write?: boolean;
-}
-export declare function getQueryKey({ range, ...rest }: QueryParams): string;
+export interface QueryParams {
+    collection: string;
+    range: IDBKeyRange | IDBValidKey | undefined;
+    index?: string;
+    direction?: IDBCursorDirection;
+    limit?: number;
+    single?: boolean;
+    write?: boolean;
+}
+export declare function getQueryKey({ range, ...rest }: QueryParams): string;

package/dist/esm/queries2/keys.js

@@ -1,30 +1,30 @@
-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;
-};
-import { hashObject } from '@verdant-web/common';
-export function getQueryKey(_a) {
-    var { range } = _a, rest = __rest(_a, ["range"]);
-    let hashedRange;
-    if (range instanceof IDBKeyRange) {
-        hashedRange = hashObject({
-            includes: range.includes,
-            lower: range.lower,
-            lowerOpen: range.lowerOpen,
-            upper: range.upper,
-            upperOpen: range.upperOpen,
-        });
-    }
-    else {
-        hashedRange = range;
-    }
-    return hashObject(Object.assign({ range: hashedRange }, rest));
-}
+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;
+};
+import { hashObject } from '@verdant-web/common';
+export function getQueryKey(_a) {
+    var { range } = _a, rest = __rest(_a, ["range"]);
+    let hashedRange;
+    if (range instanceof IDBKeyRange) {
+        hashedRange = hashObject({
+            includes: range.includes,
+            lower: range.lower,
+            lowerOpen: range.lowerOpen,
+            upper: range.upper,
+            upperOpen: range.upperOpen,
+        });
+    }
+    else {
+        hashedRange = range;
+    }
+    return hashObject(Object.assign({ range: hashedRange }, rest));
+}
 //# sourceMappingURL=keys.js.map

package/dist/esm/queries2/ranges.d.ts

@@ -1,2 +1,2 @@
-import { CollectionFilter, StorageSchema } from '@verdant-web/common';
-export declare function getRange(schema: StorageSchema, collection: string, index?: CollectionFilter): IDBKeyRange | undefined;
+import { CollectionFilter, StorageSchema } from '@verdant-web/common';
+export declare function getRange(schema: StorageSchema, collection: string, index?: CollectionFilter): IDBKeyRange | undefined;

package/dist/esm/queries2/ranges.js

@@ -1,66 +1,66 @@
-import { assert, createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, isMatchIndexFilter, isRangeIndexFilter, isSortIndexFilter, isStartsWithIndexFilter, sanitizeIndexValue, } from '@verdant-web/common';
-const matchIndexToIdbKeyRange = (filter) => {
-    return IDBKeyRange.only(sanitizeIndexValue(filter.equals));
-};
-const sortIndexToIdbKeyRange = (filter) => {
-    return undefined;
-};
-const rangeIndexToIdbKeyRange = (filter) => {
-    const lower = filter.gte || filter.gt;
-    const upper = filter.lte || filter.lt;
-    if (lower === upper) {
-        return IDBKeyRange.only(sanitizeIndexValue(lower));
-    }
-    if (!lower) {
-        return IDBKeyRange.upperBound(sanitizeIndexValue(upper), !!filter.lt);
-    }
-    else if (!upper) {
-        return IDBKeyRange.lowerBound(sanitizeIndexValue(lower), !!filter.gt);
-    }
-    else {
-        return IDBKeyRange.bound(sanitizeIndexValue(lower), sanitizeIndexValue(upper), !!filter.gt, !!filter.lt);
-    }
-};
-const compoundIndexToIdbKeyRange = (
-// FIXME:
-schema, collection, filter) => {
-    // validate the usage of the compound index:
-    // - all match fields must be contiguous at the start of the compound order
-    const indexDefinition = schema.collections[collection].compounds[filter.where];
-    assert(indexDefinition, `Index ${filter.where} does not exist on collection ${collection}`);
-    const matchedKeys = Object.keys(filter.match).sort((a, b) => indexDefinition.of.indexOf(a) - indexDefinition.of.indexOf(b));
-    for (const key of matchedKeys) {
-        if (indexDefinition.of.indexOf(key) !== matchedKeys.indexOf(key)) {
-            throw new Error(`Compound index ${filter.where} does not have ${key} at the start of its order`);
-        }
-    }
-    const matchedValues = matchedKeys.map((key) => filter.match[key]);
-    // special case: all match fields are specified - we don't need a range
-    // query, just a single key query
-    if (matchedKeys.length === indexDefinition.of.length) {
-        return IDBKeyRange.only(createCompoundIndexValue(...matchedValues));
-    }
-    // create our bounds for the matched values
-    const lower = createLowerBoundIndexValue(...matchedValues);
-    const upper = createUpperBoundIndexValue(...matchedValues);
-    return IDBKeyRange.bound(lower, upper);
-};
-function startsWithIndexToIdbKeyRange(filter) {
-    const lower = filter.startsWith;
-    const upper = filter.startsWith + '\uffff';
-    return IDBKeyRange.bound(lower, upper);
-}
-export function getRange(schema, collection, index) {
-    if (!index)
-        return undefined;
-    if (isRangeIndexFilter(index))
-        return rangeIndexToIdbKeyRange(index);
-    if (isMatchIndexFilter(index))
-        return matchIndexToIdbKeyRange(index);
-    if (isSortIndexFilter(index))
-        return sortIndexToIdbKeyRange(index);
-    if (isStartsWithIndexFilter(index))
-        return startsWithIndexToIdbKeyRange(index);
-    return compoundIndexToIdbKeyRange(schema, collection, index);
-}
+import { assert, createCompoundIndexValue, createLowerBoundIndexValue, createUpperBoundIndexValue, isMatchIndexFilter, isRangeIndexFilter, isSortIndexFilter, isStartsWithIndexFilter, sanitizeIndexValue, } from '@verdant-web/common';
+const matchIndexToIdbKeyRange = (filter) => {
+    return IDBKeyRange.only(sanitizeIndexValue(filter.equals));
+};
+const sortIndexToIdbKeyRange = (filter) => {
+    return undefined;
+};
+const rangeIndexToIdbKeyRange = (filter) => {
+    const lower = filter.gte || filter.gt;
+    const upper = filter.lte || filter.lt;
+    if (lower === upper) {
+        return IDBKeyRange.only(sanitizeIndexValue(lower));
+    }
+    if (!lower) {
+        return IDBKeyRange.upperBound(sanitizeIndexValue(upper), !!filter.lt);
+    }
+    else if (!upper) {
+        return IDBKeyRange.lowerBound(sanitizeIndexValue(lower), !!filter.gt);
+    }
+    else {
+        return IDBKeyRange.bound(sanitizeIndexValue(lower), sanitizeIndexValue(upper), !!filter.gt, !!filter.lt);
+    }
+};
+const compoundIndexToIdbKeyRange = (
+// FIXME:
+schema, collection, filter) => {
+    // validate the usage of the compound index:
+    // - all match fields must be contiguous at the start of the compound order
+    const indexDefinition = schema.collections[collection].compounds[filter.where];
+    assert(indexDefinition, `Index ${filter.where} does not exist on collection ${collection}`);
+    const matchedKeys = Object.keys(filter.match).sort((a, b) => indexDefinition.of.indexOf(a) - indexDefinition.of.indexOf(b));
+    for (const key of matchedKeys) {
+        if (indexDefinition.of.indexOf(key) !== matchedKeys.indexOf(key)) {
+            throw new Error(`Compound index ${filter.where} does not have ${key} at the start of its order`);
+        }
+    }
+    const matchedValues = matchedKeys.map((key) => filter.match[key]);
+    // special case: all match fields are specified - we don't need a range
+    // query, just a single key query
+    if (matchedKeys.length === indexDefinition.of.length) {
+        return IDBKeyRange.only(createCompoundIndexValue(...matchedValues));
+    }
+    // create our bounds for the matched values
+    const lower = createLowerBoundIndexValue(...matchedValues);
+    const upper = createUpperBoundIndexValue(...matchedValues);
+    return IDBKeyRange.bound(lower, upper);
+};
+function startsWithIndexToIdbKeyRange(filter) {
+    const lower = filter.startsWith;
+    const upper = filter.startsWith + '\uffff';
+    return IDBKeyRange.bound(lower, upper);
+}
+export function getRange(schema, collection, index) {
+    if (!index)
+        return undefined;
+    if (isRangeIndexFilter(index))
+        return rangeIndexToIdbKeyRange(index);
+    if (isMatchIndexFilter(index))
+        return matchIndexToIdbKeyRange(index);
+    if (isSortIndexFilter(index))
+        return sortIndexToIdbKeyRange(index);
+    if (isStartsWithIndexFilter(index))
+        return startsWithIndexToIdbKeyRange(index);
+    return compoundIndexToIdbKeyRange(schema, collection, index);
+}
 //# sourceMappingURL=ranges.js.map

package/dist/esm/queries2/types.d.ts

@@ -1,6 +1,6 @@
-import type { FindAllQuery } from './FindAllQuery.js';
-import type { FindPageQuery } from './FindPageQuery.js';
-import type { FindOneQuery } from './FindOneQuery.js';
-import type { FindInfiniteQuery } from './FindInfiniteQuery.js';
-import type { GetQuery } from './GetQuery.js';
-export type Query<T> = FindAllQuery<T> | FindPageQuery<T> | FindOneQuery<T> | FindInfiniteQuery<T> | GetQuery<T>;
+import type { FindAllQuery } from './FindAllQuery.js';
+import type { FindPageQuery } from './FindPageQuery.js';
+import type { FindOneQuery } from './FindOneQuery.js';
+import type { FindInfiniteQuery } from './FindInfiniteQuery.js';
+import type { GetQuery } from './GetQuery.js';
+export type Query<T> = FindAllQuery<T> | FindPageQuery<T> | FindOneQuery<T> | FindInfiniteQuery<T> | GetQuery<T>;

package/dist/esm/queries2/types.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=types.js.map

package/dist/esm/queries2/utils.d.ts

@@ -1 +1 @@
-export declare function filterResultSet(results: any): any;
+export declare function filterResultSet(results: any): any;

package/dist/esm/queries2/utils.js

@@ -1,16 +1,16 @@
-import { Entity } from '../reactives/Entity.js';
-function existsFilter(x) {
-    return x !== null;
-}
-export function filterResultSet(results) {
-    if (Array.isArray(results)) {
-        return results.map(filterResultSet).filter(existsFilter);
-    }
-    else if (results instanceof Entity) {
-        return results.deleted ? null : results;
-    }
-    else {
-        return results;
-    }
-}
+import { Entity } from '../reactives/Entity.js';
+function existsFilter(x) {
+    return x !== null;
+}
+export function filterResultSet(results) {
+    if (Array.isArray(results)) {
+        return results.map(filterResultSet).filter(existsFilter);
+    }
+    else if (results instanceof Entity) {
+        return results.deleted ? null : results;
+    }
+    else {
+        return results;
+    }
+}
 //# sourceMappingURL=utils.js.map

package/dist/esm/reactives/DocumentFamiliyCache.d.ts

@@ -1,47 +1,51 @@
-import { DocumentBaseline, EventSubscriber, ObjectIdentifier, Operation, StorageFieldSchema } from '@verdant-web/common';
-import { Entity } from './Entity.js';
-import type { EntityStore } from './EntityStore.js';
-import { Context } from '../context.js';
-export declare class DocumentFamilyCache extends EventSubscriber<Record<`change:${string}`, () => void> & {
-    'change:*': (oid: ObjectIdentifier) => void;
-}> {
-    readonly oid: ObjectIdentifier;
-    private operationsMap;
-    private unconfirmedOperationsMap;
-    private baselinesMap;
-    private entities;
-    private context;
-    private storeTools;
-    constructor({ oid, store, context, }: {
-        oid: ObjectIdentifier;
-        store: EntityStore;
-        context: Context;
-    });
-    insertUnconfirmedOperations: (operations: Operation[]) => void;
-    insertOperations: (operations: Operation[], info: {
-        isLocal: boolean;
-        affectedOids?: Set<ObjectIdentifier>;
-    }) => void;
-    insertBaselines: (baselines: DocumentBaseline[], { affectedOids, }: {
-        isLocal: boolean;
-        affectedOids?: Set<string> | undefined;
-    }) => void;
-    addConfirmedData: ({ operations, baselines, reset, isLocal, }: {
-        operations: Operation[];
-        baselines: DocumentBaseline[];
-        reset?: boolean | undefined;
-        isLocal?: boolean | undefined;
-    }) => void;
-    private applyOperations;
-    computeView: (oid: ObjectIdentifier) => {
-        view: any;
-        deleted: boolean;
-        lastTimestamp: number | null;
-    };
-    computeConfirmedView: (oid: ObjectIdentifier) => any;
-    getLastTimestamp: (oid: ObjectIdentifier) => number | null;
-    getEntity: (oid: ObjectIdentifier, schema: StorageFieldSchema, parent?: Entity) => Entity;
-    hasOid: (oid: ObjectIdentifier) => boolean;
-    dispose: () => void;
-    reset: (operations: Operation[], baselines: DocumentBaseline[]) => void;
-}
+import { DocumentBaseline, EventSubscriber, ObjectIdentifier, Operation, StorageFieldSchema } from '@verdant-web/common';
+import { Entity } from './Entity.js';
+import type { EntityStore } from './EntityStore.js';
+import { Context } from '../context.js';
+export declare class DocumentFamilyCache extends EventSubscriber<Record<`change:${string}`, () => void> & {
+    'change:*': (oid: ObjectIdentifier) => void;
+}> {
+    readonly oid: ObjectIdentifier;
+    private operationsMap;
+    private unconfirmedOperationsMap;
+    private baselinesMap;
+    private entities;
+    private context;
+    private storeTools;
+    constructor({ oid, store, context, }: {
+        oid: ObjectIdentifier;
+        store: EntityStore;
+        context: Context;
+    });
+    insertUnconfirmedOperations: (operations: Operation[]) => void;
+    insertOperations: (operations: Operation[], info: {
+        isLocal: boolean;
+        affectedOids?: Set<ObjectIdentifier>;
+    }) => void;
+    /**
+     * Insert new baselines for objects in this family.
+     * Automatically drops operations before the new baseline.
+     */
+    insertBaselines: (baselines: DocumentBaseline[], { affectedOids, }: {
+        isLocal: boolean;
+        affectedOids?: Set<string> | undefined;
+    }) => void;
+    addConfirmedData: ({ operations, baselines, reset, isLocal, }: {
+        operations: Operation[];
+        baselines: DocumentBaseline[];
+        reset?: boolean | undefined;
+        isLocal?: boolean | undefined;
+    }) => void;
+    private applyOperations;
+    computeView: (oid: ObjectIdentifier) => {
+        view: any;
+        deleted: boolean;
+        lastTimestamp: number | null;
+    };
+    computeConfirmedView: (oid: ObjectIdentifier) => any;
+    getLastTimestamp: (oid: ObjectIdentifier) => number | null;
+    getEntity: (oid: ObjectIdentifier, schema: StorageFieldSchema, parent?: Entity) => Entity;
+    hasOid: (oid: ObjectIdentifier) => boolean;
+    dispose: () => void;
+    reset: (operations: Operation[], baselines: DocumentBaseline[]) => void;
+}