initial invite api

src/generated/rpc.ts

@@ -14,7 +14,7 @@ export interface Invite_ProjectInfo {
 }
 
 export interface InviteResponse {
-  projectKey: Buffer;
+  projectKey: Buffer | Uint8Array;
   decision: InviteResponse_Decision;
 }
 

src/invite-api.js

@@ -0,0 +1,76 @@
+import { TypedEmitter } from 'tiny-typed-emitter'
+import { InviteResponse_Decision } from './generated/rpc.js'
+import { idToKey, keyToId } from './utils.js'
+
+/** @typedef {import('./rpc/index.js').MapeoRPC} MapeoRPC */
+
+export class InviteApi extends TypedEmitter {
+  // TODO: are invites persisted beyond this api?
+  #invites = new Map()
+
+  /**
+   * @param {Object} options
+   * @param {MapeoRPC} options.rpc
+   */
+  constructor({ rpc }) {
+    super()
+    this.rpc = rpc
+
+    // TODO: I'm not seeing encryption keys used in the inviteResponse in the rpc api
+    // what is the purpose of the encryption keys at this stage of the process or afterward?
+    this.rpc.on('invite', (peerId, invite) => {
+      const projectId = keyToId(invite.projectKey)
+      const peerIds = this.#invites.get(projectId) || new Set()
+      peerIds.add(peerId)
+      this.#invites.set(projectId, peerIds)
+
+      if (peerIds.size === 1) {
+        this.emit('invite-received', {
+          projectId,
+          peerId,
+        })
+      }
+    })
+  }
+
+  /**
+   * @param {string} projectId
+   */
+  accept(projectId) {
+    this.#respond({ projectId, decision: InviteResponse_Decision.ACCEPT })
+  }
+
+  /**
+   * @param {string} projectId
+   */
+  reject(projectId) {
+    this.#respond({ projectId, decision: InviteResponse_Decision.REJECT })
+  }
+
+  /**
+   * @param {Object} options
+   * @param {string} options.projectId
+   * @param {InviteResponse_Decision} options.decision
+   */
+  #respond({ projectId, decision }) {
+    const peerIds = this.#getPeerIds(projectId)
+    const projectKey = idToKey(projectId)
+
+    // TODO: should this reply to  one peer with `ACCEPT` and the rest with `ALREADY`?
+    // How is the `ALREADY` decision determined? It looks like that isn't used yet.
+    // Does anything bad happen if we respond to multiple peers with `ACCEPT`?
+    for (const peerId of peerIds.values()) {
+      this.rpc.inviteResponse(peerId, { projectKey, decision })
+    }
+
+    this.#invites.delete(projectId)
+  }
+
+  /**
+   * @param {string} projectId
+   * @returns {Set<string>} peerIds
+   */
+  #getPeerIds(projectId) {
+    return this.#invites.get(projectId) || new Set()
+  }
+}

src/utils.js

@@ -14,7 +14,7 @@ export function idToKey(id) {
 
 /**
  *
- * @param {Buffer|String} key
+ * @param {Buffer|Uint8Array|String} key
  * @returns {String}
  */
 export function keyToId(key) {

tests/helpers/rpc.js

@@ -0,0 +1,34 @@
+import NoiseSecretStream from '@hyperswarm/secret-stream'
+
+export function replicate(rpc1, rpc2) {
+  const n1 = new NoiseSecretStream(true, undefined, {
+    // Keep keypairs deterministic for tests, since we use peer.publicKey as an identifier.
+    keyPair: NoiseSecretStream.keyPair(Buffer.allocUnsafe(32).fill(0)),
+  })
+  const n2 = new NoiseSecretStream(false, undefined, {
+    keyPair: NoiseSecretStream.keyPair(Buffer.allocUnsafe(32).fill(1)),
+  })
+  n1.rawStream.pipe(n2.rawStream).pipe(n1.rawStream)
+
+  rpc1.connect(n1)
+  rpc2.connect(n2)
+
+  return async function destroy() {
+    return Promise.all([
+      /** @type {Promise<void>} */
+      (
+        new Promise((res) => {
+          n1.on('close', res)
+          n1.destroy()
+        })
+      ),
+      /** @type {Promise<void>} */
+      (
+        new Promise((res) => {
+          n2.on('close', res)
+          n2.destroy()
+        })
+      ),
+    ])
+  }
+}

tests/invite-api.js

@@ -0,0 +1,49 @@
+// @ts-check
+import test from 'brittle'
+import { MapeoRPC } from '../src/rpc/index.js'
+import { InviteApi } from '../src/invite-api.js'
+import { replicate } from './helpers/rpc.js'
+
+test('Accept invite', async (t) => {
+  t.plan(3)
+  const r1 = new MapeoRPC()
+  const r2 = new MapeoRPC()
+  const inviteApi = new InviteApi({ rpc: r2 })
+
+  const projectKey = Buffer.allocUnsafe(32).fill(0)
+
+  r1.on('peers', async (peers) => {
+    t.is(peers.length, 1)
+    const response = await r1.invite(peers[0].id, { projectKey })
+    t.is(response, MapeoRPC.InviteResponse.ACCEPT)
+  })
+
+  inviteApi.on('invite-received', ({ projectId }) => {
+    t.is(projectId, projectKey.toString('hex'))
+    inviteApi.accept(projectId)
+  })
+
+  replicate(r1, r2)
+})
+
+test('Reject invite', async (t) => {
+  t.plan(3)
+  const r1 = new MapeoRPC()
+  const r2 = new MapeoRPC()
+  const inviteApi = new InviteApi({ rpc: r2 })
+
+  const projectKey = Buffer.allocUnsafe(32).fill(0)
+
+  r1.on('peers', async (peers) => {
+    t.is(peers.length, 1)
+    const response = await r1.invite(peers[0].id, { projectKey })
+    t.is(response, MapeoRPC.InviteResponse.REJECT)
+  })
+
+  inviteApi.on('invite-received', ({ projectId }) => {
+    t.is(projectId, projectKey.toString('hex'))
+    inviteApi.reject(projectId)
+  })
+
+  replicate(r1, r2)
+})

tests/rpc.js

@@ -1,6 +1,5 @@
 // @ts-check
 import test from 'brittle'
-import NoiseSecretStream from '@hyperswarm/secret-stream'
 import {
   MapeoRPC,
   PeerDisconnectedError,
@@ -10,6 +9,7 @@ import {
 import FakeTimers from '@sinonjs/fake-timers'
 import { once } from 'events'
 import { Duplex } from 'streamx'
+import { replicate } from './helpers/rpc.js'
 
 test('Send invite and accept', async (t) => {
   t.plan(3)
@@ -365,36 +365,3 @@ test('invalid stream', (t) => {
   const regularStream = new Duplex()
   t.exception(() => r1.connect(regularStream), 'Invalid stream')
 })
-
-function replicate(rpc1, rpc2) {
-  const n1 = new NoiseSecretStream(true, undefined, {
-    // Keep keypairs deterministic for tests, since we use peer.publicKey as an identifier.
-    keyPair: NoiseSecretStream.keyPair(Buffer.allocUnsafe(32).fill(0)),
-  })
-  const n2 = new NoiseSecretStream(false, undefined, {
-    keyPair: NoiseSecretStream.keyPair(Buffer.allocUnsafe(32).fill(1)),
-  })
-  n1.rawStream.pipe(n2.rawStream).pipe(n1.rawStream)
-
-  rpc1.connect(n1)
-  rpc2.connect(n2)
-
-  return async function destroy() {
-    return Promise.all([
-      /** @type {Promise<void>} */
-      (
-        new Promise((res) => {
-          n1.on('close', res)
-          n1.destroy()
-        })
-      ),
-      /** @type {Promise<void>} */
-      (
-        new Promise((res) => {
-          n2.on('close', res)
-          n2.destroy()
-        })
-      ),
-    ])
-  }
-}