@automerge/automerge-repo 1.0.6 → 1.0.7

package/src/network/NetworkAdapter.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "eventemitter3"
 import { PeerId } from "../types.js"
-import { Message } from "./messages.js"
+import { RepoMessage } from "./messages.js"
 
 /** An interface representing some way to connect to other peers
  *
@@ -22,7 +22,7 @@ export abstract class NetworkAdapter extends EventEmitter<NetworkAdapterEvents>
    *
    * @argument message - the message to send
    */
-  abstract send(message: Message): void
+  abstract send(message: RepoMessage): void
 
   /** Called by the {@link Repo} to disconnect from the network */
   abstract disconnect(): void
@@ -33,14 +33,18 @@ export abstract class NetworkAdapter extends EventEmitter<NetworkAdapterEvents>
 export interface NetworkAdapterEvents {
   /** Emitted when the network is ready to be used */
   ready: (payload: OpenPayload) => void
+
   /** Emitted when the network is closed */
   close: () => void
+
   /** Emitted when the network adapter learns about a new peer */
   "peer-candidate": (payload: PeerCandidatePayload) => void
+
   /** Emitted when the network adapter learns that a peer has disconnected */
   "peer-disconnected": (payload: PeerDisconnectedPayload) => void
+
   /** Emitted when the network adapter receives a message from a peer */
-  message: (payload: Message) => void
+  message: (payload: RepoMessage) => void
 }
 
 export interface OpenPayload {

package/src/network/NetworkSubsystem.ts

@@ -1,18 +1,15 @@
+import debug from "debug"
 import { EventEmitter } from "eventemitter3"
-import { PeerId } from "../types.js"
+import { PeerId, SessionId } from "../types.js"
 import { NetworkAdapter, PeerDisconnectedPayload } from "./NetworkAdapter.js"
-
 import {
   EphemeralMessage,
-  isEphemeralMessage,
-  isValidMessage,
-  Message,
+  RepoMessage,
   MessageContents,
+  isEphemeralMessage,
+  isValidRepoMessage,
 } from "./messages.js"
 
-import debug from "debug"
-import { SessionId } from "../EphemeralData.js"
-
 type EphemeralMessageSource = `${PeerId}:${SessionId}`
 
 const getEphemeralMessageSource = (message: EphemeralMessage) =>
@@ -69,7 +66,7 @@ export class NetworkSubsystem extends EventEmitter<NetworkSubsystemEvents> {
     })
 
     networkAdapter.on("message", msg => {
-      if (!isValidMessage(msg)) {
+      if (!isValidRepoMessage(msg)) {
         this.#log(`invalid message: ${JSON.stringify(msg)}`)
         return
       }
@@ -110,25 +107,36 @@ export class NetworkSubsystem extends EventEmitter<NetworkSubsystemEvents> {
       this.#log(`Tried to send message but peer not found: ${message.targetId}`)
       return
     }
-    this.#log(`Sending message to ${message.targetId}`)
 
-    if (isEphemeralMessage(message)) {
-      const outbound =
-        "count" in message
-          ? message
-          : {
+    /** Messages come in without a senderId and other required information; this is where we make
+     * sure they have everything they need.
+     */
+    const prepareMessage = (message: MessageContents): RepoMessage => {
+      if (message.type === "ephemeral") {
+        if ("count" in message) {
+          // existing ephemeral message from another peer; pass on without changes
+          return message as EphemeralMessage
+        } else {
+          // new ephemeral message from us; add our senderId as well as a counter and session id
+          return {
             ...message,
             count: ++this.#count,
             sessionId: this.#sessionId,
             senderId: this.peerId,
-          }
-      this.#log("Ephemeral message", outbound)
-      peer.send(outbound)
-    } else {
-      const outbound = { ...message, senderId: this.peerId }
-      this.#log("Sync message", outbound)
-      peer.send(outbound)
+          } as EphemeralMessage
+        }
+      } else {
+        // other message type; just add our senderId
+        return {
+          ...message,
+          senderId: this.peerId,
+        } as RepoMessage
+      }
     }
+
+    const outbound = prepareMessage(message)
+    this.#log("sending message", outbound)
+    peer.send(outbound as RepoMessage)
   }
 
   isReady = () => {
@@ -157,7 +165,7 @@ function randomPeerId() {
 export interface NetworkSubsystemEvents {
   peer: (payload: PeerPayload) => void
   "peer-disconnected": (payload: PeerDisconnectedPayload) => void
-  message: (payload: Message) => void
+  message: (payload: RepoMessage) => void
   ready: () => void
 }
 

package/src/network/messages.ts

@@ -1,161 +1,70 @@
-// utilities
-import { SessionId } from "../EphemeralData.js"
-export { type SessionId } from "../EphemeralData.js"
-import { DocumentId, PeerId } from "../types.js"
-
-export function isValidMessage(
-  message: NetworkAdapterMessage
-): message is
-  | SyncMessage
-  | EphemeralMessage
-  | RequestMessage
-  | DocumentUnavailableMessage {
-  return (
-    typeof message === "object" &&
-    typeof message.type === "string" &&
-    typeof message.senderId === "string" &&
-    (isSyncMessage(message) ||
-      isEphemeralMessage(message) ||
-      isRequestMessage(message) ||
-      isDocumentUnavailableMessage(message))
-  )
-}
-
-export function isDocumentUnavailableMessage(
-  message: NetworkAdapterMessage
-): message is DocumentUnavailableMessage {
-  return message.type === "doc-unavailable"
-}
-
-export function isRequestMessage(
-  message: NetworkAdapterMessage
-): message is RequestMessage {
-  return message.type === "request"
-}
-
-export function isSyncMessage(
-  message: NetworkAdapterMessage
-): message is SyncMessage {
-  return message.type === "sync"
-}
-
-export function isEphemeralMessage(
-  message: NetworkAdapterMessage | MessageContents
-): message is EphemeralMessage | EphemeralMessageContents {
-  return message.type === "ephemeral"
-}
-
-export interface SyncMessageEnvelope {
-  senderId: PeerId
-}
+import { DocumentId, PeerId, SessionId } from "../types.js"
 
-export interface SyncMessageContents {
-  type: "sync"
-  data: Uint8Array
-  targetId: PeerId
-  documentId: DocumentId
-}
-
-type static_assert<T extends true> = never
-
-// export type SyncMessage = SyncMessageEnvelope & SyncMessageContents
-// we inline the definitions here rather than using the above type alias because
-// otherwise typedoc can't produce nice docs. We use this `static_assert` thing
-// to make sure the types continue to line up though.
-type _check_sync_message = static_assert<SyncMessage extends SyncMessageEnvelope & SyncMessageContents ? true : false>
 /**
  * A sync message for a particular document
  */
 export type SyncMessage = {
+  type: "sync"
+
   /** The peer ID of the sender of this message */
   senderId: PeerId
-  type: "sync"
-  /** The automerge sync message */
-  data: Uint8Array
+
   /** The peer ID of the recipient of this message */
   targetId: PeerId
-  /** The document ID of the document this message is for */
-  documentId: DocumentId
-}
 
+  /** The automerge sync message */
+  data: Uint8Array
 
-export interface EphemeralMessageEnvelope {
-  senderId: PeerId
-  count: number
-  sessionId: SessionId
-}
-
-export interface EphemeralMessageContents {
-  type: "ephemeral"
-  targetId: PeerId
+  /** The document ID of the document this message is for */
   documentId: DocumentId
-  data: Uint8Array
 }
 
-// export type EphemeralMessage = EphemeralMessageEnvelope & EphemeralMessageContents
-// Inline definitions to get good docs, but check the types line up
-type _check_ephemeral_message = static_assert<EphemeralMessage extends EphemeralMessageEnvelope & EphemeralMessageContents ? true : false>
-
-/** An ephemeral message 
- * 
+/** An ephemeral message
+ *
  * @remarks
  * Ephemeral messages are not persisted anywhere and have no particular
- * structure. `automerge-repo` will gossip them around, in order to avoid 
+ * structure. `automerge-repo` will gossip them around, in order to avoid
  * eternal loops of ephemeral messages every message has a session ID, which
  * is a random number generated by the sender at startup time, and a sequence
  * number. The combination of these two things allows us to discard messages
  * we have already seen.
  * */
 export type EphemeralMessage = {
-  /** The ID of the peer who sent this message */
+  type: "ephemeral"
+
+  /** The peer ID of the sender of this message */
   senderId: PeerId
+
+  /** The peer ID of the recipient of this message */
+  targetId: PeerId
+
   /** A sequence number which must be incremented for each message sent by this peer */
   count: number
+
   /** The ID of the session this message is part of. The sequence number for a given session always increases */
   sessionId: SessionId
-  type: "ephemeral"
-  /** The peer this message is for */
-  targetId: PeerId
+
   /** The document ID this message pertains to */
   documentId: DocumentId
+
   /** The actual data of the message */
   data: Uint8Array
 }
 
-export interface DocumentUnavailableMessageContents {
-  type: "doc-unavailable"
-  documentId: DocumentId
-  targetId: PeerId
-}
-
-
-// export type DocumentUnavailableMessage = SyncMessageEnvelope & DocumentUnavailableMessageContents
-// Inline definitions to get good docs, but check the types line up
-type _check_doc_unavailable = static_assert<DocumentUnavailableMessage extends SyncMessageEnvelope & DocumentUnavailableMessageContents ? true : false>
 /** Sent by a {@link Repo} to indicate that it does not have the document and none of it's connected peers do either */
 export type DocumentUnavailableMessage = {
-  /** The peer who sent this message */
-  senderId: PeerId
   type: "doc-unavailable"
-  /** The document which the peer claims it doesn't have */
-  documentId: DocumentId
-  /** The peer this message is for */
-  targetId: PeerId
-}
 
-export interface RequestMessageContents {
-  type: "request"
-  data: Uint8Array
+  /** The peer ID of the sender of this message */
+  senderId: PeerId
+
+  /** The peer ID of the recipient of this message */
   targetId: PeerId
+
+  /** The document which the peer claims it doesn't have */
   documentId: DocumentId
 }
 
-// export type RequestMessage = SyncMessageEnvelope & RequestMessageContents
-// Inline definitions to get good docs, but check the types line up
-type _check_request_message = static_assert<RequestMessage extends SyncMessageEnvelope & RequestMessageContents ? true : false>
-// We inline the definitions here rather than using the above type alias because
-// otherwise typedoc can't produce nice docs without exporting SyncMessageEnvelope
-// and RequestMessageContents
 /** Sent by a {@link Repo} to request a document from a peer
  *
  * @remarks
@@ -163,58 +72,86 @@ type _check_request_message = static_assert<RequestMessage extends SyncMessageEn
  * as the initial sync message when asking the other peer if it has the document.
  * */
 export type RequestMessage = {
-  /** The peer who sent this message */
-  senderId: PeerId
   type: "request"
+
+  /** The peer ID of the sender of this message */
+  senderId: PeerId
+
+  /** The peer ID of the recipient of this message */
+  targetId: PeerId
+
   /** The initial automerge sync message */
   data: Uint8Array
-  /** The peer this message is for */
-  targetId: PeerId
+
   /** The document ID this message requests */
   documentId: DocumentId
 }
 
-export type MessageContents =
-  | SyncMessageContents
-  | EphemeralMessageContents
-  | RequestMessageContents
-  | DocumentUnavailableMessageContents
-
-/** The type of messages that {@link Repo} sends and receive to {@link NetworkAdapter}s */
-export type Message =
-  | SyncMessage
-  | EphemeralMessage
-  | RequestMessage
-  | DocumentUnavailableMessage
-
-export type SynchronizerMessage =
-  | SyncMessage
-  | RequestMessage
-  | DocumentUnavailableMessage
-  | EphemeralMessage
-
-
 /** Notify the network that we have arrived so everyone knows our peer ID */
 export type ArriveMessage = {
-  /** Our peer ID */
-  senderId: PeerId
   type: "arrive"
+
+  /** The peer ID of the sender of this message */
+  senderId: PeerId
+
+  /** Arrive messages don't have a targetId */
+  targetId: never
 }
 
 /** Respond to an arriving peer with our peer ID */
 export type WelcomeMessage = {
-  /** Our peer ID */
+  type: "welcome"
+
+  /** The peer ID of the recipient sender this message */
   senderId: PeerId
-  /** The ID of the peer who sent the {@link ArriveMessage} we are responding to */
+
+  /** The peer ID of the recipient of this message */
   targetId: PeerId
-  type: "welcome"
 }
 
-/** The type of messages that {@link NetworkAdapter}s send and receive to each other
+/** These are message types that a {@link NetworkAdapter} surfaces to a {@link Repo}. */
+export type RepoMessage =
+  | SyncMessage
+  | EphemeralMessage
+  | RequestMessage
+  | DocumentUnavailableMessage
+
+/** These are all the message types that a {@link NetworkAdapter} might see.
  *
  * @remarks
- * It is not _required_ that a {@link NetworkAdapter} use this message type.
- * NetworkAdapters are free to use whatever message type makes sense for their
- * transport. However, this type is a useful default.
+ * It is not _required_ that a {@link NetworkAdapter} use these types: They are free to use
+ * whatever message type makes sense for their transport. However, this type is a useful default.
  * */
-export type NetworkAdapterMessage = ArriveMessage | WelcomeMessage | Message
+export type Message = RepoMessage | ArriveMessage | WelcomeMessage
+
+/**
+ * The contents of a message, without the sender ID or other properties added by the {@link NetworkSubsystem})
+ */
+export type MessageContents<T extends Message = Message> =
+  T extends EphemeralMessage
+    ? Omit<T, "senderId" | "count" | "sessionId">
+    : Omit<T, "senderId">
+
+// TYPE GUARDS
+
+export const isValidRepoMessage = (message: Message): message is RepoMessage =>
+  typeof message === "object" &&
+  typeof message.type === "string" &&
+  typeof message.senderId === "string" &&
+  (isSyncMessage(message) ||
+    isEphemeralMessage(message) ||
+    isRequestMessage(message) ||
+    isDocumentUnavailableMessage(message))
+
+// prettier-ignore
+export const isDocumentUnavailableMessage = (msg: Message): msg is DocumentUnavailableMessage => 
+  msg.type === "doc-unavailable"
+
+export const isRequestMessage = (msg: Message): msg is RequestMessage =>
+  msg.type === "request"
+
+export const isSyncMessage = (msg: Message): msg is SyncMessage =>
+  msg.type === "sync"
+
+export const isEphemeralMessage = (msg: Message): msg is EphemeralMessage =>
+  msg.type === "ephemeral"

package/src/storage/StorageSubsystem.ts

@@ -24,8 +24,8 @@ function keyHash(binary: Uint8Array) {
 }
 
 function headsHash(heads: A.Heads): string {
-  let encoder = new TextEncoder()
-  let headsbinary = mergeArrays(heads.map((h: string) => encoder.encode(h)))
+  const encoder = new TextEncoder()
+  const headsbinary = mergeArrays(heads.map((h: string) => encoder.encode(h)))
   return keyHash(headsbinary)
 }
 
@@ -53,7 +53,7 @@ export class StorageSubsystem {
       if (!this.#chunkInfos.has(documentId)) {
         this.#chunkInfos.set(documentId, [])
       }
-      this.#chunkInfos.get(documentId)!!.push({
+      this.#chunkInfos.get(documentId)!.push({
         key,
         type: "incremental",
         size: binary.length,
@@ -122,18 +122,18 @@ export class StorageSubsystem {
     if (!this.#shouldSave(documentId, doc)) {
       return
     }
-    let sourceChunks = this.#chunkInfos.get(documentId) ?? []
+    const sourceChunks = this.#chunkInfos.get(documentId) ?? []
     if (this.#shouldCompact(sourceChunks)) {
-      this.#saveTotal(documentId, doc, sourceChunks)
+      void this.#saveTotal(documentId, doc, sourceChunks)
     } else {
-      this.#saveIncremental(documentId, doc)
+      void this.#saveIncremental(documentId, doc)
     }
     this.#storedHeads.set(documentId, A.getHeads(doc))
   }
 
   async remove(documentId: DocumentId) {
-    this.#storageAdapter.removeRange([documentId, "snapshot"])
-    this.#storageAdapter.removeRange([documentId, "incremental"])
+    void this.#storageAdapter.removeRange([documentId, "snapshot"])
+    void this.#storageAdapter.removeRange([documentId, "incremental"])
   }
 
   #shouldSave(documentId: DocumentId, doc: A.Doc<unknown>): boolean {

package/src/synchronizer/CollectionSynchronizer.ts

@@ -1,21 +1,12 @@
-import { Repo } from "../Repo.js"
 import { DocHandle } from "../DocHandle.js"
-import {
-  documentIdToBinary,
-  binaryToDocumentId,
-  stringifyAutomergeUrl,
-} from "../DocUrl.js"
-import { PeerId, DocumentId } from "../types.js"
+import { stringifyAutomergeUrl } from "../DocUrl.js"
+import { Repo } from "../Repo.js"
+import { DocumentId, PeerId } from "../types.js"
 import { DocSynchronizer } from "./DocSynchronizer.js"
 import { Synchronizer } from "./Synchronizer.js"
 
 import debug from "debug"
-import {
-  DocumentUnavailableMessage,
-  RequestMessage,
-  SynchronizerMessage,
-  SyncMessage,
-} from "../network/messages.js"
+import { RepoMessage } from "../network/messages.js"
 const log = debug("automerge-repo:collectionsync")
 
 /** A CollectionSynchronizer is responsible for synchronizing a DocCollection with peers. */
@@ -66,7 +57,7 @@ export class CollectionSynchronizer extends Synchronizer {
    * When we receive a sync message for a document we haven't got in memory, we
    * register it with the repo and start synchronizing
    */
-  async receiveMessage(message: SynchronizerMessage) {
+  async receiveMessage(message: RepoMessage) {
     log(
       `onSyncMessage: ${message.senderId}, ${message.documentId}, ${
         "data" in message ? message.data.byteLength + "bytes" : ""
@@ -121,7 +112,7 @@ export class CollectionSynchronizer extends Synchronizer {
     this.#peers.add(peerId)
     for (const docSynchronizer of Object.values(this.#docSynchronizers)) {
       const { documentId } = docSynchronizer
-      this.repo.sharePolicy(peerId, documentId).then(okToShare => {
+      void this.repo.sharePolicy(peerId, documentId).then(okToShare => {
         if (okToShare) docSynchronizer.beginSync([peerId])
       })
     }