@mblaney/holster 1.0.35 → 1.0.36

package/ts/src/store.ts

@@ -0,0 +1,321 @@
+/**
+ * Store - Storage interface for graph data
+ * Provides get and put methods with filesystem or IndexedDB backend
+ */
+
+import Radisk from "./radisk.ts"
+import Radix from "./radix.ts"
+import * as utils from "./utils.ts"
+import type {
+  Lex,
+  Graph,
+  GraphNode,
+  StoreOptions,
+  FileSystemInterface,
+  EncodedValue,
+} from "./schemas.ts"
+
+const isNode = typeof document === "undefined"
+
+// Dynamic import for Node.js fs module - won't execute in browser/service worker
+const fs = isNode
+  ? await import(/*webpackIgnore: true*/ "node:fs")
+  : undefined
+
+// ASCII character for enquiry
+const enq = String.fromCharCode(5)
+// ASCII character for unit separator
+const unit = String.fromCharCode(31)
+// On-disk root node format
+const root = unit + "+0" + unit + "#" + unit + '"root' + unit
+
+/**
+ * Create file system storage backend
+ */
+const fileSystem = (opt: StoreOptions): FileSystemInterface => {
+  const dir = opt.file!
+
+  if (isNode) {
+    if (!fs!.existsSync(dir)) fs!.mkdirSync(dir)
+    if (!fs!.existsSync(dir + "/!")) fs!.writeFileSync(dir + "/!", root)
+
+    return {
+      get: (file, cb) => {
+        fs!.readFile(dir + "/" + file, (err: NodeJS.ErrnoException | null, data?: Buffer) => {
+          if (err) {
+            if ((err as { code?: string }).code === "ENOENT") {
+              cb()
+              return
+            }
+            console.log("fs.readFile error:", err)
+          }
+          const dataStr = data ? data.toString() : undefined
+          cb(err as never, dataStr)
+        })
+      },
+      put: (file, data, cb) => {
+        const tmp = file + "." + utils.text.random(9) + ".tmp"
+        fs!.writeFile(tmp, data as string, (err: NodeJS.ErrnoException | null) => {
+          if (err) {
+            console.log("fs.writeFile error:", err)
+            cb(err as never)
+            return
+          }
+          fs!.rename(tmp, dir + "/" + file, cb as never)
+        })
+      },
+      list: cb => {
+        fs!.readdir(dir, (err: NodeJS.ErrnoException | null, files?: string[]) => {
+          if (err) {
+            console.log("fs.readdir error:", err)
+            cb()
+            return
+          }
+          if (files) files.forEach(cb)
+          cb()
+        })
+      },
+    }
+  }
+
+  if (opt.indexedDB) {
+    let db: IDBDatabase
+    const dbReady = new Promise<void>((resolve, reject) => {
+      const o = indexedDB.open(dir, 1)
+      o.onupgradeneeded = event => {
+        ;(event.target as IDBOpenDBRequest).result.createObjectStore(dir)
+      }
+      o.onerror = event => {
+        console.log(event)
+        reject(event)
+      }
+      o.onsuccess = () => {
+        db = o.result
+        if (db) {
+          const tx = db.transaction([dir], "readonly")
+          const req = tx.objectStore(dir).getKey("!")
+          req.onerror = () => {
+            console.log(`error getting key ${dir}/!`)
+            reject(req.error)
+          }
+          req.onsuccess = () => {
+            if (!req.result) {
+              const tx = db.transaction([dir], "readwrite")
+              const req = tx.objectStore(dir).put(root, "!")
+              req.onerror = () => {
+                console.log(`error putting root on ${dir}/!`)
+                reject(req.error)
+              }
+              req.onsuccess = () => {
+                resolve()
+              }
+            } else {
+              resolve()
+            }
+          }
+        } else {
+          console.log("error indexedDB not available")
+          reject(new Error("indexedDB not available"))
+        }
+      }
+    })
+
+    return {
+      get: (file, cb) => {
+        const _get = (file: string, cb: (err?: string | null, data?: string) => void) => {
+          const tx = db.transaction([dir], "readonly")
+          const req = tx.objectStore(dir).get(file)
+          req.onerror = () => {
+            console.log(`error getting ${dir}/${file}`)
+            cb(req.error as unknown as string)
+          }
+          req.onsuccess = () => {
+            cb(null, req.result)
+          }
+        }
+
+        dbReady
+          .then(() => {
+            _get(file, cb)
+          })
+          .catch(err => {
+            cb(err as string)
+          })
+      },
+      put: (file, data, cb) => {
+        const _put = (
+          file: string,
+          data: string,
+          cb: (err?: string | null) => void
+        ) => {
+          const tx = db.transaction([dir], "readwrite")
+          const req = tx.objectStore(dir).put(data, file)
+          req.onerror = () => {
+            console.log(`error putting data on ${dir}/${file}`)
+            cb(req.error as unknown as string)
+          }
+          req.onsuccess = () => {
+            cb(null)
+          }
+        }
+
+        dbReady
+          .then(() => {
+            _put(file, data as string, cb)
+          })
+          .catch(err => {
+            cb(err as string)
+          })
+      },
+      list: cb => {
+        const _list = (cb: (file?: string) => void) => {
+          const tx = db.transaction([dir], "readonly")
+          const req = tx.objectStore(dir).getAllKeys()
+          req.onerror = () => {
+            console.log("error getting keys for", dir)
+            cb()
+          }
+          req.onsuccess = () => {
+            ;(req.result as string[]).forEach(cb)
+            cb()
+          }
+        }
+
+        dbReady
+          .then(() => {
+            _list(cb)
+          })
+          .catch(err => {
+            console.log("error indexedDB not available:", err)
+            cb()
+          })
+      },
+    }
+  }
+
+  // No browser storage
+  return {
+    get: (_file, cb) => {
+      cb(null, root)
+    },
+    put: (_file, _data, cb) => {
+      cb(null)
+    },
+    list: cb => {
+      cb("!")
+      cb()
+    },
+  }
+}
+
+export interface StoreInterface {
+  get: (
+    lex: Lex,
+    cb: (err?: string | null, graph?: Graph) => void,
+    _opt?: { secure?: boolean }
+  ) => void
+  put: (graph: Graph, cb: (err?: string | null) => void) => void
+}
+
+/**
+ * Create Store with get and put methods
+ */
+const Store = (opt?: StoreOptions): StoreInterface => {
+  const options = opt || {}
+  options.file = String(options.file || "radata")
+  if (!options.store) options.store = fileSystem(options)
+  const radisk = Radisk(options as never)
+
+  return {
+    get: (lex, cb, _opt) => {
+      if (!lex || !utils.obj.is(lex)) {
+        cb("lex required")
+        return
+      }
+      if (!lex["#"]) {
+        cb("soul required in lex")
+        return
+      }
+
+      const opts = _opt || {}
+      const soul = lex["#"]
+      const key =
+        !opts.secure && typeof lex["."] === "string" ? lex["."] : ""
+      let node: GraphNode | undefined
+      const signatures: Record<string, string> = {}
+
+      const each = (value: EncodedValue, key: string): void => {
+        // Always include userPublicKey for verification, regardless of filter
+        if (key !== utils.userPublicKey && !utils.match(lex["."], key)) return
+
+        if (!node) node = { _: { "#": soul, ">": {} } }
+        node[key] = value[0]
+        node._[">"][key] = value[1]
+        // If signature is present, store it in _["s"]
+        if (value.length === 3 && value[2]) {
+          signatures[value[1].toString()] = value[2]
+        }
+      }
+
+      radisk(soul + enq + key, (err, value) => {
+        let graph: Graph | undefined
+        if (utils.obj.is(value)) {
+          Radix.map(value as never, each)
+          if (!node) each(value as never, key)
+          graph = { [soul]: node! }
+        } else if (value) {
+          each(value as EncodedValue, key)
+          graph = { [soul]: node! }
+        }
+        // Only add _["s"] if we found any signatures
+        if (graph && graph[soul] && Object.keys(signatures).length > 0) {
+          graph[soul]._["s"] = signatures
+        }
+        cb(err, graph)
+      })
+    },
+    put: (graph, cb) => {
+      if (!graph) {
+        cb("graph required")
+        return
+      }
+
+      let count = 0
+      let finished = false
+      const ack = (err?: string | null): void => {
+        count--
+        if (finished) return
+
+        if (err) {
+          finished = true
+          cb(err)
+          return
+        }
+
+        if (count === 0) {
+          finished = true
+          cb(null)
+        }
+      }
+
+      Object.keys(graph).forEach(soul => {
+        const node = graph[soul]!
+        Object.keys(node).forEach(key => {
+          if (key === "_") return
+
+          count++
+          const value = node[key]!
+          const state = node._[">"][key]!
+          const sig = node._["s"] && node._["s"][state]
+          const data: EncodedValue = sig
+            ? [value, state, sig]
+            : [value, state]
+          radisk(soul + enq + key, data, ack)
+        })
+      })
+    },
+  }
+}
+
+export default Store
+

package/ts/src/user.ts

@@ -0,0 +1,381 @@
+/**
+ * User - User authentication and management
+ * Provides user creation, authentication, and password management
+ */
+
+import * as utils from "./utils.ts"
+import Wire from "./wire.ts"
+import SEA from "./sea.ts"
+import type { UserIdentity, HolsterOptions, LexFilter, WireOptions } from "./schemas.ts"
+import type { HolsterAPI } from "./holster.ts"
+
+type WireInterface = ReturnType<typeof Wire>
+
+export interface UserInterface {
+  is?: UserIdentity | null
+  create: (username: string, password: string, cb?: (err?: string | null) => void) => void
+  auth: (username: string, password: string, cb?: (err?: string | null) => void) => void
+  change: (
+    username: string,
+    password: string,
+    newPassword: string,
+    cb?: (err?: string | null) => void
+  ) => void
+  store: (localStorage?: boolean) => void
+  recall: () => void
+  leave: () => void
+  delete: (username: string, password: string, cb?: (err?: string | null) => void) => void
+  get?(
+    keys: string | string[],
+    lex?: LexFilter | ((data: unknown) => void),
+    cb?: ((data: unknown) => void) | WireOptions,
+    _opt?: WireOptions
+  ): HolsterAPI
+}
+
+/**
+ * Create User management interface
+ */
+const User = (opt: HolsterOptions | undefined, wire?: WireInterface): UserInterface => {
+  if (!wire) wire = Wire(opt as HolsterOptions)
+  const wait = opt?.wait ?? 5000
+  let pubs: string[] = []
+  let creating = false
+  let authing = false
+  let retries = 0
+
+  const auth = (
+    username: string,
+    password: string,
+    newPassword: string,
+    ack: (err?: string | null) => void
+  ): void => {
+    const retry = (username: string): void => {
+      retries++
+      auth(username, password, newPassword, ack)
+    }
+    const done = (err?: string | null): void => {
+      pubs = []
+      retries = 0
+      authing = false
+      ack(err)
+    }
+    const next = (): void => {
+      if (pubs.length === 0) {
+        done("Wrong username or password")
+        return
+      }
+
+      const pub = pubs.shift()!
+      wire.get(
+        { "#": pub, ".": ["auth", "pub", "epub"] },
+        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 authData = JSON.parse(data.auth as string) as {
+            enc: { ct: string; iv: string; s: string }
+            salt: string
+          }
+          const work = await SEA.work(password, authData.salt)
+          const dec = (await SEA.decrypt(authData.enc, work)) as
+            | { priv: string; epriv: string }
+            | null
+          if (!dec) return next()
+
+          user.is = {
+            username: username,
+            pub: data.pub as string,
+            epub: data.epub as string,
+            priv: dec.priv,
+            epriv: dec.epriv,
+          }
+          if (newPassword !== "") {
+            const salt = utils.text.random(64)
+            const newWork = await SEA.work(newPassword, salt)
+            const enc = await SEA.encrypt(dec, newWork)
+            const update = {
+              auth: JSON.stringify({ enc: enc, salt: salt }),
+            }
+            const timestamp = Date.now()
+            const sig = await SEA.signTimestamp(timestamp, user.is)
+            const graph = utils.graph(pub, update, sig!, data.pub as string, timestamp)
+            wire.put(graph, err => {
+              if (err) {
+                done(`error putting ${JSON.stringify(update)} on ${pub}: ${err}`)
+              } else {
+                done(null)
+              }
+            })
+            return
+          }
+
+          done(null)
+        },
+        { wait: wait }
+      )
+    }
+
+    if (retries > 9) {
+      done("Wrong username or password")
+      return
+    }
+
+    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)
+
+        delete (data as { _?: unknown })._
+        pubs = Object.keys(data)
+        next()
+      },
+      { wait: wait }
+    )
+  }
+
+  const user: UserInterface = {
+    is: null,
+    create: (username, password, cb) => {
+      const ack = (err?: string | null): void => {
+        if (cb) cb(err)
+        else if (err) console.log(err)
+      }
+
+      if (creating) {
+        ack("User is already being created")
+        return
+      }
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      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 }),
+          }
+
+          const pub = "~" + pair.pub
+          const timestamp = Date.now()
+          const sig = await SEA.signTimestamp(timestamp, pair)
+          const graph = utils.graph(pub, data, sig!, pair.pub, timestamp)
+          wire.put(graph, err => {
+            creating = false
+            if (err) {
+              ack(`error putting ${JSON.stringify(data)} on ${pub}: ${err}`)
+              return
+            }
+
+            const rel = { [pub]: { "#": pub } }
+            wire.put(utils.graph(soul, rel as never), err => {
+              if (err) {
+                ack(`error putting ${JSON.stringify(rel)} on ${soul}: ${err}`)
+                return
+              }
+
+              if (cb) cb(null)
+            })
+          })
+        },
+        { wait: wait }
+      )
+    },
+    auth: (username, password, cb) => {
+      const ack = (err?: string | null): void => {
+        if (cb) cb(err)
+        else if (err) console.log(err)
+      }
+
+      if (authing) {
+        ack("User is already authenticating")
+        return
+      }
+
+      user.is = null
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      authing = true
+      auth(username, password, "", ack)
+    },
+    change: (username, password, newPassword, cb) => {
+      const ack = (err?: string | null): void => {
+        if (cb) cb(err)
+        else if (err) console.log(err)
+      }
+
+      if (authing) {
+        ack("User is already authenticating")
+        return
+      }
+
+      user.is = null
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      if (newPassword === "") {
+        ack("Please provide a new password")
+        return
+      }
+
+      authing = true
+      auth(username, password, newPassword, ack)
+    },
+    store: (localStorage = false) => {
+      if (!user.is) {
+        console.log("Please authenticate before calling store")
+        return
+      }
+
+      if (localStorage) {
+        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: () => {
+      if (typeof globalThis.localStorage !== "undefined") {
+        const is = globalThis.localStorage.getItem("user.is")
+        if (is) {
+          user.is = JSON.parse(is)
+          return
+        }
+      }
+
+      if (typeof globalThis.sessionStorage !== "undefined") {
+        const is = globalThis.sessionStorage.getItem("user.is")
+        if (is) {
+          user.is = JSON.parse(is)
+        }
+      }
+    },
+    leave: () => {
+      user.is = null
+      if (typeof globalThis.localStorage !== "undefined") {
+        globalThis.localStorage.removeItem("user.is")
+      }
+      if (typeof globalThis.sessionStorage !== "undefined") {
+        globalThis.sessionStorage.removeItem("user.is")
+      }
+    },
+    delete: (username, password, cb) => {
+      const ack = (err?: string | null): void => {
+        if (cb) cb(err)
+        else if (err) console.log(err)
+      }
+
+      if (authing) {
+        ack("User is already authenticating")
+        return
+      }
+
+      if (username === "") {
+        ack("Please provide a username")
+        return
+      }
+
+      if (password === "") {
+        ack("Please provide a password")
+        return
+      }
+
+      authing = true
+      auth(username, password, "", async err => {
+        if (err) {
+          ack(err)
+          return
+        }
+
+        const data = { username: null, pub: null, epub: null, auth: null }
+        const timestamp = Date.now()
+        const sig = await SEA.signTimestamp(timestamp, user.is!)
+        const pub = "~" + user.is!.pub
+        const graph = utils.graph(pub, data as never, sig!, user.is!.pub, timestamp)
+        wire.put(graph, err => {
+          if (err) {
+            ack(`error putting null on ${pub}: ${err}`)
+            return
+          }
+
+          user.is = null
+          if (cb) cb(null)
+        })
+      })
+    },
+  }
+  return user
+}
+
+export default User
+