use crate::Header;
use crate::graphql::GraphQLResponse;
use crate::graphql::mock_response_prompt::MockResponsePrompt;
use crate::graphql::mock_response_prompt::SerializationFormat;
use crate::graphql::response_merger::ResponseMerger;
use crate::graphql::response_merger::ResponseMergerError;
use crate::llm_provider::ProviderConfig;
use crate::llm_provider::ProviderError;
use crate::llm_provider::generate_mock_response;
use crate::planner::MockPlanner;
use crate::planner::SplitError;
use crate::planner::SplitResult;
use crate::upstream::UpstreamError;
use crate::upstream::execute_graphql;
use apollo_compiler::Schema;
use apollo_compiler::response::ExecutionResponse;
use apollo_compiler::validation::Valid;
use reqwest::Client;
use reqwest::Url;
use serde_json_bytes::ByteString;
use serde_json_bytes::Map;
use serde_json_bytes::Value;
use std::sync::Arc;
use thiserror::Error;
#[derive(Debug, Clone)]
pub enum MockPlan {
NoMocks,
Introspection(ExecutionResponse),
FullMock(MockResponsePrompt),
PartialMock {
prompt: MockResponsePrompt,
upstream_operation: String,
},
}
impl From<SplitResult> for MockPlan {
fn from(split_result: SplitResult) -> Self {
match split_result {
SplitResult::NoMocks => MockPlan::NoMocks,
SplitResult::Introspection(response) => MockPlan::Introspection(response),
SplitResult::FullMock(prompt) => MockPlan::FullMock(prompt),
SplitResult::PartialMock {
prompt,
upstream_operation,
} => MockPlan::PartialMock {
prompt,
upstream_operation,
},
}
}
}
#[derive(Debug, Clone)]
pub struct MockServiceRequest {
pub operation: String,
pub operation_name: Option<String>,
pub variables: Map<ByteString, Value>,
pub schema_extension: Option<Value>,
pub graphql_url: Url,
pub graphql_headers: Vec<Header>,
pub provider: ProviderConfig,
}
#[buildstructor::buildstructor]
impl MockServiceRequest {
#[builder(visibility = "pub")]
fn new(
operation: String,
operation_name: Option<String>,
variables: Map<ByteString, Value>,
schema_extension: Option<Value>,
graphql_url: Url,
graphql_headers: Vec<Header>,
provider: ProviderConfig,
) -> Self {
Self {
operation,
operation_name,
variables,
schema_extension,
graphql_url,
graphql_headers,
provider,
}
}
}
#[derive(Debug)]
pub struct MockService {
planner: MockPlanner,
client: Client,
}
#[derive(Debug, Error)]
pub enum ServiceError {
#[error(transparent)]
Split(#[from] SplitError),
#[error(transparent)]
Provider(#[from] ProviderError),
#[error(transparent)]
Upstream(#[from] UpstreamError),
#[error(transparent)]
Merge(#[from] ResponseMergerError),
}
impl MockService {
pub fn new(schema: Arc<Valid<Schema>>, serialization_format: SerializationFormat, client: Client) -> Self {
Self {
planner: MockPlanner::new(schema, serialization_format),
client,
}
}
pub fn plan(
&self,
operation: &str,
operation_name: Option<&str>,
variables: &Map<ByteString, Value>,
schema_extension: Option<&Value>,
) -> Result<MockPlan, ServiceError> {
Ok(
self
.planner
.split_operation(operation, operation_name, variables, schema_extension)?
.into(),
)
}
pub async fn execute(&self, request: MockServiceRequest) -> Result<GraphQLResponse, ServiceError> {
let plan = self.plan(
request.operation.as_str(),
request.operation_name.as_deref(),
&request.variables,
request.schema_extension.as_ref(),
)?;
match plan {
MockPlan::Introspection(response) => Ok(GraphQLResponse {
data: response.data.map(Value::Object),
errors: response
.errors
.into_iter()
.filter_map(|e| serde_json_bytes::to_value(e).ok())
.collect(),
extensions: Map::new(),
}),
MockPlan::NoMocks => execute_graphql(
&self.client,
request.graphql_url,
&request.graphql_headers,
&request.operation,
request.operation_name.as_deref(),
&request.variables,
)
.await
.map_err(ServiceError::from),
MockPlan::FullMock(prompt) => generate_mock_response(&request.provider, &prompt)
.await
.map_err(ServiceError::from),
MockPlan::PartialMock {
prompt,
upstream_operation: passthrough_operation,
} => {
let mut upstream_response = execute_graphql(
&self.client,
request.graphql_url,
&request.graphql_headers,
&passthrough_operation,
request.operation_name.as_deref(),
&request.variables,
)
.await?;
let contextual_prompt = prompt.with_partial_response(upstream_response.data.clone());
let mut mock_response = generate_mock_response(&request.provider, &contextual_prompt).await?;
ResponseMerger::merge(&mut upstream_response, &mut mock_response)?;
Ok(upstream_response)
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json_bytes::Map;
use std::time::Duration;
fn test_service(schema_sdl: &str) -> MockService {
let schema = Schema::builder()
.parse(
"directive @mock(hint: String) on QUERY | MUTATION | FIELD",
"mock-directive.graphql",
)
.parse(schema_sdl, "schema.graphql")
.build()
.unwrap();
let schema = Arc::new(schema.validate().unwrap());
let client = Client::builder().timeout(Duration::from_secs(30)).build().unwrap();
MockService::new(schema, Default::default(), client)
}
#[test]
fn new_builds_service() {
let service = test_service("type Query { hello: String }");
assert!(matches!(
service.plan("{ hello }", None, &Map::new(), None),
Ok(MockPlan::NoMocks)
));
}
#[test]
fn plan_without_mocks_returns_no_mocks() {
let service = test_service("type Query { hello: String }");
let plan = service
.plan("{ hello }", None, &Map::new(), None)
.expect("plan should succeed");
assert!(matches!(plan, MockPlan::NoMocks));
}
#[test]
fn plan_full_mock_returns_full_mock() {
let service = test_service("type Query { hello: String }");
let plan = service
.plan("{ hello @mock }", None, &Map::new(), None)
.expect("plan should succeed");
assert!(matches!(plan, MockPlan::FullMock(_)));
}
#[test]
fn plan_partial_mock_returns_partial_mock() {
let service = test_service(
r"
type Query { me: User }
type User { id: ID name: String }
",
);
let plan = service
.plan("{ me { id name @mock } }", None, &Map::new(), None)
.expect("plan should succeed");
assert!(matches!(plan, MockPlan::PartialMock { .. }));
}
#[test]
fn plan_introspection_returns_introspection() {
let service = test_service("type Query { hello: String }");
let plan = service
.plan("{ __schema { queryType { name } } }", None, &Map::new(), None)
.expect("plan should succeed");
assert!(matches!(plan, MockPlan::Introspection(_)));
}
}