Improvements

Author: phortx

README.md

@@ -97,6 +97,9 @@ You can see query examples in the [project wiki](https://github.com/vuex-orm/vue
 To test this plugin in your existing project, you can use `yarn link` functionality. Run `yarn link` in your local
 vuex-orm-apollo directory and run `yarn link @vuex-orm/plugin-apollo` in your project dir.
 
+Remember to run `yarn build` in your vuex-orm-apollo directory and then again `yarn link` in your project after you have
+made changes to the plugin code. You probably have also to restart your webpack server.
+
 
 ```bash
 $ yarn run build

dist/vuex-orm-apollo.esm.js

@@ -7791,21 +7791,22 @@ var QueryBuilder = /** @class */ (function () {
      * @param {Model|string} model The model to use
      * @param {boolean} multiple Determines whether plural/nodes syntax or singular syntax is used.
      * @param {Arguments} args The args that will be passed to the query field ( user(role: $role) )
-     * @param {Model} rootModel The model of the root query field. Used to avoid endless recursion
+     * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations). Mainly for recursion
      * @param {string} name Optional name of the field. If not provided, this will be the model name
      * @param {boolean} allowIdFields Optional. Determines if id fields will be ignored for the argument generation.
      *                                See buildArguments
      * @returns {string}
      *
      * @todo Do we need the allowIdFields param?
-     * @todo There could be a endless recursion even with rootModel correctly set. We should track an array of models here probably?
      */
-    QueryBuilder.prototype.buildField = function (model, multiple, args, rootModel, name, allowIdFields) {
+    QueryBuilder.prototype.buildField = function (model, multiple, args, ignoreModels, name, allowIdFields) {
         if (multiple === void 0) { multiple = true; }
+        if (ignoreModels === void 0) { ignoreModels = []; }
         if (allowIdFields === void 0) { allowIdFields = false; }
         model = this.getModel(model);
+        ignoreModels.push(model);
         var params = this.buildArguments(args, false, allowIdFields);
-        var fields = "\n      " + model.getQueryFields().join(' ') + "\n      " + this.buildRelationsQuery(model, rootModel) + "\n    ";
+        var fields = "\n      " + model.getQueryFields().join(' ') + "\n      " + this.buildRelationsQuery(model, ignoreModels) + "\n    ";
         if (multiple) {
             return "\n        " + (name ? name : model.pluralName) + params + " {\n          nodes {\n            " + fields + "\n          }\n        }\n      ";
         }
@@ -7842,7 +7843,7 @@ var QueryBuilder = /** @class */ (function () {
             name = (multiple ? model.pluralName : model.singularName);
         // build query
         var query = type + " " + upcaseFirstLetter(name) + this.buildArguments(args, true) + " {\n" +
-            ("  " + this.buildField(model, multiple, args, model, name, true) + "\n") +
+            ("  " + this.buildField(model, multiple, args, [], name, true) + "\n") +
             "}";
         return src(query);
     };
@@ -7979,28 +7980,33 @@ var QueryBuilder = /** @class */ (function () {
     /**
      *
      * @param {Model} model
-     * @param {Model} rootModel
+     * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations). Mainly for recursion
      * @returns {Array<String>}
      */
-    QueryBuilder.prototype.buildRelationsQuery = function (model, rootModel) {
+    QueryBuilder.prototype.buildRelationsQuery = function (model, ignoreModels) {
         var _this = this;
+        if (ignoreModels === void 0) { ignoreModels = []; }
         if (model === null)
             return '';
         var relationQueries = [];
         model.getRelations().forEach(function (field, name) {
-            if (!rootModel || (name !== rootModel.singularName && name !== rootModel.pluralName)) {
+            if (!_this.shouldModelBeIgnored(_this.getModel(name), ignoreModels)) {
                 var multiple = field.constructor.name !== 'BelongsTo';
-                relationQueries.push(_this.buildField(name, multiple, undefined, rootModel || model));
+                relationQueries.push(_this.buildField(name, multiple, undefined, ignoreModels));
             }
         });
         return relationQueries;
     };
+    QueryBuilder.prototype.shouldModelBeIgnored = function (model, ignoreModels) {
+        return ignoreModels.find(function (m) { return m.singularName === model.singularName; }) !== undefined;
+    };
     return QueryBuilder;
 }());
 
 var Logger = /** @class */ (function () {
     function Logger(enabled) {
         this.enabled = enabled;
+        this.log('Logging is enabled.');
     }
     Logger.prototype.group = function () {
         var messages = [];
@@ -8024,7 +8030,7 @@ var Logger = /** @class */ (function () {
             console.log.apply(console, ['[Vuex-ORM-Apollo]'].concat(messages));
         }
     };
-    Logger.prototype.logQuery = function (query) {
+    Logger.prototype.logQuery = function (query, variables) {
         if (this.enabled) {
             try {
                 this.group('Sending query:');
@@ -8034,6 +8040,8 @@ var Logger = /** @class */ (function () {
                 else {
                     console.log(QueryBuilder.prettify(query));
                 }
+                if (variables)
+                    console.log('VARIABLES:', variables);
                 this.groupEnd();
             }
             catch (e) {
@@ -8329,6 +8337,7 @@ var VuexORMApollo = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        this.logger.logQuery(query, variables);
                         if (!mutation) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.apolloClient.mutate({ mutation: query, variables: variables })];
                     case 1:

src/logger.ts

@@ -1,11 +1,13 @@
 import QueryBuilder from './queryBuilder';
 import { DocumentNode } from 'graphql';
+import {Arguments} from "./interfaces";
 
 export default class Logger {
   private readonly enabled: boolean;
 
   public constructor (enabled: boolean) {
     this.enabled = enabled;
+    this.log('Logging is enabled.');
   }
 
   public group (...messages: Array<any>): void {
@@ -24,7 +26,7 @@ export default class Logger {
     }
   }
 
-  public logQuery (query: string | DocumentNode) {
+  public logQuery (query: string | DocumentNode, variables?: Arguments) {
     if (this.enabled) {
       try {
         this.group('Sending query:');
@@ -35,6 +37,8 @@ export default class Logger {
           console.log(QueryBuilder.prettify(query as string));
         }
 
+        if (variables) console.log('VARIABLES:', variables);
+
         this.groupEnd();
       } catch (e) {
         console.error('[Vuex-ORM-Apollo] There is a syntax error in the query!', e, query);

src/queryBuilder.ts

@@ -50,28 +50,28 @@ export default class QueryBuilder {
    * @param {Model|string} model The model to use
    * @param {boolean} multiple Determines whether plural/nodes syntax or singular syntax is used.
    * @param {Arguments} args The args that will be passed to the query field ( user(role: $role) )
-   * @param {Model} rootModel The model of the root query field. Used to avoid endless recursion
+   * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations). Mainly for recursion
    * @param {string} name Optional name of the field. If not provided, this will be the model name
    * @param {boolean} allowIdFields Optional. Determines if id fields will be ignored for the argument generation.
    *                                See buildArguments
    * @returns {string}
    *
    * @todo Do we need the allowIdFields param?
-   * @todo There could be a endless recursion even with rootModel correctly set. We should track an array of models here probably?
    */
   public buildField (model: Model | string,
                      multiple: boolean = true,
                      args?: Arguments,
-                     rootModel?: Model,
+                     ignoreModels: Array<Model> = [],
                      name?: string,
                      allowIdFields: boolean = false): string {
     model = this.getModel(model);
+    ignoreModels.push(model);
 
     let params: string = this.buildArguments(args, false, allowIdFields);
 
     const fields = `
       ${model.getQueryFields().join(' ')}
-      ${this.buildRelationsQuery(model, rootModel)}
+      ${this.buildRelationsQuery(model, ignoreModels)}
     `;
 
     if (multiple) {
@@ -123,7 +123,7 @@ export default class QueryBuilder {
     // build query
     const query: string =
       `${type} ${upcaseFirstLetter(name)}${this.buildArguments(args, true)} {\n` +
-      `  ${this.buildField(model, multiple, args, model, name, true)}\n` +
+      `  ${this.buildField(model, multiple, args, [], name, true)}\n` +
       `}`;
 
     return gql(query);
@@ -267,21 +267,25 @@ export default class QueryBuilder {
   /**
    *
    * @param {Model} model
-   * @param {Model} rootModel
+   * @param {Array<Model>} ignoreModels The models in this list are ignored (while traversing relations). Mainly for recursion
    * @returns {Array<String>}
    */
-  private buildRelationsQuery (model: (null | Model), rootModel?: Model) {
+  private buildRelationsQuery (model: (null | Model), ignoreModels: Array<Model> = []) {
     if (model === null) return '';
 
     const relationQueries: Array<string> = [];
 
     model.getRelations().forEach((field: Field, name: string) => {
-      if (!rootModel || (name !== rootModel.singularName && name !== rootModel.pluralName)) {
+      if (!this.shouldModelBeIgnored(this.getModel(name), ignoreModels)) {
         const multiple: boolean = field.constructor.name !== 'BelongsTo';
-        relationQueries.push(this.buildField(name, multiple, undefined, rootModel || model));
+        relationQueries.push(this.buildField(name, multiple, undefined, ignoreModels));
       }
     });
 
     return relationQueries;
   }
+
+  private shouldModelBeIgnored (model: Model, ignoreModels: Array<Model>) {
+    return ignoreModels.find((m) => m.singularName === model.singularName) !== undefined;
+  }
 }

src/vuex-orm-apollo.ts

@@ -232,6 +232,8 @@ export default class VuexORMApollo {
   private async apolloRequest (query: any, variables?: Arguments, mutation: boolean = false): Promise<Data> {
     let response;
 
+    this.logger.logQuery(query, variables);
+
     if (mutation) {
       response = await this.apolloClient.mutate({ mutation: query, variables });
     } else {