GraphQL

# root query
{
  # query for content-type '/page/article'
  page_article {
    total # total number of items found
    items { # list of items found
      # content-type fields that will be returned
      # (names are based on the content-type configuration)
      title
      author
      date_dt
    }
  }
}

# root query
{
  # query for all pages
  pages {
    total # total number of items found
    items { # list of items found
      # the page fields that will be returned
      content__type
      localId
      createdDate_dt
      lastModifiedDate_dt
      placeInNav
      orderDefault_f
      navLabel
    }
  }
}

# root query
{
  # query for all pages
  components {
    total # total number of items found
    items { # list of items found
      # the component fields that will be returned
      content__type
      localId
      createdDate_dt
      lastModifiedDate_dt
    }
  }
}

# root query
{
  # query for all pages
  contentItems {
    total # total number of items found
    items { # list of items found
      # the content item fields that will be returned
      content__type
      localId
      createdDate_dt
      lastModifiedDate_dt
    }
  }
}

# root query
{
  # query for content-type '/page/article'
  page_article(offset: 0, limit: 5) {
    total # total number of items found
    items { # list of items found
      # content-type fields that will be returned
      # (names are based on the content-type configuration)
      title
      author
      date_dt
    }
  }
}

# root query
{
  # query for content-type '/page/article'
  page_article (offset: 0, limit: 5, sortBy: "date_dt", sortOrder: ASC) {
    total # total number of items found
    items { # list of items found
      # content-type fields that will be returned
      # (names are based on the content-type configuration)
      title
      author
      date_dt
    }
  }
}

# root query
{
  # query for content-type '/page/article'
  page_article (offset: 0, limit: 5, sortBy: "date_dt", sortOrder: ASC) {
    total # total number of items found
    items { # list of items found
      # content-type fields that will be returned
      # (names are based on the content-type configuration)
      title
      # only return articles from this author
      author (filter: { matches: "Jane" })
      date_dt
    }
  }
}

# Root query
{
  page_article {
    total
    items {
      title
      author
      date_dt
      # Filter articles that are not featured
      featured_b (
        filter: {
          not: [
            {
              equals: true
            }
          ]
        }
      )
      # Filter articles from category style or health
      categories {
        item {
          key (
            filter: {
              or: [
                {
                  matches: "style"
                },
                {
                  matches: "health"
                }
              ]
            }
          )
          value_smv
        }
      }
    }
  }
}

# root query
{
  # query for content-type '/page/article'
  page_article (offset: 0, limit: 5, sortBy: "date_dt", sortOrder: ASC) {
    total # total number of items found
    items { # list of items found
      # content-type fields that will be returned
      # (names are based on the content-type configuration)
      title
      # only return articles from this author
      author (filter: { matches: "Jane" })
      date_dt
      categories {
        item {
          # only return articles from this category
          key (filter: { matches: "health" })
          value_smv
        }
      }
    }
  }
}

# root query
{
  # query for 2022 articles
  articlesOf2022: page_article {
    items {
      localId(filter: {regex: ".*2022.*"})
    }
  },
  # query for 2023 articles
  articlesOf2023: page_article {
    items {
      localId(filter: {regex: ".*2023.*"})
    }
  }
}

# Fragment definition
fragment CommonFields on ContentItem {
  localId
  createdDate_dt
}

# Root query
query {
  page_article {
    total
    items {
      # Fragment spread
      ... CommonFields
      title
      author
    }
  }

  component_feature {
    total
    items {
      # Fragment spread
      ... CommonFields
      title
      icon
    }
  }
}

# Root query
{
  contentItems {
    total
    items {
      # Query for fields from the interface
      localId
      createdDate_dt

      # Query for fields from specific types
      ... on page_article {
        title
        author
      }

      ... on component_feature {
        title
        icon
      }
    }
  }
}

<site>
 <omdb>
    <baseUrl>http://www.omdbapi.com</baseUrl>
    <apiKey>XXXXXXX</apiKey>
 </omdb>
</site>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
       xmlns:context="http://www.springframework.org/schema/context">

      <!-- Enable placeholders support -->
      <context:property-placeholder/>

      <!-- Define the service bean -->
      <bean id="omdbService" init-method="init"
            class="ru.dc.cms.movies.omdb.OmdbService">
        <property name="baseUrl" value="${omdb.baseUrl}"/>
        <property name="apiKey" value="${omdb.apiKey}"/>
      </bean>
</beans>

package ru.dc.cms.movies.omdb

// include a third-party library for easily calling the API
@Grab(value='io.github.http-builder-ng:http-builder-ng-core:1.0.4', initClass=false)
import groovyx.net.http.HttpBuilder

class OmdbService {

  // the base URL for all API calls
  String baseUrl

  // the API key needed for the calls
  String apiKey

  // The http client
  HttpBuilder http

  // creates an instance of the http client with the configured base URL
  def init() {
    http = HttpBuilder.configure {
      request.uri = baseUrl
    }
  }

  // performs a search call, returns the entries as maps
  def search(String title) {
    return [
      http.get() {
        // include the needed parameters
        request.uri.query  = [ apiKey: apiKey, t: title ]
      }
    ].flatten() // return a list even if the API only returns a single entry
  }

}

{
  "Title": "Hackers",
  "Year": "1995",
  "Rated": "PG-13",
  "Released": "15 Sep 1995",
  "Runtime": "107 min",
  "Genre": "Comedy, Crime, Drama, Thriller",
  "Director": "Iain Softley",
  "Writer": "Rafael Moreu",
  "Actors": "Jonny Lee Miller, Angelina Jolie, Jesse Bradford, Matthew Lillard",
  "Plot": "Hackers are blamed for making a virus that will capsize five oil tankers.",
  "Language": "English, Italian, Japanese, Russian",
  "Country": "USA",
  "Awards": "N/A",
  "Poster": "https://m.media-amazon.com/images/M/MV5BNmExMTkyYjItZTg0YS00NWYzLTkwMjItZWJiOWQ2M2ZkYjE4XkEyXkFqcGdeQXVyMTQxNzMzNDI@._V1_SX300.jpg",
  "Ratings": [
    {
      "Source": "Internet Movie Database",
      "Value": "6.2/10"
    },
    {
      "Source": "Rotten Tomatoes",
      "Value": "33%"
    },
    {
      "Source": "Metacritic",
      "Value": "46/100"
    }
  ],
  "Metascore": "46",
  "imdbRating": "6.2",
  "imdbVotes": "62,125",
  "imdbID": "tt0113243",
  "Type": "movie",
  "DVD": "24 Apr 2001",
  "BoxOffice": "N/A",
  "Production": "MGM",
  "Website": "N/A",
  "Response": "True"
}

{
  "Title": "Friends",
  "Year": "1994–2004",
  "Rated": "TV-14",
  "Released": "22 Sep 1994",
  "Runtime": "22 min",
  "Genre": "Comedy, Romance",
  "Director": "N/A",
  "Writer": "David Crane, Marta Kauffman",
  "Actors": "Jennifer Aniston, Courteney Cox, Lisa Kudrow, Matt LeBlanc",
  "Plot": "Follows the personal and professional lives of six twenty to thirty-something-year-old friends living in Manhattan.",
  "Language": "English, Dutch, Italian, French",
  "Country": "USA",
  "Awards": "Won 1 Golden Globe. Another 68 wins & 211 nominations.",
  "Poster": "https://m.media-amazon.com/images/M/MV5BNDVkYjU0MzctMWRmZi00NTkxLTgwZWEtOWVhYjZlYjllYmU4XkEyXkFqcGdeQXVyNTA4NzY1MzY@._V1_SX300.jpg",
  "Ratings": [
    {
      "Source": "Internet Movie Database",
      "Value": "8.9/10"
    }
  ],
  "Metascore": "N/A",
  "imdbRating": "8.9",
  "imdbVotes": "696,324",
  "imdbID": "tt0108778",
  "Type": "series",
  "totalSeasons": "10",
  "Response": "True"
}

interface OmdbEntry {
  Title: String!
  Genre: String!
  Plot: String!
  Actors: [String!]
}

type OmdbMovie implements OmdbEntry {
  Title: String!
  Genre: String!
  Plot: String!
  Actors: [String!]

  Production: String!
}

type OmdbSeries implements OmdbEntry {
  Title: String!
  Genre: String!
  Plot: String!
  Actors: [String!]

  totalSeasons: Int!
}

type OmdbService {

  search(title: String): [OmdbEntry!]

}

package graphql

import static graphql.Scalars.GraphQLInt
import static graphql.Scalars.GraphQLString
import static graphql.schema.GraphQLArgument.newArgument
import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition
import static graphql.schema.GraphQLInterfaceType.newInterface
import static graphql.schema.GraphQLList.list
import static graphql.schema.GraphQLNonNull.nonNull
import static graphql.schema.GraphQLObjectType.newObject

// Define the fields common to all types
def entryFields = [
  newFieldDefinition()
    .name('Title')
    .description('The title of the entry')
    .type(nonNull(GraphQLString))
    .build(),
  newFieldDefinition()
    .name('Genre')
    .description('The genre of the entry')
    .type(nonNull(GraphQLString))
    .build(),
  newFieldDefinition()
    .name('Plot')
    .description('The plot of the entry')
    .type(nonNull(GraphQLString))
    .build(),
  newFieldDefinition()
    .name('Actors')
    .description('The main cast of the entry')
    .type(list(nonNull(GraphQLString)))
    .build()
]

// Define the parent type
def entryType = newInterface()
  .name('OmdbEntry')
  .description('The generic entry returned by the API')
  .fields(entryFields)
  .build()

// Define the type for movies
def movieType = newObject()
  .name('OmdbMovie')
  .description('The entry returned for movies by the API')
  // Use the parent type
  .withInterface(entryType)
  // GraphQL required to repeat all fields from the interface
  .fields(entryFields)
  .field(newFieldDefinition()
    .name('Production')
    .description('The studio of the entry')
    .type(nonNull(GraphQLString))
  )
  .build()

def seriesType = newObject()
  .name('OmdbSeries')
  .description('The entry returned for series by the API')
  // Use the parent type
  .withInterface(entryType)
  // GraphQL required to repeat all fields from the interface
  .fields(entryFields)
  .field(newFieldDefinition()
    .name('totalSeasons')
    .description('The number of seasons of the entry')
    .type(nonNull(GraphQLInt))
  )
  .build()

// Add the resolver for the new types
schema.resolver('OmdbEntry', { env ->
  // The API returns the type as a field
  switch(env.object.Type) {
    case 'movie':
      return movieType
    case 'series':
      return seriesType
  }
})

// Add the child types to the schema
// (this is needed because they are not used directly in any field)
schema.additionalTypes(movieType, seriesType)

// Add the new fields to the top level type
schema.field(newFieldDefinition()
  .name('omdb') // this field is used to wrap the service calls
  .description('All operations related to the OMDb API')
  .type(newObject() // inline type definition
    .name('OmdbService')
    .description('Exposes the OMDb Service')
    .field(newFieldDefinition()
      .name('search')
      .description('Performs a search by title')
      // uses the parent type, the resolver will define the concrete type
      .type(list(nonNull(entryType)))
      .argument(newArgument()
        .name('title')
        .description("The title to search")
        .type(GraphQLString)
      )
    )
  )
)

// Add the fetcher for the search field,
schema.fetcher('OmdbService', 'search', { env ->
  // calls the Groovy bean passing the needed parameters
  applicationContext.omdbService.search(env.getArgument('title'))
})

// Define a fetcher to split the value returned by the API for the Actors
def actorsFetcher = { env -> env.source.Actors?.split(',')*.trim() }

// Add the fetcher to the concrete types
schema.fetcher('OmdbMovie', 'Actors', actorsFetcher)
schema.fetcher('OmdbSeries', 'Actors', actorsFetcher)