appcore-distributed-contracts 1.0.0

Versioned distributed wire and coordination contracts for AppCore Runtime
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

# Validate and deduplicate opaque transport

[Português](intermediate.pt.md) | [Français](intermediate.fr.md) |
[Minimal example](basic.en.md) | [Guide](../guide.en.md)

A gateway can validate routing metadata without opening encrypted application
content. Apply the bounded deduplicator only after policy validation succeeds.

```rust
use appcore_distributed_contracts::{
    OpaqueContentEnvelopeV1, OpaqueEnvelopeDecision,
    OpaqueEnvelopeDeduplicator, OpaqueEnvelopePolicy,
};
use appcore_types::{CapabilityName, InstanceId, RuntimeResult, TenantId};

fn main() -> RuntimeResult<()> {
    let capability = CapabilityName::new("sync.consume")?;
    let policy = OpaqueEnvelopePolicy {
        accepted_envelope_versions: vec![1],
        max_payload_bytes: 64 * 1024,
        accepted_capabilities: vec![capability.clone()],
    };
    let envelope = OpaqueContentEnvelopeV1::new(
        TenantId::new("tenant-acme")?,
        InstanceId::new("notes-eu-1")?,
        "message-00042",
        Some("sync-cycle-7".into()),
        capability,
        vec![0x44, 0x4e, 0x54, 0x01],
        1,
        1_700_000_000_000,
        1_700_000_060_000,
        Some(5),
    );

    if envelope.validate_transport(&policy, 1_700_000_010_000)
        != OpaqueEnvelopeDecision::Accepted
    {
        return Err(appcore_types::RuntimeError::InvalidRequest {
            kind: "opaque envelope",
            reason: "transport policy rejected",
        });
    }

    let mut deduplicator = OpaqueEnvelopeDeduplicator::new(10_000);
    assert_eq!(
        deduplicator.accept(&envelope.message_id),
        OpaqueEnvelopeDecision::Accepted
    );
    assert_eq!(
        deduplicator.accept(&envelope.message_id),
        OpaqueEnvelopeDecision::Duplicate
    );
    Ok(())
}
```

The transport sees only bounded metadata and opaque bytes. Decryption and
application schema validation remain with the destination consumer.