18 KiB
| id | title | sidebar_label |
|---|---|---|
| graphql | How to GraphQL | GraphQL Syntax |
GraphQL (GQL) is a simple query syntax that's fast replacing REST APIs. GQL is great since it allows web developers to fetch the exact data that they need without depending on changes to backend code. Also if you squint hard enough it looks a little bit like JSON 😃
The below query will fetch an users name, email and avatar image (renamed as picture). If you also need the users id then just add it to the query.
query {
user {
full_name
email
picture: avatar
}
}
Multiple tables can also be fetched using a single GraphQL query. This is very fast since the entire query is converted into a single SQL query which the database can efficiently run.
query {
user {
full_name
email
}
products {
name
description
}
}
Fetching data
To fetch a specific product by it's ID you can use the id argument. The real name id field will be resolved automatically so this query will work even if your id column is named something like product_id.
query {
products(id: 3) {
name
}
}
Postgres also supports full text search using a TSV index. Super Graph makes it easy to use this full text search capability using the search argument.
query {
products(search: "ale") {
name
}
}
Sorting
To sort or ordering results just use the order_by argument. This can be combined with where, search, etc to build complex queries to fit you needs.
query {
products(order_by: { cached_votes_total: desc }) {
id
name
}
}
Filtering
Super Graph support complex queries where you can add filters, ordering,offsets and limits on the query. For example the below query will list all products where the price is greater than 10 and the id is not 5.
query {
products(where: { and: { price: { gt: 10 }, not: { id: { eq: 5 } } } }) {
name
price
}
}
Nested where clause targeting related tables
Sometimes you need to query a table based on a condition that applies to a related table. For example say you need to list all users who belong to an account. This query below will fetch the id and email or all users who belong to the account with id 3.
query {
users(where: {
accounts: { id: { eq: 3 } }
}) {
id
email
}
}`
Logical Operators
| Name | Example | Explained |
|---|---|---|
| and | price : { and : { gt: 10.5, lt: 20 } | price > 10.5 AND price < 20 |
| or | or : { price : { greater_than : 20 }, quantity: { gt : 0 } } | price >= 20 OR quantity > 0 |
| not | not: { or : { quantity : { eq: 0 }, price : { eq: 0 } } } | NOT (quantity = 0 OR price = 0) |
Other conditions
| Name | Example | Explained |
|---|---|---|
| eq, equals | id : { eq: 100 } | id = 100 |
| neq, not_equals | id: { not_equals: 100 } | id != 100 |
| gt, greater_than | id: { gt: 100 } | id > 100 |
| lt, lesser_than | id: { gt: 100 } | id < 100 |
| gte, greater_or_equals | id: { gte: 100 } | id >= 100 |
| lte, lesser_or_equals | id: { lesser_or_equals: 100 } | id <= 100 |
| in | status: { in: [ "A", "B", "C" ] } | status IN ('A', 'B', 'C) |
| nin, not_in | status: { in: [ "A", "B", "C" ] } | status IN ('A', 'B', 'C) |
| like | name: { like "phil%" } | Names starting with 'phil' |
| nlike, not_like | name: { nlike "v%m" } | Not names starting with 'v' and ending with 'm' |
| ilike | name: { ilike "%wOn" } | Names ending with 'won' case-insensitive |
| nilike, not_ilike | name: { nilike "%wOn" } | Not names ending with 'won' case-insensitive |
| similar | name: { similar: "%(b|d)%" } | Similar Docs |
| nsimilar, not_similar | name: { nsimilar: "%(b|d)%" } | Not Similar Docs |
| has_key | column: { has_key: 'b' } | Does JSON column contain this key |
| has_key_any | column: { has_key_any: [ a, b ] } | Does JSON column contain any of these keys |
| has_key_all | column: [ a, b ] | Does JSON column contain all of this keys |
| contains | column: { contains: [1, 2, 4] } | Is this array/json column a subset of value |
| contained_in | column: { contains: "{'a':1, 'b':2}" } | Is this array/json column a subset of these value |
| is_null | column: { is_null: true } | Is column value null or not |
Aggregations
You will often find the need to fetch aggregated values from the database such as count, max, min, etc. This is simple to do with GraphQL, just prefix the aggregation name to the field name that you want to aggregrate like count_id. The below query will group products by name and find the minimum price for each group. Notice the min_price field we're adding min_ to price.
query {
products {
name
min_price
}
}
| Name | Explained |
|---|---|
| avg | Average value |
| count | Count the values |
| max | Maximum value |
| min | Minimum value |
| stddev | Standard Deviation |
| stddev_pop | Population Standard Deviation |
| stddev_samp | Sample Standard Deviation |
| variance | Variance |
| var_pop | Population Standard Variance |
| var_samp | Sample Standard variance |
All kinds of queries are possible with GraphQL. Below is an example that uses a lot of the features available. Comments # hello are also valid within queries.
query {
products(
# returns only 30 items
limit: 30
# starts from item 10, commented out for now
# offset: 10,
# orders the response items by highest price
order_by: { price: desc }
# no duplicate prices returned
distinct: [price]
# only items with an id >= 30 and < 30 are returned
where: { id: { and: { greater_or_equals: 20, lt: 28 } } }
) {
id
name
price
}
}
Custom Functions
Any function defined in the database like the below add_five that adds 5 to any number given to it can be used
within your query. The one limitation is that it should be a function that only accepts a single argument. The function is used within you're GraphQL in similar way to how aggregrations are used above. Example below
query {
thread(id: 5) {
id
total_votes
add_five_total_votes
}
}
Postgres user-defined function add_five
CREATE OR REPLACE FUNCTION add_five(a integer) RETURNS integer AS $$
BEGIN
RETURN a + 5;
END;
$$ LANGUAGE plpgsql;
In GraphQL mutations is the operation type for when you need to modify data. Super Graph supports the insert, update, upsert and delete. You can also do complex nested inserts and updates.
When using mutations the data must be passed as variables since Super Graphs compiles the query into an prepared statement in the database for maximum speed. Prepared statements are are functions in your code when called they accept arguments and your variables are passed in as those arguments.
Insert
{
"data": {
"name": "Art of Computer Programming",
"description": "The Art of Computer Programming (TAOCP) is a comprehensive monograph written by computer scientist Donald Knuth",
"price": 30.5
}
}
mutation {
product(insert: $data) {
id
name
}
}
Bulk insert
{
"data": [
{
"name": "Art of Computer Programming",
"description": "The Art of Computer Programming (TAOCP) is a comprehensive monograph written by computer scientist Donald Knuth",
"price": 30.5
},
{
"name": "Compilers: Principles, Techniques, and Tools",
"description": "Known to professors, students, and developers worldwide as the 'Dragon Book' is available in a new edition",
"price": 93.74
}
]
}
mutation {
product(insert: $data) {
id
name
}
}
Update
{
"data": {
"price": 200.0
},
"product_id": 5
}
mutation {
product(update: $data, id: $product_id) {
id
name
}
}
Bulk update
{
"data": {
"price": 500.0
},
"gt_product_id": 450.0,
"lt_product_id:": 550.0
}
mutation {
product(
update: $data
where: { price: { gt: $gt_product_id, lt: lt_product_id } }
) {
id
name
}
}
Delete
{
"data": {
"price": 500.0
},
"product_id": 5
}
mutation {
product(delete: true, id: $product_id) {
id
name
}
}
Bulk delete
{
"data": {
"price": 500.0
}
}
mutation {
product(delete: true, where: { price: { eq: { 500.0 } } }) {
id
name
}
}
Upsert
{
"data": {
"id": 5,
"name": "Art of Computer Programming",
"description": "The Art of Computer Programming (TAOCP) is a comprehensive monograph written by computer scientist Donald Knuth",
"price": 30.5
}
}
mutation {
product(upsert: $data) {
id
name
}
}
Bulk upsert
{
"data": [
{
"id": 5,
"name": "Art of Computer Programming",
"description": "The Art of Computer Programming (TAOCP) is a comprehensive monograph written by computer scientist Donald Knuth",
"price": 30.5
},
{
"id": 6,
"name": "Compilers: Principles, Techniques, and Tools",
"description": "Known to professors, students, and developers worldwide as the 'Dragon Book' is available in a new edition",
"price": 93.74
}
]
}
mutation {
product(upsert: $data) {
id
name
}
}
Often you will need to create or update multiple related items at the same time. This can be done using nested mutations. For example you might need to create a product and assign it to a user, or create a user and his products at the same time. You just have to use simple json to define you mutation and Super Graph takes care of the rest.
Nested Insert
Create a product item first and then assign it to a user
{
"data": {
"name": "Apple",
"price": 1.25,
"created_at": "now",
"updated_at": "now",
"user": {
"connect": { "id": 5 }
}
}
}
mutation {
product(insert: $data) {
id
name
user {
id
full_name
email
}
}
}
Or it's reverse, create the user first and then his product
{
"data": {
"email": "thedude@rug.com",
"full_name": "The Dude",
"created_at": "now",
"updated_at": "now",
"product": {
"name": "Apple",
"price": 1.25,
"created_at": "now",
"updated_at": "now"
}
}
}
mutation {
user(insert: $data) {
id
full_name
email
product {
id
name
price
}
}
}
Nested Update
Update a product item first and then assign it to a user
{
"data": {
"name": "Apple",
"price": 1.25,
"user": {
"connect": { "id": 5 }
}
}
}
mutation {
product(update: $data, id: 5) {
id
name
user {
id
full_name
email
}
}
}
Or it's reverse, update a user first and then his product
{
"data": {
"email": "newemail@me.com",
"full_name": "The Dude",
"product": {
"name": "Banana",
"price": 1.25
}
}
}
mutation {
user(update: $data, id: 1) {
id
full_name
email
product {
id
name
price
}
}
}
Pagination
This is a must have feature of any API. When you want your users to go through a list page by page or implement some fancy infinite scroll you're going to need pagination. There are two ways to paginate in Super Graph.
Limit-Offset This is simple enough but also inefficient when working with a large number of total items. Limit, limits the number of items fetched and offset is the point you want to fetch from. The below query will fetch 10 results at a time starting with the 100th item. You will have to keep updating offset (110, 120, 130, etc ) to walk thought the results so make offset a variable.
query {
products(limit: 10, offset: 100) {
id
slug
name
}
}
Cursor
This is a powerful and highly efficient way to paginate a large number of results. Infact it does not matter how many total results there are this will always be lighting fast. You can use a cursor to walk forward or backward through the results. If you plan to implement infinite scroll this is the option you should choose.
When going this route the results will contain a cursor value this is an encrypted string that you don't have to worry about just pass this back in to the next API call and you'll received the next set of results. The cursor value is encrypted since its contents should only matter to Super Graph and not the client. Also since the primary key is used for this feature it's possible you might not want to leak it's value to clients.
You will need to set this config value to ensure the encrypted cursor data is secure. If not set a random value is used which will change with each deployment breaking older cursor values that clients might be using so best to set it.
# Secret key for general encryption operations like
# encrypting the cursor data
secret_key: supercalifajalistics
Paginating forward through your results
{
"variables": {
"cursor": "MJoTLbQF4l0GuoDsYmCrpjPeaaIlNpfm4uFU4PQ="
}
}
query {
products(first: 10, after: $cursor) {
slug
name
}
}
Paginating backward through your results
query {
products(last: 10, before: $cursor) {
slug
name
}
}
"data": {
"products": [
{
"slug": "eius-nulla-et-8",
"name" "Pale Ale"
},
{
"slug": "sapiente-ut-alias-12",
"name" "Brown Ale"
}
...
],
"products_cursor": "dJwHassm5+d82rGydH2xQnwNxJ1dcj4/cxkh5Cer"
}
Nested tables can also have cursors. Requesting multiple cursors are supported on a single request but when paginating using a cursor only one table is currently supported. To explain this better, you can only use a before or after argument with a cursor value to paginate a single table in a query.
query {
products(last: 10) {
slug
name
customers(last: 5) {
email
full_name
}
}
}
Multiple order-by arguments are supported. Super Graph is smart enough to allow cursor based pagination when you also need complex sort order like below.
query {
products(
last: 10
before: $cursor
order_by: [ price: desc, total_customers: asc ]) {
slug
name
}
}
Using Variables
Variables ($product_id) and their values ("product_id": 5) can be passed along side the GraphQL query. Using variables makes for better client side code as well as improved server side SQL query caching. The built-in web-ui also supports setting variables. Not having to manipulate your GraphQL query string to insert values into it makes for cleaner
and better client side code.
// Define the request object keeping the query and the variables seperate
var req = {
query: "{ product(id: $product_id) { name } }",
variables: { product_id: 5 },
};
// Use the fetch api to make the query
fetch("http://localhost:8080/api/v1/graphql", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(req),
})
.then((res) => res.json())
.then((res) => console.log(res.data));