@mblaney/holster 0.3.0 → 1.0.1

package/examples/user.js

@@ -10,7 +10,7 @@ let alice, bob
 // Wait for the websocket to connect.
 setTimeout(() => {
   user.create("alice", "password", err => {
-    if (err !== "Username already exists") {
+    if (err && err !== "Username already exists") {
       console.log(err)
       return
     }
@@ -40,7 +40,7 @@ setTimeout(() => {
 
 setTimeout(() => {
   user.create("bob", "stronger password", err => {
-    if (err !== "Username already exists") {
+    if (err && err !== "Username already exists") {
       console.log(err)
       return
     }
@@ -77,7 +77,7 @@ setTimeout(() => {
   }
 
   // Use Bob's public key to fetch shared data under his account.
-  holster.user(bob.pub).get("shared", enc => {
+  user.get([bob.pub, "shared"], enc => {
     user.auth("alice", "password", async err => {
       if (err) {
         console.log(err)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mblaney/holster",
-  "version": "0.3.0",
+  "version": "1.0.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/get.js

@@ -1,18 +1,25 @@
+import {match} from "./utils.js"
+
 const Get = (lex, graph) => {
   const soul = lex["#"]
-  const key = typeof lex["."] === "string" ? lex["."] : false
-  var node = graph[soul]
+  if (!graph[soul]) return
 
-  // Can only return a node if a key is provided, because the graph may not
-  // have all the keys populated for a given soul. This is because Ham.mix
-  // only adds incoming changes to the graph.
-  if (!node || !key) return
+  const node = {_: {"#": soul, ">": {}}}
 
-  let value = node[key]
-  if (!value) return
+  if (typeof lex["."] === "string") {
+    const key = lex["."]
+    if (typeof graph[soul][key] === "undefined") return
 
-  node = {_: node._, [key]: value}
-  node._[">"] = {[key]: node._[">"][key]}
+    node[key] = graph[soul][key]
+    node._[">"][key] = graph[soul]._[">"][key]
+  } else {
+    for (const key of Object.keys(graph[soul])) {
+      if (match(lex["."], key)) {
+        node[key] = graph[soul][key]
+        node._[">"][key] = graph[soul]._[">"][key]
+      }
+    }
+  }
   return {[soul]: node}
 }
 

package/src/ham.js

@@ -26,9 +26,9 @@ const Ham = (state, currentState, value, currentValue) => {
 }
 
 Ham.mix = async (change, graph, secure, listen) => {
-  var machine = Date.now()
-  var now = {}
-  var defer = {}
+  const machine = Date.now()
+  const now = {}
+  const defer = {}
   let wait = 0
 
   for (const soul of Object.keys(change)) {
@@ -36,13 +36,14 @@ Ham.mix = async (change, graph, secure, listen) => {
     let updated = false
     let alias = false
     let nodeWait = 0
-    let pub = ""
     let verify = secure
 
     if (!node || !node._) continue
 
+    const sig = node[utils.userSignature]
+    const pub = node[utils.userPublicKey]
     // If a signature and public key are provided then always verify.
-    if (node._.s && node._.p) verify = true
+    if (sig && pub) verify = true
 
     // Special case if soul starts with "~". Node must be system data ie,
     // ~@alias or ~publickey. For aliases, key and value must be a self
@@ -53,26 +54,19 @@ Ham.mix = async (change, graph, secure, listen) => {
         alias = true
         verify = false
       } else {
-        if (node._.p && soul != "~" + node._.p) {
+        if (pub && soul != "~" + pub) {
           console.log(`error public key does not match for soul: ${soul}`)
           continue
         }
 
-        // Need to be able to create public key data before a user is
-        // authenticated, in this case the soul is the public key which
-        // should've been used to sign the data.
-        node._.p = soul.slice(1)
         verify = true
       }
     }
     if (verify) {
-      if (!node._.s || !node._.p) {
-        console.log("error signature and public key required to verify data")
-        continue
-      }
-
-      if (!(await SEA.verify({m: node, s: node._.s}, {pub: node._.p}))) {
-        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
       }
     }
@@ -81,11 +75,14 @@ Ham.mix = async (change, graph, secure, listen) => {
       if (key === "_") continue
 
       const value = node[key]
-      const state = node._[">"][key]
+      const state = node._ && node._[">"] ? node._[">"][key] : 0
       const currentValue = (graph[soul] || {})[key]
       const currentState = (graph[soul] || {_: {">": {}}})._[">"][key] || 0
 
-      if (alias && key !== utils.rel.is(value)) continue
+      if (alias && key !== utils.rel.is(value)) {
+        console.log(`error alias ${alias}: ${key} !== ${utils.rel.is(value)}`)
+        continue
+      }
 
       // Defer the update if ahead of machine time.
       const skew = state - machine
@@ -96,7 +93,7 @@ Ham.mix = async (change, graph, secure, listen) => {
         // Wait the shortest difference before trying the updates again.
         if (wait === 0 || skew < wait) wait = nodeWait = skew
         if (!defer[soul]) {
-          defer[soul] = {_: {"#": soul, ">": {}, s: node._.s, p: node._.p}}
+          defer[soul] = {_: {"#": soul, ">": {}}}
         }
         defer[soul][key] = value
         defer[soul]._[">"][key] = state
@@ -104,13 +101,13 @@ Ham.mix = async (change, graph, secure, listen) => {
         const result = Ham(state, currentState, value, currentValue)
         if (result.incoming) {
           if (!now[soul]) {
-            now[soul] = {_: {"#": soul, ">": {}, s: node._.s, p: node._.p}}
+            now[soul] = {_: {"#": soul, ">": {}}}
           }
           // TODO: graph should not just grow indefintitely in memory.
           // Need to have a max size after which start dropping the oldest state
           // Do something similar to Dup which can handle deletes?
           if (!graph[soul]) {
-            graph[soul] = {_: {"#": soul, ">": {}, s: node._.s, p: node._.p}}
+            graph[soul] = {_: {"#": soul, ">": {}}}
           }
           graph[soul][key] = now[soul][key] = value
           graph[soul]._[">"][key] = now[soul]._[">"][key] = state