fix: various fixes to new rewrite

Author: paralin

PROTOCOL.md renamed to docs/DESIGN_GENERAL_NOTES.md

@@ -1,5 +1,4 @@
-Protocol
-========
+# Query-Tree Negotiation
 
 When we initially connect to the server, we build a snapshot of the tree and send it to the server. Following, every update to the tree gets transmitted to the server as queries are applied to the store.
 
@@ -124,3 +123,44 @@ query myQuery($a: Int!) {
 ```
 
 The server can be given variable values at the same time as query tree additions. However, the server will forget any variables that aren't relevant to the current query. This way the server keeps only the data it needs in memory with minimal messaging overhead and de-duplicated variable values.
+
+# Distributing data to queries efficiently
+
+Issue: we have a result tree that looks like:
+
+```
+0: {
+  1: {
+    2: "John",
+    3: "Doe",
+    4: 28
+    5: [153, 148, 140, 133]
+  }
+}
+```
+
+The array in qnode 5 needs to be shared between the queries. We can detect when we have reached a leaf when there are no child query nodes.
+
+Here we have the issue. Cursors often extend into the values, past the qnode child leaves. We need to detach the cursors in the queries when reaching a value node.
+
+ - Cursors will need to build a "path so far" array (unfortunately).
+   - This is necessary for caching.
+   - Array of tuples, with `[Kind, (ArrayIndex/QueryNodeID), ValueKind]`
+   - Examples (note that "value" in these points to location, is not a copy):
+     - `ResultTree: {1: {2: [6123, 1523]}}`
+       - Sequence:
+       - `[Kind.QNodeID, 1, ValueKind.Object]`
+       - `[Kind.QNodeID, 2, ValueKind.Value, [6123, 1623]]`
+     - `ResultTree: {1: [{2: "test"}, {2: "what"}]}`
+       - Sequence:
+       - `[Kind.QNodeID, 1, ValueKind.Array]`
+       - `[Kind.ArrayIndex, 0, ValueKind.Object]`
+   - When reaching a value, drop the path so far and result tree.
+ - Allow passing a map of query ID -> location pointers to a result tree cursor.
+ - When adding a new query:
+   - Iterate `DFS` over the current known result tree, applying values to the result.
+   - Iterate over all known cursors, and add query by:
+     - If the path sequence terminates in a Value then ignore cursor.
+     - Iterate over path sequence, updating location.
+ - When removing a query:
+   - Iterate over all known cursors, remove query ID from map.

package.json

@@ -11,9 +11,9 @@
   },
   "dependencies": {
     "graphql": "^0.9.0",
-    "lodash": "^4.17.0",
-    "lru_map": "^0.3.3",
-    "rgraphql": "^0.3.0",
+    "lodash": "^4.0.0",
+    "lru_map": "^0.3.0",
+    "rgraphql": "^0.4.0",
     "rxjs": "^5.0.0"
   },
   "scripts": {

src/query-tree/query-tree.ts

@@ -63,6 +63,7 @@ export class QueryTreeNode {
 
   public rootNodeMap?: { [id: number]: QueryTreeNode } = {};
   public variableStore?: VariableStore;
+  public rootDisposeSubject?: Subject<QueryTreeNode>;
 
   // If this query node is invalid, we will emit an error.
   // This is closed when we dispose this query tree node.
@@ -118,6 +119,7 @@ export class QueryTreeNode {
       this.variableStore.newVariables.subscribe((nvar: Variable) => {
         this.newVariables.push(nvar);
       });
+      this.rootDisposeSubject = new Subject<QueryTreeNode>();
     }
   }
 
@@ -372,6 +374,7 @@ export class QueryTreeNode {
   }
 
   public garbageCollect(): boolean {
+    let keepThis = Object.keys(this.queries).length > 0;
     if (this.gcNext) {
       this.gcNext = false;
       // let ir = this.isRoot;
@@ -381,13 +384,16 @@ export class QueryTreeNode {
         if (keep) {
           nchildren.push(<any>child);
         } else {
+          if (keepThis) {
+            this.root.rootDisposeSubject.next(child);
+          }
           child.dispose();
         }
       }
       this.children = nchildren;
     }
 
-    return Object.keys(this.queries).length > 0;
+    return keepThis;
   }
 
   public propagateGcNext() {

src/result/result-tree.spec.ts

@@ -18,12 +18,18 @@ import {
   Query,
 } from '../query-tree/query';
 
+function parseQuery(query: string): any {
+  return parse(`query { ${query} }`).definitions[0];
+}
+
 describe('ResultTreeCursor', () => {
   it('should handle a root-level object value', () => {
     let root = {};
     let cursor = new ResultTreeCursor();
     cursor.path = [];
     cursor.resultLocations = {0: [root, (id) => {}]};
+    cursor.queryNode = new QueryTreeNode();
+    cursor.queryNode.buildQuery(parseQuery(`people { age }`), {});
     cursor.apply({queryNodeId: 1});
     cursor.apply({queryNodeId: 2, value: {intValue: 1, kind: Kind.PRIMITIVE_KIND_INT}});
     expect(root).toEqual({1: {2: 1}});
@@ -32,6 +38,8 @@ describe('ResultTreeCursor', () => {
     let root = {};
     let cursor = new ResultTreeCursor();
     cursor.path = [];
+    cursor.queryNode = new QueryTreeNode();
+    cursor.queryNode.buildQuery(parseQuery(`distances`), {});
     cursor.resultLocations = {0: [root, (id) => {}]};
     cursor.apply({queryNodeId: 1});
     cursor.apply({arrayIndex: 1, value: {intValue: 1, kind: Kind.PRIMITIVE_KIND_INT}});
@@ -41,6 +49,8 @@ describe('ResultTreeCursor', () => {
     let root = {};
     let cursor = new ResultTreeCursor();
     cursor.path = [];
+    cursor.queryNode = new QueryTreeNode();
+    cursor.queryNode.buildQuery(parseQuery(`people { name, age }`), {});
     cursor.resultLocations = {0: [root, (id) => {}]};
     cursor.apply({queryNodeId: 1});
     cursor.apply({arrayIndex: 1}); // checkpoint here.
@@ -57,6 +67,8 @@ describe('ResultTreeCursor', () => {
     let root = {};
     let cursor = new ResultTreeCursor();
     cursor.path = [];
+    cursor.queryNode = new QueryTreeNode();
+    cursor.queryNode.buildQuery(parseQuery(`ages`), {});
     cursor.resultLocations = {0: [root, (id) => {}]};
     cursor.apply({queryNodeId: 1});
     cursor.apply({arrayIndex: 1, value: {kind: Kind.PRIMITIVE_KIND_INT, intValue: 5}});
@@ -70,32 +82,30 @@ describe('ResultTreeCursor', () => {
 });
 
 describe('ResultTree', () => {
-  it('should handle a complex object', () => {
+  it('should handle a complex object', (done) => {
     let qt = new QueryTreeNode();
-    let q: Query = qt.buildQuery(<any>parse(`
-query {
-  allPeople {
-    name
-    age
-    parents
-  }
-}
-                        `).definitions[0], {});
+    let q: Query = qt.buildQuery(parseQuery(`allPeople { name, age, parents, favoriteMonths }`), {});
     let rt = new ResultTree(0, qt, CacheStrategy.CACHE_LRU, 2);
     let qres = rt.addQuery(q.id, (id) => {});
     let segments: IRGQLValue[] = [
       {queryNodeId: 1},
-      {arrayIndex: 1},
+      {arrayIndex: 1, posIdentifier: 1},
+      {queryNodeId: 2, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Jane'}},
+      {queryNodeId: 5, posIdentifier: 1},
+      {arrayIndex: 2, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'March'}},
+      {queryNodeId: 3, posIdentifier: 1, value: {kind: Kind.PRIMITIVE_KIND_INT, intValue: 5}},
+      {queryNodeId: 5, posIdentifier: 1},
+      {arrayIndex: 1, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'January'}},
+      {queryNodeId: 5, posIdentifier: 1},
+      {arrayIndex: 4, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'December'}},
+      {queryNodeId: 5, posIdentifier: 1},
+      {arrayIndex: 3, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'August'}},
       {queryNodeId: 4, posIdentifier: 1},
       {arrayIndex: 3, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Parent3'}},
-      {posIdentifier: 1, arrayIndex: 1, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Parent1'}},
-      {posIdentifier: 1, arrayIndex: 2, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Parent2'}},
-      {queryNodeId: 1},
-      {arrayIndex: 1},
-      {queryNodeId: 3, value: {kind: Kind.PRIMITIVE_KIND_INT, intValue: 5}},
-      {queryNodeId: 1},
-      {arrayIndex: 1},
-      {queryNodeId: 2, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Jane'}},
+      {queryNodeId: 4, posIdentifier: 1},
+      {arrayIndex: 1, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Parent1'}},
+      {queryNodeId: 4, posIdentifier: 1},
+      {arrayIndex: 2, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Parent2'}},
     ];
 
     for (let seg of segments) {
@@ -107,17 +117,20 @@ query {
         2: 'Jane',
         3: 5,
         4: ['Parent1', 'Parent2', 'Parent3'],
+        5: ['January', 'March', 'August', 'December'],
       }],
     });
     expect(qres).toEqual({
       'allPeople': [{
         'name': 'Jane',
         'age': 5,
         'parents': ['Parent1', 'Parent2', 'Parent3'],
+        'favoriteMonths': ['January', 'March', 'August', 'December'],
       }],
     });
 
     // Attempt to build a second query to read the cache.
+    let qorig = q;
     q = qt.buildQuery(<any>parse(`
 query {
   allPeople {
@@ -131,5 +144,30 @@ query {
         'parents': ['Parent1', 'Parent2', 'Parent3'],
       }],
     });
+
+    rt.handleSegment({queryNodeId: 4, posIdentifier: 1});
+    rt.handleSegment({arrayIndex: 4, value: {kind: Kind.PRIMITIVE_KIND_STRING, stringValue: 'Parent4'}});
+
+    expect(qres).toEqual({
+      'allPeople': [{
+        'parents': ['Parent1', 'Parent2', 'Parent3', 'Parent4'],
+      }],
+    });
+
+    // Remove the original query
+    qorig.unsubscribe();
+
+    // Force immediate gc
+    qt.garbageCollect();
+
+    // Make sure the data was removed from the tree
+    setTimeout(() => {
+      expect(rt.result).toEqual({
+        1: [{
+          4: ['Parent1', 'Parent2', 'Parent3', 'Parent4'],
+        }],
+      });
+      done();
+    }, 300);
   });
 });