@mblaney/holster 1.0.17 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Holster is a service that allows synchronising data between devices using Node, Deno, Bun or the browser.",
   "type": "module",
   "main": "index.js",

package/src/holster.js

@@ -568,25 +568,19 @@ const Holster = opt => {
               if (id) {
                 // It's a rel, read the related node. It might not be in the graph
                 // yet when the listener fires, so we retry with delays.
-                const attemptRead = (retries = 0) => {
-                  wire.get(
-                    {"#": id},
-                    relMsg => {
-                      if (relMsg.put && relMsg.put[id]) {
-                        delete relMsg.put[id]._
-                        delete relMsg.put[id][utils.userPublicKey]
-                        delete relMsg.put[id][utils.userSignature]
-                        cb(relMsg.put[id])
-                      } else if (retries < 5) {
-                        // Data not ready yet, retry after a delay
-                        setTimeout(() => attemptRead(retries + 1), 50)
-                      } else {
-                        // Give up after retries
-                        cb(null)
-                      }
-                    },
-                    _opt,
-                  )
+                const attemptRead = async (retries = 0) => {
+                  const data = await new Promise(res => {
+                    const _ctxid = utils.text.random()
+                    allctx.set(_ctxid, {chain: [{item: null, soul: id}]})
+                    api(_ctxid).next(null, res, _opt)
+                  })
+                  if (data !== null || retries >= 5) {
+                    cb(data)
+                  } else {
+                    // Data not ready, retry after delay
+                    await new Promise(resolve => setTimeout(resolve, 50))
+                    attemptRead(retries + 1)
+                  }
                 }
                 attemptRead()
               } else {

package/src/wire.js

@@ -15,7 +15,7 @@ if (typeof globalThis.WebSocket === "undefined") {
 // Rate limiting with throttling
 const createRateLimiter = isTestEnv => {
   const clients = new Map()
-  const maxRequests = 300 // 5 requests per second
+  const maxRequests = 1000 // requests per minute
   const windowMs = 60000 // 1 minute window
   const disconnectThreshold = 10 // Disconnect after 10 violations
   let cleanupInterval = null
@@ -277,6 +277,18 @@ const Wire = opt => {
         )
       })
     }
+
+    // Always broadcast original data to other peers even if no local update
+    const sendResult = send(
+      JSON.stringify({
+        "#": dup.track(utils.text.random(9)),
+        put: msg.put,
+      }),
+    )
+    if (sendResult && sendResult.err) {
+      console.log(`Error broadcasting put: ${sendResult.err}`)
+    }
+
     if (Object.keys(update.defer).length) {
       setTimeout(() => put({put: update.defer}, send), update.wait)
     }
@@ -353,30 +365,30 @@ const Wire = opt => {
         // used whereas wire spec needs to handle clock skew for updates
         // across the network.
         const update = await Ham.mix(data, graph, opt.secure, listen)
-        const none = Object.keys(update.now).length === 0
-        if (none) {
-          // Nothing to do.
-          cb(null)
-          return
-        }
-
-        if (!(await check(update.now, send, cb))) return
 
-        // Seed pendingReferences with any new references from API calls
-        for (const [soul, node] of Object.entries(update.now)) {
-          if (node && typeof node === "object") {
-            for (const [key, value] of Object.entries(node)) {
-              const soulId = utils.rel.is(value)
-              if (soulId) {
-                // Add referenced soul to pending list
-                pendingReferences.add(soulId)
+        if (Object.keys(update.now).length !== 0) {
+          if (!(await check(update.now, send, cb))) return
+
+          // Seed pendingReferences with any new references from API calls
+          for (const [soul, node] of Object.entries(update.now)) {
+            if (node && typeof node === "object") {
+              for (const [key, value] of Object.entries(node)) {
+                const soulId = utils.rel.is(value)
+                if (soulId) {
+                  // Add referenced soul to pending list
+                  pendingReferences.add(soulId)
+                }
               }
             }
           }
+
+          store.put(update.now, cb)
+        } else {
+          // No local update needed, but still callback
+          if (cb) cb(null)
         }
 
-        store.put(update.now, cb)
-        // Also put data on the wire spec.
+        // Always put data on the wire spec even if no local update needed
         const sendResult = send(
           JSON.stringify({
             "#": dup.track(utils.text.random(9)),
@@ -608,44 +620,51 @@ const Wire = opt => {
     }
 
     // Process next message in queue
-    const data = messageQueue.shift()
-    sendToPeers(data)
-
-    // Start timeout for this message now that it's been sent
-    const msg = JSON.parse(data)
-    const trackId = msg["#"]
-    if (trackId && pendingTimeouts.has(trackId)) {
-      const timeoutConfig = pendingTimeouts.get(trackId)
-      pendingTimeouts.delete(trackId)
-
-      // Respond to callback with null if no response.
-      timeoutConfig.timeoutId = setTimeout(() => {
-        const cb = queue[trackId]
-        if (cb) {
-          const id = timeoutConfig.lex["#"]
-          const ack = {[id]: null}
-          if (typeof timeoutConfig.lex["."] === "string") {
-            ack[id] = {[timeoutConfig.lex["."]]: null}
+    const data = messageQueue[0]
+    const sent = sendToPeers(data)
+
+    if (sent) {
+      // Only remove from queue if successfully sent
+      messageQueue.shift()
+
+      // Start timeout for this message now that it's been sent
+      const msg = JSON.parse(data)
+      const trackId = msg["#"]
+      if (trackId && pendingTimeouts.has(trackId)) {
+        const timeoutConfig = pendingTimeouts.get(trackId)
+        pendingTimeouts.delete(trackId)
+
+        // Respond to callback with null if no response.
+        timeoutConfig.timeoutId = setTimeout(() => {
+          const cb = queue[trackId]
+          if (cb) {
+            const id = timeoutConfig.lex["#"]
+            const ack = {[id]: null}
+            if (typeof timeoutConfig.lex["."] === "string") {
+              ack[id] = {[timeoutConfig.lex["."]]: null}
+            }
+            cb({put: ack})
+            delete queue[trackId]
           }
-          cb({put: ack})
-          delete queue[trackId]
-        }
-      }, timeoutConfig.wait)
+        }, timeoutConfig.wait)
+      }
     }
 
     // Schedule processing of next message if queue not empty
     if (messageQueue.length > 0) {
-      // Add delay between messages to respect rate limits (300 req/min = 200ms)
-      queueProcessor = setTimeout(processQueue, 250)
+      // Add delay between messages to respect rate limit
+      queueProcessor = setTimeout(processQueue, 100)
     } else {
       queueProcessor = null
     }
   }
 
   const sendToPeers = data => {
+    let sentToAtLeastOne = false
     peers.forEach(peer => {
       if (peer && peer.readyState === WebSocket.OPEN) {
         peer.send(data)
+        sentToAtLeastOne = true
       } else {
         const retryHandler = peer._retryHandler || createRetryHandler()
         peer._retryHandler = retryHandler
@@ -663,6 +682,7 @@ const Wire = opt => {
         }
       }
     })
+    return sentToAtLeastOne
   }
 
   const send = data => {
@@ -677,7 +697,7 @@ const Wire = opt => {
     messageQueue.push(data)
     // Start queue processor if not already running
     if (!queueProcessor) {
-      queueProcessor = setTimeout(processQueue, 250)
+      queueProcessor = setTimeout(processQueue, 100)
     }
   }
   if (!(opt.peers instanceof Array)) {