IMPORTANT: This solution assumes that you already have theFastly CLI installed. If you are new to the platform, read ourGetting Started guide.

$ mkdir graphql && cd graphql
$ fastly compute init
Creating a new Compute project.
Press ^C at any time to quit.
Name: [graphql]
Description: A GraphQL processor at the edge
Author: My Name
Language:
[1] Rust
[2] JavaScript
[4] Other ('bring your own' Wasm binary)
Choose option: [1]
Starter kit:
[1] Default starter for Rust
    A basic starter kit that demonstrates routing, simple synthetic responses and
    overriding caching rules.
    https://github.com/fastly/compute-starter-kit-rust-default
[2] Beacon termination
    Capture beacon data from the browser, divert beacon request payloads to a log
    endpoint, and avoid putting load on your own infrastructure.
    https://github.com/fastly/compute-starter-kit-rust-beacon-termination
[3] Static content
    Apply performance, security and usability upgrades to static bucket services such as
    Google Cloud Storage or AWS S3.
    https://github.com/fastly/compute-starter-kit-rust-static-content
Choose option or paste git URL: [1]

juniper={version="0.15.10",default-features=false}

HINT: If your backends respond with XML, you could adapt the code in this solution to use theserde-xml-rs crate.

serde={version="^1",features=["derive"]}
serde_json="^1"

{
    "ok": true,
    "data": {
        "id": "123",
        "name": "Test Bot",
        "email": "me@example.com"
    }
}

HINT: If you're starting from scratch, feel free to un-collapse and copy the entire code sample as a replacement for the default main.rs file.

8 lines
#[derive(Deserialize)]
structBackendResponse<T>{
    ok:bool,
    data:T,
}
structQuery;
#[derive(Deserialize, GraphQLObject)]
structUser{
/// User ID
    id:String,
/// Metadata
    name:String,
    email:String,
}
#[derive(Deserialize, GraphQLObject)]
structProduct{
/// Product ID
    id:String,
/// Metadata
    name:String,
    year:i32,
    color:String,
}
73 lines

HINT: If you had multiple backends, you could adapt this code to use the correct backend for each query, and introduce new backend response types if needed.

46 lines
constBACKEND_NAME:&str="api_backend";
/// The default TTL for requests.
constTTL:u32=60;
structApiClient;
impljuniper::ContextforApiClient{}
implApiClient{
pubfnnew()->ApiClient{
ApiClient{}
}
/// Get a user, given their ID.
pubfnget_user(&self, id:String)->FieldResult<User>{
let req=Request::get(format!("https://host/users/{}", id)).with_pass(true);
letmut resp= req.send(BACKEND_NAME)?;
// Read the response body into a BackendResponse
let response:BackendResponse<User>= resp.take_body_json()?;
Ok(response.data)
}
/// Get a product, given its ID.
pubfnget_product(&self, id:String)->FieldResult<Product>{
let req=Request::get(format!("https://host/products/{}", id)).with_ttl(TTL);
letmut resp= req.send(BACKEND_NAME)?;
// Read the response body into a BackendResponse
let response:BackendResponse<Product>= resp.take_body_json()?;
Ok(response.data)
}
}
27 lines

let backend=ApiClient::new();
let product= backend.get_product("abcdef".to_string())?;

35 lines
#[juniper::graphql_object(Context = ApiClient)]
implQuery{
fnuser(&self, id:String, context:&ApiClient)->FieldResult<User>{
        context.get_user(id)
}
fnproduct(&self, id:String, context:&ApiClient)->FieldResult<Product>{
        context.get_product(id)
}
}
62 lines

81 lines
#[fastly::main]
fnmain(mut req:Request)->Result<Response,Error>{
// Dispatch the request based on the method and path.
// The GraphQL API itself is at /graphql. All other paths return 404s.
let resp:Response=match(req.get_method(), req.get_path()){
(&Method::GET,"/")=>Response::from_body(playground_source("/graphql",None)),
(&Method::POST,"/graphql")=>{
// Instantiate the GraphQL schema
let root_node=RootNode::new(Query,EmptyMutation::new(),EmptySubscription::new());
// Add context to be used by the GraphQL resolver functions,
// in this case a wrapper for a Fastly backend.
let ctx=ApiClient::new();
// Deserialize the post body into a GraphQL request
let graphql_request:GraphQLRequest= req.take_body_json()?;
// Execute the request, serialize the response to JSON, and return it
let res= graphql_request.execute_sync(&root_node,&ctx);
Response::new().with_body_json(&res)?
}
        _=>Response::from_body("404 Not Found").with_status(404),
};
Ok(resp)
}

$ fastly compute publish
✓ Initializing...
✓ Verifying package manifest...
✓ Verifying local rust toolchain...
✓ Building package using rust toolchain...
✓ Creating package archive...
SUCCESS: Built rust package graphql (pkg/graphql.tar.gz)
There is no Fastly service associated with this package. To connect to an existing service
add the Service ID to the fastly.toml file, otherwise follow the prompts to create a
service now.
Press ^C at any time to quit.
Create new service: [y/N] y
✓ Initializing...
✓ Creating service...
Domain: [random-funky-words.edgecompute.app]
Backend (hostname or IP address, or leave blank to stop adding backends): mock.edgecompute.app
Backend port number: [80] 443
Backend name: [backend_1] api_backend
Backend (hostname or IP address, or leave blank to stop adding backends):
✓ Initializing...
✓ Creating domain 'random-funky-words.edgecompute.app'...
✓ Creating backend 'api_backend' (host: mock.edgecompute.app, port: 443)...
✓ Uploading package...
✓ Activating version...
Manage this service at:
        https://manage.fastly.com/configure/services/PS1Z4isxPaoZGVKVdv0eY
View this service at:
        https://random-funky-words.edgecompute.app
SUCCESS: Deployed package (service PS1Z4isxPaoZGVKVdv0eY, version 1)

usejuniper::http::playground::playground_source;
80 lines
#[fastly::main]
fnmain(mut req:Request)->Result<Response,Error>{
// Dispatch the request based on the method and path.
// The GraphQL API itself is at /graphql. All other paths return 404s.
let resp:Response=match(req.get_method(), req.get_path()){
(&Method::GET,"/")=>Response::from_body(playground_source("/graphql",None)),
(&Method::POST,"/graphql")=>{
// Instantiate the GraphQL schema
let root_node=RootNode::new(Query,EmptyMutation::new(),EmptySubscription::new());
// Add context to be used by the GraphQL resolver functions,
// in this case a wrapper for a Fastly backend.
let ctx=ApiClient::new();
// Deserialize the post body into a GraphQL request
let graphql_request:GraphQLRequest= req.take_body_json()?;
// Execute the request, serialize the response to JSON, and return it
let res= graphql_request.execute_sync(&root_node,&ctx);
Response::new().with_body_json(&res)?
}
        _=>Response::from_body("404 Not Found").with_status(404),
};
Ok(resp)
}