@live-change/db-web 0.5.25 → 0.6.2

package/lib/Server.js

@@ -8,34 +8,47 @@ const ReactiveDao = require("@live-change/dao")
 const Database = require('@live-change/db').Database
 
 class DatabaseStore {
-  constructor(path, backend, options) {
+  constructor(path, backends, options) {
     this.path = path
-    this.backend = backend
+    this.backends = backends
     this.stores = new Map()
 
-    this.db = backend.createDb(path, options)
+    this.dbs = {}
+    this.dbs.default = this.backends.default.createDb(path, options)
   }
   close() {
-    return this.backend.closeDb(this.db)
+    for(let key in this.dbs) {
+      return this.backends[key].closeDb(this.dbs[key])
+    }
   }
   delete() {
-    return this.backend.deleteDb(this.db)
+    for(let key in this.dbs) {
+      return this.backends[key].deleteDb(this.dbs[key])
+    }
   }
   getStore(name, options = {}) {
     let store = this.stores.get(name)
     if(store) return store
-    store = this.backend.createStore(this.db, name, options)
+    const backendName = options.backend ?? (options.memory ? 'memory' : 'default')
+    if(!this.backends[backendName]) {
+      throw new Error(`db ${path} backend ${backendName} not configured`)
+    }
+    if(!this.dbs[backendName]) {
+      this.dbs[backendName] = this.backends[backendName].createDb(this.path, options)
+    }
+    store = this.backends[backendName].createStore(this.dbs[backendName], name, options)
+    store.backendName = backendName
     this.stores.set(name, store)
     return store
   }
   closeStore(name) {
     let store = this.stores.get(name)
     if(!store) return;
-    return this.backend.closeStore(store)
+    return this.backends[store.backendName].closeStore(store)
   }
   deleteStore(name) {
     let store = this.getStore(name)
-    return this.backend.deleteStore(store)
+    return this.backends[store.backendName].deleteStore(store)
   }
 }
 
@@ -48,9 +61,35 @@ class Server {
 
     this.databasesListObservable = new ReactiveDao.ObservableList([])
 
-    this.backend = createBackend(config)
+    this.backends = {}
+    if(config.backend && !this.backends.default) { // backward compatibility
+      this.backends.default = createBackend({
+        name: config.backend,
+        url: config.backendUrl,
+        maxDbs: config.maxDbs,
+        maxDbSize: config.maxDbSize,
+      })
+    }
+    for(let backend of config.backends || []) {
+      if(typeof backend == 'string') {
+        backend = { name: backend }
+      }
+      this.backends[backend.name] = createBackend(backend)
+      if(!this.backends.default) {
+        this.backends.default = this.backends[backend.name]
+      }
+    }
+    if(!this.backends.default) {
+      throw new Error("No default backend configured")
+    }
+    if(!this.backends.memory) {
+      this.backends.memory = createBackend({
+        name: "memory"
+      })
+    }
 
-    this.metadataSavePromise = null
+    this.metadataDatabase = this.backends.default.createDb('_db_metadata', {})
+    this.metadataStore = this.backends.default.createStore(this.metadataDatabase, 'metadata', {})
   }
   createDao(session) {
     return new ReactiveDao(session, {
@@ -92,8 +131,7 @@ class Server {
     if(initOptions.metadata) {
       this.metadata = initOptions.metadata
     } else {
-      const jsonStr = localStorage[`${this.config.dbPrefix || ''}_lcdb`]
-      this.metadata = jsonStr && JSON.parse(jsonStr)
+      this.metadata = await this.metadataStore.objectGet('metadata')
     }
     if(!this.metadata) {
       this.metadata = {
@@ -116,7 +154,10 @@ class Server {
     const dbPath = `${this.config.dbPrefix || ''}_lcdb`
     let dbStore = this.databaseStores.get(dbName)
     if(!dbStore) {
-      dbStore = new DatabaseStore(dbPath, this.backend, dbConfig.storage)
+      const backend = this.backends[dbConfig.backend?.name ?? dbConfig.backend ?? 'default']
+      dbStore = new DatabaseStore(dbPath, { ...this.backends, default: backend },
+        typeof dbConfig.backend == 'object' ? dbConfig.backend : dbConfig.storage
+      )
       this.databaseStores.set(dbName, dbStore)
     }
     const database = new Database(
@@ -138,7 +179,7 @@ class Server {
   }
 
   async saveMetadata() {
-    localStorage[`${this.config.dbPrefix || ''}_lcdb`] = JSON.stringify(this.metadata)
+    await this.metadataStore.put({ ...this.metadata, id: 'metadata' })
   }
 
   async close() {

package/lib/backend.js

@@ -1,5 +1,6 @@
 function createBackend(config) {
-  if(config.backend == 'mem') {
+  console.log("CREATE BACKEND", config)
+  if(config.name == 'mem' || config.name == 'memory') {
     return {
       Store: require('@live-change/db-store-rbtree'),
       createDb(path, options) {
@@ -12,10 +13,9 @@ function createBackend(config) {
       },
       async deleteDb(db) {
         db.close()
-        await rimraf(db.path)
       },
       createStore(db, name, options) {
-        return new this.Store()
+        return new this.Store(options)
       },
       closeStore(store) {
       },
@@ -23,7 +23,81 @@ function createBackend(config) {
         await store.clear()
       }
     }
-  } else throw new Error("Unknown backend " + config.backend)
+  } if(config.name == 'indexeddb') {
+    return {
+      Store: require('@live-change/db-store-indexeddb'),
+      createDb(path, options) {
+        const db = {}
+        db.path = path
+        return db
+      },
+      closeDb(db) {
+        db.close()
+      },
+      async deleteDb(db) {
+        db.close()
+        db.deleteDb()
+      },
+      createStore(db, name, options) {
+        return new this.Store(db.path, name, options)
+      },
+      closeStore(store) {
+      },
+      async deleteStore(store) {
+        await store.clear()
+      }
+    }
+  } if(config.name == 'local') {
+    return {
+      Store: require('@live-change/db-store-localstorage'),
+      createDb(path, options) {
+        const db = {}
+        db.path = path
+        return db
+      },
+      closeDb(db) {
+        db.close()
+      },
+      async deleteDb(db) {
+        db.close()
+        db.deleteDb()
+      },
+      createStore(db, name, options) {
+        return new this.Store(db.path, name, 'local', options)
+      },
+      closeStore(store) {
+      },
+      async deleteStore(store) {
+        await store.clear()
+      }
+    }
+  } if(config.name == 'session') {
+    return {
+      Store: require('@live-change/db-store-localstorage'),
+      createDb(path, options) {
+        const db = {}
+        db.path = path
+        return db
+      },
+      closeDb(db) {
+        db.close()
+      },
+      async deleteDb(db) {
+        db.close()
+        db.deleteDb()
+      },
+      createStore(db, name, options) {
+        return new this.Store(db.path, name, 'session', options)
+      },
+      closeStore(store) {
+      },
+      async deleteStore(store) {
+        await store.clear()
+      }
+    }
+  } else {
+    throw new Error("Unknown backend " + config.name)
+  }
 }
 
 module.exports = createBackend

package/lib/dbDao.js

@@ -71,11 +71,25 @@ function localRequests(server, scriptContext) {
       if(dbName == 'system') throw new Error("system database is not writable")
       const db = server.databases.get(dbName)
       if(!db) throw new Error('databaseNotFound')
-      const table = db.table(tableName)
-      if(!table) throw new Error("tableNotFound")
-      const uid = table.configObservable.value.uid
-      await db.deleteTable(tableName)
-      await server.databases.get('system').table(dbName+'_tables').delete(uid)
+      if(tableName[tableName.length - 1] == "*") {
+        const list = db.tablesListObservable.list.slice()
+        for(const foundTableName of list) {
+          const base = tableName.slice(0, -1)
+          if(foundTableName.slice(0, base.length) != base) continue
+          const table = db.table(foundTableName)
+          if(!table) throw new Error("tableNotFound")
+          const uid = table.configObservable.value.uid
+          await db.deleteTable(foundTableName)
+          await server.databases.get('system').table(dbName + '_tables').delete(uid)
+        }
+      } else {
+        const table = db.table(tableName)
+        if(!table) throw new Error("tableNotFound")
+        const uid = table.configObservable.value.uid
+        await db.deleteTable(tableName)
+        await server.databases.get('system').table(dbName + '_tables').delete(uid)
+      }
+      return 'ok'
     },
     renameTable: async (dbName, tableName, newTableName) => {
       if(dbName == 'system') throw new Error("system database is not writable")
@@ -105,11 +119,24 @@ function localRequests(server, scriptContext) {
       if(dbName == 'system') throw new Error("system database is not writable")
       const db = server.databases.get(dbName)
       if(!db) throw new Error('databaseNotFound')
-      const index = await db.index(indexName)
-      if(!index) throw new Error("indexNotFound")
-      const uid = index.configObservable.value.uid
-      await db.deleteIndex(indexName)
-      await server.databases.get('system').table(dbName+'_indexes').delete(uid)
+      if(indexName[indexName.length - 1] == "*") {
+        const base = indexName.slice(0, -1)
+        const list = db.indexesListObservable.list.slice()
+        for(const foundIndexName of list) {
+          if(foundIndexName.slice(0, base.length) != base) continue
+          const index = await db.index(foundIndexName)
+          if(!index) throw new Error("indexNotFound")
+          const uid = index.configObservable.value.uid
+          await db.deleteIndex(foundIndexName)
+          await server.databases.get('system').table(dbName + '_indexes').delete(uid)
+        }
+      } else {
+        const index = await db.index(indexName)
+        if(!index) throw new Error("indexNotFound")
+        const uid = index.configObservable.value.uid
+        await db.deleteIndex(indexName)
+        await server.databases.get('system').table(dbName + '_indexes').delete(uid)
+      }
       return 'ok'
     },
     renameIndex: async (dbName, indexName, newIndexName) => {
@@ -191,6 +218,14 @@ function localRequests(server, scriptContext) {
       if(!log) throw new Error("logNotFound")
       return log.put(object)
     },
+    putOldLog: (dbName, logName, object) => {
+      if(dbName == 'system') throw new Error("system database is not writable")
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const log = db.log(logName)
+      if(!log) throw new Error("logNotFound")
+      return log.putOld(object)
+    },
     query: (dbName, code, params) => {
       if(dbName == 'system') throw new Error("system database is not writable")
       if(!dbName) throw new Error("databaseNameRequired")
@@ -202,6 +237,133 @@ function localRequests(server, scriptContext) {
   }
 }
 
+function remoteRequests(server) {
+  return {
+    createDatabase: async (dbName, options = {}) => {
+      if(server.metadata.databases[dbName]) throw new Error("databaseAlreadyExists")
+      return server.masterDao.request(['database', 'createDatabase'], dbName, options)
+    },
+    deleteDatabase: async (dbName) => {
+      if(!server.metadata.databases[dbName]) throw new Error("databaseNotFound")
+      return server.masterDao.request(['database', 'deleteDatabase'], dbName, options)
+    },
+    clearDatabaseOpLogs: async (dbName, lastTimestamp, limit) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      if(typeof lastTimestamp == 'string') lastTimestamp = new Date(lastTimestamp)
+      return server.masterDao.request(['database', 'clearDatabaseOpLogs'], dbName, lastTimestamp, limit)
+    },
+    clearTableOpLog: async (dbName, tableName, lastTimestamp, limit) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const table = db.table(tableName)
+      if(!table) throw new Error("tableNotFound")
+      if(typeof lastTimestamp == 'string') lastTimestamp = new Date(lastTimestamp)
+      return server.masterDao.request(['database', 'clearTableOpLog'], dbName, tableName, lastTimestamp, limit)
+    },
+    clearIndexOpLog: async (dbName, indexName, lastTimestamp, limit) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const index = db.table(indexName)
+      if(!index) throw new Error("indexNotFound")
+      if(typeof lastTimestamp == 'string') lastTimestamp = new Date(lastTimestamp)
+      return server.masterDao.request(['database', 'clearIndexOpLog'], dbName, indexName, lastTimestamp, limit)
+    },
+    createTable: async (dbName, tableName, options = {}) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      return server.masterDao.request(['database', 'createTable'], dbName, tableName, options)
+    },
+    deleteTable: async (dbName, tableName, options) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      return server.masterDao.request(['database', 'deleteTable'], dbName, tableName, options)
+    },
+    renameTable: async (dbName, tableName, newTableName) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const table = db.table(tableName)
+      if(!table) throw new Error("tableNotFound")
+      return server.masterDao.request(['database', 'renameTable'], dbName, tableName, newTableName)
+    },
+    createIndex: async (dbName, indexName, code, params, options = {}) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      return server.masterDao.request(['database', 'createIndex'], dbName, indexName, code, params, options )
+    },
+    deleteIndex: async (dbName, indexName, options) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      return server.masterDao.request(['database', 'deleteIndex'], dbName, indexName, options )
+    },
+    renameIndex: async (dbName, indexName, newIndexName) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const index = db.index(indexName)
+      if(!index) throw new Error("indexNotFound")
+      return server.masterDao.request(['database', 'renameIndex'], dbName, indexName, newIndexName )
+    },
+    createLog: async (dbName, logName, options = {}) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      return server.masterDao.request(['database', 'createLog'], dbName, logName, options )
+    },
+    deleteLog: async (dbName, logName, options) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      await db.deleteLog(logName)
+      return server.masterDao.request(['database', 'deleteLog'], dbName, logName, options )
+    },
+    renameLog: async (dbName, logName, newLogName) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const log = db.log(logName)
+      if(!log) throw new Error("logNotFound")
+      return server.masterDao.request(['database', 'renameLog'], dbName, logName, newLogName )
+    },
+    put: (dbName, tableName, object) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const table = db.table(tableName)
+      if(!table) throw new Error("tableNotFound")
+      return server.masterDao.request(['database', 'put'], dbName, tableName, object )
+    },
+    delete: (dbName, tableName, id) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const table = db.table(tableName)
+      if(!table) throw new Error("tableNotFound")
+      return server.masterDao.request(['database', 'delete'], dbName, tableName, id )
+    },
+    update: (dbName, tableName, id, operations, options) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const table = db.table(tableName)
+      if(!table) throw new Error("tableNotFound")
+      return server.masterDao.request(['database', 'update'], dbName, tableName, id, operations, options )
+    },
+    putLog: (dbName, logName, object) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const log = db.log(logName)
+      if(!log) throw new Error("logNotFound")
+      return server.masterDao.request(['database', 'putLog'], dbName, logName, object )
+    },
+    putOldLog: (dbName, logName, object) => {
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      const log = db.log(logName)
+      if(!log) throw new Error("logNotFound")
+      return server.masterDao.request(['database', 'putOldLog'], dbName, logName, object )
+    },
+    query: (dbName, code, params) => {
+      if(!dbName) throw new Error("databaseNameRequired")
+      const db = server.databases.get(dbName)
+      if(!db) throw new Error('databaseNotFound')
+      return server.masterDao.request(['database', 'query'], dbName, code, params )
+    }
+  }
+}
 
 function localReads(server, scriptContext) {
   return {
@@ -350,33 +512,33 @@ function localReads(server, scriptContext) {
       }
     },
     indexConfig: {
-      observable: (dbName, indexName, id) => {
+      observable: async (dbName, indexName, id) => {
         const db = server.databases.get(dbName)
         if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
-        const index = db.index(indexName)
+        const index = await db.index(indexName)
         if(!index) return new ReactiveDao.ObservableError('indexNotFound')
         return index.configObservable
       },
       get: async (dbName, indexName, id) =>{
         const db = server.databases.get(dbName)
         if(!db) throw new Error('databaseNotFound')
-        const index = db.index(indexName)
+        const index = await db.index(indexName)
         if(!index) throw new Error("indexNotFound")
         return index.configObservable.value
       }
     },
     indexCode: {
-      observable: (dbName, indexName, id) => {
+      observable: async (dbName, indexName, id) => {
         const db = server.databases.get(dbName)
         if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
-        const index = db.index(indexName)
+        const index = await db.index(indexName)
         if(!index) return new ReactiveDao.ObservableError('indexNotFound')
         return index.codeObservable
       },
       get: async (dbName, indexName, id) =>{
         const db = server.databases.get(dbName)
         if(!db) throw new Error('databaseNotFound')
-        const index = db.index(indexName)
+        const index = await db.index(indexName)
         if(!index) throw new Error("indexNotFound")
         return index.codeObservable.value
       }
@@ -431,6 +593,22 @@ function localReads(server, scriptContext) {
         return table.rangeGet(range)
       }
     },
+    tableCount: {
+      observable: (dbName, tableName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        const table = db.table(tableName)
+        if(!table) return new ReactiveDao.ObservableError('tableNotFound')
+        return table.countObservable(range)
+      },
+      get: async (dbName, tableName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        const table = db.table(tableName)
+        if(!table) throw new Error("tableNotFound")
+        return table.countGet(range)
+      }
+    },
     tableOpLogObject: {
       observable: (dbName, tableName, id) => {
         const db = server.databases.get(dbName)
@@ -463,6 +641,22 @@ function localReads(server, scriptContext) {
         return table.opLog.rangeGet(range)
       }
     },
+    tableOpLogCount: {
+      observable: (dbName, tableName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        const table = db.table(tableName)
+        if(!table) return new ReactiveDao.ObservableError('tableNotFound')
+        return table.opLog.countObservable(range)
+      },
+      get: async (dbName, tableName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        const table = db.table(tableName)
+        if(!table) throw new Error("tableNotFound")
+        return table.opLog.countGet(range)
+      }
+    },
     indexObject: {
       observable: async (dbName, indexName, id) => {
         if(!id) return new ReactiveDao.ObservableError("id is required")
@@ -497,6 +691,22 @@ function localReads(server, scriptContext) {
         return index.rangeGet(range)
       }
     },
+    indexCount: {
+      observable: async (dbName, indexName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        const index = await db.index(indexName)
+        if(!index) return new ReactiveDao.ObservableError('indexNotFound')
+        return index.countObservable(range)
+      },
+      get: async (dbName, indexName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        const index = await db.index(indexName)
+        if(!index) throw new Error("indexNotFound")
+        return index.countGet(range)
+      }
+    },
     indexOpLogObject: {
       observable: (dbName, indexName, id) => {
         const db = server.databases.get(dbName)
@@ -531,6 +741,24 @@ function localReads(server, scriptContext) {
         return index.opLog.rangeGet(range)
       }
     },
+    indexOpLogCount: {
+      observable: (dbName, indexName, range) => {
+        if(!id) return new ReactiveDao.ObservableError("id is required")
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        const index = db.index(indexName)
+        if(!index) return new ReactiveDao.ObservableError('indexNotFound')
+        return index.opLog.countObservable(range)
+      },
+      get: async (dbName, indexName, range) => {
+        if(!id) throw new Error("id is required")
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        const index = db.index(indexName)
+        if(!index) throw new Error("indexNotFound")
+        return index.opLog.countGet(range)
+      }
+    },
     logObject: {
       observable: (dbName, logName, id) => {
 
@@ -564,42 +792,55 @@ function localReads(server, scriptContext) {
         return log.rangeGet(range)
       }
     },
+    logCount: {
+      observable: (dbName, logName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
+        const log = db.log(logName)
+        if(!log) return new ReactiveDao.ObservableError('logNotFound')
+        return log.countObservable(range)
+      },
+      get: async (dbName, logName, range) => {
+        const db = server.databases.get(dbName)
+        if(!db) throw new Error('databaseNotFound')
+        const log = db.log(logName)
+        if(!log) throw new Error("logNotFound")
+        return log.countGet(range)
+      }
+    },
     query: {
-      observable: (dbName, code, params = {}) => {
+      observable: (dbName, code, params = {}, sourceName = 'query/query.js') => {
         if(!dbName) return new ReactiveDao.ObservableError("databaseNameRequired")
         const db = server.databases.get(dbName)
         if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
-        const queryFunction = scriptContext.run(code, 'query')
-
+        const queryFunction = scriptContext.run(code, 'queryCode:' + sourceName) /// TODO: log queries, more info here
         return db.queryObservable(async (input, output) => {
           return queryFunction(input, output, params)
         })
       },
-      get: async (dbName, code, params = {}) => {
+      get: async (dbName, code, params = {}, sourceName = 'query/query.js') => {
         if(!dbName) throw new Error("databaseNameRequired")
         const db = server.databases.get(dbName)
         if(!db) throw new Error('databaseNotFound')
-        const queryFunction = scriptContext.run(code, 'query')
-        return db.queryGet((input, output) => {
-          return queryFunction(input, output, params)
-        })
+        const queryFunction = scriptContext.run(code, 'queryCode:' + sourceName)
+        return db.queryGet((input, output) => queryFunction(input, output, params))
       }
     },
     queryObject: {
-      observable: (dbName, code, params = {}) => {
+      observable: (dbName, code, params = {}, sourceName = 'queryObject/query.js') => {
         if(!dbName) return new ReactiveDao.ObservableError("databaseNameRequired")
         const db = server.databases.get(dbName)
         if(!db) return new ReactiveDao.ObservableError('databaseNotFound')
-        const queryFunction = scriptContext.run(code, 'query')
+        const queryFunction = scriptContext.run(code, 'queryCode:' + sourceName) /// TODO: log queries, more info here
         return db.queryObjectObservable(async (input, output) => {
           return queryFunction(input, output, params)
         })
       },
-      get: async (dbName, code, params = {}) => {
+      get: async (dbName, code, params = {}, sourceName = 'queryObject/query.js') => {
         if(!dbName) throw new Error("databaseNameRequired")
         const db = server.databases.get(dbName)
         if(!db) throw new Error('databaseNotFound')
-        const queryFunction = scriptContext.run(code, 'query')
+        const queryFunction = scriptContext.run(code, 'queryCode:' + sourceName)
         return db.queryObjectGet((input, output) => queryFunction(input, output, params))
       }
     }
@@ -608,5 +849,6 @@ function localReads(server, scriptContext) {
 
 module.exports = {
   localRequests,
+  remoteRequests,
   localReads
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/db-web",
-  "version": "0.5.25",
+  "version": "0.6.2",
   "author": {
     "email": "michal@laszczewski.com",
     "name": "Michał Łaszczewski",
@@ -29,10 +29,12 @@
     "tape": "^5.3.2"
   },
   "dependencies": {
-    "@live-change/dao": "^0.5.10",
-    "@live-change/db": "^0.5.25",
-    "@live-change/db-store-rbtree": "^0.5.25",
+    "@live-change/dao": "0.5.14",
+    "@live-change/db": "^0.6.2",
+    "@live-change/db-store-indexeddb": "^0.6.2",
+    "@live-change/db-store-localstorage": "^0.6.2",
+    "@live-change/db-store-rbtree": "^0.6.2",
     "debug": "^4.3.4"
   },
-  "gitHead": "dac1ac23bd1a4e1ba83e674d5493ab6c832f4462"
+  "gitHead": "9a1b104864c08f3e35b009f191889e3308e3eeb0"
 }