Can a graphql mutation be wired inside a DataFetcher class along with query? - graphql

Question

Error:FieldUndefined: Field 'createUser' in type 'Query' is undefined # 'createUser'"
#Service
public class GraphQlService {
#Value("classpath:schema.graphql")
Resource resource;
private GraphQL graphQL;
#Autowired
UserDataFetcher userFetcher;
#Autowired
PostDataFetcher postFetcher;
#PostConstruct
public void loadSchema() throws IOException {
File schemaFile = resource.getFile();
TypeDefinitionRegistry typeRegistry = new SchemaParser().parse(schemaFile);
RuntimeWiring wiring = buildRuntimeWiring();
GraphQLSchema schema = new SchemaGenerator().makeExecutableSchema(typeRegistry, wiring);
graphQL = GraphQL.newGraphQL(schema).build();
}
private RuntimeWiring buildRuntimeWiring() {
return RuntimeWiring.newRuntimeWiring()
.type("Query", typeWiring -> typeWiring
.dataFetcher("user", userFetcher)
.dataFetcher("post", postFetcher))
.type("Mutation", typeWiring -> typeWiring
.dataFetcher("createUser", userFetcher))
.build();
}
public GraphQL getGraphQL() {
return graphQL;
}
}
1. Cant I use common datafetcher/reslover for both Query and Mutation
as I have done below in a single class.It is not able to find
createUser?
#Component
public class UserDataFetcher implements DataFetcher<List<User>> {
#Autowired
UserRepository userRepository;
public User createUser(DataFetchingEnvironment environment) {
String username = environment.getArgument("username");
String location= environment.getArgument("location");
User[] follower = environment.getArgument("followers");
User[] following = environment.getArgument("following");
Post[] pos = environment.getArgument("posts");
User user = new User();
user.setUsername(username);
user.setFollowers(follower);
user.setFollowing(following);
user.setLocation(location);
user.setPosts(pos);
return userRepository.save(user);
}
#Override
public List<User> get(DataFetchingEnvironment environment) {
return userRepository.findAll();
}
}
//SDL below for schema
schema {
query: Query
mutation: Mutation
}
type User{
id:ID!
username:String!
followers:[User]
following:[User]
location:String!
posts:[Posts]
}
type Post{
id: ID
title: String!
author: User!
}
type Query{
user: [User]
post: [Post]
}
type Mutation{
createUser(username: String!, location: String!,followers: [User],following:[User],posts:[Post]):User
}
2. Is the schema correct because it would say User and Post are not mentioned as InputType. I tried InputType for User and Post but
couldnt get it working.How should correct schema for storing
followers and following look like ?

Answer 1

1) No, each DataFetcher implementation can do a single operation only - that's the get method the interface specifies. How would the framework know to call the createUser method?
2) No, the schema is not valid. You can not use User as an argument (input) type. You need to define a separate input type, e.g.
input UserInput {
username:String!
followers:[ID!]
following:[ID!]
location:String!
}
Just think, if you could make User the input, how would you provide the mandatory ID? What if User implements an interface, since interfaces are not defined for inputs? Imagine if User had a recursive field type. In output, that would be fine (as you control the nesting level directly), but would be impossible to satisfy for an input type.
The rules for inputs and output are quite different, so the types need to be defined separately.
Also, in this example, only the IDs are optionally expected for the followers or the followed, instead of the full objects, as it often makes more sense.