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

package/dist/cjs/metadata/MessageCreator.js

@@ -1,128 +1,128 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageCreator = void 0;
-const common_1 = require("@verdant-web/common");
-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((0, common_1.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((0, common_1.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,
-            };
-        };
-    }
-}
-exports.MessageCreator = MessageCreator;
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCreator = void 0;
+const common_1 = require("@verdant-web/common");
+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((0, common_1.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((0, common_1.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,
+            };
+        };
+    }
+}
+exports.MessageCreator = MessageCreator;
 //# sourceMappingURL=MessageCreator.js.map

package/dist/cjs/metadata/Metadata.d.ts

@@ -1,112 +1,112 @@
-import { ClientMessage, DocumentBaseline, EventSubscriber, FileRef, HybridLogicalClockTimestampProvider, ObjectIdentifier, Operation, PatchCreator, StorageSchema } from '@verdant-web/common';
-import { AckInfoStore } from './AckInfoStore.js';
-import { BaselinesStore } from './BaselinesStore.js';
-import { LocalReplicaInfo, LocalReplicaStore } from './LocalReplicaStore.js';
-import { MessageCreator } from './MessageCreator.js';
-import { OperationsStore } from './OperationsStore.js';
-import { SchemaStore } from './SchemaStore.js';
-import { Context } from '../context.js';
-export interface ExportData {
-    operations: Operation[];
-    baselines: DocumentBaseline[];
-    localReplica: LocalReplicaInfo;
-    schema: StorageSchema;
-}
-export declare class Metadata extends EventSubscriber<{
-    message: (message: ClientMessage) => void;
-    rebase: (baselines: DocumentBaseline[]) => void;
-    filesDeleted: (files: FileRef[]) => void;
-}> {
-    readonly operations: OperationsStore;
-    readonly baselines: BaselinesStore;
-    readonly localReplica: LocalReplicaStore;
-    readonly ackInfo: AckInfoStore;
-    readonly messageCreator: MessageCreator;
-    readonly patchCreator: PatchCreator;
-    readonly schema: SchemaStore;
-    readonly time: HybridLogicalClockTimestampProvider;
-    private readonly disableRebasing;
-    /**
-     * indicates the client is shutting down and we should stop
-     * accessing the database.
-     */
-    private _closing;
-    private context;
-    constructor({ disableRebasing, context, }: {
-        disableRebasing?: boolean;
-        context: Omit<Context, 'documentDb'>;
-    });
-    private get db();
-    private get log();
-    setContext: (context: Context) => void;
-    get now(): string;
-    close: () => void;
-    /**
-     * Methods for accessing data
-     */
-    createTransaction: (stores: ('operations' | 'baselines')[]) => IDBTransaction;
-    /**
-     * Gets the OID and every sub-object OID for a given document.
-     * Includes any sub-objects that are not referenced by the root object
-     * but still happen to be in storage.
-     */
-    getAllDocumentRelatedOids: (oid: ObjectIdentifier) => Promise<string[]>;
-    getDocumentSnapshot: (oid: ObjectIdentifier, options?: {
-        to?: string;
-    }) => Promise<any>;
-    /**
-     * Methods for writing data
-     */
-    /**
-     * Acks that we have seen a timestamp to the server
-     * and stores it as our local ackedLogicalTime if it's
-     * greater than our current ackedLogicalTime.
-     */
-    ack: (timestamp: string) => Promise<void>;
-    /**
-     * Applies a patch to the document and stores it in the database.
-     * @returns the oldest local history timestamp
-     */
-    insertLocalOperation: (operations: Operation[]) => Promise<void>;
-    /**
-     * Inserts remote operations. This does not affect local history.
-     * @returns a list of affected document OIDs
-     */
-    insertRemoteOperations: (operations: Operation[]) => Promise<string[]>;
-    insertRemoteBaselines: (baselines: DocumentBaseline[]) => Promise<string[]>;
-    updateLastSynced: (timestamp: string) => Promise<void>;
-    lastSyncedTimestamp: () => Promise<string | null>;
-    private tryAutonomousRebase;
-    /**
-     * Attempt to autonomously rebase local documents without server intervention.
-     * This can currently only happen for a client who has never synced before.
-     * The goal is to allow local-only clients to compress their history to exactly
-     * their undo stack.
-     */
-    private runRebase;
-    rebase: (oid: ObjectIdentifier, upTo: string, providedTx?: IDBTransaction) => Promise<{
-        oid: string;
-        snapshot: any;
-        timestamp: string;
-    }>;
-    reset: () => Promise<void>;
-    updateSchema: (schema: StorageSchema, overrideConflict?: number) => Promise<void>;
-    setGlobalAck: (timestamp: string) => Promise<void>;
-    export: () => Promise<ExportData>;
-    /**
-     * Resets local metadata and clears operation/baseline stores.
-     * DOES NOT add operations/baselines - this should be done
-     * through the normal higher level systems.
-     */
-    resetFrom: (data: ExportData) => Promise<void>;
-    stats: () => Promise<{
-        operationsSize: {
-            count: number;
-            size: number;
-        };
-        baselinesSize: {
-            count: number;
-            size: number;
-        };
-    }>;
-}
+import { ClientMessage, DocumentBaseline, EventSubscriber, FileRef, HybridLogicalClockTimestampProvider, ObjectIdentifier, Operation, PatchCreator, StorageSchema } from '@verdant-web/common';
+import { AckInfoStore } from './AckInfoStore.js';
+import { BaselinesStore } from './BaselinesStore.js';
+import { LocalReplicaInfo, LocalReplicaStore } from './LocalReplicaStore.js';
+import { MessageCreator } from './MessageCreator.js';
+import { OperationsStore } from './OperationsStore.js';
+import { SchemaStore } from './SchemaStore.js';
+import { Context } from '../context.js';
+export interface ExportData {
+    operations: Operation[];
+    baselines: DocumentBaseline[];
+    localReplica: LocalReplicaInfo;
+    schema: StorageSchema;
+}
+export declare class Metadata extends EventSubscriber<{
+    message: (message: ClientMessage) => void;
+    rebase: (baselines: DocumentBaseline[]) => void;
+    filesDeleted: (files: FileRef[]) => void;
+}> {
+    readonly operations: OperationsStore;
+    readonly baselines: BaselinesStore;
+    readonly localReplica: LocalReplicaStore;
+    readonly ackInfo: AckInfoStore;
+    readonly messageCreator: MessageCreator;
+    readonly patchCreator: PatchCreator;
+    readonly schema: SchemaStore;
+    readonly time: HybridLogicalClockTimestampProvider;
+    private readonly disableRebasing;
+    /**
+     * indicates the client is shutting down and we should stop
+     * accessing the database.
+     */
+    private _closing;
+    private context;
+    constructor({ disableRebasing, context, }: {
+        disableRebasing?: boolean;
+        context: Omit<Context, 'documentDb'>;
+    });
+    private get db();
+    private get log();
+    setContext: (context: Context) => void;
+    get now(): string;
+    close: () => void;
+    /**
+     * Methods for accessing data
+     */
+    createTransaction: (stores: ('operations' | 'baselines')[]) => IDBTransaction;
+    /**
+     * Gets the OID and every sub-object OID for a given document.
+     * Includes any sub-objects that are not referenced by the root object
+     * but still happen to be in storage.
+     */
+    getAllDocumentRelatedOids: (oid: ObjectIdentifier) => Promise<string[]>;
+    getDocumentSnapshot: (oid: ObjectIdentifier, options?: {
+        to?: string;
+    }) => Promise<any>;
+    /**
+     * Methods for writing data
+     */
+    /**
+     * Acks that we have seen a timestamp to the server
+     * and stores it as our local ackedLogicalTime if it's
+     * greater than our current ackedLogicalTime.
+     */
+    ack: (timestamp: string) => Promise<void>;
+    /**
+     * Applies a patch to the document and stores it in the database.
+     * @returns the oldest local history timestamp
+     */
+    insertLocalOperation: (operations: Operation[]) => Promise<void>;
+    /**
+     * Inserts remote operations. This does not affect local history.
+     * @returns a list of affected document OIDs
+     */
+    insertRemoteOperations: (operations: Operation[]) => Promise<string[]>;
+    insertRemoteBaselines: (baselines: DocumentBaseline[]) => Promise<string[]>;
+    updateLastSynced: (timestamp: string) => Promise<void>;
+    lastSyncedTimestamp: () => Promise<string | null>;
+    private tryAutonomousRebase;
+    /**
+     * Attempt to autonomously rebase local documents without server intervention.
+     * This can currently only happen for a client who has never synced before.
+     * The goal is to allow local-only clients to compress their history to exactly
+     * their undo stack.
+     */
+    private runRebase;
+    rebase: (oid: ObjectIdentifier, upTo: string, providedTx?: IDBTransaction) => Promise<{
+        oid: string;
+        snapshot: any;
+        timestamp: string;
+    }>;
+    reset: () => Promise<void>;
+    updateSchema: (schema: StorageSchema, overrideConflict?: number) => Promise<void>;
+    setGlobalAck: (timestamp: string) => Promise<void>;
+    export: () => Promise<ExportData>;
+    /**
+     * Resets local metadata and clears operation/baseline stores.
+     * DOES NOT add operations/baselines - this should be done
+     * through the normal higher level systems.
+     */
+    resetFrom: (data: ExportData) => Promise<void>;
+    stats: () => Promise<{
+        operationsSize: {
+            count: number;
+            size: number;
+        };
+        baselinesSize: {
+            count: number;
+            size: number;
+        };
+    }>;
+}