GraphQL and Groovy

#greachConf @marioggar © Mario Garcia 2017
GRAPHQL AND GROOVYGRAPHQL AND GROOVYGRAPHQL AND GROOVYGRAPHQL AND GROOVYGRAPHQL AND GROOVYGRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVY
GRAPHQL AND GROOVYGRAPHQL AND GROOVY
@marioggar
1

ABOUT ME
Name
Mario Garcia
You can find me:
https://twitter.com/marioggar
https://github.com/mariogarcia
2 . 1

PROUD MEMBER OF…
2 . 2

WORKING AT KALEIDOS
2 . 3

BUT A GREAT FAMILY
2 . 4

LET ME TELL YOU WHY YOU’RE HERE…
I’ve heard GraphQL is the next big thing
If I do one more REST app I’ll kill myself
I didn’t find any other interesting talk
Whatever it is…
3 . 1

3 . 2

SUMMARY
4 . 1

GraphQL overview
GraphQL types query language
GraphQL + JVM + HTTP
Conclusions
4 . 2

GRAPHQL OVERVIEW
5 . 1

WHAT IS GRAPHQL
Is a query language
Is also a server-side runtime spec
It uses a type system to define those queries
5 . 2

WHAT IS NOT GRAPHQL
Is not a web framework
Is not about HTTP
And definitely, definitely, definitely…
GraphQL is not REST
5 . 3

GRAPHQL VS REST
5 . 4

WHY WE COULD WANT TO MOVE TO GRAPHQL ?
5 . 5

FIRST OF ALL
While REST is an architectural concept
GraphQL is just a query language
5 . 6

DIFFERENCES
Resources vs Queries
Rest: 1 URI =⇒ 1 resource
GraphQL: 1 URI =⇒ n dataset
Application layer
Rest == HTTP
GraphQL is not tied to any specific protocol
Front-End friendly
Rest: Back end is the king ...and the bottleneck
5 . 7

NO PROBLEM. I'LL SEE WHAT I CAN DO
5 . 8

THE CHALLENGE
I want to expose all James Bond films information
Users will ONLY use web browsers...FOR NOW
BUT we have to be ready for mobile AT SOME POINT
5 . 9

WHAT DO WE DO ?
We build up 1 API endpoint
Only targets 1 device
Still we can create a couple of views for the
same data
5 . 10

THEN SHIT HAPPENS!
5 . 11

AND NORMALLY GETS WORST
Users want to see A, B, and C in user home
Front end could reuse views
and/or aggregate calls
still may not be enough and they will start asking back-end
to do more… and more … and more…
5 . 12

5 . 13

THEN YOU REMEMBER THAT…
ONLY means in addition
FOR NOW means within the next two weeks
BUT means winter is coming!
and of course…AT SOME POINT means probably next
week
5 . 14

GRAPHQL + HTTP TO THE RESCUE!
5 . 15

5 . 16

WHAT CHANGED ?
GraphQL HTTP endpoint as a common query interface
Therefore a lot more flexibility for front end
Your REST/NOT-REST microservices will be easier to
maintain
Will be easier to keep one single responsability in each one
of them
5 . 17

EXECUTING QUERIES
6 . 1

STEPS TO EXECUTE A QUERY
Define TYPES
Define QUERIES
Execute queries against schema
6 . 2

FIRST EXAMPLE
6 . 3

FIRST EXAMPLE: SCHEMA
type Film {
title: !String
year: Int
}
type Queries {
lastFilm: Film
filmByYear(year: Int): Film
}
schema {
query: Queries
}
http://facebook.github.io/graphql/
6 . 4

FIRST EXAMPLE: TYPES
Client CAN add/omit as many optional fields as it wants
Client MUST add mandatory fields in the query
type Film {
title: !String
year: Int
}
6 . 5

FIRST EXAMPLE : QUERIES
Queries always use types or scalars
Queries may have arguments
type Queries {
lastFilm: Film
}
6 . 6

FIRST EXAMPLE : EXECUTE QUERY
query: "give me the last James Bond film with its title
result: "SPECTRE"
{
lastFilm {
title
}
}
{
"data": {
"lastFilm": {
"title": "SPECTRE"
}
}
}
6 . 7

LITTLE BIT CLOSER
query
1. lastFilm: Is the query I’m interested in
2. title: Is a specific field in the return type (Film)
{
lastFilm { (1)
title (2)
}
}
6 . 8

VALIDATION
title is mandatory
invalid query
type Film {
title: !String
year: Int
}
{
lastFilm
}
6 . 9

6 . 10

JVM LIBRARIES OUT THERE!
GraphQL-Java
https://github.com/graphql-java/graphql-java
6 . 11

FIRST EXAMPLE REVISITED: TYPES
type Film {
title: !String
year: Int
}
GraphQLObjectType.newObject()
.name("Film")
.field(newFieldDefinition()
.type(GraphQLString)
.name("title"))
.type(GraphQLInt)
.name("year"))
.build();
6 . 12

FIRST EXAMPLE REVISITED: QUERIES
type Queries {
lastFilm: Film
}
schema {
query: Queries
}
GraphQLObjectType lastFilm =
.name("Queries")
.type(filmType)
.name("lastFilm")
.dataFetcher(Queries::findLastFilm))
.build();
return GraphQLSchema
.newSchema()
.query(lastFilm)
.build();
6 . 13

DATA FETCHER
Functional Interface graphql.schema.DataFetcher
If using JDK could use method reference
If using Groovy Closures FTW
If using Groovy w Parrot → Both o/
6 . 14

FIRST EXAMPLE REVISITED: EXECUTION
1. schema: query + types definition
2. query: query string
3. context: helpful for adding metadata (e.g. authorization)
4. variables: if the query has any
Map<String,Object> result = new GraphQL(schema) (1)
.execute(query, (2)
null, (3)
"") (4)
.getData() as Map<String,Object>
6 . 15

TOO MUCH JAVA CODE…
6 . 16

6 . 17

GRAPHQL DSL (GQL)
DSL over GraphQL-Java
Still alpha
Feeback is very welcome :)
https://github.com/grooviter/gql
6 . 18

GROOVY TIME: TYPES
type Film {
title: !String
year: Int
}
DSL.type('Film') {
field('title') {
type nonNull(GraphQLString)
}
field('something', GraphQLBoolean)
field('year') {
description 'release date'
type GraphQLString
}
}
6 . 19

GROOVY TIME: TYPES (II)
vs
.name("Film")
.type(GraphQLString)
.name("title"))
.type(GraphQLInt)
.name("year"))
.build();
DSL.type('Film') {
field('title') {
type nonNull(GraphQLString)
}
field('something', GraphQLBoolean)
field('year') {
description 'release date'
type GraphQLString
}
}
6 . 20

GROOVY TIME: QUERIES
type Queries {
lastFilm: Film
}
schema {
query: Queries
}
return DSL.schema {
query('Queries') {
field('lastFilm') {
type Schema.FilmType
fetcher Queries.&findLastFilm
}
field('byYear') {
fetcher Queries.&findByYear
argument('year') {
type GraphQLString
}
}
}
}
6 . 21

GROOVY TIME: QUERIES (II)
vs
GraphQLObjectType lastFilm =
.name("Queries")
.type(filmType)
.name("lastFilm")
.dataFetcher(Queries::findLastFilm))
.build();
return GraphQLSchema
.newSchema()
.query(lastFilm)
.build();
return DSL.schema {
query('Queries') {
field('lastFilm') {
}
field('byYear') {
argument('year') {
type GraphQLString
}
}
6 . 22

GROOVY TIME: QUERY EXECUTION
yields
def result = DSL
.execute(schema, queryString)
.data as Map<String,Object>
{
lastFilm: {
year: 2015,
title: 'SPECTRE'
}
}
6 . 23

GROOVY TIME: QUERY EXECUTION (II)
vs
Map<String,Object> result = new GraphQL(schema) (1)
.execute(query, (2)
null, (3)
"") (4)
.getData() as Map<String,Object>
def result = DSL
.execute(schema, queryString)
.data as Map<String,Object>
6 . 24

QUERIES WITH ARGUMENTS
6 . 25

WHO KNOWS THE TITLE OF 1962 ?
query
query execution
queryString = '''
query FindBondFilmByYear($year: String){
byYear(year: $year) {
year
title
}
}
'''
Map<String,Object> result = DSL
.execute(schema, queryString, [year: year])
.data
6 . 26

DR. NO
[byYear: [
title: 'DR. NO',
year: "1962"
]
]
6 . 27

NOW…
6 . 28

WOULDN’T IT COOL IF I EXPOSE THIS TO THE
WORLD ?
6 . 29

HTTP + GRAPHQL
7 . 1

RATPACK + GRAPHQL
7 . 2

TECHNOLOGIES USED
Ratpack
GraphQL-java
GQL
GraphiQL
7 . 3

FULL FILM TYPE
And it fits in the slide!!
static final GraphQLObjectType Film =
DSL.type('Film') {
field 'title' , nonNull(GraphQLString)
field 'year' , GraphQLInt
field 'directedBy' , GraphQLString
field 'bond' , GraphQLString
field 'themeSong' , list(ThemeSong)
field 'bondGirls' , list(BondGirl)
field 'villains' , list(Villain)
field 'counterparts', list(CounterPart)
field 'gadgets' , list(GraphQLString)
field 'vehicles' , list(GraphQLString)
}
7 . 4

QUERIES
return DSL.schema {
query('Queries') {
field('lastFilm') {
type Schema.Film
}
field('byYear') {
type Schema.Film
argument('year') {
type GraphQLString
}
}
field('byBondActorNameLike') {
type list(Schema.Film)
fetcher Queries.&byBondActorNameLike
argument('name') {
type GraphQLString
}
}
}
}
7 . 5

RATPACK HANDLER
class GraphQLHandler implements Handler {
@Inject
GraphQLSchema schema
@Override
void handle(final Context ctx) {
def payload = ctx.get(Map) // JSON request => Map
Blocking.get {
DSL.execute(schema, "${payload.query}", payload.variables as Map<String,Object>)
}.then { ExecutionResult result ->
def response = [data: result.errors ?: result.data]
ctx.render json(response)
}
}
}
7 . 6

URI MAPPING
1. GraphQL endpoint
2. GraphiQL web console
handlers {
prefix('graphql') { (1)
all(createBindingHandler(Map))
post(GraphQLHandler)
}
files { (2)
dir('static').indexFiles('index.html')
}
}
7 . 7

SHOWTIME!
query UserHome($actor: String, $year: String) {
latest: lastFilm {
title
year
directedBy
bond
}
whenIwasBorn: byYear(year: $year) {
title
}
favouriteActorMovies: byBondActorNameLike(name: $actor) {
title
year
bond
}
}
7 . 8

A WORD ON QUERIES & MUTATIONS
Queries are supposed to be able to be batched
Queries are supposed to be computed in parallel
Mutations are supposed to run sequentially
7 . 9

GRAILS + RELAY
7 . 10

RELAY ?
Good GraphQL practices implemented in a JS library
https://facebook.github.io/relay/
7 . 11

RELAY
How to handle pagination
How to handle ids
HTTP recommended features
…
http://graphql.org/learn/best-practices/
7 . 12

GORM GRAPHQL
Plugin Grails 3
https://github.com/mrcirillo/relay-gorm-connector
7 . 13

GRAPHQL SCHEMA
@RelayType(description='An optional description of a film')
class Film {
@RelayField(description='An optional description of name')
String title
String year
String bond
}
7 . 14

GRAILS URLMAPPINGS
post "/graphql"(controller: "graph")
7 . 15

GRAILS CONTROLLER
class GraphController {
def relayService // provided by plugin
def index() {
def query = request.JSON.query.toString()
def vars = request.JSON.variables
def result = relayService.query(query, null, vars?:[:])
render(result as JSON)
}
}
7 . 16

GRAPHQL BEST PRACTICES HINT: ID HASHING
Instead of passing 1 use a hash like hagghsXy==
def idString = RelayHelpers.toGlobalId("Film", film.id.toString())
def query = """
query {
node(id: "$idString") {
... on Film {
title
}
}
}
"""
7 . 17

CONCLUSIONS
Is not GraphQL instead of REST
Is about GraphQL over your existent services
A great improvement from the business point of view
Your front end workmates will love you
8 . 1

THANK YOU!
8 . 2

QUESTIONS & ANSWERS
9

GraphQL and Groovy

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Plus de Mario García

Plus de Mario García (16)

Dernier

Dernier (20)

GraphQL and Groovy