Bạn có thể sử dụng mã bên dưới.
String query = {
article(id: "Dn59y87PGhkJXpaiZ") {
_id,
content(language:"en") {
content,
timestamp
}
}
}
const ContentType = new GraphQLObjectType({
name: 'content',
fields: {
content: { type: GraphQLString },
timestamp: { type: GraphQLInt }
}
})
const ArticleType = new GraphQLObjectType({
name: 'article',
fields: {
_id: { type: GraphQLID },
content: {
type: new GraphQLList(ContentType),
args: {
language: {
name: 'language',
type: new GraphQLNonNull(GraphQLString)
}
},
async resolve (args) {
return filter content here by lang
}
}
}
}
})
export default new GraphQLSchema({
query: new GraphQLObjectType({
name: 'RootQueryType',
fields: {
article: {
type: new GraphQLList(ArticleType),
description: 'Content of article dataset',
args: {
id: {
name: 'id',
type: new GraphQLNonNull(GraphQLID)
}
},
async resolve ({ db }, args) {
return db.collection('articles').find({ main: args.id}).toArray()
}
}
}
})
})
Ví dụ về Java:
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;
import graphql.ExecutionResult;
import graphql.GraphQL;
import graphql.schema.*;
import org.bson.Document;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import static graphql.Scalars.*;
import static graphql.schema.GraphQLArgument.newArgument;
import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition;
import static graphql.schema.GraphQLObjectType.newObject;
import static graphql.schema.GraphQLSchema.newSchema;
public class GraphQLTest {
private static final ArticleRepository articleRepository;
public static class ArticleRepository {
private final MongoCollection<Document> articles;
ArticleRepository(MongoCollection<Document> articles) {
this.articles = articles;
}
public List<Map<String, Object>> getAllArticles(String id) {
List<Map<String, Object>> allArticles = articles.find(Filters.eq("main", id)).map(doc -> (Map<String, Object>)doc).into(new ArrayList<>());
return allArticles;
}
}
public static void main(String... args) {
String query = "{\n" +
" article(id: \"Dn59y87PGhkJXpaiZ\") {\n" +
" _id,\n" +
" content(language:\"en\") {\n" +
" content,\n" +
" timestamp\n" +
" }\n" +
" }\n" +
"}";
ExecutionResult result = GraphQL.newGraphQL(buildSchema()).build().execute(query);
System.out.print(result.getData().toString());
}
static {
MongoDatabase mongo = new MongoClient().getDatabase("test");
articleRepository = new ArticleRepository(mongo.getCollection("articles"));
}
private static GraphQLSchema buildSchema() {
GraphQLObjectType ContentType = newObject().name("content")
.field(newFieldDefinition().name("content").type(GraphQLString).build())
.field(newFieldDefinition().name("timestamp").type(GraphQLInt).build()).build();
GraphQLObjectType ArticleType = newObject().name("article")
.field(newFieldDefinition().name("_id").type(GraphQLID).build())
.field(newFieldDefinition().name("content").type(new GraphQLList(ContentType))
.argument(newArgument().name("language").type(GraphQLString).build())
.dataFetcher(dataFetchingEnvironment -> {
Document source = dataFetchingEnvironment.getSource();
Document contentMap = (Document) source.get("content");
ArrayList<Document> contents = (ArrayList<Document>) contentMap.get(dataFetchingEnvironment.getArgument("lang"));
return contents;
}).build()).build();
GraphQLFieldDefinition.Builder articleDefinition = newFieldDefinition()
.name("article")
.type(new GraphQLList(ArticleType))
.argument(newArgument().name("id").type(new GraphQLNonNull(GraphQLID)).build())
.dataFetcher(dataFetchingEnvironment -> articleRepository.getAllArticles(dataFetchingEnvironment.getArgument("id")));
return newSchema().query(
newObject()
.name("RootQueryType")
.field(articleDefinition)
.build()
).build();
}
}