@mblaney/holster 1.0.1 → 1.0.3

package/package.json

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

@@ -229,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
       }
 
@@ -361,7 +361,8 @@ const Holster = opt => {
           return
         }
 
-        // Resolve the current context before putting data.
+        // 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
 
@@ -639,7 +640,7 @@ const Holster = opt => {
 
             // When there's a callback need to resolve the context first.
             const _done = done(ctxid)
-            const {soul} = resolve({get: lex}, _done)
+            const {soul} = resolve({get: lex, _opt: _opt}, _done)
             if (soul) get(lex, soul, _done, _opt)
           }
         }

package/src/store.js

@@ -35,11 +35,11 @@ const fileSystem = opt => {
         })
       },
       put: (file, data, cb) => {
-        var random = Math.random().toString(36).slice(-9)
         // Don't put tmp files under dir so that they're not listed.
-        var tmp = file + "." + random + ".tmp"
+        var tmp = file + "." + utils.text.random(9) + ".tmp"
         fs.writeFile(tmp, data, err => {
           if (err) {
+            console.log("fs.writeFile error:", err)
             cb(err)
             return
           }
@@ -90,7 +90,7 @@ const fileSystem = opt => {
 
     return {
       get: (file, cb) => {
-        if (db) {
+        const _get = (file, cb) => {
           const tx = db.transaction([dir], "readonly")
           const req = tx.objectStore(dir).get(file)
           req.onerror = () => {
@@ -99,12 +99,28 @@ const fileSystem = opt => {
           req.onsuccess = () => {
             cb(null, req.result)
           }
-        } else {
-          cb("error indexedDB not available")
         }
+        if (db) {
+          _get(file, cb)
+          return
+        }
+
+        let retry = 0
+        const interval = setInterval(() => {
+          if (db) {
+            clearInterval(interval)
+            _get(file, cb)
+            return
+          }
+
+          if (retry++ > 5) {
+            clearInterval(interval)
+            cb("error indexedDB not available")
+          }
+        }, 1000)
       },
       put: (file, data, cb) => {
-        if (db) {
+        const _put = (file, data, cb) => {
           const tx = db.transaction([dir], "readwrite")
           const req = tx.objectStore(dir).put(data, file)
           req.onerror = () => {
@@ -113,12 +129,28 @@ const fileSystem = opt => {
           req.onsuccess = () => {
             cb(null)
           }
-        } else {
-          cb("error indexedDB not available")
         }
+        if (db) {
+          _put(file, data, cb)
+          return
+        }
+
+        let retry = 0
+        const interval = setInterval(() => {
+          if (db) {
+            clearInterval(interval)
+            _put(file, data, cb)
+            return
+          }
+
+          if (retry++ > 5) {
+            clearInterval(interval)
+            cb("error indexedDB not available")
+          }
+        }, 1000)
       },
       list: cb => {
-        if (db) {
+        const _list = cb => {
           const tx = db.transaction([dir], "readonly")
           const req = tx.objectStore(dir).getAllKeys()
           req.onerror = () => console.log("error getting keys for", dir)
@@ -126,10 +158,26 @@ const fileSystem = opt => {
             req.result.forEach(cb)
             cb()
           }
-        } else {
-          console.log("error indexedDB not available")
-          cb()
         }
+        if (db) {
+          _list(cb)
+          return
+        }
+
+        let retry = 0
+        const interval = setInterval(() => {
+          if (db) {
+            clearInterval(interval)
+            _list(cb)
+            return
+          }
+
+          if (retry++ > 5) {
+            clearInterval(interval)
+            console.log("error indexedDB not available")
+            cb()
+          }
+        }, 1000)
       },
     }
   }

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/src/wire.js

@@ -220,8 +220,22 @@ const Wire = opt => {
 
     const send = (data, isBinary) => {
       clients().forEach(client => {
-        if (client.readyState === WebSocket.OPEN) {
+        if (client && client.readyState === WebSocket.OPEN) {
           client.send(data, {binary: isBinary})
+        } else {
+          let retry = 0
+          const interval = setInterval(() => {
+            if (client && client.readyState === WebSocket.OPEN) {
+              clearInterval(interval)
+              client.send(data, {binary: isBinary})
+              return
+            }
+
+            if (retry++ > 5) {
+              clearInterval(interval)
+              console.log("websocket not available")
+            }
+          }, 1000)
         }
       })
     }
@@ -257,7 +271,19 @@ const Wire = opt => {
       if (peer && peer.readyState === WebSocket.OPEN) {
         peer.send(data)
       } else {
-        console.log("websocket not available")
+        let retry = 0
+        const interval = setInterval(() => {
+          if (peer && peer.readyState === WebSocket.OPEN) {
+            clearInterval(interval)
+            peer.send(data)
+            return
+          }
+
+          if (retry++ > 5) {
+            clearInterval(interval)
+            console.log("websocket not available")
+          }
+        }, 1000)
       }
     })
   }
@@ -265,10 +291,9 @@ const Wire = opt => {
     opt.peers = [`ws://localhost:${opt.port || 8765}`]
   }
   opt.peers.forEach(peer => {
-    let ws = new WebSocket(peer)
-    peers.push(ws)
     const start = () => {
-      if (!ws) ws = new WebSocket(peer)
+      let ws = new WebSocket(peer)
+      peers.push(ws)
       ws.onclose = c => {
         if (peers.indexOf(ws) !== -1) {
           peers.splice(peers.indexOf(ws), 1)