cbindgen fixes

Author: analogrelay

sdk/cosmos/azure_data_cosmos_native/build.rs

@@ -3,6 +3,8 @@
 
 // cSpell:ignore SOURCEVERSION, SOURCEBRANCH, BUILDID, BUILDNUMBER, COSMOSCLIENT, cosmosclient, libcosmosclient, cbindgen
 
+use std::collections::HashMap;
+
 fn main() {
     let build_id = format!(
         "$Id: {}, Version: {}, Commit: {}, Branch: {}, Build ID: {}, Build Number: {}, Timestamp: {}$",
@@ -28,20 +30,46 @@ fn main() {
     .to_string();
     header.push_str(&format!("// Build identifier: {}\n", build_id));
 
+    let config = cbindgen::Config {
+        language: cbindgen::Language::C,
+        header: Some(header),
+        after_includes: Some(
+            "\n// Specifies the version of cosmosclient this header file was generated from.\n// This should match the version of libcosmosclient you are referencing.\n#define COSMOSCLIENT_H_VERSION \"".to_string()
+                + env!("CARGO_PKG_VERSION")
+                + "\"",
+        ),
+        cpp_compat: true,
+        parse: cbindgen::ParseConfig {
+            parse_deps: true,
+            include: Some(vec!["azure_data_cosmos".into()]),
+            ..Default::default()
+        },
+        style: cbindgen::Style::Both,
+        enumeration: cbindgen::EnumConfig {
+            rename_variants: cbindgen::RenameRule::QualifiedScreamingSnakeCase,
+            ..Default::default()
+        },
+        documentation_length: cbindgen::DocumentationLength::Full,
+        documentation_style: cbindgen::DocumentationStyle::Doxy,
+        export: cbindgen::ExportConfig {
+            prefix: Some("cosmos_".into()),
+            exclude: vec!["PartitionKeyValue".into()],
+            rename: HashMap::from([
+                ("CosmosError".into(), "error".into()),
+                ("CosmosErrorCode".into(), "error_code".into()),
+                ("CosmosClient".into(), "client".into()),
+                ("DatabaseClient".into(), "database_client".into()),
+                ("ContainerClient".into(), "container_client".into()),
+            ]),
+            ..Default::default()
+        },
+        ..Default::default()
+    };
+
     let crate_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
     cbindgen::Builder::new()
         .with_crate(crate_dir)
-        .with_language(cbindgen::Language::C)
-        .with_after_include(format!(
-            "\n// Specifies the version of cosmosclient this header file was generated from.\n// This should match the version of libcosmosclient you are referencing.\n#define COSMOSCLIENT_H_VERSION \"{}\"",
-            env!("CARGO_PKG_VERSION")
-        ))
-        .with_style(cbindgen::Style::Both)
-        .rename_item("CosmosClientHandle", "CosmosClient")
-        .rename_item("DatabaseClientHandle", "DatabaseClient")
-        .rename_item("ContainerClientHandle", "ContainerClient")
-        .with_cpp_compat(true)
-        .with_header(header)
+        .with_config(config)
         .generate()
         .expect("unable to generate bindings")
         .write_to_file("include/azurecosmos.h");

sdk/cosmos/azure_data_cosmos_native/c_tests/item_crud.c

@@ -4,65 +4,74 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <time.h>
 #include "../include/azurecosmos.h"
 
 #define SENTINEL_VALUE "test-sentinel-12345"
 #define ITEM_ID "test-item-id"
 #define PARTITION_KEY_VALUE "test-partition"
+#define PARTITION_KEY_PATH "/partitionKey"
 
 int main() {
     cosmos_enable_tracing();
 
-    // Get environment variables
+    // Get environment variables (only endpoint and key required)
     const char *endpoint = getenv("AZURE_COSMOS_ENDPOINT");
     const char *key = getenv("AZURE_COSMOS_KEY");
-    const char *database_name = getenv("AZURE_COSMOS_DATABASE");
-    const char *container_name = getenv("AZURE_COSMOS_CONTAINER");
 
-    if (!endpoint || !key || !database_name || !container_name) {
+    if (!endpoint || !key) {
         printf("Error: Missing required environment variables.\n");
-        printf("Required: AZURE_COSMOS_ENDPOINT, AZURE_COSMOS_KEY, AZURE_COSMOS_DATABASE, AZURE_COSMOS_CONTAINER\n");
+        printf("Required: AZURE_COSMOS_ENDPOINT, AZURE_COSMOS_KEY\n");
         return 1;
     }
 
+    // Generate unique database and container names using timestamp
+    time_t current_time = time(NULL);
+    char database_name[64];
+    snprintf(database_name, sizeof(database_name), "auto-test-db-%ld", current_time);
+
     printf("Running Cosmos DB item CRUD test...\n");
     printf("Endpoint: %s\n", endpoint);
     printf("Database: %s\n", database_name);
-    printf("Container: %s\n", container_name);
+    printf("Container: test-container\n");
 
-    struct CosmosError error = {0};
-    struct CosmosClient *client = NULL;
-    struct DatabaseClient *database = NULL;
-    struct ContainerClient *container = NULL;
+    cosmos_error error = {0};
+    cosmos_client *client = NULL;
+    cosmos_database_client *database = NULL;
+    cosmos_container_client *container = NULL;
     char *read_json = NULL;
     int result = 0;
+    int database_created = 0;
+    int container_created = 0;
 
     // Create Cosmos client
-    CosmosErrorCode code = cosmos_client_create(endpoint, key, &client, &error);
-    if (code != Success) {
+    cosmos_error_code code = cosmos_client_create_with_key(endpoint, key, &client, &error);
+    if (code != COSMOS_ERROR_CODE_SUCCESS) {
         printf("Failed to create Cosmos client: %s (code: %d)\n", error.message, error.code);
         result = 1;
         goto cleanup;
     }
     printf("✓ Created Cosmos client\n");
 
-    // Get database client
-    code = cosmos_client_database_client(client, database_name, &database, &error);
-    if (code != Success) {
-        printf("Failed to get database client: %s (code: %d)\n", error.message, error.code);
+    // Create database
+    code = cosmos_client_create_database(client, database_name, &database, &error);
+    if (code != COSMOS_ERROR_CODE_SUCCESS) {
+        printf("Failed to create database: %s (code: %d)\n", error.message, error.code);
         result = 1;
         goto cleanup;
     }
-    printf("✓ Got database client\n");
+    database_created = 1;
+    printf("✓ Created database: %s\n", database_name);
 
-    // Get container client
-    code = cosmos_database_container_client(database, container_name, &container, &error);
-    if (code != Success) {
-        printf("Failed to get container client: %s (code: %d)\n", error.message, error.code);
+    // Create container with partition key
+    code = cosmos_database_create_container(database, "test-container", PARTITION_KEY_PATH, &container, &error);
+    if (code != COSMOS_ERROR_CODE_SUCCESS) {
+        printf("Failed to create container: %s (code: %d)\n", error.message, error.code);
         result = 1;
         goto cleanup;
     }
-    printf("✓ Got container client\n");
+    container_created = 1;
+    printf("✓ Created container: %s with partition key: %s\n", "test-container", PARTITION_KEY_PATH);
 
     // Construct JSON document with sentinel value
     char json_data[512];
@@ -74,7 +83,7 @@ int main() {
 
     // Upsert the item
     code = cosmos_container_upsert_item(container, PARTITION_KEY_VALUE, json_data, &error);
-    if (code != Success) {
+    if (code != COSMOS_ERROR_CODE_SUCCESS) {
         printf("Failed to upsert item: %s (code: %d)\n", error.message, error.code);
         result = 1;
         goto cleanup;
@@ -83,7 +92,7 @@ int main() {
 
     // Read the item back
     code = cosmos_container_read_item(container, PARTITION_KEY_VALUE, ITEM_ID, &read_json, &error);
-    if (code != Success) {
+    if (code != COSMOS_ERROR_CODE_SUCCESS) {
         printf("Failed to read item: %s (code: %d)\n", error.message, error.code);
         result = 1;
         goto cleanup;
@@ -110,22 +119,35 @@ int main() {
     printf("SUCCESS: Item CRUD test completed successfully.\n");
 
 cleanup:
-//     // Free all allocated resources
-//     if (read_json) {
-//         cosmos_string_free(read_json);
-//     }
-//     if (container) {
-//         cosmos_container_free(container);
-//     }
-//     if (database) {
-//         cosmos_database_free(database);
-//     }
-//     if (client) {
-//         cosmos_client_free(client);
-//     }
-//     if (error.message) {
-//         cosmos_error_free(&error);
-//     }
+    // Clean up resources in reverse order, even on failure
+    if (read_json) {
+        cosmos_string_free(read_json);
+    }
+
+    // Delete database (this will also delete the container)
+    if (database && database_created) {
+        printf("Deleting database: %s\n", database_name);
+        cosmos_error delete_error = {0};
+        cosmos_error_code delete_code = cosmos_database_delete(database, &delete_error);
+        if (delete_code != COSMOS_ERROR_CODE_SUCCESS) {
+            printf("Failed to delete database: %s (code: %d)\n", delete_error.message, delete_error.code);
+        } else {
+            printf("✓ Deleted database successfully\n");
+        }
+    }
+
+    if (container) {
+        cosmos_container_free(container);
+    }
+    if (database) {
+        cosmos_database_free(database);
+    }
+    if (client) {
+        cosmos_client_free(client);
+    }
+    if (error.message) {
+        cosmos_error_free(&error);
+    }
 
     return result;
 }

sdk/cosmos/azure_data_cosmos_native/src/clients/container_client.rs

@@ -8,12 +8,12 @@ use serde_json::value::RawValue;
 use crate::blocking::block_on;
 use crate::error::{self, marshal_result, CosmosError, CosmosErrorCode};
 use crate::string::{parse_cstr, safe_cstring_into_raw};
-use crate::ContainerClientHandle;
 
+/// Releases the memory associated with a [`ContainerClient`].
 #[no_mangle]
-pub extern "C" fn cosmos_container_free(container: *mut ContainerClientHandle) {
+pub extern "C" fn cosmos_container_free(container: *mut ContainerClient) {
     if !container.is_null() {
-        unsafe { ContainerClientHandle::free_ptr(container) }
+        unsafe { drop(Box::from_raw(container)) }
     }
 }
 
@@ -39,7 +39,7 @@ fn create_item_inner(
 /// * `out_error` - Output parameter that will receive error information if the function fails.
 #[no_mangle]
 pub extern "C" fn cosmos_container_create_item(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     partition_key: *const c_char,
     json_data: *const c_char,
     out_error: *mut CosmosError,
@@ -49,7 +49,7 @@ pub extern "C" fn cosmos_container_create_item(
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     let partition_key_str = match parse_cstr(partition_key, error::CSTR_INVALID_PARTITION_KEY) {
         Ok(s) => s,
@@ -87,7 +87,6 @@ fn upsert_item_inner(
 ) -> Result<(), CosmosError> {
     let raw_value: Box<RawValue> = serde_json::from_str(json_str)?;
     let pk = partition_key.to_string();
-    tracing::trace!(raw_value = %raw_value.get(), pk = %pk, "Upserting item");
     block_on(container.upsert_item(pk, raw_value, None))?;
     Ok(())
 }
@@ -101,7 +100,7 @@ fn upsert_item_inner(
 /// * `out_error` - Output parameter that will receive error information if the function fails.
 #[no_mangle]
 pub extern "C" fn cosmos_container_upsert_item(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     partition_key: *const c_char,
     json_data: *const c_char,
     out_error: *mut CosmosError,
@@ -111,7 +110,7 @@ pub extern "C" fn cosmos_container_upsert_item(
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     let partition_key_str = match parse_cstr(partition_key, error::CSTR_INVALID_PARTITION_KEY) {
         Ok(s) => s,
@@ -165,7 +164,7 @@ fn read_item_inner(
 /// * `out_error` - Output parameter that will receive error information if the function fails.
 #[no_mangle]
 pub extern "C" fn cosmos_container_read_item(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     partition_key: *const c_char,
     item_id: *const c_char,
     out_json: *mut *mut c_char,
@@ -180,7 +179,7 @@ pub extern "C" fn cosmos_container_read_item(
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     let partition_key_str = match parse_cstr(partition_key, error::CSTR_INVALID_PARTITION_KEY) {
         Ok(s) => s,
@@ -235,7 +234,7 @@ fn replace_item_inner(
 /// * `out_error` - Output parameter that will receive error information if the function fails
 #[no_mangle]
 pub extern "C" fn cosmos_container_replace_item(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     partition_key: *const c_char,
     item_id: *const c_char,
     json_data: *const c_char,
@@ -250,7 +249,7 @@ pub extern "C" fn cosmos_container_replace_item(
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     let partition_key_str = match parse_cstr(partition_key, error::CSTR_INVALID_PARTITION_KEY) {
         Ok(s) => s,
@@ -311,7 +310,7 @@ fn delete_item_inner(
 /// * `out_error` - Output parameter that will receive error information if the function fails
 #[no_mangle]
 pub extern "C" fn cosmos_container_delete_item(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     partition_key: *const c_char,
     item_id: *const c_char,
     out_error: *mut CosmosError,
@@ -320,7 +319,7 @@ pub extern "C" fn cosmos_container_delete_item(
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     let partition_key_str = match parse_cstr(partition_key, error::CSTR_INVALID_PARTITION_KEY) {
         Ok(s) => s,
@@ -366,15 +365,15 @@ fn read_container_inner(container: &ContainerClient) -> Result<String, CosmosErr
 /// * `out_error` - Output parameter that will receive error information if the function fails.
 #[no_mangle]
 pub extern "C" fn cosmos_container_read(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     out_json: *mut *mut c_char,
     out_error: *mut CosmosError,
 ) -> CosmosErrorCode {
     if container.is_null() || out_json.is_null() || out_error.is_null() {
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     marshal_result(
         read_container_inner(container_handle),
@@ -417,7 +416,7 @@ fn query_items_inner(
 /// * `out_error` - Output parameter that will receive error information if the function fails.
 #[no_mangle]
 pub extern "C" fn cosmos_container_query_items(
-    container: *const ContainerClientHandle,
+    container: *const ContainerClient,
     query: *const c_char,
     partition_key: *const c_char,
     out_json: *mut *mut c_char,
@@ -427,7 +426,7 @@ pub extern "C" fn cosmos_container_query_items(
         return CosmosErrorCode::InvalidArgument;
     }
 
-    let container_handle = unsafe { ContainerClientHandle::unwrap_ptr(container) };
+    let container_handle = unsafe { &*container };
 
     let query_str = match parse_cstr(query, error::CSTR_INVALID_QUERY) {
         Ok(s) => s,