@mblaney/holster 0.2.0 → 1.0.0

package/src/user.js

@@ -48,20 +48,23 @@ const User = (opt, wire) => {
           priv: dec.priv,
           epriv: dec.epriv,
         }
-        // Holster API uses ctx to set the root node for user data.
-        user.ctx = "~" + data.pub
-
         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)
-          const auth = {auth: JSON.stringify({enc: enc, salt: salt})}
-          const signed = await SEA.sign(auth, user.is)
+          // 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}),
+          }
+          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 ${auth} on ${pub}: ${err}`)
+              done(`error putting ${update} on ${pub}: ${err}`)
             } else {
               done(null)
             }
@@ -236,40 +239,37 @@ const User = (opt, wire) => {
         if (typeof globalThis.localStorage !== "undefined") {
           globalThis.localStorage.setItem("user.is", JSON.stringify(user.is))
         }
+        if (typeof globalThis.sessionStorage !== "undefined") {
+          globalThis.sessionStorage.removeItem("user.is")
+        }
         return
       }
 
       if (typeof globalThis.sessionStorage !== "undefined") {
         globalThis.sessionStorage.setItem("user.is", JSON.stringify(user.is))
       }
+      if (typeof globalThis.localStorage !== "undefined") {
+        globalThis.localStorage.removeItem("user.is")
+      }
     },
-    recall: localStorage => {
-      if (localStorage) {
-        if (typeof globalThis.localStorage !== "undefined") {
-          const is = globalThis.localStorage.getItem("user.is")
-          if (is) {
-            user.is = JSON.parse(is)
-            user.ctx = "~" + user.is.pub
-          } else {
-            console.log("User credentials not stored in local storage")
-          }
+    recall: () => {
+      if (typeof globalThis.localStorage !== "undefined") {
+        const is = globalThis.localStorage.getItem("user.is")
+        if (is) {
+          user.is = JSON.parse(is)
+          return
         }
-        return
       }
 
       if (typeof globalThis.sessionStorage !== "undefined") {
         const is = globalThis.sessionStorage.getItem("user.is")
         if (is) {
           user.is = JSON.parse(is)
-          user.ctx = "~" + user.is.pub
-        } else {
-          console.log("User credentials not stored in session storage")
         }
       }
     },
     leave: () => {
       user.is = null
-      user.ctx = null
       if (typeof globalThis.localStorage !== "undefined") {
         globalThis.localStorage.removeItem("user.is")
       }
@@ -316,7 +316,6 @@ const User = (opt, wire) => {
           }
 
           user.is = null
-          user.ctx = null
           // Return null on success. Note currently not updating ~@username,
           // not sure if allowing username re-user is a good idea anyway?
           if (cb) cb(null)

package/src/utils.js

@@ -68,19 +68,26 @@ export const rel = {
   ify: soul => obj.put({}, "#", soul),
 }
 
+export const userSignature = "_holster_user_signature"
 export const userPublicKey = "_holster_user_public_key"
 
 // graph converts objects to graph format with updated states,
 // with optional meta data to verify signed data.
 export const graph = (soul, data, sig, pub) => {
-  const g = {[soul]: {_: {"#": soul, ">": {}, s: sig, p: pub}}}
+  const g = {[soul]: {_: {"#": soul, ">": {}}}}
   for (const [key, value] of Object.entries(data)) {
-    g[soul][key] = value
-    g[soul]._[">"][key] = Date.now()
+    if (key !== "_" && key != userPublicKey && key != userSignature) {
+      g[soul][key] = value
+      g[soul]._[">"][key] = Date.now()
+    }
   }
-  // If a public key is provided it also needs to be stored on the node to
-  // ensure that future updates are only possible with the same public key.
-  if (pub) {
+  // If a signature and public key are provided they also need to be stored on
+  // the node to ensure that future updates are only possible with the same
+  // public key. The signature is requried because later get requests will
+  // broadcast the data as a put, which other devices will need to verify.
+  if (sig && pub) {
+    g[soul][userSignature] = sig
+    g[soul]._[">"][userSignature] = Date.now()
     g[soul][userPublicKey] = pub
     g[soul]._[">"][userPublicKey] = Date.now()
   }

package/src/wire.js

@@ -37,13 +37,12 @@ const Wire = opt => {
       }
 
       const node = data[soul]
-      const pub = node._ ? node._.p : undefined
       const key = utils.userPublicKey
       // If there is no current node then the data is ok to write without
       // matching public keys, as the provided soul also needs a rel on the
       // parent node which then also requires checking. Otherwise publc keys
       // need to match for existing data.
-      if (!msg.put || !msg.put[soul] || msg.put[soul][key] === pub) {
+      if (!msg.put || !msg.put[soul] || msg.put[soul][key] === node[key]) {
         continue
       }
 
@@ -107,32 +106,38 @@ const Wire = opt => {
     }
   }
 
-  const getWithCallback = (lex, cb, send, opt) => {
+  const getWithCallback = (lex, cb, send, _opt) => {
     if (!cb) return
 
-    if (!utils.obj.is(opt)) opt = {}
+    if (!utils.obj.is(_opt)) _opt = {}
+
     const ack = Get(lex, graph)
+    const track = utils.text.random(9)
+    // Request the whole node in secure mode for verification.
+    const request = JSON.stringify({
+      "#": dup.track(track),
+      get: opt.secure ? {"#": lex["#"]} : lex,
+    })
+
     if (ack) {
+      // Also send request on the wire to check for updates.
+      send(request)
       cb({put: ack})
       return
     }
 
     store.get(lex, (err, ack) => {
       if (ack) {
+        // Also send request on the wire to check for updates.
+        send(request)
         cb({put: ack, err: err})
         return
       }
 
       if (err) console.log(err)
 
-      const track = utils.text.random(9)
       queue[track] = cb
-      send(
-        JSON.stringify({
-          "#": dup.track(track),
-          get: lex,
-        }),
-      )
+      send(request)
       // Respond to callback with null if no response.
       setTimeout(() => {
         const cb = queue[track]
@@ -143,14 +148,14 @@ const Wire = opt => {
           cb({put: ack})
           delete queue[track]
         }
-      }, opt.wait || 100)
+      }, _opt.wait || 100)
     })
   }
 
   const api = send => {
     return {
-      get: (lex, cb, opt) => {
-        getWithCallback(lex, cb, send, opt)
+      get: (lex, cb, _opt) => {
+        getWithCallback(lex, cb, send, _opt)
       },
       put: async (data, cb) => {
         // Deferred updates are only stored using wire spec, they're ignored
@@ -172,7 +177,7 @@ const Wire = opt => {
           }),
         )
       },
-      on: (lex, cb) => {
+      on: (lex, cb, _get, _opt) => {
         const soul = lex && lex["#"]
         if (!soul || !cb) return
 
@@ -181,6 +186,7 @@ const Wire = opt => {
         } else {
           listen[soul] = [{".": lex["."], cb: cb}]
         }
+        if (_get) getWithCallback(lex, cb, send, _opt)
       },
       off: (lex, cb) => {
         const soul = lex && lex["#"]

package/test/holster.get.test.js

@@ -36,8 +36,27 @@ describe("holster.get", () => {
     })
   })
 
-  // Chaining get creates a new context for each call.
-  test("get chained unknown keys callback null", (t, done) => {
+  test("get unknown keys in for loop callbacks null", (t, done) => {
+    for (let i = 0; i < 5; i++) {
+      holster.get("unknown" + i, data => {
+        assert.equal(data, null)
+        if (i === 4) done()
+      })
+    }
+  })
+
+  test("nested unknown keys both callbacks null", (t, done) => {
+    holster.get("unknown", data => {
+      assert.equal(data, null)
+
+      holster.get("unknown", data => {
+        assert.equal(data, null)
+        done()
+      })
+    })
+  })
+
+  test("get already called callback null", (t, done) => {
     holster.get("chained").get("unknown", data => {
       assert.equal(data, null)
       done()
@@ -51,6 +70,17 @@ describe("holster.get", () => {
     })
   })
 
+  test("nested next chained unknown keys callback null", (t, done) => {
+    holster.get("chained").next("unknown", data => {
+      assert.equal(data, null)
+
+      holster.get("chained").next("unknown", data => {
+        assert.equal(data, null)
+        done()
+      })
+    })
+  })
+
   test("cleanup", (t, done) => {
     fs.rm("test/holster.get", {recursive: true, force: true}, err => {
       assert.equal(err, null)

package/test/holster.on.test.js

@@ -37,10 +37,12 @@ describe("holster.on", () => {
       done() // This done is not called and test would fail if it was.
     })
 
-    holster.get("key2").put("value2", err => {
-      assert.equal(err, null)
-      done()
-    })
+    setTimeout(() => {
+      holster.get("key2").put("value2", err => {
+        assert.equal(err, null)
+        done()
+      })
+    }, 100)
   })
 
   test("on for property on root two updates - two events", (t, done) => {
@@ -70,6 +72,45 @@ describe("holster.on", () => {
     })
   })
 
+  test("on for properties on root in for loop", (t, done) => {
+    for (let i = 0; i < 5; i++) {
+      holster.get("for" + i).put(i, err => {
+        assert.equal(err, null)
+      })
+    }
+
+    // Need to wait until after all initial puts are done to set on listeners.
+    setTimeout(() => {
+      for (let i = 0; i < 5; i++) {
+        holster.get("for" + i).on(data => {
+          assert.equal(data, "update" + i)
+          if (i === 4) done()
+        })
+      }
+
+      setTimeout(() => {
+        for (let i = 0; i < 5; i++) {
+          holster.get("for" + i).put("update" + i, err => {
+            assert.equal(err, null)
+          })
+        }
+      }, 100)
+    }, 500)
+  })
+
+  test("on with get flag set - data returned", (t, done) => {
+    holster.get("key4").put("value4", err => {
+      assert.equal(err, null)
+
+      setTimeout(() => {
+        holster.get("key4").on(data => {
+          assert.equal(data, "value4")
+          done()
+        }, true)
+      }, 100)
+    })
+  })
+
   test("chained next before on", (t, done) => {
     // The node needs to exist before it can be listend to for updates.
     holster
@@ -140,7 +181,7 @@ describe("holster.on", () => {
         },
       }
       holster.get("nested").on(data => {
-        assert.deepEqual(data, update)
+        assert.deepEqual(data, {key: nested.key, ...update})
       })
 
       holster

package/test/holster.put.test.js

@@ -63,6 +63,23 @@ describe("holster.put", () => {
     })
   })
 
+  test("put and get values in for loop on root", (t, done) => {
+    for (let i = 0; i < 5; i++) {
+      holster.get("for" + i).put(i, err => {
+        assert.equal(err, null)
+      })
+    }
+
+    setTimeout(() => {
+      for (let i = 0; i < 5; i++) {
+        holster.get("for" + i, data => {
+          assert.equal(data, i)
+          if (i === 4) setTimeout(done, 100)
+        })
+      }
+    }, 200)
+  })
+
   test("chained get before put", (t, done) => {
     holster
       .get("hello")
@@ -269,7 +286,7 @@ describe("holster.put", () => {
     })
   })
 
-  test("holster put string with set", (t, done) => {
+  test("put string with set", (t, done) => {
     holster.get("set").put("first", true, err => {
       assert.equal(err, null)
 
@@ -292,7 +309,7 @@ describe("holster.put", () => {
     })
   })
 
-  test("holster put object with set", (t, done) => {
+  test("put object with set", (t, done) => {
     const set1 = {
       key: "value 1",
       child: "child value 1",

package/test/holster.secure.test.js

@@ -43,14 +43,6 @@ describe("holster.secure", () => {
     })
   })
 
-  // Chaining get creates a new context for each call.
-  test("get chained unknown keys callback null", (t, done) => {
-    holster.get("chained").get("unknown", data => {
-      assert.equal(data, null)
-      done()
-    })
-  })
-
   test("next chained unknown keys callback null", (t, done) => {
     holster.get("chained").next("unknown", data => {
       assert.equal(data, null)
@@ -102,7 +94,7 @@ describe("holster.secure", () => {
     })
   })
 
-  test("put and get string", (t, done) => {
+  test("user put and get string", (t, done) => {
     user.get("key").put("value", err => {
       assert.equal(err, null)
 

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

@@ -62,11 +62,23 @@ describe("holster.user.get", () => {
     })
   })
 
-  // Chaining get creates a new context for each call.
-  test("get chained unknown keys callback null", (t, done) => {
-    user.get("chained").get("unknown", data => {
+  test("get unknown keys in for loop callbacks null", (t, done) => {
+    for (let i = 0; i < 5; i++) {
+      user.get("unknown" + i, data => {
+        assert.equal(data, null)
+        if (i === 4) done()
+      })
+    }
+  })
+
+  test("nested get unknown key callback null", (t, done) => {
+    user.get("unknown", data => {
       assert.equal(data, null)
-      done()
+
+      user.get("unknown", data => {
+        assert.equal(data, null)
+        done()
+      })
     })
   })
 
@@ -77,6 +89,17 @@ describe("holster.user.get", () => {
     })
   })
 
+  test("nested next chained unknown keys callback null", (t, done) => {
+    user.get("chained").next("unknown", data => {
+      assert.equal(data, null)
+
+      user.get("chained").next("unknown", data => {
+        assert.equal(data, null)
+        done()
+      })
+    })
+  })
+
   test("cleanup", (t, done) => {
     fs.rm("test/holster.user.get", {recursive: true, force: true}, err => {
       assert.equal(err, null)

package/test/holster.user.lex.test.js

@@ -12,7 +12,6 @@ describe("holster.user.lex", () => {
     maxAge: 100,
   })
   const user = holster.user()
-  let alice = ""
 
   test("user create", (t, done) => {
     user.create("alice", "password", err => {
@@ -25,7 +24,6 @@ describe("holster.user.lex", () => {
     user.auth("alice", "password", err => {
       assert.equal(err, null)
       assert.equal(user.is.username, "alice")
-      alice = user.is.pub
       done()
     })
   })
@@ -84,6 +82,7 @@ describe("holster.user.lex", () => {
         other: "other child value",
       },
     }
+
     user.get("nested").put(nested, err => {
       assert.equal(err, null)
 
@@ -123,6 +122,7 @@ describe("holster.user.lex", () => {
           has: "child update",
         },
       }
+
       user
         .get("on-nested")
         .next("child")

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

@@ -69,6 +69,7 @@ describe("holster.user.on", () => {
           assert.equal(data, "update1")
         } else {
           assert.equal(data, "update2")
+          user.get("key3").off()
           done()
         }
       })
@@ -86,6 +87,54 @@ describe("holster.user.on", () => {
     })
   })
 
+  test("on for properties in for loop", (t, done) => {
+    ;(async () => {
+      for (let i = 0; i < 5; i++) {
+        // Need to be careful putting user properties in a loop as they are
+        // verified per node, so wait for each update to return.
+        const err = await new Promise(res => {
+          user.get("for" + i).put(i, res)
+        })
+        assert.equal(err, null)
+      }
+    })()
+
+    // Need to wait until after all initial puts are done to set on listeners.
+    setTimeout(async () => {
+      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()
+        })
+      }
+
+      setTimeout(async () => {
+        for (let i = 0; i < 5; i++) {
+          // Same as above put, wait for each update to return.
+          const err = await new Promise(res => {
+            user.get("for" + i).put("update" + i, res)
+          })
+          assert.equal(err, null)
+        }
+      }, 500)
+    }, 1000)
+  })
+
+  test("on with get flag set - data returned", (t, done) => {
+    user.get("key4").put("value4", err => {
+      assert.equal(err, null)
+
+      setTimeout(() => {
+        user.get("key4").on(data => {
+          assert.equal(data, "value4")
+          user.get("key4").off()
+          done()
+        }, true)
+      }, 100)
+    })
+  })
+
   test("chained next before on", (t, done) => {
     // The node needs to exist before it can be listend to for updates.
     user
@@ -119,6 +168,7 @@ describe("holster.user.on", () => {
       key: "plain value",
       number: 42,
     }
+
     user.get("plain").put(plain, err => {
       assert.equal(err, null)
 
@@ -126,6 +176,7 @@ describe("holster.user.on", () => {
         key: "update",
         number: 42,
       }
+
       user.get("plain").on(data => {
         assert.deepEqual(data, update)
         done()
@@ -156,6 +207,7 @@ describe("holster.user.on", () => {
           has: "child update",
         },
       }
+
       user.get("nested").on(data => {
         assert.deepEqual(data, update)
       })
@@ -177,9 +229,11 @@ describe("holster.user.on", () => {
   })
 
   test("cleanup", (t, done) => {
-    fs.rm("test/holster.user.on", {recursive: true, force: true}, err => {
-      assert.equal(err, null)
-      done()
-    })
+    setTimeout(() => {
+      fs.rm("test/holster.user.on", {recursive: true, force: true}, err => {
+        assert.equal(err, null)
+        done()
+      })
+    }, 100)
   })
 })