syncweb-core 0.1.1-alpha.7

delay-tolerant web surfing
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

//! Shared folder-sharing helper.
//!
//! The CLI embedded path, the daemon IPC share handler, and `create` all build
//! a folder ticket, optionally pin the folder's blobs, optionally persist the
//! share record, and emit a `syncweb://folder/...` URL. This helper unifies that
//! flow so the call sites share one implementation.

use iroh_docs::{DocTicket, NamespaceId};

use crate::error::Result;

use super::SyncwebFolder;

/// Options controlling how a folder is shared.
#[derive(Clone, Copy, Debug, Default)]
#[non_exhaustive]
pub struct ShareOptions {
    /// Grant write access on the ticket (default: read-only).
    pub writable: bool,
    /// Pin the folder's blobs so shared content is retained.
    pub pin: bool,
    /// Persist the share record so it can be listed and unshared later.
    pub persist: bool,
}

impl ShareOptions {
    #[must_use]
    pub const fn new(writable: bool) -> Self {
        Self {
            writable,
            pin: false,
            persist: false,
        }
    }

    #[must_use]
    pub const fn with_pin(mut self, pin: bool) -> Self {
        self.pin = pin;
        self
    }

    #[must_use]
    pub const fn with_persist(mut self, persist: bool) -> Self {
        self.persist = persist;
        self
    }
}

/// The outcome of sharing a folder.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct ShareResult {
    pub namespace: NamespaceId,
    pub writable: bool,
    pub ticket: DocTicket,
    pub url: String,
    pub pinned: usize,
}

impl ShareResult {
    #[must_use]
    pub const fn access(&self) -> &'static str {
        if self.writable { "write" } else { "read" }
    }
}

/// Build a folder share ticket, optionally pinning and persisting it.
///
/// `persist` is invoked with the namespace, access label, and ticket when
/// `options.persist` is set, letting the caller record the share in its own
/// database without coupling this helper to a specific store.
///
/// # Errors
///
/// Returns an error if pinning or ticket creation fails, or the persist
/// callback fails.
pub async fn share_folder<F>(folder: &SyncwebFolder, options: ShareOptions, persist: F) -> Result<ShareResult>
where
    F: FnOnce(NamespaceId, &str, &DocTicket) -> Result<()>,
{
    let pinned = if options.pin {
        folder.pin_all_content().await?
    } else {
        0
    };
    let ticket = folder.ticket(options.writable).await?;
    let result = ShareResult {
        namespace: folder.namespace_id(),
        writable: options.writable,
        ticket,
        url: String::new(),
        pinned,
    };
    if options.persist {
        persist(result.namespace, result.access(), &result.ticket)?;
    }
    let url = crate::uri::folder_url(result.namespace, &result.ticket);
    Ok(ShareResult { url, ..result })
}