@automerge/automerge-repo 2.0.0-alpha.6 → 2.0.0-collectionsync-alpha.1

package/dist/synchronizer/CollectionSynchronizer.js

@@ -1,10 +1,11 @@
 import debug from "debug";
-import { stringifyAutomergeUrl } from "../AutomergeUrl.js";
+import { parseAutomergeUrl, stringifyAutomergeUrl } from "../AutomergeUrl.js";
 import { DocSynchronizer } from "./DocSynchronizer.js";
 import { Synchronizer } from "./Synchronizer.js";
 const log = debug("automerge-repo:collectionsync");
 /** A CollectionSynchronizer is responsible for synchronizing a DocCollection with peers. */
 export class CollectionSynchronizer extends Synchronizer {
+    beelay;
     repo;
     /** The set of peers we are connected with */
     #peers = new Set();
@@ -13,9 +14,12 @@ export class CollectionSynchronizer extends Synchronizer {
     docSynchronizers = {};
     /** Used to determine if the document is know to the Collection and a synchronizer exists or is being set up */
     #docSetUp = {};
-    constructor(repo) {
+    #denylist;
+    constructor(beelay, repo, denylist = []) {
         super();
+        this.beelay = beelay;
         this.repo = repo;
+        this.#denylist = denylist.map(url => parseAutomergeUrl(url).documentId);
     }
     /** Returns a synchronizer for the given document, creating one if it doesn't already exist.  */
     #fetchDocSynchronizer(documentId) {
@@ -28,21 +32,13 @@ export class CollectionSynchronizer extends Synchronizer {
     /** Creates a new docSynchronizer and sets it up to propagate messages */
     #initDocSynchronizer(handle) {
         const docSynchronizer = new DocSynchronizer({
+            beelay: this.beelay,
             handle,
-            onLoadSyncState: async (peerId) => {
-                if (!this.repo.storageSubsystem) {
-                    return;
-                }
-                const { storageId, isEphemeral } = this.repo.peerMetadataByPeerId[peerId] || {};
-                if (!storageId || isEphemeral) {
-                    return;
-                }
-                return this.repo.storageSubsystem.loadSyncState(handle.documentId, storageId);
-            },
         });
         docSynchronizer.on("message", event => this.emit("message", event));
         docSynchronizer.on("open-doc", event => this.emit("open-doc", event));
         docSynchronizer.on("sync-state", event => this.emit("sync-state", event));
+        docSynchronizer.on("metrics", event => this.emit("metrics", event));
         return docSynchronizer;
     }
     /** returns an array of peerIds that we share this document generously with */
@@ -67,6 +63,18 @@ export class CollectionSynchronizer extends Synchronizer {
         if (!documentId) {
             throw new Error("received a message with an invalid documentId");
         }
+        if (this.#denylist.includes(documentId)) {
+            this.emit("metrics", {
+                type: "doc-denied",
+                documentId,
+            });
+            this.emit("message", {
+                type: "doc-unavailable",
+                documentId,
+                targetId: message.senderId,
+            });
+            return;
+        }
         this.#docSetUp[documentId] = true;
         const docSynchronizer = this.#fetchDocSynchronizer(documentId);
         docSynchronizer.receiveMessage(message);
@@ -120,8 +128,13 @@ export class CollectionSynchronizer extends Synchronizer {
         return Array.from(this.#peers);
     }
     metrics() {
-        return Object.fromEntries(Object.entries(this.docSynchronizers).map(([documentId, synchronizer]) => {
-            return [documentId, synchronizer.metrics()];
-        }));
+        return {};
+        // return Object.fromEntries(
+        //   Object.entries(this.docSynchronizers).map(
+        //     ([documentId, synchronizer]) => {
+        //       return [documentId, synchronizer.metrics()]
+        //     }
+        //   )
+        // )
     }
 }

package/dist/synchronizer/DocSynchronizer.d.ts

@@ -1,12 +1,12 @@
 import * as A from "@automerge/automerge/slim/next";
 import { DocHandle } from "../DocHandle.js";
 import { EphemeralMessage, RepoMessage, RequestMessage, SyncMessage } from "../network/messages.js";
-import { PeerId } from "../types.js";
+import { DocumentId, PeerId } from "../types.js";
 import { Synchronizer } from "./Synchronizer.js";
 type PeerDocumentStatus = "unknown" | "has" | "unavailable" | "wants";
 interface DocSynchronizerConfig {
     handle: DocHandle<unknown>;
-    onLoadSyncState?: (peerId: PeerId) => Promise<A.SyncState | undefined>;
+    beelay: A.beelay.Beelay;
 }
 /**
  * DocSynchronizer takes a handle to an Automerge document, and receives & dispatches sync messages
@@ -15,11 +15,12 @@ interface DocSynchronizerConfig {
 export declare class DocSynchronizer extends Synchronizer {
     #private;
     syncDebounceRate: number;
-    constructor({ handle, onLoadSyncState }: DocSynchronizerConfig);
+    constructor({ handle, beelay }: DocSynchronizerConfig);
     get peerStates(): Record<PeerId, PeerDocumentStatus>;
-    get documentId(): import("../types.js").DocumentId;
+    get documentId(): DocumentId;
     hasPeer(peerId: PeerId): boolean;
     beginSync(peerIds: PeerId[]): void;
+    peerWantsDocument(peerId: PeerId): void;
     endSync(peerId: PeerId): void;
     receiveMessage(message: RepoMessage): void;
     receiveEphemeralMessage(message: EphemeralMessage): void;
@@ -29,7 +30,7 @@ export declare class DocSynchronizer extends Synchronizer {
         size: {
             numOps: number;
             numChanges: number;
-        };
+        } | undefined;
     };
 }
 export {};

package/dist/synchronizer/DocSynchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DocSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/DocSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gCAAgC,CAAA;AAGnD,OAAO,EACL,SAAS,EAKV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,gBAAgB,EAEhB,WAAW,EACX,cAAc,EACd,WAAW,EAEZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD,KAAK,kBAAkB,GAAG,SAAS,GAAG,KAAK,GAAG,aAAa,GAAG,OAAO,CAAA;AAOrE,UAAU,qBAAqB;IAC7B,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA;CACvE;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAE/C,gBAAgB,SAAM;gBAsBV,EAAE,MAAM,EAAE,eAAe,EAAE,EAAE,qBAAqB;IAyB9D,IAAI,UAAU,uCAEb;IAED,IAAI,UAAU,qCAEb;IAkID,OAAO,CAAC,MAAM,EAAE,MAAM;IAItB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE;IAmD3B,OAAO,CAAC,MAAM,EAAE,MAAM;IAKtB,cAAc,CAAC,OAAO,EAAE,WAAW;IAkBnC,uBAAuB,CAAC,OAAO,EAAE,gBAAgB;IAuBjD,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;IA+ExD,OAAO,IAAI;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAM7E"}
+{"version":3,"file":"DocSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/DocSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gCAAgC,CAAA;AAGnD,OAAO,EACL,SAAS,EAKV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,gBAAgB,EAEhB,WAAW,EACX,cAAc,EACd,WAAW,EAEZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAgB,UAAU,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIhD,KAAK,kBAAkB,GAAG,SAAS,GAAG,KAAK,GAAG,aAAa,GAAG,OAAO,CAAA;AAOrE,UAAU,qBAAqB;IAC7B,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAA;CACxB;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAE/C,gBAAgB,SAAM;gBAaV,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,qBAAqB;IAgCrD,IAAI,UAAU,uCAEb;IAED,IAAI,UAAU,IAAI,UAAU,CAE3B;IAyBD,OAAO,CAAC,MAAM,EAAE,MAAM;IAItB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE;IAkD3B,iBAAiB,CAAC,MAAM,EAAE,MAAM;IAOhC,OAAO,CAAC,MAAM,EAAE,MAAM;IAMtB,cAAc,CAAC,OAAO,EAAE,WAAW;IAiBnC,uBAAuB,CAAC,OAAO,EAAE,gBAAgB;IAsBjD,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;IA8BxD,OAAO,IAAI;QACT,KAAK,EAAE,MAAM,EAAE,CAAA;QACf,IAAI,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,GAAG,SAAS,CAAA;KACzD;CAMF"}

package/dist/synchronizer/DocSynchronizer.js

@@ -2,9 +2,8 @@ import * as A from "@automerge/automerge/slim/next";
 import { decode } from "cbor-x";
 import debug from "debug";
 import { READY, REQUESTING, UNAVAILABLE, } from "../DocHandle.js";
-import { isRequestMessage, } from "../network/messages.js";
 import { Synchronizer } from "./Synchronizer.js";
-import { throttle } from "../helpers/throttle.js";
+import { parseAutomergeUrl } from "../AutomergeUrl.js";
 /**
  * DocSynchronizer takes a handle to an Automerge document, and receives & dispatches sync messages
  * to bring it inline with all other peers' versions.
@@ -14,43 +13,43 @@ export class DocSynchronizer extends Synchronizer {
     syncDebounceRate = 100;
     /** Active peers */
     #peers = [];
-    #pendingSyncStateCallbacks = {};
     #peerDocumentStatuses = {};
-    /** Sync state for each peer we've communicated with (including inactive peers) */
-    #syncStates = {};
-    #pendingSyncMessages = [];
+    #lastSaveOffset = null;
     #syncStarted = false;
+    #beelay;
     #handle;
-    #onLoadSyncState;
-    constructor({ handle, onLoadSyncState }) {
+    #docId;
+    constructor({ handle, beelay }) {
         super();
         this.#handle = handle;
-        this.#onLoadSyncState =
-            onLoadSyncState ?? (() => Promise.resolve(undefined));
-        const docId = handle.documentId.slice(0, 5);
-        this.#log = debug(`automerge-repo:docsync:${docId}`);
-        handle.on("change", throttle(() => this.#syncWithPeers(), this.syncDebounceRate));
+        this.#beelay = beelay;
+        this.#docId = this.#handle.documentId;
+        this.#log = debug(`automerge-repo:docsync:${this.#handle.documentId}`);
         handle.on("ephemeral-message-outbound", payload => this.#broadcastToPeers(payload));
-        // Process pending sync messages immediately after the handle becomes ready.
-        void (async () => {
-            await handle.doc([READY, REQUESTING]);
-            this.#processAllPendingSyncMessages();
-        })();
+        handle.on("change", changeInfo => {
+            const newLinks = changeInfo.patches
+                .map(patch => {
+                if (patch.action === "put") {
+                    if (patch.value instanceof A.Link) {
+                        return patch.value;
+                    }
+                }
+                return null;
+            })
+                .filter(v => v != null);
+            for (const link of newLinks) {
+                const { documentId: target } = parseAutomergeUrl(link.target);
+                this.#beelay.addLink({ from: this.#handle.documentId, to: target });
+            }
+        });
     }
     get peerStates() {
         return this.#peerDocumentStatuses;
     }
     get documentId() {
-        return this.#handle.documentId;
+        return this.#docId;
     }
     /// PRIVATE
-    async #syncWithPeers() {
-        this.#log(`syncWithPeers`);
-        const doc = await this.#handle.doc();
-        if (doc === undefined)
-            return;
-        this.#peers.forEach(peerId => this.#sendSyncMessage(peerId, doc));
-    }
     async #broadcastToPeers({ data, }) {
         this.#log(`broadcastToPeers`, this.#peers);
         this.#peers.forEach(peerId => this.#sendEphemeralMessage(peerId, data));
@@ -60,145 +59,78 @@ export class DocSynchronizer extends Synchronizer {
         const message = {
             type: "ephemeral",
             targetId: peerId,
-            documentId: this.#handle.documentId,
+            documentId: this.documentId,
             data,
         };
         this.emit("message", message);
     }
-    #withSyncState(peerId, callback) {
-        this.#addPeer(peerId);
-        if (!(peerId in this.#peerDocumentStatuses)) {
-            this.#peerDocumentStatuses[peerId] = "unknown";
-        }
-        const syncState = this.#syncStates[peerId];
-        if (syncState) {
-            callback(syncState);
-            return;
-        }
-        let pendingCallbacks = this.#pendingSyncStateCallbacks[peerId];
-        if (!pendingCallbacks) {
-            this.#onLoadSyncState(peerId)
-                .then(syncState => {
-                this.#initSyncState(peerId, syncState ?? A.initSyncState());
-            })
-                .catch(err => {
-                this.#log(`Error loading sync state for ${peerId}: ${err}`);
-            });
-            pendingCallbacks = this.#pendingSyncStateCallbacks[peerId] = [];
-        }
-        pendingCallbacks.push(callback);
-    }
-    #addPeer(peerId) {
-        if (!this.#peers.includes(peerId)) {
-            this.#peers.push(peerId);
-            this.emit("open-doc", { documentId: this.documentId, peerId });
-        }
-    }
-    #initSyncState(peerId, syncState) {
-        const pendingCallbacks = this.#pendingSyncStateCallbacks[peerId];
-        if (pendingCallbacks) {
-            for (const callback of pendingCallbacks) {
-                callback(syncState);
-            }
-        }
-        delete this.#pendingSyncStateCallbacks[peerId];
-        this.#syncStates[peerId] = syncState;
-    }
-    #setSyncState(peerId, syncState) {
-        this.#syncStates[peerId] = syncState;
-        this.emit("sync-state", {
-            peerId,
-            syncState,
-            documentId: this.#handle.documentId,
-        });
-    }
-    #sendSyncMessage(peerId, doc) {
-        this.#log(`sendSyncMessage ->${peerId}`);
-        this.#withSyncState(peerId, syncState => {
-            const [newSyncState, message] = A.generateSyncMessage(doc, syncState);
-            if (message) {
-                this.#setSyncState(peerId, newSyncState);
-                const isNew = A.getHeads(doc).length === 0;
-                if (!this.#handle.isReady() &&
-                    isNew &&
-                    newSyncState.sharedHeads.length === 0 &&
-                    !Object.values(this.#peerDocumentStatuses).includes("has") &&
-                    this.#peerDocumentStatuses[peerId] === "unknown") {
-                    // we don't have the document (or access to it), so we request it
-                    this.emit("message", {
-                        type: "request",
-                        targetId: peerId,
-                        documentId: this.#handle.documentId,
-                        data: message,
-                    });
-                }
-                else {
-                    this.emit("message", {
-                        type: "sync",
-                        targetId: peerId,
-                        data: message,
-                        documentId: this.#handle.documentId,
-                    });
-                }
-                // if we have sent heads, then the peer now has or will have the document
-                if (!isNew) {
-                    this.#peerDocumentStatuses[peerId] = "has";
-                }
-            }
-        });
-    }
     /// PUBLIC
     hasPeer(peerId) {
         return this.#peers.includes(peerId);
     }
     beginSync(peerIds) {
-        const noPeersWithDocument = peerIds.every(peerId => this.#peerDocumentStatuses[peerId] in ["unavailable", "wants"]);
-        // At this point if we don't have anything in our storage, we need to use an empty doc to sync
-        // with; but we don't want to surface that state to the front end
+        this.#log(`beginSync: ${peerIds.join(", ")}`);
         const docPromise = this.#handle
-            .doc([READY, REQUESTING, UNAVAILABLE])
+            .whenReady([READY, REQUESTING, UNAVAILABLE])
             .then(doc => {
-            // we register out peers first, then say that sync has started
             this.#syncStarted = true;
             this.#checkDocUnavailable();
-            const wasUnavailable = doc === undefined;
-            if (wasUnavailable && noPeersWithDocument) {
+        })
+            // TODO: handle this error
+            .catch(() => { });
+        peerIds.forEach(peerId => {
+            if (!this.#peers.includes(peerId)) {
+                this.#peers.push(peerId);
+            }
+            else {
                 return;
             }
-            // If the doc is unavailable we still need a blank document to generate
-            // the sync message from
-            return doc ?? A.init();
-        });
-        this.#log(`beginSync: ${peerIds.join(", ")}`);
-        peerIds.forEach(peerId => {
-            this.#withSyncState(peerId, syncState => {
-                // HACK: if we have a sync state already, we round-trip it through the encoding system to make
-                // sure state is preserved. This prevents an infinite loop caused by failed attempts to send
-                // messages during disconnection.
-                // TODO: cover that case with a test and remove this hack
-                const reparsedSyncState = A.decodeSyncState(A.encodeSyncState(syncState));
-                this.#setSyncState(peerId, reparsedSyncState);
-                docPromise
-                    .then(doc => {
-                    if (doc) {
-                        this.#sendSyncMessage(peerId, doc);
+            this.#peerDocumentStatuses[peerId] = "unknown";
+            docPromise.then(() => {
+                this.#syncStarted = true;
+                this.#log(`beginning sync with ${peerId} for doc: ${this.documentId}`);
+                this.#beelay
+                    .syncDoc(this.documentId, peerId)
+                    .then(({ snapshot, found }) => {
+                    this.#peerDocumentStatuses[peerId] = found ? "has" : "unavailable";
+                    // this.#log("synced snapshot: ", snapshot)
+                    if (found) {
+                        this.#beelay.loadDocument(this.#docId).then(commitOrBundles => {
+                            if (commitOrBundles != null) {
+                                this.#handle?.update(d => {
+                                    let doc = d;
+                                    for (const commitOrBundle of commitOrBundles) {
+                                        doc = A.loadIncremental(doc, commitOrBundle.contents);
+                                    }
+                                    return doc;
+                                });
+                                this.#checkDocUnavailable();
+                            }
+                        });
+                    }
+                    else {
+                        this.#checkDocUnavailable();
                     }
-                })
-                    .catch(err => {
-                    this.#log(`Error loading doc for ${peerId}: ${err}`);
+                    this.#beelay.listen(peerId, snapshot);
                 });
             });
         });
     }
+    peerWantsDocument(peerId) {
+        this.#peerDocumentStatuses[peerId] = "wants";
+        if (!this.#peers.includes(peerId)) {
+            this.beginSync([peerId]);
+        }
+    }
     endSync(peerId) {
         this.#log(`removing peer ${peerId}`);
         this.#peers = this.#peers.filter(p => p !== peerId);
+        this.#beelay.cancelListens(peerId);
     }
     receiveMessage(message) {
         switch (message.type) {
             case "sync":
             case "request":
-                this.receiveSyncMessage(message);
                 break;
             case "ephemeral":
                 this.receiveEphemeralMessage(message);
@@ -212,7 +144,7 @@ export class DocSynchronizer extends Synchronizer {
         }
     }
     receiveEphemeralMessage(message) {
-        if (message.documentId !== this.#handle.documentId)
+        if (message.documentId !== this.documentId)
             throw new Error(`channelId doesn't match documentId`);
         const { senderId, data } = message;
         const contents = decode(new Uint8Array(data));
@@ -230,37 +162,7 @@ export class DocSynchronizer extends Synchronizer {
             });
         });
     }
-    receiveSyncMessage(message) {
-        if (message.documentId !== this.#handle.documentId)
-            throw new Error(`channelId doesn't match documentId`);
-        // We need to block receiving the syncMessages until we've checked local storage
-        if (!this.#handle.inState([READY, REQUESTING, UNAVAILABLE])) {
-            this.#pendingSyncMessages.push({ message, received: new Date() });
-            return;
-        }
-        this.#processAllPendingSyncMessages();
-        this.#processSyncMessage(message);
-    }
-    #processSyncMessage(message) {
-        if (isRequestMessage(message)) {
-            this.#peerDocumentStatuses[message.senderId] = "wants";
-        }
-        this.#checkDocUnavailable();
-        // if the message has heads, then the peer has the document
-        if (A.decodeSyncMessage(message.data).heads.length > 0) {
-            this.#peerDocumentStatuses[message.senderId] = "has";
-        }
-        this.#withSyncState(message.senderId, syncState => {
-            this.#handle.update(doc => {
-                const [newDoc, newSyncState] = A.receiveSyncMessage(doc, syncState, message.data);
-                this.#setSyncState(message.senderId, newSyncState);
-                // respond to just this peer (as required)
-                this.#sendSyncMessage(message.senderId, doc);
-                return newDoc;
-            });
-            this.#checkDocUnavailable();
-        });
-    }
+    receiveSyncMessage(message) { }
     #checkDocUnavailable() {
         // if we know none of the peers have the document, tell all our peers that we don't either
         if (this.#syncStarted &&
@@ -272,24 +174,20 @@ export class DocSynchronizer extends Synchronizer {
                 .forEach(peerId => {
                 const message = {
                     type: "doc-unavailable",
-                    documentId: this.#handle.documentId,
+                    documentId: this.documentId,
                     targetId: peerId,
                 };
                 this.emit("message", message);
             });
-            this.#handle.unavailable();
-        }
-    }
-    #processAllPendingSyncMessages() {
-        for (const message of this.#pendingSyncMessages) {
-            this.#processSyncMessage(message.message);
+            if (this.#handle) {
+                this.#handle.unavailable();
+            }
         }
-        this.#pendingSyncMessages = [];
     }
     metrics() {
         return {
             peers: this.#peers,
-            size: this.#handle.metrics(),
+            size: this.#handle?.metrics(),
         };
     }
 }

package/dist/synchronizer/Synchronizer.d.ts

@@ -9,6 +9,7 @@ export interface SynchronizerEvents {
     message: (payload: MessageContents) => void;
     "sync-state": (payload: SyncStatePayload) => void;
     "open-doc": (arg: OpenDocMessage) => void;
+    metrics: (arg: DocSyncMetrics) => void;
 }
 /** Notify the repo that the sync state has changed  */
 export interface SyncStatePayload {
@@ -16,4 +17,14 @@ export interface SyncStatePayload {
     documentId: DocumentId;
     syncState: SyncState;
 }
+export type DocSyncMetrics = {
+    type: "receive-sync-message";
+    documentId: DocumentId;
+    durationMillis: number;
+    numOps: number;
+    numChanges: number;
+} | {
+    type: "doc-denied";
+    documentId: DocumentId;
+};
 //# sourceMappingURL=Synchronizer.d.ts.map

package/dist/synchronizer/Synchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/Synchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EACL,eAAe,EACf,cAAc,EACd,WAAW,EACZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhD,8BAAsB,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IACzE,QAAQ,CAAC,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;CACpD;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;IAC3C,YAAY,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAA;IACjD,UAAU,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAA;CAC1C;AAED,uDAAuD;AACvD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;IACtB,SAAS,EAAE,SAAS,CAAA;CACrB"}
+{"version":3,"file":"Synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/Synchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EACL,eAAe,EACf,cAAc,EACd,WAAW,EACZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhD,8BAAsB,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IACzE,QAAQ,CAAC,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;CACpD;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;IAC3C,YAAY,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAA;IACjD,UAAU,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAA;IACzC,OAAO,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAA;CACvC;AAED,uDAAuD;AACvD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;IACtB,SAAS,EAAE,SAAS,CAAA;CACrB;AAED,MAAM,MAAM,cAAc,GACtB;IACE,IAAI,EAAE,sBAAsB,CAAA;IAC5B,UAAU,EAAE,UAAU,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;CACnB,GACD;IACE,IAAI,EAAE,YAAY,CAAA;IAClB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA"}

package/dist/test/CollectionSynchronizer.test.d.ts

@@ -0,0 +1,2 @@
+export {}
+//# sourceMappingURL=CollectionSynchronizer.test.d.ts.map

package/dist/test/CollectionSynchronizer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionSynchronizer.test.d.ts","sourceRoot":"","sources":["../../test/CollectionSynchronizer.test.ts"],"names":[],"mappings":""}

package/dist/test/CollectionSynchronizer.test.js

@@ -0,0 +1,57 @@
+import assert from "assert"
+import { beforeEach } from "mocha"
+import { Repo } from "../src/index.js"
+import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
+describe("CollectionSynchronizer", () => {
+  let repo
+  let synchronizer
+  beforeEach(() => {
+    repo = new Repo({
+      network: [],
+    })
+    synchronizer = new CollectionSynchronizer(repo)
+  })
+  it("is not null", async () => {
+    assert(synchronizer !== null)
+  })
+  it("starts synchronizing a document to peers when added", done => {
+    const handle = repo.create()
+    synchronizer.addPeer("peer1")
+    synchronizer.once("message", event => {
+      assert(event.targetId === "peer1")
+      assert(event.documentId === handle.documentId)
+      done()
+    })
+    synchronizer.addDocument(handle.documentId)
+  })
+  it("starts synchronizing existing documents when a peer is added", done => {
+    const handle = repo.create()
+    synchronizer.addDocument(handle.documentId)
+    synchronizer.once("message", event => {
+      assert(event.targetId === "peer1")
+      assert(event.documentId === handle.documentId)
+      done()
+    })
+    synchronizer.addPeer("peer1")
+  })
+  it("should not synchronize to a peer which is excluded from the share policy", done => {
+    const handle = repo.create()
+    repo.sharePolicy = async peerId => peerId !== "peer1"
+    synchronizer.addDocument(handle.documentId)
+    synchronizer.once("message", () => {
+      done(new Error("Should not have sent a message"))
+    })
+    synchronizer.addPeer("peer1")
+    setTimeout(done)
+  })
+  it("should not synchronize a document which is excluded from the share policy", done => {
+    const handle = repo.create()
+    repo.sharePolicy = async (_, documentId) => documentId !== handle.documentId
+    synchronizer.addPeer("peer2")
+    synchronizer.once("message", () => {
+      done(new Error("Should not have sent a message"))
+    })
+    synchronizer.addDocument(handle.documentId)
+    setTimeout(done)
+  })
+})

package/dist/test/DocHandle.test.d.ts

@@ -0,0 +1,2 @@
+export {}
+//# sourceMappingURL=DocHandle.test.d.ts.map

package/dist/test/DocHandle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocHandle.test.d.ts","sourceRoot":"","sources":["../../test/DocHandle.test.ts"],"names":[],"mappings":""}