@live-change/db-store-level 0.6.22 → 0.7.0

package/index.js

@@ -1 +1,2 @@
-module.exports = require('./lib/Store.js')
+import Store from './lib/Store.js'
+export default Store

package/lib/Store.js

@@ -1,5 +1,6 @@
-const IntervalTree = require('@live-change/interval-tree').default
-const ReactiveDao = require("@live-change/dao")
+import IntervalTreeLib from '@live-change/interval-tree'
+const IntervalTree = IntervalTreeLib.default
+import ReactiveDao from "@live-change/dao"
 
 class ObjectObservable extends ReactiveDao.ObservableValue {
   constructor(store, key) {
@@ -337,4 +338,4 @@ class Store {
   }
 }
 
-module.exports = Store
+export default Store

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/db-store-level",
-  "version": "0.6.22",
+  "version": "0.7.0",
   "description": "Database with observable data for live queries",
   "main": "index.js",
   "scripts": {
@@ -19,20 +19,21 @@
   "bugs": {
     "url": "https://github.com/live-change/live-change-db/issues"
   },
+  "type": "module",
   "homepage": "https://github.com/live-change/live-change-db",
   "devDependencies": {
     "encoding-down": "^7.1.0",
     "leveldown": "^6.1.0",
     "levelup": "^5.1.1",
     "memdown": "^6.1.1",
-    "rimraf": "^3.0.2",
+    "rimraf": "^5.0.5",
     "rocksdb": "^5.1.1",
     "subleveldown": "^6.0.1",
-    "tape": "^5.3.2"
+    "tape": "^5.7.4"
   },
   "dependencies": {
-    "@live-change/dao": "0.5.21",
+    "@live-change/dao": "0.5.22",
     "@live-change/interval-tree": "^1.0.12"
   },
-  "gitHead": "cef1aace649e46c20af0ff07b30ca2508ac3714d"
+  "gitHead": "b372725d436e29f7cc66b811533009c9ea5330a1"
 }

package/tests/limited-range-observable.js

@@ -1,15 +1,23 @@
-const test = require('tape')
-const levelup = require('levelup')
-const leveldown = require('leveldown')
-const encoding = require('encoding-down')
-const rimraf = require("rimraf")
+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'
 
-const Store = require('../lib/Store.js')
+import Store from '../lib/Store.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) {
+  return async t => {
+    return await testQueue.add(() => fn(t))
+  }
+}
+
 test("store range observable", t => {
   t.plan(5)
 
@@ -58,55 +66,56 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, objects.slice(0, 5), 'range value' )
 
-    t.test("remove object 'b_3' from observed range", async t => {
+    t.test("remove object 'b_3' from observed range", queued(async t => {
       t.plan(1)
+      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' )
-    })
+    }))
 
-    t.test("add object 'b_3' to observed range", async t => {
+    t.test("add object 'b_3' to observed range", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_3', v: 10 }
       await store.put(obj)
       objects.splice(3, 0, obj)
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
-    })
+    }))
 
-    t.test("add object 'b_32' to observed range", async t => {
+    t.test("add object 'b_32' to observed range", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_32', v: 11 }
       await store.put(obj)
       objects.splice(4, 0, obj)
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
-    })
+    }))
 
-    t.test("add object 'b_35' outside observed range limits", async t => {
+    t.test("add object 'b_35' outside observed range limits", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_35', v: 11 }
       await store.put(obj)
       objects.splice(5, 0, obj)
       t.pass('added')
-    })
+    }))
 
-    t.test("delete object 'b_32' so b_35 will enter into range limits", async t => {
+    t.test("delete object 'b_32' so b_35 will enter into range limits", queued(async 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' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
   })
 
   t.test("observe range (b_0,b_5)", async t => {
@@ -117,55 +126,53 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, objects.slice(1,4) , 'range value' )
 
-    t.test("remove object 'b_0' outside observed range", async t => {
+    t.test("remove object 'b_0' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('b_0')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("remove object 'b_5' outside observed range", async t => {
+    t.test("remove object 'b_5' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('b_5')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("remove object 'b_4' outside observed range limits", async t => {
+    t.test("remove object 'b_4' outside observed range limits", queued(async t => {
       t.plan(1)
       await store.delete('b_4')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("add object 'b_12' to observed range", async t => {
+    t.test("add object 'b_12' to observed range", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_12', v: 7 }
       await store.put(obj)
       objects.splice(2, 0, obj)
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(1,4), 'range value' )
-    })
+    }))
 
-    t.test("remove object 'b_12' from observed range", async t => {
+    t.test("remove object 'b_12' from observed range", queued(async 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' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
   })
 
   t.test("close and remove database", async t => {
     t.plan(1)
     await level.close()
-    rimraf(dbPath, (err) => {
-      if(err) return t.fail(err)
-      t.pass('removed')
-    })
+    await rimraf(dbPath)
+    t.pass('removed')
   })
 })

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

@@ -1,15 +1,23 @@
-const test = require('tape')
-const levelup = require('levelup')
-const leveldown = require('leveldown')
-const encoding = require('encoding-down')
-const rimraf = require("rimraf")
+import test from 'tape'
+import levelup from 'levelup'
+import leveldown from 'leveldown'
+import encoding from 'encoding-down'
+import { rimraf } from 'rimraf'
 
-const Store = require('../lib/Store.js')
+import Store from '../lib/Store.js'
 
 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 => {
+    return await testQueue.add(() => fn(t))
+  }
+}
+
 test("store range observable", t => {
   t.plan(5)
 
@@ -58,55 +66,55 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, objects.slice(0, 5), 'range value' )
 
-    t.test("remove object 'b_6' from observed range", async t => {
+    t.test("remove object 'b_6' from observed range", queued(async 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' )
-    })
+    }))
 
-    t.test("add object 'b_6' to observed range", async t => {
+    t.test("add object 'b_6' to observed range", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_6', v: 10 }
       await store.put(obj)
       objects.splice(3, 0, obj)
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
-    })
+    }))
 
-    t.test("add object 'b_58' to observed range", async t => {
+    t.test("add object 'b_58' to observed range", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_58', v: 11 }
       await store.put(obj)
       objects.splice(4, 0, obj)
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(0, 5), 'range value' )
-    })
+    }))
 
-    t.test("add object 'b_52' outside observed range limits", async t => {
+    t.test("add object 'b_52' outside observed range limits", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_52', v: 11 }
       await store.put(obj)
       objects.splice(5, 0, obj)
       t.pass('added')
-    })
+    }))
 
-    t.test("delete object 'b_58' so b_52 will enter into range limits", async t => {
+    t.test("delete object 'b_58' so b_52 will enter into range limits", queued(async 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' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
   })
 
   t.test("observe reverse range (b_5,b_0)", async t => {
@@ -117,55 +125,53 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, objects.slice(6,9) , 'range value' )
 
-    t.test("remove object 'b_5' outside observed range", async t => {
+    t.test("remove object 'b_5' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('b_5')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("remove object 'b_0' outside observed range", async t => {
+    t.test("remove object 'b_0' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('b_0')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("remove object 'b_1' outside observed range limits", async t => {
+    t.test("remove object 'b_1' outside observed range limits", queued(async t => {
       t.plan(1)
       await store.delete('b_1')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("add object 'b_48' to observed range", async t => {
+    t.test("add object 'b_48' to observed range", queued(async t => {
       t.plan(1)
       const obj = { id: 'b_48', v: 7 }
       await store.put(obj)
       objects.splice(6, 0, obj)
       let values = await getNextValue()
       t.deepEqual(values, objects.slice(6,9), 'range value' )
-    })
+    }))
 
-    t.test("remove object 'b_48' from observed range", async t => {
+    t.test("remove object 'b_48' from observed range", queued(async 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' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
   })
 
   t.test("close and remove database", async t => {
     t.plan(1)
     await level.close()
-    rimraf(dbPath, (err) => {
-      if(err) return t.fail(err)
-      t.pass('removed')
-    })
+    await rimraf(dbPath)
+    t.pass('removed')
   })
 })

package/tests/object-observable.js

@@ -1,10 +1,10 @@
-const test = require('tape')
-const levelup = require('levelup')
-const leveldown = require('leveldown')
-const encoding = require('encoding-down')
-const rimraf = require("rimraf")
+import test from 'tape'
+import levelup from 'levelup'
+import leveldown from 'leveldown'
+import encoding from 'encoding-down'
+import { rimraf } from 'rimraf'
 
-const Store = require('../lib/Store.js')
+import Store from '../lib/Store.js'
 
 const dbPath = `./test.oo.db`
 rimraf.sync(dbPath)
@@ -63,9 +63,7 @@ test("store object observable", t => {
   t.test("close and remove database", async t => {
     t.plan(1)
     await level.close()
-    rimraf(dbPath, (err) => {
-      if(err) return t.fail(err)
-      t.pass('removed')
-    })
+    await rimraf(dbPath)
+    t.pass('removed')
   })
 })

package/tests/range-observable.js

@@ -1,10 +1,18 @@
-const test = require('tape')
-const levelup = require('levelup')
-const leveldown = require('leveldown')
-const encoding = require('encoding-down')
-const rimraf = require("rimraf")
-
-const Store = require('../lib/Store.js')
+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 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.ro.db`
 rimraf.sync(dbPath)
@@ -51,39 +59,40 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, [ { v: 1, id: 'a' }, { v: 3, id: 'c' } ], 'range value' )
 
-    t.test("remove object 'a' from observed range", async t => {
+    t.test("remove object 'a' from observed range", queued(async t => {
       t.plan(1)
       await store.delete('a')
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 3, id: 'c' } ], 'range value' )
-    })
+    }))
 
-    t.test("add object 'a' to observed range", async t => {
+    t.test("add object 'a' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'a', v: 4 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 4, id: 'a' }, { v: 3, id: 'c' } ], 'range value' )
-    })
+    }))
 
-    t.test("add object 'b' to observed range", async t => {
+    t.test("add object 'b' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'b', v: 5 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 4, id: 'a' }, { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
-    })
+    }))
 
-    t.test("add object 'd' to observed range", async t => {
+    t.test("add object 'd' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'd', v: 6 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 4, id: 'a' }, { v: 5, id: 'b' }, { v: 3, id: 'c' }, { v: 6, id: 'd' } ], 'range value' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
+
   })
 
   t.test("observe range (a,d)", async t => {
@@ -93,45 +102,44 @@ test("store range observable", t => {
     let values = await getNextValue()
     t.deepEqual(values, [ { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
 
-    t.test("remove object 'd' outside observed range", async t => {
+    t.test("remove object 'd' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('d')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("remove object 'a' outside observed range", async t => {
+    t.test("remove object 'a' outside observed range", queued(async t => {
       t.plan(1)
       await store.delete('a')
       t.pass('deleted')
-    })
+    }))
 
-    t.test("add object 'ab' to observed range", async t => {
+    t.test("add object 'ab' to observed range", queued(async t => {
       t.plan(1)
       await store.put({ id: 'ab', v: 7 })
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 7, id: 'ab' }, { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
-    })
+    }))
 
-    t.test("remove object 'ab' from observed range", async t => {
+    t.test("remove object 'ab' from observed range", queued(async t => {
       t.plan(1)
       await store.delete('ab')
       let values = await getNextValue()
       t.deepEqual(values, [ { v: 5, id: 'b' }, { v: 3, id: 'c' } ], 'range value' )
-    })
+    }))
 
-    t.test("unobserve range", async t => {
+    t.test("unobserve range", queued(async t => {
       t.plan(1)
       rangeObservable.unobserve(rangeObserver)
       t.pass('unobserved')
-    })
+    }))
+
   })
 
   t.test("close and remove database", async t => {
     t.plan(1)
     await level.close()
-    rimraf(dbPath, (err) => {
-      if(err) return t.fail(err)
-      t.pass('removed')
-    })
+    await rimraf(dbPath)
+    t.pass('removed')
   })
 })