@comapeo/core 2.3.2 → 3.0.0

package/src/invite/invite-state-machine.js

@@ -0,0 +1,208 @@
+import { setup, assign, fromPromise, assertEvent, raise } from 'xstate'
+import { omit } from '../lib/omit.js'
+import { InviteResponse_Decision } from '../generated/rpc.js'
+import ensureError from 'ensure-error'
+import { TimeoutError } from '../errors.js'
+
+const RECEIVE_PROJECT_DETAILS_TIMEOUT_MS = 10_000
+const ADD_PROJECT_TIMEOUT_MS = 10_000
+
+/** @import { StringToTaggedUnion } from '../types.js' */
+/** @import { ProjectJoinDetails } from '../generated/rpc.js' */
+/**
+ * @internal
+ * @typedef {object} Context
+ * @property {null | Error} error
+ * @property {null | string} projectPublicId
+ */
+/**
+ * @typedef {object} MachineSetupTypes
+ * @property {Context} context
+ * @property {{ projectPublicId: string | null }} output
+ * @property {StringToTaggedUnion<'ACCEPT_INVITE' | 'CANCEL_INVITE' | 'REJECT_INVITE' | 'ALREADY_IN_PROJECT' | 'ADDED_PROJECT' | 'PEER_DISCONNECTED'> | ({ type: 'RECEIVE_PROJECT_DETAILS' } & ProjectJoinDetails)} events
+ */
+
+export const inviteStateMachine = setup({
+  types: /** @type {MachineSetupTypes} */ ({}),
+  actors: {
+    sendInviteResponse: fromPromise(
+      /**
+       * @param {{ input: { decision: InviteResponse_Decision }}} _opts
+       */
+      async (_opts) => {}
+    ),
+    addProject: fromPromise(
+      /**
+       * @param {{ input: ProjectJoinDetails }} _opts
+       * @returns {Promise<string>} The project public ID
+       */
+      async (_opts) => ''
+    ),
+  },
+  guards: {
+    isNotAlreadyJoiningOrInProject: () => true,
+  },
+  delays: {
+    receiveTimeout: RECEIVE_PROJECT_DETAILS_TIMEOUT_MS,
+    addProjectTimeout: ADD_PROJECT_TIMEOUT_MS,
+  },
+}).createMachine({
+  id: 'invite',
+  context: {
+    error: null,
+    projectPublicId: null,
+  },
+  initial: 'pending',
+  states: {
+    pending: {
+      description: 'Pending invite awaiting response',
+      on: {
+        CANCEL_INVITE: { target: 'canceled' },
+        ACCEPT_INVITE: [
+          {
+            target: 'responding.accept',
+            guard: { type: 'isNotAlreadyJoiningOrInProject' },
+          },
+          {
+            actions: raise({ type: 'ALREADY_IN_PROJECT' }),
+          },
+        ],
+        ALREADY_IN_PROJECT: {
+          target: 'responding.already',
+        },
+        REJECT_INVITE: {
+          target: 'responding.reject',
+        },
+      },
+    },
+    responding: {
+      description: 'Responding to invite',
+      initial: 'default',
+      on: {
+        CANCEL_INVITE: { target: '#invite.canceled' },
+      },
+      states: {
+        default: {
+          always: {
+            target: '#invite.error',
+            actions: assign({ error: () => new TypeError('InvalidState') }),
+          },
+        },
+        accept: {
+          description: 'Sending accept response',
+          invoke: {
+            src: 'sendInviteResponse',
+            input: { decision: InviteResponse_Decision.ACCEPT },
+            onDone: '#invite.joining',
+            onError: '#invite.error',
+          },
+          on: {
+            // It's possible project details could be received before the send
+            // response promise resolves (e.g. somehow the peer receives the
+            // response and sends the project details before the response is
+            // confirmed as sent), so we accept project details at this point
+            RECEIVE_PROJECT_DETAILS: {
+              target: '#invite.joining.addingProject',
+            },
+          },
+        },
+        reject: {
+          description: 'Sending reject response',
+          invoke: {
+            src: 'sendInviteResponse',
+            input: { decision: InviteResponse_Decision.REJECT },
+            onDone: '#invite.rejected',
+            onError: '#invite.error',
+          },
+        },
+        already: {
+          description: 'Sending already response',
+          invoke: {
+            src: 'sendInviteResponse',
+            input: { decision: InviteResponse_Decision.ALREADY },
+            onDone: '#invite.respondedAlready',
+            onError: '#invite.error',
+          },
+        },
+      },
+    },
+    joining: {
+      initial: 'awaitingDetails',
+      description: 'Joining project from invite',
+      states: {
+        awaitingDetails: {
+          description: 'Waiting for project details',
+          on: {
+            RECEIVE_PROJECT_DETAILS: { target: 'addingProject' },
+            CANCEL_INVITE: { target: '#invite.canceled' },
+          },
+          after: {
+            receiveTimeout: {
+              target: '#invite.error',
+              actions: assign({
+                error: () =>
+                  new TimeoutError('Timed out waiting for project details'),
+              }),
+            },
+          },
+        },
+        addingProject: {
+          description: 'Adding project from invite',
+          invoke: {
+            src: 'addProject',
+            input: ({ event }) => {
+              assertEvent(event, 'RECEIVE_PROJECT_DETAILS')
+              return omit(event, ['type'])
+            },
+            onDone: {
+              target: '#invite.joined',
+              actions: assign({
+                projectPublicId: ({ event }) => event.output,
+              }),
+            },
+            onError: '#invite.error',
+          },
+          after: {
+            addProjectTimeout: {
+              target: '#invite.error',
+              actions: assign({
+                error: () => new TimeoutError('Timed out adding project'),
+              }),
+            },
+          },
+        },
+      },
+    },
+    canceled: {
+      description: 'The invite has been canceled',
+      type: 'final',
+    },
+    rejected: {
+      description: 'Rejected invite',
+      type: 'final',
+    },
+    respondedAlready: {
+      description: 'Responded that already in project',
+      type: 'final',
+    },
+    joined: {
+      description: 'Successfully joined project',
+      type: 'final',
+    },
+    error: {
+      entry: assign({
+        error: ({ event, context }) =>
+          context.error ||
+          ensureError(
+            // @ts-expect-error - xstate types are incorrect, for internal events
+            // the error property can exist, and ensureError handles event.error
+            // being undefined.
+            event.error
+          ),
+      }),
+      type: 'final',
+      description: 'Error joining project',
+    },
+  },
+  output: ({ context }) => ({ projectPublicId: context.projectPublicId }),
+})

package/src/local-peers.js

@@ -64,6 +64,7 @@ class Peer {
   #deviceType
   #connectedAt = 0
   #disconnectedAt = 0
+  #drainedListeners = new Set()
   #protomux
   #log
 
@@ -157,53 +158,94 @@ class Peer {
     this.#disconnectedAt = Date.now()
     // This promise should have already resolved, but if the peer never connected then we reject here
     this.#connected.reject(new PeerFailedConnectionError())
+    for (const listener of this.#drainedListeners) {
+      listener.reject(new Error('RPC Disconnected before sending'))
+    }
+    this.#drainedListeners.clear()
     this.#log('disconnected')
   }
+
+  // Call this when the stream has drained all data to the network
+  drained() {
+    for (const listener of this.#drainedListeners) {
+      listener.resolve()
+    }
+    this.#drainedListeners.clear()
+  }
+
+  /**
+   * @param {boolean} didWrite
+   * @returns {Promise<void>}
+   */
+  async #waitForDrain(didWrite) {
+    if (didWrite) return
+    const onDrain = pDefer()
+
+    this.#drainedListeners.add(onDrain)
+
+    await onDrain.promise
+  }
+
   /**
    * @param {Buffer} buf
+   * @returns {Promise<void>}
    */
-  [kTestOnlySendRawInvite](buf) {
+  async [kTestOnlySendRawInvite](buf) {
     this.#assertConnected()
     const messageType = MESSAGE_TYPES.Invite
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
   }
-  /** @param {Invite} invite */
-  sendInvite(invite) {
-    this.#assertConnected()
+  /**
+   * @param {Invite} invite
+   * @returns {Promise<void>}
+   */
+  async sendInvite(invite) {
+    this.#assertConnected('Peer disconnected before sending invite')
     const buf = Buffer.from(Invite.encode(invite).finish())
     const messageType = MESSAGE_TYPES.Invite
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
     this.#log('sent invite %h', invite.inviteId)
   }
-  /** @param {InviteCancel} inviteCancel */
-  sendInviteCancel(inviteCancel) {
-    this.#assertConnected()
+  /**
+   * @param {InviteCancel} inviteCancel
+   * @returns {Promise<void>}
+   */
+  async sendInviteCancel(inviteCancel) {
+    this.#assertConnected('Peer disconnected before sending invite cancel')
     const buf = Buffer.from(InviteCancel.encode(inviteCancel).finish())
     const messageType = MESSAGE_TYPES.InviteCancel
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
     this.#log('sent invite cancel %h', inviteCancel.inviteId)
   }
-  /** @param {InviteResponse} response */
-  sendInviteResponse(response) {
-    this.#assertConnected()
+  /**
+   * @param {InviteResponse} response
+   * @returns {Promise<void>}
+   */
+  async sendInviteResponse(response) {
+    this.#assertConnected('Peer disconnected before sending invite response')
     const buf = Buffer.from(InviteResponse.encode(response).finish())
     const messageType = MESSAGE_TYPES.InviteResponse
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
     this.#log('sent response for %h: %s', response.inviteId, response.decision)
   }
   /** @param {ProjectJoinDetails} details */
-  sendProjectJoinDetails(details) {
-    this.#assertConnected()
+  async sendProjectJoinDetails(details) {
+    this.#assertConnected(
+      'Peer disconnected before sending project join details'
+    )
     const buf = Buffer.from(ProjectJoinDetails.encode(details).finish())
     const messageType = MESSAGE_TYPES.ProjectJoinDetails
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
     this.#log('sent project join details for %h', details.projectKey)
   }
-  /** @param {DeviceInfo} deviceInfo */
-  sendDeviceInfo(deviceInfo) {
+  /**
+   * @param {DeviceInfo} deviceInfo
+   * @returns {Promise<void>}
+   */
+  async sendDeviceInfo(deviceInfo) {
     const buf = Buffer.from(DeviceInfo.encode(deviceInfo).finish())
     const messageType = MESSAGE_TYPES.DeviceInfo
-    this.#channel.messages[messageType].send(buf)
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
     this.#log('sent deviceInfo %o', deviceInfo)
   }
   /** @param {DeviceInfo} deviceInfo */
@@ -212,10 +254,11 @@ class Peer {
     this.#deviceType = deviceInfo.deviceType
     this.#log('received deviceInfo %o', deviceInfo)
   }
-  #assertConnected() {
+  /** @param {string} [message] */
+  #assertConnected(message) {
     if (this.#state === 'connected' && !this.#channel.closed) return
     /* c8 ignore next */
-    throw new PeerDisconnectedError() // TODO: report error - this should not happen
+    throw new PeerDisconnectedError(message) // TODO: report error - this should not happen
   }
 }
 
@@ -270,7 +313,7 @@ export class LocalPeers extends TypedEmitter {
   async sendInvite(deviceId, invite) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendInvite(invite)
+    await peer.sendInvite(invite)
   }
 
   /**
@@ -281,7 +324,7 @@ export class LocalPeers extends TypedEmitter {
   async sendInviteCancel(deviceId, inviteCancel) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendInviteCancel(inviteCancel)
+    await peer.sendInviteCancel(inviteCancel)
   }
 
   /**
@@ -293,7 +336,7 @@ export class LocalPeers extends TypedEmitter {
   async sendInviteResponse(deviceId, inviteResponse) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendInviteResponse(inviteResponse)
+    await peer.sendInviteResponse(inviteResponse)
   }
 
   /**
@@ -303,7 +346,7 @@ export class LocalPeers extends TypedEmitter {
   async sendProjectJoinDetails(deviceId, details) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendProjectJoinDetails(details)
+    await peer.sendProjectJoinDetails(details)
   }
 
   /**
@@ -314,7 +357,7 @@ export class LocalPeers extends TypedEmitter {
   async sendDeviceInfo(deviceId, deviceInfo) {
     await this.#waitForPendingConnections()
     const peer = await this.#getPeerByDeviceId(deviceId)
-    peer.sendDeviceInfo(deviceInfo)
+    await peer.sendDeviceInfo(deviceInfo)
   }
 
   /**
@@ -446,6 +489,9 @@ export class LocalPeers extends TypedEmitter {
         this.#emitPeers()
         done()
       },
+      ondrain: () => {
+        peer.drained()
+      },
     })
     channel.open()
 
@@ -614,7 +660,7 @@ export { TimeoutError }
 
 export class UnknownPeerError extends Error {
   /** @param {string} [message] */
-  constructor(message) {
+  constructor(message = 'UnknownPeerError') {
     super(message)
     this.name = 'UnknownPeerError'
   }
@@ -622,7 +668,7 @@ export class UnknownPeerError extends Error {
 
 export class PeerDisconnectedError extends Error {
   /** @param {string} [message] */
-  constructor(message) {
+  constructor(message = 'Peer disconnected') {
     super(message)
     this.name = 'PeerDisconnectedError'
   }
@@ -630,7 +676,7 @@ export class PeerDisconnectedError extends Error {
 
 export class PeerFailedConnectionError extends Error {
   /** @param {string} [message] */
-  constructor(message) {
+  constructor(message = 'PeerFailedConnectionError') {
     super(message)
     this.name = 'PeerFailedConnectionError'
   }

package/src/mapeo-manager.js

@@ -42,7 +42,7 @@ import IconServerPlugin from './fastify-plugins/icons.js'
 import { plugin as MapServerPlugin } from './fastify-plugins/maps.js'
 import { getFastifyServerAddress } from './fastify-plugins/utils.js'
 import { LocalPeers } from './local-peers.js'
-import { InviteApi } from './invite-api.js'
+import { InviteApi } from './invite/invite-api.js'
 import { LocalDiscovery } from './discovery/local-discovery.js'
 import { Roles } from './roles.js'
 import { Logger } from './logger.js'

package/src/member-api.js

@@ -17,6 +17,7 @@ import { abortSignalAny } from './lib/ponyfills.js'
 import timingSafeEqual from 'string-timing-safe-equal'
 import { isHostnameIpAddress } from './lib/is-hostname-ip-address.js'
 import { ErrorWithCode, getErrorMessage } from './lib/error.js'
+import { InviteAbortedError } from './errors.js'
 import { wsCoreReplicator } from './lib/ws-core-replicator.js'
 import { MEMBER_ROLE_ID, ROLES, isRoleIdForNewInvite } from './roles.js'
 /**
@@ -212,9 +213,9 @@ export class MemberApi extends TypedEmitter {
    * @param {AbortSignal} signal
    */
   async #sendInviteAndGetResponse(deviceId, invite, signal) {
-    const inviteAbortedError = new Error('Invite aborted')
-
-    if (signal.aborted) throw inviteAbortedError
+    if (signal.aborted) {
+      throw new InviteAbortedError()
+    }
 
     const abortController = new AbortController()
 
@@ -246,7 +247,7 @@ export class MemberApi extends TypedEmitter {
       return await responsePromise
     } catch (err) {
       if (err instanceof Error && err.name === 'AbortError') {
-        throw inviteAbortedError
+        throw new InviteAbortedError()
       } else {
         throw err
       }

package/src/types.ts

@@ -155,3 +155,9 @@ export type BlobStoreEntriesStream = Readable & {
     HyperdriveEntry & { driveId: string; blobCoreId: string }
   >
 }
+
+export type StringToTaggedUnion<T extends string> = {
+  [K in T]: {
+    type: K
+  }
+}[T]

package/src/utils.js

@@ -34,11 +34,16 @@ export function noop() {}
 
 /**
  * @param {unknown} condition
- * @param {string} message
+ * @param {string | Error} messageOrError
  * @returns {asserts condition}
  */
-export function assert(condition, message) {
-  if (!condition) throw new Error(message)
+export function assert(condition, messageOrError) {
+  if (condition) return
+  if (typeof messageOrError === 'string') {
+    throw new Error(messageOrError)
+  } else {
+    throw messageOrError
+  }
 }
 
 /**

package/dist/invite-api.d.ts

@@ -1,70 +0,0 @@
-/**
- * @typedef {Object} InviteApiEvents
- * @property {(invite: Invite) => void} invite-received
- * @property {(invite: Invite, removalReason: InviteRemovalReason) => void} invite-removed
- */
-/**
- * @extends {TypedEmitter<InviteApiEvents>}
- */
-export class InviteApi extends TypedEmitter<InviteApiEvents> {
-    /**
-     * @param {Object} options
-     * @param {import('./local-peers.js').LocalPeers} options.rpc
-     * @param {object} options.queries
-     * @param {(projectInviteId: Readonly<Buffer>) => undefined | { projectPublicId: string }} options.queries.getProjectByInviteId
-     * @param {(projectDetails: Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }) => Promise<string>} options.queries.addProject
-     * @param {Logger} [options.logger]
-     */
-    constructor({ rpc, queries, logger }: {
-        rpc: import("./local-peers.js").LocalPeers;
-        queries: {
-            getProjectByInviteId: (projectInviteId: Readonly<Buffer>) => undefined | {
-                projectPublicId: string;
-            };
-            addProject: (projectDetails: Pick<ProjectJoinDetails, "projectKey" | "encryptionKeys"> & {
-                projectName: string;
-            }) => Promise<string>;
-        };
-        logger?: Logger | undefined;
-    });
-    rpc: import("./local-peers.js").LocalPeers;
-    /**
-     * @returns {Array<Invite>}
-     */
-    getPending(): Array<Invite>;
-    /**
-     * Attempt to accept the invite.
-     *
-     * This can fail if the invitor has canceled the invite or if you cannot
-     * connect to the invitor's device.
-     *
-     * If the invite is accepted and you had other invites to the same project,
-     * those invites are removed, and the invitors are told that you're already
-     * part of this project.
-     *
-     * @param {Pick<Invite, 'inviteId'>} invite
-     * @returns {Promise<string>}
-     */
-    accept({ inviteId: inviteIdString }: Pick<Invite, "inviteId">): Promise<string>;
-    /**
-     * @param {Pick<Invite, 'inviteId'>} invite
-     * @returns {void}
-     */
-    reject({ inviteId: inviteIdString }: Pick<Invite, "inviteId">): void;
-    #private;
-}
-export type InviteInternal = InviteRpcMessage & {
-    receivedAt: number;
-};
-export type Invite = MapBuffers<InviteInternal>;
-export type InviteRemovalReason = ("accepted" | "rejected" | "canceled" | "accepted other" | "connection error" | "internal error");
-export type InviteApiEvents = {
-    "invite-received": (invite: Invite) => void;
-    "invite-removed": (invite: Invite, removalReason: InviteRemovalReason) => void;
-};
-import { TypedEmitter } from 'tiny-typed-emitter';
-import type { ProjectJoinDetails } from './generated/rpc.js';
-import { Logger } from './logger.js';
-import type { Invite as InviteRpcMessage } from './generated/rpc.js';
-import type { MapBuffers } from './types.js';
-//# sourceMappingURL=invite-api.d.ts.map

package/dist/invite-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"invite-api.d.ts","sourceRoot":"","sources":["../src/invite-api.js"],"names":[],"mappings":"AAiJA;;;;GAIG;AAEH;;GAEG;AACH;IAME;;;;;;;OAOG;IACH,sCANG;QAAuD,GAAG,EAAlD,OAAO,kBAAkB,EAAE,UAAU;QACrB,OAAO,EAC/B;YAAwG,oBAAoB,EAApH,CAAC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,SAAS,GAAG;gBAAE,eAAe,EAAE,MAAM,CAAA;aAAE;YAC4D,UAAU,EAApJ,CAAC,cAAc,EAAE,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,gBAAgB,CAAC,GAAG;gBAAE,WAAW,EAAE,MAAM,CAAA;aAAE,KAAK,OAAO,CAAC,MAAM,CAAC;SAChI;QAAyB,MAAM;KAAC,EA0BlC;IAnBC,2CAAc;IAsFhB;;OAEG;IACH,cAFa,KAAK,CAAC,MAAM,CAAC,CAMzB;IAED;;;;;;;;;;;;OAYG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,OAAO,CAAC,MAAM,CAAC,CAkI3B;IAED;;;OAGG;IACH,qCAHW,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,GACtB,IAAI,CAuBhB;;CACF;6BA7ZY,gBAAgB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE;qBAGxC,WAAW,cAAc,CAAC;kCAG3B,CACZ,UAAa,GACb,UAAa,GACb,UAAa,GACb,gBAAmB,GACnB,kBAAqB,GACrB,gBAAmB,CAChB;;uBA8GU,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI;sBACxB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,mBAAmB,KAAK,IAAI;;6BApJ7C,oBAAoB;wCAavC,oBAAoB;uBAPP,aAAa;gDAO1B,oBAAoB;gCANE,YAAY"}