rong_s3 0.3.1

S3-compatible object storage module for RongJS
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use rong::*;
use std::rc::Rc;

/// S3 configuration: credentials + bucket + endpoint.
#[derive(Clone, Debug)]
pub struct S3Config {
    pub access_key_id: String,
    pub secret_access_key: String,
    pub session_token: Option<String>,
    pub region: String,
    pub endpoint: Option<String>,
    pub bucket: String,
    pub acl: Option<String>,
    pub virtual_hosted_style: bool,
}

impl Default for S3Config {
    fn default() -> Self {
        Self {
            access_key_id: String::new(),
            secret_access_key: String::new(),
            session_token: None,
            region: "us-east-1".to_string(),
            endpoint: None,
            bucket: String::new(),
            acl: None,
            virtual_hosted_style: false,
        }
    }
}

impl S3Config {
    /// Build config from a JS options object.
    pub fn from_js_options(obj: &JSObject) -> JSResult<Self> {
        let mut config = Self::default();

        if let Ok(v) = obj.get::<_, String>("accessKeyId") {
            config.access_key_id = v;
        }
        if let Ok(v) = obj.get::<_, String>("secretAccessKey") {
            config.secret_access_key = v;
        }
        if let Ok(v) = obj.get::<_, String>("sessionToken") {
            config.session_token = Some(v);
        }
        if let Ok(v) = obj.get::<_, String>("region") {
            config.region = v;
        }
        if let Ok(v) = obj.get::<_, String>("endpoint") {
            config.endpoint = Some(v);
        }
        if let Ok(v) = obj.get::<_, String>("bucket") {
            config.bucket = v;
        }
        if let Ok(v) = obj.get::<_, String>("acl") {
            config.acl = Some(v);
        }
        if let Ok(v) = obj.get::<_, bool>("virtualHostedStyle") {
            config.virtual_hosted_style = v;
        }

        Ok(config)
    }

    /// Overlay JS options on top of this config. Only provided fields are overwritten.
    pub fn merge_js_options(&self, obj: &JSObject) -> JSResult<Self> {
        let mut config = self.clone();

        if let Ok(v) = obj.get::<_, String>("accessKeyId") {
            config.access_key_id = v;
        }
        if let Ok(v) = obj.get::<_, String>("secretAccessKey") {
            config.secret_access_key = v;
        }
        if let Ok(v) = obj.get::<_, String>("sessionToken") {
            config.session_token = Some(v);
        }
        if let Ok(v) = obj.get::<_, String>("region") {
            config.region = v;
        }
        if let Ok(v) = obj.get::<_, String>("endpoint") {
            config.endpoint = Some(v);
        }
        if let Ok(v) = obj.get::<_, String>("bucket") {
            config.bucket = v;
        }
        if let Ok(v) = obj.get::<_, String>("acl") {
            config.acl = Some(v);
        }
        if let Ok(v) = obj.get::<_, bool>("virtualHostedStyle") {
            config.virtual_hosted_style = v;
        }

        Ok(config)
    }

    /// Create an s3::Bucket from this config.
    pub fn create_bucket(&self) -> JSResult<s3::Bucket> {
        if self.access_key_id.is_empty() || self.secret_access_key.is_empty() {
            return Err(HostError::new(
                "ERR_S3_MISSING_CREDENTIALS",
                "S3 credentials are required. Pass accessKeyId and secretAccessKey in the options object.",
            )
            .into());
        }
        if self.bucket.is_empty() {
            return Err(HostError::new(
                "ERR_S3_MISSING_CREDENTIALS",
                "S3 bucket name is required. Pass bucket in the options object.",
            )
            .into());
        }

        let region = match &self.endpoint {
            Some(endpoint) => s3::Region::Custom {
                region: self.region.clone(),
                endpoint: endpoint.clone(),
            },
            None => s3::Region::Custom {
                region: self.region.clone(),
                endpoint: format!("https://s3.{}.amazonaws.com", self.region),
            },
        };

        let credentials = s3::creds::Credentials::new(
            Some(&self.access_key_id),
            Some(&self.secret_access_key),
            self.session_token.as_deref(),
            None,
            None,
        )
        .map_err(|e| {
            HostError::new(
                "ERR_S3_MISSING_CREDENTIALS",
                format!("Failed to create S3 credentials: {}", e),
            )
        })?;

        let bucket = s3::Bucket::new(&self.bucket, region, credentials)
            .map_err(|e| HostError::new("ERR_S3", format!("Failed to create S3 bucket: {}", e)))?;

        let bucket = if self.virtual_hosted_style {
            bucket
        } else {
            bucket.with_path_style()
        };

        Ok(*bucket)
    }

    pub fn into_rc(self) -> Rc<S3Config> {
        Rc::new(self)
    }
}