coil-wasm 0.1.1

WASM extension runtime and host APIs for the Coil framework.
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

mod data_contract;

pub use data_contract::*;

use crate::grants::{HostCapabilityGrant, MetadataGrant, StorageClassGrant};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HostServiceDomain {
    Auth,
    Data,
    Storage,
    Render,
    CacheIntent,
    Network,
    Secrets,
    Jobs,
    Metadata,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AuthServiceRequest {
    Check,
    List,
    Lookup,
    TupleWrite,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DataServiceRequest {
    Read { contract: ModuleDataContract },
    Write { contract: ModuleDataContract },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StorageServiceRequest {
    Read {
        class: StorageClassGrant,
    },
    Write {
        class: StorageClassGrant,
        bytes: u64,
    },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RenderServiceRequest {
    Fragment { slot: String },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CacheIntentServiceRequest {
    HintWrite,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum HostServiceRequest {
    Auth(AuthServiceRequest),
    Data(DataServiceRequest),
    Storage(StorageServiceRequest),
    Render(RenderServiceRequest),
    CacheIntent(CacheIntentServiceRequest),
    OutboundHttp {
        integration: String,
        response_bytes: u64,
    },
    SecretRead {
        secret: String,
    },
    EnqueueJob {
        queue: String,
    },
    MetadataWrite {
        kind: MetadataGrant,
    },
}

impl HostServiceRequest {
    pub fn domain(&self) -> HostServiceDomain {
        match self {
            Self::Auth(_) => HostServiceDomain::Auth,
            Self::Data(_) => HostServiceDomain::Data,
            Self::Storage(_) => HostServiceDomain::Storage,
            Self::Render(_) => HostServiceDomain::Render,
            Self::CacheIntent(_) => HostServiceDomain::CacheIntent,
            Self::OutboundHttp { .. } => HostServiceDomain::Network,
            Self::SecretRead { .. } => HostServiceDomain::Secrets,
            Self::EnqueueJob { .. } => HostServiceDomain::Jobs,
            Self::MetadataWrite { .. } => HostServiceDomain::Metadata,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HostServiceCall {
    pub grant: HostCapabilityGrant,
    pub request: HostServiceRequest,
}

impl HostServiceCall {
    pub fn new(grant: HostCapabilityGrant, request: HostServiceRequest) -> Self {
        Self { grant, request }
    }

    pub fn domain(&self) -> HostServiceDomain {
        self.request.domain()
    }
}