Fixed #181 - deep caching

Author: theodorDiaconu

lib/links/config.schema.js

@@ -1,3 +1,16 @@
+export const CacheSchema = new SimpleSchema({
+    field: {type: String},
+    body: {
+        type: Object,
+        blackbox: true,
+    },
+    bypassSchema: {
+        type: Boolean,
+        defaultValue: false,
+        optional: true,
+    }
+});
+
 export default new SimpleSchema({
     type: {
         type: String,
@@ -39,6 +52,10 @@ export default new SimpleSchema({
         type: Boolean,
         defaultValue: false,
         optional: true
+    },
+    cache: {
+        type: CacheSchema,
+        optional: true,
     }
 });
 

lib/links/linker.js

@@ -3,8 +3,10 @@ import LinkManyMeta from './linkTypes/linkManyMeta.js';
 import LinkOne from './linkTypes/linkOne.js';
 import LinkOneMeta from './linkTypes/linkOneMeta.js';
 import LinkResolve from './linkTypes/linkResolve.js';
-import ConfigSchema from './config.schema.js';
+import ConfigSchema, {CacheSchema} from './config.schema.js';
 import smartArguments from './linkTypes/lib/smartArguments';
+import dot from 'dot-object';
+import {_} from 'meteor/underscore';
 
 export default class Linker {
     /**
@@ -22,9 +24,8 @@ export default class Linker {
         this._extendSchema();
 
         // initialize cascade removal hooks.
-        if (linkConfig.autoremove) {
-            this._initAutoremove();
-        }
+        this._initAutoremove();
+        this._initCache();
 
         if (this.isVirtual()) {
             // if it's a virtual field make sure that when this is deleted, it will be removed from the references
@@ -355,6 +356,10 @@ export default class Linker {
     }
 
     _initAutoremove() {
+        if (!this.linkConfig.autoremove) {
+            return;
+        }
+
         if (!this.isVirtual()) {
             this.mainCollection.after.remove((userId, doc) => {
                 this.getLinkedCollection().remove({
@@ -374,4 +379,77 @@ export default class Linker {
             })
         }
     }
+
+    _initCache() {
+        if (!this.linkConfig.cache || !Meteor.isServer) {
+            return;
+        }
+
+        CacheSchema.validate(this.linkConfig.cache);
+
+        const packageExists = !!Package['herteby:denormalize'];
+        if (!packageExists) {
+            throw new Meteor.Error('missing-package', `Please add the herteby:denormalize package to your Meteor application in order to make caching work`)
+        }
+
+        const {field, body, bypassSchema} = this.linkConfig.cache;
+        let cacheConfig;
+
+        let referenceFieldSuffix = '';
+        if (this.isMeta()) {
+            referenceFieldSuffix = (this.isSingle() ? '._id' : ':_id');
+        }
+
+        if (this.isVirtual()) {
+            let inversedLink = this.linkConfig.relatedLinker.linkConfig;
+
+            let type = inversedLink.type == 'many' ? 'many-inverse' : 'inversed';
+
+            cacheConfig = {
+                type: type,
+                collection: this.linkConfig.collection,
+                fields: body,
+                referenceField: inversedLink.field + referenceFieldSuffix,
+                cacheField: field,
+                bypassSchema: !!bypassSchema
+            };
+        } else {
+            cacheConfig = {
+                type: this.linkConfig.type,
+                collection: this.linkConfig.collection,
+                fields: body,
+                referenceField: this.linkConfig.field + referenceFieldSuffix,
+                cacheField: field,
+                bypassSchema: !!bypassSchema
+            };
+        }
+
+        this.mainCollection.cache(cacheConfig);
+    }
+
+    /**
+     * Verifies if this linker is cached. It can be cached from the inverse side as well.
+     *
+     * @returns {boolean}
+     * @private
+     */
+    isCached() {
+        return !!this.linkConfig.cache;
+    }
+
+    /**
+     * Verifies if the body of the linked element does not contain fields outside the cache body
+     *
+     * @param body
+     * @returns {boolean}
+     * @private
+     */
+    isSubBodyCache(body) {
+        const cacheBody = this.linkConfig.cache.body;
+
+        const cacheBodyFields = _.keys(dot.dot(cacheBody));
+        const bodyFields = _.keys(dot.dot(body));
+
+        return _.difference(bodyFields, cacheBodyFields).length === 0;
+    }
 }

lib/query/lib/createGraph.js

@@ -40,6 +40,20 @@ export function createNodes(root) {
         let linker = root.collection.getLinker(fieldName);
 
         if (linker) {
+            // check if it is a cached link
+            // if yes, then we need to explicitly define this at collection level
+            // so when we transform the data for delivery, we move it to the link name
+            if (linker.isCached()) {
+                if (linker.isSubBodyCache(body)) {
+                    const cacheField = linker.linkConfig.cache.field;
+
+                    root.snapCache(cacheField, fieldName);
+                    addFieldNode(body, cacheField, root);
+                    
+                    return;
+                }
+            }
+
             let subroot = new CollectionNode(linker.getLinkedCollection(), body, fieldName);
             root.add(subroot, linker);
 

lib/query/lib/prepareForDelivery.js

@@ -8,6 +8,7 @@ import sift from 'sift';
 import {Minimongo} from 'meteor/minimongo';
 
 export default (node) => {
+    snapBackCaches(node);
     applyReducers(node);
     cleanReducerLeftovers(node);
     applyPostFilters(node);
@@ -169,6 +170,30 @@ function storeMetadata(element, parentElement, storage, isVirtual) {
     }
 }
 
+function snapBackCaches(node) {
+    node.collectionNodes.forEach(collectionNode => {
+        snapBackCaches(collectionNode);
+    });
+
+    if (!_.isEmpty(node.snapCaches)) {
+        // process stuff
+        _.each(node.snapCaches, (linkName, cacheField) => {
+            const isSingle = _.contains(node.snapCachesSingles, cacheField);
+            node.results.forEach(result => {
+                if (result[cacheField]) {
+                    if (isSingle && _.isArray(result[cacheField])) {
+                        result[linkName] = _.first(result[cacheField]);
+                    } else {
+                        result[linkName] = result[cacheField];
+                    }
+
+                    delete result[cacheField];
+                }
+            })
+        })
+    }
+}
+
 // /**
 //  * @param elements
 //  * @param storage

lib/query/nodes/collectionNode.js

@@ -20,6 +20,8 @@ export default class CollectionNode {
         this.scheduledForDeletion = false;
         this.reducers = [];
         this.results = [];
+        this.snapCaches = {}; // {cacheField: linkName}
+        this.snapCachesSingles = []; // [cacheField1, cacheField2]
     }
 
     get collectionNodes() {
@@ -168,6 +170,20 @@ export default class CollectionNode {
             : (this.collection ? this.collection._name : 'N/A');
     }
 
+    /**
+     * This is used for caching links
+     *
+     * @param cacheField
+     * @param subLinkName
+     */
+    snapCache(cacheField, subLinkName) {
+        this.snapCaches[cacheField] = subLinkName;
+
+        if (this.collection.getLinker(subLinkName).isOneResult()) {
+            this.snapCachesSingles.push(cacheField);
+        }
+    }
+
     /**
      * This method verifies whether to remove the linkStorageField form the results
      * unless you specify it in your query.

lib/query/testing/link-cache/collections.js

@@ -0,0 +1,117 @@
+import {Mongo} from 'meteor/mongo';
+
+export const Authors = new Mongo.Collection('cache_authors');
+export const AuthorProfiles = new Mongo.Collection('cache_author_profiles');
+export const Posts = new Mongo.Collection('cache_posts');
+export const Groups = new Mongo.Collection('cache_groups');
+export const Categories = new Mongo.Collection('cache_categories');
+
+Authors.remove({});
+AuthorProfiles.remove({});
+Posts.remove({});
+Groups.remove({});
+Categories.remove({});
+
+Posts.addLinks({
+    author: {
+        type: 'one',
+        collection: Authors,
+        field: 'authorId',
+        cache: {
+            field: 'authorCache',
+            body: {
+                name: 1,
+                address: 1,
+            }
+        }
+    },
+    categories: {
+        type: 'many',
+        metadata: true,
+        collection: Categories,
+        field: 'categoryIds',
+        cache: {
+            field: 'categoriesCache',
+            body: {
+                name: 1,
+            }
+        }
+    }
+});
+
+Authors.addLinks({
+    posts: {
+        collection: Posts,
+        inversedBy: 'author',
+        cache: {
+            field: 'postCache',
+            body: {
+                title: 1,
+            }
+        }
+    },
+    groups: {
+        type: 'many',
+        collection: Groups,
+        field: 'groupIds',
+        cache: {
+            field: 'groupsCache',
+            body: {
+                name: 1,
+            }
+        }
+    },
+    profile: {
+        type: 'one',
+        metadata: true,
+        collection: AuthorProfiles,
+        field: 'profileId',
+        unique: true,
+        cache: {
+            field: 'profileCache',
+            body: {
+                name: 1,
+            }
+        }
+    }
+});
+
+AuthorProfiles.addLinks({
+    author: {
+        collection: Authors,
+        inversedBy: 'profile',
+        unique: true,
+        cache: {
+            field: 'authorCache',
+            body: {
+                name: 1,
+            }
+        }
+    }
+});
+
+Groups.addLinks({
+    authors: {
+        collection: Authors,
+        inversedBy: 'groups',
+        cache: {
+            field: 'authorsCache',
+            body: {
+                name: 1,
+            }
+        }
+    }
+});
+
+Categories.addLinks({
+    posts: {
+        collection: Posts,
+        inversedBy: 'categories',
+        cache: {
+            field: 'postsCache',
+            body: {
+                title: 1,
+            }
+        }
+    }
+});