@live-change/dao 0.4.9 → 0.4.13

package/browser.js

@@ -34,6 +34,10 @@ import DaoCache from "./lib/DaoCache.js"
 rd.DaoCache = DaoCache
 export { DaoCache }
 
+import InboxReader from "./lib/InboxReader.js"
+rd.InboxReader = InboxReader
+export { InboxReader }
+
 import ReactiveConnection from "./lib/ReactiveConnection.js"
 rd.ReactiveConnection = ReactiveConnection
 export { ReactiveConnection }

package/index.js

@@ -55,6 +55,9 @@ Dao.DaoProxy = DaoProxy
 const DaoCache = require("./lib/DaoCache.js")
 Dao.DaoCache = DaoCache
 
+const InboxReader = require("./lib/InboxReader.js")
+Dao.InboxReader = InboxReader
+
 const Path = require("./lib/Path.js")
 Dao.Path = Path
 

package/lib/InboxReader.js

@@ -0,0 +1,97 @@
+
+class InboxReader {
+  constructor(observableFunction, callback, start = '', bucketSize = 32) {
+    this.observableFunction = observableFunction
+    this.position = start
+    this.callback = callback
+    this.bucketSize = bucketSize
+
+    this.observable = null
+    this.queue = []
+    this.processingPromise = null
+    this.finished = false
+    this.readPromise = null
+    this.readPromiseResolve = null
+
+    this.observer = (signal, ...args) => {
+      if(signal == 'error') {
+        const error = args[0]
+        console.error("PEER MESSAGE ERROR", error.stack || error)
+        return
+      }
+      if(signal == 'putByField') {
+        const [field, id, message] = args
+        this.handleMessage(message)
+      } else if(signal == 'set') {
+        const value = args[0]
+        for (const message of value) {
+          this.handleMessage(message)
+        }
+      } else if(signal == 'push') {
+        const [message] = args
+        this.handleMessage(message)
+      } else {
+        console.error("INBOX READER SIGNAL NOT HANDLED", signal)
+      }
+      this.startProcessing()
+      this.observeNext()
+    }
+    this.observeNext()
+  }
+
+  observeNext() {
+    if(this.queue.length > this.bucketSize) return // no need to observe, there is work to do
+    if(this.observable) {
+      const observableValue = this.observable.getValue()
+      if(!observableValue) return // still loading data
+      if(observableValue.length < this.bucketSize) return // we are waiting for more
+    }
+    if(this.observable) {
+      this.observable.unobserve(this.observer)
+      this.observable = null
+    }
+    this.readPromise = new Promise(resolve => this.readPromiseResolve = resolve)
+    this.observable = this.observableFunction(this.position, this.bucketSize)
+    this.observable.observe(this.observer)
+  }
+
+  handleMessage(message) {
+    if(message.id <= this.position) return // ignore
+    this.position = message.id
+    this.queue.push(message)
+  }
+
+  startProcessing() {
+    if(!this.processingPromise) {
+      this.processingPromise = this.doProcessing()
+      this.processingPromise.then(() => this.processingPromise = null)
+    }
+    return this.processingPromise
+  }
+
+  async doProcessing() {
+    while(this.queue.length > 0 && !this.finished) {
+      const message = this.queue.shift()
+      await this.callback(message)
+      this.observeNext() // observe if needed
+    }
+  }
+
+  async sync() {
+    while(this.queue.length > 0 || this.readPromise) {
+      if(this.queue.length > 0) await this.startProcessing()
+      if(this.readPromise) await this.readPromise
+    }
+  }
+
+  dispose() {
+    this.finished = true
+    if(this.observable) {
+      this.observable.unobserve(this.observer)
+      this.observable = null
+    }
+  }
+
+}
+
+module.exports = InboxReader

package/lib/ObservableList.js

@@ -65,7 +65,7 @@ class ObservableList extends Observable {
       if(i == l) this.list.push(element)
     } else {
       let i
-      for(i = this.list.length-1; i >= 0; i--) {
+      for(i = this.list.length - 1; i >= 0; i--) {
         if(this.list[i][field] == value) {
           oldElement = this.list[i]
           this.list.splice(i, 1, element)

package/lib/Path.js

@@ -71,16 +71,17 @@ class Path {
     }
     return new Path(this.what, newMore, this.to, this.actions)
   }
-  action(paramsFunc) {
+  action(name, paramsFunc) {
     let newActions = this.actions ? this.actions.slice() : []
     const source = sourceProxy()
-    const actionObject = paramsFunc(source)
+    const actionObject = (paramsFunc || to)(source)
     const path = actionObject.slice(0, -1)
     const params = actionObject[actionObject.length - 1]
     let processedParams = processParams(params)
     const action = {
+      name: paramsFunc ? name : undefined,
       path,
-      params: { object: processedParams }
+      params: { object: processedParams },
     }
     newActions.push(action)
     return new Path(this.what, this.more, this.to, newActions)

package/package.json

@@ -35,6 +35,6 @@
   "scripts": {
     "test": "NODE_ENV=test blue-tape tests/*"
   },
-  "version": "0.4.9",
-  "gitHead": "ec7e7187e4d9c3888b399b6eebd672e6c992e1a0"
+  "version": "0.4.13",
+  "gitHead": "573a234a6c5a9525aa97894fd9b2bf67ffe1d2a4"
 }

package/tests/path.js

@@ -49,9 +49,10 @@ test("Path", t => {
 
   t.test("tasks with delete actions", t => {
     t.plan(1)
-    const path = tasks({ }).action(task => deleteTask({ task: task.id }))
+    const path = tasks({ }).action('delete', task => deleteTask({ task: task.id }))
+    console.log(JSON.stringify(path))
     t.deepEqual(clean(path), {"what":["tasks",{}],"actions":[
-        {"path":["tasks"],"params":{"object":{"task":{"property":"id"}}}}
+        {"name":"delete","path":["tasks"],"params":{"object":{"task":{"property":"id"}}}}
       ]})
   })