trql-client 0.29.0

Transport-agnostic Trust Registry query client (TRQP over Trust Tasks): HTTPS, DIDComm, TSP
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

//! Transport-agnostic query client for the Affinidi Trust Registry.
//!
//! Queries are TRQP authorization/recognition checks carried as **Trust Task
//! documents** (`registry/authorization/0.2` and `registry/recognition/0.2`,
//! falling back to 0.1 for a registry that answers `unsupportedVersion`; see
//! [`TrqlClient::authorization`]) — the same contract the registry
//! serves over every transport. The document is the protocol; a transport is
//! only a pipe that moves one request document and returns the peer's reply
//! document (see [`TrqlTransport`]).
//!
//! Three bindings are provided behind features:
//!
//! * `https` (default) — [`HttpsTransport`]: `POST <registry>/trust-tasks`,
//!   the `trust-tasks-https` wire contract.
//! * `didcomm` — [`DidcommTransport`]: the `trust-tasks-didcomm` envelope over
//!   an ATM mediator websocket.
//! * `tsp` — [`TspTransport`]: the `trust-tasks-tsp` envelope sealed in a TSP
//!   `Direct` message, multiplexed on the same mediator websocket.
//!
//! Every reply is correlated to its request (`threadId` == request `id`) and
//! a reply that cannot be parsed is surfaced as a contract error, never as a
//! transport failure. A registry rejection arrives as a typed
//! [`TrqlError::Rejected`] carrying the machine-readable trust-task-error
//! code.
//!
//! ```rust,ignore
//! use std::sync::Arc;
//! use trql_client::{HttpsTransport, HttpsTransportConfig, TrqlClient, TrqpQuery};
//!
//! let transport = HttpsTransport::new(HttpsTransportConfig::new("http://localhost:3232"))?;
//! let client = TrqlClient::new(Arc::new(transport), "did:webvh:...registry");
//!
//! let response = client
//!     .authorization(TrqpQuery::new(
//!         "did:webvh:...signer",     // entity
//!         "did:webvh:...authority",  // authority
//!         "git.commit.sign",         // action
//!         "openvtc",                 // resource
//!     ))
//!     .await?;
//! if response.authorized { /* ... */ }
//! ```

// The client still speaks `registry/authorization` and `registry/recognition`
// 0.1, now superseded by 0.2, as the fallback for registries that predate 0.2.
#![allow(deprecated)]

mod answer;
mod client;
mod discovery;
mod error;
mod transport;

#[cfg(feature = "didcomm")]
mod didcomm;
#[cfg(feature = "https")]
mod https;
#[cfg(any(feature = "didcomm", feature = "tsp"))]
mod pending;
#[cfg(feature = "tsp")]
mod tsp;

pub use answer::{AuthorizationAnswer, RecognitionAnswer, SpecVersion};
pub use client::{TrqlClient, TrqpQuery};
pub use discovery::{
    DIDCOMM_SERVICE_TYPE, PREFERENCE_ORDER, REST_SERVICE_TYPE, REST_SERVICE_TYPES,
    ServiceCapabilities, TRUST_REGISTRY_SERVICE_TYPE, TSP_SERVICE_TYPE, TransportChoice,
    VTA_REST_SERVICE_TYPE, registry_referral,
};
pub use error::TrqlError;
pub use transport::{TransportKind, TrqlTransport};

#[cfg(feature = "didcomm")]
pub use didcomm::{DidcommTransport, DidcommTransportConfig};
#[cfg(feature = "https")]
pub use https::{HttpsTransport, HttpsTransportConfig};
#[cfg(feature = "tsp")]
pub use tsp::{TspTransport, TspTransportConfig};

/// The generated request/response payload types this client speaks, per spec
/// version, re-exported so consumers don't need a direct `trust-tasks-rs`
/// dependency to inspect them. [`TrqlClient`] answers with
/// [`AuthorizationAnswer`] / [`RecognitionAnswer`], not these.
pub mod payloads {
    /// `registry/authorization/0.2` and `registry/recognition/0.2`.
    pub mod v0_2 {
        pub use trust_tasks_rs::specs::registry::authorization::v0_2::{
            Payload as AuthorizationRequest, QueryContext as AuthorizationQueryContext,
            Response as AuthorizationResponse,
        };
        pub use trust_tasks_rs::specs::registry::recognition::v0_2::{
            Payload as RecognitionRequest, QueryContext as RecognitionQueryContext,
            Response as RecognitionResponse,
        };
    }
    /// `registry/authorization/0.1` and `registry/recognition/0.1`, the
    /// fallback for registries that predate 0.2.
    pub mod v0_1 {
        pub use trust_tasks_rs::specs::registry::authorization::v0_1::{
            Payload as AuthorizationRequest, QueryContext as AuthorizationQueryContext,
            Response as AuthorizationResponse,
        };
        pub use trust_tasks_rs::specs::registry::recognition::v0_1::{
            Payload as RecognitionRequest, QueryContext as RecognitionQueryContext,
            Response as RecognitionResponse,
        };
    }
}