@mblaney/holster 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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/ham.js

@@ -63,11 +63,10 @@ Ham.mix = async (change, graph, secure, listen) => {
       }
     }
     if (verify) {
-      // Partial nodes can be read from disk, just ignore them.
-      if (!sig || !pub) continue
-
-      if (!(await SEA.verify({m: node, s: sig}, {pub: pub}))) {
-        console.log(`error could not verify soul: ${soul}`)
+      // Partial nodes can be read from disk, which are ignored. This could be
+      // a missing signature or public key, or missing properties on the node
+      // which means verify won't work either.
+      if (!sig || !pub || !(await SEA.verify({m: node, s: sig}, {pub: pub}))) {
         continue
       }
     }

package/src/holster.js

@@ -100,17 +100,21 @@ const Holster = opt => {
       return utils.graph(soul, data)
     }
 
-    const done = data => {
-      const ctx = allctx.get(ctxid)
-      if (ctx && typeof ctx.cb !== "undefined") {
-        // Use a timeout so that the context can be removed before data is
-        // returned to the callback (allows nested get calls).
-        setTimeout(() => ctx.cb(data), 1)
-      } else if (data) {
-        console.log("error no callback for data", data, "ctx", ctx)
+    // done takes a context id and returns a new callback function so that the
+    // callback is not overwritten by simultaneous requests.
+    const done = ctxid => {
+      return data => {
+        const ctx = allctx.get(ctxid)
+        if (ctx && typeof ctx.cb !== "undefined") {
+          // Use a timeout so that the context can be removed before data is
+          // returned to the callback (allows nested get calls).
+          setTimeout(() => ctx.cb(data), 1)
+        } else if (data) {
+          console.log("error no callback for data", data, "ctx", ctx)
+        }
+        // A context updated by "on" should only be removed by "off".
+        if (ctx && !ctx.on) allctx.delete(ctxid)
       }
-      // A context updated by "on" should only be removed by "off".
-      if (ctx && !ctx.on) allctx.delete(ctxid)
     }
 
     const resolve = (request, cb) => {
@@ -225,7 +229,7 @@ const Holster = opt => {
         // The context has been resolved but it does not include the requested
         // node, which requires one more lookup.
         ctx.chain.push({item: null, soul: null})
-        api(ctxid).next(null, request.get, cb)
+        api(ctxid).next(null, request.get, cb, request._opt)
         return false
       }
 
@@ -258,13 +262,22 @@ const Holster = opt => {
         allctx.set(ctxid, {chain: [{item: key, soul: "root"}], cb: cb})
         if (!cb) return api(ctxid)
 
+        const _done = done(ctxid)
         // When there's a callback need to resolve the context first.
-        const {soul} = resolve({get: lex, _opt: _opt}, done)
-        if (soul) get(lex, soul, done, _opt)
+        const {soul} = resolve({get: lex, _opt: _opt}, _done)
+        if (soul) get(lex, soul, _done, _opt)
       },
       next: (key, lex, cb, _opt) => {
-        const ack = data => {
-          cb ? cb(data) : done(data)
+        // ack needs to work the same as done, pass it the context id and then
+        // return a new function for the actual callback.
+        const ack = ctxid => {
+          return data => {
+            if (cb) {
+              cb(data)
+            } else {
+              done(ctxid)(data)
+            }
+          }
         }
         if (typeof lex === "function") {
           _opt = cb
@@ -273,12 +286,13 @@ const Holster = opt => {
         }
         if (!ctxid) {
           console.log("error please provide a key using get(key)")
-          ack(null)
+          if (cb) cb(null)
           return
         }
 
+        const _ack = ack(ctxid)
         if (key === "" || key === "_") {
-          ack(null)
+          _ack(null)
           return
         }
 
@@ -304,20 +318,25 @@ const Holster = opt => {
         if (!ctx.cb) return api(ctxid)
 
         // When there's a callback need to resolve the context first.
-        const {soul} = resolve({get: lex, _opt: _opt}, ack)
-        if (soul) get(lex, soul, ack, _opt)
+        const {soul} = resolve({get: lex, _opt: _opt}, _ack)
+        if (soul) get(lex, soul, _ack, _opt)
       },
       put: (data, set, cb) => {
         if (typeof set === "function") {
           cb = set
           set = false
         }
-        const ack = err => {
-          cb ? cb(err) : done(err)
+        const ack = ctxid => {
+          return data => {
+            if (cb) {
+              cb(data)
+            } else {
+              done(ctxid)(data)
+            }
+          }
         }
-
         if (!ctxid) {
-          ack("please provide a key using get(key)")
+          if (cb) cb("error please provide a key using get(key)")
           return
         }
 
@@ -334,15 +353,17 @@ const Holster = opt => {
         }
         if (set) data = {[utils.text.random()]: data}
 
+        const _ack = ack(ctxid)
         const result = check(data)
         if (typeof result === "string") {
           // All strings returned from check are errors, cannot continue.
-          ack(result)
+          _ack(result)
           return
         }
 
-        // Resolve the current context before putting data.
-        const {item, soul} = resolve({put: data}, ack)
+        // Resolve the current context before putting data. (Note that set is
+        // not passed to resolve because it's already been applied above.)
+        const {item, soul} = resolve({put: data}, _ack)
         if (!soul) return
 
         if (result === true) {
@@ -354,7 +375,7 @@ const Holster = opt => {
             ctx.user || opt.secure ? {"#": soul} : {"#": soul, ".": item}
           wire.get(lex, async msg => {
             if (msg.err) {
-              ack(`error getting ${soul}: ${msg.err}`)
+              _ack(`error getting ${soul}: ${msg.err}`)
               return
             }
 
@@ -365,21 +386,21 @@ const Holster = opt => {
               // Not a rel, can just put the data.
               if (!node) node = {}
               node[item] = data
-              const g = await graph(soul, node, ctx.user, ack)
+              const g = await graph(soul, node, ctx.user, _ack)
               if (g === null) return
 
-              wire.put(g, ack)
+              wire.put(g, _ack)
               return
             }
 
             wire.get({"#": id}, async msg => {
               if (msg.err) {
-                ack(`error getting ${id}: ${msg.err}`)
+                _ack(`error getting ${id}: ${msg.err}`)
                 return
               }
 
               if (!msg.put || !msg.put[id]) {
-                ack(`error ${id} not found`)
+                _ack(`error ${id} not found`)
                 return
               }
 
@@ -400,16 +421,16 @@ const Holster = opt => {
                   api(_ctxid).put(null, res)
                 })
                 if (err) {
-                  ack(err)
+                  _ack(err)
                   return
                 }
               }
               if (!node) node = {}
               node[item] = data
-              const g = await graph(soul, node, ctx.user, ack)
+              const g = await graph(soul, node, ctx.user, _ack)
               if (g === null) return
 
-              wire.put(g, ack)
+              wire.put(g, _ack)
             })
           })
           return
@@ -422,7 +443,7 @@ const Holster = opt => {
           ctx.user || opt.secure ? {"#": soul} : {"#": soul, ".": item}
         wire.get(lex, async msg => {
           if (msg.err) {
-            ack(`error getting ${soul}.${item}: ${msg.err}`)
+            _ack(`error getting ${soul}.${item}: ${msg.err}`)
             return
           }
 
@@ -433,12 +454,12 @@ const Holster = opt => {
             // The current rel doesn't exist, so add it first.
             if (!node) node = {}
             node[item] = utils.rel.ify(utils.text.random())
-            const g = await graph(soul, node, ctx.user, ack)
+            const g = await graph(soul, node, ctx.user, _ack)
             if (g === null) return
 
             wire.put(g, err => {
               if (err) {
-                ack(`error putting ${item} on ${soul}: ${err}`)
+                _ack(`error putting ${item} on ${soul}: ${err}`)
               } else {
                 const _ctxid = utils.text.random()
                 const chain = [{item: item, soul: soul}]
@@ -466,13 +487,13 @@ const Holster = opt => {
               }
             })
             if (err) {
-              ack(err)
+              _ack(err, ctxid)
               return
             }
           }
 
           if (update.length === 0) {
-            ack(null)
+            _ack(null)
             return
           }
 
@@ -480,7 +501,7 @@ const Holster = opt => {
           // object, so fetch the node so the rest of the updates can be added.
           wire.get({"#": id}, async msg => {
             if (msg.err) {
-              ack(`error getting ${id}: ${msg.err}`)
+              _ack(`error getting ${id}: ${msg.err}`)
               return
             }
 
@@ -489,10 +510,10 @@ const Holster = opt => {
             update.forEach(key => {
               node[key] = data[key]
             })
-            const g = await graph(id, node, ctx.user, ack)
+            const g = await graph(id, node, ctx.user, _ack)
             if (g === null) return
 
-            wire.put(g, ack)
+            wire.put(g, _ack)
           })
         })
       },
@@ -618,8 +639,9 @@ const Holster = opt => {
             if (!cb) return api(ctxid)
 
             // When there's a callback need to resolve the context first.
-            const {soul} = resolve({get: lex}, done)
-            if (soul) get(lex, soul, done, _opt)
+            const _done = done(ctxid)
+            const {soul} = resolve({get: lex, _opt: _opt}, _done)
+            if (soul) get(lex, soul, _done, _opt)
           }
         }
         return user

package/src/user.js

@@ -27,53 +27,57 @@ const User = (opt, wire) => {
       }
 
       const pub = pubs.shift()
-      wire.get({"#": pub}, async msg => {
-        if (msg.err) {
-          done(`error getting ${pub}: ${msg.err}`)
-          return
-        }
+      wire.get(
+        {"#": pub},
+        async msg => {
+          if (msg.err) {
+            done(`error getting ${pub}: ${msg.err}`)
+            return
+          }
 
-        const data = msg.put && msg.put[pub]
-        if (!data || !data.auth) return next()
+          const data = msg.put && msg.put[pub]
+          if (!data || !data.auth) return next()
 
-        const auth = JSON.parse(data.auth)
-        const work = await SEA.work(password, auth.salt)
-        const dec = await SEA.decrypt(auth.enc, work)
-        if (!dec) return next()
+          const auth = JSON.parse(data.auth)
+          const work = await SEA.work(password, auth.salt)
+          const dec = await SEA.decrypt(auth.enc, work)
+          if (!dec) return next()
 
-        user.is = {
-          username: username,
-          pub: data.pub,
-          epub: data.epub,
-          priv: dec.priv,
-          epriv: dec.epriv,
-        }
-        if (newPassword !== "") {
-          // Encrypt private key using new password and a new salt.
-          const salt = utils.text.random(64)
-          const work = await SEA.work(newPassword, salt)
-          const enc = await SEA.encrypt(dec, work)
-          // Put all fields so that verification applies to the whole node.
-          const update = {
+          user.is = {
             username: username,
             pub: data.pub,
             epub: data.epub,
-            auth: JSON.stringify({enc: enc, salt: salt}),
+            priv: dec.priv,
+            epriv: dec.epriv,
           }
-          const signed = await SEA.sign(update, user.is)
-          const graph = utils.graph(pub, signed.m, signed.s, data.pub)
-          wire.put(graph, err => {
-            if (err) {
-              done(`error putting ${update} on ${pub}: ${err}`)
-            } else {
-              done(null)
+          if (newPassword !== "") {
+            // Encrypt private key using new password and a new salt.
+            const salt = utils.text.random(64)
+            const work = await SEA.work(newPassword, salt)
+            const enc = await SEA.encrypt(dec, work)
+            // Put all fields so that verification applies to the whole node.
+            const update = {
+              username: username,
+              pub: data.pub,
+              epub: data.epub,
+              auth: JSON.stringify({enc: enc, salt: salt}),
             }
-          })
-          return
-        }
+            const signed = await SEA.sign(update, user.is)
+            const graph = utils.graph(pub, signed.m, signed.s, data.pub)
+            wire.put(graph, err => {
+              if (err) {
+                done(`error putting ${update} on ${pub}: ${err}`)
+              } else {
+                done(null)
+              }
+            })
+            return
+          }
 
-        return done(null)
-      })
+          return done(null)
+        },
+        {wait: 1000},
+      )
     }
 
     if (retries > 9) {
@@ -82,21 +86,25 @@ const User = (opt, wire) => {
     }
 
     const soul = "~@" + username
-    wire.get({"#": soul}, async msg => {
-      if (msg.err) {
-        done(`error getting ${soul}: ${msg.err}`)
-        return
-      }
-
-      const data = msg.put && msg.put[soul]
-      if (!data) return retry(username)
+    wire.get(
+      {"#": soul},
+      async msg => {
+        if (msg.err) {
+          done(`error getting ${soul}: ${msg.err}`)
+          return
+        }
 
-      delete msg.put[soul]._
-      // Usernames aren't guaranteed to be unique, so store the list and then
-      // try each of them until one is successful with the given password.
-      pubs = Object.keys(data)
-      next()
-    })
+        const data = msg.put && msg.put[soul]
+        if (!data) return retry(username)
+
+        delete msg.put[soul]._
+        // Usernames aren't guaranteed to be unique, so store the list and then
+        // try each of them until one is successful with the given password.
+        pubs = Object.keys(data)
+        next()
+      },
+      {wait: 1000},
+    )
   }
 
   const user = {
@@ -124,53 +132,57 @@ const User = (opt, wire) => {
       creating = true
 
       const soul = "~@" + username
-      wire.get({"#": soul}, async msg => {
-        if (msg.err) {
-          creating = false
-          ack(`error getting ${soul}: ${msg.err}`)
-          return
-        }
-
-        if (msg.put && msg.put[soul]) {
-          creating = false
-          ack("Username already exists")
-          return
-        }
-
-        const salt = utils.text.random(64)
-        const work = await SEA.work(password, salt)
-        const pair = await SEA.pair()
-        const priv = {priv: pair.priv, epriv: pair.epriv}
-        const enc = await SEA.encrypt(priv, work)
-        const data = {
-          username: username,
-          pub: pair.pub,
-          epub: pair.epub,
-          auth: JSON.stringify({enc: enc, salt: salt}),
-        }
+      wire.get(
+        {"#": soul},
+        async msg => {
+          if (msg.err) {
+            creating = false
+            ack(`error getting ${soul}: ${msg.err}`)
+            return
+          }
 
-        const pub = "~" + pair.pub
-        const signed = await SEA.sign(data, pair)
-        const graph = utils.graph(pub, signed.m, signed.s, pair.pub)
-        wire.put(graph, err => {
-          creating = false
-          if (err) {
-            ack(`error putting ${data} on ${pub}: ${err}`)
+          if (msg.put && msg.put[soul]) {
+            creating = false
+            ack("Username already exists")
             return
           }
 
-          const rel = {[pub]: {"#": pub}}
-          wire.put(utils.graph(soul, rel), err => {
+          const salt = utils.text.random(64)
+          const work = await SEA.work(password, salt)
+          const pair = await SEA.pair()
+          const priv = {priv: pair.priv, epriv: pair.epriv}
+          const enc = await SEA.encrypt(priv, work)
+          const data = {
+            username: username,
+            pub: pair.pub,
+            epub: pair.epub,
+            auth: JSON.stringify({enc: enc, salt: salt}),
+          }
+
+          const pub = "~" + pair.pub
+          const signed = await SEA.sign(data, pair)
+          const graph = utils.graph(pub, signed.m, signed.s, pair.pub)
+          wire.put(graph, err => {
+            creating = false
             if (err) {
-              ack(`error putting ${rel} on ${soul}: ${err}`)
+              ack(`error putting ${data} on ${pub}: ${err}`)
               return
             }
 
-            // Return null on success.
-            if (cb) cb(null)
+            const rel = {[pub]: {"#": pub}}
+            wire.put(utils.graph(soul, rel), err => {
+              if (err) {
+                ack(`error putting ${rel} on ${soul}: ${err}`)
+                return
+              }
+
+              // Return null on success.
+              if (cb) cb(null)
+            })
           })
-        })
-      })
+        },
+        {wait: 1000},
+      )
     },
     auth: (username, password, cb) => {
       const ack = err => {

package/test/holster.get.test.js

@@ -37,12 +37,16 @@ describe("holster.get", () => {
   })
 
   test("get unknown keys in for loop callbacks null", (t, done) => {
+    let count = 0
     for (let i = 0; i < 5; i++) {
       holster.get("unknown" + i, data => {
         assert.equal(data, null)
-        if (i === 4) done()
+        count++
       })
     }
+    setTimeout(() => {
+      if (count === 5) done()
+    }, 200)
   })
 
   test("nested unknown keys both callbacks null", (t, done) => {

package/test/holster.put.test.js

@@ -71,12 +71,16 @@ describe("holster.put", () => {
     }
 
     setTimeout(() => {
+      let count = 0
       for (let i = 0; i < 5; i++) {
         holster.get("for" + i, data => {
           assert.equal(data, i)
-          if (i === 4) setTimeout(done, 100)
+          count++
         })
       }
+      setTimeout(() => {
+        if (count === 5) done()
+      }, 200)
     }, 200)
   })
 

package/test/holster.user.get.test.js

@@ -63,12 +63,16 @@ describe("holster.user.get", () => {
   })
 
   test("get unknown keys in for loop callbacks null", (t, done) => {
+    let count = 0
     for (let i = 0; i < 5; i++) {
       user.get("unknown" + i, data => {
         assert.equal(data, null)
-        if (i === 4) done()
+        count++
       })
     }
+    setTimeout(() => {
+      if (count === 5) done()
+    }, 200)
   })
 
   test("nested get unknown key callback null", (t, done) => {

package/test/holster.user.on.test.js

@@ -101,11 +101,12 @@ describe("holster.user.on", () => {
 
     // Need to wait until after all initial puts are done to set on listeners.
     setTimeout(async () => {
+      let count = 0
       for (let i = 0; i < 5; i++) {
         user.get("for" + i).on(data => {
           assert.equal(data, "update" + i)
           user.get("for" + i).off()
-          if (i === 4) done()
+          count++
         })
       }
 
@@ -117,6 +118,9 @@ describe("holster.user.on", () => {
           })
           assert.equal(err, null)
         }
+        setTimeout(() => {
+          if (count === 5) done()
+        }, 500)
       }, 500)
     }, 1000)
   })

package/test/holster.user.put.test.js

@@ -98,12 +98,16 @@ describe("holster.user.put", () => {
     })()
 
     setTimeout(async () => {
+      let count = 0
       for (let i = 0; i < 5; i++) {
         user.get("for" + i, data => {
           assert.equal(data, i)
-          if (i === 4) setTimeout(done, 100)
+          count++
         })
       }
+      setTimeout(() => {
+        if (count === 5) done()
+      }, 200)
     }, 500)
   })