use crate::Header;
use cynic::http::CynicReqwestError;
use cynic::http::ReqwestExt;
use cynic_introspection::CapabilitySet;
use cynic_introspection::IntrospectionQuery;
use cynic_introspection::SchemaError;
use cynic_introspection::SpecificationVersion;
use reqwest::Client;
use reqwest::StatusCode;
use reqwest::Url;
use reqwest::header::HeaderMap;
pub async fn load_schema_with_introspection(
url: &Url,
headers: &[Header],
client: &Client,
) -> Result<String, IntrospectionError> {
let introspection_result =
match execute_instrospection_query(url, headers, client, SpecificationVersion::October2021.capabilities()).await {
Ok(introspection_result) => introspection_result,
Err(IntrospectionError::GraphqlErrors(_)) => {
execute_instrospection_query(url, headers, client, SpecificationVersion::June2018.capabilities()).await?
}
Err(error) => return Err(error),
};
Ok(
introspection_result
.into_schema()
.map_err(IntrospectionError::from)?
.to_sdl(),
)
}
pub async fn execute_instrospection_query(
url: &Url,
headers: &[Header],
client: &Client,
capability_set: CapabilitySet,
) -> Result<IntrospectionQuery, IntrospectionError> {
let response = client
.post(url.clone())
.headers(headers.iter().cloned().collect::<HeaderMap>())
.run_graphql(IntrospectionQuery::with_capabilities(capability_set))
.await
.map_err(IntrospectionError::from)?;
if let Some(errors) = response.errors {
return Err(IntrospectionError::GraphqlErrors(format!("{errors:?}")));
}
response.data.ok_or(IntrospectionError::MissingSchema)
}
#[derive(Debug, thiserror::Error)]
pub enum IntrospectionError {
#[error("introspection request failed: {0}")]
Request(#[source] reqwest::Error),
#[error("introspection request returned HTTP status: {status}, body: {body}")]
HttpStatus {
status: StatusCode,
body: String,
},
#[error("introspection response was not valid JSON: {0}")]
Json(#[source] serde_json::Error),
#[error("introspection response did not contain a schema")]
MissingSchema,
#[error("introspection response contained GraphQL errors: {0}")]
GraphqlErrors(String),
#[error("failed to convert introspection response: {0}")]
Conversion(String),
#[error("failed to build Apollo schema: {0}")]
Schema(String),
}
impl From<CynicReqwestError> for IntrospectionError {
fn from(error: CynicReqwestError) -> Self {
match error {
CynicReqwestError::ReqwestError(error) => Self::Request(error),
CynicReqwestError::ErrorResponse(status, body) => Self::HttpStatus { status, body },
}
}
}
impl From<SchemaError> for IntrospectionError {
fn from(error: SchemaError) -> Self {
match error {
SchemaError::IntrospectionQueryFailed => Self::MissingSchema,
_ => Self::Conversion(error.to_string()),
}
}
}