web-dev-qa-db-fra.com

Comment créer un résolveur imbriqué dans le serveur apollo graphql

Étant donné le schéma graphql suivant du serveur apollo .__, je souhaitais les décomposer en modules distincts afin que je ne souhaite pas que la requête d’auteur soit située sous le schéma racine de requête .. et qu’elle soit séparée. J'ai donc ajouté une autre couche appelée authorQueries avant de l'ajouter à la requête racine.

type Author {
    id: Int,
    firstName: String,
    lastName: String
}  
type authorQueries {
    author(firstName: String, lastName: String): Author
}

type Query {
    authorQueries: authorQueries
}

schema {
    query: Query
}

J'ai essayé ce qui suit .. vous pouvez voir que authorQueries a été ajouté en tant que couche supplémentaire avant que la fonction auteur ne soit spécifiée.

Query: {
    authorQueries :{
        author (root, args) {
            return {}
       }
    }
}

Lors de l'interrogation dans Graphiql, j'ai également ajouté cette couche supplémentaire. 

{
    authorQueries {
        author(firstName: "Stephen") {
            id
        }
    }
}

Je reçois l'erreur suivante.

"message": "Resolve function for \"Query.authorQueries\" returned undefined",

graphqlapollostackapollo-server
13
elbarto

Pour créer un résolveur "imbriqué", définissez simplement le résolveur sur le type de retour du champ parent. Dans ce cas, votre champ authorQueries renvoie le type authorQueries afin que vous puissiez y placer votre résolveur:

{
  Query: { authorQueries: () => ({}) },
  authorQueries: {
    author(root, args) {
      return "Hello, world!";
    }
  }
}

Donc, au sens technique, il n’existe pas de résolveur imbriqué - chaque type d’objet possède une liste simple de champs et ces champs ont des types de retour. L'imbrication de la requête GraphQL est ce qui rend le résultat imbriqué.

15
stubailo

J'ai trouvé que le retour de fonctions sur les champs parents renvoyait le type et que l'argument this était lié, et cassait l'interface de résolveur, car le résolveur imbriqué ne faisait pas le parent comme premier argument.

Pour les définitions de type en ligne

import {
  graphql,
} from 'graphql';

import {
  makeExecutableSchema, IResolverObject
} from 'graphql-tools';

const types = `
type Query {
  person: User
}

type User {
  id: ID
  name: String,
  dog(showCollar: Boolean): Dog
}

type Dog {
  name: String
}
`;

const User: IResolverObject = {
  dog(obj, args, ctx) {
    console.log('Dog Arg 1', obj);
    return {
      name: 'doggy'
    };
  }
};

const resolvers = {
  User,
  Query: {
    person(obj) {
      console.log('Person Arg 1', obj);
      return {
        id: 'foo',
        name: 'bar',
      };
    }
  }
};

const schema = makeExecutableSchema({
  typeDefs: [types],
  resolvers
});

const query = `{ 
  person {
    name,
    dog(showCollar: true) {
      name
    }
  }
 }`;


graphql(schema, query).then(result => {
  console.log(JSON.stringify(result, null, 2));
});

// Person Arg 1 undefined
// Dog Arg 1 { id: 'foo', name: 'bar' }
// {
//   "data": {
//     "person": {
//       "name": "bar",
//       "dog": {
//         "name": "doggy"
//       }
//     }
//   }
// }

Vous pouvez également utiliser addResolveFunctionsToSchema comme indiqué dans le résumé ci-dessous.

https://Gist.github.com/blugavere/4060f4bf2f3d5b741c639977821a254f

0
blugavere