STRLCPY/graphql-engine

refactor execute/ndc/client.rs (#435)

- Move redundant code in `client.rs` into a separate function.
- Doc utility functions through comments

V3_GIT_ORIGIN_REV_ID: f172ec2309b48c627f4ab9179efcb4c278e82989

Rakesh Emmadi committed with hasura-bot 2 months ago

46cb1bfe

1 parent 59de1c3c

Total 1 files

■ ■ ■ ■ ■ ■

v3/crates/engine/src/execute/ndc/client.rs

1	1		use ndc_client::models as ndc_models;
2	2		use reqwest::header::{HeaderMap, HeaderValue};
3		-	use serde::Deserialize;
	3	+	use serde::{de::DeserializeOwned, Deserialize};
4	4		use std::fmt;
5	5		use thiserror::Error;
6	6		use tracing_util::SpanVisibility;
		skipped 71 lines
78	78
79	79		let uri = append_path(&configuration.base_path, &["capabilities"])
80	80		.map_err(\|_\| Error::InvalidBaseURL)?;
81		-	let mut req_builder = client.request(reqwest::Method::GET, uri);
82		-
83		-	req_builder = inject_trace_context(req_builder);
84		-
85		-	if let Some(ref user_agent) = configuration.user_agent {
86		-	req_builder =
87		-	req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
88		-	}
89		-
90		-	// Note: The headers will be merged in to any already set.
91		-	req_builder = req_builder.headers(configuration.headers.clone());
92		-
93		-	let req = req_builder.build()?;
94		-	let resp = client.execute(req).await?;
95		-
96		-	let response_status = resp.status();
97		-	let response_content = resp.json().await?;
	81	+	let req_builder = client.request(reqwest::Method::GET, uri);
98	82
99		-	if !response_status.is_client_error() && !response_status.is_server_error() {
100		-	serde_json::from_value(response_content).map_err(Error::from)
101		-	} else {
102		-	Err(construct_error(response_status, response_content))
103		-	}
	83	+	execute_request(configuration, req_builder).await
104	84		})
105	85		})
106	86		.await
		skipped 14 lines
121	101
122	102		let uri = append_path(&configuration.base_path, &["query", "explain"])
123	103		.map_err(\|_\| Error::InvalidBaseURL)?;
124		-	let mut req_builder = client.request(reqwest::Method::POST, uri);
125		-
126		-	if let Some(ref user_agent) = configuration.user_agent {
127		-	req_builder =
128		-	req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
129		-	}
130		-
131		-	// Note: The headers will be merged in to any already set.
132		-	req_builder = req_builder.headers(configuration.headers.clone());
	104	+	let req_builder = client.request(reqwest::Method::POST, uri);
133	105
134		-	req_builder = req_builder.json(&query_request);
135		-
136		-	req_builder = inject_trace_context(req_builder);
137		-
138		-	let req = req_builder.build()?;
139		-	let resp = client.execute(req).await?;
140		-
141		-	let response_status = resp.status();
142		-	let response_content = resp.json().await?;
143		-
144		-	if !response_status.is_client_error() && !response_status.is_server_error() {
145		-	serde_json::from_value(response_content).map_err(Error::from)
146		-	} else {
147		-	Err(construct_error(response_status, response_content))
148		-	}
	106	+	execute_request(configuration, req_builder.json(&query_request)).await
149	107		})
150	108		})
151	109		.await
		skipped 14 lines
166	124
167	125		let uri = append_path(&configuration.base_path, &["mutation", "explain"])
168	126		.map_err(\|_\| Error::InvalidBaseURL)?;
169		-	let mut req_builder = client.request(reqwest::Method::POST, uri);
170		-
171		-	if let Some(ref user_agent) = configuration.user_agent {
172		-	req_builder =
173		-	req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
174		-	}
175		-
176		-	// Note: The headers will be merged in to any already set.
177		-	req_builder = req_builder.headers(configuration.headers.clone());
178		-
179		-	req_builder = req_builder.json(&mutation_request);
180		-
181		-	req_builder = inject_trace_context(req_builder);
182		-
183		-	let req = req_builder.build()?;
184		-	let resp = client.execute(req).await?;
185		-
186		-	let response_status = resp.status();
187		-	let response_content = resp.json().await?;
	127	+	let req_builder = client.request(reqwest::Method::POST, uri);
188	128
189		-	if !response_status.is_client_error() && !response_status.is_server_error() {
190		-	serde_json::from_value(response_content).map_err(Error::from)
191		-	} else {
192		-	Err(construct_error(response_status, response_content))
193		-	}
	129	+	execute_request(configuration, req_builder.json(&mutation_request)).await
194	130		})
195	131		})
196	132		.await
		skipped 14 lines
211	147
212	148		let uri = append_path(&configuration.base_path, &["mutation"])
213	149		.map_err(\|_\| Error::InvalidBaseURL)?;
214		-	let mut req_builder = client.request(reqwest::Method::POST, uri);
215		-
216		-	if let Some(ref user_agent) = configuration.user_agent {
217		-	req_builder =
218		-	req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
219		-	}
220		-
221		-	// Note: The headers will be merged in to any already set.
222		-	req_builder = req_builder.headers(configuration.headers.clone());
223		-
224		-	req_builder = req_builder.json(&mutation_request);
225		-
226		-	req_builder = inject_trace_context(req_builder);
227		-
228		-	let req = req_builder.build()?;
229		-	let resp = client.execute(req).await?;
	150	+	let req_builder = client.request(reqwest::Method::POST, uri);
230	151
231		-	let response_status = resp.status();
232		-	let response_content = resp.json().await?;
233		-
234		-	if !response_status.is_client_error() && !response_status.is_server_error() {
235		-	serde_json::from_value(response_content).map_err(Error::from)
236		-	} else {
237		-	Err(construct_error(response_status, response_content))
238		-	}
	152	+	execute_request(configuration, req_builder.json(&mutation_request)).await
239	153		})
240	154		})
241	155		.await
		skipped 14 lines
256	170
257	171		let uri = append_path(&configuration.base_path, &["query"])
258	172		.map_err(\|_\| Error::InvalidBaseURL)?;
259		-	let mut req_builder = client.request(reqwest::Method::POST, uri);
260		-
261		-	if let Some(ref user_agent) = configuration.user_agent {
262		-	req_builder =
263		-	req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
264		-	}
265		-
266		-	// Note: The headers will be merged in to any already set.
267		-	req_builder = req_builder.headers(configuration.headers.clone());
268		-
269		-	req_builder = req_builder.json(&query_request);
270		-
271		-	req_builder = inject_trace_context(req_builder);
272		-
273		-	let req = req_builder.build()?;
274		-	let resp = client.execute(req).await?;
275		-
276		-	let response_status = resp.status();
277		-	let response_content = resp.json().await?;
	173	+	let req_builder = client.request(reqwest::Method::POST, uri);
278	174
279		-	if !response_status.is_client_error() && !response_status.is_server_error() {
280		-	serde_json::from_value(response_content).map_err(Error::from)
281		-	} else {
282		-	Err(construct_error(response_status, response_content))
283		-	}
	175	+	execute_request(configuration, req_builder.json(&query_request)).await
284	176		})
285	177		})
286	178		.await
		skipped 13 lines
300	192
301	193		let uri = append_path(&configuration.base_path, &["schema"])
302	194		.map_err(\|_\| Error::InvalidBaseURL)?;
303		-	let mut req_builder = client.request(reqwest::Method::GET, uri);
304		-
305		-	req_builder = inject_trace_context(req_builder);
306		-
307		-	if let Some(ref user_agent) = configuration.user_agent {
308		-	req_builder =
309		-	req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
310		-	}
311		-
312		-	// Note: The headers will be merged in to any already set.
313		-	req_builder = req_builder.headers(configuration.headers.clone());
314		-
315		-	let req = req_builder.build()?;
316		-	let resp = client.execute(req).await?;
317		-
318		-	let response_status = resp.status();
319		-	let response_content = resp.json().await?;
	195	+	let req_builder = client.request(reqwest::Method::GET, uri);
320	196
321		-	if !response_status.is_client_error() && !response_status.is_server_error() {
322		-	serde_json::from_value(response_content).map_err(Error::from)
323		-	} else {
324		-	Err(construct_error(response_status, response_content))
325		-	}
	197	+	execute_request(configuration, req_builder).await
326	198		})
327	199		})
328	200		.await
		skipped 1 lines
330	202
331	203		// Private utility functions
332	204
333		-	fn inject_trace_context(builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
	205	+	/// Inject trace context into the request via headers
	206	+	fn inject_trace_context(mut request_builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
334	207		let trace_headers = tracing_util::get_trace_context();
335		-	let mut req_builder = builder;
336	208		for (key, value) in trace_headers {
337		-	req_builder = req_builder.header(key, value);
	209	+	request_builder = request_builder.header(key, value);
338	210		}
339		-	req_builder
	211	+	request_builder
340	212		}
341	213
	214	+	/// Append a path to a URL
342	215		fn append_path(url: &reqwest::Url, path: &[&str]) -> Result<reqwest::Url, ()> {
343	216		let mut url = url.clone();
344	217		url.path_segments_mut()?.pop_if_empty().extend(path);
345	218		Ok(url)
346	219		}
347	220
	221	+	/// Execute a request and deserialize the JSON response
	222	+	async fn execute_request<T: DeserializeOwned>(
	223	+	configuration: &Configuration,
	224	+	mut request_builder: reqwest::RequestBuilder,
	225	+	) -> Result<T, Error> {
	226	+	// Inject trace context into the request
	227	+	request_builder = inject_trace_context(request_builder);
	228	+	// Set user agent if provided
	229	+	if let Some(ref user_agent) = configuration.user_agent {
	230	+	request_builder = request_builder.header(reqwest::header::USER_AGENT, user_agent);
	231	+	}
	232	+	// Set headers from configuration
	233	+	// Note: The headers will be merged in to any already set.
	234	+	request_builder = request_builder.headers(configuration.headers.clone());
	235	+
	236	+	// Build and execute the request
	237	+	let request = request_builder.build()?;
	238	+	let resp = configuration.client.execute(request).await?;
	239	+
	240	+	let response_status = resp.status();
	241	+	let response_content = resp.json().await?;
	242	+
	243	+	if !response_status.is_client_error() && !response_status.is_server_error() {
	244	+	serde_json::from_value(response_content).map_err(Error::from)
	245	+	} else {
	246	+	Err(construct_error(response_status, response_content))
	247	+	}
	248	+	}
	249	+
	250	+	/// Build an error from the response status and content
348	251		fn construct_error(
349	252		response_status: reqwest::StatusCode,
350	253		response_content: serde_json::Value,
		skipped 62 lines