Determine multiple flag from the schema

Author: phortx

dist/vuex-orm-graphql.esm.js

@@ -9870,7 +9870,7 @@ var Schema = /** @class */ (function () {
         return mutation;
     };
     Schema.prototype.getQuery = function (name) {
-        var query = this.types.get(name);
+        var query = this.queries.get(name);
         if (!query)
             throw new Error("Couldn't find Query of name " + name + " in the GraphQL Schema.");
         return query;
@@ -9996,7 +9996,7 @@ var Context = /** @class */ (function () {
                         this.processSchema();
                         this.logger.log('Schema procession done ...');
                         _a.label = 2;
-                    case 2: return [2 /*return*/];
+                    case 2: return [2 /*return*/, this.schema];
                 }
             });
         });
@@ -10451,18 +10451,18 @@ var Action = /** @class */ (function () {
      * @param {boolean} multiple Tells if we're requesting a single record or multiple.
      * @returns {Promise<any>}
      */
-    Action.mutation = function (name, variables, dispatch, model, multiple) {
-        if (multiple === void 0) { multiple = false; }
+    Action.mutation = function (name, variables, dispatch, model) {
         return __awaiter$3(this, void 0, void 0, function () {
-            var context, query, newData, insertedData, records, newRecord;
+            var context, schema, multiple, query, newData, insertedData, records, newRecord;
             return __generator$3(this, function (_a) {
                 switch (_a.label) {
                     case 0:
                         if (!variables) return [3 /*break*/, 5];
                         context = Context.getInstance();
                         return [4 /*yield*/, context.loadSchema()];
                     case 1:
-                        _a.sent();
+                        schema = _a.sent();
+                        multiple = schema.returnsConnection(schema.getMutation(name));
                         query = QueryBuilder.buildQuery('mutation', model, name, variables, multiple);
                         return [4 /*yield*/, Context.getInstance().apollo.request(model, query, variables, true)];
                     case 2:
@@ -10776,25 +10776,26 @@ var Mutate = /** @class */ (function (_super) {
      */
     Mutate.call = function (_a, _b) {
         var state = _a.state, dispatch = _a.dispatch;
-        var args = _b.args, multiple = _b.multiple, name = _b.name;
+        var args = _b.args, name = _b.name;
         return __awaiter$6(this, void 0, void 0, function () {
-            var model;
+            var context, schema, model;
             return __generator$6(this, function (_c) {
-                if (name) {
-                    model = this.getModelFromState(state);
-                    args = this.prepareArgs(args);
-                    // There could be anything in the args, but we have to be sure that all records are gone through
-                    // transformOutgoingData()
-                    this.transformArgs(args);
-                    if (multiple === undefined)
-                        multiple = !args['id'];
-                    // Send the mutation
-                    return [2 /*return*/, Action.mutation(name, args, dispatch, model, multiple)];
-                }
-                else {
-                    throw new Error("The mutate action requires the mutation name ('mutation') to be set");
+                switch (_c.label) {
+                    case 0:
+                        if (!name) return [3 /*break*/, 2];
+                        context = Context.getInstance();
+                        return [4 /*yield*/, context.loadSchema()];
+                    case 1:
+                        schema = _c.sent();
+                        model = this.getModelFromState(state);
+                        args = this.prepareArgs(args);
+                        // There could be anything in the args, but we have to be sure that all records are gone through
+                        // transformOutgoingData()
+                        this.transformArgs(args);
+                        // Send the mutation
+                        return [2 /*return*/, Action.mutation(name, args, dispatch, model)];
+                    case 2: throw new Error("The mutate action requires the mutation name ('mutation') to be set");
                 }
-                return [2 /*return*/];
             });
         });
     };
@@ -11060,22 +11061,21 @@ var Query = /** @class */ (function (_super) {
      */
     Query.call = function (_a, _b) {
         var state = _a.state, dispatch = _a.dispatch;
-        var name = _b.name, multiple = _b.multiple, filter = _b.filter, bypassCache = _b.bypassCache;
+        var name = _b.name, filter = _b.filter, bypassCache = _b.bypassCache;
         return __awaiter$9(this, void 0, void 0, function () {
-            var context, model, query, data;
+            var context, schema, model, multiple, query, data;
             return __generator$9(this, function (_c) {
                 switch (_c.label) {
                     case 0:
                         if (!name) return [3 /*break*/, 3];
                         context = Context.getInstance();
                         return [4 /*yield*/, context.loadSchema()];
                     case 1:
-                        _c.sent();
+                        schema = _c.sent();
                         model = this.getModelFromState(state);
                         // Filter
                         filter = filter ? Transformer.transformOutgoingData(model, filter) : {};
-                        if (multiple === undefined)
-                            multiple = !filter['id'];
+                        multiple = schema.returnsConnection(schema.getQuery(name));
                         query = QueryBuilder.buildQuery('query', model, name, filter, multiple, false);
                         return [4 /*yield*/, context.apollo.request(model, query, filter, false, bypassCache)];
                     case 2:

docs/guide/README.md

@@ -4,15 +4,16 @@ Vuex-ORM-GraphQL is a plugin for the amazing [Vuex-ORM](https://github.com/vuex-
 Object-Relational Mapping access to the Vuex Store. Vuex-ORM-GraphQL enhances Vuex-ORM to let you sync your Vuex state
 via the Vuex-ORM models with your server via a [GraphQL API](http://graphql.org/).
 
-The plugin will automatically generate GraphQL queries and mutations based on your model definitions and thus hides
-the specifics of Network Communication, GraphQL, Caching, De- and Serialization of your Data and so on from the
-developer. Getting a record of a model from the server is as easy as calling `Product.fetch()`. This allows you to write
-sophisticated Single-Page Applications fast and efficient without worrying about GraphQL.
+The plugin will automatically generate GraphQL queries and mutations based on your model definitions and by
+reading your and GraphQL schema from your server. Thus it hides the specifics of Network Communication, GraphQL,
+Caching, De- and Serialization of your Data and so on from the developer. Getting a record of a model from the server
+is as easy as calling `Product.fetch()`. This allows you to write sophisticated Single-Page Applications fast and
+efficient without worrying about GraphQL.
 
 
 ::: warning
-You should have basic knowledge of [Vue](https://vuejs.org/), [Vuex](https://vuex.vuejs.org/) and
-[Vuex-ORM](https://vuex-orm.github.io/vuex-orm/) before reading this documentation.
+You should have basic knowledge of [GraphQL](http://graphql.org/), [Vue](https://vuejs.org/),
+[Vuex](https://vuex.vuejs.org/) and [Vuex-ORM](https://vuex-orm.github.io/vuex-orm/) before reading this documentation.
 :::
 
 

docs/guide/custom-queries/README.md

@@ -38,10 +38,11 @@ await Post.dispatch('query', { name: 'example', filter: { id: post.id } });
 As you can see you have to provide the query name and any further arguments you want to pass. In this case we send
 the post id, but this could be anything else. Please also notice that `record.$customQuery` automatically adds the id
 of the record into the arguments list. The plugin automatically determines if there are multiple records or a single
-record is requests by looking in the arguments hash if there is a `id` field and respectively setups the query.
+record is returned by looking in the arguments hash if there is a `id` field and respectively setups the query.
 
 A model related custom query is always tied to the model, so the plugin expects the return value of the custom query
-is of the model type. In this example that means, that Vuex-ORM-GraphQL expects that the `example` query is of type `Post`. 
+is of the model type. In this example that means, that Vuex-ORM-GraphQL expects that the `example` query is of type
+`Post`.
 
 This generates the following query:
 
@@ -76,7 +77,6 @@ database.
 Following fields are allowed:
 
 - `name`: Required. The name of the query.
-- `multiple`: Whether the query is of a connection type (multiple records are returned) or not (single record is returned).
 - `filter`: Hash map with filters. These are passed as a filter typed variable like in fetch.
 - `bypassCache`: Whether to bypass the caching.
 
@@ -176,7 +176,6 @@ database.
 Following fields are allowed:
 
 - `name`: Required. The name of the mutation.
-- `multiple`: Whether the mutation is of a connection type (multiple records are returned) or not (single record is returned).
 - `args`: Hash map with arguments (variables).
 
 
@@ -220,14 +219,5 @@ Following fields are allowed:
 
 ## Multiple or single record
 
-Vuex-ORM-GraphQL tries to determine automatically if a  single record or a connection (multiple records) is returned by
-a query/mutation via checking if a `id` field is set in the filter/args/variables. But sometimes you have a
-query/mutation without ID but it still returns a single record or vice versa. For this case you can manually set the
-`multiple` field to tell the plugin how the result is shaped:
-
-```javascript
-await Post.customQuery({ name: 'example', multiple: true, filter: { id: post.id } });
-```
-
-In future versions of this project this might be obsolete because it could consume and analyze the schema to know
-how the queries and mutations are shaped.
+Vuex-ORM-GraphQL will determine automatically if a single record or a connection (multiple records) is returned by a
+query/mutation via checking your GraphQL Schema. How smart is this?

docs/guide/destroy/README.md

@@ -23,6 +23,13 @@ the following GraphQL query is generated:
 mutation DeletePost($id: ID!) {
   deletePost(id: $id) {
     id
+    title
+    content
+    
+    user {
+      id
+      email
+    }
   }
 }
 ```

src/actions/action.ts

@@ -6,6 +6,7 @@ import Model from '../orm/model';
 import State from '@vuex-orm/core/lib/modules/State';
 import Transformer from '../graphql/transformer';
 import NameGenerator from '../graphql/name-generator';
+import Schema from '../graphql/schema';
 
 const inflection = require('inflection');
 
@@ -24,11 +25,12 @@ export default class Action {
    * @returns {Promise<any>}
    */
   protected static async mutation (name: string, variables: Data | undefined, dispatch: DispatchFunction,
-                                   model: Model, multiple: boolean = false): Promise<any> {
+                                   model: Model): Promise<any> {
     if (variables) {
-      const context = Context.getInstance();
-      await context.loadSchema();
+      const context: Context = Context.getInstance();
+      const schema: Schema = await context.loadSchema();
 
+      const multiple: boolean = schema.returnsConnection(schema.getMutation(name));
       const query = QueryBuilder.buildQuery('mutation', model, name, variables, multiple);
 
       // Send GraphQL Mutation

src/actions/mutate.ts

@@ -1,5 +1,7 @@
 import { ActionParams, Arguments, Data } from '../support/interfaces';
 import Action from './action';
+import Context from '../common/context';
+import Schema from '../graphql/schema';
 
 /**
  * Mutate action for sending a custom mutation. Will be used for Model.mutate() and record.$mutate().
@@ -13,19 +15,19 @@ export default class Mutate extends Action {
    * @param {Arguments} args Arguments for the mutation. Must contain a 'mutation' field.
    * @returns {Promise<Data>} The new record if any
    */
-  public static async call ({ state, dispatch }: ActionParams, { args, multiple, name }: ActionParams): Promise<Data> {
+  public static async call ({ state, dispatch }: ActionParams, { args, name }: ActionParams): Promise<Data> {
     if (name) {
+      const context: Context = Context.getInstance();
+      const schema: Schema = await context.loadSchema();
       const model = this.getModelFromState(state);
       args = this.prepareArgs(args);
 
       // There could be anything in the args, but we have to be sure that all records are gone through
       // transformOutgoingData()
       this.transformArgs(args);
 
-      if (multiple === undefined) multiple = !args['id'];
-
       // Send the mutation
-      return Action.mutation(name, args, dispatch, model, multiple);
+      return Action.mutation(name, args, dispatch, model);
     } else {
       throw new Error("The mutate action requires the mutation name ('mutation') to be set");
     }

src/actions/query.ts

@@ -5,6 +5,7 @@ import Transformer from '../graphql/transformer';
 import { ActionParams, Data } from '../support/interfaces';
 import Action from './action';
 import NameGenerator from '../graphql/name-generator';
+import Schema from '../graphql/schema';
 
 /**
  * Query action for sending a custom query. Will be used for Model.customQuery() and record.$customQuery.
@@ -20,17 +21,17 @@ export default class Query extends Action {
    * @returns {Promise<Data>} The fetched records as hash
    */
   public static async call ({ state, dispatch }: ActionParams,
-                            { name, multiple, filter, bypassCache }: ActionParams): Promise<Data> {
+                            { name, filter, bypassCache }: ActionParams): Promise<Data> {
     if (name) {
-      const context = Context.getInstance();
-      await context.loadSchema();
-
+      const context: Context = Context.getInstance();
+      const schema: Schema = await context.loadSchema();
       const model = this.getModelFromState(state);
 
       // Filter
       filter = filter ? Transformer.transformOutgoingData(model, filter) : {};
 
-      if (multiple === undefined) multiple = !filter['id'];
+      // Multiple?
+      const multiple: boolean = schema.returnsConnection(schema.getQuery(name));
 
       // Build query
       const query = QueryBuilder.buildQuery('query', model, name, filter, multiple, false);

src/common/context.ts

@@ -97,7 +97,7 @@ export default class Context {
   /**
    * The graphql schema. Is null until the first request.
    */
-  private schema: Schema | undefined;
+  public schema: Schema | undefined;
 
   /**
    * Private constructor, called by the setup method
@@ -149,7 +149,7 @@ export default class Context {
     return this.instance;
   }
 
-  public async loadSchema () {
+  public async loadSchema (): Promise<Schema> {
     if (!this.schema) {
       this.logger.log('Fetching GraphQL Schema initially ...');
 
@@ -166,6 +166,8 @@ export default class Context {
       this.processSchema();
       this.logger.log('Schema procession done ...');
     }
+
+    return this.schema;
   }
 
   /**

src/graphql/schema.ts

@@ -36,7 +36,7 @@ export default class Schema {
     return mutation;
   }
 
-  public getQuery (name: string): GraphQLType {
+  public getQuery (name: string): GraphQLField {
     const query = this.queries.get(name);
 
     if (!query) throw new Error(`Couldn't find Query of name ${name} in the GraphQL Schema.`);

test/integration/VuexORMGraphQL.spec.js

@@ -396,25 +396,71 @@ mutation UpdateUser($id: ID!, $user: UserInput!) {
     it('sends the correct query to the API', async () => {
       const response = {
         data: {
-          deleteUser: {
-            __typename: 'user',
-            id: 1,
-            name: 'Charlie Brown'
+          deletePost: {
+            __typename: 'post',
+            id: 42,
+            otherId: 13548,
+            published: true,
+            title: 'Example Post 5',
+            content: 'Foo',
+            comments: {
+              __typename: 'comment',
+              nodes: [{
+                __typename: 'comment',
+                id: 15,
+                content: 'Works!',
+                subjectId: 42,
+                subjectType: 'Post',
+                user: {
+                  __typename: 'user',
+                  id: 2,
+                  name: 'Charly Brown'
+                }
+              }]
+            },
+            user: {
+              __typename: 'user',
+              id: 1,
+              name: 'Johnny Imba',
+            }
           }
         }
       };
 
       const request = await sendWithMockFetch(response, async () => {
-        const user = User.find(1);
-        await user.$destroy();
+        const post = Post.find(1);
+        await post.$destroy();
       });
 
       expect(request.variables).toEqual({ id: 1 });
       expect(request.query).toEqual(`
-mutation DeleteUser($id: ID!) {
-  deleteUser(id: $id) {
+mutation DeletePost($id: ID!) {
+  deletePost(id: $id) {
     id
-    name
+    content
+    title
+    otherId
+    published
+    user {
+      id
+      name
+      __typename
+    }
+    comments {
+      nodes {
+        id
+        content
+        subjectId
+        subjectType
+        user {
+          id
+          name
+          __typename
+        }
+        __typename
+      }
+      __typename
+    }
     __typename
   }
 }