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

package/dist/esm/entities/DocumentFamiliyCache.js

@@ -1,279 +1,279 @@
-import { applyPatch, assignOid, cloneDeep, compareTimestampSchemaVersions, EventSubscriber, } from '@verdant-web/common';
-import { Entity, refreshEntity } from './Entity.js';
-import { Resolvable } from '../utils/Resolvable.js';
-/**
- * Local operations: operations on this client that haven't
- * yet been synced and are only applied in-memory. These are
- * always applied after all other operations, they are conceptually
- * 'in the future' as they are not yet synced or stored.
- *
- * Confirmed operations: operations that have been synced and
- * stored in the database.
- *
- * Unconfirmed operations: operations received from sync which
- * have not been stored yet and are only in memory. These exist
- * because new incoming operations are synchronously applied to
- * cached entities while storage goes on async.
- */
-export class DocumentFamilyCache extends EventSubscriber {
-    get initializedPromise() {
-        return this._initialized.promise;
-    }
-    constructor({ oid, store, context, }) {
-        super();
-        this.entities = new Map();
-        this._initialized = new Resolvable();
-        this.setInitialized = () => {
-            this._initialized.resolve(true);
-        };
-        this.insertLocalOperations = (operations) => {
-            const oidSet = new Set();
-            for (const operation of operations) {
-                const { oid } = operation;
-                oidSet.add(oid);
-                const existingOperations = this.localOperationsMap.get(oid) || [];
-                existingOperations.push(operation);
-                this.localOperationsMap.set(oid, existingOperations);
-            }
-            for (const oid of oidSet) {
-                const entityRef = this.entities.get(oid);
-                const entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
-                if (entity) {
-                    refreshEntity(entity, { isLocal: true });
-                    this.emit(`change:${oid}`);
-                    this.emit('change:*', oid);
-                }
-            }
-        };
-        this.insertOperations = (operations, info) => {
-            var _a;
-            for (const operation of operations) {
-                const { oid } = operation;
-                (_a = info.affectedOids) === null || _a === void 0 ? void 0 : _a.add(oid);
-                const existingOperations = this.operationsMap.get(oid) || [];
-                // insert in order of timestamp
-                const index = existingOperations.findIndex((op) => op.timestamp >= operation.timestamp);
-                // ensure the operation doesn't already exist in this position
-                if (index !== -1) {
-                    if (existingOperations[index].timestamp === operation.timestamp) {
-                        continue;
-                    }
-                    existingOperations.splice(index, 0, operation);
-                }
-                else {
-                    existingOperations.push(operation);
-                }
-                this.operationsMap.set(oid, existingOperations);
-                // FIXME: seems inefficient
-                const unconfirmedOperations = this.localOperationsMap.get(oid);
-                if (unconfirmedOperations) {
-                    this.localOperationsMap.set(oid, unconfirmedOperations.filter((op) => op.timestamp !== operation.timestamp));
-                }
-            }
-        };
-        /**
-         * Insert new baselines for objects in this family.
-         * Automatically drops operations before the new baseline.
-         */
-        this.insertBaselines = (baselines, { affectedOids, }) => {
-            var _a;
-            for (const baseline of baselines) {
-                const { oid } = baseline;
-                // opt out if our baseline is newer.
-                const existing = this.baselinesMap.get(oid);
-                if ((existing === null || existing === void 0 ? void 0 : existing.timestamp) && existing.timestamp >= baseline.timestamp) {
-                    continue;
-                }
-                affectedOids === null || affectedOids === void 0 ? void 0 : affectedOids.add(oid);
-                this.baselinesMap.set(oid, baseline);
-                // drop operations before the baseline
-                const ops = this.operationsMap.get(oid) || [];
-                while (((_a = ops[0]) === null || _a === void 0 ? void 0 : _a.timestamp) < baseline.timestamp) {
-                    ops.shift();
-                }
-            }
-        };
-        this.addData = ({ operations, baselines, reset, isLocal, }) => {
-            if (reset) {
-                this.operationsMap.clear();
-                this.baselinesMap.clear();
-            }
-            const info = {
-                isLocal: isLocal || false,
-                affectedOids: new Set(),
-            };
-            this.insertBaselines(baselines, info);
-            // for reset scenario, don't immediately update entities;
-            // we will update all of them in one go.
-            this.insertOperations(operations, info);
-            if (reset) {
-                for (const entityRef of this.entities.values()) {
-                    const entity = entityRef.deref();
-                    if (entity) {
-                        refreshEntity(entity, info);
-                    }
-                }
-            }
-            else {
-                for (const oid of info.affectedOids) {
-                    const entityRef = this.entities.get(oid);
-                    const entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
-                    if (entity) {
-                        refreshEntity(entity, info);
-                        this.emit(`change:${oid}`);
-                        this.emit('change:*', oid);
-                    }
-                }
-            }
-        };
-        this.applyOperations = (view, deleted, operations, after) => {
-            let futureSeen = undefined;
-            const now = this.storeTools.now;
-            for (const operation of operations) {
-                if (after && operation.timestamp <= after) {
-                    continue;
-                }
-                if (compareTimestampSchemaVersions(operation.timestamp, now) > 0) {
-                    // we don't apply patches from future versions
-                    futureSeen = operation.timestamp;
-                    continue;
-                }
-                if (operation.data.op === 'delete') {
-                    deleted = true;
-                }
-                else {
-                    view = applyPatch(view, operation.data);
-                    if (operation.data.op === 'initialize') {
-                        deleted = false;
-                    }
-                }
-            }
-            if (futureSeen) {
-                this.context.globalEvents.emit('futureSeen', futureSeen);
-            }
-            return { view, deleted, empty: !view && !operations.length };
-        };
-        this.computeView = (oid) => {
-            if (this.baselinesMap.size === 0 &&
-                this.operationsMap.size === 0 &&
-                this.localOperationsMap.size === 0) {
-                this.context.log('debug', `Entity ${oid} accessed with no data at all`);
-                return { view: null, deleted: true, lastTimestamp: null };
-            }
-            const confirmed = this.computeConfirmedView(oid);
-            const unconfirmedOperations = this.localOperationsMap.get(oid) || [];
-            if (confirmed.empty && !unconfirmedOperations.length) {
-                this.context.log('debug', `Entity ${oid} accessed with no local data at all`);
-                return { view: null, deleted: true, lastTimestamp: null };
-            }
-            let { view, deleted } = this.applyOperations(confirmed.view, confirmed.deleted, unconfirmedOperations);
-            if (view) {
-                assignOid(view, oid);
-            }
-            return { view, deleted, lastTimestamp: this.getLastTimestamp(oid) };
-        };
-        this.computeConfirmedView = (oid) => {
-            const baseline = this.baselinesMap.get(oid);
-            const operations = this.operationsMap.get(oid) || [];
-            const snapshot = cloneDeep((baseline === null || baseline === void 0 ? void 0 : baseline.snapshot) || undefined);
-            const result = this.applyOperations(snapshot, !snapshot, operations, baseline === null || baseline === void 0 ? void 0 : baseline.timestamp);
-            if (result.view) {
-                assignOid(result.view, oid);
-            }
-            if (result.empty) {
-                this.context.log('debug', `Entity ${oid} accessed with no confirmed data`);
-            }
-            return result;
-        };
-        this.getLastTimestamp = (oid) => {
-            var _a, _b, _c;
-            let operations = this.localOperationsMap.get(oid);
-            if (!(operations === null || operations === void 0 ? void 0 : operations.length)) {
-                operations = this.operationsMap.get(oid) || [];
-            }
-            let logicalTimestamp = null;
-            if (operations.length) {
-                logicalTimestamp = (_a = operations[operations.length - 1]) === null || _a === void 0 ? void 0 : _a.timestamp;
-            }
-            else {
-                logicalTimestamp = (_c = (_b = this.baselinesMap.get(oid)) === null || _b === void 0 ? void 0 : _b.timestamp) !== null && _c !== void 0 ? _c : null;
-            }
-            if (!logicalTimestamp)
-                return null;
-            return this.storeTools.time.getWallClockTime(logicalTimestamp);
-        };
-        this.getEntity = (oid, schema, parent, readonlyKeys) => {
-            let entityRef = this.entities.get(oid);
-            let entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
-            if (!entity) {
-                entity = new Entity({
-                    oid,
-                    cache: this,
-                    fieldSchema: schema,
-                    store: this.storeTools,
-                    parent,
-                    readonlyKeys,
-                });
-                // immediately add to cache and queue a removal if nobody subscribed
-                this.entities.set(oid, this.context.weakRef(entity));
-            }
-            return entity;
-        };
-        this.hasOid = (oid) => {
-            return this.operationsMap.has(oid) || this.baselinesMap.has(oid);
-        };
-        this.dispose = () => {
-            this.entities.forEach((entity) => { var _a; return (_a = entity.deref()) === null || _a === void 0 ? void 0 : _a.dispose(); });
-            this.entities.clear();
-        };
-        this.reset = ({ operations, baselines, dropExistingUnconfirmed: dropUnconfirmed = false, unconfirmedOperations, dropAll, }) => {
-            this.context.log('debug', `Resetting cache for ${this.oid} with ${operations.length} ops and ${baselines.length} baselines, dropUnconfirmed=${dropUnconfirmed}`);
-            const info = { isLocal: false, affectedOids: new Set() };
-            // NOTE: not clearing these maps... there are even more
-            // race conditions where we begin opening a cache, queue up a
-            // reset, then receive incoming operations before the reset
-            // actually hits this function, so those incoming ops are
-            // dropped.
-            // FIXME: include this in a future refactor of this
-            // whole system.
-            if (dropAll)
-                this.baselinesMap.clear();
-            this.insertBaselines(baselines, info);
-            if (dropAll)
-                this.operationsMap.clear();
-            this.insertOperations(operations, info);
-            if (unconfirmedOperations || dropUnconfirmed) {
-                this.localOperationsMap.clear();
-                if (unconfirmedOperations) {
-                    this.insertLocalOperations(unconfirmedOperations);
-                }
-            }
-            for (const oid of this.entities.keys()) {
-                const entityRef = this.entities.get(oid);
-                const entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
-                if (entity) {
-                    refreshEntity(entity, info);
-                    this.emit(`change:${oid}`);
-                    this.emit('change:*', oid);
-                }
-            }
-        };
-        this.oid = oid;
-        this.operationsMap = new Map();
-        this.localOperationsMap = new Map();
-        this.baselinesMap = new Map();
-        this.storeTools = {
-            addLocalOperations: store.addLocalOperations,
-            patchCreator: store.meta.patchCreator,
-            addFile: store.files.add,
-            getFile: store.files.get,
-            time: store.meta.time,
-            now: store.meta.now,
-        };
-        this.context = context;
-    }
-    get weakRef() {
-        return this.context.weakRef;
-    }
-}
+import { applyPatch, assignOid, cloneDeep, compareTimestampSchemaVersions, EventSubscriber, } from '@verdant-web/common';
+import { Entity, refreshEntity } from './Entity.js';
+import { Resolvable } from '../utils/Resolvable.js';
+/**
+ * Local operations: operations on this client that haven't
+ * yet been synced and are only applied in-memory. These are
+ * always applied after all other operations, they are conceptually
+ * 'in the future' as they are not yet synced or stored.
+ *
+ * Confirmed operations: operations that have been synced and
+ * stored in the database.
+ *
+ * Unconfirmed operations: operations received from sync which
+ * have not been stored yet and are only in memory. These exist
+ * because new incoming operations are synchronously applied to
+ * cached entities while storage goes on async.
+ */
+export class DocumentFamilyCache extends EventSubscriber {
+    get initializedPromise() {
+        return this._initialized.promise;
+    }
+    constructor({ oid, store, context, }) {
+        super();
+        this.entities = new Map();
+        this._initialized = new Resolvable();
+        this.setInitialized = () => {
+            this._initialized.resolve(true);
+        };
+        this.insertLocalOperations = (operations) => {
+            const oidSet = new Set();
+            for (const operation of operations) {
+                const { oid } = operation;
+                oidSet.add(oid);
+                const existingOperations = this.localOperationsMap.get(oid) || [];
+                existingOperations.push(operation);
+                this.localOperationsMap.set(oid, existingOperations);
+            }
+            for (const oid of oidSet) {
+                const entityRef = this.entities.get(oid);
+                const entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
+                if (entity) {
+                    refreshEntity(entity, { isLocal: true });
+                    this.emit(`change:${oid}`);
+                    this.emit('change:*', oid);
+                }
+            }
+        };
+        this.insertOperations = (operations, info) => {
+            var _a;
+            for (const operation of operations) {
+                const { oid } = operation;
+                (_a = info.affectedOids) === null || _a === void 0 ? void 0 : _a.add(oid);
+                const existingOperations = this.operationsMap.get(oid) || [];
+                // insert in order of timestamp
+                const index = existingOperations.findIndex((op) => op.timestamp >= operation.timestamp);
+                // ensure the operation doesn't already exist in this position
+                if (index !== -1) {
+                    if (existingOperations[index].timestamp === operation.timestamp) {
+                        continue;
+                    }
+                    existingOperations.splice(index, 0, operation);
+                }
+                else {
+                    existingOperations.push(operation);
+                }
+                this.operationsMap.set(oid, existingOperations);
+                // FIXME: seems inefficient
+                const unconfirmedOperations = this.localOperationsMap.get(oid);
+                if (unconfirmedOperations) {
+                    this.localOperationsMap.set(oid, unconfirmedOperations.filter((op) => op.timestamp !== operation.timestamp));
+                }
+            }
+        };
+        /**
+         * Insert new baselines for objects in this family.
+         * Automatically drops operations before the new baseline.
+         */
+        this.insertBaselines = (baselines, { affectedOids, }) => {
+            var _a;
+            for (const baseline of baselines) {
+                const { oid } = baseline;
+                // opt out if our baseline is newer.
+                const existing = this.baselinesMap.get(oid);
+                if ((existing === null || existing === void 0 ? void 0 : existing.timestamp) && existing.timestamp >= baseline.timestamp) {
+                    continue;
+                }
+                affectedOids === null || affectedOids === void 0 ? void 0 : affectedOids.add(oid);
+                this.baselinesMap.set(oid, baseline);
+                // drop operations before the baseline
+                const ops = this.operationsMap.get(oid) || [];
+                while (((_a = ops[0]) === null || _a === void 0 ? void 0 : _a.timestamp) < baseline.timestamp) {
+                    ops.shift();
+                }
+            }
+        };
+        this.addData = ({ operations, baselines, reset, isLocal, }) => {
+            if (reset) {
+                this.operationsMap.clear();
+                this.baselinesMap.clear();
+            }
+            const info = {
+                isLocal: isLocal || false,
+                affectedOids: new Set(),
+            };
+            this.insertBaselines(baselines, info);
+            // for reset scenario, don't immediately update entities;
+            // we will update all of them in one go.
+            this.insertOperations(operations, info);
+            if (reset) {
+                for (const entityRef of this.entities.values()) {
+                    const entity = entityRef.deref();
+                    if (entity) {
+                        refreshEntity(entity, info);
+                    }
+                }
+            }
+            else {
+                for (const oid of info.affectedOids) {
+                    const entityRef = this.entities.get(oid);
+                    const entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
+                    if (entity) {
+                        refreshEntity(entity, info);
+                        this.emit(`change:${oid}`);
+                        this.emit('change:*', oid);
+                    }
+                }
+            }
+        };
+        this.applyOperations = (view, deleted, operations, after) => {
+            let futureSeen = undefined;
+            const now = this.storeTools.now;
+            for (const operation of operations) {
+                if (after && operation.timestamp <= after) {
+                    continue;
+                }
+                if (compareTimestampSchemaVersions(operation.timestamp, now) > 0) {
+                    // we don't apply patches from future versions
+                    futureSeen = operation.timestamp;
+                    continue;
+                }
+                if (operation.data.op === 'delete') {
+                    deleted = true;
+                }
+                else {
+                    view = applyPatch(view, operation.data);
+                    if (operation.data.op === 'initialize') {
+                        deleted = false;
+                    }
+                }
+            }
+            if (futureSeen) {
+                this.context.globalEvents.emit('futureSeen', futureSeen);
+            }
+            return { view, deleted, empty: !view && !operations.length };
+        };
+        this.computeView = (oid) => {
+            if (this.baselinesMap.size === 0 &&
+                this.operationsMap.size === 0 &&
+                this.localOperationsMap.size === 0) {
+                this.context.log('debug', `Entity ${oid} accessed with no data at all`);
+                return { view: null, deleted: true, lastTimestamp: null };
+            }
+            const confirmed = this.computeConfirmedView(oid);
+            const unconfirmedOperations = this.localOperationsMap.get(oid) || [];
+            if (confirmed.empty && !unconfirmedOperations.length) {
+                this.context.log('debug', `Entity ${oid} accessed with no local data at all`);
+                return { view: null, deleted: true, lastTimestamp: null };
+            }
+            let { view, deleted } = this.applyOperations(confirmed.view, confirmed.deleted, unconfirmedOperations);
+            if (view) {
+                assignOid(view, oid);
+            }
+            return { view, deleted, lastTimestamp: this.getLastTimestamp(oid) };
+        };
+        this.computeConfirmedView = (oid) => {
+            const baseline = this.baselinesMap.get(oid);
+            const operations = this.operationsMap.get(oid) || [];
+            const snapshot = cloneDeep((baseline === null || baseline === void 0 ? void 0 : baseline.snapshot) || undefined);
+            const result = this.applyOperations(snapshot, !snapshot, operations, baseline === null || baseline === void 0 ? void 0 : baseline.timestamp);
+            if (result.view) {
+                assignOid(result.view, oid);
+            }
+            if (result.empty) {
+                this.context.log('debug', `Entity ${oid} accessed with no confirmed data`);
+            }
+            return result;
+        };
+        this.getLastTimestamp = (oid) => {
+            var _a, _b, _c;
+            let operations = this.localOperationsMap.get(oid);
+            if (!(operations === null || operations === void 0 ? void 0 : operations.length)) {
+                operations = this.operationsMap.get(oid) || [];
+            }
+            let logicalTimestamp = null;
+            if (operations.length) {
+                logicalTimestamp = (_a = operations[operations.length - 1]) === null || _a === void 0 ? void 0 : _a.timestamp;
+            }
+            else {
+                logicalTimestamp = (_c = (_b = this.baselinesMap.get(oid)) === null || _b === void 0 ? void 0 : _b.timestamp) !== null && _c !== void 0 ? _c : null;
+            }
+            if (!logicalTimestamp)
+                return null;
+            return this.storeTools.time.getWallClockTime(logicalTimestamp);
+        };
+        this.getEntity = (oid, schema, parent, readonlyKeys) => {
+            let entityRef = this.entities.get(oid);
+            let entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
+            if (!entity) {
+                entity = new Entity({
+                    oid,
+                    cache: this,
+                    fieldSchema: schema,
+                    store: this.storeTools,
+                    parent,
+                    readonlyKeys,
+                });
+                // immediately add to cache and queue a removal if nobody subscribed
+                this.entities.set(oid, this.context.weakRef(entity));
+            }
+            return entity;
+        };
+        this.hasOid = (oid) => {
+            return this.operationsMap.has(oid) || this.baselinesMap.has(oid);
+        };
+        this.dispose = () => {
+            this.entities.forEach((entity) => { var _a; return (_a = entity.deref()) === null || _a === void 0 ? void 0 : _a.dispose(); });
+            this.entities.clear();
+        };
+        this.reset = ({ operations, baselines, dropExistingUnconfirmed: dropUnconfirmed = false, unconfirmedOperations, dropAll, }) => {
+            this.context.log('debug', `Resetting cache for ${this.oid} with ${operations.length} ops and ${baselines.length} baselines, dropUnconfirmed=${dropUnconfirmed}`);
+            const info = { isLocal: false, affectedOids: new Set() };
+            // NOTE: not clearing these maps... there are even more
+            // race conditions where we begin opening a cache, queue up a
+            // reset, then receive incoming operations before the reset
+            // actually hits this function, so those incoming ops are
+            // dropped.
+            // FIXME: include this in a future refactor of this
+            // whole system.
+            if (dropAll)
+                this.baselinesMap.clear();
+            this.insertBaselines(baselines, info);
+            if (dropAll)
+                this.operationsMap.clear();
+            this.insertOperations(operations, info);
+            if (unconfirmedOperations || dropUnconfirmed) {
+                this.localOperationsMap.clear();
+                if (unconfirmedOperations) {
+                    this.insertLocalOperations(unconfirmedOperations);
+                }
+            }
+            for (const oid of this.entities.keys()) {
+                const entityRef = this.entities.get(oid);
+                const entity = entityRef === null || entityRef === void 0 ? void 0 : entityRef.deref();
+                if (entity) {
+                    refreshEntity(entity, info);
+                    this.emit(`change:${oid}`);
+                    this.emit('change:*', oid);
+                }
+            }
+        };
+        this.oid = oid;
+        this.operationsMap = new Map();
+        this.localOperationsMap = new Map();
+        this.baselinesMap = new Map();
+        this.storeTools = {
+            addLocalOperations: store.addLocalOperations,
+            patchCreator: store.meta.patchCreator,
+            addFile: store.files.add,
+            getFile: store.files.get,
+            time: store.meta.time,
+            now: store.meta.now,
+        };
+        this.context = context;
+    }
+    get weakRef() {
+        return this.context.weakRef;
+    }
+}
 //# sourceMappingURL=DocumentFamiliyCache.js.map