apple 0.2.0

A Rust library for Apple Sign-In authentication, CloudKit Web Services, and App Store Server API
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

use crate::cloudkit::client::CloudKitClient;
use crate::error::AppleError;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize)]
pub struct CloudKitUser {
    #[serde(rename = "userRecordName")]
    pub user_record_name: Option<String>,
    #[serde(rename = "firstName")]
    pub first_name: Option<String>,
    #[serde(rename = "lastName")]
    pub last_name: Option<String>,
    #[serde(rename = "emailAddress")]
    pub email_address: Option<String>,
    #[serde(rename = "isDiscoverable")]
    pub is_discoverable: Option<bool>,
}

#[derive(Debug, Deserialize)]
struct CurrentUserResponse {
    #[serde(rename = "userRecordName")]
    user_record_name: Option<String>,
    #[serde(rename = "firstName")]
    first_name: Option<String>,
    #[serde(rename = "lastName")]
    last_name: Option<String>,
    #[serde(rename = "emailAddress")]
    email_address: Option<String>,
    #[serde(rename = "isDiscoverable")]
    is_discoverable: Option<bool>,
}

#[derive(Debug, Deserialize)]
struct DiscoverUsersResponse {
    users: Vec<CloudKitUser>,
}

#[derive(Debug, Serialize)]
struct LookupUsersRequest {
    #[serde(rename = "emailAddresses")]
    email_addresses: Vec<String>,
}

#[derive(Debug, Deserialize)]
struct LookupUsersResponse {
    users: Vec<CloudKitUser>,
}

impl CloudKitClient {
    pub async fn get_current_user(&self) -> Result<CloudKitUser, AppleError> {
        let url = self.build_base_url("users/caller");

        #[derive(Serialize)]
        struct EmptyBody {}

        let response: CurrentUserResponse = self.signed_post(&url, &EmptyBody {}).await?;

        Ok(CloudKitUser {
            user_record_name: response.user_record_name,
            first_name: response.first_name,
            last_name: response.last_name,
            email_address: response.email_address,
            is_discoverable: response.is_discoverable,
        })
    }

    pub async fn discover_users(&self) -> Result<Vec<CloudKitUser>, AppleError> {
        let url = self.build_base_url("users/discover");

        #[derive(Serialize)]
        struct EmptyBody {}

        let response: DiscoverUsersResponse = self.signed_post(&url, &EmptyBody {}).await?;
        Ok(response.users)
    }

    pub async fn lookup_users_by_email(
        &self,
        email_addresses: &[&str],
    ) -> Result<Vec<CloudKitUser>, AppleError> {
        let url = self.build_base_url("users/lookup/email");
        let request = LookupUsersRequest {
            email_addresses: email_addresses.iter().map(|s| s.to_string()).collect(),
        };

        let response: LookupUsersResponse = self.signed_post(&url, &request).await?;
        Ok(response.users)
    }
}