@mblaney/holster 2.3.0 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "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

@@ -73,11 +73,7 @@ const Holster = opt => {
     const data = await new Promise(res => {
       const _ctxid = utils.text.random()
       allctx.set(_ctxid, {chain: [{item: null, soul: id}], user: ctxUser})
-      api(_ctxid).next(
-        null,
-        res,
-        retries === 0 ? utils.obj.put(_opt, "fast", true) : _opt,
-      )
+      api(_ctxid).next(null, res, _opt)
     })
     if (data !== null || retries >= 5) return data
     await new Promise(resolve => setTimeout(resolve, 50))

package/src/wire.js

@@ -534,12 +534,12 @@ const Wire = opt => {
       return
     }
 
-    store.get(lex, (err, ack) => {
-      if (ack) {
+    store.get(lex, (err, stored) => {
+      if (stored) {
         // Populate in-memory graph from store data before sending the server
         // request, so stale server responses with older state are correctly
         // rejected by ham.mix.
-        for (const [soul, node] of Object.entries(ack)) {
+        for (const [soul, node] of Object.entries(stored)) {
           if (!node) continue
           if (!graph[soul]) {
             graph[soul] = {...node}
@@ -567,40 +567,44 @@ const Wire = opt => {
           }
         }
         // Full-node fetch: the graph is now complete for this soul.
-        if (!lex["."] && ack[lex["#"]]) hasNode.add(lex["#"])
-        // Only serve from store if the requested property is present.
-        const node = ack[lex["#"]]
-        const hasProperty =
-          node &&
-          Object.keys(node).some(
-            key => key !== "_" && utils.match(lex["."], key),
-          )
-        if (hasProperty) {
-          // Public keys are immutable once written — never need a wire check.
-          if (!isNode && lex["."] !== utils.userPublicKey) {
-            if (!lex["."] || typeof lex["."] === "string") {
-              const checkKey = lex["#"] + (lex["."] ? "." + lex["."] : "")
-              const now = Date.now()
-              const lastCheck = recentChecks.get(checkKey)
-              if (!lastCheck || now - lastCheck > recentCheckTTL) {
-                recentChecks.set(checkKey, now)
-                const sendResult = send(request)
-                if (sendResult && sendResult.err) {
-                  cb({err: sendResult.err})
-                  return
-                }
-              }
-            } else {
+        if (!lex["."] && stored[lex["#"]]) hasNode.add(lex["#"])
+      }
+
+      // Answered from the graph rather than the raw store result: the merge
+      // above keeps any newer in-memory values, so a local put that store
+      // hasn't finished persisting yet is still included, while everything
+      // already on disk fills in the rest of the node.
+      const ack = {...stored, ...Get(lex, graph, true)}
+      // Only serve locally if the requested property is present.
+      const node = ack[lex["#"]]
+      const hasProperty =
+        node &&
+        Object.keys(node).some(key => key !== "_" && utils.match(lex["."], key))
+      if (hasProperty) {
+        // Public keys are immutable once written - never need a wire check.
+        if (!isNode && lex["."] !== utils.userPublicKey) {
+          if (!lex["."] || typeof lex["."] === "string") {
+            const checkKey = lex["#"] + (lex["."] ? "." + lex["."] : "")
+            const now = Date.now()
+            const lastCheck = recentChecks.get(checkKey)
+            if (!lastCheck || now - lastCheck > recentCheckTTL) {
+              recentChecks.set(checkKey, now)
               const sendResult = send(request)
               if (sendResult && sendResult.err) {
                 cb({err: sendResult.err})
                 return
               }
             }
+          } else {
+            const sendResult = send(request)
+            if (sendResult && sendResult.err) {
+              cb({err: sendResult.err})
+              return
+            }
           }
-          cb(err ? {put: ack, err: err} : {put: ack})
-          return
         }
+        cb(err ? {put: ack, err: err} : {put: ack})
+        return
       }
 
       // Data wasn't found locally, log errors and call back after a timeout.
@@ -678,17 +682,6 @@ const Wire = opt => {
           return
         }
 
-        // Ham.mix has already merged this locally-authored update into
-        // graph[soul], synchronously, before store.put below even starts
-        // persisting it - mark it as fully known now rather than waiting
-        // for a future disk fetch to do so, so a read landing in that
-        // window doesn't get forced through a disk round-trip that could
-        // itself race ahead of this same write and find nothing, even
-        // though the correct answer was already sitting in memory.
-        for (const soul of Object.keys(update.now)) {
-          hasNode.add(soul)
-        }
-
         if (opt.userLimit) {
           for (const [soul, node] of Object.entries(update.now)) {
             const pub = node[utils.userPublicKey]

package/ts/src/get.ts

@@ -59,9 +59,10 @@ const Get = (lex: Lex, graph: Graph, fast?: boolean): Graph | undefined => {
     // return undefined to ensure we get all matching properties from store.
     if (!fast) return undefined
 
+    let found = false
     for (const key of Object.keys(graph[soul]!)) {
       // Always include userPublicKey for verification, regardless of filter
-      if (key === userPublicKey || match(lex["."], key)) {
+      if (key !== "_" && (key === userPublicKey || match(lex["."], key))) {
         node[key] = graph[soul]![key]!
         node._[">"][key] = graph[soul]!._[">"][key]!
         const state = graph[soul]!._[">"][key]!
@@ -69,8 +70,10 @@ const Get = (lex: Lex, graph: Graph, fast?: boolean): Graph | undefined => {
         if (sigs && sigs[state]) {
           signatures[state.toString()] = sigs[state]!
         }
+        found = true
       }
     }
+    if (!found) return undefined
   }
 
   if (Object.keys(signatures).length > 0) {

package/ts/src/holster.ts

@@ -182,11 +182,7 @@ const Holster = (opt?: HolsterOptions | string | string[]): HolsterAPI => {
     const data = await new Promise<unknown>(res => {
       const _ctxid = utils.text.random()
       allctx.set(_ctxid, {chain: [{item: null, soul: id}], user: ctxUser})
-      api(_ctxid).next(
-        null as never,
-        res as never,
-        (retries === 0 ? utils.obj.put(opt, "fast", true) : opt) as never,
-      )
+      api(_ctxid).next(null as never, res as never, opt as never)
     })
     if (data !== null || retries >= 5) return data
     await new Promise(resolve => setTimeout(resolve, 50))

package/ts/src/wire.ts

@@ -593,12 +593,12 @@ const Wire = (opt: HolsterOptions): WireAPI => {
       return
     }
 
-    store.get(lex, (err, ack) => {
-      if (ack) {
+    store.get(lex, (err, stored) => {
+      if (stored) {
         // Populate in-memory graph from store data before sending the server
         // request, so stale server responses with older state are correctly
         // rejected by ham.mix.
-        for (const [soul, node] of Object.entries(ack)) {
+        for (const [soul, node] of Object.entries(stored)) {
           if (!node) continue
           if (!graph[soul]) {
             graph[soul] = {...node} as unknown as Graph[string]
@@ -622,40 +622,44 @@ const Wire = (opt: HolsterOptions): WireAPI => {
           }
         }
         // Full-node fetch: the graph is now complete for this soul.
-        if (!lex["."] && ack[lex["#"]]) hasNode.add(lex["#"])
-        // Only serve from store if the requested property is present.
-        const node = ack[lex["#"]]
-        const hasProperty =
-          node &&
-          Object.keys(node).some(
-            key => key !== "_" && utils.match(lex["."], key),
-          )
-        if (hasProperty) {
-          // Public keys are immutable once written — never need a wire check.
-          if (!isNode && lex["."] !== utils.userPublicKey) {
-            if (!lex["."] || typeof lex["."] === "string") {
-              const checkKey = lex["#"] + (lex["."] ? "." + lex["."] : "")
-              const now = Date.now()
-              const lastCheck = recentChecks.get(checkKey)
-              if (!lastCheck || now - lastCheck > recentCheckTTL) {
-                recentChecks.set(checkKey, now)
-                const sendResult = send(request)
-                if (sendResult && sendResult.err) {
-                  cb({err: sendResult.err})
-                  return
-                }
-              }
-            } else {
+        if (!lex["."] && stored[lex["#"]]) hasNode.add(lex["#"])
+      }
+
+      // Answered from the graph rather than the raw store result: the merge
+      // above keeps any newer in-memory values, so a local put that store
+      // hasn't finished persisting yet is still included, while everything
+      // already on disk fills in the rest of the node.
+      const ack = {...stored, ...Get(lex, graph, true)}
+      // Only serve locally if the requested property is present.
+      const node = ack[lex["#"]]
+      const hasProperty =
+        node &&
+        Object.keys(node).some(key => key !== "_" && utils.match(lex["."], key))
+      if (hasProperty) {
+        // Public keys are immutable once written - never need a wire check.
+        if (!isNode && lex["."] !== utils.userPublicKey) {
+          if (!lex["."] || typeof lex["."] === "string") {
+            const checkKey = lex["#"] + (lex["."] ? "." + lex["."] : "")
+            const now = Date.now()
+            const lastCheck = recentChecks.get(checkKey)
+            if (!lastCheck || now - lastCheck > recentCheckTTL) {
+              recentChecks.set(checkKey, now)
               const sendResult = send(request)
               if (sendResult && sendResult.err) {
                 cb({err: sendResult.err})
                 return
               }
             }
+          } else {
+            const sendResult = send(request)
+            if (sendResult && sendResult.err) {
+              cb({err: sendResult.err})
+              return
+            }
           }
-          cb(err ? {put: ack, err: err} : {put: ack})
-          return
         }
+        cb(err ? {put: ack, err: err} : {put: ack})
+        return
       }
 
       if (err) console.log(err)
@@ -725,17 +729,6 @@ const Wire = (opt: HolsterOptions): WireAPI => {
           return
         }
 
-        // Ham.mix has already merged this locally-authored update into
-        // graph[soul], synchronously, before store.put below even starts
-        // persisting it - mark it as fully known now rather than waiting
-        // for a future disk fetch to do so, so a read landing in that
-        // window doesn't get forced through a disk round-trip that could
-        // itself race ahead of this same write and find nothing, even
-        // though the correct answer was already sitting in memory.
-        for (const soul of Object.keys(update.now)) {
-          hasNode.add(soul)
-        }
-
         if (options.userLimit) {
           for (const [soul, node] of Object.entries(update.now)) {
             const pub = node![utils.userPublicKey] as string | undefined