@live-change/dao 0.3.5 → 0.3.9

package/browser.js

@@ -14,6 +14,10 @@ import ObservableList from "./lib/ObservableList.js"
 rd.ObservableList = ObservableList
 export { ObservableList }
 
+import ExtendedObservableList from "./lib/ExtendedObservableList.js"
+rd.ExtendedObservableList = ExtendedObservableList
+export { ExtendedObservableList }
+
 import DaoPrerenderCache from "./lib/DaoPrerenderCache.js"
 const ReactiveCache = DaoPrerenderCache // backward compatibility
 rd.ReactiveCache = DaoPrerenderCache // backward compatibility

package/index.js

@@ -11,6 +11,9 @@ Dao.ObservableValue = ObservableValue
 const ObservableList = require("./lib/ObservableList.js")
 Dao.ObservableList = ObservableList
 
+const ExtendedObservableList = require("./lib/ExtendedObservableList.js")
+Dao.ExtendedObservableList = ExtendedObservableList
+
 const ReactiveServer = require("./lib/ReactiveServer.js")
 Dao.ReactiveServer = ReactiveServer
 

package/lib/DaoPrerenderCache.js

@@ -6,12 +6,21 @@ class DaoPrerenderCache {
   constructor(dao, mode) {
     this.dao = dao
     this.cache = new Map()
+    this.extendedCache = new Map()
     this.mode = mode
     this.observables = new Map()
   }
-  
+
   setCache(data) {
     this.cache = new Map(data)
+    for(const [keyJson, value] of data) {
+      const key = JSON.parse(keyJson)
+      if(key.paths) {
+        for(const { what, data } of value) {
+          this.extendedCache.set(JSON.stringify(what), data)
+        }
+      }
+    }
     for(const [what, observable] of this.observables.entries()) {
       if(observable.isDisposed()) {
         observable.set(this.cache.get(what))
@@ -35,7 +44,12 @@ class DaoPrerenderCache {
       observable = this.dao.observable(what)
     }
     this.observables.set(cacheKey, observable)
-    if (this.cache.has(cacheKey)) observable.restore(this.cache.get(cacheKey))
+    if(this.cache.has(cacheKey)) observable.restore(this.cache.get(cacheKey))
+    if(this.extendedCache.has(cacheKey)) {
+      observable.restore(this.extendedCache.get(cacheKey))
+      return observable
+      // do not save extended values
+    }
     if(observable.isInitialized && observable.isInitialized()) {
       if(this.mode == 'save') {
         this.cache.set(cacheKey, observable.save())
@@ -43,34 +57,57 @@ class DaoPrerenderCache {
       return observable
     }
     if(this.mode == 'load') {
-      //if (this.cache.has(cacheKey)) observable.restore(this.cache.get(cacheKey))
+      // if (this.cache.has(cacheKey)) observable.restore(this.cache.get(cacheKey))
+      // it was loaded earlier
     }
     return observable
   }
-  
+
   get(what) {
     const cacheKey = JSON.stringify(what)
     debug("GET", cacheKey)
-    if (this.cache.has(cacheKey)) {
+    if(this.cache.has(cacheKey)) {
       const value = this.cache.get(cacheKey)
       debug("GET FROM CACHE", cacheKey, " => ", value)
       return Promise.resolve(value)
     }
+    if(this.extendedCache.has(cacheKey)) {
+      const value = this.extendedCache.get(cacheKey)
+      debug("GET FROM EXTENDED CACHE", cacheKey, " => ", value)
+      return Promise.resolve(value)
+    }
     if(this.mode == 'load') {
     }
     const promise = this.dao.get(what)
     if(this.mode == 'save') {
       if(!promise) throw new Error("GET NOT FOUND: "+what)
-      promise.then(result => {      
+      promise.then(result => {
         let observable = this.observables.get(cacheKey)
         if(observable) {
-          if(typeof observable == 'function') return observable('set', result)
-          if(observable.notify) {
-            return observable.notify('set', result)
+          if(typeof observable == 'function') {
+            observable('set', result)
+          } else if(observable.notify) {
+            observable.notify('set', result)
+          } else {
+            observable.set(result)
           }
-          observable.set(result)
         }
         this.cache.set(cacheKey, result)
+        if(what.paths) {
+          for(const { what, data } of result) {
+            let observable = this.observables.get(cacheKey)
+            if(observable) {
+              if(typeof observable == 'function') {
+                observable('set', data)
+              } else if(observable.notify) {
+                observable.notify('set', data)
+              } else {
+                observable.set(data)
+              }
+            }
+            this.extendedCache.set(JSON.stringify(what), data)
+          }
+        }
       })
     }
     return promise

package/lib/ExtendedObservableList.js

@@ -0,0 +1,225 @@
+const ObservableList = require("./ObservableList.js")
+
+class ExtendedObservableList extends ObservableList {
+  constructor(observableList, elementActivator, elementDispose, valueActivator = observableList.valueActivator) {
+    let list = observableList.list
+    if(elementActivator) {
+      list = Array.isArray(list) ? list.map(elementActivator) : elementActivator(list)
+    }
+    super(list, undefined, undefined, valueActivator)
+
+    this.observableList = observableList
+    this.elementActivator = elementActivator
+    this.elementDispose = elementDispose
+    this.valueActivator = valueActivator
+
+    this.savedError = null
+    this.properties = []
+    this.errorProperties = []
+
+    this.observableList.observe(this)
+  }
+
+  dispose() {
+    this.observableList.unobserve(this)
+    if(this.elementDispose) {
+      if(Array.isArray(this.list)) {
+        for(const disposed of this.list) this.elementDispose(disposed)
+      } else {
+        this.elementDispose(this.list)
+      }
+      this.list = undefined
+    }
+    ObservableList.dispose.apply(this)
+  }
+
+  respawn() {
+    ObservableList.respawn.apply(this)
+    this.observableList.observe(this)
+  }
+
+  extend(elementFunc, elementDispose) {
+    const extendedList = new ExtendedObservableList(
+      this.value, null, null, this.valueActivator, elementFunc, elementDispose)
+    const oldDispose = extendedList.dispose
+    const oldRespawn = extendedList.respawn
+
+    this.observe(extendedList)
+    extendedList.dispose = () => {
+      this.unobserve(extendedList)
+      oldDispose.apply(extendedList)
+    }
+    extendedList.respawn = () => {
+      oldRespawn.apply(extendedList)
+      this.observe(extendedList)
+    }
+    return extendedList
+  }
+
+  set(list) {
+    if(list === this.list) return;
+    try {
+      if (JSON.stringify(list) == JSON.stringify(this.list)) return;
+    } catch(e) {}
+    if(this.elementDispose) {
+      if(Array.isArray(this.list)) {
+        for(const disposed of this.list) this.elementDispose(disposed)
+      } else {
+        this.elementDispose(this.list)
+      }
+    }
+    if(this.elementActivator) {
+      list = Array.isArray(list) ? list.map(this.elementActivator) : this.elementActivator(list)
+    }
+    this.list = this.valueActivator ? this.valueActivator(list) : list
+    this.fireObservers('set', list)
+    for(const [object, property] of this.properties) {
+      object[property] = this.list
+    }
+  }
+
+  push(value) {
+    if(this.elementActivator) value = this.elementActivator(value)
+    this.list.push(value)
+    this.fireObservers('push', value)
+  }
+  unshift(value) {
+    if(this.elementActivator) value = this.elementActivator(value)
+    this.list.unshift(value)
+    this.fireObservers('unshift', value)
+  }
+  pop() {
+    if(this.elementDispose) this.elementDispose(this.list[this.list.length - 1])
+    this.list.pop()
+    this.fireObservers('pop')
+  }
+  shift() {
+    if(this.elementDispose) this.elementDispose(this.list[0])
+    this.list.shift()
+    this.fireObservers('shift')
+  }
+  splice(at, del, ...values) {
+    const removed = this.list.splice(at, del, ...values)
+    if(this.elementDispose) for(const disposed of removed) this.elementDispose(dispose)
+    this.fireObservers('splice', at, del, ...values)
+  }
+  putByField(field, value, element, reverse = false, oldElement) {
+    if(this.elementActivator) element = this.elementActivator(element)
+    if(!reverse) {
+      let i, l
+      for(i = 0, l = this.list.length; i < l; i++) {
+        if(this.list[i][field] == value) {
+          oldElement = this.list[i]
+          if(this.elementDispose) this.elementDispose(oldElement)
+          this.list.splice(i, 1, element)
+          break
+        } else if(this.list[i][field] > value) {
+          this.list.splice(i, 0, element)
+          break
+        }
+      }
+      if(i == l) this.list.push(element)
+    } else {
+      let i
+      for(i = this.list.length-1; i >= 0; i--) {
+        if(this.list[i][field] == value) {
+          oldElement = this.list[i]
+          if(this.elementDispose) this.elementDispose(oldElement)
+          this.list.splice(i, 1, element)
+          break
+        } else if(this.list[i][field] > value) {
+          this.list.splice(i + 1, 0, element)
+          break
+        }
+      }
+      if(i < 0) this.list.splice(0, 0, element)
+    }
+    this.fireObservers('putByField', field, value, element, reverse, oldElement)
+  }
+  remove(exact) {
+    let json = JSON.stringify(exact)
+    for(let i = 0, l = this.list.length; i < l; i++) {
+      if(JSON.stringify(this.list[i]) == json) {
+        if(this.elementDispose) this.elementDispose(this.list[i])
+        this.list.splice(i, 1)
+      }
+    }
+    this.fireObservers('remove', exact)
+  }
+  removeByField(field, value, oldElement) {
+    let json = JSON.stringify(value)
+    for(let i = 0, l = this.list.length; i < l; i++) {
+      if(JSON.stringify(this.list[i][field]) == json) {
+        oldElement = this.list[i]
+        if(this.elementDispose) this.elementDispose(oldElement)
+        this.list.splice(i, 1)
+        i--
+        l--
+      }
+    }
+    this.fireObservers('removeByField', field, value, oldElement)
+  }
+  removeBy(fields) {
+    let jsonf = []
+    for(var k in fields) {
+      jsonf.push([k, JSON.stringify(fields[k])])
+    }
+    for(let i = 0, l = this.list.length; i < l; i++) {
+      let found = true
+      for(let [key, json] of jsonf) {
+        found = found && (JSON.stringify(this.list[i][key]) == json)
+      }
+      if(found) {
+        if(this.elementDispose) this.elementDispose(this.list[i])
+        this.list.splice(i, 1)
+        i--
+        l--
+      }
+    }
+    this.fireObservers('removeBy', fields)
+  }
+
+  update(exact, element) {
+    let json = JSON.stringify(exact)
+    for(let i = 0, l = this.list.length; i < l; i++) {
+      if(JSON.stringify(this.list[i]) == json) {
+        if(this.elementDispose) this.elementDispose(this.list[i])
+        if(this.elementActivator) element = this.elementActivator(element)
+        this.list.splice(i, 1, element)
+      }
+    }
+    this.fireObservers('update', exact, element)
+  }
+  updateByField(field, value, element) {
+    let json = JSON.stringify(value)
+    for(let i = 0, l = this.list.length; i < l; i++) {
+      if(JSON.stringify(this.list[i][field]) == json) {
+        if(this.elementDispose) this.elementDispose(this.list[i])
+        if(this.elementActivator) element = this.elementActivator(element)
+        this.list.splice(i, 1, element)
+      }
+    }
+    this.fireObservers('updateByField', field, value, element)
+  }
+  updateBy(fields, element) {
+    let jsonf = []
+    for(const k in fields) {
+      jsonf.push([k, JSON.stringify(fields[k])])
+    }
+    for(let i = 0, l = this.list.length; i < l; i++) {
+      let found = true
+      for(let [key, json] of jsonf) {
+        found = found && (JSON.stringify(this.list[i][key]) == json)
+      }
+      if(found) {
+        if(this.elementDispose) this.elementDispose(this.list[i])
+        if(this.elementActivator) element = this.elementActivator(element)
+        this.list.splice(i, 1, element)
+      }
+    }
+    this.fireObservers('updateBy', fields, element)
+  }
+
+}
+
+module.exports = ExtendedObservableList

package/lib/Observable.js

@@ -90,21 +90,22 @@ class Observable {
 
   wait() {
     let finished = false
-    const resultObserver = (signal) => {
-      finished = true
-      this.unobserve(resultObserver)
-      this.uncatch(errorObserver)
-      resolve(signal)
-    }
-    const errorObserver = (error) => {
-      finished = true
-      this.unobserve(resultObserver)
-      this.uncatch(errorObserver)
-      reject(error)
-    }
-    const waitPromise = Promise((resolve, reject) => {
-      if(!finished) this.observe(resultObserver)
+
+    const waitPromise = new Promise((resolve, reject) => {
+      const resultObserver = (signal) => {
+        finished = true
+        this.unobserve(resultObserver)
+        this.uncatch(errorObserver)
+        resolve(signal)
+      }
+      const errorObserver = (error) => {
+        finished = true
+        this.unobserve(resultObserver)
+        this.uncatch(errorObserver)
+        reject(error)
+      }
       if(!finished) this.catch(errorObserver)
+      if(!finished) this.observe(resultObserver)
     })
     waitPromise.cancel = () => {
       finished = true

package/lib/ObservableProxy.js

@@ -15,6 +15,7 @@ class ObservableProxy extends Observable {
   }
 
   setTarget(observable) {
+    if(this === observable) throw new Error('infinite loop')
     if(!this.disposed && this.observable) {
       this.observable.unobserve(this.observer)
       for(let [object, property] of this.properties) {
@@ -80,8 +81,8 @@ class ObservableProxy extends Observable {
   unbindProperty(object, property) {
     for(var i = 0; i < this.properties.length; i++) {
       var prop = this.properties[i]
-      if(prop[0] == object && prop[1] == property) {
-        this.properties.splice(i,1)
+      if(prop[0] === object && prop[1] === property) {
+        this.properties.splice(i, 1)
         if(this.observable) this.observable.unbindProperty(object, property)
         if(this.isUseless()) this.dispose()
         return

package/lib/Path.js

@@ -35,16 +35,16 @@ function resolve(schema) {
 }
 
 class Path {
-  constructor(what, more = undefined) {
+  constructor(what, more = undefined, to = undefined) {
     this.what = what
     this.more = more
+    this.to = to
   }
   with(...funcs) {
     let newMore = this.more ? this.more.slice() : []
     for(const func of funcs) {
       const source = sourceProxy()
       const fetchObject = func(source)
-      const what = fetchObject.what
       const path = fetchObject.what.slice(0, -1)
       const params = fetchObject.what[fetchObject.what.length - 1]
       let processedParams = {}
@@ -57,7 +57,8 @@ class Path {
       }
       const more = {
         schema: [[...path, { object: processedParams }]],
-        more: fetchObject.more
+        more: fetchObject.more,
+        to: fetchObject.to
       }
       newMore.push(more)
     }
@@ -71,6 +72,10 @@ class Path {
       schema: resolve(outputObject)
     }
   }
+
+  bind(to) {
+    return new Path(this.what, this.more, to)
+  }
 }
 
 module.exports = Path

package/lib/collectPointers.js

@@ -1,8 +1,14 @@
 function flatMap(source, fun) {
   let results = source.map(fun)
   let count = 0
-  for(let result of results) count += result.length
+  let many = source.many
+  for(let result of results) {
+    count += result.length
+    many = many || result.many
+  }
+  if(count > 1 && !many) throw new Error("too many results from not many")
   let out = new Array(count)
+  out.many = many
   let p = 0
   for(let result of results) {
     for(let element of result) out[p++] = element
@@ -12,12 +18,12 @@ function flatMap(source, fun) {
 
 function getPropertyValues(source, property) {
   if(Array.isArray(source)) {
-    return flatMap(source, v => getPropertyValues(v, property))
+    return flatMap(markMany(source), v => getPropertyValues(v, property))
   } else {
     if(source === undefined) return []
     if(source === null) return []
     let v = source[property]
-    if(Array.isArray(v)) return v
+    if(Array.isArray(v)) return markMany(v)
     if(v === undefined) return []
     return [v]
   }
@@ -31,10 +37,22 @@ function getNestedPropertyValues(source, property) {
   return accumulator
 }
 
+function markMany(arr) {
+  arr = arr.slice()
+  arr.many = true
+  return arr
+}
+
 function cross(lists) {
   let count = 1
-  for(let list of lists) count *= list.length
+  let many = false
+  for(let list of lists) {
+    count *= list.length
+    many = many || list.many
+  }
   let out = new Array(count)
+  out.many = many
+  if(count > 1 && !many) throw new Error("more than one result for non array fields")
   for(let i = 0; i < count; i++) {
     let res = new Array(lists.length)
     let a = i
@@ -68,10 +86,13 @@ function collect(source, schema, getSource) {
         return results
       })
     } else if(schema.nonEmpty) {
-      return collect(source, schema.nonEmpty, getSource).filter(x=>!!x)
+      const collected = collect(source, schema.nonEmpty, getSource)
+      const result = collected.filter(x=>!!x)
+      result.many = collected.many
+      return result
     } else if(schema.identity) {
       if(typeof source == 'undefined' || source === null) return []
-      return Array.isArray(source) ? source : [source]
+      return Array.isArray(source) ? markMany(source) : [source]
     } else if(schema.array) {
       return [ collect(source, schema.array, getSource) ]
     } else if(schema.property) {
@@ -112,6 +133,7 @@ function collect(source, schema, getSource) {
         }
         results[i] = result
       }
+      results.many = crossed.many
       return results
     }
   }
@@ -120,9 +142,12 @@ function collect(source, schema, getSource) {
 function collectPointers(source, schemas, getSource) {
   let results = []
   for(let schema of schemas) {
-    results = results.concat(collect(source, schema, getSource))
+    const collected = collect(source, schema, getSource)
+    const many = results.many || collected.many
+    results = results.concat(collected)
+    results.many = many
   }
   return results
 }
 
-module.exports = collectPointers
+module.exports = collectPointers

package/package.json

@@ -36,5 +36,5 @@
   "scripts": {
     "test": "NODE_ENV=test blue-tape tests/*"
   },
-  "version": "0.3.5"
+  "version": "0.3.9"
 }

package/tests/pointers-collector.js

@@ -5,43 +5,47 @@ test("pointers collector", (t) => {
   t.plan(14)
 
   t.test("simple property", (t) => {
-    t.plan(1)
+    t.plan(2)
     let pointers = ReactiveDao.collectPointers({
       user: "123"
     },[
       ["users", "User", { property: "user" }]
     ])
-    t.deepEqual(pointers, [["users","User","123"]], "found one user")
+    t.equal(!!pointers.many, false)
+    t.deepEqual(pointers.slice(), [["users","User","123"]], "found one user")
   })
 
   t.test("simple property from array", (t) => {
-    t.plan(1)
+    t.plan(2)
     let pointers = ReactiveDao.collectPointers([
       { user: "123" },
       { user: "233" }
     ],[
       ["users", "User", { property: "user" }]
     ])
-    t.deepEqual(pointers, [["users","User","123"], ["users","User","233"]], "found two users")
+    t.equal(!!pointers.many, true)
+    t.deepEqual(pointers.slice(), [["users","User","123"], ["users","User","233"]], "found two users")
   })
 
   t.test("identity pointers", (t) => {
-    t.plan(1)
+    t.plan(2)
     let pointers = ReactiveDao.collectPointers([ 0, 1, 2, 3 ], [
       [ 'test', 'user', { identity: true } ]
     ])
-    t.deepEqual(pointers, [ [ 'test', 'user', 0 ], [ 'test', 'user', 1 ], [ 'test', 'user', 2 ],
+    t.equal(!!pointers.many, true)
+    t.deepEqual(pointers.slice(), [ [ 'test', 'user', 0 ], [ 'test', 'user', 1 ], [ 'test', 'user', 2 ],
       [ 'test', 'user', 3 ] ])
   })
 
   t.test("array property tags", (t) => {
-    t.plan(1)
+    t.plan(2)
     let pointers = ReactiveDao.collectPointers({
       tags: ["1", "2", "3"]
     },[
       ["tags", "Tag", { property: "tags" }]
     ])
-    t.deepEqual(pointers, [
+    t.equal(!!pointers.many, true)
+    t.deepEqual(pointers.slice(), [
         ["tags","Tag","1"],
         ["tags","Tag","2"],
         ["tags","Tag","3"]
@@ -49,7 +53,7 @@ test("pointers collector", (t) => {
   })
 
   t.test("nested property", (t) => {
-    t.plan(1)
+    t.plan(2)
     let pointers = ReactiveDao.collectPointers({
       userData: {
         country: "PL"
@@ -57,7 +61,8 @@ test("pointers collector", (t) => {
     },[
       ["country", { property: ["userData", "country"] }]
     ])
-    t.deepEqual(pointers, [["country","PL"]], "found nested property value")
+    t.equal(!!pointers.many, false)
+    t.deepEqual(pointers.slice(), [["country","PL"]], "found nested property value")
   })
 
   t.test("object result", (t) => {
@@ -72,7 +77,7 @@ test("pointers collector", (t) => {
       } },
       { object: { path: ["tags", { property: "tags" }] } }
     ])
-    t.deepEqual(pointers, [
+    t.deepEqual(pointers.slice(), [
       { path: ["user", { user: "123" }], next: [[ "picture", { property: "picture" } ]] },
       { path: ["tags","1"] },
       { path: ["tags","2"] },
@@ -91,7 +96,7 @@ test("pointers collector", (t) => {
         { source: 'interests', schema: { array: { identity: true } }},
         { source: { static: 'city' }, schema: { property: "name" } }]
     ], (src) => sources[src])
-    t.deepEqual(pointers, [ [ 'findProjects', [ 'cats', 'dogs', 'birds' ], 'NY' ] ])
+    t.deepEqual(JSON.parse(JSON.stringify(pointers)), [ [ 'findProjects', [ 'cats', 'dogs', 'birds' ], 'NY' ] ])
   })
 
   t.test("undefined argument", (t) => {
@@ -99,7 +104,7 @@ test("pointers collector", (t) => {
     let pointers = ReactiveDao.collectPointers({ sessionId: 1 },[
       ["users", "User", { property: "user" }]
     ])
-    t.deepEqual(pointers, [])
+    t.deepEqual(pointers.slice(), [])
   })
 
   t.test("undefined argument in object", (t) => {
@@ -107,7 +112,7 @@ test("pointers collector", (t) => {
     let pointers = ReactiveDao.collectPointers({ sessionId: 1 },[
       ["users", "User", { object: { user: { property: "user" }}}]
     ])
-    t.deepEqual(pointers, [])
+    t.deepEqual(pointers.slice(), [])
   })
 
   t.test("switch match", (t) => {
@@ -120,7 +125,7 @@ test("pointers collector", (t) => {
           US: "New York"
         }}]
     ])
-    t.deepEqual(pointers, [["Warsaw"]], "switch working")
+    t.deepEqual(pointers.slice(), [["Warsaw"]], "switch working")
   })
 
   t.test("switch default", (t) => {
@@ -134,7 +139,7 @@ test("pointers collector", (t) => {
         },
         default: "London"}]
     ])
-    t.deepEqual(pointers, [["London"]], "switch working")
+    t.deepEqual(pointers.slice(), [["London"]], "switch working")
   })
 
   t.test("switch not match", (t) => {
@@ -147,7 +152,7 @@ test("pointers collector", (t) => {
           US: "New York"
         }}]
     ])
-    t.deepEqual(pointers, [], "switch working")
+    t.deepEqual(pointers.slice(), [], "switch working")
   })
 
   t.test("test nonEmpty", (t) => {
@@ -157,7 +162,7 @@ test("pointers collector", (t) => {
     },[
       ["users", "User", { nonEmpty: { property: "user" }}]
     ])
-    t.deepEqual(pointers, [], "nulls are filtered")
+    t.deepEqual(pointers.slice(), [], "nulls are filtered")
   })
 
   t.test("test complex property fetch", (t) => {
@@ -187,7 +192,7 @@ test("pointers collector", (t) => {
           category: { nonEmpty: { property: ['data', 'sidebarItems','category'] } }
       } }]
     ])
-    t.deepEqual(pointers, [
+    t.deepEqual(pointers.slice(), [
           [
             "categories",
             "CategoryOne",