@mblaney/holster 0.1.0 → 0.3.0

package/examples/user.js

@@ -71,6 +71,11 @@ setTimeout(() => {
 }, 2000)
 
 setTimeout(() => {
+  if (!bob) {
+    console.log("Something went wrong, bob didn't log in.")
+    return
+  }
+
   // Use Bob's public key to fetch shared data under his account.
   holster.user(bob.pub).get("shared", enc => {
     user.auth("alice", "password", async err => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Holster is a service that allows synchronising data between devices using Node, Deno, Bun or the browser.",
   "type": "module",
   "main": "index.js",
@@ -10,7 +10,7 @@
   },
   "keywords": [],
   "author": "Malcolm Blaney",
-  "license": "Zlib OR MIT OR Apache-2.0",
+  "license": "Zlib, MIT, Apache-2.0",
   "dependencies": {
     "express": "^5.1.0",
     "fs": "^0.0.1-security",

package/src/holster.js

@@ -4,12 +4,18 @@ import User from "./user.js"
 import SEA from "./sea.js"
 
 const Holster = opt => {
+  if (typeof opt === "string") opt = {peers: [opt]}
+  else if (opt instanceof Array) opt = {peers: opt}
+  else if (!utils.obj.is(opt)) opt = {}
+
   const wire = Wire(opt)
   const user = User(null, wire)
   // Map callbacks since the user's callback is not passed to wire.on.
   const map = new Map()
   // Allow concurrent calls to the api by storing each context.
   const allctx = new Map()
+  // Allow user queries by public key
+  let publicKey
 
   const ok = data => {
     return (
@@ -45,51 +51,50 @@ const Holster = opt => {
   }
 
   const api = ctxid => {
-    const get = (lex, soul, ack) => {
-      wire.get(utils.obj.put(lex, "#", soul), async msg => {
-        if (msg.err) console.log(msg.err)
-        if (msg.put && msg.put[soul]) {
-          delete msg.put[soul]._
-          delete msg.put[soul][utils.userPublicKey]
-          // Resolve any rels on the node before returning to the user.
-          for (const key of Object.keys(msg.put[soul])) {
-            const id = utils.rel.is(msg.put[soul][key])
-            if (id) {
-              const data = await new Promise(res => {
-                const _ctxid = utils.text.random()
-                allctx.set(_ctxid, {chain: [{item: null, soul: id}]})
-                api(_ctxid).next(null, res)
-              })
-              msg.put[soul][key] = data
+    const get = (lex, soul, ack, opt) => {
+      wire.get(
+        utils.obj.put(lex, "#", soul),
+        async msg => {
+          if (msg.err) console.log(msg.err)
+          if (msg.put && msg.put[soul]) {
+            delete msg.put[soul]._
+            delete msg.put[soul][utils.userPublicKey]
+            // Resolve any rels on the node before returning to the user.
+            for (const key of Object.keys(msg.put[soul])) {
+              const id = utils.rel.is(msg.put[soul][key])
+              if (id) {
+                const data = await new Promise(res => {
+                  const _ctxid = utils.text.random()
+                  allctx.set(_ctxid, {chain: [{item: null, soul: id}]})
+                  api(_ctxid).next(null, res)
+                })
+                msg.put[soul][key] = data
+              }
             }
+            ack(msg.put[soul])
+          } else {
+            // No data callback.
+            ack(null)
           }
-          ack(msg.put[soul])
-        } else {
-          // No data callback.
-          ack(null)
-        }
-      })
+        },
+        opt,
+      )
     }
 
     const graph = async (soul, data, cb) => {
       if (!cb) cb = console.log
 
-      if (!user.is) {
-        if (opt.secure) {
-          cb(`error putting data on ${soul}: user required in secure mode`)
-          return null
-        }
-
-        return utils.graph(soul, data)
+      if (user.is) {
+        const signed = await SEA.sign(data, user.is)
+        return utils.graph(soul, signed.m, signed.s, user.is.pub)
       }
 
-      if (!user.is) {
-        cb(`error putting data on ${soul}: user not authenticated`)
+      if (opt.secure) {
+        cb(`error putting data on ${soul}: user required in secure mode`)
         return null
       }
 
-      const signed = await SEA.sign(data, user.is)
-      return utils.graph(soul, signed.m, signed.s, user.is.pub)
+      return utils.graph(soul, data)
     }
 
     const done = data => {
@@ -190,7 +195,7 @@ const Holster = opt => {
     }
 
     return {
-      get: (key, lex, cb) => {
+      get: (key, lex, cb, opt) => {
         if (typeof lex === "function") {
           cb = lex
           lex = null
@@ -202,14 +207,14 @@ const Holster = opt => {
 
         // lex requires a callback as it's not included in the chain below.
         if (lex && !cb) {
-          console.log("lex requires a callback function")
+          console.log("error lex requires a callback function")
           return
         }
 
         // Top level keys are added to a root node so their values don't need
         // to be objects, the user's public key is used as the root node when
-        // user.ctx is set.
-        const root = user.ctx ? user.ctx : "root"
+        // publicKey or user.ctx is set.
+        const root = publicKey ? publicKey : user.ctx ? user.ctx : "root"
 
         ctxid = utils.text.random()
         allctx.set(ctxid, {chain: [{item: key, soul: root}], cb: cb})
@@ -217,9 +222,9 @@ const Holster = opt => {
 
         // When there's a callback need to resolve the context first.
         const {soul} = resolve({get: lex}, done)
-        if (soul) get(lex, soul, done)
+        if (soul) get(lex, soul, done, opt)
       },
-      next: (key, lex, cb) => {
+      next: (key, lex, cb, opt) => {
         const ack = data => {
           cb ? cb(data) : done(data)
         }
@@ -229,7 +234,7 @@ const Holster = opt => {
           lex = null
         }
         if (!ctxid) {
-          console.log("please provide a key using get(key)")
+          console.log("error please provide a key using get(key)")
           ack(null)
           return
         }
@@ -241,7 +246,7 @@ const Holster = opt => {
 
         // lex requires a callback as it's not included in the chain below.
         if (lex && !cb) {
-          console.log("lex requires a callback function")
+          console.log("error lex requires a callback function")
           return
         }
 
@@ -262,9 +267,13 @@ const Holster = opt => {
 
         // When there's a callback need to resolve the context first.
         const {soul} = resolve({get: lex}, ack)
-        if (soul) get(lex, soul, ack)
+        if (soul) get(lex, soul, ack, opt)
       },
-      put: (data, cb) => {
+      put: (data, set, cb) => {
+        if (typeof set === "function") {
+          cb = set
+          set = false
+        }
         const ack = err => {
           cb ? cb(err) : done(err)
         }
@@ -285,6 +294,7 @@ const Holster = opt => {
           ctx.cb = cb
           cb = null
         }
+        if (set) data = {[utils.text.random()]: data}
 
         const result = check(data)
         if (typeof result === "string") {
@@ -423,7 +433,7 @@ const Holster = opt => {
         if (!cb) return
 
         if (!ctxid) {
-          console.log("please provide a key using get(key)")
+          console.log("error please provide a key using get(key)")
           cb(null)
           return
         }
@@ -458,7 +468,7 @@ const Holster = opt => {
       },
       off: cb => {
         if (!ctxid) {
-          console.log("please provide a key using get(key)")
+          console.log("error please provide a key using get(key)")
           if (cb) cb(null)
           return
         }
@@ -487,7 +497,8 @@ const Holster = opt => {
         // will set the user context to that key, otherwise user.ctx is set when
         // a user logs in so that their public key will be used as the root node
         // in get(), also put() will sign all graph updates for verification.
-        if (pub) user.ctx = "~" + pub
+        if (pub) publicKey = "~" + pub
+        else publicKey = null
         return Object.assign(user, api())
       },
       // Allow the wire spec to be used via holster.

package/src/index.js

@@ -3,7 +3,6 @@ import path from "path"
 import {fileURLToPath} from "url"
 import Holster from "./holster.js"
 
-// TODO: pass in opt for websocket url, etc.
 const holster = Holster()
 
 // Note that express is only used here to serve the examples folder. It is not

package/src/sea-utils.js

@@ -2,7 +2,7 @@ import SafeBuffer from "./buffer.js"
 
 const isNode = typeof document === "undefined"
 const crypto = isNode
-  ? (await import("node:crypto")).webcrypto
+  ? (await import(/*webpackIgnore: true*/ "node:crypto")).webcrypto
   : globalThis.crypto
 export const subtle = crypto.subtle
 

package/src/store.js

@@ -3,7 +3,7 @@ import Radix from "./radix.js"
 import * as utils from "./utils.js"
 
 const isNode = typeof document === "undefined"
-const fs = isNode ? await import("node:fs") : undefined
+const fs = isNode ? await import(/*webpackIgnore: true*/ "node:fs") : undefined
 
 // ASCII character for enquiry.
 const enq = String.fromCharCode(5)

package/src/wire.js

@@ -15,8 +15,6 @@ if (typeof globalThis.WebSocket === "undefined") {
 // Wire starts a websocket client or server and returns get and put methods
 // for access to the wire spec and storage.
 const Wire = opt => {
-  if (!utils.obj.is(opt)) opt = {}
-
   const dup = Dup(opt.maxAge)
   const store = Store(opt)
   const graph = {}
@@ -207,7 +205,10 @@ const Wire = opt => {
     // mock-sockets provides clients as a function that returns an array.
     let clients = () => wss.clients()
     if (!wss) {
-      wss = new wsModule.WebSocketServer({port: 8080})
+      const config = opt.server
+        ? {server: opt.server}
+        : {port: opt.port || 8765}
+      wss = new wsModule.WebSocketServer(config)
       clients = () => wss.clients
     }
 
@@ -244,46 +245,57 @@ const Wire = opt => {
     return api(send)
   }
 
-  let ws = new WebSocket("ws://localhost:8080")
+  const peers = []
   const send = data => {
-    if (!ws || ws.readyState !== WebSocket.OPEN) {
-      console.log("websocket not available")
-      return
-    }
-
-    ws.send(data)
+    peers.forEach(peer => {
+      if (peer && peer.readyState === WebSocket.OPEN) {
+        peer.send(data)
+      } else {
+        console.log("websocket not available")
+      }
+    })
   }
-  const start = () => {
-    if (!ws) ws = new WebSocket("ws://localhost:8080")
-    ws.onclose = c => {
-      ws = null
-      setTimeout(start, Math.floor(Math.random() * 5000))
-    }
-    ws.onerror = e => {
-      console.error(e)
-    }
-    ws.onmessage = m => {
-      const msg = JSON.parse(m.data)
-      if (dup.check(msg["#"])) return
+  if (!(opt.peers instanceof Array)) {
+    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)
+      ws.onclose = c => {
+        if (peers.indexOf(ws) !== -1) {
+          peers.splice(peers.indexOf(ws), 1)
+        }
+        ws = null
+        setTimeout(start, Math.floor(Math.random() * 5000))
+      }
+      ws.onerror = e => {
+        console.error(e)
+      }
+      ws.onmessage = m => {
+        const msg = JSON.parse(m.data)
+        if (dup.check(msg["#"])) return
 
-      dup.track(msg["#"])
-      if (msg.get) get(msg, send)
-      if (msg.put) put(msg, send)
-      send(m.data)
+        dup.track(msg["#"])
+        if (msg.get) get(msg, send)
+        if (msg.put) put(msg, send)
+        send(m.data)
 
-      const id = msg["@"]
-      const cb = queue[id]
-      if (cb) {
-        delete msg["#"]
-        delete msg["@"]
-        cb(msg)
+        const id = msg["@"]
+        const cb = queue[id]
+        if (cb) {
+          delete msg["#"]
+          delete msg["@"]
+          cb(msg)
 
-        delete queue[id]
+          delete queue[id]
+        }
       }
     }
-  }
+    start()
+  })
 
-  start()
   return api(send)
 }
 

package/test/holster.put.test.js

@@ -269,6 +269,65 @@ describe("holster.put", () => {
     })
   })
 
+  test("holster put string with set", (t, done) => {
+    holster.get("set").put("first", true, err => {
+      assert.equal(err, null)
+
+      holster.get("set", data => {
+        assert.equal(Object.values(data)[0], "first")
+
+        setTimeout(() => {
+          holster.get("set").put("second", true, err => {
+            assert.equal(err, null)
+
+            holster.get("set", data => {
+              for (const value of Object.values(data)) {
+                assert.ok(value === "first" || value === "second")
+              }
+              done()
+            })
+          })
+        }, 2)
+      })
+    })
+  })
+
+  test("holster put object with set", (t, done) => {
+    const set1 = {
+      key: "value 1",
+      child: "child value 1",
+    }
+    const set2 = {
+      key: "value 2",
+      child: "child value 2",
+    }
+    holster.get("set2").put(set1, true, err => {
+      assert.equal(err, null)
+
+      holster.get("set2", data => {
+        assert.deepEqual(Object.values(data)[0], set1)
+
+        setTimeout(() => {
+          holster.get("set2").put(set2, true, err => {
+            assert.equal(err, null)
+
+            holster.get("set2", data => {
+              for (const value of Object.values(data)) {
+                if (value.key === "value 1") {
+                  assert.deepEqual(value, set1)
+                }
+                if (value.key === "value 2") {
+                  assert.deepEqual(value, set2)
+                }
+              }
+              done()
+            })
+          })
+        }, 2)
+      })
+    })
+  })
+
   test("cleanup", (t, done) => {
     fs.rm("test/holster.put", {recursive: true, force: true}, err => {
       assert.equal(err, null)

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

@@ -291,7 +291,25 @@ describe("holster.user.put", () => {
     })
   })
 
-  test("get number using public key", (t, done) => {
+  test("get number using public key - logged in", (t, done) => {
+    let ok = false
+
+    holster.user(alice).get("pi", data => {
+      assert.equal(data, 3.14159)
+      if (ok) done()
+      else ok = true
+    })
+
+    // Not reusing the existing user here resets the stored public key used
+    // above, but that is ok because they use separate contexts.
+    holster.user().get("pi", data => {
+      assert.equal(data, 3.14159)
+      if (ok) done()
+      else ok = true
+    })
+  })
+
+  test("get number using public key - logged out", (t, done) => {
     user.leave()
 
     holster.user(alice).get("pi", data => {