@comapeo/core 2.3.2 → 3.0.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

@@ -169,7 +169,7 @@ class Peer {
   }
   /** @param {Invite} invite */
   sendInvite(invite) {
-    this.#assertConnected()
+    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)
@@ -177,7 +177,7 @@ class Peer {
   }
   /** @param {InviteCancel} inviteCancel */
   sendInviteCancel(inviteCancel) {
-    this.#assertConnected()
+    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)
@@ -185,7 +185,7 @@ class Peer {
   }
   /** @param {InviteResponse} response */
   sendInviteResponse(response) {
-    this.#assertConnected()
+    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)
@@ -193,7 +193,9 @@ class Peer {
   }
   /** @param {ProjectJoinDetails} details */
   sendProjectJoinDetails(details) {
-    this.#assertConnected()
+    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)
@@ -212,10 +214,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
   }
 }
 
@@ -614,7 +617,7 @@ export { TimeoutError }
 
 export class UnknownPeerError extends Error {
   /** @param {string} [message] */
-  constructor(message) {
+  constructor(message = 'UnknownPeerError') {
     super(message)
     this.name = 'UnknownPeerError'
   }
@@ -622,7 +625,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 +633,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
+  }
 }
 
 /**