@live-change/dao 0.4.6 → 0.4.9

package/lib/DaoProxy.js

@@ -57,7 +57,7 @@ class DaoProxy extends EventEmitter {
       const newObservable = this.observables.get(spath)
       if(newObservable && newObservable !== observable) {
         observable.observable = newObservable
-      } else if(observable.observable.isDisposed()) {
+      } else if(!observable.observable || observable.observable.isDisposed()) {
         if(this.dao) {
           observable.observable = this.dao.observable(what)
         } else {

package/lib/ObservableProxy.js

@@ -91,13 +91,17 @@ class ObservableProxy extends Observable {
   }
 
   bindProperty(object, property) {
-    if(this.isDisposed()) this.respawn()
+    if(this.isDisposed()) {
+      this.respawn()
+    }
     this.properties.push([object, property])
-    if(this.observable) this.observable.bindProperty(object, property)
+    if(this.observable) {
+      this.observable.bindProperty(object, property)
+    }
   }
   unbindProperty(object, property) {
-    for(var i = 0; i < this.properties.length; i++) {
-      var prop = this.properties[i]
+    for(let i = 0; i < this.properties.length; i++) {
+      const prop = this.properties[i]
       if(prop[0] === object && prop[1] === property) {
         this.properties.splice(i, 1)
         if(this.observable) this.observable.unbindProperty(object, property)

package/lib/Path.js

@@ -26,6 +26,7 @@ function resolve(schema) {
     return schema.map(resolve)
   }
   if(typeof schema == 'object') {
+    //console.log("RESOLVE", schema)
     if(schema.$toPath) return schema.$toPath()
     const out = {}
     for(const key in schema) out[key] = resolve(schema[key])
@@ -34,11 +35,24 @@ function resolve(schema) {
   return schema
 }
 
+function processParams(params) {
+  let processedParams = {}
+  for(const key in params) {
+    const param = params[key]
+    //console.log("PARAM", key, param)
+    const resolvedParam = resolve(param)
+    //console.log("RESOLVED PARAM", key, resolvedParam)
+    processedParams[key] = resolvedParam
+  }
+  return processedParams
+}
+
 class Path {
-  constructor(what, more = undefined, to = undefined) {
+  constructor(what, more = undefined, to = undefined, actions = undefined) {
     this.what = what
     this.more = more
     this.to = to
+    this.actions = actions
   }
   with(...funcs) {
     let newMore = this.more ? this.more.slice() : []
@@ -47,14 +61,7 @@ class Path {
       const fetchObject = func(source)
       const path = fetchObject.what.slice(0, -1)
       const params = fetchObject.what[fetchObject.what.length - 1]
-      let processedParams = {}
-      for(const key in params) {
-        const param = params[key]
-        //console.log("PARAM", key, param)
-        const resolvedParam = resolve(param)
-        //console.log("RESOLVED PARAM", key, resolvedParam)
-        processedParams[key] = resolvedParam
-      }
+      let processedParams = processParams(params)
       const more = {
         schema: [[...path, { object: processedParams }]],
         more: fetchObject.more,
@@ -62,7 +69,21 @@ class Path {
       }
       newMore.push(more)
     }
-    return new Path(this.what, newMore)
+    return new Path(this.what, newMore, this.to, this.actions)
+  }
+  action(paramsFunc) {
+    let newActions = this.actions ? this.actions.slice() : []
+    const source = sourceProxy()
+    const actionObject = paramsFunc(source)
+    const path = actionObject.slice(0, -1)
+    const params = actionObject[actionObject.length - 1]
+    let processedParams = processParams(params)
+    const action = {
+      path,
+      params: { object: processedParams }
+    }
+    newActions.push(action)
+    return new Path(this.what, this.more, this.to, newActions)
   }
   get(func) {
     const source = sourceProxy()
@@ -74,7 +95,7 @@ class Path {
   }
 
   bind(to) {
-    return new Path(this.what, this.more, to)
+    return new Path(this.what, this.more, to, this.actions)
   }
 }
 

package/package.json

@@ -13,7 +13,7 @@
     "url": "https://github.com/live-change/live-change-dao.git"
   },
   "dependencies": {
-    "debug": "^4.3.2"
+    "debug": "^4.3.4"
   },
   "description": "live data access object",
   "devDependencies": {
@@ -35,6 +35,6 @@
   "scripts": {
     "test": "NODE_ENV=test blue-tape tests/*"
   },
-  "version": "0.4.6",
-  "gitHead": "29c98c353b6f8cc902d3bf2f67cdfc47e313ef58"
+  "version": "0.4.9",
+  "gitHead": "ec7e7187e4d9c3888b399b6eebd672e6c992e1a0"
 }

package/tests/path.js

@@ -0,0 +1,60 @@
+const test = require('blue-tape')
+const testServerDao = require('./testServerDao.js')
+const { Path } = require("../index.js")
+
+const users = (params) => new Path(['users', params])
+const user = (params) => new Path(['user', params])
+const avatar = (params) => new Path(['avatar', params])
+const tasks = (params) => new Path(['tasks', params])
+const deleteTask = (params) => ['tasks', params]
+
+const clean = x => JSON.parse(JSON.stringify(x))
+
+test("Path", t => {
+  t.plan(4)
+
+  t.test("single user query", t => {
+    t.plan(1)
+    const path = user({ user: '123' })
+    t.deepEqual(clean(path), { what: [ 'user', { user: '123' } ] })
+  })
+
+  t.test("all users with avatars", t => {
+    t.plan(1)
+    const path = users({ }).with(u => avatar({ user: u.id }))
+    t.deepEqual(clean(path), {"what":["users",{}],"more":[{"schema":[["avatar",{"object":{"user":{"property":"id"}}}]]}]})
+  })
+
+  t.test("all tasks with authors and observers with avatars", t => {
+    t.plan(1)
+    const userWithAvatar = (id) => user({ user: id }).with(u => avatar({ id: u.id }))
+    const path = tasks({ })
+        .with(task => userWithAvatar(task.author))
+        .with(task => userWithAvatar(task.observers))
+    t.deepEqual(clean(path), { "what": [ "tasks",  {} ], "more": [
+        {
+          "schema": [["user", { "object": { "user": { "property": "author" } } } ]],
+          "more": [
+            { "schema": [["avatar", {"object": {"id": {"property": "id"}}}]] }
+          ]
+        },
+        {
+          "schema": [["user", {"object": {"user": {"property": "observers"}}}]],
+          "more": [
+              {"schema": [["avatar", {"object": {"id": {"property": "id"}}}]]}
+          ]
+        }
+      ]})
+  })
+
+  t.test("tasks with delete actions", t => {
+    t.plan(1)
+    const path = tasks({ }).action(task => deleteTask({ task: task.id }))
+    t.deepEqual(clean(path), {"what":["tasks",{}],"actions":[
+        {"path":["tasks"],"params":{"object":{"task":{"property":"id"}}}}
+      ]})
+  })
+
+})
+
+test.onFinish(() => process.exit(0))