@verdant-web/store 2.0.1 → 2.0.3

package/dist/esm/metadata/BaselinesStore.js

@@ -1,56 +1,56 @@
-import { getOidRange, } from '@verdant-web/common';
-import { IDBService } from '../IDBService.js';
-export class BaselinesStore extends IDBService {
-    constructor(db) {
-        super(db);
-        this.getAllForDocument = async (oid, { mode = 'readonly', transaction, } = {}) => {
-            const baselines = [];
-            await this.iterateOverAllForDocument(oid, (baseline) => {
-                baselines.push(baseline);
-            }, { mode, transaction });
-            return baselines;
-        };
-        this.iterateOverAllForDocument = async (oid, iterator, { mode = 'readonly', transaction, } = {}) => {
-            return this.iterate('baselines', (store) => {
-                const [start, end] = getOidRange(oid);
-                return store.openCursor(IDBKeyRange.bound(start, end, false, false));
-            }, iterator, mode, transaction);
-        };
-        this.getAllForMultipleDocuments = async (docOids, { mode = 'readonly' } = {}) => {
-            const result = await this.runAll('baselines', (store) => {
-                return docOids.map((oid) => {
-                    const [start, end] = getOidRange(oid);
-                    return store.getAll(IDBKeyRange.bound(start, end, false, false));
-                });
-            }, mode);
-            return result.flat();
-        };
-        this.getAllSince = async (timestamp, { mode = 'readonly' } = {}) => {
-            return this.run('baselines', (store) => {
-                const range = timestamp
-                    ? IDBKeyRange.lowerBound(timestamp, true)
-                    : undefined;
-                const index = store.index('timestamp');
-                return index.getAll(range);
-            }, mode);
-        };
-        this.get = async (oid, { transaction, mode = 'readonly', } = {}) => {
-            return this.run('baselines', (store) => store.get(oid), mode, transaction);
-        };
-        this.set = async (baseline, { transaction } = {}) => {
-            await this.run('baselines', (store) => store.put(baseline), 'readwrite', transaction);
-        };
-        this.setAll = async (baselines, { transaction } = {}) => {
-            await this.runAll('baselines', (store) => {
-                return baselines.map((baseline) => store.put(baseline));
-            }, 'readwrite', transaction);
-        };
-        this.reset = () => {
-            return this.clear('baselines');
-        };
-        this.delete = async (oid, { transaction }) => {
-            await this.run('baselines', (store) => store.delete(oid), 'readwrite', transaction);
-        };
-    }
-}
+import { getOidRange, } from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+export class BaselinesStore extends IDBService {
+    constructor(db) {
+        super(db);
+        this.getAllForDocument = async (oid, { mode = 'readonly', transaction, } = {}) => {
+            const baselines = [];
+            await this.iterateOverAllForDocument(oid, (baseline) => {
+                baselines.push(baseline);
+            }, { mode, transaction });
+            return baselines;
+        };
+        this.iterateOverAllForDocument = async (oid, iterator, { mode = 'readonly', transaction, } = {}) => {
+            return this.iterate('baselines', (store) => {
+                const [start, end] = getOidRange(oid);
+                return store.openCursor(IDBKeyRange.bound(start, end, false, false));
+            }, iterator, mode, transaction);
+        };
+        this.getAllForMultipleDocuments = async (docOids, { mode = 'readonly' } = {}) => {
+            const result = await this.runAll('baselines', (store) => {
+                return docOids.map((oid) => {
+                    const [start, end] = getOidRange(oid);
+                    return store.getAll(IDBKeyRange.bound(start, end, false, false));
+                });
+            }, mode);
+            return result.flat();
+        };
+        this.getAllSince = async (timestamp, { mode = 'readonly' } = {}) => {
+            return this.run('baselines', (store) => {
+                const range = timestamp
+                    ? IDBKeyRange.lowerBound(timestamp, true)
+                    : undefined;
+                const index = store.index('timestamp');
+                return index.getAll(range);
+            }, mode);
+        };
+        this.get = async (oid, { transaction, mode = 'readonly', } = {}) => {
+            return this.run('baselines', (store) => store.get(oid), mode, transaction);
+        };
+        this.set = async (baseline, { transaction } = {}) => {
+            await this.run('baselines', (store) => store.put(baseline), 'readwrite', transaction);
+        };
+        this.setAll = async (baselines, { transaction } = {}) => {
+            await this.runAll('baselines', (store) => {
+                return baselines.map((baseline) => store.put(baseline));
+            }, 'readwrite', transaction);
+        };
+        this.reset = () => {
+            return this.clear('baselines');
+        };
+        this.delete = async (oid, { transaction }) => {
+            await this.run('baselines', (store) => store.delete(oid), 'readwrite', transaction);
+        };
+    }
+}
 //# sourceMappingURL=BaselinesStore.js.map

package/dist/esm/metadata/LocalReplicaStore.d.ts

@@ -1,17 +1,17 @@
-import { IDBService } from '../IDBService.js';
-export type LocalReplicaInfo = {
-    type: 'localReplicaInfo';
-    id: string;
-    ackedLogicalTime: string | null;
-    lastSyncedLogicalTime: string | null;
-};
-export declare class LocalReplicaStore extends IDBService {
-    private cached;
-    get: ({ transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<LocalReplicaInfo>;
-    update: (data: Partial<LocalReplicaInfo>, { transaction }?: {
-        transaction?: IDBTransaction | undefined;
-    }) => Promise<void>;
-    reset: () => Promise<void>;
-}
+import { IDBService } from '../IDBService.js';
+export type LocalReplicaInfo = {
+    type: 'localReplicaInfo';
+    id: string;
+    ackedLogicalTime: string | null;
+    lastSyncedLogicalTime: string | null;
+};
+export declare class LocalReplicaStore extends IDBService {
+    private cached;
+    get: ({ transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<LocalReplicaInfo>;
+    update: (data: Partial<LocalReplicaInfo>, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    reset: () => Promise<void>;
+}

package/dist/esm/metadata/LocalReplicaStore.js

@@ -1,41 +1,41 @@
-import cuid from 'cuid';
-import { IDBService } from '../IDBService.js';
-export class LocalReplicaStore extends IDBService {
-    constructor() {
-        super(...arguments);
-        this.get = async ({ transaction } = {}) => {
-            if (this.cached) {
-                return this.cached;
-            }
-            const lookup = await this.run('info', (store) => store.get('localReplicaInfo'), undefined, transaction);
-            if (!lookup) {
-                // create our own replica info now
-                const replicaId = cuid();
-                const replicaInfo = {
-                    type: 'localReplicaInfo',
-                    id: replicaId,
-                    ackedLogicalTime: null,
-                    lastSyncedLogicalTime: null,
-                };
-                await this.run('info', (store) => store.put(replicaInfo), 'readwrite');
-                this.cached = replicaInfo;
-                return replicaInfo;
-            }
-            this.cached = lookup;
-            return lookup;
-        };
-        this.update = async (data, { transaction } = {}) => {
-            const localReplicaInfo = await this.get({ transaction });
-            Object.assign(localReplicaInfo, data);
-            await this.run('info', (store) => store.put(localReplicaInfo), 'readwrite');
-            this.cached = localReplicaInfo;
-        };
-        this.reset = async () => {
-            const localInfo = await this.get();
-            localInfo.ackedLogicalTime = null;
-            localInfo.lastSyncedLogicalTime = null;
-            await this.run('info', (store) => store.put(localInfo), 'readwrite');
-        };
-    }
-}
+import cuid from 'cuid';
+import { IDBService } from '../IDBService.js';
+export class LocalReplicaStore extends IDBService {
+    constructor() {
+        super(...arguments);
+        this.get = async ({ transaction } = {}) => {
+            if (this.cached) {
+                return this.cached;
+            }
+            const lookup = await this.run('info', (store) => store.get('localReplicaInfo'), undefined, transaction);
+            if (!lookup) {
+                // create our own replica info now
+                const replicaId = cuid();
+                const replicaInfo = {
+                    type: 'localReplicaInfo',
+                    id: replicaId,
+                    ackedLogicalTime: null,
+                    lastSyncedLogicalTime: null,
+                };
+                await this.run('info', (store) => store.put(replicaInfo), 'readwrite');
+                this.cached = replicaInfo;
+                return replicaInfo;
+            }
+            this.cached = lookup;
+            return lookup;
+        };
+        this.update = async (data, { transaction } = {}) => {
+            const localReplicaInfo = await this.get({ transaction });
+            Object.assign(localReplicaInfo, data);
+            await this.run('info', (store) => store.put(localReplicaInfo), 'readwrite');
+            this.cached = localReplicaInfo;
+        };
+        this.reset = async () => {
+            const localInfo = await this.get();
+            localInfo.ackedLogicalTime = null;
+            localInfo.lastSyncedLogicalTime = null;
+            await this.run('info', (store) => store.put(localInfo), 'readwrite');
+        };
+    }
+}
 //# sourceMappingURL=LocalReplicaStore.js.map

package/dist/esm/metadata/MessageCreator.d.ts

@@ -1,19 +1,19 @@
-import { AckMessage, HeartbeatMessage, OperationMessage, PresenceUpdateMessage, SyncMessage } from '@verdant-web/common';
-import { Metadata } from './Metadata.js';
-export declare class MessageCreator {
-    private meta;
-    constructor(meta: Metadata);
-    createOperation: (init: Pick<OperationMessage, 'operations'> & {
-        timestamp?: string;
-    }) => Promise<OperationMessage>;
-    createMigrationOperation: ({ targetVersion, ...init }: Pick<OperationMessage, "operations"> & {
-        targetVersion: number;
-    }) => Promise<OperationMessage>;
-    /**
-     * @param since - override local understanding of last sync time
-     */
-    createSyncStep1: (since?: string | null) => Promise<SyncMessage>;
-    createPresenceUpdate: (presence: any) => Promise<PresenceUpdateMessage>;
-    createHeartbeat: () => Promise<HeartbeatMessage>;
-    createAck: (nonce: string) => Promise<AckMessage>;
-}
+import { AckMessage, HeartbeatMessage, OperationMessage, PresenceUpdateMessage, SyncMessage } from '@verdant-web/common';
+import { Metadata } from './Metadata.js';
+export declare class MessageCreator {
+    private meta;
+    constructor(meta: Metadata);
+    createOperation: (init: Pick<OperationMessage, 'operations'> & {
+        timestamp?: string;
+    }) => Promise<OperationMessage>;
+    createMigrationOperation: ({ targetVersion, ...init }: Pick<OperationMessage, "operations"> & {
+        targetVersion: number;
+    }) => Promise<OperationMessage>;
+    /**
+     * @param since - override local understanding of last sync time
+     */
+    createSyncStep1: (since?: string | null) => Promise<SyncMessage>;
+    createPresenceUpdate: (presence: any) => Promise<PresenceUpdateMessage>;
+    createHeartbeat: () => Promise<HeartbeatMessage>;
+    createAck: (nonce: string) => Promise<AckMessage>;
+}

package/dist/esm/metadata/MessageCreator.js

@@ -1,124 +1,124 @@
-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 { getOidRoot, } from '@verdant-web/common';
-export class MessageCreator {
-    constructor(meta) {
-        this.meta = meta;
-        this.createOperation = async (init) => {
-            const localInfo = await this.meta.localReplica.get();
-            return {
-                type: 'op',
-                timestamp: this.meta.now,
-                replicaId: localInfo.id,
-                operations: init.operations.map((op) => ({
-                    data: op.data,
-                    oid: op.oid,
-                    timestamp: op.timestamp,
-                })),
-            };
-        };
-        this.createMigrationOperation = async (_a) => {
-            var { targetVersion } = _a, init = __rest(_a, ["targetVersion"]);
-            const localInfo = await this.meta.localReplica.get();
-            return {
-                type: 'op',
-                operations: init.operations.map((op) => (Object.assign(Object.assign({}, op), { timestamp: this.meta.time.zero(targetVersion) }))),
-                timestamp: this.meta.time.zero(targetVersion),
-                replicaId: localInfo.id,
-            };
-        };
-        /**
-         * @param since - override local understanding of last sync time
-         */
-        this.createSyncStep1 = async (since) => {
-            const localReplicaInfo = await this.meta.localReplica.get();
-            const provideChangesSince = since === null ? null : localReplicaInfo.lastSyncedLogicalTime;
-            // collect all of our operations that are newer than the server's last operation
-            // if server replica isn't stored, we're syncing for the first time.
-            const operations = [];
-            const affectedDocs = new Set();
-            // FIXME: this branch gives bad vibes. should we always
-            // send all operations from other replicas too? is there
-            // ever a case where we have a "since" timestamp and there
-            // are foreign ops that match it?
-            if (provideChangesSince) {
-                await this.meta.operations.iterateOverAllLocalOperations((patch) => {
-                    operations.push({
-                        data: patch.data,
-                        oid: patch.oid,
-                        timestamp: patch.timestamp,
-                    });
-                    affectedDocs.add(getOidRoot(patch.oid));
-                }, {
-                    after: provideChangesSince,
-                    // block on writes to prevent race conditions
-                    mode: 'readwrite',
-                });
-            }
-            else {
-                // if providing the whole history, don't limit to only local
-                // operations
-                await this.meta.operations.iterateOverAllOperations((patch) => {
-                    operations.push({
-                        data: patch.data,
-                        oid: patch.oid,
-                        timestamp: patch.timestamp,
-                    });
-                    affectedDocs.add(getOidRoot(patch.oid));
-                }, {
-                    mode: 'readwrite',
-                });
-            }
-            // we only need to send baselines if we've never synced before
-            let baselines = [];
-            if (!provideChangesSince) {
-                baselines = await this.meta.baselines.getAllSince('');
-            }
-            return {
-                type: 'sync',
-                schemaVersion: this.meta.schema.currentVersion,
-                timestamp: this.meta.now,
-                replicaId: localReplicaInfo.id,
-                resyncAll: !localReplicaInfo.lastSyncedLogicalTime,
-                operations,
-                baselines,
-                since: provideChangesSince,
-            };
-        };
-        this.createPresenceUpdate = async (presence) => {
-            const localReplicaInfo = await this.meta.localReplica.get();
-            return {
-                type: 'presence-update',
-                presence,
-                replicaId: localReplicaInfo.id,
-            };
-        };
-        this.createHeartbeat = async () => {
-            const localReplicaInfo = await this.meta.localReplica.get();
-            return {
-                type: 'heartbeat',
-                timestamp: this.meta.now,
-                replicaId: localReplicaInfo.id,
-            };
-        };
-        this.createAck = async (nonce) => {
-            const localReplicaInfo = await this.meta.localReplica.get();
-            return {
-                type: 'ack',
-                timestamp: this.meta.now,
-                replicaId: localReplicaInfo.id,
-                nonce,
-            };
-        };
-    }
-}
+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 { getOidRoot, } from '@verdant-web/common';
+export class MessageCreator {
+    constructor(meta) {
+        this.meta = meta;
+        this.createOperation = async (init) => {
+            const localInfo = await this.meta.localReplica.get();
+            return {
+                type: 'op',
+                timestamp: this.meta.now,
+                replicaId: localInfo.id,
+                operations: init.operations.map((op) => ({
+                    data: op.data,
+                    oid: op.oid,
+                    timestamp: op.timestamp,
+                })),
+            };
+        };
+        this.createMigrationOperation = async (_a) => {
+            var { targetVersion } = _a, init = __rest(_a, ["targetVersion"]);
+            const localInfo = await this.meta.localReplica.get();
+            return {
+                type: 'op',
+                operations: init.operations.map((op) => (Object.assign(Object.assign({}, op), { timestamp: this.meta.time.zero(targetVersion) }))),
+                timestamp: this.meta.time.zero(targetVersion),
+                replicaId: localInfo.id,
+            };
+        };
+        /**
+         * @param since - override local understanding of last sync time
+         */
+        this.createSyncStep1 = async (since) => {
+            const localReplicaInfo = await this.meta.localReplica.get();
+            const provideChangesSince = since === null ? null : localReplicaInfo.lastSyncedLogicalTime;
+            // collect all of our operations that are newer than the server's last operation
+            // if server replica isn't stored, we're syncing for the first time.
+            const operations = [];
+            const affectedDocs = new Set();
+            // FIXME: this branch gives bad vibes. should we always
+            // send all operations from other replicas too? is there
+            // ever a case where we have a "since" timestamp and there
+            // are foreign ops that match it?
+            if (provideChangesSince) {
+                await this.meta.operations.iterateOverAllLocalOperations((patch) => {
+                    operations.push({
+                        data: patch.data,
+                        oid: patch.oid,
+                        timestamp: patch.timestamp,
+                    });
+                    affectedDocs.add(getOidRoot(patch.oid));
+                }, {
+                    after: provideChangesSince,
+                    // block on writes to prevent race conditions
+                    mode: 'readwrite',
+                });
+            }
+            else {
+                // if providing the whole history, don't limit to only local
+                // operations
+                await this.meta.operations.iterateOverAllOperations((patch) => {
+                    operations.push({
+                        data: patch.data,
+                        oid: patch.oid,
+                        timestamp: patch.timestamp,
+                    });
+                    affectedDocs.add(getOidRoot(patch.oid));
+                }, {
+                    mode: 'readwrite',
+                });
+            }
+            // we only need to send baselines if we've never synced before
+            let baselines = [];
+            if (!provideChangesSince) {
+                baselines = await this.meta.baselines.getAllSince('');
+            }
+            return {
+                type: 'sync',
+                schemaVersion: this.meta.schema.currentVersion,
+                timestamp: this.meta.now,
+                replicaId: localReplicaInfo.id,
+                resyncAll: !localReplicaInfo.lastSyncedLogicalTime,
+                operations,
+                baselines,
+                since: provideChangesSince,
+            };
+        };
+        this.createPresenceUpdate = async (presence) => {
+            const localReplicaInfo = await this.meta.localReplica.get();
+            return {
+                type: 'presence-update',
+                presence,
+                replicaId: localReplicaInfo.id,
+            };
+        };
+        this.createHeartbeat = async () => {
+            const localReplicaInfo = await this.meta.localReplica.get();
+            return {
+                type: 'heartbeat',
+                timestamp: this.meta.now,
+                replicaId: localReplicaInfo.id,
+            };
+        };
+        this.createAck = async (nonce) => {
+            const localReplicaInfo = await this.meta.localReplica.get();
+            return {
+                type: 'ack',
+                timestamp: this.meta.now,
+                replicaId: localReplicaInfo.id,
+                nonce,
+            };
+        };
+    }
+}
 //# sourceMappingURL=MessageCreator.js.map