Struct CoreClient 

pub struct CoreClient { /* private fields */ }

Implementations

impl CoreClient

pub async fn insert<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn batch_insert<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn search<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/core_direct_search_optional.rs (lines 41-44)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "core_direct_search_optional";
    let started = Instant::now();
    let config = ScenarioConfig::from_env();
    let client = create_client().await?;
    let run_id = new_run_id("core_direct_search_optional");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated optional core direct-search".to_string();
    let mut metrics = json!({});

    let scenario = async {
        match client
            .core
            .search(json!({
                "query": "direct core semantic search probe",
                "k": 5,
            }))
            .await
        {
            Ok(payload) => {
                require(
                    payload.is_array() || payload.is_object(),
                    format!("core.search payload must be dict/list: {payload}"),
                )?;

                metrics = json!({
                    "run_id": run_id,
                    "enabled": true,
                    "result_count": extract_result_count(&payload),
                });
                detail = "validated optional core direct-search (enabled)".to_string();
            }
            Err(err) => {
                if config.expect_direct_search_enabled {
                    return Err(boxed_error(format!(
                        "core.search expected enabled but failed: {err}"
                    )));
                }
                let message = err.to_string();
                require(
                    is_permission_denied_like(&message),
                    format!(
                        "core.search should fail with permission denied when disabled: {message}"
                    ),
                )?;

                metrics = json!({
                    "run_id": run_id,
                    "enabled": false,
                    "message": message,
                });
                detail = "validated optional core direct-search (disabled)".to_string();
            }
        }

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

examples/internal/core_direct_search.rs (lines 41-44)

async fn main() -> Result<(), Box<dyn Error>> {
    let name = "internal_core_direct_search";
    let started = Instant::now();
    let config = ScenarioConfig::from_env();
    let client = create_client().await?;
    let run_id = new_run_id("internal_core_direct_search");
    client.set_run_id(Some(run_id.clone()));
    client.set_transport(TransportMode::Http);

    let mut passed = true;
    let mut detail = "validated optional core direct-search".to_string();
    let mut metrics = json!({});

    let scenario = async {
        match client
            .core
            .search(json!({
                "query": "direct core semantic search probe",
                "k": 5,
            }))
            .await
        {
            Ok(payload) => {
                require(
                    payload.is_array() || payload.is_object(),
                    format!("core.search payload must be dict/list: {payload}"),
                )?;

                metrics = json!({
                    "run_id": run_id,
                    "enabled": true,
                    "result_count": extract_result_count(&payload),
                });
                detail = "validated optional core direct-search (enabled)".to_string();
            }
            Err(err) => {
                if config.expect_direct_search_enabled {
                    return Err(boxed_error(format!(
                        "core.search expected enabled but failed: {err}"
                    )));
                }
                let message = err.to_string();
                require(
                    is_permission_denied_like(&message),
                    format!(
                        "core.search should fail with permission denied when disabled: {message}"
                    ),
                )?;

                metrics = json!({
                    "run_id": run_id,
                    "enabled": false,
                    "message": message,
                });
                detail = "validated optional core direct-search (disabled)".to_string();
            }
        }

        Ok::<(), Box<dyn Error>>(())
    }
    .await;

    if let Err(err) = scenario {
        passed = false;
        detail = err.to_string();
    }

    let cleanup_ok = cleanup_run(&client, &run_id).await;
    if !cleanup_ok {
        passed = false;
        detail = format!("{detail} | cleanup failures");
    }

    print_summary(
        name,
        passed,
        &detail,
        &metrics,
        started.elapsed().as_secs_f64(),
        cleanup_ok,
    );

    if passed {
        Ok(())
    } else {
        Err(boxed_error(detail))
    }
}

pub async fn delete_node<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn delete_run<T: Serialize>(&self, payload: T) -> Result<Value>

Examples found in repository

examples/support/utils.rs (line 93)

pub async fn cleanup_run(client: &Client, run_id: &str) -> bool {
    let control_ok = client
        .control
        .delete_run(json!({ "run_id": run_id }))
        .await
        .is_ok();
    let core_ok = match client.core.delete_run(json!({ "run_id": run_id })).await {
        Ok(_) => true,
        Err(err) => is_permission_denied_like(&err.to_string()),
    };
    control_ok && core_ok
}

pub async fn create_session<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn snapshot_session<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn load_session<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn commit_session<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn drop_session<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn write_memory<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn read_memory<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn add_memory<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn get_memory<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn clear_memory<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn grant_permission<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn revoke_permission<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn check_permission<T: Serialize>(&self, payload: T) -> Result<Value>

pub async fn unsubscribe_events<T: Serialize>( &self, payload: T, ) -> Result<Value>

impl CoreClient

pub async fn subscribe_events<T: Serialize>( &self, payload: T, ) -> Result<ValueStream>

pub async fn watch_memory<T: Serialize>( &self, payload: T, ) -> Result<ValueStream>

pub async fn list_subscriptions(&self) -> Result<Value>

pub async fn storage_stats(&self) -> Result<Value>

pub async fn trigger_compaction(&self) -> Result<Value>

Trait Implementations

impl Clone for CoreClient

fn clone(&self) -> CoreClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.