Rhai scripts for the Apollo Router

You can customize the Apollo Router's behavior with scripts that use the Rhai scripting language. Rhai is ideal for performing common scripting tasks (manipulating strings, processing headers, etc.) in a Rust-based project.

Your Rhai scripts can hook into multiple stages of the Apollo Router's request-handling lifecycle.

Use cases

Common use cases for Apollo Router Rhai scripts include:

• Modifying the details of HTTP requests and responses. This includes requests sent from clients to your router, along with requests sent from your router to your subgraphs. You can modify any combination of the following:
  • Request and response bodies
  • Headers
  • Status codes
  • Request context
• Logging various information throughout the request lifecycle
• Performing checkpoint-style short circuiting of requests

Setup

To enable Rhai scripts in your router, you add the following keys to the router's YAML config file:

1
# This is a top-level key. It MUST define at least one of the two
2
# sub-keys shown, even if you use that subkey's default value.
3
rhai:
4
  # Specify a different Rhai script directory path with this key.
5
  # The path can be relative or absolute.
6
  scripts: "/rhai/scripts/directory"
7

8
  # Specify a different name for your "main" Rhai file with this key.
9
  # The router looks for this filename in your Rhai script directory.
10
  main: "test.rhai"

1. Add the rhai top-level key to your router's YAML config file.
   • This key must contain at least one of a scripts key or a main key (see the example above).
2. Place all of your Rhai script files in a specific directory.
   • By default, the Apollo Router looks in the ./rhai directory (relative to the directory the router command is executed from).
   • You can override this default with the scripts key (see above).
3. Define a "main" Rhai file in your router project.
   • This file defines all of the "entry point" hooks that the Apollo Router uses to call into your script.
   • By default, the Apollo Router looks for main.rhai in your Rhai script directory.
   • You can override this default with the main key (see above).

The main file

Your Rhai script's main file defines whichever combination of request lifecycle hooks you want to use. Here's a skeleton main.rhai file that includes all available hooks and also registers all available callbacks:

1
// You don't need to define all of these hooks! Just define
2
// whichever ones your customization needs.
3

4
fn supergraph_service(service) {
5
  let request_callback = |request| {
6
      print("Supergraph service: Client request received");
7
  };
8
  
9
  let response_callback = |response| {
10
      print("Supergraph service: Client response ready to send");
11
  };
12

13
  service.map_request(request_callback);
14
  service.map_response(response_callback);
15
}
16

17
fn execution_service(service) {
18
  let request_callback = |request| {
19
      print("Execution service: GraphQL execution initiated");
20
  };
21
  
22
  let response_callback = |response| {
23
      print("Supergraph service: Client response assembled");
24
  };
25

26
  service.map_request(request_callback);
27
  service.map_response(response_callback);
28
}
29

30
// Passed an additional `subgraph` parameter that indicates the subgraph's name
31
fn subgraph_service(service, subgraph) {
32
  let request_callback = |request| {
33
      print(`Subgraph service: Ready to send sub-operation to subgraph ${subgraph}`);
34
  };
35
  
36
  let response_callback = |response| {
37
      print(`Subgraph service: Received sub-operation response from subgraph ${subgraph}`);
38
  };
39

40
  service.map_request(request_callback);
41
  service.map_response(response_callback);
42
}

You can provide exactly one main Rhai file to the Apollo Router. This means that all of your customization's functionality must originate from these hook definitions.

To organize unrelated functionality within your Rhai customization, your main file can import and use symbols from any number of other Rhai files (known as modules) in your script directory:

1
// Module file
2

3
fn process_request(request) {
4
  print("Supergraph service: Client request received");
5
}

1
// Main file
2

3
import "my_module" as my_mod;
4

5
fn process_request(request) {
6
  my_mod::process_request(request)
7
}
8

9
fn supergraph_service(service) {
10
  // Rhai convention for creating a function pointer
11
  const request_callback = Fn("process_request"); 
12
  
13
  service.map_request(request_callback);
14
}

Router request lifecycle

Before you build your Rhai script, it helps to understand how the Apollo Router handles each incoming GraphQL request. During each request's execution, different services in the router communicate with each other as shown:

As execution proceeds "left to right" from the RouterService to individual SubgraphServices, each service passes the client's original request along to the next service. Similarly, as execution continues "right to left" from SubgraphServices to the RouterService, each service passes the generated response for the client.

Your Rhai scripts can hook into any combination of the above services except the RouterService (which is reserved for built-in features). They can modify the request, response, and/or related metadata as they're passed along.

Service descriptions

Each Apollo Router service (except RouterService) has a corresponding function that a Rhai script can define to hook into that service:

Each service uses data structures for request and response data that contain:

• A context object that was created at the start of the request and is propagated throughout the entire request lifecycle. It holds:
  • The original request from the client
  • A bag of data that can be populated by plugins for communication across the request lifecycle
• Any other specific data to that service (e.g., query plans and downstream requests/responses)

Service callbacks

Each hook in your Rhai script's main file is passed a service object, which provides two methods: map_request and map_response. Most of the time in a hook, you use one or both of these methods to register callback functions that are called during the lifecycle of a GraphQL operation.

• map_request callbacks are called in each service as execution proceeds "to the right" from the router receiving a client request:

  These callbacks are each passed the current state of the client's request (which might have been modified by an earlier callback in the chain). Each callback can modify this request object directly.

  Additionally, callbacks for subgraph_service can access and modify the sub-operation request that the router will send to the corresponding subgraph via request.subgraph.

  See fields of request

• map_response callbacks are called in each service as execution proceeds back "to the left" from subgraphs resolving their individual sub-operations:

  First, callbacks for subgraph_service are each passed the response from the corresponding subgraph.

  Afterward, callbacks for execution_service, supergraph_service and then router_service are passed the combined response for the client that's assembled from all subgraph responses.

Example scripts

In addition to the examples below, see more examples in the Router repo's examples directory. Rhai-specific examples are listed in README.md.

Handling incoming requests

This example illustrates how to register router request handling.

1
// At the supergraph_service stage, register callbacks for processing requests
2
fn supergraph_service(service) {
3
    const request_callback = Fn("process_request"); // This is standard Rhai functionality for creating a function pointer
4
    service.map_request(request_callback); // Register the callback
5
}
6

7
// Generate a log for each request
8
fn process_request(request) {
9
    log_info("this is info level log message");
10
}

Manipulating headers and the request context

This example manipulates headers and the request context:

1
// At the supergraph_service stage, register callbacks for processing requests and
2
// responses.
3
fn supergraph_service(service) {
4
    const request_callback = Fn("process_request"); // This is standard Rhai functionality for creating a function pointer
5
    service.map_request(request_callback); // Register the request callback
6
    const response_callback = Fn("process_response"); // This is standard Rhai functionality for creating a function pointer
7
    service.map_response(response_callback); // Register the response callback
8
}
9

10
// Ensure the header is present in the request
11
// If an error is thrown, then the request is short-circuited to an error response
12
fn process_request(request) {
13
    log_info("processing request"); // This will appear in the router log as an INFO log
14
    // Verify that x-custom-header is present and has the expected value
15
    if request.headers["x-custom-header"] != "CUSTOM_VALUE" {
16
        log_error("Error: you did not provide the right custom header"); // This will appear in the router log as an ERROR log
17
        throw "Error: you did not provide the right custom header"; // This will appear in the errors response and short-circuit the request
18
    }
19
    // Put the header into the context and check the context in the response
20
    request.context["x-custom-header"] = request.headers["x-custom-header"];
21
}
22

23
// Ensure the header is present in the response context
24
// If an error is thrown, then the response is short-circuited to an error response
25
fn process_response(response) {
26
    log_info("processing response"); // This will appear in the router log as an INFO log
27
    // Verify that x-custom-header is present and has the expected value
28
    if response.context["x-custom-header"] != "CUSTOM_VALUE" {
29
        log_error("Error: we lost our custom header from our context"); // This will appear in the router log as an ERROR log
30
        throw "Error: we lost our custom header from our context"; // This will appear in the errors response and short-circuit the response
31
    }
32
}

Converting cookies to headers

This example converts cookies into headers for transmission to subgraphs. There is a complete working example (with tests) of this in the examples/cookies-to-headers directory.

1
// Call map_request with our service and pass in a string with the name
2
// of the function to callback
3
fn subgraph_service(service, subgraph) {
4
    // Choose how to treat each subgraph using the "subgraph" parameter.
5
    // In this case we are doing the same thing for all subgraphs
6
    // and logging out details for each.
7
    print(`registering request callback for: ${subgraph}`); // print() is the same as using log_info()
8
    const request_callback = Fn("process_request");
9
    service.map_request(request_callback);
10
}
11

12
// This will convert all cookie pairs into headers.
13
// If you only wish to convert certain cookies, you
14
// can add logic to modify the processing.
15
fn process_request(request) {
16
    print("adding cookies as headers");
17

18
    // Find our cookies
19
    let cookies = request.headers["cookie"].split(';');
20
    for cookie in cookies {
21
        // Split our cookies into name and value
22
        let k_v = cookie.split('=', 2);
23
        if k_v.len() == 2 {
24
            // trim off any whitespace
25
            k_v[0].trim();
26
            k_v[1].trim();
27
            // update our headers
28
            // Note: we must update subgraph.headers, since we are
29
            // setting a header in our subgraph request
30
            request.subgraph.headers[k_v[0]] = k_v[1];
31
        }
32
    }
33
}

Hot reloading

The router "watches" your rhai.scripts directory (along with all subdirectories), and it initiates an interpreter reload whenever it detects one of the following changes:

• Creation of a new file with a .rhai suffix
• Modification or deletion of an existing file with a .rhai suffix

The router attempts to identify any errors in your scripts before applying changes. If errors are detected, the router logs them and continues using its existing set of scripts.

Limitations

Currently, Rhai scripts cannot do the following:

• Use Rust crates
• Execute network requests
• Read or write to disk

If your router customization needs to do any of these, you can instead use external co-processing (this is an Enterprise feature).

Global variables

The router's Rhai interface can simulate closures: https://rhai.rs/book/language/fn-closure.html

However, and this is an important restriction:

" The anonymous function syntax, however, automatically captures variables that are not defined within the current scope, but are defined in the external scope – i.e. the scope where the anonymous function is created. "

Thus it's not possible for a Rhai closure to reference a global variable. For example: this kind of thing might be attempted:

1
fn supergraph_service(service){
2
    let f = |request| {
3
        let v = Router.APOLLO_SDL;
4
        print(v);
5
    };
6
    service.map_request(f);
7
}

Note: Router is a global variable.

That won't work and you'll get an error something like: service callback failed: Variable not found: Router (line 4, position 17)

There are two workarounds. Either:

1. Create a local copy of the global that can be captured by the closure:

1
fn supergraph_service(service){
2
    let v = Router.APOLLO_SDL;
3
    let f = |request| {
4
        print(v);
5
    };
6
    service.map_request(f);
7
}

Or:

2. Use a function pointer rather than closure syntax:

1
fn supergraph_service(service) {
2
    const request_callback = Fn("process_request");
3
    service.map_request(request_callback);
4
}
5

6
fn process_request(request) {
7
    print(`${Router.APOLLO_SDL}`);
8
}

Avoiding deadlocks

The Apollo Router requires that its Rhai engine implements the sync feature to guarantee data integrity within the router's multi-threading execution environment. This means that shared values within Rhai might cause a deadlock.

This is particularly risky when using closures within callbacks while referencing external data. Take particular care to avoid this kind of situation by making copies of data when required. The examples/surrogate-cache-key directory contains an example of this, where "closing over" response.headers would cause a deadlock. To avoid this, a local copy of the required data is obtained and used in the closure.

Debugging

Understanding errors

If there is a syntax error in a Rhai script, the router will log an error message at startup mentioning the apollo.rhai plugin. The line number in the error message describes where the error was detected, not where the error is present. For example, if you're missing a semicolon at the end of line 10, the error will mention line 11 (once Rhai realizes the mistake).

Syntax highlighting

Syntax highlighting can make it easier to spot errors in a script. We recommend using the online Rhai playground or using VS Code with the Rhai extension.

Logging

For tracking down runtime errors, insert logging statements to narrow down the issue.