MongoDB.local Berlin: Building a GraphQL API with MongoDB, Prisma and Typescript

Building a GraphQL API with
MongoDB, Prisma & TypeScript
@nikolasbur
k

Nikolas Burk
Based in Berlin
Developer at @prisma
@nikolasbur
k
@nikolasbur
k

GraphQL Introduction
Understanding GraphQL Servers
Building GraphQL Servers with MongoDB,
Prisma & TypeScript
Agenda
@nikolasbur
k
1
2
3

GraphQL Introduction
@nikolasbur
k
1

● A query language for APIs (alternative to REST)
● Language-agnostic on backend and frontend
● Developed by Facebook, now led by GraphQL Foundation
What is GraphQL?

GraphQL has become the
new API standard

Beneﬁts of GraphQL
✓ "Query exactly the data you need" (in a single request)
✓ Declarative & strongly typed schema
✓ Schema used as cross-team communication tool
✓ Decouples teams
✓ Incrementally adoptable
✓ Rich ecosystem & very active community

query {
user(id: “user123”) {
name
posts {
title
}
}
}
HTTP POST
{
"data" :{
"user": {
"name": "Sarah",
"posts": [
{ "title": "Join us for GraphQL Conf 2019” },
{ "title": "GraphQL is the future of APIs" },
]
}
}
}

REST
● Multiple endpoints
● Server decides what data is returned
GraphQL
● Single endpoint
● Client decides what data is returned

Architectures / Use cases of GraphQL
GraphQL-Native Backend GraphQL as API Gateway

Understanding
GraphQL Servers
@nikolasbur
k
2

API deﬁnition: The GraphQL schema
Implementation: Resolver functions
Server: Network (HTTP), Middleware, …
3 parts of a GraphQL server
1
2
3

“Hello World”
const Query = queryType({
definition(t) {
t.string('hello', {
args: { name: stringArg() },
resolve: (_, args) => {
return `Hello ${args.name}`
}
})
},
})
const schema = makeSchema({ types: [Query] })
const server = new GraphQLServer({ schema })
server.start(() => console.log(`Running on http://localhost:4000`))
index.ts

“Hello World”
definition(t) {
t.string('hello', {
resolve: (_, args) => {
return `Hello ${args.name}`
}
})
},
})
const schema = makeSchema({ types: [Query] })
const server = new GraphQLServer({ schema })
server.start(() => console.log(`Running on http://localhost:4000`))
type Query {
hello(name: String!): String!
}
index.ts schema.graphql (generated)

`User` model: Query
const User = objectType({
name: 'User',
definition(t) {
t.id('id')
t.string('name')
}
})
definition(t) {
t.field('users', {
type: 'User',
list: true,
resolve: () => db.users.findAll()
})
},
})
index.ts

name: 'User',
definition(t) {
t.id('id')
t.string('name')
}
})
definition(t) {
t.field('users', {
type: 'User',
list: true,
})
},
})
index.ts
`User` model: Query

name: 'User',
definition(t) {
t.id('id')
t.string('name')
}
})
definition(t) {
t.field('users', {
type: 'User',
list: true,
})
},
})
index.ts
type User {
id: ID!
name: String!
}
type Query {
users: [User!]!
}
schema.graphql (generated)
`User` model: Query

name: 'User',
definition(t) {
t.id('id')
t.string('name')
}
})
const Mutation = mutationType({
definition(t) {
t.field('createUser', {
type: 'User',
list: true,
resolve: (_, args) => db.users.create({name: args.name})
})
},
})
index.ts
`User` model: Mutation

name: 'User',
definition(t) {
t.id('id')
t.string('name')
}
})
const Mutation = mutationType({
definition(t) {
t.field('createUser', {
type: 'User',
list: true,
resolve: (_, args) => db.users.create({name: args.name})
})
},
})
index.ts
type User {
id: ID!
name: String!
}
type Mutation {
createUser(name: String): User!
}
schema.graphql (generated)
`User` model: Mutation

Building GraphQL Servers
with Prisma
@nikolasbur
k
3

GraphQL resolvers are hard
✗ A lot of CRUD boilerplate
✗ Deeply nested queries
✗ Performant database access & N+1 problem
✗ Database transactions
✗ Difficult to achieve full type-safety
✗ Implementing realtime operations

What is Prisma?
Database Access (ORM)
Type-safe database access with
the auto-generated Prisma client
Migrations
Declarative data modeling and
schema migrations
Admin UI
Visual data management with
Prisma Admin
Prisma replaces traditional ORMs and simplifies database workflows
Query Analytics
Quickly identify slow data
access patterns

Prisma is the database-interface for
application developers

Flexibility and (type-)safety with
MongoDB & Prisma
✓ Flexible & safe schema maintenance
✓ Type-safe database access with the auto-
generated Prisma client
✓ Uses introspection for your existing MongoDB
✓ Relations via embedded types or references
✓ Prisma + MongoDB = Best of both worlds

Prisma + GraphQL = GraphQL Yoga !
● GraphQL-native backend framework for Node.js
● Modern alternative to Ruby on Rails, Spring, Django, …
● Features:
✓ Full type-safety (supporting JavaScript & TypeScript)
✓ Deep database integration via Prisma
✓ Powerful CLI (incl. scaffolding, hot-reload dev server, build, ...)
✓ Compatible with GraphQL ecosystem

Thank you !
@nikolasbur
k
@nikolasbur
k
CFP Closed

Thank you !
@nikolasbur
k
@nikolasbur
k

MongoDB.local Berlin: Building a GraphQL API with MongoDB, Prisma and Typescript

More Related Content

What's hot (20)

Similar to MongoDB.local Berlin: Building a GraphQL API with MongoDB, Prisma and Typescript (20)

More from MongoDB (20)

Recently uploaded (20)

MongoDB.local Berlin: Building a GraphQL API with MongoDB, Prisma and Typescript