Genarrative/server-rs/crates/spacetime-client/src/external_api_key.rs

use super::*;

impl SpacetimeClient {
    pub async fn create_external_api_key(
        &self,
        input: ExternalApiKeyCreateRecordInput,
    ) -> Result<ExternalApiKeyRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "create_external_api_key_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .create_external_api_key_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_external_api_key_single_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn list_external_api_keys(
        &self,
        owner_user_id: String,
    ) -> Result<Vec<ExternalApiKeyRecord>, SpacetimeClientError> {
        let procedure_input = ExternalApiKeyListInput { owner_user_id };

        self.call_after_connect(
            "list_external_api_keys_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .list_external_api_keys_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_external_api_key_list_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn revoke_external_api_key(
        &self,
        input: ExternalApiKeyRevokeRecordInput,
    ) -> Result<ExternalApiKeyRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "revoke_external_api_key_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .revoke_external_api_key_and_return_then(procedure_input, move |_, result| {
                        let mapped = result
                            .map_err(SpacetimeClientError::from_sdk_error)
                            .and_then(map_external_api_key_single_procedure_result);
                        send_once(&sender, mapped);
                    });
            },
        )
        .await
    }

    pub async fn authenticate_external_api_key(
        &self,
        input: ExternalApiKeyAuthenticateRecordInput,
    ) -> Result<ExternalApiKeyRecord, SpacetimeClientError> {
        let procedure_input = input.into();

        self.call_after_connect(
            "authenticate_external_api_key_and_return",
            move |connection, sender| {
                connection
                    .procedures()
                    .authenticate_external_api_key_and_return_then(
                        procedure_input,
                        move |_, result| {
                            let mapped = result
                                .map_err(SpacetimeClientError::from_sdk_error)
                                .and_then(map_external_api_key_single_procedure_result);
                            send_once(&sender, mapped);
                        },
                    );
            },
        )
        .await
    }
}