148 lines
4.7 KiB
Rust
148 lines
4.7 KiB
Rust
use anyhow::Result;
|
|
use imphnen_entities::{
|
|
CountResult, MetaRequestDto, MetaResponseDto, ResponseListSuccessDto,
|
|
};
|
|
use serde::{de::DeserializeOwned, Serialize};
|
|
use surrealdb::engine::any;
|
|
use surrealdb::Surreal;
|
|
use tracing;
|
|
|
|
pub struct QueryListBuilder<'a> {
|
|
db: &'a Surreal<any::Any>,
|
|
table: &'a str,
|
|
meta: &'a MetaRequestDto,
|
|
conditions: Vec<String>,
|
|
search_field: String,
|
|
select_fields: Option<Vec<&'a str>>,
|
|
fetch_fields: Option<Vec<&'a str>>,
|
|
cast_thing_fields: bool,
|
|
}
|
|
|
|
impl<'a> QueryListBuilder<'a> {
|
|
pub fn new(
|
|
db: &'a Surreal<any::Any>,
|
|
table: &'a str,
|
|
meta: &'a MetaRequestDto,
|
|
) -> Self {
|
|
Self {
|
|
db,
|
|
table,
|
|
meta,
|
|
conditions: vec![],
|
|
search_field: "name".to_string(),
|
|
select_fields: None,
|
|
fetch_fields: None,
|
|
cast_thing_fields: false,
|
|
}
|
|
}
|
|
|
|
pub fn search_field(mut self, field: &'a str) -> Self {
|
|
self.search_field = field.to_string();
|
|
self
|
|
}
|
|
|
|
pub fn select_fields(mut self, fields: Vec<&'a str>) -> Self {
|
|
self.select_fields = Some(fields);
|
|
self
|
|
}
|
|
|
|
pub fn fetch_fields(mut self, fields: Vec<&'a str>) -> Self {
|
|
self.fetch_fields = Some(fields);
|
|
self
|
|
}
|
|
|
|
pub fn with_condition(mut self, condition: &str) -> Self {
|
|
self.conditions.push(condition.to_string());
|
|
self
|
|
}
|
|
|
|
pub fn with_cast_thing_fields(mut self) -> Self {
|
|
self.cast_thing_fields = true;
|
|
self
|
|
}
|
|
|
|
pub async fn build<T>(self) -> Result<ResponseListSuccessDto<Vec<T>>>
|
|
where
|
|
T: DeserializeOwned + Serialize,
|
|
{
|
|
let page = self.meta.page.unwrap_or(1).max(1);
|
|
let per_page = self.meta.per_page.unwrap_or(10).max(1);
|
|
let start = (page - 1) * per_page;
|
|
|
|
// --- Data Query ---
|
|
let data_query_builder = crate::ListQueryBuilder::from_meta(
|
|
self.table,
|
|
self.meta,
|
|
&self.search_field,
|
|
self.select_fields,
|
|
self.fetch_fields,
|
|
).with_additional_conditions(&self.conditions);
|
|
let data_sql = data_query_builder.build();
|
|
|
|
// --- Count Query ---
|
|
let count_query_builder = crate::ListQueryBuilder::from_meta(
|
|
self.table,
|
|
self.meta,
|
|
&self.search_field,
|
|
None, // No select fields for count
|
|
None, // No fetch fields for count
|
|
).with_additional_conditions(&self.conditions);
|
|
let count_sql = count_query_builder.build_count();
|
|
|
|
// Combine both queries into a single query string within a transaction for a single database call
|
|
let combined_sql = format!(
|
|
"BEGIN; {}; {}; COMMIT;",
|
|
data_sql,
|
|
count_sql
|
|
);
|
|
|
|
let mut query_exec = self.db.query(combined_sql.clone());
|
|
|
|
// Bind parameters for both data and count queries.
|
|
// It's assumed that the parameters are named consistently and applied to both.
|
|
// The ListQueryBuilder already uses $search, $per_page, $start, $filter.
|
|
if let Some(search) = &self.meta.search {
|
|
if !search.is_empty() {
|
|
query_exec = query_exec.bind(("search", search.to_lowercase()));
|
|
}
|
|
}
|
|
if let Some(filter_val) = &self.meta.filter {
|
|
query_exec = crate::bind_filter_value(query_exec, filter_val.clone());
|
|
}
|
|
query_exec = query_exec
|
|
.bind(("per_page", per_page))
|
|
.bind(("start", start));
|
|
|
|
let query_debug_str = format!("{:?}", &query_exec);
|
|
|
|
let mut response = query_exec.await.map_err(|e| {
|
|
tracing::error!(
|
|
query = %combined_sql, // `combined_sql` is cloned, so it can be borrowed here
|
|
full_query_object = %query_debug_str,
|
|
"Failed to execute combined query: {:?}", e
|
|
);
|
|
e
|
|
})?;
|
|
|
|
// Extract results: first for the data, then for the count
|
|
let raw: Vec<T> = response.take(0)?; // First result is the data
|
|
let count_result: Vec<CountResult> = response.take(1)?; // Second result is the count
|
|
|
|
let total = count_result.first().map(|c| c.count);
|
|
// Debug logging
|
|
if std::env::var("RUST_ENV").unwrap_or_else(|_| "development".to_string()) == "development" {
|
|
println!("QueryListBuilder: data length = {}, total from count = {:?}", raw.len(), total);
|
|
println!("Combined SQL: {}", combined_sql);
|
|
}
|
|
|
|
Ok(ResponseListSuccessDto {
|
|
data: raw,
|
|
meta: Some(MetaResponseDto {
|
|
page: Some(page),
|
|
per_page: Some(per_page),
|
|
total,
|
|
}),
|
|
})
|
|
}
|
|
}
|