@live-change/db-store-level 0.9.226 → 0.9.228

package/.node-version

@@ -0,0 +1 @@
+20.20.2

package/lib/Store.js

@@ -1,7 +1,64 @@
 import IntervalTreeLib from '@live-change/flatten-interval-tree'
-const IntervalTree = IntervalTreeLib.default
+const IntervalTree = IntervalTreeLib.default ?? IntervalTreeLib
 import ReactiveDao from "@live-change/dao"
 
+function isNotFound(err) {
+  if(!err) return false
+  if(err.notFound) return true
+  if(err.code === 'LEVEL_NOT_FOUND') return true
+  if(err.name === 'NotFoundError') return true
+  const text = String(err.message || err)
+  return /notfound/i.test(text)
+}
+
+function keyToString(key) {
+  if(key == null) return ''
+  if(typeof key === 'string') return key
+  if(Buffer.isBuffer(key)) return key.toString('utf8')
+  return String(key)
+}
+
+function valueToString(value) {
+  if(value == null) return null
+  if(typeof value === 'string') return value
+  if(Buffer.isBuffer(value)) return value.toString('utf8')
+  return String(value)
+}
+
+function parseValue(value) {
+  const s = valueToString(value)
+  if(s == null || s === '') return null
+  return JSON.parse(s)
+}
+
+function prefixEnd(prefix) {
+  if(!prefix) return undefined
+  const buf = Buffer.from(prefix, 'utf8')
+  for(let i = buf.length - 1; i >= 0; i--) {
+    if(buf[i] < 255) {
+      buf[i]++
+      return buf.slice(0, i + 1).toString('utf8')
+    }
+  }
+  return prefix + '\xFF'
+}
+
+function iteratorNext(iterator) {
+  return new Promise((resolve, reject) => {
+    iterator.next((err, key, value) => {
+      if(err) return reject(err)
+      if(key === undefined && value === undefined) return resolve(null)
+      resolve({ key, value })
+    })
+  })
+}
+
+function iteratorEnd(iterator) {
+  return new Promise((resolve, reject) => {
+    iterator.end(err => err ? reject(err) : resolve())
+  })
+}
+
 class ObjectObservable extends ReactiveDao.ObservableValue {
   constructor(store, key) {
     super()
@@ -88,7 +145,6 @@ class RangeObservable extends ReactiveDao.ObservableList {
 
   async putObject(object, oldObject) {
     await this.readPromise
-    //console.log("OBSERVABLE PUT OBJECT", object)
     const id = object.id
     if(this.range.gt && !(id > this.range.gt)) return
     if(this.range.lt && !(id < this.range.lt)) return
@@ -118,7 +174,7 @@ class RangeObservable extends ReactiveDao.ObservableList {
             this.fireObservers('putByField', 'id', id, object, true, oldObject)
             return
           } else if(this.list[i].id > id) {
-            if(i == this.list.length - 1) return // last element is bigger, do nothing
+            if(i == this.list.length - 1) return
             this.list.splice(i + 1, 0, object)
             this.fireObservers('putByField', 'id', id, object, true, oldObject)
             const popped = this.list.pop()
@@ -160,6 +216,7 @@ class RangeObservable extends ReactiveDao.ObservableList {
   }
 
   async deleteObject(object) {
+    if(!object) return
     await this.readPromise
     const id = object.id
     if(this.range.gt && !(id > this.range.gt)) return
@@ -192,7 +249,7 @@ class RangeObservable extends ReactiveDao.ObservableList {
     this.changesStream = null
 
     this.store.rangeObservables.delete(this.rangeKey)
-    let removed = this.store.rangeObservablesTree.remove(this.rangeDescr, this)
+    this.store.rangeObservablesTree.remove(this.rangeDescr, this)
   }
 
   respawn() {
@@ -210,22 +267,194 @@ class RangeObservable extends ReactiveDao.ObservableList {
   }
 }
 
+class CountObservable extends ReactiveDao.ObservableValue {
+  constructor(store, range) {
+    super()
+    this.store = store
+    this.range = range
+
+    this.disposed = false
+    this.ready = false
+    this.respawnId = 0
+    this.refillId = 0
+    this.refillPromise = null
+
+    this.forward = null
+
+    this.rangeKey = JSON.stringify(this.range)
+    this.rangeDescr = [ this.range.gt || this.range.gte || '', this.range.lt || this.range.lte || '\xFF\xFF\xFF\xFF']
+
+    this.readPromise = this.startReading()
+  }
+
+  async startReading() {
+    this.store.countObservables.set(this.rangeKey, this)
+    this.store.rangeObservablesTree.insert(this.rangeDescr, this)
+    this.set(await this.store.countGet(this.range))
+  }
+
+  async putObject(object, oldObject) {
+    const id = object.id
+    if(this.range.gt && !(id > this.range.gt)) return
+    if(this.range.lt && !(id < this.range.lt)) return
+    await this.readPromise
+    if(this.range.limit) {
+      this.set(await this.store.countGet(this.range))
+    } else {
+      if(object && !oldObject) {
+        this.set(this.value + 1)
+      } else if(!object && oldObject) {
+        this.set(this.value - 1)
+      }
+    }
+  }
+
+  async deleteObject(object) {
+    if(!object) return
+    const id = object.id
+    if(this.range.gt && !(id > this.range.gt)) return
+    if(this.range.lt && !(id < this.range.lt)) return
+    this.set(this.value - 1)
+  }
+
+  dispose() {
+    if(this.forward) {
+      this.forward.unobserve(this)
+      this.forward = null
+      return
+    }
+
+    this.disposed = true
+    this.respawnId++
+    this.changesStream = null
+
+    this.store.countObservables.delete(this.rangeKey)
+    this.store.rangeObservablesTree.remove(this.rangeDescr, this)
+  }
+
+  respawn() {
+    const existingObservable = this.store.countObservables.get(JSON.stringify(this.range))
+    if(existingObservable) {
+      this.forward = existingObservable
+      this.forward.observe(this)
+      return
+    }
+
+    this.respawnId++
+    this.ready = false
+    this.disposed = false
+    this.startReading()
+  }
+}
+
 class Store {
-  constructor(level, options = {}) {
-    this.level = level
+  constructor(down, options = {}) {
+    this.down = down
+    this.prefix = options.prefix || ''
+    this.prefixEnd = this.prefix ? prefixEnd(this.prefix) : undefined
     this.objectObservables = new Map()
     this.rangeObservables = new Map()
+    this.countObservables = new Map()
     this.rangeObservablesTree = new IntervalTree()
     this.locks = new Map()
   }
 
-  objectGet(key) {
-    return this.level.get(key).catch(err => {
-      if(err.name == 'NotFoundError') return null
-      throw err
+  async ready() {
+    if(this.down && this.down._opened) await this.down._opened
+  }
+
+  encodeKey(id) {
+    return this.prefix + id
+  }
+
+  decodeKey(key) {
+    const s = keyToString(key)
+    if(this.prefix && s.startsWith(this.prefix)) return s.slice(this.prefix.length)
+    return s
+  }
+
+  iteratorRange(range, extra = {}) {
+    const opts = {
+      reverse: !!range.reverse,
+      keyAsBuffer: false,
+      valueAsBuffer: false,
+      ...extra
+    }
+    if(range.limit != null) opts.limit = range.limit
+
+    if(range.gt != null) opts.gt = this.encodeKey(range.gt)
+    else if(range.gte != null) opts.gte = this.encodeKey(range.gte)
+    else if(this.prefix) opts.gte = this.prefix
+
+    if(range.lt != null) opts.lt = this.encodeKey(range.lt)
+    else if(range.lte != null) opts.lte = this.encodeKey(range.lte)
+    else if(this.prefixEnd) opts.lt = this.prefixEnd
+
+    return opts
+  }
+
+  async iterate(opts, onItem) {
+    await this.ready()
+    const iterator = this.down.iterator(opts)
+    try {
+      while(true) {
+        const pair = await iteratorNext(iterator)
+        if(!pair) break
+        await onItem(pair)
+      }
+    } finally {
+      await iteratorEnd(iterator)
+    }
+  }
+
+  downGet(key) {
+    return new Promise((resolve, reject) => {
+      this.down.get(key, (err, value) => {
+        if(err) {
+          if(isNotFound(err)) return resolve(null)
+          return reject(err)
+        }
+        resolve(value)
+      })
+    })
+  }
+
+  downPut(key, value) {
+    return new Promise((resolve, reject) => {
+      this.down.put(key, value, err => err ? reject(err) : resolve())
     })
   }
 
+  downDel(key) {
+    return new Promise((resolve, reject) => {
+      this.down.del(key, err => {
+        if(err && !isNotFound(err)) return reject(err)
+        resolve()
+      })
+    })
+  }
+
+  downBatch(ops) {
+    if(!ops.length) return Promise.resolve()
+    return new Promise((resolve, reject) => {
+      this.down.batch(ops, err => err ? reject(err) : resolve())
+    })
+  }
+
+  downClear(opts) {
+    return new Promise((resolve, reject) => {
+      this.down.clear(opts, err => err ? reject(err) : resolve())
+    })
+  }
+
+  async objectGet(key) {
+    if(!key) throw new Error("key is required")
+    await this.ready()
+    const raw = await this.downGet(this.encodeKey(key))
+    if(raw == null) return null
+    return parseValue(raw)
+  }
+
   objectObservable(key) {
     let observable = this.objectObservables.get(key)
     if(observable) return observable
@@ -233,23 +462,16 @@ class Store {
     return observable
   }
 
-  rangeGet(range) {
-    return new Promise((resolve, reject) => {
-      let data = []
-      this.level.createReadStream({ ...range, keys: false, values: true })
-        .on('data', function (value) {
-          data.push(value)
-        })
-        .on('error', function (err) {
-          reject(err)
-        })
-        .on('close', function () {
-          reject('closed')
-        })
-        .on('end', function () {
-          resolve(data)
-        })
+  async rangeGet(range) {
+    if(!range) throw new Error("range not defined")
+    const data = []
+    await this.iterate(this.iteratorRange(range, { keys: true, values: true }), ({ key, value }) => {
+      const id = this.decodeKey(key)
+      const object = parseValue(value)
+      if(object && object.id == null) object.id = id
+      data.push(object)
     })
+    return data
   }
 
   rangeObservable(range) {
@@ -260,96 +482,153 @@ class Store {
   }
 
   async rangeDelete(range, options = {}) {
+    if(!range) throw new Error("range not defined")
     const keysOnly = options.keysOnly === true
-    const self = this
-    return new Promise((resolve, reject) => {
-      let count = 0, last
-      const streamOpts = keysOnly
-        ? { ...range, keys: true, values: false }
-        : { ...range, keys: false, values: true }
-      this.level.createReadStream(streamOpts)
-          .on('data', function(data) {
-            const id = keysOnly ? data : data.id
-            last = id
-            self.level.del(id)
-            count ++
-            const objectObservable = self.objectObservables.get(id)
-            if(objectObservable) objectObservable.set(null)
-            const rangeObservables = self.rangeObservablesTree.search([id, id])
-            for (const rangeObservable of rangeObservables) {
-              rangeObservable.deleteObject(keysOnly ? { id } : data)
-            }
-          })
-          .on('error', function(err) {
-            reject(err)
-          })
-          .on('close', function() {
-            reject('closed')
-          })
-          .on('end', function() {
-            resolve({ count, last })
-          })
+    const rows = []
+    await this.iterate(
+      this.iteratorRange(range, { keys: true, values: !keysOnly }),
+      ({ key, value }) => {
+        const id = this.decodeKey(key)
+        rows.push({
+          id,
+          encoded: this.encodeKey(id),
+          object: keysOnly ? { id } : parseValue(value)
+        })
+      }
+    )
+    await this.downBatch(rows.map(row => ({ type: 'del', key: row.encoded })))
+    for(const row of rows) {
+      const objectObservable = this.objectObservables.get(row.id)
+      if(objectObservable) objectObservable.set(null)
+      const rangeObservables = this.rangeObservablesTree.search([row.id, row.id])
+      for(const rangeObservable of rangeObservables) {
+        await rangeObservable.deleteObject(row.object || { id: row.id })
+      }
+    }
+    return {
+      count: rows.length,
+      last: rows.length ? rows[rows.length - 1].id : undefined
+    }
+  }
+
+  async countGet(range) {
+    if(!range) throw new Error("range not defined")
+    let count = 0
+    await this.iterate(this.iteratorRange(range, { keys: true, values: false }), () => {
+      count++
     })
+    return count
+  }
+
+  countObservable(range) {
+    let observable = this.countObservables.get(JSON.stringify(range))
+    if(observable) return observable
+    observable = new CountObservable(this, range)
+    return observable
+  }
+
+  async clear() {
+    await this.ready()
+    const opts = {}
+    if(this.prefix) {
+      opts.gte = this.prefix
+      if(this.prefixEnd) opts.lt = this.prefixEnd
+    }
+    await this.downClear(opts)
   }
 
   async put(object) {
     const id = object.id
+    if(typeof id != 'string') throw new Error(`ID is not string: ${JSON.stringify(id)}`)
+    if(!id) throw new Error("ID must not be empty string!")
     let lock
-    while(lock = this.locks.get(object.id)) await lock
-    let updateLock = (async ()=> {
-      let oldObject = await this.level.get(id).catch(err => {
-        if(err.name == 'NotFoundError') return null
-        throw err
-      })
-      if (!id) {
+    while(lock = this.locks.get(id)) await lock
+    const updateLock = (async () => {
+      try {
+        await this.ready()
+        const raw = await this.downGet(this.encodeKey(id))
+        const oldObject = raw == null ? null : parseValue(raw)
+        await this.downPut(this.encodeKey(id), JSON.stringify(object))
+        const objectObservable = this.objectObservables.get(id)
+        if(objectObservable) objectObservable.set(object, oldObject)
+        const rangeObservables = this.rangeObservablesTree.search([id, id])
+        for(const rangeObservable of rangeObservables) {
+          if(rangeObservable.rangeDescr[0] > id || rangeObservable.rangeDescr[1] < id) {
+            console.error("TREE LEAKING", "ID", id, "IS OUT OF", rangeObservable.rangeDescr)
+            continue
+          }
+          await rangeObservable.putObject(object, oldObject)
+        }
+        return oldObject
+      } finally {
         this.locks.delete(id)
-        throw new Error("id must not be empty")
       }
-      await this.level.put(id, object)
-      const objectObservable = this.objectObservables.get(id)
-      if (objectObservable) objectObservable.set(object, oldObject)
-      const rangeObservables = this.rangeObservablesTree.search([id, id])
-      for (const rangeObservable of rangeObservables) {
-        rangeObservable.putObject(object, oldObject)
-      }
-      this.locks.delete(id)
-      return oldObject
     })()
     this.locks.set(id, updateLock)
     return await updateLock
   }
 
   async delete(id) {
-    let deleteLock = (async ()=> {
-      let object = await this.level.get(id).catch(err => {
-        if(err.name == 'NotFoundError') return null
-        throw err
-      })
-      if(!object) {
+    let lock
+    while(lock = this.locks.get(id)) await lock
+    const deleteLock = (async () => {
+      try {
+        await this.ready()
+        const raw = await this.downGet(this.encodeKey(id))
+        const object = raw == null ? null : parseValue(raw)
+        if(!object) return null
+        await this.downDel(this.encodeKey(id))
+        const objectObservable = this.objectObservables.get(id)
+        if(objectObservable) objectObservable.set(null)
+        const rangeObservables = this.rangeObservablesTree.search([id, id])
+        for(const rangeObservable of rangeObservables) {
+          await rangeObservable.deleteObject(object)
+        }
+        return object
+      } finally {
         this.locks.delete(id)
-        return null
       }
-      await this.level.del(id)
-      const objectObservable = this.objectObservables.get(id)
-      if(objectObservable) objectObservable.set(null)
-      const rangeObservables = this.rangeObservablesTree.search([id, id])
-      for(const rangeObservable of rangeObservables) {
-        rangeObservable.deleteObject(object)
-      }
-      this.locks.delete(id)
-      return object
     })()
     this.locks.set(id, deleteLock)
-    const result = await deleteLock
-    return result
+    return await deleteLock
   }
 
   stat() {
-    return {
-      available: false,
-      entryCount: null,
-      usedBytes: null
-    }
+    return new Promise(async (resolve) => {
+      try {
+        await this.ready()
+        if(typeof this.down.approximateSize !== 'function') {
+          return resolve({
+            available: false,
+            entryCount: null,
+            usedBytes: null
+          })
+        }
+        const start = this.prefix || '\x00'
+        const end = this.prefixEnd || '\xFF'
+        this.down.approximateSize(start, end, (err, size) => {
+          if(err) {
+            resolve({
+              available: false,
+              entryCount: null,
+              usedBytes: null
+            })
+            return
+          }
+          resolve({
+            available: true,
+            entryCount: null,
+            usedBytes: size
+          })
+        })
+      } catch(e) {
+        resolve({
+          available: false,
+          entryCount: null,
+          usedBytes: null
+        })
+      }
+    })
   }
 }
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@live-change/db-store-level",
-  "version": "0.9.226",
+  "version": "0.9.228",
   "description": "Database with observable data for live queries",
   "main": "index.js",
   "scripts": {
-    "test": "NODE_ENV=test tape tests/*"
+    "test": "NODE_ENV=test tape tests/*observable.js tests/store-*.js tests/prefix-isolation.js"
   },
   "repository": {
     "type": "git",
@@ -22,17 +22,14 @@
   "type": "module",
   "homepage": "https://github.com/live-change/live-change-stack",
   "devDependencies": {
-    "encoding-down": "^7.1.0",
     "leveldown": "^6.1.0",
-    "levelup": "^5.1.1",
-    "memdown": "^6.1.1",
+    "p-queue": "^8.1.1",
     "rimraf": "^5.0.5",
-    "subleveldown": "^6.0.1",
     "tape": "^5.7.4"
   },
   "dependencies": {
-    "@live-change/dao": "^0.9.226",
-    "@live-change/flatten-interval-tree": "^0.9.226"
+    "@live-change/dao": "^0.9.228",
+    "@live-change/flatten-interval-tree": "^0.9.228"
   },
-  "gitHead": "8b9b3bae11b5347f01de0cd09d5d8535a0d251cf"
+  "gitHead": "fd47aa55100c5a25c3f52c899a79a663421037ff"
 }

package/tests/count-observable.js

@@ -0,0 +1,138 @@
+import test from 'tape'
+import Store from '../lib/Store.js'
+import { openTestDown, closeTestDown } from './utils.js'
+import PQueue from 'p-queue'
+
+const testQueue = new PQueue({ concurrency: 1 })
+function queued(fn) {
+  return async t => {
+    return await testQueue.add(() => fn(t))
+  }
+}
+
+const dbPath = `./test.co.db`
+
+test("store count observable", t => {
+  t.plan(5)
+
+  let down
+  let store
+
+  t.test("create store", async t => {
+    t.plan(1)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
+    t.pass('store created')
+  })
+
+  t.test("put objects", async t => {
+    t.plan(1)
+    await store.put({ v: 1, id: 'a' })
+    await store.put({ v: 3, id: 'c' })
+    t.pass('objects written')
+  })
+
+  let nextValueResolve
+  let gotNextValue
+  const getNextValue = () => {
+    if(gotNextValue) {
+      gotNextValue = false
+      return countObservable.value
+    }
+    return new Promise((resolve, reject) => nextValueResolve = resolve)
+  }
+  let countObservable
+  const countObserver = (signal, value, ...rest) => {
+    console.log("SIGNAL", signal, value, ...rest)
+    gotNextValue = true
+    if(nextValueResolve) nextValueResolve(countObservable.value)
+  }
+
+  t.test("observe count [a,z]", async t => {
+    t.plan(6)
+    countObservable = store.countObservable({ gte: 'a', lte: 'z' })
+    countObservable.observe(countObserver)
+    let values = await getNextValue()
+    t.deepEqual(values, 2, 'count value' )
+
+    t.test("remove object 'a' from observed count", queued(async t => {
+      t.plan(1)
+      await store.delete('a')
+      let values = await getNextValue()
+      t.deepEqual(values, 1, 'count value' )
+    }))
+
+    t.test("add object 'a' to observed count", queued(async t => {
+      t.plan(1)
+      await store.put({ id: 'a', v: 4 })
+      let values = await getNextValue()
+      t.deepEqual(values, 2, 'count value' )
+    }))
+
+    t.test("add object 'b' to observed count", queued(async t => {
+      t.plan(1)
+      await store.put({ id: 'b', v: 5 })
+      let values = await getNextValue()
+      t.deepEqual(values, 3, 'count value' )
+    }))
+
+    t.test("add object 'd' to observed count", queued(async t => {
+      t.plan(1)
+      await store.put({ id: 'd', v: 6 })
+      let values = await getNextValue()
+      t.deepEqual(values, 4, 'count value' )
+    }))
+
+    t.test("unobserve count", queued(async t => {
+      t.plan(1)
+      countObservable.unobserve(countObserver)
+      t.pass('unobserved')
+    }))
+  })
+
+  t.test("observe count (a,d)", async t => {
+    t.plan(6)
+    countObservable = store.countObservable({ gt: 'a', lt: 'd' })
+    countObservable.observe(countObserver)
+    let values = await getNextValue()
+    t.deepEqual(values, 2, 'count value' )
+
+    t.test("remove object 'd' outside observed count", queued(async t => {
+      t.plan(1)
+      await store.delete('d')
+      t.pass('deleted')
+    }))
+
+    t.test("remove object 'a' outside observed count", queued(async t => {
+      t.plan(1)
+      await store.delete('a')
+      t.pass('deleted')
+    }))
+
+    t.test("add object 'ab' to observed count", queued(async t => {
+      t.plan(1)
+      await store.put({ id: 'ab', v: 7 })
+      let values = await getNextValue()
+      t.deepEqual(values, 3, 'count value' )
+    }))
+
+    t.test("remove object 'ab' from observed count", queued(async t => {
+      t.plan(1)
+      await store.delete('ab')
+      let values = await getNextValue()
+      t.deepEqual(values, 2, 'count value' )
+    }))
+
+    t.test("unobserve count", queued(async t => {
+      t.plan(1)
+      countObservable.unobserve(countObserver)
+      t.pass('unobserved')
+    }))
+  })
+
+  t.test("close and remove database", queued(async t => {
+    t.plan(1)
+    await closeTestDown(down, dbPath)
+    t.pass('removed')
+  }))
+})

package/tests/limited-range-observable.js

@@ -1,15 +1,9 @@
 import test from 'tape'
-import levelup from 'levelup'
-import leveldown from 'leveldown'
-import encoding from 'encoding-down'
-import { rimraf } from 'rimraf'
 import PQueue from 'p-queue'
-
 import Store from '../lib/Store.js'
+import { openTestDown, closeTestDown } from './utils.js'
 
 const dbPath = `./test.lro.db`
-rimraf.sync(dbPath)
-const level = levelup(encoding(leveldown(dbPath), { keyEncoding: 'ascii', valueEncoding: 'json' }))
 
 const testQueue = new PQueue({ concurrency: 1 })
 function queued(fn) {
@@ -21,11 +15,13 @@ function queued(fn) {
 test("store range observable", t => {
   t.plan(5)
 
+  let down
   let store
 
   t.test("create store", async t => {
     t.plan(1)
-    store = new Store(level)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
     t.pass('store created')
   })
 
@@ -71,7 +67,6 @@ test("store range observable", t => {
       console.error("TEST STARTED")
       await store.delete('b_3')
       objects.splice(3, 1)
-      await getNextValue() // one shorter
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
     }))
@@ -106,7 +101,6 @@ test("store range observable", t => {
       t.plan(1)
       await store.delete('b_32')
       objects.splice(4, 1)
-      await getNextValue()
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
     }))
@@ -157,7 +151,6 @@ test("store range observable", t => {
       t.plan(1)
       await store.delete('b_12')
       objects.splice(2, 1)
-      await getNextValue()
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(1,4) , 'range value' )
     }))
@@ -169,10 +162,9 @@ test("store range observable", t => {
     }))
   })
 
-  t.test("close and remove database", async t => {
+  t.test("close and remove database", queued(async t => {
     t.plan(1)
-    await level.close()
-    await rimraf(dbPath)
+    await closeTestDown(down, dbPath)
     t.pass('removed')
-  })
+  }))
 })

package/tests/limited-reverse-range-observable.js

@@ -1,16 +1,10 @@
 import test from 'tape'
-import levelup from 'levelup'
-import leveldown from 'leveldown'
-import encoding from 'encoding-down'
-import { rimraf } from 'rimraf'
-
 import Store from '../lib/Store.js'
+import { openTestDown, closeTestDown } from './utils.js'
+import PQueue from 'p-queue'
 
 const dbPath = `./test.lrro.db`
-rimraf.sync(dbPath)
-const level = levelup(encoding(leveldown(dbPath), { keyEncoding: 'ascii', valueEncoding: 'json' }))
 
-import PQueue from 'p-queue'
 const testQueue = new PQueue({ concurrency: 1 })
 function queued(fn) {
   return async t => {
@@ -21,11 +15,13 @@ function queued(fn) {
 test("store range observable", t => {
   t.plan(5)
 
+  let down
   let store
 
   t.test("create store", async t => {
     t.plan(1)
-    store = new Store(level)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
     t.pass('store created')
   })
 
@@ -70,7 +66,6 @@ test("store range observable", t => {
       t.plan(1)
       await store.delete('b_6')
       objects.splice(3, 1)
-      await getNextValue() // one shorter
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
     }))
@@ -105,7 +100,6 @@ test("store range observable", t => {
       t.plan(1)
       await store.delete('b_58')
       objects.splice(4, 1)
-      await getNextValue()
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
     }))
@@ -156,7 +150,6 @@ test("store range observable", t => {
       t.plan(1)
       await store.delete('b_48')
       objects.splice(6, 1)
-      await getNextValue()
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(6,9) , 'range value' )
     }))
@@ -168,10 +161,9 @@ test("store range observable", t => {
     }))
   })
 
-  t.test("close and remove database", async t => {
+  t.test("close and remove database", queued(async t => {
     t.plan(1)
-    await level.close()
-    await rimraf(dbPath)
+    await closeTestDown(down, dbPath)
     t.pass('removed')
-  })
+  }))
 })

package/tests/object-observable.js

@@ -1,23 +1,27 @@
 import test from 'tape'
-import levelup from 'levelup'
-import leveldown from 'leveldown'
-import encoding from 'encoding-down'
-import { rimraf } from 'rimraf'
-
 import Store from '../lib/Store.js'
+import { openTestDown, closeTestDown } from './utils.js'
+import PQueue from 'p-queue'
+
+const testQueue = new PQueue({ concurrency: 1 })
+function queued(fn) {
+  return async t => {
+    return await testQueue.add(() => fn(t))
+  }
+}
 
 const dbPath = `./test.oo.db`
-rimraf.sync(dbPath)
-const level = levelup(encoding(leveldown(dbPath), { keyEncoding: 'ascii', valueEncoding: 'json' }))
 
 test("store object observable", t => {
   t.plan(3)
 
+  let down
   let store
 
   t.test("create store", async t => {
     t.plan(1)
-    store = new Store(level)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
     t.pass('store created')
   })
 
@@ -45,25 +49,24 @@ test("store object observable", t => {
     let value = await getNextValue()
     t.deepEqual(value, null, 'found null')
 
-    t.test("add object A", async t => {
+    t.test("add object A", queued(async t => {
       t.plan(1)
       await store.put({ id: 'A', a: 1 })
       let value = await getNextValue()
       t.deepEqual(value, { id: 'A', a: 1 } , 'found object' )
-    })
+    }))
 
-    t.test("delete object A", async t => {
+    t.test("delete object A", queued(async t => {
       t.plan(1)
       await store.delete('A')
       let value = await getNextValue()
       t.deepEqual(value, null , 'found null' )
-    })
+    }))
   })
 
-  t.test("close and remove database", async t => {
+  t.test("close and remove database", queued(async t => {
     t.plan(1)
-    await level.close()
-    await rimraf(dbPath)
+    await closeTestDown(down, dbPath)
     t.pass('removed')
-  })
-})
+  }))
+})

package/tests/prefix-isolation.js

@@ -0,0 +1,50 @@
+import test from 'tape'
+import Store from '../lib/Store.js'
+import { openTestDown, closeTestDown } from './utils.js'
+import PQueue from 'p-queue'
+
+const testQueue = new PQueue({ concurrency: 1 })
+function queued(fn) {
+  return async t => {
+    return await testQueue.add(() => fn(t))
+  }
+}
+
+const dbPath = `./test.px.db`
+
+test("store prefix isolation and clear", t => {
+  t.plan(3)
+
+  let down
+  let storeA
+  let storeB
+
+  t.test("create stores", queued(async t => {
+    t.plan(1)
+    down = await openTestDown(dbPath)
+    storeA = new Store(down, { prefix: 'a\x00' })
+    storeB = new Store(down, { prefix: 'b\x00' })
+    t.pass('stores created')
+  }))
+
+  t.test("prefix isolation", queued(async t => {
+    t.plan(8)
+    await storeA.put({ id: 'k', v: 1 })
+    await storeB.put({ id: 'k', v: 2 })
+    t.deepEqual(await storeA.objectGet('k'), { id: 'k', v: 1 }, 'store A own value')
+    t.deepEqual(await storeB.objectGet('k'), { id: 'k', v: 2 }, 'store B own value')
+    t.deepEqual(await storeA.rangeGet({}), [{ id: 'k', v: 1 }], 'store A range')
+    t.deepEqual(await storeB.rangeGet({}), [{ id: 'k', v: 2 }], 'store B range')
+    t.equal(await storeA.countGet({}), 1, 'store A count')
+    t.equal(await storeB.countGet({}), 1, 'store B count')
+    await storeA.clear()
+    t.equal(await storeA.objectGet('k'), null, 'store A cleared')
+    t.deepEqual(await storeB.objectGet('k'), { id: 'k', v: 2 }, 'store B intact after A clear')
+  }))
+
+  t.test("close and remove database", queued(async t => {
+    t.plan(1)
+    await closeTestDown(down, dbPath)
+    t.pass('removed')
+  }))
+})

package/tests/range-observable.js

@@ -1,12 +1,8 @@
 import test from 'tape'
-import levelup from 'levelup'
-import leveldown from 'leveldown'
-import encoding from 'encoding-down'
-import { rimraf } from 'rimraf'
-
 import Store from '../lib/Store.js'
-
+import { openTestDown, closeTestDown } from './utils.js'
 import PQueue from 'p-queue'
+
 const testQueue = new PQueue({ concurrency: 1 })
 function queued(fn) {
   return async t => {
@@ -15,17 +11,17 @@ function queued(fn) {
 }
 
 const dbPath = `./test.ro.db`
-rimraf.sync(dbPath)
-const level = levelup(encoding(leveldown(dbPath), { keyEncoding: 'ascii', valueEncoding: 'json' }))
 
 test("store range observable", t => {
   t.plan(5)
 
+  let down
   let store
 
   t.test("create store", async t => {
     t.plan(1)
-    store = new Store(level)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
     t.pass('store created')
   })
 
@@ -136,10 +132,9 @@ test("store range observable", t => {
 
   })
 
-  t.test("close and remove database", async t => {
+  t.test("close and remove database", queued(async t => {
     t.plan(1)
-    await level.close()
-    await rimraf(dbPath)
+    await closeTestDown(down, dbPath)
     t.pass('removed')
-  })
+  }))
 })

package/tests/reverse-range-observable.js

@@ -1,12 +1,8 @@
 import test from 'tape'
-import levelup from 'levelup'
-import leveldown from 'leveldown'
-import encoding from 'encoding-down'
-import { rimraf } from 'rimraf'
-
 import Store from '../lib/Store.js'
-
+import { openTestDown, closeTestDown } from './utils.js'
 import PQueue from 'p-queue'
+
 const testQueue = new PQueue({ concurrency: 1 })
 function queued(fn) {
   return async t => {
@@ -15,17 +11,17 @@ function queued(fn) {
 }
 
 const dbPath = `./test.rro.db`
-rimraf.sync(dbPath)
-const level = levelup(encoding(leveldown(dbPath), { keyEncoding: 'ascii', valueEncoding: 'json' }))
 
 test("store range observable", t => {
   t.plan(5)
 
+  let down
   let store
 
   t.test("create store", async t => {
     t.plan(1)
-    store = new Store(level)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
     t.pass('store created')
   })
 
@@ -135,10 +131,9 @@ test("store range observable", t => {
     }))
   })
 
-  t.test("close and remove database", async t => {
+  t.test("close and remove database", queued(async t => {
     t.plan(1)
-    await level.close()
-    await rimraf(dbPath)
+    await closeTestDown(down, dbPath)
     t.pass('removed')
-  })
+  }))
 })

package/tests/store-non-reactive.js

@@ -1,12 +1,8 @@
 import test from 'tape'
-import levelup from 'levelup'
-import leveldown from 'leveldown'
-import encoding from 'encoding-down'
-import { rimraf } from 'rimraf'
-
 import Store from '../lib/Store.js'
-
+import { openTestDown, closeTestDown } from './utils.js'
 import PQueue from 'p-queue'
+
 const testQueue = new PQueue({ concurrency: 1 })
 function queued(fn) {
   return async t => {
@@ -15,22 +11,22 @@ function queued(fn) {
 }
 
 const dbPath = `./test.nr.db`
-rimraf.sync(dbPath)
-const level = levelup(encoding(leveldown(dbPath), { keyEncoding: 'ascii', valueEncoding: 'json' }))
 
 test("store non-reactive properties", t => {
   t.plan(3)
 
+  let down
   let store
 
   t.test("create store", async t => {
     t.plan(1)
-    store = new Store(level)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
     t.pass('store created')
   })
 
   t.test("non reactive operations", async t => {
-    t.plan(15)
+    t.plan(20)
 
     t.test("put value", queued(async t => {
       t.plan(1)
@@ -57,24 +53,48 @@ test("store non-reactive properties", t => {
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 2, id: 'b' }, { v: 3, id: 'c' } ], 'range read' )
     }))
 
+    t.test("count range [a,c]", queued(async t => {
+      t.plan(1)
+      let values = await store.countGet({ gte: 'a', lte: 'c' })
+      t.deepEqual(values, 3, 'range count' )
+    }))
+
     t.test("get reverse range [c,a]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c', reverse: true })
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 2, id: 'b' },  { v: 1, id: 'a' } ], 'range read' )
     }))
 
+    t.test("count reverse range [a,c]", queued(async t => {
+      t.plan(1)
+      let values = await store.countGet({ gte: 'a', lte: 'c', reverse: true })
+      t.deepEqual(values, 3, 'range count' )
+    }))
+
     t.test("get range [a,c] with limit 2", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c', limit: 2 })
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 2, id: 'b' } ], 'range read' )
     }))
 
+    t.test("count range [a,c] with limit 2", queued(async t => {
+      t.plan(1)
+      let values = await store.countGet({ gte: 'a', lte: 'c', limit: 2 })
+      t.deepEqual(values, 2, 'range read' )
+    }))
+
     t.test("get reverse range [c,a] with limit 2", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gte: 'a', lte: 'c', reverse: true, limit: 2 })
       t.deepEqual(values, [ { v: 3, id: 'c' }, { v: 2, id: 'b' } ], 'range read' )
     }))
 
+    t.test("get reverse count [c,a] with limit 2", queued(async t => {
+      t.plan(1)
+      let values = await store.countGet({ gte: 'a', lte: 'c', reverse: true, limit: 2 })
+      t.deepEqual(values, 2, 'range read' )
+    }))
+
     t.test("get range (a,c]", queued(async t => {
       t.plan(1)
       let values = await store.rangeGet({ gt: 'a', lte: 'c' })
@@ -122,12 +142,21 @@ test("store non-reactive properties", t => {
       let values = await store.rangeGet({ gte: 'a', lte: 'c' })
       t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 3, id: 'c' } ], 'range read' )
     }))
+
+    t.test("rangeDelete keysOnly", queued(async t => {
+      t.plan(3)
+      await store.put({ id: 'd', v: 4 })
+      await store.put({ id: 'e', v: 5 })
+      const result = await store.rangeDelete({ gte: 'd', lt: 'f' }, { keysOnly: true })
+      t.equal(result.count, 2, 'deleted 2 keys without reading values')
+      t.equal(await store.objectGet('d'), null, 'd gone')
+      t.equal(await store.objectGet('e'), null, 'e gone')
+    }))
   })
 
-  t.test("close and remove database", async t => {
+  t.test("close and remove database", queued(async t => {
     t.plan(1)
-    await level.close()
-    await rimraf(dbPath)
+    await closeTestDown(down, dbPath)
     t.pass('removed')
-  })
+  }))
 })

package/tests/store-stat.js

@@ -0,0 +1,33 @@
+import test from 'tape'
+import Store from '../lib/Store.js'
+import { openTestDown, closeTestDown } from './utils.js'
+
+const dbPath = `./test.st.db`
+
+test("store stat", t => {
+  t.plan(3)
+
+  let down
+  let store
+
+  t.test("create store", async t => {
+    t.plan(1)
+    down = await openTestDown(dbPath)
+    store = new Store(down, { prefix: 't\x00' })
+    t.pass('store created')
+  })
+
+  t.test("approximate size after put", async t => {
+    t.plan(2)
+    await store.put({ id: 'a', v: 1 })
+    const s = await store.stat()
+    t.equal(s.available, true, 'stat available')
+    t.equal(typeof s.usedBytes, 'number', 'usedBytes is a number')
+  })
+
+  t.test("close and remove database", async t => {
+    t.plan(1)
+    await closeTestDown(down, dbPath)
+    t.pass('removed')
+  })
+})

package/tests/utils.js

@@ -0,0 +1,21 @@
+import { createRequire } from 'module'
+import { rimraf } from 'rimraf'
+
+const require = createRequire(import.meta.url)
+const leveldown = require('leveldown')
+
+export async function openTestDown(dbPath) {
+  await rimraf(dbPath)
+  const down = leveldown(dbPath)
+  await new Promise((resolve, reject) => {
+    down.open({ createIfMissing: true }, err => err ? reject(err) : resolve())
+  })
+  return down
+}
+
+export async function closeTestDown(down, dbPath) {
+  await new Promise((resolve, reject) => {
+    down.close(err => err ? reject(err) : resolve())
+  })
+  await rimraf(dbPath)
+}