1use coven_format::codes::{InviteAdmits, InviteCode, PairingCode, RestoreCode};
4use coven_foundation::id_source::{MemberId, StoreId};
5use coven_storage::{
6 CloudProvider, InviteStorage, OAuthAccess, RestoreStorage, SharedWith, StorageConfig,
7};
8
9#[derive(Clone, Copy, Debug, PartialEq, Eq)]
11pub enum CodeKind {
12 Restore,
15 Invite,
18 Pairing,
21}
22
23#[derive(Clone, Debug, PartialEq, Eq)]
25pub enum CodeInfo {
26 Restore(CodeMetadata),
28 Invite(InviteInfo),
31 Pairing(PairingInfo),
33}
34
35impl CodeInfo {
36 pub fn metadata(&self) -> &CodeMetadata {
38 match self {
39 Self::Restore(metadata)
40 | Self::Invite(InviteInfo { metadata, .. })
41 | Self::Pairing(PairingInfo { metadata, .. }) => metadata,
42 }
43 }
44}
45
46#[derive(Clone, Debug, PartialEq, Eq)]
48pub struct PairingInfo {
49 pub metadata: CodeMetadata,
51 pub expires_at: std::time::SystemTime,
54}
55
56#[derive(Clone, Debug, PartialEq, Eq)]
59pub struct InviteInfo {
60 pub metadata: CodeMetadata,
62 pub store_name: String,
64 pub inviter: String,
68 pub admits: InviteAdmits,
71 pub expires_at: std::time::SystemTime,
74 pub shared_with: Option<coven_storage::SharedWith>,
79}
80
81#[derive(Clone, Debug, PartialEq, Eq)]
83pub struct CodeMetadata {
84 pub store_id: StoreId,
86 pub member: MemberId,
89 pub cloud_provider: CloudProvider,
91 pub location: StorageConfig,
93 pub oauth_access: Option<OAuthAccess>,
95 pub carries_s3_key: bool,
99}
100
101#[derive(Clone, Debug, thiserror::Error)]
103pub enum CodeError {
104 #[error("invalid restore, invite or pairing code")]
106 Invalid,
107 #[error("expected {expected:?} code, received {actual:?}")]
109 WrongKind {
110 expected: CodeKind,
112 actual: CodeKind,
114 },
115 #[error("code is for store {actual}, not {expected}")]
119 WrongStore {
120 expected: StoreId,
122 actual: StoreId,
124 },
125 #[error("invite admits {expected:?}, but the join is for {actual:?}")]
128 WrongJoiner {
129 expected: InviteAdmits,
131 actual: InviteAdmits,
133 },
134}
135
136impl CodeError {
137 pub fn require_store(expected: StoreId, actual: StoreId) -> Result<(), Self> {
139 if actual == expected {
140 Ok(())
141 } else {
142 Err(Self::WrongStore { expected, actual })
143 }
144 }
145}
146
147pub fn decode_code_info(code: &str) -> Result<CodeInfo, CodeError> {
149 let (code, location, carries_s3_key, shared_with) = decode(code)?;
150 let metadata = |store_id, member| CodeMetadata {
151 store_id,
152 member,
153 cloud_provider: location.provider(),
154 oauth_access: location.oauth_access(),
155 location,
156 carries_s3_key,
157 };
158 Ok(match code {
159 DecodedCode::Restore(code) => CodeInfo::Restore(metadata(code.store, code.member)),
160 DecodedCode::Invite(code) => CodeInfo::Invite(InviteInfo {
161 metadata: metadata(code.store, code.member),
162 store_name: code.name,
163 inviter: code.inviter,
164 admits: code.admits,
165 expires_at: std::time::UNIX_EPOCH + std::time::Duration::from_secs(code.expires_at),
166 shared_with,
167 }),
168 DecodedCode::Pairing(code) => CodeInfo::Pairing(PairingInfo {
169 metadata: metadata(code.store, code.member),
170 expires_at: std::time::UNIX_EPOCH + std::time::Duration::from_secs(code.expires_at),
171 }),
172 })
173}
174
175pub fn decode_restore_info(code: &str) -> Result<CodeMetadata, CodeError> {
178 match decode_code_info(code)? {
179 CodeInfo::Restore(metadata) => Ok(metadata),
180 CodeInfo::Invite(_) => wrong_kind(CodeKind::Restore, CodeKind::Invite),
181 CodeInfo::Pairing(_) => wrong_kind(CodeKind::Restore, CodeKind::Pairing),
182 }
183}
184
185pub fn decode_invite_info(code: &str) -> Result<InviteInfo, CodeError> {
190 match decode_code_info(code)? {
191 CodeInfo::Invite(info) => Ok(info),
192 CodeInfo::Restore(_) => wrong_kind(CodeKind::Invite, CodeKind::Restore),
193 CodeInfo::Pairing(_) => wrong_kind(CodeKind::Invite, CodeKind::Pairing),
194 }
195}
196
197pub fn decode_pairing_info(code: &str) -> Result<PairingInfo, CodeError> {
202 match decode_code_info(code)? {
203 CodeInfo::Pairing(info) => Ok(info),
204 CodeInfo::Restore(_) => wrong_kind(CodeKind::Pairing, CodeKind::Restore),
205 CodeInfo::Invite(_) => wrong_kind(CodeKind::Pairing, CodeKind::Invite),
206 }
207}
208
209pub fn read_restore_code(code: &str) -> Result<RestoreCode, CodeError> {
212 decode_restore(code).map(|(code, _)| code)
213}
214
215pub fn restore_sign_in(store: StoreId, code: &str) -> Result<Option<OAuthAccess>, CodeError> {
221 let (code, location) = decode_restore(code)?;
222 CodeError::require_store(store, code.store)?;
223 Ok(location.oauth_access())
224}
225
226fn decode_restore(code: &str) -> Result<(RestoreCode, StorageConfig), CodeError> {
229 match decode(code)? {
230 (DecodedCode::Restore(code), location, ..) => Ok((code, location)),
231 (DecodedCode::Invite(_), ..) => wrong_kind(CodeKind::Restore, CodeKind::Invite),
232 (DecodedCode::Pairing(_), ..) => wrong_kind(CodeKind::Restore, CodeKind::Pairing),
233 }
234}
235
236pub fn read_invite_code(code: &str) -> Result<InviteCode, CodeError> {
238 match decode(code)?.0 {
239 DecodedCode::Invite(code) => Ok(code),
240 DecodedCode::Restore(_) => wrong_kind(CodeKind::Invite, CodeKind::Restore),
241 DecodedCode::Pairing(_) => wrong_kind(CodeKind::Invite, CodeKind::Pairing),
242 }
243}
244
245pub fn read_pairing_code(code: &str) -> Result<PairingCode, CodeError> {
247 match decode(code)?.0 {
248 DecodedCode::Pairing(code) => Ok(code),
249 DecodedCode::Restore(_) => wrong_kind(CodeKind::Pairing, CodeKind::Restore),
250 DecodedCode::Invite(_) => wrong_kind(CodeKind::Pairing, CodeKind::Invite),
251 }
252}
253
254fn wrong_kind<T>(expected: CodeKind, actual: CodeKind) -> Result<T, CodeError> {
255 Err(CodeError::WrongKind { expected, actual })
256}
257
258enum DecodedCode {
259 Restore(RestoreCode),
260 Invite(InviteCode),
261 Pairing(PairingCode),
262}
263
264#[expect(
265 clippy::map_err_ignore,
266 reason = "a code that does not decode is Invalid, whichever field failed"
267)]
268fn decode(text: &str) -> Result<(DecodedCode, StorageConfig, bool, Option<SharedWith>), CodeError> {
269 if text.starts_with(RestoreCode::TEXT_PREFIX) {
270 let code = RestoreCode::from_text(text).map_err(|_| CodeError::Invalid)?;
271 let storage =
272 RestoreStorage::decode(code.storage.as_bytes()).map_err(|_| CodeError::Invalid)?;
273 let carries_s3_key = storage.s3_key.is_some();
274 Ok((DecodedCode::Restore(code), storage.location, carries_s3_key, None))
275 } else if text.starts_with(InviteCode::TEXT_PREFIX) {
276 let code = InviteCode::from_text(text).map_err(|_| CodeError::Invalid)?;
277 let (invitation, carries_s3_key) =
279 match InviteStorage::decode(code.storage.as_bytes()).map_err(|_| CodeError::Invalid)? {
280 InviteStorage::Account(invitation) => (invitation, false),
281 InviteStorage::S3 { invitation, .. } => (invitation, true),
282 };
283 Ok((
284 DecodedCode::Invite(code),
285 invitation.location().clone(),
286 carries_s3_key,
287 invitation.account().cloned(),
288 ))
289 } else if text.starts_with(PairingCode::TEXT_PREFIX) {
290 let code = PairingCode::from_text(text).map_err(|_| CodeError::Invalid)?;
291 let storage =
292 RestoreStorage::decode(code.storage.as_bytes()).map_err(|_| CodeError::Invalid)?;
293 let carries_s3_key = storage.s3_key.is_some();
294 Ok((DecodedCode::Pairing(code), storage.location, carries_s3_key, None))
295 } else {
296 Err(CodeError::Invalid)
297 }
298}
299
300#[cfg(test)]
301#[path = "codes_tests.rs"]
302mod tests;