@comapeo/core 6.0.2 → 7.0.1

package/src/generated/rpc.ts

@@ -1,4 +1,5 @@
 /* eslint-disable */
+import Long from "long";
 import _m0 from "protobufjs/minimal.js";
 import { EncryptionKeys } from "./keys.js";
 
@@ -181,6 +182,31 @@ export interface ProjectJoinDetailsAck {
   inviteId: Buffer;
 }
 
+export interface MapShareExtension {
+  /** URLs to map share */
+  mapShareUrls: string[];
+  /** ID of peer that can receive the map share (each map share is linked to a specific device ID) */
+  receiverDeviceKey: Buffer;
+  /** The ID of the map share */
+  shareId: string;
+  /** The name of the map being shared */
+  mapName: string;
+  /** The ID of the map being shared */
+  mapId: string;
+  /** When ths share was created */
+  mapShareCreatedAt: number;
+  /** When the map was created */
+  mapCreatedAt: number;
+  /** The bounding box of the map data being shared */
+  bounds: number[];
+  /** The minimum zoom level of the map data being shared */
+  minzoom: number;
+  /** The maximum zoom level of the map data being shared */
+  maxzoom: number;
+  /** Estimated size of the map data being shared in bytes */
+  estimatedSizeBytes: number;
+}
+
 function createBaseInvite(): Invite {
   return {
     inviteId: Buffer.alloc(0),
@@ -761,6 +787,204 @@ export const ProjectJoinDetailsAck = {
   },
 };
 
+function createBaseMapShareExtension(): MapShareExtension {
+  return {
+    mapShareUrls: [],
+    receiverDeviceKey: Buffer.alloc(0),
+    shareId: "",
+    mapName: "",
+    mapId: "",
+    mapShareCreatedAt: 0,
+    mapCreatedAt: 0,
+    bounds: [],
+    minzoom: 0,
+    maxzoom: 0,
+    estimatedSizeBytes: 0,
+  };
+}
+
+export const MapShareExtension = {
+  encode(message: MapShareExtension, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.mapShareUrls) {
+      writer.uint32(10).string(v!);
+    }
+    if (message.receiverDeviceKey.length !== 0) {
+      writer.uint32(18).bytes(message.receiverDeviceKey);
+    }
+    if (message.shareId !== "") {
+      writer.uint32(26).string(message.shareId);
+    }
+    if (message.mapName !== "") {
+      writer.uint32(34).string(message.mapName);
+    }
+    if (message.mapId !== "") {
+      writer.uint32(42).string(message.mapId);
+    }
+    if (message.mapShareCreatedAt !== 0) {
+      writer.uint32(48).uint64(message.mapShareCreatedAt);
+    }
+    if (message.mapCreatedAt !== 0) {
+      writer.uint32(56).uint64(message.mapCreatedAt);
+    }
+    writer.uint32(66).fork();
+    for (const v of message.bounds) {
+      writer.double(v);
+    }
+    writer.ldelim();
+    if (message.minzoom !== 0) {
+      writer.uint32(72).int32(message.minzoom);
+    }
+    if (message.maxzoom !== 0) {
+      writer.uint32(80).int32(message.maxzoom);
+    }
+    if (message.estimatedSizeBytes !== 0) {
+      writer.uint32(88).uint64(message.estimatedSizeBytes);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MapShareExtension {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMapShareExtension();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.mapShareUrls.push(reader.string());
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.receiverDeviceKey = reader.bytes() as Buffer;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.shareId = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.mapName = reader.string();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.mapId = reader.string();
+          continue;
+        case 6:
+          if (tag !== 48) {
+            break;
+          }
+
+          message.mapShareCreatedAt = longToNumber(reader.uint64() as Long);
+          continue;
+        case 7:
+          if (tag !== 56) {
+            break;
+          }
+
+          message.mapCreatedAt = longToNumber(reader.uint64() as Long);
+          continue;
+        case 8:
+          if (tag === 65) {
+            message.bounds.push(reader.double());
+
+            continue;
+          }
+
+          if (tag === 66) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.bounds.push(reader.double());
+            }
+
+            continue;
+          }
+
+          break;
+        case 9:
+          if (tag !== 72) {
+            break;
+          }
+
+          message.minzoom = reader.int32();
+          continue;
+        case 10:
+          if (tag !== 80) {
+            break;
+          }
+
+          message.maxzoom = reader.int32();
+          continue;
+        case 11:
+          if (tag !== 88) {
+            break;
+          }
+
+          message.estimatedSizeBytes = longToNumber(reader.uint64() as Long);
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  create<I extends Exact<DeepPartial<MapShareExtension>, I>>(base?: I): MapShareExtension {
+    return MapShareExtension.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<MapShareExtension>, I>>(object: I): MapShareExtension {
+    const message = createBaseMapShareExtension();
+    message.mapShareUrls = object.mapShareUrls?.map((e) => e) || [];
+    message.receiverDeviceKey = object.receiverDeviceKey ?? Buffer.alloc(0);
+    message.shareId = object.shareId ?? "";
+    message.mapName = object.mapName ?? "";
+    message.mapId = object.mapId ?? "";
+    message.mapShareCreatedAt = object.mapShareCreatedAt ?? 0;
+    message.mapCreatedAt = object.mapCreatedAt ?? 0;
+    message.bounds = object.bounds?.map((e) => e) || [];
+    message.minzoom = object.minzoom ?? 0;
+    message.maxzoom = object.maxzoom ?? 0;
+    message.estimatedSizeBytes = object.estimatedSizeBytes ?? 0;
+    return message;
+  },
+};
+
+declare const self: any | undefined;
+declare const window: any | undefined;
+declare const global: any | undefined;
+const tsProtoGlobalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 
 type DeepPartial<T> = T extends Builtin ? T
@@ -771,3 +995,15 @@ type DeepPartial<T> = T extends Builtin ? T
 type KeysOfUnion<T> = T extends T ? keyof T : never;
 type Exact<P, I extends P> = P extends Builtin ? P
   : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}

package/src/index.js

@@ -9,8 +9,8 @@ export { FastifyController } from './fastify-controller.js'
 export { MapeoManager } from './mapeo-manager.js'
 
 // Type exports
-/** @typedef {import('./mapeo-project.js').MapShare} MapShare */
-/** @typedef {import('./generated/extensions.js').MapShareExtension} MapShareExtension */
+/** @typedef {import('./mapeo-manager.js').MapShare} MapShare */
+/** @typedef {import('./generated/rpc.js').MapShareExtension} MapShareExtension */
 /** @typedef {import('./mapeo-project.js').MapeoProject} MapeoProject */
 /** @typedef {import('./mapeo-project.js').RoleChangeEvent} RoleChangeEvent */
 /** @typedef {import('./mapeo-manager.js').PublicPeerInfo} PublicPeerInfo */

package/src/local-peers.js

@@ -15,6 +15,7 @@ import {
   ProjectJoinDetails,
   ProjectJoinDetailsAck,
   DeviceInfo_RPCFeatures,
+  MapShareExtension,
 } from './generated/rpc.js'
 import pDefer from 'p-defer'
 import { Logger } from './logger.js'
@@ -69,6 +70,7 @@ const MESSAGE_TYPES = {
   InviteCancelAck: 6,
   InviteResponseAck: 7,
   ProjectJoinDetailsAck: 8,
+  MapShareExtension: 9,
 }
 const MESSAGES_MAX_ID = Math.max.apply(null, [...Object.values(MESSAGE_TYPES)])
 
@@ -289,6 +291,19 @@ class Peer {
     const messageType = MESSAGE_TYPES.Invite
     await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
   }
+
+  /**
+   * @param {MapShareExtension} mapShare
+   * @returns {Promise<void>}
+   */
+  async sendMapShare(mapShare) {
+    this.#assertConnected('Peer disconnected before sending map share')
+    const buf = Buffer.from(MapShareExtension.encode(mapShare).finish())
+    const messageType = MESSAGE_TYPES.MapShareExtension
+    await this.#waitForDrain(this.#channel.messages[messageType].send(buf))
+    this.#log('sent map share %s', mapShare.shareId)
+  }
+
   /**
    * @param {Invite} invite
    * @returns {Promise<void>}
@@ -433,6 +448,7 @@ class Peer {
  * @property {(peerId: string, inviteResponse: InviteResponseAck) => void} invite-response-ack Emitted when an invite response acknowledgement is received
  * @property {(peerId: string, details: ProjectJoinDetails) => void} got-project-details Emitted when project details are received
  * @property {(peerId: string, details: ProjectJoinDetailsAck) => void} got-project-details-ack Emitted when project details are acknowledged as received
+ * @property {(sender: PeerInfo, details: MapShareExtension) => void} map-share Emitted when a MapShare request is received
  * @property {(discoveryKey: Buffer, protomux: Protomux<import('@hyperswarm/secret-stream')>) => void} discovery-key Emitted when a new hypercore is replicated (by a peer) to a peer protomux instance (passed as the second parameter)
  * @property {(messageType: string, errorMessage?: string) => void} failed-to-handle-message Emitted when we received a message we couldn't handle for some reason. Primarily useful for testing
  */
@@ -468,6 +484,17 @@ export class LocalPeers extends TypedEmitter {
     return connectedPeerInfos
   }
 
+  /**
+   * @param {string} deviceId
+   * @param {MapShareExtension} mapShare
+   * @returns {Promise<void>}
+   */
+  async sendMapShare(deviceId, mapShare) {
+    await this.#waitForPendingConnections()
+    const peer = await this.#getPeerByDeviceId(deviceId)
+    await peer.sendMapShare(mapShare)
+  }
+
   /**
    * @param {string} deviceId
    * @param {Invite} invite
@@ -783,6 +810,12 @@ export class LocalPeers extends TypedEmitter {
         this.#emitPeers()
         break
       }
+      case 'MapShareExtension': {
+        const mapShare = MapShareExtension.decode(value)
+        const info = /** @type {PeerInfo} */ (peer.info)
+        this.emit('map-share', info, mapShare)
+        break
+      }
       case 'InviteAck': {
         const ack = InviteAck.decode(value)
         peer.receiveAck('InviteAck', ack)

package/src/mapeo-manager.js

@@ -7,6 +7,7 @@ import { drizzle } from 'drizzle-orm/better-sqlite3'
 import Hypercore from 'hypercore'
 import { TypedEmitter } from 'tiny-typed-emitter'
 import { createRequire } from 'module'
+import ensureError from 'ensure-error'
 
 import { IndexWriter } from './index-writer/index.js'
 import {
@@ -36,6 +37,7 @@ import {
   projectKeyToProjectInviteId,
   projectKeyToPublicId,
   timeoutPromise,
+  validateMapShareExtension,
 } from './utils.js'
 import { openedNoiseSecretStream } from './lib/noise-secret-stream-helpers.js'
 import { omit } from './lib/omit.js'
@@ -61,7 +63,7 @@ import { WebSocket } from 'ws'
 import { excludeKeys } from 'filter-obj'
 import { migrate } from './lib/drizzle-helpers.js'
 
-/** @import { MapShareExtension } from './generated/extensions.js' */
+/** @import { MapShareExtension } from './generated/rpc.js' */
 /** @import NoiseSecretStream from '@hyperswarm/secret-stream' */
 /** @import { SetNonNullable } from 'type-fest' */
 /** @import { ProjectJoinDetails, } from './generated/rpc.js' */
@@ -74,6 +76,24 @@ import { migrate } from './lib/drizzle-helpers.js'
 /** @typedef {Pick<ProjectSettings, 'createdAt' | 'updatedAt' | 'name' | 'projectColor' | 'projectDescription' | 'sendStats'>} ListedProjectSettings */
 /** @typedef {ListedProjectSettings & { status: 'joined', projectId: string } | ProjectInfo & { status: 'joining' | 'left', projectId: string }} ListedProject */
 
+/**
+ * @typedef {object} AugmentedMapShareProperties
+ * @property {readonly [number, number, number, number]} bounds - Bounding box of the shared map [W, S, E, N].
+ * @property {readonly [string, ...string[]]} mapShareUrls - URLs associated with the map share.
+ * @property {number} mapShareReceivedAt - Timestamp when the map share was received.
+ * @property {string} senderDeviceId - The ID of the device that sent the map share.
+ * @property {string} [senderDeviceName] - The name of the device that sent the map share.
+ * @property {string} receiverDeviceId - The deviceId of the peer the map share was sent to
+ */
+
+/**
+ * @typedef {Omit<MapShareExtension, 'bounds' | 'mapShareUrls' | 'receiverDeviceKey'> & AugmentedMapShareProperties} MapShare
+ */
+
+/**
+ * @typedef {Omit<MapShare, 'mapShareReceivedAt' | 'senderDeviceId' | 'senderDeviceName'>} MapShareSend
+ */
+
 const CLIENT_SQLITE_FILE_NAME = 'client.db'
 
 // Max file descriptors that RandomAccessFile should use for hypercore storage
@@ -107,7 +127,7 @@ export const DEFAULT_IS_ARCHIVE_DEVICE = true
 /**
  * @typedef {object} MapeoManagerEvents
  * @property {(peers: PublicPeerInfo[]) => void} local-peers Emitted when the list of connected peers changes (new ones added, or connection status changes)
- * @property {(mapShare: import('./mapeo-project.js').MapShare) => void} map-share Emitted when a project has recieved a map share request
+ * @property {(mapShare: MapShare) => void} map-share Emitted when a project has recieved a map share request
  * @property {(e: Error, mapShare: MapShareExtension) => void} map-share-error - Emitted when an incoming map share fails to be recieved due to formatting issues
  */
 
@@ -202,6 +222,15 @@ export class MapeoManager extends TypedEmitter {
         this.#l.log('Received dk %h but no active projects', dk)
       }
     })
+    this.#localPeers.on('map-share', (deviceId, mapShareBase) =>
+      this.#handleMapShare(deviceId, mapShareBase).catch((e) => {
+        this.emit('map-share-error', e, mapShareBase)
+        this.#l.log(
+          'Error: Unable to handle incoming Map Share',
+          ensureError(e)
+        )
+      })
+    )
 
     this.#projectSettingsIndexWriter = new IndexWriter({
       tables: [projectSettingsTable],
@@ -491,6 +520,11 @@ export class MapeoManager extends TypedEmitter {
     // TODO: Close the project instance instead of keeping it around
     this.#activeProjects.set(projectPublicId, project)
 
+    // Make sure to clean up when closed
+    project.once('close', () => {
+      this.#activeProjects.delete(projectPublicId)
+    })
+
     // 7. Load config, if relevant
     // TODO: see how to expose warnings to frontend
     // eslint-disable-next-line no-unused-vars
@@ -554,6 +588,11 @@ export class MapeoManager extends TypedEmitter {
     // 3. Keep track of project instance as we know it's a properly existing project
     this.#activeProjects.set(projectPublicId, project)
 
+    // Make sure to clean up when closed
+    project.once('close', () => {
+      this.#activeProjects.delete(projectPublicId)
+    })
+
     return project
   }
 
@@ -583,34 +622,6 @@ export class MapeoManager extends TypedEmitter {
       },
     })
 
-    const projectPublicId = projectKeyToPublicId(projectKeys.projectKey)
-
-    /**
-     * @param {import('./mapeo-project.js').MapShare} mapShare
-     */
-    const onMapShare = (mapShare) => {
-      this.emit('map-share', mapShare)
-    }
-
-    /**
-     *
-     * @param {Error} e
-     * @param {MapShareExtension} mapShareExtension
-     */
-    const onMapShareError = (e, mapShareExtension) => {
-      this.emit('map-share-error', e, mapShareExtension)
-    }
-
-    project.once('close', () => {
-      this.#activeProjects.delete(projectPublicId)
-      project.removeListener('map-share', onMapShare)
-      project.removeListener('map-share-error', onMapShareError)
-    })
-
-    project.on('map-share', onMapShare)
-
-    project.on('map-share-error', onMapShareError)
-
     return project
   }
 
@@ -781,11 +792,6 @@ export class MapeoManager extends TypedEmitter {
       throw ensureKnownError(e)
     }
 
-    // Make sure to clean up when closed
-    project.once('close', () => {
-      this.#activeProjects.delete(projectPublicId)
-    })
-
     // Only write info on invite if configured
     if (!invitorWroteDeviceInfo) {
       try {
@@ -1046,6 +1052,58 @@ export class MapeoManager extends TypedEmitter {
     })
   }
 
+  /**
+   * Send a map share offer to the peer with device ID `mapShare.receiverDeviceId`
+   *
+   * @param {MapShareSend} mapShare
+   * @param {object} [options]
+   * @param {boolean} [options.__testOnlyBypassValidation=false] Warning: Do not use!
+   */
+  async sendMapShare(mapShare, { __testOnlyBypassValidation = false } = {}) {
+    const { receiverDeviceId, ...mapShareData } = mapShare
+    const receiverDeviceKey = Buffer.from(receiverDeviceId, 'hex')
+
+    /** @type {MapShareExtension} */
+    // @ts-expect-error readonly fields being assigned as mutable
+    const shareExtension = {
+      ...mapShareData,
+      receiverDeviceKey,
+    }
+    if (!__testOnlyBypassValidation) {
+      validateMapShareExtension(shareExtension)
+    }
+    await this.#localPeers.sendMapShare(receiverDeviceId, shareExtension)
+  }
+
+  /**
+   * @param {import('./local-peers.js').PeerInfo} sender
+   * @param {MapShareExtension} mapShareBase
+   */
+  async #handleMapShare(sender, mapShareBase) {
+    const mapShareReceivedAt = Date.now()
+
+    validateMapShareExtension(mapShareBase)
+
+    const { receiverDeviceKey, ...mapShareData } = mapShareBase
+
+    const receiverDeviceId = receiverDeviceKey.toString('hex')
+
+    if (receiverDeviceId !== this.#deviceId) {
+      throw new Error('Got map share intended for a different peer')
+    }
+
+    /** @type {MapShare} */
+    const mapShare = {
+      ...mapShareData,
+      senderDeviceId: sender.deviceId,
+      senderDeviceName: sender.name,
+      mapShareReceivedAt,
+      receiverDeviceId,
+    }
+
+    this.emit('map-share', mapShare)
+  }
+
   async getMapStyleJsonUrl() {
     await timeoutPromise(Promise.resolve(this.#fastify.ready()), {
       milliseconds: 1000,