@comapeo/core 2.0.1 → 2.2.0

package/src/lib/ws-core-replicator.js

@@ -0,0 +1,47 @@
+import { pipeline } from 'node:stream/promises'
+import { Transform } from 'node:stream'
+import { createWebSocketStream } from 'ws'
+/** @import { WebSocket } from 'ws' */
+/** @import { ReplicationStream } from '../types.js' */
+
+/**
+ * @param {WebSocket} ws
+ * @param {ReplicationStream} replicationStream
+ * @returns {Promise<void>}
+ */
+export function wsCoreReplicator(ws, replicationStream) {
+  // This is purely to satisfy typescript at its worst. `pipeline` expects a
+  // NodeJS ReadWriteStream, but our replicationStream is a streamx Duplex
+  // stream. The difference is that streamx does not implement the
+  // `setEncoding`, `unpipe`, `wrap` or `isPaused` methods. The `pipeline`
+  // function does not depend on any of these methods (I have read through the
+  // NodeJS source code at cebf21d (v22.9.0) to confirm this), so we can safely
+  // cast the stream to a NodeJS ReadWriteStream.
+  const _replicationStream = /** @type {NodeJS.ReadWriteStream} */ (
+    /** @type {unknown} */ (replicationStream)
+  )
+  return pipeline(
+    _replicationStream,
+    wsSafetyTransform(ws),
+    createWebSocketStream(ws),
+    _replicationStream
+  )
+}
+
+/**
+ * Avoid writing data to a closing or closed websocket, which would result in an
+ * error. Instead we drop the data and wait for the stream close/end events to
+ * propagate and close the streams cleanly.
+ *
+ * @param {WebSocket} ws
+ */
+function wsSafetyTransform(ws) {
+  return new Transform({
+    transform(chunk, encoding, callback) {
+      if (ws.readyState === ws.CLOSED || ws.readyState === ws.CLOSING) {
+        return callback()
+      }
+      callback(null, chunk)
+    },
+  })
+}

package/src/mapeo-manager.js

@@ -16,10 +16,11 @@ import {
   kBlobStore,
   kClearDataIfLeft,
   kProjectLeave,
+  kSetIsArchiveDevice,
   kSetOwnDeviceInfo,
 } from './mapeo-project.js'
 import {
-  localDeviceInfoTable,
+  deviceSettingsTable,
   projectKeysTable,
   projectSettingsTable,
 } from './schema/client.js'
@@ -44,14 +45,15 @@ import { LocalPeers } from './local-peers.js'
 import { InviteApi } from './invite-api.js'
 import { LocalDiscovery } from './discovery/local-discovery.js'
 import { Roles } from './roles.js'
-import NoiseSecretStream from '@hyperswarm/secret-stream'
 import { Logger } from './logger.js'
 import {
   kSyncState,
   kRequestFullStop,
   kRescindFullStopRequest,
 } from './sync/sync-api.js'
+import { NotFoundError } from './errors.js'
 /** @import { ProjectSettingsValue as ProjectValue } from '@comapeo/schema' */
+/** @import NoiseSecretStream from '@hyperswarm/secret-stream' */
 /** @import { SetNonNullable } from 'type-fest' */
 /** @import { CoreStorage, Namespace } from './types.js' */
 /** @import { DeviceInfoParam } from './schema/client.js' */
@@ -79,9 +81,6 @@ export const DEFAULT_FALLBACK_MAP_FILE_PATH = require.resolve(
 export const DEFAULT_ONLINE_STYLE_URL =
   'https://demotiles.maplibre.org/style.json'
 
-export const kRPC = Symbol('rpc')
-export const kManagerReplicate = Symbol('replicate manager')
-
 /**
  * @typedef {Omit<import('./local-peers.js').PeerInfo, 'protomux'>} PublicPeerInfo
  */
@@ -221,33 +220,10 @@ export class MapeoManager extends TypedEmitter {
     this.#localDiscovery.on('connection', this.#replicate.bind(this))
   }
 
-  /**
-   * MapeoRPC instance, used for tests
-   */
-  get [kRPC]() {
-    return this.#localPeers
-  }
-
   get deviceId() {
     return this.#deviceId
   }
 
-  /**
-   * Create a Mapeo replication stream. This replication connects the Mapeo RPC
-   * channel and allows invites. All active projects will sync automatically to
-   * this replication stream. Only use for local (trusted) connections, because
-   * the RPC channel key is public. To sync a specific project without
-   * connecting RPC, use project[kProjectReplication].
-   *
-   * @param {boolean} isInitiator
-   */
-  [kManagerReplicate](isInitiator) {
-    const noiseStream = new NoiseSecretStream(isInitiator, undefined, {
-      keyPair: this.#keyManager.getIdentityKeypair(),
-    })
-    return this.#replicate(noiseStream)
-  }
-
   /**
    * @param {'blobs' | 'icons' | 'maps'} mediaType
    * @returns {Promise<string>}
@@ -481,7 +457,7 @@ export class MapeoManager extends TypedEmitter {
       .get()
 
     if (!projectKeysTableResult) {
-      throw new Error(`NotFound: project ID ${projectPublicId} not found`)
+      throw new NotFoundError(`Project ID ${projectPublicId} not found`)
     }
 
     const { projectId } = projectKeysTableResult
@@ -507,6 +483,7 @@ export class MapeoManager extends TypedEmitter {
   async #createProjectInstance(projectKeys) {
     validateProjectKeys(projectKeys)
     const projectId = keyToId(projectKeys.projectKey)
+    const isArchiveDevice = this.getIsArchiveDevice()
     const project = new MapeoProject({
       ...this.#projectStorage(projectId),
       ...projectKeys,
@@ -517,6 +494,7 @@ export class MapeoManager extends TypedEmitter {
       localPeers: this.#localPeers,
       logger: this.#loggerBase,
       getMediaBaseUrl: this.#getMediaBaseUrl.bind(this),
+      isArchiveDevice,
     })
     await project[kClearDataIfLeft]()
     return project
@@ -579,7 +557,7 @@ export class MapeoManager extends TypedEmitter {
    * downloaded their proof of project membership and the project config.
    *
    * @param {Pick<import('./generated/rpc.js').ProjectJoinDetails, 'projectKey' | 'encryptionKeys'> & { projectName: string }} projectJoinDetails
-   * @param {{ waitForSync?: boolean }} [opts] For internal use in tests, set opts.waitForSync = false to not wait for sync during addProject()
+   * @param {{ waitForSync?: boolean }} [opts] Set opts.waitForSync = false to not wait for sync during addProject()
    * @returns {Promise<string>}
    */
   addProject = async (
@@ -733,9 +711,7 @@ export class MapeoManager extends TypedEmitter {
   }
 
   /**
-   * @typedef {Exclude<
-   * import('./schema/client.js').DeviceInfoParam['deviceType'],
-   * 'selfHostedServer'>} RPCDeviceType
+   * @typedef {import('./schema/client.js').DeviceInfoParam['deviceType']} RPCDeviceType
    */
 
   /**
@@ -746,10 +722,10 @@ export class MapeoManager extends TypedEmitter {
   async setDeviceInfo(deviceInfo) {
     const values = { deviceId: this.#deviceId, deviceInfo }
     this.#db
-      .insert(localDeviceInfoTable)
+      .insert(deviceSettingsTable)
       .values(values)
       .onConflictDoUpdate({
-        target: localDeviceInfoTable.deviceId,
+        target: deviceSettingsTable.deviceId,
         set: values,
       })
       .run()
@@ -762,13 +738,22 @@ export class MapeoManager extends TypedEmitter {
       })
     )
 
-    await Promise.all(
-      this.#localPeers.peers
-        .filter(({ status }) => status === 'connected')
-        .map((peer) =>
-          this.#localPeers.sendDeviceInfo(peer.deviceId, deviceInfo)
-        )
-    )
+    if (deviceInfo.deviceType !== 'selfHostedServer') {
+      // We have to make a copy of this because TypeScript can't guarantee that
+      // `deviceInfo` won't be mutated by the time it gets to the
+      // `sendDeviceInfo` call below.
+      const deviceInfoToSend = {
+        ...deviceInfo,
+        deviceType: deviceInfo.deviceType,
+      }
+      await Promise.all(
+        this.#localPeers.peers
+          .filter(({ status }) => status === 'connected')
+          .map((peer) =>
+            this.#localPeers.sendDeviceInfo(peer.deviceId, deviceInfoToSend)
+          )
+      )
+    }
 
     this.#l.log('set device info %o', deviceInfo)
   }
@@ -784,8 +769,8 @@ export class MapeoManager extends TypedEmitter {
   getDeviceInfo() {
     const row = this.#db
       .select()
-      .from(localDeviceInfoTable)
-      .where(eq(localDeviceInfoTable.deviceId, this.#deviceId))
+      .from(deviceSettingsTable)
+      .where(eq(deviceSettingsTable.deviceId, this.#deviceId))
       .get()
     return {
       deviceId: this.#deviceId,
@@ -794,6 +779,50 @@ export class MapeoManager extends TypedEmitter {
     }
   }
 
+  /**
+   * Set whether this device is an archive device. Archive devices will download
+   * all media during sync, where-as non-archive devices will not download media
+   * original variants, and only download preview and thumbnail variants.
+   * @param {boolean} isArchiveDevice
+   * @returns {void}
+   */
+  setIsArchiveDevice(isArchiveDevice) {
+    const values = { deviceId: this.#deviceId, isArchiveDevice }
+    const result = this.#db
+      .insert(deviceSettingsTable)
+      .values(values)
+      .onConflictDoUpdate({
+        target: deviceSettingsTable.deviceId,
+        set: values,
+      })
+      .run()
+    if (!result || result.changes === 0) {
+      throw new Error('Failed to set isArchiveDevice')
+    }
+    for (const project of this.#activeProjects.values()) {
+      project[kSetIsArchiveDevice](isArchiveDevice)
+    }
+  }
+
+  /**
+   * Get whether this device is an archive device. Archive devices will download
+   * all media during sync, where-as non-archive devices will not download media
+   * original variants, and only download preview and thumbnail variants.
+   * @returns {boolean} isArchiveDevice
+   */
+  getIsArchiveDevice() {
+    const row = this.#db
+      .select()
+      .from(deviceSettingsTable)
+      .where(eq(deviceSettingsTable.deviceId, this.#deviceId))
+      .get()
+    if (typeof row?.isArchiveDevice === 'boolean') {
+      return row.isArchiveDevice
+    } else {
+      return true
+    }
+  }
+
   /**
    * @returns {InviteApi}
    */
@@ -868,7 +897,7 @@ export class MapeoManager extends TypedEmitter {
       .get()
 
     if (!row) {
-      throw new Error(`NotFound: project ID ${projectPublicId} not found`)
+      throw new NotFoundError(`Project ID ${projectPublicId} not found`)
     }
 
     const { keysCipher, projectId, projectInfo } = row