Apollo/GraphQL：ネストされた要素を取得するには？

Question

これは私のmongoDBのサンプルドキュメントです。 Apollo/GraphQL経由でcontent.en配列を取得する必要があります。しかし、ネストされたオブジェクトは私のために問題を起こしています。 enは言語タグなので、これを変数として使用することができれば素晴らしいでしょう。 graphQL結果がでなければなりませんMongoDBので

データ

{ 
    "_id" : "9uPjYoYu58WM5Tbtf", 
    "content" : { 
     "en" : [ 
      { 
       "content" : "Third paragraph", 
       "timestamp" : 1484939404 
      } 
     ] 
    }, 
    "main" : "Dn59y87PGhkJXpaiZ" 
} 

：

{ 
    "data": { 
    "article": [ 
     { 
     "_id": "9uPjYoYu58WM5Tbtf", 
     "content": [ 
       { 
        "content" : "Third paragraph", 
        "timestamp" : 1484939404 
       } 
      ] 
     } 
    ] 
    } 
} 

ことを意味し、私はIDと言語固有のコンテンツの配列を取得する必要があります。

タイプ

const ArticleType = new GraphQLObjectType({ 
    name: 'article', 
    fields: { 
    _id: { type: GraphQLID }, 
    content: { type: GraphQLString } 
    } 
}) 

GraphQLスキーマ

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() 
     } 
     } 
    } 
    }) 
}) 

Q：私は次のセットアップを取得しています何

---

しかし、これではありません、 content: { type: GraphQLString }：ueryで

{ 
    article(id: "Dn59y87PGhkJXpaiZ") { 
    _id, 
    content 
    } 
} 

結果

{ 
    "data": { 
    "article": [ 
     { 
     "_id": "9uPjYoYu58WM5Tbtf", 
     "content": "[object Object]" 
     } 
    ] 
    } 
} 

Answer 1

以下のコードを使用できます。

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() 
     } 
     } 
    } 
    }) 
}) 

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(); 
    } 
} 

Answer 2

は、私はこの問題は、このラインから来ていると思います。あなたは言語のISOコードがパラメータであることを言ったので

const ContentType = new GraphQLObjectType({ 
    name: 'content', 
    fields: { 
    en: { type: GraphQLList }, 
    it: { type: GraphQLList } 
    // ... other languages 
    } 
}) 

Answer 3

とその：別のGraphQLObjectTypeにコンテンツを抽出してみて、その後contentフィールド

としてArticleTypeに渡し編集

これを試してみてください内容はで、言語ISOコードのに依存しています（今からlanguageTagと呼ぶでしょう）。私はあなたのスキーマを次のように編集する必要があると考えました。

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) 
      }, 

      // Edited this part to add the language tag 
      languageTag: { 
      name: 'languageTag', 
      type: new GraphQLNonNull(GraphQLString) 
      } 
     }, 

     async resolve ({ db }, args) { 
      return db.collection('articles').find({ main: args.id }).toArray() 
     } 
     } 
    } 
    }) 
}) 

ただし、これでもコンテンツの取得に関する問題は解決しません。 ContentTypeというスキーマに別のタイプを追加する必要があると思います。私が育てたい

const ContentType = new GraphQLObjectType({ 
    name: 'ContentType', 
    fields: { 
    content: { 
     type: GraphQLString, 
     resolve: (root, args, context) => root.content[args.languageTag].content 
    }, 
    timestamp: { 
     type: GraphQLString, 
     resolve: (root, args, context) => root.content[args.languageTag].timestamp 
    } 
    }, 
}) 

最後にひとつの問題は、あなたがArrayとして単一articleに戻ってきているということです。これを変更して単一のオブジェクトを返すことをお勧めします。最後になりましたが、あなたのスキーマは次のようになります：私はそれをテストするためにあなたのデータベースを持っていないので、

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) 
      }, 

      // Edited this part to add the language tag 
      languageTag: { 
      name: 'languageTag', 
      type: new GraphQLNonNull(GraphQLString) 
     }, 

     // Add the extra fields to the article 
     fields: { 
      content: ContentType 
     } 

     async resolve ({ db }, args) { 
      return db.collection('articles').findOne({ main: args.id }) 
     } 
     } 
    } 
    }) 
}) 

このコードは、少しオフである可能性があります。私はそれが正しい方向への良いプッシュであると思う。