router-bridge 0.1.7

JavaScript bridge for the Apollo Router
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use std::path::{Path, PathBuf};
use std::process::Command;

fn main() {
    // only do `npm` related stuff if we're _not_ publishing to crates.io
    if std::fs::metadata("./package.json").is_ok() {
        println!("cargo:rerun-if-changed=js-src");

        let current_dir = std::env::current_dir().unwrap();

        update_bridge(&current_dir);
    } else {
        // the crate has been published, no need to rerun
        println!("cargo:rerun-if-changed=build.rs");
    }

    let out_dir: PathBuf = std::env::var_os("OUT_DIR")
        .expect("$OUT_DIR not set.")
        .into();

    create_snapshot(&out_dir);
}

fn update_bridge(current_dir: &Path) {
    println!("cargo:warning=Updating router-bridge");
    let npm = which::which("npm").expect("'npm' is not available");

    if cfg!(debug_assertions) {
        // in debug mode we want to update the package-lock.json
        // so we run `npm install`
        println!("cargo:warning=running `npm install`");
        assert!(Command::new(&npm)
            .current_dir(&current_dir)
            .args(&["install"])
            .status()
            .unwrap()
            .success());
    } else {
        // in release mode, we're probably running in CI
        // and want the version we publish to match
        // the git source
        // so we run `npm ci`.
        println!("cargo:warning=running `npm ci`");
        assert!(Command::new(&npm)
            .current_dir(&current_dir)
            .args(&["ci"])
            .status()
            .unwrap()
            .success());
    }

    println!("cargo:warning=running `npm run format`");
    assert!(Command::new(&npm)
        .current_dir(&current_dir)
        .args(&["run", "format"])
        .status()
        .unwrap()
        .success());

    println!("cargo:warning=running `npm run build`");
    assert!(Command::new(&npm)
        .current_dir(&current_dir)
        .args(&["run", "build"])
        .status()
        .unwrap()
        .success());
}

#[cfg(feature = "docs_rs")]
fn create_snapshot(out_dir: &Path) {
    // If we're building on docs.rs we just create
    // an empty snapshot file and return, because `rusty_v8`
    // doesn't actually compile on docs.rs
    std::fs::write(out_dir.join("query_runtime.snap"), &[]).unwrap();
}

#[cfg(not(feature = "docs_rs"))]
fn create_snapshot(out_dir: &Path) {
    use deno_core::{JsRuntime, RuntimeOptions};
    use std::fs::{read_to_string, File};
    use std::io::Write;

    let options = RuntimeOptions {
        will_snapshot: true,
        ..Default::default()
    };
    let mut runtime = JsRuntime::new(options);

    // The runtime automatically contains a Deno.core object with several
    // functions for interacting with it.
    let runtime_str = read_to_string("bundled/runtime.js").unwrap();
    runtime
        .execute_script("<init>", &runtime_str)
        .expect("unable to initialize router bridge runtime environment");

    // Load the composition library.
    let bridge_str = read_to_string("bundled/bridge.js").unwrap();
    runtime
        .execute_script("bridge.js", &bridge_str)
        .expect("unable to evaluate bridge module");

    // Create our base query snapshot which will be included in
    // src/js.rs to initialise our JsRuntime().
    let mut snap = File::create(out_dir.join("query_runtime.snap")).unwrap();
    snap.write_all(&runtime.snapshot()).unwrap();
}