CODEWITHSUNDEEP
graphqlgraphql-js
Joe
Joe

Reputation: 681

GraphQL Schema to handle mixed types

I've recently started to research the possibility of using GraphQL for requesting dynamic data configurations. The very first thing that jumps out at me is the strongly-typed concept of GraphQL.

Is there a way for GraphQL schemas to handle arrays of mixed type objects? I would greatly appreciate either an explanation or possibly a reference I can read over.

I am currently working with GraphQL with Node.js but a later implementation will be out of a Java Container. All data will be JSON pulled from MongoDB.

Upvotes: 9

Views: 11103

Answers (3)

kaqqao
kaqqao

Reputation: 15489

You either have to make these disparate types implement the same interface, make your resolvers return unions, or create a custom scalar to hold the dynamic data.

The cleanest approach is the first one: if your resulting objects can be of a limited number of types, define the types so that they implement the same interface, and type your resolvers by the interface. This allows the client to conditionally select sub-fields based on the actual type, and you maintain type safety.

The second approach has similar limitations: you need to know the possible types ahead of time, but they do not have to implement the same interface. It is preferable when the possible values are unrelated to each other and have either/or semantics, like success/failure.

The custom scalar approach is the only one in which you do not need to know the possible types of the result, i.e. the structure of the result can be completely dynamic. Here's an implementation of that approach, known as JSON scalar (i.e. cram any JSON-serializable structure into a scalar value). The big downside of this approach is that it makes sub-selection impossible, as the entire value becomes one big scalar (even though it's a complex object).

Since the question is asking about an array of objects of unknown types, I'll point out that you can, of course, have a list of all the options above.

Examples:

#Interface for any search result
interface SearchResult {
  title: String!
  url: String!
}

#A specific kind of search result
type Book implements SearchResult {
  title: String!
  url: String!
  author: Author!
  isbn: String!
}

type Article implements SearchResult {
  title: String!
  url: String!
  categories: [Category]!
}

type Query {
  #Search can return a mix of Books and Articles
  search(keyword: String!): [SearchResult!]
}

Or

#No interface this time
type Book {
  name: String! #No common fields with Article
  author: Author!
  publisher: Publisher!
}

type Article {
  title: String!
  url: String!
  categories: [Category]!
}

union SearchResult = Book | Article

type Query {
  #Search can return a mix of Books and Articles
  search(keyword: String!): [SearchResult!]
}

Or

scalar JSON

type Query {
  #Search can return anything at all... All bets are off
  search(keyword: String!): [JSON!]
}

Upvotes: 6

Lucia
Lucia

Reputation: 13587

If data is completely JSON and you would rather preserve them as is, check out JSON scalar type. Basically,

import { GraphQLObjectType } from 'graphql';
import GraphQLJSON from 'graphql-type-json';

export default new GraphQLObjectType({
  name: 'MyType',
  fields: {
    myField: { type: GraphQLJSON },
  },
});

Upvotes: 2

Aleksandrenko
Aleksandrenko

Reputation: 3063

I think it's possible to make a custom/generic type that will fit the need. So that way it's still a strong typed array but the type will be flexable enough to set what you need.

Here is an example with custom types: https://github.com/stylesuxx/graphql-custom-types

Upvotes: -1

Related Questions