@mblaney/holster 1.0.35 → 2.0.0

package/test/store.test.js

@@ -1,316 +0,0 @@
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Store from "../src/store.js"
-import fs from "fs"
-
-describe("store", () => {
-  const kitty = Store({file: "test/kitty"})
-  const multiple = Store({file: "test/multiple", size: 100})
-  const special = Store({file: "test/special"})
-  const newFileValue =
-    "file size is only 100 bytes so writing this value requires calling slice"
-
-  test("get graph", (t, done) => {
-    kitty.get({"#": "FDSA"}, (err, value) => {
-      assert.deepEqual(value, {
-        FDSA: {
-          _: {
-            "#": "FDSA",
-            ">": {
-              color: 3,
-              name: 2,
-              slave: 2,
-              species: 2,
-            },
-          },
-          color: "ginger",
-          name: "Fluffy",
-          slave: {
-            "#": "ASDF",
-          },
-          species: "felis silvestris",
-        },
-      })
-      done()
-    })
-  })
-
-  test("get item", (t, done) => {
-    kitty.get({"#": "FDSA", ".": "species"}, (err, value) => {
-      assert.deepEqual(value, {
-        FDSA: {
-          _: {
-            "#": "FDSA",
-            ">": {
-              species: 2,
-            },
-          },
-          species: "felis silvestris",
-        },
-      })
-      done()
-    })
-  })
-
-  test("put keys to multiple files", (t, done) => {
-    multiple.put(
-      {
-        keyA: {
-          _: {"#": "keyA", ">": {value: 1}},
-          value: "valueA",
-        },
-        keyB: {
-          _: {"#": "keyB", ">": {value: 1}},
-          value: "valueB",
-        },
-        keyC: {
-          _: {"#": "keyC", ">": {value: 1, extraField: 1}},
-          value: "valueC",
-          extraField: true,
-        },
-        newFile: {
-          _: {"#": "newFile", ">": {value: 1}},
-          value: newFileValue,
-        },
-      },
-      err => {
-        assert.equal(err, null)
-        fs.access("test/multiple/!", err => {
-          assert.equal(err, null)
-          fs.access("test/multiple/newFile", err => {
-            assert.equal(err, null)
-            done()
-          })
-        })
-      },
-    )
-  })
-
-  test("get key from first file", (t, done) => {
-    multiple.get({"#": "keyA"}, (err, value) => {
-      assert.deepEqual(value, {
-        keyA: {
-          _: {
-            "#": "keyA",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "valueA",
-        },
-      })
-      done()
-    })
-  })
-
-  test("get another key from first file", (t, done) => {
-    multiple.get({"#": "keyC"}, (err, value) => {
-      assert.deepEqual(value, {
-        keyC: {
-          _: {
-            "#": "keyC",
-            ">": {
-              extraField: 1,
-              value: 1,
-            },
-          },
-          extraField: true,
-          value: "valueC",
-        },
-      })
-    })
-    multiple.get({"#": "keyC", ".": "value"}, (err, value) => {
-      assert.deepEqual(value, {
-        keyC: {
-          _: {
-            "#": "keyC",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "valueC",
-        },
-      })
-      done()
-    })
-  })
-
-  test("get key from second file", (t, done) => {
-    multiple.get({"#": "newFile"}, (err, value) => {
-      assert.deepEqual(value, {
-        newFile: {
-          _: {
-            "#": "newFile",
-            ">": {
-              value: 1,
-            },
-          },
-          value: newFileValue,
-        },
-      })
-      fs.rm("test/multiple", {recursive: true, force: true}, err => {
-        assert.equal(err, null)
-        done()
-      })
-    })
-  })
-
-  test("put keys with special characters", (t, done) => {
-    special.put(
-      {
-        "#": {
-          _: {"#": "#", ">": {value: 1}},
-          value: "ok got #",
-        },
-        ">": {
-          _: {"#": ">", ">": {value: 1, extraField: 1}},
-          value: "ok got >",
-          extraField: true,
-        },
-        ".": {
-          _: {"#": ".", ">": {value: 1, extraField: 1}},
-          value: "ok got .",
-          extraField: true,
-        },
-        "+": {
-          _: {"#": "+", ">": {value: 1}},
-          value: "ok got +",
-        },
-        "[": {
-          _: {"#": "[", ">": {value: 1}},
-          value: "ok got [",
-        },
-        ",": {
-          _: {"#": ",", ">": {value: 1}},
-          value: "ok got ,",
-        },
-        '"': {
-          _: {"#": '"', ">": {value: 1}},
-          value: 'ok got "',
-        },
-        _: {
-          _: {"#": "_", ">": {value: 1}},
-          value: "ok got _",
-        },
-      },
-      err => {
-        assert.equal(err, null)
-        fs.access("test/special/!", err => {
-          assert.equal(err, null)
-          done()
-        })
-      },
-    )
-  })
-
-  test("get keys with special characters", (t, done) => {
-    special.get({"#": "#"}, (err, value) => {
-      assert.deepEqual(value, {
-        "#": {
-          _: {
-            "#": "#",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got #",
-        },
-      })
-    })
-    special.get({"#": ">", ".": "value"}, (err, value) => {
-      assert.deepEqual(value, {
-        ">": {
-          _: {
-            "#": ">",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got >",
-        },
-      })
-    })
-    special.get({"#": ".", ".": "value"}, (err, value) => {
-      assert.deepEqual(value, {
-        ".": {
-          _: {
-            "#": ".",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got .",
-        },
-      })
-    })
-    special.get({"#": "+"}, (err, value) => {
-      assert.deepEqual(value, {
-        "+": {
-          _: {
-            "#": "+",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got +",
-        },
-      })
-    })
-    special.get({"#": "["}, (err, value) => {
-      assert.deepEqual(value, {
-        "[": {
-          _: {
-            "#": "[",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got [",
-        },
-      })
-    })
-    special.get({"#": ","}, (err, value) => {
-      assert.deepEqual(value, {
-        ",": {
-          _: {
-            "#": ",",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got ,",
-        },
-      })
-    })
-    special.get({"#": '"'}, (err, value) => {
-      assert.deepEqual(value, {
-        '"': {
-          _: {
-            "#": '"',
-            ">": {
-              value: 1,
-            },
-          },
-          value: 'ok got "',
-        },
-      })
-    })
-    special.get({"#": "_"}, (err, value) => {
-      assert.deepEqual(value, {
-        _: {
-          _: {
-            "#": "_",
-            ">": {
-              value: 1,
-            },
-          },
-          value: "ok got _",
-        },
-      })
-      fs.rm("test/special", {recursive: true, force: true}, err => {
-        assert.equal(err, null)
-        done()
-      })
-    })
-  })
-})

package/test/system/basic.test.js

@@ -1,29 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - basic setup", () => {
-  const wss = new Server("ws://localhost:9001")
-  const holster = Holster({file: "test/system/basic", wss: wss})
-
-  test("put and get data", (t, done) => {
-    holster.get("test").put({message: "hello"}, err => {
-      assert.equal(err, null)
-
-      holster.get("test", data => {
-        assert.notEqual(data, null)
-        assert.equal(data.message, "hello")
-        done()
-      })
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm("test/system/basic", {recursive: true, force: true}, err => {
-      assert.equal(err, null)
-      done()
-    })
-  })
-})

package/test/system/chained-on.test.js

@@ -1,41 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - chained get with on", () => {
-  const wss = new Server("ws://localhost:9002")
-  const holster = Holster({file: "test/system/chained-on", wss: wss})
-
-  test("on listener fires with null when no data exists", (t, done) => {
-    holster.get("key").on(data => {
-      // This is the actual behavior - on fires with null for non-existent keys
-      assert.equal(data, null)
-      done()
-    }, true)
-  })
-
-  test("put then on listener receives data", (t, done) => {
-    // Put data first
-    holster.get("key2").put({value: "test"}, err => {
-      assert.equal(err, null)
-
-      // Then set up listener - should get the existing data
-      setTimeout(() => {
-        holster.get("key2").on(data => {
-          assert.notEqual(data, null)
-          assert.equal(data.value, "test")
-          done()
-        }, true)
-      }, 50)
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm("test/system/chained-on", {recursive: true, force: true}, err => {
-      assert.equal(err, null)
-      done()
-    })
-  })
-})

package/test/system/concurrent-listeners.test.js

@@ -1,125 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - concurrent listeners", () => {
-  const wss = new Server("ws://localhost:9005")
-  const holster = Holster({file: "test/system/concurrent-listeners", wss: wss})
-
-  test("multiple listeners on same path receive data", (t, done) => {
-    let listener1Called = false
-    let listener2Called = false
-
-    holster.get("key").put({value: "test"}, err => {
-      assert.equal(err, null)
-
-      // Set up two listeners on the same path
-      holster.get("key").on(data => {
-        listener1Called = true
-        assert.notEqual(data, null)
-        assert.equal(data.value, "test")
-        checkComplete()
-      }, true)
-
-      holster.get("key").on(data => {
-        listener2Called = true
-        assert.notEqual(data, null)
-        assert.equal(data.value, "test")
-        checkComplete()
-      }, true)
-
-      function checkComplete() {
-        if (listener1Called && listener2Called) {
-          done()
-        }
-      }
-    })
-  })
-
-  test("nested listeners on parent and child paths", (t, done) => {
-    let parentCalled = false
-    let childCalled = false
-
-    holster.get("parent").put({value: "parent-value"}, err => {
-      assert.equal(err, null)
-
-      holster
-        .get("parent")
-        .next("child")
-        .put({value: "child-value"}, err => {
-          assert.equal(err, null)
-
-          // Listen on parent
-          holster.get("parent").on(data => {
-            parentCalled = true
-            assert.notEqual(data, null)
-            assert.equal(data.value, "parent-value")
-            checkComplete()
-          }, true)
-
-          // Listen on child
-          holster
-            .get("parent")
-            .next("child")
-            .on(data => {
-              childCalled = true
-              assert.notEqual(data, null)
-              assert.equal(data.value, "child-value")
-              checkComplete()
-            }, true)
-
-          function checkComplete() {
-            if (parentCalled && childCalled) {
-              done()
-            }
-          }
-        })
-    })
-  })
-
-  test("listener race condition - data before and after listener setup", (t, done) => {
-    const results = []
-
-    // Put data first
-    holster.get("race").put({value: "first"}, err => {
-      assert.equal(err, null)
-
-      // Set up listener with _get=true to read existing data
-      // The listener will be called with the existing data via the get request
-      holster.get("race").on(data => {
-        results.push(data?.value)
-      }, true)
-
-      // Immediately put new data - listener will fire for this put as well
-      setTimeout(() => {
-        holster.get("race").put({value: "second"}, err => {
-          assert.equal(err, null)
-
-          setTimeout(() => {
-            // Should have received both values - one from get, one from put
-            assert.equal(
-              results.length >= 1,
-              true,
-              "Should receive at least initial value from get",
-            )
-            assert.equal(results[0], "first", "First value should be 'first'")
-            done()
-          }, 100)
-        })
-      }, 50)
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm(
-      "test/system/concurrent-listeners",
-      {recursive: true, force: true},
-      err => {
-        assert.equal(err, null)
-        done()
-      },
-    )
-  })
-})

package/test/system/immediate-read.test.js

@@ -1,30 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - immediate read after write", () => {
-  const wss = new Server("ws://localhost:9008")
-  const holster = Holster({file: "test/system/immediate-read", wss: wss})
-
-  test("get immediately after put returns data despite queue delays", (t, done) => {
-    holster.get("testkey").put({value: "test"}, err => {
-      assert.equal(err, null)
-
-      // Immediate get after put - validates retry logic handles queued writes
-      holster.get("testkey", data => {
-        assert.notEqual(data, null)
-        assert.equal(data.value, "test")
-        done()
-      })
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm("test/system/immediate-read", {recursive: true, force: true}, err => {
-      assert.equal(err, null)
-      done()
-    })
-  })
-})

package/test/system/listener-before-data.test.js

@@ -1,51 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - listener before data", () => {
-  const wss = new Server("ws://localhost:9007")
-  const holster = Holster({file: "test/system/listener-before-data", wss: wss})
-
-  test("listener set up before data exists receives data when populated", (t, done) => {
-    const results = []
-
-    // Set up listener first - this is the browser Display.js pattern
-    holster.get("testkey").on(data => {
-      results.push(data)
-    })
-
-    // Give listener time to set up
-    setTimeout(() => {
-      holster.get("testkey").put({value: "test"}, err => {
-        assert.equal(err, null)
-
-        // Give listener time to fire
-        setTimeout(() => {
-          // With the new behavior, listener fires after data is stored
-          // Should have received the test value from the put
-          const nonNull = results.filter(r => r !== null)
-          assert.equal(
-            nonNull.length >= 1,
-            true,
-            "Should have at least one non-null result",
-          )
-          assert.equal(nonNull[0].value, "test")
-          done()
-        }, 200)
-      })
-    }, 100)
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm(
-      "test/system/listener-before-data",
-      {recursive: true, force: true},
-      err => {
-        assert.equal(err, null)
-        done()
-      },
-    )
-  })
-})

package/test/system/promise-wrapper.test.js

@@ -1,47 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - promise wrapped calls", () => {
-  const wss = new Server("ws://localhost:9004")
-  const holster = Holster({file: "test/system/promise-wrapper", wss: wss})
-
-  test("promise wrapped get returns null for missing key", async t => {
-    const data = await new Promise(res => {
-      holster.get("missing", res)
-    })
-    assert.equal(data, null)
-  })
-
-  test("promise wrapped get returns data for existing key", async t => {
-    await new Promise(res => {
-      holster.get("key").put({value: "test"}, res)
-    })
-
-    const data = await new Promise(res => {
-      holster.get("key", res)
-    })
-    assert.notEqual(data, null)
-    assert.equal(data.value, "test")
-  })
-
-  test("promise wrapped next returns null for missing nested key", async t => {
-    const data = await new Promise(res => {
-      holster.get("key1").next("missing", res)
-    })
-    assert.equal(data, null)
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm(
-      "test/system/promise-wrapper",
-      {recursive: true, force: true},
-      err => {
-        assert.equal(err, null)
-        done()
-      },
-    )
-  })
-})

package/test/system/user-chained-on.test.js

@@ -1,60 +0,0 @@
-import fs from "fs"
-import {Server} from "mock-socket"
-import {describe, test} from "node:test"
-import assert from "node:assert/strict"
-import Holster from "../../src/holster.js"
-
-describe("system - user chained get with on", () => {
-  const wss = new Server("ws://localhost:9012")
-  const holster = Holster({
-    file: "test/system/user-chained-on",
-    wss: wss,
-    wait: 500,
-  })
-  const user = holster.user()
-
-  test("user create and auth", (t, done) => {
-    user.create("testuser", "password", err => {
-      assert.equal(err, null)
-      user.auth("testuser", "password", err => {
-        assert.equal(err, null)
-        done()
-      })
-    })
-  })
-
-  test("on listener fires with null when no data exists", (t, done) => {
-    user.get("key").on(data => {
-      // This is the actual behavior - on fires with null for non-existent keys
-      assert.equal(data, null)
-      done()
-    }, true)
-  })
-
-  test("put then on listener receives data", (t, done) => {
-    // Put data first
-    user.get("key2").put({value: "test"}, err => {
-      assert.equal(err, null)
-
-      // Then set up listener - should get the existing data
-      setTimeout(() => {
-        user.get("key2").on(data => {
-          assert.notEqual(data, null)
-          assert.deepEqual(data, {value: "test"})
-          done()
-        }, true)
-      }, 50)
-    })
-  })
-
-  test("cleanup", (t, done) => {
-    fs.rm(
-      "test/system/user-chained-on",
-      {recursive: true, force: true},
-      err => {
-        assert.equal(err, null)
-        done()
-      },
-    )
-  })
-})