use std::ops::ControlFlow;
use std::ops::Deref;
use std::slice::Iter;
use std::time::Duration;
use std::vec::IntoIter;
use tokio_stream::{Stream, StreamExt};
use tonic::metadata::MetadataValue;
use tonic::transport::Channel;
use crate::error::{ArcadeDbError, Result};
use crate::options::ClientOptions;
pub use crate::proto::com::arcadedb::grpc::*;
use crate::proto::com::arcadedb::grpc::{
arcade_db_admin_service_client::ArcadeDbAdminServiceClient,
arcade_db_service_client::ArcadeDbServiceClient, insert_options::ConflictMode,
update_record_request::Payload,
};
use crate::record::RecordDecodeError;
mod database;
mod execute;
mod query;
mod records;
mod results;
mod streaming;
mod transaction;
pub use database::DatabaseClient;
pub use results::{QueryResult, QueryResultBatch, StreamSummary};
pub use streaming::consume_stream;
pub use transaction::{Transaction, TxCommands};
pub(crate) fn map_rpc_error(what: &str, detail: &str, err: tonic::Status) -> ArcadeDbError {
let message = err.message();
if err.code() == tonic::Code::AlreadyExists
|| message.to_ascii_lowercase().contains("already exist")
{
return ArcadeDbError::AlreadyExists {
what: what.into(),
message: message.into(),
};
}
ArcadeDbError::Rpc {
operation: what.into(),
detail: detail.into(),
status: err,
}
}
fn command_failed(operation: &str, message: String, affected: i64) -> ArcadeDbError {
if message.to_ascii_lowercase().contains("already exist") {
return ArcadeDbError::AlreadyExists {
what: operation.into(),
message,
};
}
ArcadeDbError::CommandFailed {
operation: operation.into(),
message,
affected: Some(affected),
}
}
struct AuthState {
user_val: MetadataValue<tonic::metadata::Ascii>,
pass_val: MetadataValue<tonic::metadata::Ascii>,
db_val: MetadataValue<tonic::metadata::Ascii>,
database: String,
creds: DatabaseCredentials,
request_timeout: Option<Duration>,
}
#[derive(Clone)]
pub struct ArcadeDbClient {
data: ArcadeDbServiceClient<Channel>,
admin: ArcadeDbAdminServiceClient<Channel>,
auth: std::sync::Arc<AuthState>,
}
impl ArcadeDbClient {
pub async fn connect(addr: &str, user: &str, pass: &str, database: &str) -> Result<Self> {
Self::connect_with(ClientOptions::new(addr, user, pass, database)).await
}
pub async fn connect_with(options: ClientOptions) -> Result<Self> {
options.validate()?;
let addr = options.addr.clone();
let scheme = if options.tls.is_some() {
"https"
} else {
"http"
};
let mut endpoint = Channel::from_shared(format!("{scheme}://{addr}")).map_err(|e| {
ArcadeDbError::InvalidEndpoint {
addr: addr.clone(),
source: e,
}
})?;
if let Some(timeout) = options.connect_timeout {
endpoint = endpoint.connect_timeout(timeout);
}
if let Some(tls) = options.tls {
endpoint = endpoint
.tls_config(tls)
.map_err(|e| ArcadeDbError::InvalidInput {
message: format!("ClientOptions: TLS config rejected by the transport: {e}"),
})?;
}
let attempts = options.connect_attempts;
let backoff = options.connect_backoff;
let channel = {
let mut last_err: Option<tonic::transport::Error> = None;
let mut ch: Option<Channel> = None;
for attempt in 0..attempts {
match endpoint.clone().connect().await {
Ok(c) => {
ch = Some(c);
break;
}
Err(e) => {
tracing::debug!(attempt, %addr, "arcade connect retry: {e}");
last_err = Some(e);
tokio::time::sleep(backoff).await;
}
}
}
ch.ok_or_else(|| ArcadeDbError::Connect {
addr: addr.clone(),
attempts,
source: last_err,
})?
};
tracing::info!(%addr, "connected to ArcadeDB gRPC");
if options.open_or_create {
let mut admin = ArcadeDbAdminServiceClient::new(channel.clone());
let creds = DatabaseCredentials {
username: options.user.clone(),
password: options.pass.clone(),
};
let exists = admin
.clone()
.exists_database(ExistsDatabaseRequest {
credentials: Some(creds.clone()),
name: options.database.clone(),
})
.await
.map_err(|e| {
map_rpc_error("exists database (open_or_create)", &options.database, e)
})?
.into_inner()
.exists;
if !exists {
match admin
.create_database(CreateDatabaseRequest {
credentials: Some(creds),
name: options.database.clone(),
r#type: "graph".into(),
})
.await
{
Ok(_) => {
tracing::info!(db = %options.database, "database created (open_or_create)")
}
Err(e) => {
let e =
map_rpc_error("create database (open_or_create)", &options.database, e);
if !matches!(e, ArcadeDbError::AlreadyExists { .. }) {
return Err(e);
}
}
}
}
}
let parse_meta = |value: &str,
what: &str|
-> Result<MetadataValue<tonic::metadata::Ascii>> {
value.parse().map_err(|_| ArcadeDbError::InvalidInput {
message: format!(
"ClientOptions: {what} contains characters invalid in a gRPC metadata value (visible ASCII only)"
),
})
};
Ok(Self {
data: ArcadeDbServiceClient::new(channel.clone()),
admin: ArcadeDbAdminServiceClient::new(channel),
auth: std::sync::Arc::new(AuthState {
user_val: parse_meta(&options.user, "user")?,
pass_val: parse_meta(&options.pass, "password")?,
db_val: parse_meta(&options.database, "database")?,
database: options.database.clone(),
creds: DatabaseCredentials {
username: options.user,
password: options.pass,
},
request_timeout: options.request_timeout,
}),
})
}
pub fn database(&self) -> &str {
&self.auth.database
}
pub(crate) fn add_auth_headers<T>(&self, mut req: tonic::Request<T>) -> tonic::Request<T> {
let auth = &self.auth;
req.metadata_mut()
.insert("x-arcade-user", auth.user_val.clone());
req.metadata_mut()
.insert("x-arcade-password", auth.pass_val.clone());
req.metadata_mut()
.insert("x-arcade-database", auth.db_val.clone());
if let Some(timeout) = auth.request_timeout {
req.set_timeout(timeout);
}
req
}
pub(crate) fn admin_stub(&self) -> ArcadeDbAdminServiceClient<Channel> {
self.admin.clone()
}
pub(crate) fn creds(&self) -> DatabaseCredentials {
self.auth.creds.clone()
}
pub fn admin(&self) -> crate::admin::Admin {
crate::admin::Admin::new(self.clone())
}
pub fn scan(&self) -> crate::scan::Scan {
crate::scan::Scan::new(self.clone())
}
pub fn batch(&self) -> crate::batch::Batch {
crate::batch::Batch::new(self.clone())
}
#[cfg(feature = "cache")]
pub fn cache(&self) -> crate::cache::Cache {
crate::cache::Cache::new(self.clone())
}
}
pub(crate) fn validate_identifier(name: &str, what: &str) -> Result<String> {
if !name.is_empty() && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
Ok(name.to_string())
} else {
Err(ArcadeDbError::InvalidInput {
message: format!(
"invalid {what} `{name}`: expected non-empty ASCII letters, digits, or `_`"
),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use super::{query::single_column_value, transaction::is_retryable_conflict};
#[test]
fn already_exists_rejections_normalize_to_the_dedicated_variant() {
for msg in [
"Database 'oak' already exists",
"Type 'item' already existing in database",
] {
let err = map_rpc_error("create database", "oak", tonic::Status::internal(msg));
assert!(
matches!(err, ArcadeDbError::AlreadyExists { .. }),
"message {msg:?} should normalize"
);
assert_eq!(err.server_message(), Some(msg));
}
let err = map_rpc_error(
"create database",
"oak",
tonic::Status::already_exists("Database 'oak' already exists"),
);
assert!(matches!(err, ArcadeDbError::AlreadyExists { .. }));
let err = map_rpc_error("query", "SELECT 1", tonic::Status::unavailable("boom"));
assert!(matches!(err, ArcadeDbError::Rpc { .. }));
let err = command_failed(
"execute command",
"Error: Type 'item' already exists".into(),
0,
);
assert!(matches!(err, ArcadeDbError::AlreadyExists { .. }));
let err = command_failed("execute command", "syntax error".into(), 0);
assert!(matches!(err, ArcadeDbError::CommandFailed { .. }));
}
#[test]
fn identifier_validation_accepts_only_plain_names() {
assert_eq!(validate_identifier("item", "type name").unwrap(), "item");
assert_eq!(
validate_identifier("user_shelf_v2", "type name").unwrap(),
"user_shelf_v2"
);
for bad in [
"",
"item; DROP",
"has space",
"has-dash",
"schema:types",
"a.b",
] {
assert!(
validate_identifier(bad, "type name").is_err(),
"`{bad}` must be rejected"
);
}
}
#[test]
fn mvcc_conflicts_are_detected_from_the_server_message() {
for msg in [
"The record was changed by concurrent transaction",
"MVCC conflict on update",
"NeedRetryException: please retry the transaction",
] {
let err = map_rpc_error("commit transaction", "", tonic::Status::aborted(msg));
assert!(is_retryable_conflict(&err), "`{msg}` must be retryable");
}
let err = map_rpc_error("query", "", tonic::Status::internal("syntax error"));
assert!(!is_retryable_conflict(&err));
let err = ArcadeDbError::NotFound {
operation: "x".into(),
detail: "y".into(),
};
assert!(!is_retryable_conflict(&err));
}
#[test]
fn one_row_accessors_decode_or_report_not_found() {
let row = crate::rec("t", vec![("name", crate::encode::str_v("oak"))]);
let empty = QueryResult {
records: vec![],
execution_time_ms: 0,
};
assert!(empty.first::<ItemRow>().unwrap().is_none());
assert!(matches!(
empty.one::<ItemRow>(),
Err(ArcadeDbError::NotFound { .. })
));
let single = QueryResult {
records: vec![row],
execution_time_ms: 0,
};
let row = single.first::<ItemRow>().unwrap().unwrap();
assert_eq!(row.name, "oak");
assert_eq!(single.one::<ItemRow>().unwrap().name, "oak");
let wide = crate::rec(
"t",
vec![
("a", crate::encode::str_v("1")),
("b", crate::encode::str_v("2")),
],
);
assert!(single_column_value(&wide, "SELECT a, b FROM t").is_err());
let lone = crate::rec("t", vec![("count", crate::encode::i64_v(7))]);
let scalar = single_column_value(&lone, "SELECT count(*) AS count FROM t")
.unwrap()
.clone();
assert!(matches!(scalar.kind, Some(grpc_value::Kind::Int64Value(7))));
}
#[derive(Clone)]
struct ItemRow {
name: String,
}
impl<'a> TryFrom<&'a GrpcRecord> for ItemRow {
type Error = RecordDecodeError;
fn try_from(rec: &'a GrpcRecord) -> Result<Self, Self::Error> {
let name = rec
.properties
.get("name")
.ok_or_else(|| RecordDecodeError::missing_field("name"))?;
let Some(grpc_value::Kind::StringValue(s)) = &name.kind else {
return Err(RecordDecodeError::conversion("name: expected string"));
};
Ok(ItemRow { name: s.clone() })
}
}
}