libp2r2p 0.5.0 → 0.7.0

package/private-message/index.js

@@ -12,6 +12,7 @@ const HEX_PUBKEY = /^[0-9a-f]{64}$/i
 
 const watchesByChannel = new Map()
 const subsByRelay = new Map()
+let nextWatchRevision = 1
 
 function nowSeconds () {
   return Math.floor(Date.now() / 1000)
@@ -254,6 +255,27 @@ function maxWatchNumber (channels, field) {
   return values.length ? Math.max(...values) : undefined
 }
 
+function watchNumbersForChannels (channels, field) {
+  const out = {}
+  for (const channel of channels) {
+    const value = watchesByChannel.get(channel)?.[field]
+    if (Number.isFinite(value)) out[channel] = value
+  }
+  return out
+}
+
+function watchRevisionsForChannels (channels) {
+  return Object.fromEntries(channels.map(channel => [channel, watchesByChannel.get(channel)?.revision || 0]))
+}
+
+function subscriptionMatches (current, channels) {
+  if (!current || !setEquals(current.channels, channels)) return false
+  for (const channel of channels) {
+    if (current.revisions?.[channel] !== watchesByChannel.get(channel)?.revision) return false
+  }
+  return true
+}
+
 function firstWatchValue (channels, field) {
   for (const channel of channels) {
     const value = watchesByChannel.get(channel)?.[field]
@@ -263,25 +285,34 @@ function firstWatchValue (channels, field) {
 }
 
 function closeSubscription (sub, gracefulClose) {
-  if (gracefulClose) setTimeout(() => sub.close(), RESUBSCRIBE_GRACE_MS)
-  else sub.close()
+  if (gracefulClose) {
+    setTimeout(() => Promise.resolve().then(() => sub.close()).catch(() => {}), RESUBSCRIBE_GRACE_MS)
+    return null
+  }
+  try {
+    return Promise.resolve(sub.close())
+  } catch (err) {
+    return Promise.reject(err)
+  }
 }
 
 function rebuildSubscriptions ({ _subscribe = privateChannel.subscribe, gracefulClose = true } = {}) {
   const desired = desiredRelayState()
+  const closing = []
 
   for (const [relay, current] of subsByRelay) {
     const nextChannels = desired.get(relay)
-    if (nextChannels && setEquals(current.channels, nextChannels)) continue
+    if (nextChannels && subscriptionMatches(current, nextChannels)) continue
     if (!nextChannels) {
-      closeSubscription(current.sub, gracefulClose)
+      const close = closeSubscription(current.sub, gracefulClose)
+      if (close) closing.push(close)
       subsByRelay.delete(relay)
     }
   }
 
   for (const [relay, channels] of desired) {
     const current = subsByRelay.get(relay)
-    if (current && setEquals(current.channels, channels)) continue
+    if (subscriptionMatches(current, channels)) continue
 
     const channelList = [...channels]
     const firstWatch = watchesByChannel.get(channelList[0])
@@ -300,8 +331,9 @@ function rebuildSubscriptions ({ _subscribe = privateChannel.subscribe, graceful
       mode: firstWatch.mode,
       modeByPubkey: modesForChannels(channelList),
       receivedChunkTtlMs: maxWatchNumber(channelList, 'receivedChunkTtlMs'),
+      receivedChunkTtlMsByPubkey: watchNumbersForChannels(channelList, 'receivedChunkTtlMs'),
       receivedChunkMaxBytes: maxWatchNumber(channelList, 'receivedChunkMaxBytes'),
-      receivedChunkStorageArea: firstWatchValue(channelList, 'receivedChunkStorageArea'),
+      receivedChunkIndexedDB: firstWatchValue(channelList, 'receivedChunkIndexedDB'),
       ignoredGroupTtlMs: maxWatchNumber(channelList, 'ignoredGroupTtlMs'),
       ignoredGroupMaxEntries: maxWatchNumber(channelList, 'ignoredGroupMaxEntries'),
       limit: 0,
@@ -321,9 +353,17 @@ function rebuildSubscriptions ({ _subscribe = privateChannel.subscribe, graceful
       onError: err => firstWatch.callbacks.onError?.(err)
     })
 
-    subsByRelay.set(relay, { channels: new Set(channels), sub })
-    if (current) closeSubscription(current.sub, gracefulClose)
+    subsByRelay.set(relay, {
+      channels: new Set(channels),
+      revisions: watchRevisionsForChannels(channelList),
+      sub
+    })
+    if (current) {
+      const close = closeSubscription(current.sub, gracefulClose)
+      if (close) closing.push(close)
+    }
   }
+  return Promise.allSettled(closing)
 }
 
 export async function watch ({
@@ -348,7 +388,7 @@ export async function watch ({
   onError,
   receivedChunkTtlMs,
   receivedChunkMaxBytes,
-  receivedChunkStorageArea,
+  receivedChunkIndexedDB,
   ignoredGroupTtlMs,
   ignoredGroupMaxEntries,
   since = nowSeconds(),
@@ -372,26 +412,30 @@ export async function watch ({
       mode,
       receivedChunkTtlMs,
       receivedChunkMaxBytes,
-      receivedChunkStorageArea,
+      receivedChunkIndexedDB,
       ignoredGroupTtlMs,
       ignoredGroupMaxEntries,
       callbacks,
       since
     }
     const current = watchesByChannel.get(channel)
-    if (
+    const sameSettings = Boolean(
       current &&
-      setEquals(new Set(current.relays), new Set(next.relays)) &&
+      current.receiverSigner === next.receiverSigner &&
+      current.iykcSigner === next.iykcSigner &&
       current.privateChannelSigner === next.privateChannelSigner &&
       current.privateChannelReaderSigner === next.privateChannelReaderSigner &&
       current.privateChannelReaderPubkey === next.privateChannelReaderPubkey &&
+      current.receiverPubkey === next.receiverPubkey &&
       current.mode === next.mode &&
       current.receivedChunkTtlMs === next.receivedChunkTtlMs &&
       current.receivedChunkMaxBytes === next.receivedChunkMaxBytes &&
-      current.receivedChunkStorageArea === next.receivedChunkStorageArea &&
+      current.receivedChunkIndexedDB === next.receivedChunkIndexedDB &&
       current.ignoredGroupTtlMs === next.ignoredGroupTtlMs &&
       current.ignoredGroupMaxEntries === next.ignoredGroupMaxEntries
-    ) {
+    )
+    next.revision = sameSettings ? current.revision : nextWatchRevision++
+    if (sameSettings && setEquals(new Set(current.relays), new Set(next.relays))) {
       current.callbacks = callbacks
       continue
     }
@@ -399,18 +443,19 @@ export async function watch ({
     changed = true
   }
 
-  if (changed) rebuildSubscriptions({ _subscribe })
+  if (changed) await rebuildSubscriptions({ _subscribe })
   return () => unwatch(channelList)
 }
 
 export function unwatch (channels) {
   const channelList = channels ? uniq(Array.isArray(channels) ? channels : [channels]) : [...watchesByChannel.keys()]
   for (const channel of channelList) watchesByChannel.delete(channel)
-  rebuildSubscriptions({ gracefulClose: false })
+  return rebuildSubscriptions({ gracefulClose: false })
 }
 
 export function clearChannelState (channelPubkey) {
-  if (watchesByChannel.has(channelPubkey)) unwatch(channelPubkey)
+  if (watchesByChannel.has(channelPubkey)) return unwatch(channelPubkey)
+  return Promise.resolve([])
 }
 
 async function sendPrivateMessage ({