appwrite 0.3.0

Appwrite SDK for Rust
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
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

//! Service modules for Appwrite SDK

pub mod account;
pub use account::Account;
pub mod activities;
pub use activities::Activities;
pub mod avatars;
pub use avatars::Avatars;
pub mod backups;
pub use backups::Backups;
pub mod databases;
pub use databases::Databases;
pub mod functions;
pub use functions::Functions;
pub mod graphql;
pub use graphql::Graphql;
pub mod health;
pub use health::Health;
pub mod locale;
pub use locale::Locale;
pub mod messaging;
pub use messaging::Messaging;
pub mod project;
pub use project::Project;
pub mod sites;
pub use sites::Sites;
pub mod storage;
pub use storage::Storage;
pub mod tables_db;
pub use tables_db::TablesDB;
pub mod teams;
pub use teams::Teams;
pub mod tokens;
pub use tokens::Tokens;
pub mod users;
pub use users::Users;
pub mod webhooks;
pub use webhooks::Webhooks;

use crate::client::Client;

/// Base trait for all Appwrite services
pub trait Service {
    /// Get a reference to the client
    fn client(&self) -> &Client;
}

// Re-export all services for convenience
pub struct Services {
    client: Client,
    account: Account,
    activities: Activities,
    avatars: Avatars,
    backups: Backups,
    databases: Databases,
    functions: Functions,
    graphql: Graphql,
    health: Health,
    locale: Locale,
    messaging: Messaging,
    project: Project,
    sites: Sites,
    storage: Storage,
    tables_db: TablesDB,
    teams: Teams,
    tokens: Tokens,
    users: Users,
    webhooks: Webhooks,
}

impl Services {
    /// Create new services instance
    pub fn new(client: Client) -> Self {
        Self {
            account: Account::new(&client),
            activities: Activities::new(&client),
            avatars: Avatars::new(&client),
            backups: Backups::new(&client),
            databases: Databases::new(&client),
            functions: Functions::new(&client),
            graphql: Graphql::new(&client),
            health: Health::new(&client),
            locale: Locale::new(&client),
            messaging: Messaging::new(&client),
            project: Project::new(&client),
            sites: Sites::new(&client),
            storage: Storage::new(&client),
            tables_db: TablesDB::new(&client),
            teams: Teams::new(&client),
            tokens: Tokens::new(&client),
            users: Users::new(&client),
            webhooks: Webhooks::new(&client),
            client,
        }
    }

    /// Get client reference
    pub fn client(&self) -> &Client {
        &self.client
    }

    /// Get Account service
    pub fn account(&self) -> &Account {
        &self.account
    }
    /// Get Activities service
    pub fn activities(&self) -> &Activities {
        &self.activities
    }
    /// Get Avatars service
    pub fn avatars(&self) -> &Avatars {
        &self.avatars
    }
    /// Get Backups service
    pub fn backups(&self) -> &Backups {
        &self.backups
    }
    /// Get Databases service
    pub fn databases(&self) -> &Databases {
        &self.databases
    }
    /// Get Functions service
    pub fn functions(&self) -> &Functions {
        &self.functions
    }
    /// Get Graphql service
    pub fn graphql(&self) -> &Graphql {
        &self.graphql
    }
    /// Get Health service
    pub fn health(&self) -> &Health {
        &self.health
    }
    /// Get Locale service
    pub fn locale(&self) -> &Locale {
        &self.locale
    }
    /// Get Messaging service
    pub fn messaging(&self) -> &Messaging {
        &self.messaging
    }
    /// Get Project service
    pub fn project(&self) -> &Project {
        &self.project
    }
    /// Get Sites service
    pub fn sites(&self) -> &Sites {
        &self.sites
    }
    /// Get Storage service
    pub fn storage(&self) -> &Storage {
        &self.storage
    }
    /// Get TablesDB service
    pub fn tables_db(&self) -> &TablesDB {
        &self.tables_db
    }
    /// Get Teams service
    pub fn teams(&self) -> &Teams {
        &self.teams
    }
    /// Get Tokens service
    pub fn tokens(&self) -> &Tokens {
        &self.tokens
    }
    /// Get Users service
    pub fn users(&self) -> &Users {
        &self.users
    }
    /// Get Webhooks service
    pub fn webhooks(&self) -> &Webhooks {
        &self.webhooks
    }
}