Rhai 脚本以自定义路由器

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
// 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
}

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
}

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
}

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
}

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
}

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
}

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
}