udb 0.3.5

Universal Data Broker — a Rust gRPC broker over multiple databases (Postgres, MySQL, SQLite, MongoDB, ClickHouse, Cassandra, MSSQL, Redis, Qdrant, S3, Neo4j, …) with per-tenant RLS, 2PC, sagas, and CDC.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use super::support::*;
use crate::proto::udb::core::storage::services::v1 as storage_pb;
use crate::proto::udb::core::storage::services::v1::storage_service_server::StorageService;
use tonic::Request;
use uuid::Uuid;

#[tokio::test]
#[ignore = "requires live Postgres; run with UDB_LIVE_AUTH_TESTS=1 cargo test --lib live_postgres_storage_native_schema_from_proto -- --ignored --nocapture"]
async fn live_postgres_storage_native_schema_from_proto() {
    let _guard = live_native_service_db_lock().lock().await;
    let pool = live_pg_pool().await;
    migrate_native_service_db(&pool).await;

    assert_native_table_columns(
        &pool,
        "udb.core.storage.entity.v1.File",
        &[
            "file_id",
            "tenant_id",
            "filename",
            "object_key",
            "file_type",
            "status",
            "is_public",
            "audit_info",
            "deleted_at",
        ],
    )
    .await;

    cleanup_native_service_db(&pool).await;
}

#[tokio::test]
#[ignore = "requires live Postgres; run with UDB_LIVE_AUTH_TESTS=1 cargo test --lib live_postgres_storage_crud_roundtrip -- --ignored --nocapture"]
async fn live_postgres_storage_crud_roundtrip() {
    let _guard = live_native_service_db_lock().lock().await;
    let pool = live_pg_pool().await;
    migrate_native_service_db(&pool).await;
    let svc = storage_service(pool.clone()).await;
    let tenant_id = Uuid::new_v4().to_string();

    // register → PENDING record + allocated object_key
    let reg = svc
        .register_upload(Request::new(storage_pb::RegisterUploadRequest {
            tenant_id: tenant_id.clone(),
            filename: "invoice.pdf".to_string(),
            content_type: "application/pdf".to_string(),
            file_type: "PDF".to_string(),
            size_bytes: 2048,
            ..Default::default()
        }))
        .await
        .expect("register_upload")
        .into_inner();
    assert!(!reg.file_id.is_empty());
    assert!(reg.object_key.contains(&reg.file_id));
    put_storage_object(&reg.object_key, "application/pdf", b"%PDF-udb-live").await;

    // finalize → ACTIVE, returns the row
    let fin = svc
        .finalize_upload(Request::new(storage_pb::FinalizeUploadRequest {
            tenant_id: tenant_id.clone(),
            file_id: reg.file_id.clone(),
            content_type: "application/pdf".to_string(),
            is_public: Some(true),
            size_bytes: 2048,
            ..Default::default()
        }))
        .await
        .expect("finalize_upload")
        .into_inner();
    let file = fin.file.expect("finalized file");
    assert_eq!(file.file_id, reg.file_id);
    assert!(file.is_public);
    assert_eq!(
        file.size_bytes, 2048,
        "finalize must persist the actual size"
    );

    // list → finds it
    let listed = svc
        .list_files(Request::new(storage_pb::ListFilesRequest {
            tenant_id: tenant_id.clone(),
            ..Default::default()
        }))
        .await
        .expect("list_files")
        .into_inner();
    assert_eq!(listed.total_count, 1);

    // update → new filename
    svc.update_file(Request::new(storage_pb::UpdateFileRequest {
        tenant_id: tenant_id.clone(),
        file_id: reg.file_id.clone(),
        filename: "invoice-final.pdf".to_string(),
        ..Default::default()
    }))
    .await
    .expect("update_file");

    // delete (soft) → gone from get
    let del = svc
        .delete_file(Request::new(storage_pb::DeleteFileRequest {
            tenant_id: tenant_id.clone(),
            file_id: reg.file_id.clone(),
        }))
        .await
        .expect("delete_file")
        .into_inner();
    assert!(del.success);

    let missing = svc
        .get_file(Request::new(storage_pb::GetFileRequest {
            tenant_id,
            file_id: reg.file_id,
        }))
        .await;
    assert!(missing.is_err(), "soft-deleted file must not be readable");

    cleanup_native_service_db(&pool).await;
}