@live-change/db-store-indexeddb 0.6.1 → 0.6.3

package/lib/Store.js

@@ -1,7 +1,7 @@
 const IntervalTree = require('@live-change/interval-tree').default
 const ReactiveDao = require("@live-change/dao")
 const { BroadcastChannel, createLeaderElection } = require('broadcast-channel')
-const idb = require('idb')
+
 
 
 class ObjectObservable extends ReactiveDao.ObservableValue {
@@ -221,13 +221,119 @@ 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.rangeObservables.set(this.rangeKey, this)
+    const treeInsert = this.rangeDescr
+    this.store.rangeObservablesTree.insert(treeInsert, 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) {
+    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.rangeObservables.delete(this.rangeKey)
+    let removed = this.store.rangeObservablesTree.remove(this.rangeDescr, this)
+  }
+
+  respawn() {
+    const existingObservable = this.store.rangeObservables.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()
+  }
+}
+
+async function handleRequest(request, onUpgrade = ()=>{}) {
+  return new Promise((resolve, reject) => {
+    request.onerror = (event) => {
+      reject(request.error)
+    }
+    request.onsuccess = (event) => {
+      resolve(request.result)
+    }
+    request.onupgradeneeded = onUpgrade
+  })
+}
+
 class Store {
-  constructor(dbName, storeName) {
+  constructor(dbName, storeName, options = {}) {
     if(!dbName) throw new Error("dbName argument is required")
     if(!storeName) throw new Error("storeName argument is required")
 
     this.dbName = dbName
     this.storeName = storeName
+    this.idbName = dbName + '.' + storeName
+
+    if(options.noSerialization) {
+      this.serialization = {
+        stringify: x => x,
+        parse: x => x
+      }
+    } else {
+      const serialization = options.serialization ?? JSON
+      this.serialization = {
+        stringify: x => x ? ({ id: x.id, data: serialization.stringify(x) }) : null,
+        parse: x => x?.data ? serialization.parse(x.data) : null
+      }
+    }
 
     this.finished = false
 
@@ -235,30 +341,28 @@ class Store {
     this.dbPromise = null
     this.channel = null
 
+    this.openPromise = null
+
     this.objectObservables = new Map()
     this.rangeObservables = new Map()
+    this.countObservables = new Map()
     this.rangeObservablesTree = new IntervalTree()
   }
 
   async openDb() {
-    this.dbPromise = idb.openDB(`lc-db-${this.dbName}-${this.storeName}`, 1, {
-      upgrade: (db) => {
-        const store = db.createObjectStore(this.storeName, { keyPath: 'id' })
-      },
-      terminated: async () => {
-        console.log("IndexedDB terminated!")
-        if(this.finished) return
-        for(const [key, value] of this.objectObservables) value.dispose()
-        for(const [key, value] of this.rangeObservables) value.dispose()
-        await this.openDb()
-        for(const [key, value] of this.objectObservables) value.respawn()
-        for(const [key, value] of this.rangeObservables) value.respawn()
-      }
+    //console.log("Opening db", this.dbName, this.storeName)
+    const openRequest = globalThis.indexedDB.open(this.idbName, 1)
+    globalThis.lastOpenRequest = openRequest
+    this.dbPromise = handleRequest(openRequest, (event) => {
+      //console.error("Upgrading db", this.dbName, this.storeName)
+      const db = event.target.result
+      const store = db.createObjectStore(this.storeName, { keyPath: 'id' })
     })
     this.db = await this.dbPromise
+    //console.log("Opened db", this.dbName, this.storeName)
   }
   async openChannel() {
-    this.channel = new BroadcastChannel('lc-db-channel' + this.dbName, {
+    this.channel = new BroadcastChannel('lc-db-channel' + this.dbName + '-' + this.storeName, {
       idb: {
         onclose: () => {
           if(this.finished) return
@@ -278,16 +382,22 @@ class Store {
     await this.channel.close()
     ;(await this.dbPromise).close()
   }
+  async ensureOpen() {
+    if(!this.openPromise) this.openPromise = this.open()
+    await this.openPromise
+  }
 
   async deleteDb() {
+    ;(await this.dbPromise).deleteObjectStore(this.storeName)
     if(!this.finished) await this.close()
-    await idb.deleteDB('lc-db-' + this.dbName)
   }
 
   async handleChannelMessage(message) {
     switch(message.type) {
       case 'put' : {
-        const { object, oldObject } = message
+        const { object: objectJson, oldObjectJson } = message
+        const object = this.serialization.parse(objectJson)
+        const oldObject = this.serialization.parse(oldObjectJson)
         const id = object?.id || oldObject?.id
         if(typeof id != 'string') throw new Error(`ID is not string: ${JSON.stringify(id)}`)
         const objectObservable = this.objectObservables.get(id)
@@ -298,7 +408,8 @@ class Store {
         }
       } break
       case 'delete' : {
-        const { object } = message
+        const { object: objectJson } = message
+        const object = this.serialization.parse(objectJson)
         const id = object?.id
         if(typeof id != 'string') throw new Error(`ID is not string: ${JSON.stringify(id)}`)
         const objectObservable = this.objectObservables.get(id)
@@ -314,9 +425,13 @@ class Store {
   }
 
   async objectGet(id) {
+    await this.ensureOpen()
     if(!id) throw new Error("key is required")
     if(typeof id != 'string') throw new Error(`ID is not string: ${JSON.stringify(id)}`)
-    return await this.db.get(this.storeName, id) || null
+    const transaction = this.db.transaction([this.storeName], 'readonly')
+    const store = transaction.objectStore(this.storeName)
+    const json = await handleRequest(store.get(id) || null)
+    return json ? this.serialization.parse(json) : null
   }
 
   objectObservable(key) {
@@ -328,9 +443,7 @@ class Store {
 
   async rangeGet(range) {
     if(!range) throw new Error("range not defined")
-    console.log("RANGE GET!")
-
-    const txn = this.db.transaction(this.storeName, 'readonly')
+    await this.ensureOpen()
     let data = []
     const min = range.gt || range.gte
     const max = range.lt || range.lte
@@ -340,32 +453,53 @@ class Store {
     } else if(min) {
       keyRange = IDBKeyRange.lowerBound(min, !!range.gt)
     } else if(max) {
-      keyRange = IDBKeyRange.upperBound(min, !!range.gt)
+      keyRange = IDBKeyRange.upperBound(max, !!range.gt)
     }
 
+    const txn = this.db.transaction([this.storeName], 'readonly')
+    const store = txn.objectStore(this.storeName)
     if(range.reverse) {
-      let cursor = await txn.store.openCursor(keyRange, 'prev')
-      while ((!range.limit || data.length < range.limit) && cursor) {
-        if (range.gt && cursor.key <= range.gt) break
-        if (range.gte && cursor.key < range.gte) break
-        if ((!range.lt || cursor.key < range.lt) && (!range.lte || cursor.key <= range.lte)) {
-          data.push(cursor.value)
+      await new Promise((resolve, reject) => {
+        const cursorRequest = store.openCursor(keyRange, 'prev')
+        cursorRequest.onsuccess = (event) => {
+          const cursor = event.target.result
+          if ((!range.limit || data.length < range.limit) && cursor) {
+            if (range.gt && cursor.key <= range.gt) return resolve()
+            if (range.gte && cursor.key < range.gte) return resolve()
+            if ((!range.lt || cursor.key < range.lt) && (!range.lte || cursor.key <= range.lte)) {
+              const json = cursor.value
+              data.push(this.serialization.parse(json))
+            }
+            cursor.continue()
+          } else {
+            return resolve()
+          }
         }
-        cursor = await cursor.continue()
-      }
+        cursorRequest.onerror = (event) => {
+          reject(event.target.error)
+        }
+      })
     } else {
-      let cursor = await txn.store.openCursor(keyRange, 'next')
-      //console.log("CURSOR", cursor)
-      while((!range.limit || data.length < range.limit) && cursor) {
-        if(range.lt && cursor.key >= range.lt) break
-        if(range.lte && cursor.key > range.lte) break
-        if((!range.gt || cursor.key > range.gt) && (!range.gte || cursor.key >= range.gte)) {
-          data.push(cursor.value)
+      await new Promise((resolve, reject) => {
+        const cursorRequest = store.openCursor(keyRange, 'next')
+        cursorRequest.onsuccess = (event) => {
+          const cursor = event.target.result
+          if ((!range.limit || data.length < range.limit) && cursor) {
+            if(range.lt && cursor.key >= range.lt) return resolve()
+            if(range.lte && cursor.key > range.lte) return resolve()
+            if((!range.gt || cursor.key > range.gt) && (!range.gte || cursor.key >= range.gte)) {
+              const json = cursor.value
+              data.push(this.serialization.parse(json))
+            }
+            cursor.continue()
+          } else {
+            return resolve()
+          }
         }
-        cursor = await cursor.continue()
-        //console.log("CURSOR C", cursor)
-      }
-      //console.log("CUR READ END", cursor)
+        cursorRequest.onerror = (event) => {
+          reject(event.target.error)
+        }
+      })
     }
     return data
   }
@@ -379,6 +513,7 @@ class Store {
 
   async countGet(range) {
     if(!range) throw new Error("range not defined")
+    await this.ensureOpen()
     const min = range.gt || range.gte
     const max = range.lt || range.lte
     let keyRange = undefined
@@ -389,7 +524,9 @@ class Store {
     } else if(max) {
       keyRange = IDBKeyRange.upperBound(min, !!range.gt)
     }
-    const count = await this.count(this.storeName, keyRange)
+    const txn = this.db.transaction([this.storeName], 'readonly')
+    const store = txn.objectStore(this.storeName)
+    const count = await handleRequest(store.count(keyRange))
     if(range.limit && count > range.limit) return range.limit
     return count
   }
@@ -403,8 +540,8 @@ class Store {
 
   async rangeDelete(range) {
     if(!range) throw new Error("range not defined")
+    await this.ensureOpen()
 
-    const txn = this.db.transaction(this.storeName)
     let count = 0, last
     const min = range.gt || range.gte
     const max = range.lt || range.lte
@@ -417,50 +554,74 @@ class Store {
       keyRange = IDBKeyRange.upperBound(min, !!range.gt)
     }
 
+    const txn = this.db.transaction([this.storeName], 'readonly')
+    const store = txn.objectStore(this.storeName)
     if(range.reverse) {
-      let cursor = await txn.store.openCursor(keyRange, 'prev')
-      while ((!range.limit || data.length < range.limit) && cursor) {
-        if (range.gt && cursor.key <= range.gt) break
-        if (range.gte && cursor.key < range.gte) break
-        if ((!range.lt || cursor.key < range.lt) && (!range.lte || cursor.key <= range.lte)) {
-          count++
-          const id = cursor.key
-          const object = cursor.value
-          last = id
-          await cursor.delete()
-
-          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)
+      await new Promise((resolve, reject) => {
+        const cursorRequest = store.openCursor(keyRange, 'prev')
+        cursorRequest.onsuccess = async (event) => {
+          const cursor = event.target.result
+          if ((!range.limit || count < range.limit) && cursor) {
+            if (range.gt && cursor.key <= range.gt) return resolve()
+            if (range.gte && cursor.key < range.gte) return resolve()
+            if ((!range.lt || cursor.key < range.lt) && (!range.lte || cursor.key <= range.lte)) {
+              count++
+              const id = cursor.key
+              const json = cursor.value
+              const object = this.serialization.parse(json)
+              last = id
+              await handleRequest(cursor.delete())
+
+              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.channel.postMessage({ type: "delete", object: this.serialization.stringify(object) })
+            }
+            cursor.continue()
+          } else {
+            return resolve()
           }
-          this.channel.postMessage({ type: "delete", object })
         }
-        cursor = await cursor.continue()
-      }
+        cursorRequest.onerror = (event) => {
+          reject(event.target.error)
+        }
+      })
     } else {
-      let cursor = await txn.store.openCursor(keyRange, 'prev')
-      while((!range.limit || data.length < range.limit) && cursor) {
-        if(range.lt && cursor.key >= range.lt) break
-        if(range.lte && cursor.key > range.lte) break
-        if((!range.gt || cursor.key > range.gt) && (!range.gte || cursor.key >= range.gte)) {
-          count++
-          const id = cursor.key
-          const object = cursor.value
-          last = id
-          await cursor.delete()
-
-          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)
+      await new Promise((resolve, reject) => {
+        const cursorRequest = store.openCursor(keyRange, 'next')
+        cursorRequest.onsuccess = async (event) => {
+          const cursor = event.target.result
+          if ((!range.limit || count < range.limit) && cursor) {
+            if(range.lt && cursor.key >= range.lt) return resolve()
+            if(range.lte && cursor.key > range.lte) return resolve()
+            if((!range.gt || cursor.key > range.gt) && (!range.gte || cursor.key >= range.gte)) {
+              count++
+              const id = cursor.key
+              const json = cursor.value
+              const object = this.serialization.parse(json)
+              last = id
+              await handleRequest(cursor.delete())
+
+              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.channel.postMessage({ type: "delete", object: this.serialization.stringify(object) })
+            }
+            cursor.continue()
+          } else {
+            return resolve()
           }
-          this.channel.postMessage({ type: "delete", object })
         }
-        cursor = await cursor.continue()
-      }
+        cursorRequest.onerror = (event) => {
+          reject(event.target.error)
+        }
+      })
     }
     return { count, last }
   }
@@ -468,30 +629,46 @@ class Store {
   async put(object) {
     const id = object.id
     if(typeof id != 'string') throw new Error(`ID is not string: ${JSON.stringify(id)}`)
-    const oldObject = await this.db.get(this.storeName, id)
-    console.log("PUT", object)
-    await this.db.put(this.storeName, object)
+    await this.ensureOpen()
+    //console.error("put", id, object, 'in', this.storeName)
+    //console.error("storeNames", this.db.objectStoreNames)
+    const transaction = this.db.transaction([this.storeName], 'readwrite')
+    const store = transaction.objectStore(this.storeName)
+    const oldObjectJson = await handleRequest(store.get(id))
+    const oldObject = oldObjectJson ? this.serialization.parse(oldObjectJson) : null
+    //console.log("PUT", object)
+    const json = this.serialization.stringify(object)
+    await handleRequest(store.put(json))
     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.channel.postMessage({ type: "put", object, oldObject })
+    this.channel.postMessage({ type: "put",
+      object: this.serialization.stringify(object),
+      oldObject: this.serialization.stringify(oldObject)
+    })
     return oldObject
   }
 
   async delete(id) {
     if(typeof id != 'string') throw new Error(`ID is not string: ${JSON.stringify(id)}`)
-    const object = await this.db.get(this.storeName, id)
-    await this.db.delete(this.storeName, id)
+    await this.ensureOpen()
+
+    const transaction = this.db.transaction([this.storeName], 'readwrite')
+    const store = transaction.objectStore(this.storeName)
+
+    const json = await handleRequest(store.get(id))
+    const object = json ? this.serialization.parse(json) : null
+    await handleRequest(store.delete(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.channel.postMessage({ type: "delete", object  })
+    this.channel.postMessage({ type: "delete", object: this.serialization.stringify(object)  })
     return object
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/db-store-indexeddb",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Database with observable data for live queries",
   "main": "index.js",
   "scripts": {
@@ -26,9 +26,9 @@
     "tape": "^5.3.2"
   },
   "dependencies": {
-    "@live-change/dao": "0.5.14",
+    "@live-change/dao": "0.5.15",
     "@live-change/interval-tree": "^1.0.12",
     "broadcast-channel": "^4.2.0"
   },
-  "gitHead": "f458425c609deeb9d1f38c15a3aa37759629a67e"
+  "gitHead": "8dc4ac726243970c9f1431bf67b4390f7845ce76"
 }