@comapeo/core 5.4.1 → 6.0.0

package/src/invite/invite-api.js

@@ -1,6 +1,6 @@
 import { TypedEmitter } from 'tiny-typed-emitter'
 import { InviteResponse_Decision } from '../generated/rpc.js'
-import { assert, keyToId, noop } from '../utils.js'
+import { keyToId, noop } from '../utils.js'
 import HashMap from '../lib/hashmap.js'
 import timingSafeEqual from 'string-timing-safe-equal'
 import { Logger } from '../logger.js'
@@ -10,6 +10,8 @@ import {
   NotFoundError,
   AlreadyJoinedError,
   InviteSendError,
+  ensureKnownError,
+  InviteNotFoundError,
 } from '../errors.js'
 
 /** @import { ProjectToAddDetails } from '../mapeo-manager.js' */
@@ -79,24 +81,24 @@ export class InviteApi extends TypedEmitter {
     this.rpc.on('invite', (...args) => {
       try {
         this.#handleNewInvite(...args)
-      } catch (err) {
-        console.error('Error handling invite', err)
+      } catch (e) {
+        this.#l.log('ERROR: could not handle invite', e)
       }
     })
 
     this.rpc.on('invite-cancel', (_peerId, inviteCancel) => {
       try {
         this.#handleInviteCancel(inviteCancel)
-      } catch (err) {
-        console.error('Error handling invite cancel', err)
+      } catch (e) {
+        this.#l.log('ERROR: could not handle invite cancel', e)
       }
     })
 
     this.rpc.on('got-project-details', (peerId, projectJoinDetails) => {
       try {
         this.#handleGotProjectDetails(peerId, projectJoinDetails)
-      } catch (err) {
-        console.error('Error handling got-project-details', err)
+      } catch (e) {
+        this.#l.log('ERROR: could not handle got-project-details', e)
       }
     })
   }
@@ -127,6 +129,7 @@ export class InviteApi extends TypedEmitter {
       projectColor,
       projectDescription,
       sendStats,
+      invitorWroteDeviceInfo,
     } = inviteRpcMessage
     const invite = { ...inviteRpcMessage, receivedAt: Date.now() }
 
@@ -167,6 +170,7 @@ export class InviteApi extends TypedEmitter {
               projectColor,
               projectDescription,
               sendStats,
+              invitorWroteDeviceInfo,
             })
           }),
         },
@@ -202,7 +206,9 @@ export class InviteApi extends TypedEmitter {
     this.#l.log('Received invite cancel for invite ID %h', inviteId)
 
     const invite = this.#invites.get(inviteId)
-    assert(!!invite, `Cannot find invite ${inviteId.toString('hex')}`)
+    if (!invite) {
+      throw new InviteNotFoundError({ inviteId: inviteId.toString('hex') })
+    }
 
     // TODO: Move this logging to the state machine
     const state = invite.actor.getSnapshot()
@@ -292,10 +298,9 @@ export class InviteApi extends TypedEmitter {
       const inviteId = Buffer.from(inviteIdString, 'hex')
 
       const invite = this.#invites.get(inviteId)
-      assert(
-        !!invite,
-        new NotFoundError(`Cannot find invite ${inviteIdString}`)
-      )
+      if (!invite) {
+        throw new InviteNotFoundError({ inviteId: inviteId.toString('hex') })
+      }
       assertCanSend(invite.actor, { type: 'ACCEPT_INVITE' })
 
       this.#l.log('Accepting invite %h', inviteId)
@@ -321,9 +326,9 @@ export class InviteApi extends TypedEmitter {
       }
 
       return projectPublicId
-    } catch (err) {
-      this.#l.log('ERROR: Unable to accept invite', err)
-      throw err
+    } catch (e) {
+      this.#l.log('ERROR: Unable to accept invite', e)
+      throw ensureKnownError(e)
     }
   }
 
@@ -335,7 +340,9 @@ export class InviteApi extends TypedEmitter {
     const inviteId = Buffer.from(inviteIdString, 'hex')
 
     const invite = this.#invites.get(inviteId)
-    assert(!!invite, `Cannot find invite ${inviteIdString}`)
+    if (!invite) {
+      throw new InviteNotFoundError({ inviteId: inviteId.toString('hex') })
+    }
     assertCanSend(invite.actor, { type: 'REJECT_INVITE' })
 
     this.#l.log('Rejecting invite %h', inviteId)
@@ -381,14 +388,13 @@ function toInvite(internal, snapshot, invitorDeviceId) {
  */
 function assertCanSend(actor, eventType) {
   const state = actor.getSnapshot()
-  assert(
-    state.can(eventType),
-    new InviteSendError(
+  if (!state.can(eventType)) {
+    throw new InviteSendError(
       `Cannot send ${JSON.stringify(eventType)} in state ${toStateString(
         state.value
       )}`
     )
-  )
+  }
 }
 
 /**

package/src/lib/drizzle-helpers.js

@@ -1,9 +1,13 @@
 import { sql } from 'drizzle-orm'
 import fs from 'node:fs'
 import path from 'node:path'
-import { assert } from '../utils.js'
 import { migrate as drizzleMigrate } from 'drizzle-orm/better-sqlite3/migrator'
 import { DRIZZLE_MIGRATIONS_TABLE } from '../constants.js'
+import {
+  InvalidDrizzleJournalError,
+  InvalidDrizzleQueryResultError,
+  MigrationError,
+} from '../errors.js'
 /** @import { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3' */
 
 /**
@@ -11,13 +15,16 @@ import { DRIZZLE_MIGRATIONS_TABLE } from '../constants.js'
  * @returns {number}
  */
 const getNumberResult = (queryResult) => {
-  assert(
-    queryResult &&
+  if (
+    !(
+      queryResult &&
       typeof queryResult === 'object' &&
       'result' in queryResult &&
-      typeof queryResult.result === 'number',
-    'expected query to return proper result'
-  )
+      typeof queryResult.result === 'number'
+    )
+  ) {
+    throw new InvalidDrizzleQueryResultError()
+  }
   return queryResult.result
 }
 
@@ -68,37 +75,40 @@ const safeGetLatestMigrationMillis = (db) =>
  * @returns {MigrationResult}
  */
 export function migrate(db, { migrationsFolder, migrationFns = {} }) {
-  const journal = /** @type {unknown} */ (
-    JSON.parse(
-      fs.readFileSync(
-        path.join(migrationsFolder, 'meta/_journal.json'),
-        'utf-8'
+  try {
+    const journal = /** @type {unknown} */ (
+      JSON.parse(
+        fs.readFileSync(
+          path.join(migrationsFolder, 'meta/_journal.json'),
+          'utf-8'
+        )
       )
     )
-  )
-  // Drizzle _could_ decide to change the journal format in the future, but this
-  // assertion will ensure that tests fail if they do.
-  assertValidJournal(journal)
-
-  const prevMigrationMillis = safeGetLatestMigrationMillis(db)
+    // Drizzle _could_ decide to change the journal format in the future, but this
+    // assertion will ensure that tests fail if they do.
+    assertValidJournal(journal)
 
-  drizzleMigrate(db, {
-    migrationsFolder,
-    migrationsTable: DRIZZLE_MIGRATIONS_TABLE,
-  })
+    const prevMigrationMillis = safeGetLatestMigrationMillis(db)
 
-  for (const entry of journal.entries) {
-    if (entry.when <= prevMigrationMillis) continue
-    const fn = migrationFns[entry.tag]
-    if (fn) fn(db)
-  }
+    drizzleMigrate(db, {
+      migrationsFolder,
+      migrationsTable: DRIZZLE_MIGRATIONS_TABLE,
+    })
 
-  const lastMigrationMillis = safeGetLatestMigrationMillis(db)
+    for (const entry of journal.entries) {
+      if (entry.when <= prevMigrationMillis) continue
+      const fn = migrationFns[entry.tag]
+      if (fn) fn(db)
+    }
 
-  if (lastMigrationMillis === prevMigrationMillis) return 'no migration'
+    const lastMigrationMillis = safeGetLatestMigrationMillis(db)
 
-  if (prevMigrationMillis === 0) return 'initialized database'
+    if (lastMigrationMillis === prevMigrationMillis) return 'no migration'
 
+    if (prevMigrationMillis === 0) return 'initialized database'
+  } catch (e) {
+    throw new MigrationError({ cause: e })
+  }
   return 'migrated'
 }
 
@@ -108,13 +118,16 @@ export function migrate(db, { migrationsFolder, migrationFns = {} }) {
  * @returns {asserts journal is { version: '5', entries: { tag: string, when: number }[] }}
  */
 function assertValidJournal(journal) {
-  assert(journal && typeof journal === 'object', 'invalid journal')
-  assert(
-    'version' in journal && journal.version === '5',
-    'unexpected journal version'
-  )
-  assert(
-    'entries' in journal &&
+  if (!(journal && typeof journal === 'object')) {
+    throw new InvalidDrizzleJournalError()
+  }
+  if (!('version' in journal && journal.version === '5')) {
+    throw new InvalidDrizzleJournalError('unexpected journal version')
+  }
+
+  if (
+    !(
+      'entries' in journal &&
       Array.isArray(journal.entries) &&
       journal.entries.every(
         /** @param {unknown} m */
@@ -125,7 +138,9 @@ function assertValidJournal(journal) {
           typeof m.tag === 'string' &&
           'when' in m &&
           typeof m.when === 'number'
-      ),
-    'invalid entries in journal'
-  )
+      )
+    )
+  ) {
+    throw new InvalidDrizzleJournalError('invalid entries in journal')
+  }
 }

package/src/lib/hypercore-helpers.js

@@ -1,11 +1,13 @@
-import { assert } from '../utils.js'
+import { MissingDiscoveryKeyError } from '../errors.js'
 
 /**
  * @param {import('hypercore')<'binary', any>} core Core to unreplicate. Must be ready.
  * @param {import('protomux')} protomux
  */
 export function unreplicate(core, protomux) {
-  assert(core.discoveryKey, 'Core should have a discovery key')
+  if (!core.discoveryKey) {
+    throw new MissingDiscoveryKeyError()
+  }
   protomux.unpair({
     protocol: 'hypercore/alpha',
     id: core.discoveryKey,

package/src/lib/key-by.js

@@ -1,3 +1,5 @@
+import { DuplicateKeyError } from '../errors.js'
+
 /**
  * Like [`Map.groupBy`][0], but the result's values aren't arrays.
  *
@@ -16,7 +18,7 @@ export function keyBy(items, callbackFn) {
   for (const item of items) {
     const key = callbackFn(item)
     if (result.has(key)) {
-      throw new Error(`keyBy found duplicate key ${JSON.stringify(key)}`)
+      throw new DuplicateKeyError({ key: `${key}` })
     }
     result.set(key, item)
   }

package/src/local-peers.js

@@ -1,7 +1,7 @@
 import { TypedEmitter } from 'tiny-typed-emitter'
 import Protomux from 'protomux'
 import timingSafeEqual from 'string-timing-safe-equal'
-import { assert, ExhaustivenessError, keyToId, noop } from './utils.js'
+import { keyToId, noop, timeoutPromise } from './utils.js'
 import { isBlank } from './lib/string.js'
 import cenc from 'compact-encoding'
 import {
@@ -18,10 +18,15 @@ import {
 } from './generated/rpc.js'
 import pDefer from 'p-defer'
 import { Logger } from './logger.js'
-import pTimeout, { TimeoutError } from 'p-timeout'
 import {
+  PeerDisconnectedError,
+  PeerFailedConnectionError,
   RPCDisconnectBeforeAckError,
   RPCDisconnectBeforeSendingError,
+  UnknownPeerError,
+  ExhaustivenessError,
+  InvalidInviteError,
+  InvalidProjectJoinDetailsError,
 } from './errors.js'
 /** @import NoiseStream from '@hyperswarm/secret-stream' */
 /** @import { OpenedNoiseStream } from './lib/noise-secret-stream-helpers.js' */
@@ -157,7 +162,7 @@ class Peer {
         }
       /* c8 ignore next 2 */
       default:
-        throw new ExhaustivenessError(this.#state)
+        throw new ExhaustivenessError({ value: this.#state })
     }
   }
   /**
@@ -280,7 +285,7 @@ class Peer {
    * @returns {Promise<void>}
    */
   async [kTestOnlySendRawInvite](buf) {
-    this.#assertConnected()
+    this.#assertConnected('Peer not connected for test')
     const messageType = MESSAGE_TYPES.Invite
     await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
   }
@@ -408,7 +413,7 @@ class Peer {
     this.#features = deviceInfo.features
     this.#log('received deviceInfo %o', deviceInfo)
   }
-  /** @param {string} [message] */
+  /** @param {string} message */
   #assertConnected(message) {
     if (this.#state === 'connected' && !this.#channel.closed) return
     /* c8 ignore next */
@@ -536,7 +541,6 @@ export class LocalPeers extends TypedEmitter {
    */
   connect(stream) {
     const noiseStream = stream.noiseStream
-    if (!noiseStream) throw new Error('Invalid stream')
     const outerStream = noiseStream.rawStream
     const protomux =
       noiseStream.userData && Protomux.isProtomux(noiseStream.userData)
@@ -617,8 +621,8 @@ export class LocalPeers extends TypedEmitter {
               /** @type {keyof typeof MESSAGE_TYPES} */ (type),
               message
             )
-          } catch (err) {
-            const errorMessage = String(err)
+          } catch (e) {
+            const errorMessage = String(e)
             this.emit('failed-to-handle-message', type, errorMessage)
             this.#l.log(`Error handling ${type} message: ${errorMessage}`)
           }
@@ -817,7 +821,9 @@ export class LocalPeers extends TypedEmitter {
    * Wait for any connections that are currently opening
    */
   #waitForPendingConnections() {
-    return pTimeout(Promise.all(this.#opening), { milliseconds: SEND_TIMEOUT })
+    return timeoutPromise(Promise.all(this.#opening), {
+      milliseconds: SEND_TIMEOUT,
+    })
   }
 
   /**
@@ -830,14 +836,14 @@ export class LocalPeers extends TypedEmitter {
   async #getPeerByDeviceId(deviceId) {
     const devicePeers = this.#peers.get(deviceId)
     if (!devicePeers || devicePeers.size === 0) {
-      throw new UnknownPeerError('Unknown peer ' + deviceId.slice(0, 7))
+      throw new UnknownPeerError({ deviceId: deviceId.slice(0, 7) })
     }
     const peer = chooseDevicePeer(devicePeers)
     if (peer) return peer
     return new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
         this.off('peers', onPeers)
-        reject(new UnknownPeerError('Unknown peer ' + deviceId.slice(0, 7)))
+        reject(new UnknownPeerError({ deviceId: deviceId.slice(0, 7) }))
       }, DEDUPE_TIMEOUT)
 
       const onPeers = () => {
@@ -854,38 +860,14 @@ export class LocalPeers extends TypedEmitter {
   }
 }
 
-export { TimeoutError }
-
-export class UnknownPeerError extends Error {
-  /** @param {string} [message] */
-  constructor(message = 'UnknownPeerError') {
-    super(message)
-    this.name = 'UnknownPeerError'
-  }
-}
-
-export class PeerDisconnectedError extends Error {
-  /** @param {string} [message] */
-  constructor(message = 'Peer disconnected') {
-    super(message)
-    this.name = 'PeerDisconnectedError'
-  }
-}
-
-export class PeerFailedConnectionError extends Error {
-  /** @param {string} [message] */
-  constructor(message = 'PeerFailedConnectionError') {
-    super(message)
-    this.name = 'PeerFailedConnectionError'
-  }
-}
-
 /**
  * @param {Readonly<Uint8Array>} id
  * @throws if the invite ID is too short
  */
 function assertInviteIdIsValid(id) {
-  assert(id.byteLength >= 32, 'Invite ID must be >= 32 bytes')
+  if (id.byteLength < 32) {
+    throw new InvalidInviteError('Invite ID must be >= 32 bytes')
+  }
 }
 
 /**
@@ -896,9 +878,15 @@ function assertInviteIdIsValid(id) {
 function parseInvite(data) {
   const result = Invite.decode(data)
   assertInviteIdIsValid(result.inviteId)
-  assert(result.projectInviteId.length, 'Invite must have project invite ID')
-  assert(!isBlank(result.projectName), 'Invite project name cannot be blank')
-  assert(!isBlank(result.invitorName), 'Invite invitor name cannot be blank')
+  if (!result.projectInviteId.length) {
+    throw new InvalidInviteError('Invite must have project invite ID')
+  }
+  if (isBlank(result.projectName)) {
+    throw new InvalidInviteError('Invite project name cannot be blank')
+  }
+  if (isBlank(result.invitorName)) {
+    throw new InvalidInviteError('Invite invitor name cannot be blank')
+  }
   return result
 }
 
@@ -932,11 +920,16 @@ function parseInviteResponse(data) {
 function parseProjectJoinDetails(data) {
   const result = ProjectJoinDetails.decode(data)
   assertInviteIdIsValid(result.inviteId)
-  assert(result.projectKey.length, 'Project join details must have project key')
-  assert(
-    result.encryptionKeys?.auth?.byteLength,
-    'Project join details must have auth encryption keys'
-  )
+  if (!result.projectKey.length) {
+    throw new InvalidProjectJoinDetailsError(
+      'Project join details must have project key'
+    )
+  }
+  if (!result.encryptionKeys?.auth?.byteLength) {
+    throw new InvalidProjectJoinDetailsError(
+      'Project join details must have auth encryption keys'
+    )
+  }
   return result
 }
 

package/src/logger.js

@@ -1,4 +1,5 @@
 import createDebug from 'debug'
+import ensureError from 'ensure-error'
 import { discoveryKey } from 'hypercore-crypto'
 import mapObject from 'map-obj'
 import util from 'util'
@@ -69,7 +70,7 @@ createDebug.formatters.X = function (v) {
       breakLength: 90,
     })
   } catch (e) {
-    return `[ERROR: $(e.message)]`
+    return `[ERROR: ${ensureError(e).message}]`
   }
 }
 

package/src/mapeo-manager.js

@@ -6,7 +6,6 @@ import { eq, and } from 'drizzle-orm'
 import { drizzle } from 'drizzle-orm/better-sqlite3'
 import Hypercore from 'hypercore'
 import { TypedEmitter } from 'tiny-typed-emitter'
-import pTimeout from 'p-timeout'
 import { createRequire } from 'module'
 
 import { IndexWriter } from './index-writer/index.js'
@@ -36,6 +35,7 @@ import {
   projectKeyToId,
   projectKeyToProjectInviteId,
   projectKeyToPublicId,
+  timeoutPromise,
 } from './utils.js'
 import { openedNoiseSecretStream } from './lib/noise-secret-stream-helpers.js'
 import { omit } from './lib/omit.js'
@@ -49,7 +49,14 @@ import { InviteApi } from './invite/invite-api.js'
 import { LocalDiscovery } from './discovery/local-discovery.js'
 import { Logger } from './logger.js'
 import { kRequestFullStop, kRescindFullStopRequest } from './sync/sync-api.js'
-import { NotFoundError } from './errors.js'
+import {
+  EncryptionKeysNotFoundError,
+  ensureKnownError,
+  ExhaustivenessError,
+  FailedToSetIsArchiveDeviceError,
+  NotFoundError,
+  ProjectExistsError,
+} from './errors.js'
 import { WebSocket } from 'ws'
 import { excludeKeys } from 'filter-obj'
 import { migrate } from './lib/drizzle-helpers.js'
@@ -63,7 +70,7 @@ import { migrate } from './lib/drizzle-helpers.js'
 /** @import { ProjectSettings, ProjectSettingsValue } from '@comapeo/schema' */
 
 /** @typedef {SetNonNullable<ProjectKeys, 'encryptionKeys'>} ValidatedProjectKeys */
-/** @typedef {Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string, projectColor?: string, projectDescription?: string, sendStats?: boolean }} ProjectToAddDetails */
+/** @typedef {Pick<ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string, projectColor?: string, projectDescription?: string, sendStats?: boolean, invitorWroteDeviceInfo? : boolean }} ProjectToAddDetails */
 /** @typedef {Pick<ProjectSettings, 'createdAt' | 'updatedAt' | 'name' | 'projectColor' | 'projectDescription' | 'sendStats'>} ListedProjectSettings */
 /** @typedef {ListedProjectSettings & { status: 'joined', projectId: string } | ProjectInfo & { status: 'joining' | 'left', projectId: string }} ListedProject */
 
@@ -277,7 +284,7 @@ export class MapeoManager extends TypedEmitter {
         break
       }
       default: {
-        throw new Error(`Unsupported media type ${mediaType}`)
+        throw new ExhaustivenessError({ value: mediaType })
       }
     }
 
@@ -587,11 +594,11 @@ export class MapeoManager extends TypedEmitter {
 
     /**
      *
-     * @param {Error} err
+     * @param {Error} e
      * @param {MapShareExtension} mapShareExtension
      */
-    const onMapShareError = (err, mapShareExtension) => {
-      this.emit('map-share-error', err, mapShareExtension)
+    const onMapShareError = (e, mapShareExtension) => {
+      this.emit('map-share-error', e, mapShareExtension)
     }
 
     project.once('close', () => {
@@ -696,6 +703,7 @@ export class MapeoManager extends TypedEmitter {
       projectColor,
       projectDescription,
       sendStats = false,
+      invitorWroteDeviceInfo = false,
     },
     { waitForSync = true } = {}
   ) => {
@@ -715,7 +723,7 @@ export class MapeoManager extends TypedEmitter {
       .get()
 
     if (existingProject && existingProject.hasLeftProject !== true) {
-      throw new Error(`Project with ID ${projectPublicId} already exists`)
+      throw new ProjectExistsError({ projectPublicId })
     }
 
     // 2. Check for an active project
@@ -770,7 +778,7 @@ export class MapeoManager extends TypedEmitter {
         .delete(projectKeysTable)
         .where(eq(projectKeysTable.projectId, projectId))
         .run()
-      throw e
+      throw ensureKnownError(e)
     }
 
     // Make sure to clean up when closed
@@ -778,18 +786,21 @@ export class MapeoManager extends TypedEmitter {
       this.#activeProjects.delete(projectPublicId)
     })
 
-    try {
-      const deviceInfo = this.getDeviceInfo()
-      if (hasSavedDeviceInfo(deviceInfo)) {
-        await project[kSetOwnDeviceInfo](deviceInfo)
+    // Only write info on invite if configured
+    if (!invitorWroteDeviceInfo) {
+      try {
+        const deviceInfo = this.getDeviceInfo()
+        if (hasSavedDeviceInfo(deviceInfo)) {
+          await project[kSetOwnDeviceInfo](deviceInfo)
+        }
+      } catch (e) {
+        // Can ignore an error trying to write device info
+        this.#l.log(
+          'ERROR: failed to write project %h deviceInfo %o',
+          projectKey,
+          e
+        )
       }
-    } catch (e) {
-      // Can ignore an error trying to write device info
-      this.#l.log(
-        'ERROR: failed to write project %h deviceInfo %o',
-        projectKey,
-        e
-      )
     }
 
     // 5. Wait for initial project sync
@@ -899,7 +910,7 @@ export class MapeoManager extends TypedEmitter {
       })
       .run()
     if (!result || result.changes === 0) {
-      throw new Error('Failed to set isArchiveDevice')
+      throw new FailedToSetIsArchiveDeviceError()
     }
     for (const project of this.#activeProjects.values()) {
       project[kSetIsArchiveDevice](isArchiveDevice)
@@ -1036,7 +1047,9 @@ export class MapeoManager extends TypedEmitter {
   }
 
   async getMapStyleJsonUrl() {
-    await pTimeout(this.#fastify.ready(), { milliseconds: 1000 })
+    await timeoutPromise(Promise.resolve(this.#fastify.ready()), {
+      milliseconds: 1000,
+    })
     return (await this.#getMediaBaseUrl('maps')) + '/style.json'
   }
 
@@ -1078,7 +1091,7 @@ function omitPeerProtomux(peers) {
  */
 function validateProjectKeys(projectKeys) {
   if (!projectKeys.encryptionKeys) {
-    throw new Error('encryptionKeys should not be undefined')
+    throw new EncryptionKeysNotFoundError()
   }
 }