Introduce code generation from .graphql files for making queries (#52)

Josh and Alex want to make the CLI make some GraphQL requests.

We have a plan to use https://github.com/graphql-rust/graphql-client with its code generation features along with a schema that we'll keep up to date as a build phase.

To unblock them, this PR adds 2 example queries and tests to show how this works.

I verified this works locally by using my personal api key and removing the `should_panic`.

Their existing code saves the api key on the file system after authenticating.
We should therefore create a `Client` instance that's instantiated with the api key `auth` creates.

See the documentation for the library we're using and see examples here: https://github.com/graphql-rust/graphql-client/tree/master/graphql_client/tests

Author: Ran Magen

.github/workflows/test.yml

@@ -71,25 +71,26 @@ jobs:
           rustup default ${{ matrix.rust }}
 
       - name: Run Tests
-        if: matrix.build != 'linux-stable'
+#        if: matrix.build != 'linux-stable'
         run: cargo test
         env:
           RUST_LOG: warn,apollo-cli=info
           RUST_BACKTRACE: 1
-      
-      - name: Run cargo-tarpaulin
-        if: matrix.build == 'linux-stable'
-        uses: actions-rs/[email protected]
-        with:
-          version: '0.9.0'
-          timeout: 300 # 5 mins for test coverage
-          args: '--ignore-tests -- --test-threads 1'
+
+# Restore this when we get coverage working well -- integration tests on binary packages don't report coverage correctly.
+#      - name: Run cargo-tarpaulin
+#        if: matrix.build == 'linux-stable'
+#        uses: actions-rs/[email protected]
+#        with:
+#          version: '0.9.0'
+#          timeout: 600 # 10 mins for test coverage
+#          args: '--ignore-tests'
 
-      - name: Upload to codecov.io
-        if: matrix.build == 'linux-stable'
-        uses: codecov/[email protected]
-        with:
-          token: ${{secrets.CODECOV_TOKEN}}
+#      - name: Upload to codecov.io
+#        if: matrix.build == 'linux-stable'
+#        uses: codecov/[email protected]
+#        with:
+#          token: ${{secrets.CODECOV_TOKEN}}
 
   test_worker:
     name: Test CDN and installer

cli/.graphqlconfig

@@ -0,0 +1,16 @@
+{
+  "name": "Apollo Graph Manager GraphQL Schema",
+  "schemaPath": ".schema/schema.graphql",
+  "includes": ["graphql/**.graphql"],
+  "extensions": {
+    "endpoints": {
+      "Default GraphQL Endpoint": {
+        "url": "https://engine-graphql.apollographql.com/api/graphql",
+        "headers": {
+          "user-agent": "JS GraphQL"
+        },
+        "introspect": false
+      }
+    }
+  }
+}

cli/Cargo.toml

@@ -21,7 +21,10 @@ console = "0.11.3"
 dirs = "2.0.2"
 env_logger = "0.7.1"
 graphql-parser = { path = "../graphql-parser" }
+graphql_client = "0.9.0"
+http = "0.2.1"
 human-panic = "1.0.3"
+json = "0.12.4"
 log = { version = "0.4.8", features = ["std"] }
 openssl = { version = "0.10.29", optional = true }
 reqwest = { version = "0.10.6", features = ["blocking", "json"] }

cli/graphql/get_schema_query.graphql

@@ -0,0 +1,10 @@
+# Provided as example. Remove at some point if not used.
+
+query GetSchemaQuery($serviceId: ID!, $variant: String!) {
+    service(id: $serviceId) {
+        schema(tag: $variant) {
+            hash
+        }
+    }
+}
+

cli/graphql/me_query.graphql

@@ -0,0 +1,9 @@
+# Provided as example. Remove at some point if not used.
+
+query MeQuery {
+    me {
+        __typename
+        id
+        name
+    }
+}

cli/src/cli.rs

@@ -17,7 +17,7 @@ use crate::version::command_name;
     global_setting = AppSettings::DontCollapseArgsInUsage,
     global_setting = AppSettings::VersionlessSubcommands,
 )]
-/// The [Experimental] Apollo CLI, for supporting all your graphql needs :)
+/// The _Experimental_ Apollo CLI, for supporting all your graphql needs :)
 pub struct Apollo {
     #[structopt(subcommand)]
     pub command: Option<Subcommand>,

cli/src/client/mod.rs

@@ -0,0 +1,55 @@
+use graphql_client::{GraphQLQuery, Response};
+use http::Uri;
+use reqwest::blocking;
+use std::env;
+use std::error::Error;
+
+mod queries;
+
+static PROD_GQL_API_URL: &str = "https://engine-graphql.apollographql.com/api/graphql";
+
+fn api_uri() -> Uri {
+    env::var("APOLLO_API_URL")
+        .ok()
+        .and_then(|url| url.parse::<Uri>().ok())
+        .unwrap_or_else(|| PROD_GQL_API_URL.parse::<Uri>().unwrap())
+}
+
+pub struct Client {
+    api_key: String,
+    uri: Uri,
+    reqwest: blocking::Client,
+}
+
+impl Client {
+    fn from(api_key: String) -> Client {
+        Client {
+            api_key,
+            uri: api_uri(),
+            reqwest: blocking::Client::new(),
+        }
+    }
+
+    fn send<Q: GraphQLQuery>(
+        &self,
+        variables: Q::Variables,
+    ) -> Result<Response<Q::ResponseData>, Box<dyn Error>> {
+        let request_body = Q::build_query(variables);
+
+        let res = self
+            .reqwest
+            .post(&self.uri.to_string())
+            .header("Content-Type", "application/json")
+            .header("apollographql-client-name", "experimental-apollo-cli")
+            .header(
+                "apollographql-client-version",
+                env::var("CARGO_PKG_VERSION").unwrap(),
+            )
+            .header("x-api-key", &self.api_key)
+            .json(&request_body)
+            .send()?;
+
+        let response_body: Response<Q::ResponseData> = res.json()?;
+        Ok(response_body)
+    }
+}

cli/src/client/queries.rs

@@ -0,0 +1,74 @@
+use crate::client::Client;
+use graphql_client::*;
+use std::error::Error;
+
+// We have to declare types for scalars in the schema.
+// type GraphQLDocument = String;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    query_path = "graphql/get_schema_query.graphql",
+    schema_path = ".schema/schema.graphql",
+    response_derives = "PartialEq, Debug",
+    deprecated = "warn"
+)]
+pub struct GetSchemaQuery;
+
+pub fn get_schema_query(
+    client: &Client,
+    variables: get_schema_query::Variables,
+) -> Result<Option<String>, Box<dyn Error>> {
+    let response_body: Response<get_schema_query::ResponseData> =
+        client.send::<GetSchemaQuery>(variables)?;
+
+    let hash: Option<String> = response_body.data.and_then(|data| {
+        data.service
+            .and_then(|service| service.schema.map(|schema| schema.hash))
+    });
+
+    Ok(hash)
+}
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    query_path = "graphql/me_query.graphql",
+    schema_path = ".schema/schema.graphql",
+    response_derives = "PartialEq, Debug",
+    deprecated = "warn"
+)]
+pub struct MeQuery;
+
+pub fn me_query(client: &Client) -> Result<Option<me_query::MeQueryMe>, Box<dyn Error>> {
+    let response_body: Response<me_query::ResponseData> =
+        client.send::<MeQuery>(me_query::Variables {})?;
+
+    Ok(response_body.data.and_then(|data| data.me))
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[should_panic] // will not panic with a real API key with access to "my-service".
+    #[ignore]
+    fn get_schema_query() {
+        use super::*;
+        let client = Client::from("todo_get_api_key".to_owned());
+
+        let vars = get_schema_query::Variables {
+            service_id: "my-service".to_owned(),
+            variant: "current".to_owned(),
+        };
+        let hash = get_schema_query(&client, vars).unwrap().unwrap();
+        println!("{}", hash);
+    }
+
+    #[test]
+    #[should_panic] // will not panic with a real API key.
+    #[ignore]
+    fn me_query() {
+        use super::*;
+        let client = Client::from("todo_get_api_key".to_owned());
+        let me = me_query(&client).unwrap().unwrap();
+        println!("{:?}", me);
+    }
+}

cli/src/main.rs

@@ -2,6 +2,7 @@
 extern crate text_io;
 
 mod cli;
+mod client;
 mod commands;
 mod config;
 mod errors;