EagerLoading

Author: phortx

README.md

@@ -78,6 +78,31 @@ CRUD | Vuex Only | Persist to GraphQL API
 **D**ELETE | dispatch('delete') | dispatch('destroy')
 
 
+## Eager Loading
+
+All `belongsTo` related entities are eager loaded when fetch is called. All other related entities have to be added
+to a static field in the model called `eagerLoad` to have them eagerly loaded with fetch.
+
+Example:
+
+```javascript
+class User extends Model {
+  static entity = 'users';
+  static eagerLoad = ['posts'];
+
+  static fields () {
+    return {
+      id: this.attr(null),
+      name: this.attr(''),
+      
+      posts: this.hasMany(Post, 'userId')
+    }
+  }
+}
+```
+
+
+
 ## Schema expectations
 
 This plugin has an opinion how the GraphQL API schema should look like:

dist/vuex-orm-apollo.esm.js

@@ -7980,8 +7980,8 @@ var QueryBuilder = /** @class */ (function () {
     /**
      *
      * @param {Model} model
-     * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations). Mainly for recursion
-     * @returns {Array<String>}
+     * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations).
+     * @returns {string}
      */
     QueryBuilder.prototype.buildRelationsQuery = function (model, ignoreModels) {
         var _this = this;
@@ -7990,12 +7990,29 @@ var QueryBuilder = /** @class */ (function () {
             return '';
         var relationQueries = [];
         model.getRelations().forEach(function (field, name) {
-            if (!_this.shouldModelBeIgnored(_this.getModel(name), ignoreModels)) {
+            var relatedModel = _this.getModel(name);
+            if (_this.shouldEagerLoadRelation(model, field, relatedModel) &&
+                !_this.shouldModelBeIgnored(relatedModel, ignoreModels)) {
                 var multiple = field.constructor.name !== 'BelongsTo';
-                relationQueries.push(_this.buildField(name, multiple, undefined, ignoreModels));
+                relationQueries.push(_this.buildField(relatedModel, multiple, undefined, ignoreModels));
             }
         });
-        return relationQueries;
+        return relationQueries.join('\n');
+    };
+    /**
+     * Determines if we should eager load (means: add a query field) a related entity. belongsTo related entities
+     * are always eager loaded. Others can be added to the eagerLoad array of the model.
+     *
+     * @param {Model} model The base model
+     * @param {Field} field Relation field
+     * @param {Model} relatedModel Related model
+     * @returns {boolean}
+     */
+    QueryBuilder.prototype.shouldEagerLoadRelation = function (model, field, relatedModel) {
+        if (field.constructor.name === 'BelongsTo')
+            return true;
+        var eagerLoadList = model.baseModel.eagerLoad || [];
+        return eagerLoadList.find(function (n) { return n === relatedModel.singularName || n === relatedModel.pluralName; }) !== undefined;
     };
     QueryBuilder.prototype.shouldModelBeIgnored = function (model, ignoreModels) {
         return ignoreModels.find(function (m) { return m.singularName === model.singularName; }) !== undefined;
@@ -8236,7 +8253,7 @@ var VuexORMApollo = /** @class */ (function () {
                 name = args['mutation'];
                 delete args['mutation'];
                 model = this.getModel(state.$name);
-                return [2 /*return*/, this.mutate(name, args, dispatch, model)];
+                return [2 /*return*/, this.mutate(name, args, dispatch, model, false)];
             });
         });
     };

src/interfaces.ts

@@ -28,6 +28,7 @@ export interface Arguments extends Object {
 
 export interface ORMModel {
   entity: string;
+  eagerLoad: undefined | Array<string>;
 
   fields (): any;
   dispatch (name: string, ...params: Array<any>): any;

src/queryBuilder.ts

@@ -267,25 +267,43 @@ export default class QueryBuilder {
   /**
    *
    * @param {Model} model
-   * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations). Mainly for recursion
-   * @returns {Array<String>}
+   * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations).
+   * @returns {string}
    */
-  private buildRelationsQuery (model: (null | Model), ignoreModels: Array<Model> = []) {
+  private buildRelationsQuery (model: (null | Model), ignoreModels: Array<Model> = []): string {
     if (model === null) return '';
 
     const relationQueries: Array<string> = [];
 
     model.getRelations().forEach((field: Field, name: string) => {
-      if (!this.shouldModelBeIgnored(this.getModel(name), ignoreModels)) {
+      const relatedModel: Model = this.getModel(name);
+
+      if (this.shouldEagerLoadRelation(model, field, relatedModel) &&
+          !this.shouldModelBeIgnored(relatedModel, ignoreModels)) {
         const multiple: boolean = field.constructor.name !== 'BelongsTo';
-        relationQueries.push(this.buildField(name, multiple, undefined, ignoreModels));
+        relationQueries.push(this.buildField(relatedModel, multiple, undefined, ignoreModels));
       }
     });
 
-    return relationQueries;
+    return relationQueries.join('\n');
+  }
+
+  /**
+   * Determines if we should eager load (means: add a query field) a related entity. belongsTo related entities
+   * are always eager loaded. Others can be added to the eagerLoad array of the model.
+   *
+   * @param {Model} model The base model
+   * @param {Field} field Relation field
+   * @param {Model} relatedModel Related model
+   * @returns {boolean}
+   */
+  private shouldEagerLoadRelation (model: Model, field: Field, relatedModel: Model): boolean {
+    if (field.constructor.name === 'BelongsTo') return true;
+    const eagerLoadList: Array<String> = model.baseModel.eagerLoad || [];
+    return eagerLoadList.find((n) => n === relatedModel.singularName || n === relatedModel.pluralName) !== undefined;
   }
 
-  private shouldModelBeIgnored (model: Model, ignoreModels: Array<Model>) {
+  private shouldModelBeIgnored (model: Model, ignoreModels: Array<Model>): boolean {
     return ignoreModels.find((m) => m.singularName === model.singularName) !== undefined;
   }
 }

src/vuex-orm-apollo.ts

@@ -157,7 +157,7 @@ export default class VuexORMApollo {
 
     const model = this.getModel(state.$name);
 
-    return this.mutate(name, args, dispatch, model);
+    return this.mutate(name, args, dispatch, model, false);
   }
 
   /**