use std::sync::Arc;
use serde::Serialize;
use serde_json::Value;
use crate::core::encoding::{encode_segment, to_json_vec};
use crate::core::error::{DelopayError, Result};
use crate::core::models::user::{
AuthResponse, ChangeMemberScopeResponse, CreateInvitationLinkResponse,
DashboardOAuthProvidersResponse, DashboardOAuthStartResponse, DashboardTourResponse,
GetUserRoleDetailsResponse, InvitationLinkPreviewResponse, InvitationLinkResponse,
InvitationLinkRestrictions, InviteLinkResponse, InviteUsersResponse,
JoinInvitationLinkPreAuthResponse, JoinInvitationLinkResponse, ListInvitationLinksResponse,
LoginHistoryResponse, MemberMethodAccessResponse, MemberPermissionOverridesResponse,
ParentGroupInfo, PermissionOverride, PhoneOtpResponse, PhoneOtpVerifyResponse,
ReInviteUserResponse, RecoveryCodesResponse, RegisterThroughInvitationLinkResponse,
ResetTeamMemberPasswordResponse, RoleConnectorGrantResponse, RolePaymentVisibilityPolicy,
TeamMemberContactProfileResponse, TeamMemberContacts, TeamMemberDetailsResponse, TokenResponse,
TotpResponse, TourProgress, UpdateMemberExpiryResponse, UserInLineage, UserPreferenceResponse,
UserResponse, UserSessionListResponse, UserSessionRevokeResponse,
};
use crate::http::client::Inner;
use crate::http::transport::HttpMethod;
use crate::resources::ValidateRequest;
#[derive(Debug, Clone)]
pub struct Users {
inner: Arc<Inner>,
}
impl Users {
pub(crate) fn new(inner: Arc<Inner>) -> Self {
Self { inner }
}
pub async fn sign_up(&self, params: &SignUpRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/signup", Some(&body), &[], None)
.await
}
pub async fn sign_up_with_merchant(
&self,
params: &SignUpWithMerchantRequest,
) -> Result<AuthResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/signup", Some(&body), &[], None)
.await
}
pub async fn sign_in(&self, params: &SignInRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/signin", Some(&body), &[], None)
.await
}
pub async fn sign_out(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Post, "/user/signout", None, &[], None)
.await
}
pub async fn sign_in_oidc(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/oidc", Some(&body), &[], None)
.await
}
pub async fn list_login_activity(
&self,
params: Option<&LoginHistoryParams>,
) -> Result<LoginHistoryResponse> {
let query = params.map(LoginHistoryParams::to_query).unwrap_or_default();
self.inner
.request(
HttpMethod::Get,
"/user/me/login-activity",
None,
&query,
None,
)
.await
}
pub async fn list_active_sessions(&self) -> Result<UserSessionListResponse> {
self.inner
.request(HttpMethod::Get, "/user/me/sessions", None, &[], None)
.await
}
pub async fn revoke_session(&self, session_id: &str) -> Result<UserSessionRevokeResponse> {
let path = format!("/user/me/sessions/{}/revoke", encode_segment(session_id));
self.inner
.request(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn details(&self) -> Result<UserResponse> {
self.inner
.request(HttpMethod::Get, "/user", None, &[], None)
.await
}
pub async fn update(&self, params: &UpdateUserDetailsRequest) -> Result<UserResponse> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, "/user/update", Some(&body), &[], None)
.await
}
pub async fn change_password(&self, params: &ChangePasswordRequest) -> Result<UserResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/change-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn rotate_password(&self, params: &ResetPasswordRequest) -> Result<UserResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/rotate-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn forgot_password(&self, params: &ForgotPasswordRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/forgot-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn reset_password(&self, params: &ResetPasswordRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/reset-password",
Some(&body),
&[],
None,
)
.await
}
pub async fn verify_email(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/verify-email",
Some(&body),
&[],
None,
)
.await
}
pub async fn send_verification_email(&self, params: &ForgotPasswordRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/verify-email-request",
Some(&body),
&[],
None,
)
.await
}
pub async fn create_merchant(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/create-merchant",
Some(&body),
&[],
None,
)
.await
}
pub async fn switch_merchant(&self, params: &SwitchMerchantRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/switch/merchant",
Some(&body),
&[],
None,
)
.await
}
pub async fn switch_profile(&self, params: &SwitchProfileRequest) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/switch/profile",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_merchants(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/list/merchant", None, &[], None)
.await
}
pub async fn list_profiles(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/list/profile", None, &[], None)
.await
}
pub async fn invite_users(
&self,
params: &[InviteUsersRequest],
) -> Result<Vec<InviteUsersResponse>> {
for p in params {
p.validate()?;
}
let body = to_json_vec(¶ms)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/invite",
Some(&body),
&[],
None,
)
.await
}
pub async fn accept_invitation(&self, params: &Value) -> Result<AuthResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/invite/accept",
Some(&body),
&[],
None,
)
.await
}
pub async fn resend_invite(
&self,
params: &ReInviteUserRequest,
) -> Result<ReInviteUserResponse> {
params.validate()?;
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/resend-invite",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_user_roles(
&self,
params: Option<&Value>,
) -> Result<Vec<GetUserRoleDetailsResponse>> {
let body = match params {
Some(p) => Some(to_json_vec(p)?),
None => None,
};
self.inner
.request(
HttpMethod::Post,
"/user/employees",
body.as_deref(),
&[],
None,
)
.await
}
pub async fn update_user_role(&self, params: &UpdateUserRoleRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/employees/update-role",
Some(&body),
&[],
None,
)
.await
}
pub async fn delete_user_role(&self, params: &DeleteUserRoleRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Delete,
"/user/employees/delete",
Some(&body),
&[],
None,
)
.await
}
pub async fn list_users_in_lineage(
&self,
params: Option<&ListUsersInLineageParams>,
) -> Result<Vec<UserInLineage>> {
let query = params
.map(ListUsersInLineageParams::to_query)
.unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/user/employees/list", None, &query, None)
.await
}
pub async fn check_2fa_status(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/user/2fa", None, &[], None)
.await
}
pub async fn begin_totp(&self) -> Result<TotpResponse> {
self.inner
.request(HttpMethod::Get, "/user/2fa/totp/begin", None, &[], None)
.await
}
pub async fn verify_totp(&self, params: &VerifyTotpRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/2fa/totp/verify",
Some(&body),
&[],
None,
)
.await
}
pub async fn update_totp(&self, params: &VerifyTotpRequest) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Put,
"/user/2fa/totp/verify",
Some(&body),
&[],
None,
)
.await
}
pub async fn reset_totp(&self) -> Result<Value> {
self.inner
.request(HttpMethod::Get, "/user/2fa/totp/reset", None, &[], None)
.await
}
pub async fn generate_recovery_codes(&self) -> Result<RecoveryCodesResponse> {
self.inner
.request(
HttpMethod::Get,
"/user/2fa/recovery-code/generate",
None,
&[],
None,
)
.await
}
pub async fn verify_recovery_code(&self, params: &Value) -> Result<AuthResponse> {
self.post_open("/user/2fa/recovery-code/verify", params)
.await
}
pub async fn send_phone_otp(&self, params: &PhoneOtpRequest) -> Result<PhoneOtpResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/phone/send-otp",
Some(&body),
&[],
None,
)
.await
}
pub async fn verify_phone_otp(
&self,
params: &PhoneOtpVerifyRequest,
) -> Result<PhoneOtpVerifyResponse> {
let body = to_json_vec(params)?;
self.inner
.request(
HttpMethod::Post,
"/user/phone/verify-otp",
Some(&body),
&[],
None,
)
.await
}
pub async fn create_auth_method(&self, params: &Value) -> Result<Value> {
self.post_open("/user/auth", params).await
}
pub async fn list_auth_methods(&self) -> Result<Vec<Value>> {
self.inner
.request(HttpMethod::Get, "/user/auth/list", None, &[], None)
.await
}
pub async fn list_roles(&self, params: Option<&ListRolesParams>) -> Result<Vec<Value>> {
let query = params.map(ListRolesParams::to_query).unwrap_or_default();
self.inner
.request(HttpMethod::Get, "/user/role/list", None, &query, None)
.await
}
pub async fn role_permissions(&self) -> Result<Vec<ParentGroupInfo>> {
self.inner
.request(HttpMethod::Get, "/user/role", None, &[], None)
.await
}
pub async fn create_role(&self, params: &Value) -> Result<Value> {
self.post_open("/user/role", params).await
}
pub async fn list_oauth_providers(&self) -> Result<DashboardOAuthProvidersResponse> {
self.inner
.request(HttpMethod::Get, "/user/oauth/providers", None, &[], None)
.await
}
pub async fn list_linked_oauth_providers(&self) -> Result<DashboardOAuthProvidersResponse> {
self.inner
.request(HttpMethod::Get, "/user/oauth/linked", None, &[], None)
.await
}
pub async fn start_oauth_sign_in(
&self,
params: &DashboardOAuthStartRequest,
) -> Result<DashboardOAuthStartResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/oauth/start",
Some(&body),
&[],
None,
)
.await
}
pub async fn start_oauth_link(
&self,
params: &DashboardOAuthLinkStartRequest,
) -> Result<DashboardOAuthStartResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/oauth/link/start",
Some(&body),
&[],
None,
)
.await
}
pub async fn complete_oauth_sign_in(
&self,
params: &DashboardOAuthCompleteRequest,
) -> Result<TokenResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/oauth/complete",
Some(&body),
&[],
None,
)
.await
}
pub async fn complete_oauth_link(
&self,
params: &DashboardOAuthCompleteRequest,
) -> Result<Value> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/oauth/link/complete",
Some(&body),
&[],
None,
)
.await
}
pub async fn disconnect_oauth_provider(
&self,
provider: &str,
params: &DashboardOAuthDisconnectRequest,
) -> Result<Value> {
let path = format!("/user/oauth/linked/{}", encode_segment(provider));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Delete, &path, Some(&body), &[], None)
.await
}
pub async fn refresh_token(&self) -> Result<TokenResponse> {
self.inner
.request_body_keyed_with_query(HttpMethod::Post, "/user/token/refresh", None, &[], None)
.await
}
pub async fn retrieve_preference(&self, key: &str) -> Result<UserPreferenceResponse> {
self.inner
.request(HttpMethod::Get, &preference_path(key), None, &[], None)
.await
}
pub async fn set_preference(
&self,
key: &str,
params: &SetUserPreferenceRequest,
) -> Result<UserPreferenceResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
&preference_path(key),
Some(&body),
&[],
None,
)
.await
}
pub async fn initialize_preference(
&self,
key: &str,
value: serde_json::Map<String, Value>,
) -> Result<UserPreferenceResponse> {
self.set_preference(key, &SetUserPreferenceRequest::new(value).if_absent(true))
.await
}
pub async fn delete_preference(&self, key: &str) -> Result<UserPreferenceResponse> {
self.inner
.request_body_keyed_with_query(
HttpMethod::Delete,
&preference_path(key),
None,
&[],
None,
)
.await
}
pub async fn retrieve_dashboard_tour(&self) -> Result<DashboardTourResponse> {
self.inner
.request(HttpMethod::Get, "/user/dashboard-tour", None, &[], None)
.await
}
pub async fn update_dashboard_tour(
&self,
params: &UpdateDashboardTourRequest,
) -> Result<DashboardTourResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Put,
"/user/dashboard-tour",
Some(&body),
&[],
None,
)
.await
}
pub async fn retrieve_role_payment_visibility(
&self,
) -> Result<Option<RolePaymentVisibilityPolicy>> {
self.inner
.request(
HttpMethod::Get,
"/user/role/payment-visibility",
None,
&[],
None,
)
.await
}
pub async fn retrieve_own_permission_overrides(&self) -> Result<Vec<PermissionOverride>> {
self.inner
.request(
HttpMethod::Get,
"/user/role/permission-overrides",
None,
&[],
None,
)
.await
}
pub async fn retrieve_role_connectors(
&self,
role_id: &str,
) -> Result<RoleConnectorGrantResponse> {
let path = format!("/user/role/{}/connectors", encode_segment(role_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update_role_connectors(
&self,
role_id: &str,
params: &UpdateRoleConnectorGrantRequest,
) -> Result<RoleConnectorGrantResponse> {
params.validate()?;
let path = format!("/user/role/{}/connectors", encode_segment(role_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn change_member_scope(
&self,
params: &ChangeMemberScopeRequest,
) -> Result<ChangeMemberScopeResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/employees/change-scope",
Some(&body),
&[],
None,
)
.await
}
pub async fn update_member_expiry(
&self,
params: &UpdateMemberExpiryRequest,
) -> Result<UpdateMemberExpiryResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/employees/update-expiry",
Some(&body),
&[],
None,
)
.await
}
pub async fn retrieve_team_member_details(
&self,
user_id: &str,
) -> Result<TeamMemberDetailsResponse> {
let path = format!("{}/details", employee_path(user_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn retrieve_invite_link(&self, user_id: &str) -> Result<InviteLinkResponse> {
let path = format!("{}/invite-link", employee_path(user_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn retrieve_team_member_contact_profile(
&self,
user_id: &str,
) -> Result<TeamMemberContactProfileResponse> {
let path = format!("{}/contact-profile", employee_path(user_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update_team_member_contacts(
&self,
user_id: &str,
params: &UpdateTeamMemberContactsRequest,
) -> Result<TeamMemberContactProfileResponse> {
let path = format!("{}/contact-profile", employee_path(user_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn create_team_member_note(
&self,
user_id: &str,
params: &WriteTeamMemberNoteRequest,
) -> Result<TeamMemberContactProfileResponse> {
let path = format!("{}/notes", employee_path(user_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn update_team_member_note(
&self,
user_id: &str,
note_id: &str,
params: &WriteTeamMemberNoteRequest,
) -> Result<TeamMemberContactProfileResponse> {
let path = note_path(user_id, note_id);
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn delete_team_member_note(
&self,
user_id: &str,
note_id: &str,
expected_revision: &str,
) -> Result<TeamMemberContactProfileResponse> {
let path = note_path(user_id, note_id);
let query = [("expected_revision", expected_revision.to_string())];
self.inner
.request_body_keyed_with_query(HttpMethod::Delete, &path, None, &query, None)
.await
}
pub async fn reset_team_member_password(
&self,
user_id: &str,
params: &ResetTeamMemberPasswordRequest,
) -> Result<ResetTeamMemberPasswordResponse> {
let path = format!("{}/reset-password", employee_path(user_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, Some(&body), &[], None)
.await
}
pub async fn retrieve_member_method_access(
&self,
user_id: &str,
) -> Result<MemberMethodAccessResponse> {
let path = format!("{}/method-access", employee_path(user_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update_member_method_access(
&self,
user_id: &str,
params: &UpdateMemberMethodAccessRequest,
) -> Result<MemberMethodAccessResponse> {
let path = format!("{}/method-access", employee_path(user_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn retrieve_member_permission_overrides(
&self,
user_id: &str,
) -> Result<MemberPermissionOverridesResponse> {
let path = format!("{}/permission-overrides", employee_path(user_id));
self.inner
.request(HttpMethod::Get, &path, None, &[], None)
.await
}
pub async fn update_member_permission_overrides(
&self,
user_id: &str,
params: &UpdateMemberPermissionOverridesRequest,
) -> Result<MemberPermissionOverridesResponse> {
let path = format!("{}/permission-overrides", employee_path(user_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn create_invitation_link(
&self,
params: &CreateInvitationLinkRequest,
) -> Result<CreateInvitationLinkResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
INVITATION_LINKS_PATH,
Some(&body),
&[],
None,
)
.await
}
pub async fn list_invitation_links(&self) -> Result<ListInvitationLinksResponse> {
self.inner
.request(HttpMethod::Get, INVITATION_LINKS_PATH, None, &[], None)
.await
}
pub async fn update_invitation_link(
&self,
link_id: &str,
params: &UpdateInvitationLinkRequest,
) -> Result<InvitationLinkResponse> {
let path = format!("{INVITATION_LINKS_PATH}/{}", encode_segment(link_id));
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(HttpMethod::Put, &path, Some(&body), &[], None)
.await
}
pub async fn revoke_invitation_link(&self, link_id: &str) -> Result<InvitationLinkResponse> {
let path = format!("{INVITATION_LINKS_PATH}/{}/revoke", encode_segment(link_id));
self.inner
.request_body_keyed_with_query(HttpMethod::Post, &path, None, &[], None)
.await
}
pub async fn preview_invitation_link(
&self,
token: &str,
) -> Result<InvitationLinkPreviewResponse> {
self.post_link_token("/user/invitation-link/preview", token)
.await
}
pub async fn join_invitation_link(&self, token: &str) -> Result<JoinInvitationLinkResponse> {
self.post_link_token("/user/invitation-link/join", token)
.await
}
pub async fn join_invitation_link_pre_auth(
&self,
token: &str,
) -> Result<JoinInvitationLinkPreAuthResponse> {
self.post_link_token("/user/invitation-link/join/pre-auth", token)
.await
}
pub async fn register_through_invitation_link(
&self,
params: &RegisterThroughInvitationLinkRequest,
) -> Result<RegisterThroughInvitationLinkResponse> {
let body = to_json_vec(params)?;
self.inner
.request_body_keyed_with_query(
HttpMethod::Post,
"/user/invitation-link/register",
Some(&body),
&[],
None,
)
.await
}
async fn post_link_token<T: serde::de::DeserializeOwned>(
&self,
path: &str,
token: &str,
) -> Result<T> {
let body = to_json_vec(&InvitationLinkTokenBody { token })?;
self.inner
.request_body_keyed_with_query(HttpMethod::Post, path, Some(&body), &[], None)
.await
}
async fn post_open<T: serde::de::DeserializeOwned>(
&self,
path: &str,
params: &Value,
) -> Result<T> {
let body = to_json_vec(params)?;
self.inner
.request(HttpMethod::Post, path, Some(&body), &[], None)
.await
}
}
#[derive(Clone, Default, Serialize)]
pub struct SignUpRequest {
pub email: String,
pub password: String,
}
impl std::fmt::Debug for SignUpRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SignUpRequest")
.field("email", &self.email)
.field("password", &"[redacted]")
.finish()
}
}
impl SignUpRequest {
pub fn new(email: impl Into<String>, password: impl Into<String>) -> Self {
Self {
email: email.into(),
password: password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct SignUpWithMerchantRequest {
pub name: String,
pub email: String,
pub password: String,
pub company_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_type: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl std::fmt::Debug for SignUpWithMerchantRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SignUpWithMerchantRequest")
.field("name", &self.name)
.field("email", &self.email)
.field("password", &"[redacted]")
.field("company_name", &self.company_name)
.field("organization_type", &self.organization_type)
.field("extra", &self.extra)
.finish()
}
}
const SIGN_UP_WITH_MERCHANT_REQUEST_NAMED: &[&str] = &[
"name",
"email",
"password",
"company_name",
"organization_type",
];
impl ValidateRequest for SignUpWithMerchantRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if SIGN_UP_WITH_MERCHANT_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on \
SignUpWithMerchantRequest"
)));
}
}
Ok(())
}
}
impl SignUpWithMerchantRequest {
pub fn new(
name: impl Into<String>,
email: impl Into<String>,
password: impl Into<String>,
company_name: impl Into<String>,
) -> Self {
Self {
name: name.into(),
email: email.into(),
password: password.into(),
company_name: company_name.into(),
..Default::default()
}
}
#[must_use]
pub fn organization_type(mut self, organization_type: impl Into<String>) -> Self {
self.organization_type = Some(organization_type.into());
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct SignInRequest {
pub email: String,
pub password: String,
}
impl std::fmt::Debug for SignInRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SignInRequest")
.field("email", &self.email)
.field("password", &"[redacted]")
.finish()
}
}
impl SignInRequest {
pub fn new(email: impl Into<String>, password: impl Into<String>) -> Self {
Self {
email: email.into(),
password: password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct ChangePasswordRequest {
pub old_password: String,
pub new_password: String,
}
impl std::fmt::Debug for ChangePasswordRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChangePasswordRequest")
.field("old_password", &"[redacted]")
.field("new_password", &"[redacted]")
.finish()
}
}
impl ChangePasswordRequest {
pub fn new(old_password: impl Into<String>, new_password: impl Into<String>) -> Self {
Self {
old_password: old_password.into(),
new_password: new_password.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ForgotPasswordRequest {
pub email: String,
}
impl ForgotPasswordRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct ResetPasswordRequest {
pub token: String,
pub password: String,
}
impl std::fmt::Debug for ResetPasswordRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ResetPasswordRequest")
.field("token", &"[redacted]")
.field("password", &"[redacted]")
.finish()
}
}
impl ResetPasswordRequest {
pub fn new(token: impl Into<String>, password: impl Into<String>) -> Self {
Self {
token: token.into(),
password: password.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SwitchMerchantRequest {
pub merchant_id: String,
}
impl SwitchMerchantRequest {
pub fn new(merchant_id: impl Into<String>) -> Self {
Self {
merchant_id: merchant_id.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SwitchProfileRequest {
pub profile_id: String,
}
impl SwitchProfileRequest {
pub fn new(profile_id: impl Into<String>) -> Self {
Self {
profile_id: profile_id.into(),
}
}
}
pub const MAX_INVITE_LINK_VALID_DAYS: i32 = 30;
fn check_link_valid_for_days(days: Option<i32>) -> Result<()> {
if days.is_some_and(|days| !(1..=MAX_INVITE_LINK_VALID_DAYS).contains(&days)) {
return Err(DelopayError::InvalidRequest(format!(
"`link_valid_for_days` must be 1 to {MAX_INVITE_LINK_VALID_DAYS}"
)));
}
Ok(())
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ReInviteUserRequest {
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub link_valid_for_days: Option<i32>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl ReInviteUserRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
..Default::default()
}
}
#[must_use]
pub fn link_valid_for_days(mut self, days: i32) -> Self {
self.link_valid_for_days = Some(days);
self
}
}
const RE_INVITE_USER_REQUEST_NAMED: &[&str] = &["email", "link_valid_for_days"];
impl ValidateRequest for ReInviteUserRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if RE_INVITE_USER_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on ReInviteUserRequest"
)));
}
}
check_link_valid_for_days(self.link_valid_for_days)
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct InviteUsersRequest {
pub email: String,
pub name: String,
pub role_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_ids: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub project_ids: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub offer_dashboard_tour: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub link_valid_for_days: Option<i32>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
const INVITE_USERS_REQUEST_NAMED: &[&str] = &[
"email",
"name",
"role_id",
"profile_ids",
"project_ids",
"expires_at",
"offer_dashboard_tour",
"link_valid_for_days",
];
impl ValidateRequest for InviteUsersRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if INVITE_USERS_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on InviteUsersRequest"
)));
}
}
check_link_valid_for_days(self.link_valid_for_days)
}
}
impl InviteUsersRequest {
pub fn new(
email: impl Into<String>,
name: impl Into<String>,
role_id: impl Into<String>,
) -> Self {
Self {
email: email.into(),
name: name.into(),
role_id: role_id.into(),
..Default::default()
}
}
#[must_use]
pub fn profile_ids(mut self, profile_ids: Vec<String>) -> Self {
self.profile_ids = Some(profile_ids);
self
}
#[must_use]
pub fn project_ids(mut self, project_ids: Vec<String>) -> Self {
self.project_ids = Some(project_ids);
self
}
#[must_use]
pub fn expires_at(mut self, expires_at: impl Into<String>) -> Self {
self.expires_at = Some(expires_at.into());
self
}
#[must_use]
pub fn offer_dashboard_tour(mut self, offer: bool) -> Self {
self.offer_dashboard_tour = Some(offer);
self
}
#[must_use]
pub fn link_valid_for_days(mut self, days: i32) -> Self {
self.link_valid_for_days = Some(days);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateUserRoleRequest {
pub email: String,
pub role_id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
}
impl UpdateUserRoleRequest {
pub fn new(email: impl Into<String>, role_id: impl Into<String>) -> Self {
Self {
email: email.into(),
role_id: role_id.into(),
profile_id: None,
}
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DeleteUserRoleRequest {
pub email: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub project_id: Option<String>,
}
impl DeleteUserRoleRequest {
pub fn new(email: impl Into<String>) -> Self {
Self {
email: email.into(),
profile_id: None,
project_id: None,
}
}
#[must_use]
pub fn project_id(mut self, project_id: impl Into<String>) -> Self {
self.project_id = Some(project_id.into());
self
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct VerifyTotpRequest {
pub totp: String,
}
impl std::fmt::Debug for VerifyTotpRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("VerifyTotpRequest")
.field("totp", &"[redacted]")
.finish()
}
}
impl VerifyTotpRequest {
pub fn new(totp: impl Into<String>) -> Self {
Self { totp: totp.into() }
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct PhoneOtpRequest {
pub phone_number: String,
}
impl PhoneOtpRequest {
pub fn new(phone_number: impl Into<String>) -> Self {
Self {
phone_number: phone_number.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct PhoneOtpVerifyRequest {
pub phone_number: String,
pub code: String,
}
impl std::fmt::Debug for PhoneOtpVerifyRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PhoneOtpVerifyRequest")
.field("phone_number", &self.phone_number)
.field("code", &"[redacted]")
.finish()
}
}
impl PhoneOtpVerifyRequest {
pub fn new(phone_number: impl Into<String>, code: impl Into<String>) -> Self {
Self {
phone_number: phone_number.into(),
code: code.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateUserDetailsRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_language: Option<String>,
}
impl UpdateUserDetailsRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
#[must_use]
pub fn preferred_language(mut self, language: impl Into<String>) -> Self {
self.preferred_language = Some(language.into());
self
}
}
#[derive(Debug, Clone, Default)]
pub struct LoginHistoryParams {
pub limit: Option<i64>,
pub offset: Option<i64>,
}
impl LoginHistoryParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.limit {
q.push(("limit", v.to_string()));
}
if let Some(v) = self.offset {
q.push(("offset", v.to_string()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct ListUsersInLineageParams {
pub entity_type: Option<String>,
pub profile_id: Option<String>,
}
impl ListUsersInLineageParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = &self.entity_type {
q.push(("entity_type", v.clone()));
}
if let Some(v) = &self.profile_id {
q.push(("profile_id", v.clone()));
}
q
}
}
#[derive(Debug, Clone, Default)]
pub struct ListRolesParams {
pub groups: Option<bool>,
pub entity_type: Option<String>,
}
impl ListRolesParams {
fn to_query(&self) -> Vec<(&'static str, String)> {
let mut q = Vec::new();
if let Some(v) = self.groups {
q.push(("groups", v.to_string()));
}
if let Some(v) = &self.entity_type {
q.push(("entity_type", v.clone()));
}
q
}
}
const INVITATION_LINKS_PATH: &str = "/user/employees/invitation-links";
fn preference_path(key: &str) -> String {
format!("/user/preferences/{}", encode_segment(key))
}
fn employee_path(user_id: &str) -> String {
format!("/user/employees/{}", encode_segment(user_id))
}
fn note_path(user_id: &str, note_id: &str) -> String {
format!(
"{}/notes/{}",
employee_path(user_id),
encode_segment(note_id)
)
}
#[derive(Serialize)]
struct InvitationLinkTokenBody<'a> {
token: &'a str,
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct DashboardOAuthStartRequest {
pub provider: String,
pub app: String,
pub verifier_hash: String,
}
impl DashboardOAuthStartRequest {
pub fn new(
provider: impl Into<String>,
app: impl Into<String>,
verifier_hash: impl Into<String>,
) -> Self {
Self {
provider: provider.into(),
app: app.into(),
verifier_hash: verifier_hash.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct DashboardOAuthLinkStartRequest {
pub provider: String,
pub app: String,
pub verifier_hash: String,
pub password: String,
}
impl std::fmt::Debug for DashboardOAuthLinkStartRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DashboardOAuthLinkStartRequest")
.field("provider", &self.provider)
.field("app", &self.app)
.field("verifier_hash", &self.verifier_hash)
.field("password", &"[redacted]")
.finish()
}
}
impl DashboardOAuthLinkStartRequest {
pub fn new(
provider: impl Into<String>,
app: impl Into<String>,
verifier_hash: impl Into<String>,
password: impl Into<String>,
) -> Self {
Self {
provider: provider.into(),
app: app.into(),
verifier_hash: verifier_hash.into(),
password: password.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct DashboardOAuthCompleteRequest {
pub ticket: String,
pub verifier: String,
pub app: String,
}
impl std::fmt::Debug for DashboardOAuthCompleteRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DashboardOAuthCompleteRequest")
.field("ticket", &"[redacted]")
.field("verifier", &"[redacted]")
.field("app", &self.app)
.finish()
}
}
impl DashboardOAuthCompleteRequest {
pub fn new(
ticket: impl Into<String>,
verifier: impl Into<String>,
app: impl Into<String>,
) -> Self {
Self {
ticket: ticket.into(),
verifier: verifier.into(),
app: app.into(),
}
}
}
#[derive(Clone, Default, Serialize)]
pub struct DashboardOAuthDisconnectRequest {
pub password: String,
}
impl std::fmt::Debug for DashboardOAuthDisconnectRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DashboardOAuthDisconnectRequest")
.field("password", &"[redacted]")
.finish()
}
}
impl DashboardOAuthDisconnectRequest {
pub fn new(password: impl Into<String>) -> Self {
Self {
password: password.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct SetUserPreferenceRequest {
pub value: serde_json::Map<String, Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub if_absent: Option<bool>,
}
impl SetUserPreferenceRequest {
pub fn new(value: serde_json::Map<String, Value>) -> Self {
Self {
value,
if_absent: None,
}
}
#[must_use]
pub fn if_absent(mut self, if_absent: bool) -> Self {
self.if_absent = Some(if_absent);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateDashboardTourRequest {
#[serde(skip_serializing_if = "Option::is_none")]
pub progress: Option<TourProgress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub restart: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub acknowledge_access: Option<bool>,
}
impl UpdateDashboardTourRequest {
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn progress(mut self, progress: TourProgress) -> Self {
self.progress = Some(progress);
self
}
#[must_use]
pub fn restart(mut self, restart: bool) -> Self {
self.restart = Some(restart);
self
}
#[must_use]
pub fn acknowledge_access(mut self, acknowledge_access: bool) -> Self {
self.acknowledge_access = Some(acknowledge_access);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateRoleConnectorGrantRequest {
pub merchant_connector_ids: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(flatten, skip_serializing_if = "serde_json::Map::is_empty")]
pub extra: serde_json::Map<String, Value>,
}
impl UpdateRoleConnectorGrantRequest {
pub fn new(merchant_connector_ids: Vec<String>) -> Self {
Self {
merchant_connector_ids,
..Default::default()
}
}
#[must_use]
pub fn reason(mut self, reason: impl Into<String>) -> Self {
self.reason = Some(reason.into());
self
}
}
const UPDATE_ROLE_CONNECTOR_GRANT_REQUEST_NAMED: &[&str] = &["merchant_connector_ids", "reason"];
impl ValidateRequest for UpdateRoleConnectorGrantRequest {
fn validate(&self) -> Result<()> {
for key in self.extra.keys() {
if UPDATE_ROLE_CONNECTOR_GRANT_REQUEST_NAMED.contains(&key.as_str()) {
return Err(DelopayError::InvalidRequest(format!(
"`extra` key `{key}` collides with a named field on UpdateRoleConnectorGrantRequest"
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ChangeMemberScopeRequest {
pub email: String,
pub role_id: String,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub profile_ids: Vec<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub project_ids: Vec<String>,
}
impl ChangeMemberScopeRequest {
pub fn new(email: impl Into<String>, role_id: impl Into<String>) -> Self {
Self {
email: email.into(),
role_id: role_id.into(),
..Default::default()
}
}
#[must_use]
pub fn profile_ids(mut self, profile_ids: Vec<String>) -> Self {
self.profile_ids = profile_ids;
self
}
#[must_use]
pub fn project_ids(mut self, project_ids: Vec<String>) -> Self {
self.project_ids = project_ids;
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateMemberExpiryRequest {
pub email: String,
pub expires_at: Option<String>,
}
impl UpdateMemberExpiryRequest {
pub fn new(email: impl Into<String>, expires_at: impl Into<String>) -> Self {
Self {
email: email.into(),
expires_at: Some(expires_at.into()),
}
}
pub fn clear(email: impl Into<String>) -> Self {
Self {
email: email.into(),
expires_at: None,
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateTeamMemberContactsRequest {
pub expected_revision: String,
pub contacts: TeamMemberContacts,
}
impl UpdateTeamMemberContactsRequest {
pub fn new(expected_revision: impl Into<String>, contacts: TeamMemberContacts) -> Self {
Self {
expected_revision: expected_revision.into(),
contacts,
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct WriteTeamMemberNoteRequest {
pub expected_revision: String,
pub body: String,
}
impl WriteTeamMemberNoteRequest {
pub fn new(expected_revision: impl Into<String>, body: impl Into<String>) -> Self {
Self {
expected_revision: expected_revision.into(),
body: body.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct ResetTeamMemberPasswordRequest {
pub reason: String,
}
impl ResetTeamMemberPasswordRequest {
pub fn new(reason: impl Into<String>) -> Self {
Self {
reason: reason.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateMemberMethodAccessRequest {
pub all_methods: bool,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub methods: Vec<String>,
pub expected_revision: String,
}
impl UpdateMemberMethodAccessRequest {
pub fn all(expected_revision: impl Into<String>) -> Self {
Self {
all_methods: true,
methods: Vec::new(),
expected_revision: expected_revision.into(),
}
}
pub fn only(methods: Vec<String>, expected_revision: impl Into<String>) -> Self {
Self {
all_methods: false,
methods,
expected_revision: expected_revision.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateMemberPermissionOverridesRequest {
pub overrides: Vec<PermissionOverride>,
pub expected_revision: String,
}
impl UpdateMemberPermissionOverridesRequest {
pub fn new(overrides: Vec<PermissionOverride>, expected_revision: impl Into<String>) -> Self {
Self {
overrides,
expected_revision: expected_revision.into(),
}
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct CreateInvitationLinkRequest {
pub name: String,
pub target: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub profile_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub project_id: Option<String>,
pub role_id: String,
pub max_uses: i32,
pub expires_at: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub member_expires_at: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub restrictions: Option<InvitationLinkRestrictions>,
}
impl CreateInvitationLinkRequest {
pub fn new(
name: impl Into<String>,
target: impl Into<String>,
role_id: impl Into<String>,
max_uses: i32,
expires_at: impl Into<String>,
) -> Self {
Self {
name: name.into(),
target: target.into(),
role_id: role_id.into(),
max_uses,
expires_at: expires_at.into(),
..Default::default()
}
}
#[must_use]
pub fn profile_id(mut self, profile_id: impl Into<String>) -> Self {
self.profile_id = Some(profile_id.into());
self
}
#[must_use]
pub fn project_id(mut self, project_id: impl Into<String>) -> Self {
self.project_id = Some(project_id.into());
self
}
#[must_use]
pub fn member_expires_at(mut self, member_expires_at: impl Into<String>) -> Self {
self.member_expires_at = Some(member_expires_at.into());
self
}
#[must_use]
pub fn restrictions(mut self, restrictions: InvitationLinkRestrictions) -> Self {
self.restrictions = Some(restrictions);
self
}
}
#[derive(Debug, Clone, Default, Serialize)]
pub struct UpdateInvitationLinkRequest {
pub name: String,
pub max_uses: i32,
pub expires_at: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub member_expires_at: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub restrictions: Option<InvitationLinkRestrictions>,
pub version: String,
}
impl UpdateInvitationLinkRequest {
pub fn new(
name: impl Into<String>,
max_uses: i32,
expires_at: impl Into<String>,
version: impl Into<String>,
) -> Self {
Self {
name: name.into(),
max_uses,
expires_at: expires_at.into(),
version: version.into(),
..Default::default()
}
}
#[must_use]
pub fn member_expires_at(mut self, member_expires_at: impl Into<String>) -> Self {
self.member_expires_at = Some(member_expires_at.into());
self
}
#[must_use]
pub fn restrictions(mut self, restrictions: InvitationLinkRestrictions) -> Self {
self.restrictions = Some(restrictions);
self
}
}
#[derive(Clone, Default, Serialize)]
pub struct RegisterThroughInvitationLinkRequest {
pub token: String,
pub name: String,
pub email: String,
pub password: String,
}
impl std::fmt::Debug for RegisterThroughInvitationLinkRequest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RegisterThroughInvitationLinkRequest")
.field("token", &"[redacted]")
.field("name", &self.name)
.field("email", &self.email)
.field("password", &"[redacted]")
.finish()
}
}
impl RegisterThroughInvitationLinkRequest {
pub fn new(
token: impl Into<String>,
name: impl Into<String>,
email: impl Into<String>,
password: impl Into<String>,
) -> Self {
Self {
token: token.into(),
name: name.into(),
email: email.into(),
password: password.into(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::mock::{Step, client_with};
use serde_json::json;
const OK: &str = r#"{"ok":true}"#;
const EMPTY_LIST: &str = "[]";
const AUTH: &str = r#"{"token":"jwt-secret-1","token_type":"bearer","expires":3600}"#;
const TOKEN: &str = r#"{"token":"spt-secret-1","token_type":"reset_password"}"#;
const USER: &str = r#"{"merchant_id":"mer_1","name":"Ada","email":"ada@example.com",
"role_id":"role_1","is_two_factor_auth_setup":true,"profile_id":"pro_1",
"entity_type":"merchant","version":"v2"}"#;
#[test]
fn sign_up_request_debug_redacts_the_password() {
let req = SignUpRequest::new("ada@example.com", "hunter2-sign-up");
let rendered = format!("{req:?}");
assert!(!rendered.contains("hunter2-sign-up"), "{rendered}");
assert!(rendered.contains("ada@example.com"), "{rendered}");
}
#[test]
fn sign_up_with_merchant_request_debug_redacts_the_password() {
let req = SignUpWithMerchantRequest::new(
"Ada",
"ada@example.com",
"hunter2-merchant",
"Analytical Engines Ltd",
);
let rendered = format!("{req:?}");
assert!(!rendered.contains("hunter2-merchant"), "{rendered}");
assert!(rendered.contains("Analytical Engines Ltd"), "{rendered}");
}
#[test]
fn sign_in_request_debug_redacts_the_password() {
let req = SignInRequest::new("ada@example.com", "hunter2-sign-in");
let rendered = format!("{req:?}");
assert!(!rendered.contains("hunter2-sign-in"), "{rendered}");
assert!(rendered.contains("ada@example.com"), "{rendered}");
}
#[test]
fn change_password_request_debug_redacts_both_passwords() {
let req = ChangePasswordRequest::new("old-secret-pw", "new-secret-pw");
let rendered = format!("{req:?}");
assert!(!rendered.contains("old-secret-pw"), "{rendered}");
assert!(!rendered.contains("new-secret-pw"), "{rendered}");
}
#[test]
fn reset_password_request_debug_redacts_token_and_password() {
let req = ResetPasswordRequest::new("email-token-abc", "brand-new-pw");
let rendered = format!("{req:?}");
assert!(!rendered.contains("email-token-abc"), "{rendered}");
assert!(!rendered.contains("brand-new-pw"), "{rendered}");
}
#[test]
fn verify_totp_request_debug_redacts_the_code() {
let req = VerifyTotpRequest::new("987654");
assert!(!format!("{req:?}").contains("987654"));
}
#[test]
fn phone_otp_verify_request_debug_redacts_the_code() {
let req = PhoneOtpVerifyRequest::new("+441234567890", "246810");
let rendered = format!("{req:?}");
assert!(!rendered.contains("246810"), "{rendered}");
assert!(rendered.contains("+441234567890"), "{rendered}");
}
#[test]
fn sign_up_with_merchant_request_named_fields_are_complete() {
let req = SignUpWithMerchantRequest::new("Ada", "ada@example.com", "pw", "Co")
.organization_type("company");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
SIGN_UP_WITH_MERCHANT_REQUEST_NAMED.contains(&key.as_str()),
"SIGN_UP_WITH_MERCHANT_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn invite_users_request_named_fields_are_complete() {
let req = InviteUsersRequest::new("bob@example.com", "Bob", "role_1")
.profile_ids(vec!["pro_1".to_string()])
.project_ids(vec!["prj_1".to_string()])
.expires_at("2027-01-01T00:00:00Z")
.offer_dashboard_tour(true)
.link_valid_for_days(14);
let value = serde_json::to_value(req).unwrap();
assert_eq!(value["link_valid_for_days"], 14);
assert_eq!(value["project_ids"], json!(["prj_1"]));
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
INVITE_USERS_REQUEST_NAMED.contains(&key.as_str()),
"INVITE_USERS_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn re_invite_user_request_named_fields_are_complete() {
let value = serde_json::to_value(
ReInviteUserRequest::new("bob@example.com").link_valid_for_days(3),
)
.unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
RE_INVITE_USER_REQUEST_NAMED.contains(&key.as_str()),
"RE_INVITE_USER_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[test]
fn link_valid_for_days_out_of_range_is_refused() {
for days in [0, 31] {
assert!(
ReInviteUserRequest::new("bob@example.com")
.link_valid_for_days(days)
.validate()
.is_err()
);
assert!(
InviteUsersRequest::new("bob@example.com", "Bob", "role_1")
.link_valid_for_days(days)
.validate()
.is_err()
);
}
for days in [1, 30] {
assert!(
ReInviteUserRequest::new("bob@example.com")
.link_valid_for_days(days)
.validate()
.is_ok()
);
}
}
#[test]
fn validate_rejects_extra_keys_colliding_with_named_fields() {
let mut invite = InviteUsersRequest::new("bob@example.com", "Bob", "role_1");
invite.extra.insert("email".to_string(), json!("x@y.z"));
assert!(matches!(
invite.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
let mut signup = SignUpWithMerchantRequest::new("Ada", "a@b.c", "pw", "Co");
signup
.extra
.insert("company_name".to_string(), json!("Other"));
assert!(matches!(
signup.validate().unwrap_err(),
DelopayError::InvalidRequest(_)
));
}
#[tokio::test]
async fn auth_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(OK),
]);
let users = client.users();
let signed_up = users
.sign_up(&SignUpRequest::new("ada@example.com", "pw"))
.await
.unwrap();
assert_eq!(signed_up.token, "jwt-secret-1");
assert_eq!(signed_up.token_type.as_deref(), Some("bearer"));
assert_eq!(signed_up.expires, Some(3600));
users
.sign_up_with_merchant(&SignUpWithMerchantRequest::new(
"Ada",
"ada@example.com",
"pw",
"Analytical Engines",
))
.await
.unwrap();
users
.sign_in(&SignInRequest::new("ada@example.com", "pw"))
.await
.unwrap();
users.sign_out().await.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("POST", "https://api.test/user/signup")
);
assert_eq!(seen[0].body_json()["email"], "ada@example.com");
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/user/signup")
);
assert_eq!(seen[1].body_json()["company_name"], "Analytical Engines");
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("POST", "https://api.test/user/signin")
);
assert_eq!(seen[2].body_json()["password"], "pw");
assert_eq!(
(seen[3].method, seen[3].url.as_str()),
("POST", "https://api.test/user/signout")
);
assert!(seen[3].body.is_none(), "signout must not send a body");
}
#[tokio::test]
async fn sign_in_oidc_posts_the_open_body() {
let (client, mock) = client_with(vec![Step::ok(AUTH)]);
client
.users()
.sign_in_oidc(&json!({"code": "oidc_code_1"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/oidc");
assert_eq!(seen[0].body_json()["code"], "oidc_code_1");
}
#[tokio::test]
async fn login_activity_and_sessions_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(
r#"{"entries":[{"id":"lh_1","event_type":"signin_success","failure_reason":null,
"auth_method":"password","ip_address":"203.0.113.7","user_agent":"curl",
"country_code":"GB","city":"London","latitude":51.5,"longitude":-0.12,
"created_at":"2026-01-01T00:00:00Z"}],
"total_count":1,"offset":0,"limit":25}"#,
),
Step::ok(r#"{"entries":[],"total_count":0,"offset":100,"limit":50}"#),
Step::ok(
r#"{"sessions":[{"id":"ses_1","auth_method":"password","ip_address":null,
"user_agent":null,"country_code":null,"city":null,
"created_at":"2026-01-01T00:00:00Z","last_seen_at":"2026-01-02T00:00:00Z",
"expires_at":"2026-01-08T00:00:00Z","is_current":true}]}"#,
),
Step::ok(r#"{"revoked":true}"#),
]);
let users = client.users();
let activity = users.list_login_activity(None).await.unwrap();
assert_eq!(activity.total_count, 1);
assert_eq!(activity.entries[0].event_type, "signin_success");
assert_eq!(activity.entries[0].city.as_deref(), Some("London"));
users
.list_login_activity(Some(&LoginHistoryParams {
limit: Some(50),
offset: Some(100),
}))
.await
.unwrap();
let sessions = users.list_active_sessions().await.unwrap();
assert_eq!(sessions.sessions[0].id, "ses_1");
assert!(sessions.sessions[0].is_current);
let revoked = users.revoke_session("ses/1 a").await.unwrap();
assert!(revoked.revoked);
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/user/me/login-activity")
);
assert_eq!(
seen[1].url,
"https://api.test/user/me/login-activity?limit=50&offset=100"
);
assert_eq!(
(seen[2].method, seen[2].url.as_str()),
("GET", "https://api.test/user/me/sessions")
);
assert_eq!(
(seen[3].method, seen[3].url.as_str()),
(
"POST",
"https://api.test/user/me/sessions/ses%2F1%20a/revoke"
)
);
}
#[tokio::test]
async fn profile_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![Step::ok(USER), Step::ok(USER)]);
let users = client.users();
let me = users.details().await.unwrap();
assert_eq!(me.email, "ada@example.com");
assert!(me.is_two_factor_auth_setup);
assert_eq!(me.theme_id, None);
users
.update(
&UpdateUserDetailsRequest::new()
.name("Ada L.")
.preferred_language("de"),
)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("GET", "https://api.test/user")
);
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/user/update")
);
assert_eq!(
seen[1].body_json(),
json!({"name": "Ada L.", "preferred_language": "de"})
);
}
#[tokio::test]
async fn password_and_email_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(USER),
Step::ok(USER),
Step::ok(OK),
Step::ok(OK),
Step::ok(AUTH),
Step::ok(OK),
]);
let users = client.users();
users
.change_password(&ChangePasswordRequest::new("old", "new"))
.await
.unwrap();
users
.rotate_password(&ResetPasswordRequest::new("tok", "rotated"))
.await
.unwrap();
users
.forgot_password(&ForgotPasswordRequest::new("ada@example.com"))
.await
.unwrap();
users
.reset_password(&ResetPasswordRequest::new("tok", "reset"))
.await
.unwrap();
users
.verify_email(&json!({"token": "verify-tok"}))
.await
.unwrap();
users
.send_verification_email(&ForgotPasswordRequest::new("ada@example.com"))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/change-password"),
("POST", "https://api.test/user/rotate-password"),
("POST", "https://api.test/user/forgot-password"),
("POST", "https://api.test/user/reset-password"),
("POST", "https://api.test/user/verify-email"),
("POST", "https://api.test/user/verify-email-request"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!((seen[i].method, seen[i].url.as_str()), (*method, *url));
}
assert_eq!(seen[0].body_json()["old_password"], "old");
assert_eq!(seen[1].body_json()["password"], "rotated");
assert_eq!(seen[2].body_json()["email"], "ada@example.com");
assert_eq!(seen[3].body_json()["password"], "reset");
assert_eq!(seen[4].body_json()["token"], "verify-tok");
assert_eq!(seen[5].body_json()["email"], "ada@example.com");
}
#[tokio::test]
async fn switching_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(AUTH),
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
]);
let users = client.users();
users
.create_merchant(&json!({"merchant_name": "Acme"}))
.await
.unwrap();
let switched = users
.switch_merchant(&SwitchMerchantRequest::new("mer_1"))
.await
.unwrap();
assert_eq!(switched.token, "jwt-secret-1");
users
.switch_profile(&SwitchProfileRequest::new("pro_1"))
.await
.unwrap();
users.list_merchants().await.unwrap();
users.list_profiles().await.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/create-merchant"),
("POST", "https://api.test/user/switch/merchant"),
("POST", "https://api.test/user/switch/profile"),
("GET", "https://api.test/user/list/merchant"),
("GET", "https://api.test/user/list/profile"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!((seen[i].method, seen[i].url.as_str()), (*method, *url));
}
assert_eq!(seen[0].body_json()["merchant_name"], "Acme");
assert_eq!(seen[1].body_json()["merchant_id"], "mer_1");
assert_eq!(seen[2].body_json()["profile_id"], "pro_1");
}
#[tokio::test]
async fn invite_users_posts_a_json_array() {
let (client, mock) = client_with(vec![Step::ok(
r#"[{"email":"bob@example.com","is_email_sent":false,"password":"temp-pw","error":null},
{"email":"eve@example.com","is_email_sent":true}]"#,
)]);
let out = client
.users()
.invite_users(&[
InviteUsersRequest::new("bob@example.com", "Bob", "role_1"),
InviteUsersRequest::new("eve@example.com", "Eve", "role_2")
.profile_ids(vec!["pro_9".to_string()]),
])
.await
.unwrap();
assert_eq!(out.len(), 2);
assert!(!out[0].is_email_sent);
assert_eq!(out[0].password.as_deref(), Some("temp-pw"));
assert!(out[1].is_email_sent);
assert_eq!(out[1].password, None);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/employees/invite");
let body = seen[0].body_json();
assert!(body.is_array(), "invite body must be a JSON array: {body}");
assert_eq!(body[0]["email"], "bob@example.com");
assert_eq!(body[1]["profile_ids"][0], "pro_9");
}
#[tokio::test]
async fn employee_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(AUTH),
Step::ok(r#"{"link_expires_at":"2026-11-10T00:00:00Z","surprise_field":1}"#),
Step::ok(
r#"[{"role_id":"role_1","org":{"id":"org_1","name":null},
"merchant":{"id":"mer_1","name":"Acme"},
"project":{"id":"prj_1","name":null},"status":"InvitationSent",
"entity_type":"profile","role_name":"Shop admin","surprise_field":1}]"#,
),
Step::ok(EMPTY_LIST),
Step::ok(OK),
Step::ok(OK),
Step::ok(
r#"[{"user_id":"usr_1","email":"bob@example.com",
"roles":[{"role_id":"role_1","role_name":"Admin","entity_type":"profile",
"profile_id":"pro_1","can_impersonate":true,
"expires_at":"2027-01-01T00:00:00Z"}],
"permission_overrides":[{"area":"Refunds","level":"hidden"}]}]"#,
),
Step::ok(EMPTY_LIST),
]);
let users = client.users();
users
.accept_invitation(&json!({"token": "invite-tok"}))
.await
.unwrap();
let resent = users
.resend_invite(&ReInviteUserRequest::new("bob@example.com").link_valid_for_days(14))
.await
.unwrap();
assert_eq!(resent.link_expires_at, "2026-11-10T00:00:00Z");
assert_eq!(resent.extra["surprise_field"], 1);
let roles = users.list_user_roles(None).await.unwrap();
assert_eq!(roles[0].org.id, "org_1");
assert!(roles[0].org.name.is_none());
assert_eq!(
roles[0].merchant.as_ref().unwrap().name.as_deref(),
Some("Acme")
);
assert_eq!(roles[0].project.as_ref().unwrap().id, "prj_1");
assert!(roles[0].profile.is_none());
assert_eq!(roles[0].status, "InvitationSent");
assert_eq!(roles[0].extra["surprise_field"], 1);
users
.list_user_roles(Some(&json!({"entity_type": "merchant"})))
.await
.unwrap();
users
.update_user_role(
&UpdateUserRoleRequest::new("bob@example.com", "role_2").profile_id("pro_1"),
)
.await
.unwrap();
users
.delete_user_role(
&DeleteUserRoleRequest::new("bob@example.com")
.profile_id("pro_1")
.project_id("prj_1"),
)
.await
.unwrap();
let lineage = users.list_users_in_lineage(None).await.unwrap();
assert_eq!(lineage[0].user_id, "usr_1");
assert_eq!(lineage[0].roles[0].role_name, "Admin");
assert_eq!(lineage[0].roles[0].profile_id.as_deref(), Some("pro_1"));
assert_eq!(lineage[0].roles[0].can_impersonate, Some(true));
assert_eq!(lineage[0].permission_overrides[0].level, "hidden");
users
.list_users_in_lineage(Some(&ListUsersInLineageParams {
entity_type: Some("profile".to_string()),
profile_id: Some("pro_1".to_string()),
}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/employees/invite/accept"),
("POST", "https://api.test/user/resend-invite"),
("POST", "https://api.test/user/employees"),
("POST", "https://api.test/user/employees"),
("POST", "https://api.test/user/employees/update-role"),
("DELETE", "https://api.test/user/employees/delete"),
("GET", "https://api.test/user/employees/list"),
(
"GET",
"https://api.test/user/employees/list?entity_type=profile&profile_id=pro_1",
),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[0].body_json()["token"], "invite-tok");
assert_eq!(
seen[1].body_json(),
json!({"email": "bob@example.com", "link_valid_for_days": 14})
);
assert!(seen[2].body.is_none());
assert_eq!(seen[3].body_json()["entity_type"], "merchant");
assert_eq!(seen[4].body_json()["role_id"], "role_2");
assert_eq!(seen[5].body_json()["email"], "bob@example.com");
assert_eq!(seen[5].body_json()["project_id"], "prj_1");
}
#[tokio::test]
async fn two_factor_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(OK),
Step::ok(
r#"{"secret":{"secret":"JBSWY3DPEHPK3PXP",
"totp_url":"otpauth://totp/x?secret=JBSWY3DPEHPK3PXP"}}"#,
),
Step::ok(OK),
Step::ok(OK),
Step::ok(OK),
Step::ok(r#"{"recovery_codes":["aaaa-bbbb","cccc-dddd"]}"#),
Step::ok(AUTH),
]);
let users = client.users();
users.check_2fa_status().await.unwrap();
let totp = users.begin_totp().await.unwrap();
let enrolment = totp.secret.as_ref().expect("not yet enrolled");
assert_eq!(enrolment.secret, "JBSWY3DPEHPK3PXP");
assert!(enrolment.totp_url.starts_with("otpauth://"));
users
.verify_totp(&VerifyTotpRequest::new("111111"))
.await
.unwrap();
users
.update_totp(&VerifyTotpRequest::new("222222"))
.await
.unwrap();
users.reset_totp().await.unwrap();
let codes = users.generate_recovery_codes().await.unwrap();
assert_eq!(codes.recovery_codes, vec!["aaaa-bbbb", "cccc-dddd"]);
users
.verify_recovery_code(&json!({"recovery_code": "abcd-efgh"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("GET", "https://api.test/user/2fa"),
("GET", "https://api.test/user/2fa/totp/begin"),
("POST", "https://api.test/user/2fa/totp/verify"),
("PUT", "https://api.test/user/2fa/totp/verify"),
("GET", "https://api.test/user/2fa/totp/reset"),
("GET", "https://api.test/user/2fa/recovery-code/generate"),
("POST", "https://api.test/user/2fa/recovery-code/verify"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[2].body_json()["totp"], "111111");
assert_eq!(seen[3].body_json()["totp"], "222222");
assert_eq!(seen[6].body_json()["recovery_code"], "abcd-efgh");
}
#[tokio::test]
async fn phone_otp_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(r#"{"message":"sent"}"#),
Step::ok(r#"{"verified":true}"#),
]);
let users = client.users();
let sent = users
.send_phone_otp(&PhoneOtpRequest::new("+441234567890"))
.await
.unwrap();
assert_eq!(sent.message, "sent");
let verified = users
.verify_phone_otp(&PhoneOtpVerifyRequest::new("+441234567890", "246810"))
.await
.unwrap();
assert!(verified.verified);
let seen = mock.seen.lock().unwrap();
assert_eq!(
(seen[0].method, seen[0].url.as_str()),
("POST", "https://api.test/user/phone/send-otp")
);
assert_eq!(seen[0].body_json()["phone_number"], "+441234567890");
assert_eq!(
(seen[1].method, seen[1].url.as_str()),
("POST", "https://api.test/user/phone/verify-otp")
);
assert_eq!(seen[1].body_json()["code"], "246810");
}
#[tokio::test]
async fn auth_method_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![Step::ok(OK), Step::ok(EMPTY_LIST)]);
let users = client.users();
users
.create_auth_method(&json!({"auth_type": "oidc"}))
.await
.unwrap();
users.list_auth_methods().await.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("POST", "https://api.test/user/auth"),
("GET", "https://api.test/user/auth/list"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[0].body_json()["auth_type"], "oidc");
}
#[tokio::test]
async fn role_endpoints_hit_their_paths() {
let (client, mock) = client_with(vec![
Step::ok(EMPTY_LIST),
Step::ok(EMPTY_LIST),
Step::ok(
r#"[{"name":"Operations","resources":["payment"],"scopes":["Read","Write"]}]"#,
),
Step::ok(OK),
]);
let users = client.users();
users.list_roles(None).await.unwrap();
users
.list_roles(Some(&ListRolesParams {
groups: Some(true),
entity_type: Some("merchant".to_string()),
}))
.await
.unwrap();
let permissions = users.role_permissions().await.unwrap();
assert_eq!(permissions[0].name, "Operations");
assert_eq!(permissions[0].scopes, vec!["Read", "Write"]);
users
.create_role(&json!({"role_name": "Ops"}))
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
let expected = [
("GET", "https://api.test/user/role/list"),
(
"GET",
"https://api.test/user/role/list?groups=true&entity_type=merchant",
),
("GET", "https://api.test/user/role"),
("POST", "https://api.test/user/role"),
];
for (i, (method, url)) in expected.iter().enumerate() {
assert_eq!(
(seen[i].method, seen[i].url.as_str()),
(*method, *url),
"call {i}"
);
}
assert_eq!(seen[3].body_json()["role_name"], "Ops");
}
const OAUTH_PROVIDERS: &str =
r#"{"available":["google","github"],"linked":["github"],"new_field":1}"#;
const OAUTH_START: &str =
r#"{"authorization_url":"https://idp.example/auth?state=st-secret-1","new_field":1}"#;
const PREFERENCE: &str =
r#"{"key":"merchant.analytics","value":{"order":["a","b"]},"new_field":1}"#;
const TOUR: &str = r#"{"scope":{"merchant_id":"mer_1","profile_id":null},
"auto_offer":true,"offer_source":"merchant","merchant_default":true,
"progress":{"completed":["home"],"skipped":[],"offer_handled_at":null,
"active":{"kind":"full","step_id":"payments","baseline":null},"baseline":null},
"access":{"current":[{"name":"Operations","scopes":["Read"]}],"acknowledged":null},
"read_only":false,"new_field":1}"#;
const ROLE_CONNECTORS: &str = r#"{"role_id":"role_1","restricted":true,
"connectors":[{"merchant_connector_id":"mca_1","created_by":"usr_1","reason":null}],
"new_field":1}"#;
const CONTACT_PROFILE: &str = r#"{"tenant_id":"public","merchant_id":"mer_1",
"user_id":"usr_1","revision":"rev_2",
"contacts":{"discord_name":"ada","extra_channels":[{"kind":"other","label":"Signal","value":"+100"}]},
"notes":[{"note_id":"note_1","body":"Prefers mornings",
"created_by":{"user_id":"usr_2","name":"Bob"},
"last_edited_by":{"user_id":"usr_2","name":"Bob"},
"created_at":"2026-01-01T00:00:00Z","last_edited_at":"2026-01-01T00:00:00Z"}],
"can_edit":true,"new_field":1}"#;
const METHOD_ACCESS: &str = r#"{"user_id":"usr_1","all_methods":false,"methods":["card"],
"revision":"rev_1","can_edit":true,"grant_all":true,"grantable":["card","sepa"],
"options":[{"key":"card","label":"Card"}],"new_field":1}"#;
const PERMISSION_OVERRIDES: &str = r#"{"user_id":"usr_1","entity_type":"merchant",
"roles":[{"role_id":"role_1","role_name":"Ops","profile_id":null,"project_id":null}],
"areas":[{"area":"Operations","available_levels":["hidden","read","write"],
"role_level":"write","override_level":"read","effective_level":"read",
"grantable_level":"write"}],
"overrides":[{"area":"Operations","level":"read"}],"revision":"rev_1",
"can_edit":true,"refusal":null,"can_raise":false,"modified_by":"usr_2",
"modified_at":"2026-01-01T00:00:00Z","new_field":1}"#;
const INVITATION_LINK: &str = r#"{"id":"invl_1","name":"Support","target":"shop",
"profile_id":"pro_1","project_id":null,"target_name":"Shop 1","role_id":"role_1",
"role_name":"Support","max_uses":10,"use_count":2,"remaining":8,
"expires_at":"2026-12-01T00:00:00Z","member_expires_at":null,
"restrictions":{"ip_ranges":["10.0.0.0/8"],"country_rule":"allow","countries":["DE"]},
"status":"active","created_by":"usr_1","created_by_name":"Ada",
"created_at":"2026-01-01T00:00:00Z","modified_at":"2026-01-02T00:00:00Z",
"revoked_at":null,"new_field":1}"#;
const JOIN: &str = r#"{"outcome":"joined","org_id":"org_1","merchant_id":"mer_1",
"target":"merchant","profile_id":null,"project_id":null,"target_name":"Acme",
"role_id":"role_1","role_name":"Admin","member_expires_at":null,"new_field":1}"#;
#[tokio::test]
async fn list_oauth_providers_gets_the_providers_path() {
let (client, mock) = client_with(vec![Step::ok(OAUTH_PROVIDERS)]);
let out = client.users().list_oauth_providers().await.unwrap();
assert_eq!(out.available, ["google", "github"]);
assert_eq!(out.linked, ["github"]);
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/user/oauth/providers");
}
#[tokio::test]
async fn list_linked_oauth_providers_gets_the_linked_path() {
let (client, mock) = client_with(vec![Step::ok(OAUTH_PROVIDERS)]);
let out = client.users().list_linked_oauth_providers().await.unwrap();
assert_eq!(out.linked, ["github"]);
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/user/oauth/linked");
}
#[tokio::test]
async fn start_oauth_sign_in_posts_the_provider_app_and_hash() {
let (client, mock) = client_with(vec![Step::ok(OAUTH_START)]);
let req = DashboardOAuthStartRequest::new("google", "merchant", "hash-1");
let out = client.users().start_oauth_sign_in(&req).await.unwrap();
assert!(out.authorization_url.starts_with("https://idp.example/"));
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/oauth/start");
assert_eq!(
seen[0].body_json(),
json!({"provider": "google", "app": "merchant", "verifier_hash": "hash-1"})
);
}
#[tokio::test]
async fn start_oauth_link_posts_the_password_too() {
let (client, mock) = client_with(vec![Step::ok(OAUTH_START)]);
let req = DashboardOAuthLinkStartRequest::new("github", "admin", "hash-2", "pw-1");
let out = client.users().start_oauth_link(&req).await.unwrap();
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/oauth/link/start");
assert_eq!(
seen[0].body_json(),
json!({"provider": "github", "app": "admin", "verifier_hash": "hash-2",
"password": "pw-1"})
);
}
#[tokio::test]
async fn complete_oauth_sign_in_posts_ticket_and_verifier_and_decodes_a_token() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"token":"jwt-1","token_type":"user_info","new_field":1}"#,
)]);
let req = DashboardOAuthCompleteRequest::new("tkt-1", "ver-1", "merchant");
let out = client.users().complete_oauth_sign_in(&req).await.unwrap();
assert_eq!(out.token, "jwt-1");
assert_eq!(out.token_type, "user_info");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/oauth/complete");
assert_eq!(
seen[0].body_json(),
json!({"ticket": "tkt-1", "verifier": "ver-1", "app": "merchant"})
);
}
#[tokio::test]
async fn complete_oauth_link_posts_and_accepts_an_empty_body() {
let (client, mock) = client_with(vec![Step::ok("")]);
let req = DashboardOAuthCompleteRequest::new("tkt-2", "ver-2", "admin");
let out = client.users().complete_oauth_link(&req).await.unwrap();
assert_eq!(out, Value::Null);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/oauth/link/complete");
assert_eq!(seen[0].body_json()["ticket"], "tkt-2");
}
#[tokio::test]
async fn disconnect_oauth_provider_deletes_with_the_password_body() {
let (client, mock) = client_with(vec![Step::ok("")]);
let req = DashboardOAuthDisconnectRequest::new("pw-2");
client
.users()
.disconnect_oauth_provider("git hub", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(seen[0].url, "https://api.test/user/oauth/linked/git%20hub");
assert_eq!(seen[0].body_json(), json!({"password": "pw-2"}));
}
#[tokio::test]
async fn refresh_token_posts_without_a_body() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"token":"jwt-2","token_type":"user_info","new_field":1}"#,
)]);
let out = client.users().refresh_token().await.unwrap();
assert_eq!(out.token, "jwt-2");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/token/refresh");
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn refresh_token_is_not_retried_on_a_5xx() {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::ok(TOKEN)],
2,
);
assert!(client.users().refresh_token().await.is_err());
assert_eq!(mock.call_count(), 1);
}
#[tokio::test]
async fn retrieve_preference_gets_the_encoded_key() {
let (client, mock) = client_with(vec![Step::ok(PREFERENCE)]);
let out = client
.users()
.retrieve_preference("merchant/analytics")
.await
.unwrap();
assert_eq!(out.key, "merchant.analytics");
assert_eq!(out.value.unwrap()["order"], json!(["a", "b"]));
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/preferences/merchant%2Fanalytics"
);
}
#[tokio::test]
async fn set_preference_puts_the_value() {
let (client, mock) = client_with(vec![Step::ok(PREFERENCE)]);
let mut value = serde_json::Map::new();
value.insert("order".into(), json!(["a", "b"]));
let req = SetUserPreferenceRequest::new(value);
let out = client
.users()
.set_preference("merchant.analytics", &req)
.await
.unwrap();
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/preferences/merchant.analytics"
);
assert_eq!(seen[0].body_json(), json!({"value": {"order": ["a", "b"]}}));
}
#[tokio::test]
async fn initialize_preference_puts_with_if_absent() {
let (client, mock) = client_with(vec![Step::ok(PREFERENCE)]);
let mut value = serde_json::Map::new();
value.insert("order".into(), json!(["c"]));
client
.users()
.initialize_preference("merchant.analytics", value)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/preferences/merchant.analytics"
);
assert_eq!(
seen[0].body_json(),
json!({"value": {"order": ["c"]}, "if_absent": true})
);
}
#[tokio::test]
async fn delete_preference_deletes_and_decodes_a_null_value() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"key":"merchant.analytics","value":null,"new_field":1}"#,
)]);
let out = client
.users()
.delete_preference("merchant.analytics")
.await
.unwrap();
assert!(out.value.is_none());
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/user/preferences/merchant.analytics"
);
}
#[tokio::test]
async fn retrieve_dashboard_tour_decodes_progress_and_access() {
let (client, mock) = client_with(vec![Step::ok(TOUR)]);
let out = client.users().retrieve_dashboard_tour().await.unwrap();
assert_eq!(out.scope.merchant_id, "mer_1");
assert!(out.scope.profile_id.is_none());
assert_eq!(out.offer_source, "merchant");
let progress = out.progress.unwrap();
assert_eq!(progress.completed, ["home"]);
assert_eq!(
progress.active.unwrap().step_id.as_deref(),
Some("payments")
);
assert_eq!(out.access.current[0].name, "Operations");
assert!(out.access.acknowledged.is_none());
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/user/dashboard-tour");
}
#[tokio::test]
async fn update_dashboard_tour_puts_the_progress_with_nullable_fields() {
let (client, mock) = client_with(vec![Step::ok(TOUR)]);
let req = UpdateDashboardTourRequest::new()
.progress(TourProgress::new().completed(vec!["home".into()]))
.acknowledge_access(true);
let out = client.users().update_dashboard_tour(&req).await.unwrap();
assert!(!out.read_only);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(seen[0].url, "https://api.test/user/dashboard-tour");
assert_eq!(
seen[0].body_json(),
json!({
"progress": {"completed": ["home"], "skipped": [],
"offer_handled_at": null, "active": null, "baseline": null},
"acknowledge_access": true
})
);
}
#[tokio::test]
async fn retrieve_role_payment_visibility_decodes_a_policy_and_null() {
let (client, mock) = client_with(vec![
Step::ok(
r#"{"payment_methods":"read","payment_processors":"none",
"processor_exceptions":[{"processor":"stripe","access":"read"}],
"new_field":1}"#,
),
Step::ok("null"),
]);
let users = client.users();
let policy = users
.retrieve_role_payment_visibility()
.await
.unwrap()
.unwrap();
assert_eq!(policy.payment_methods.as_deref(), Some("read"));
assert_eq!(policy.processor_exceptions[0].processor, "stripe");
assert_eq!(policy.extra["new_field"], 1);
assert!(
users
.retrieve_role_payment_visibility()
.await
.unwrap()
.is_none()
);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(seen[0].url, "https://api.test/user/role/payment-visibility");
}
#[tokio::test]
async fn retrieve_own_permission_overrides_decodes_the_list() {
let (client, mock) =
client_with(vec![Step::ok(r#"[{"area":"Operations","level":"read"}]"#)]);
let out = client
.users()
.retrieve_own_permission_overrides()
.await
.unwrap();
assert_eq!(out[0].area, "Operations");
assert_eq!(out[0].level, "read");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/role/permission-overrides"
);
}
#[tokio::test]
async fn retrieve_role_connectors_gets_the_encoded_role() {
let (client, mock) = client_with(vec![Step::ok(ROLE_CONNECTORS)]);
let out = client
.users()
.retrieve_role_connectors("role/1")
.await
.unwrap();
assert!(out.restricted);
assert_eq!(out.connectors[0].merchant_connector_id, "mca_1");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/role/role%2F1/connectors"
);
}
#[tokio::test]
async fn update_role_connectors_puts_the_complete_set() {
let (client, mock) = client_with(vec![Step::ok(ROLE_CONNECTORS)]);
let req = UpdateRoleConnectorGrantRequest::new(vec!["mca_1".into()]).reason("audit");
client
.users()
.update_role_connectors("role/1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/role/role%2F1/connectors"
);
assert_eq!(
seen[0].body_json(),
json!({"merchant_connector_ids": ["mca_1"], "reason": "audit"})
);
}
#[tokio::test]
async fn update_role_connectors_refuses_a_colliding_extra_key_before_sending() {
let (client, mock) = client_with(vec![Step::ok(ROLE_CONNECTORS)]);
let mut req = UpdateRoleConnectorGrantRequest::new(vec![]);
req.extra.insert("reason".into(), json!("other"));
let err = client
.users()
.update_role_connectors("role_1", &req)
.await
.unwrap_err();
assert!(matches!(err, DelopayError::InvalidRequest(ref m) if m.contains("reason")));
assert_eq!(mock.call_count(), 0);
}
#[test]
fn update_role_connector_grant_request_named_fields_are_complete() {
let req = UpdateRoleConnectorGrantRequest::new(vec!["mca_1".into()]).reason("r");
let value = serde_json::to_value(req).unwrap();
for key in value.as_object().expect("serializes to an object").keys() {
assert!(
UPDATE_ROLE_CONNECTOR_GRANT_REQUEST_NAMED.contains(&key.as_str()),
"UPDATE_ROLE_CONNECTOR_GRANT_REQUEST_NAMED is missing wire key `{key}`"
);
}
}
#[tokio::test]
async fn change_member_scope_posts_email_role_and_shops() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"role_id":"role_2","entity_type":"profile","profile_ids":["pro_1"],
"project_ids":[],"sessions_revoked":true,"new_field":1}"#,
)]);
let req = ChangeMemberScopeRequest::new("bob@example.com", "role_2")
.profile_ids(vec!["pro_1".into()]);
let out = client.users().change_member_scope(&req).await.unwrap();
assert!(out.sessions_revoked);
assert_eq!(out.profile_ids, ["pro_1"]);
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/employees/change-scope");
assert_eq!(
seen[0].body_json(),
json!({"email": "bob@example.com", "role_id": "role_2", "profile_ids": ["pro_1"]})
);
}
#[tokio::test]
async fn update_member_expiry_sends_an_explicit_null_to_clear() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"expires_at":null,"roles_updated":2,"new_field":1}"#,
)]);
let req = UpdateMemberExpiryRequest::clear("bob@example.com");
let out = client.users().update_member_expiry(&req).await.unwrap();
assert_eq!(out.roles_updated, 2);
assert!(out.expires_at.is_none());
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/employees/update-expiry");
assert_eq!(
seen[0].body_json(),
json!({"email": "bob@example.com", "expires_at": null})
);
}
#[tokio::test]
async fn retrieve_team_member_details_gets_the_encoded_member() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"user_id":"usr_1","email":"bob@example.com","name":"Bob",
"phone_number":null,"is_verified":true,"status":"Active","two_factor":"set",
"created_at":"2026-01-01T00:00:00Z","last_password_modified_at":null,
"roles":[{"role_id":"role_1","role_name":"Admin","entity_type":"merchant"}],
"can_reset_password":true,"pending_invitation":false,"new_field":1}"#,
)]);
let out = client
.users()
.retrieve_team_member_details("usr/1")
.await
.unwrap();
assert_eq!(out.two_factor, "set");
assert_eq!(out.roles[0].role_name, "Admin");
assert!(out.can_reset_password);
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/details"
);
}
#[tokio::test]
async fn retrieve_invite_link_gets_the_encoded_member() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"availability":"available","link":"https://dash.example/i?t=secret",
"expires_at":"2026-02-01T00:00:00Z","new_field":1}"#,
)]);
let out = client.users().retrieve_invite_link("usr/1").await.unwrap();
assert_eq!(out.availability, "available");
assert!(out.link.is_some());
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/invite-link"
);
}
#[tokio::test]
async fn retrieve_team_member_contact_profile_decodes_contacts_and_notes() {
let (client, mock) = client_with(vec![Step::ok(CONTACT_PROFILE)]);
let out = client
.users()
.retrieve_team_member_contact_profile("usr/1")
.await
.unwrap();
assert_eq!(out.revision, "rev_2");
assert_eq!(out.contacts.discord_name.as_deref(), Some("ada"));
assert_eq!(out.contacts.extra_channels[0].label, "Signal");
assert_eq!(out.notes[0].created_by.name, "Bob");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/contact-profile"
);
}
#[tokio::test]
async fn update_team_member_contacts_puts_the_whole_contacts() {
let (client, mock) = client_with(vec![Step::ok(CONTACT_PROFILE)]);
let contacts = TeamMemberContacts::new()
.telegram_username("ada_t")
.extra_channels(vec![
crate::core::models::user::TeamMemberContactChannel::new("other", "Signal", "+100"),
]);
let req = UpdateTeamMemberContactsRequest::new("rev_1", contacts);
client
.users()
.update_team_member_contacts("usr/1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/contact-profile"
);
assert_eq!(
seen[0].body_json(),
json!({"expected_revision": "rev_1", "contacts": {
"telegram_username": "ada_t",
"extra_channels": [{"kind": "other", "label": "Signal", "value": "+100"}]
}})
);
}
#[tokio::test]
async fn create_team_member_note_posts_the_body_and_revision() {
let (client, mock) = client_with(vec![Step::ok(CONTACT_PROFILE)]);
let req = WriteTeamMemberNoteRequest::new("rev_1", "Prefers mornings");
let out = client
.users()
.create_team_member_note("usr/1", &req)
.await
.unwrap();
assert_eq!(out.notes[0].note_id, "note_1");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/employees/usr%2F1/notes");
assert_eq!(
seen[0].body_json(),
json!({"expected_revision": "rev_1", "body": "Prefers mornings"})
);
}
#[tokio::test]
async fn update_team_member_note_puts_both_encoded_ids() {
let (client, mock) = client_with(vec![Step::ok(CONTACT_PROFILE)]);
let req = WriteTeamMemberNoteRequest::new("rev_2", "Edited");
client
.users()
.update_team_member_note("usr/1", "note 1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/notes/note%201"
);
assert_eq!(seen[0].body_json()["body"], "Edited");
}
#[tokio::test]
async fn delete_team_member_note_sends_the_revision_in_the_query() {
let (client, mock) = client_with(vec![Step::ok(CONTACT_PROFILE)]);
client
.users()
.delete_team_member_note("usr/1", "note 1", "rev_2")
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "DELETE");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/notes/note%201?expected_revision=rev_2"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn reset_team_member_password_posts_the_reason() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"user_id":"usr_1","temporary_password":"tmp-pw-1","new_field":1}"#,
)]);
let req = ResetTeamMemberPasswordRequest::new("locked out");
let out = client
.users()
.reset_team_member_password("usr/1", &req)
.await
.unwrap();
assert_eq!(out.temporary_password, "tmp-pw-1");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/reset-password"
);
assert_eq!(seen[0].body_json(), json!({"reason": "locked out"}));
}
#[tokio::test]
async fn retrieve_member_method_access_gets_the_encoded_member() {
let (client, mock) = client_with(vec![Step::ok(METHOD_ACCESS)]);
let out = client
.users()
.retrieve_member_method_access("usr/1")
.await
.unwrap();
assert_eq!(out.methods, ["card"]);
assert_eq!(out.options[0].label, "Card");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/method-access"
);
}
#[tokio::test]
async fn update_member_method_access_puts_the_limited_methods() {
let (client, mock) = client_with(vec![Step::ok(METHOD_ACCESS)]);
let req = UpdateMemberMethodAccessRequest::only(vec!["card".into()], "rev_1");
client
.users()
.update_member_method_access("usr/1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/method-access"
);
assert_eq!(
seen[0].body_json(),
json!({"all_methods": false, "methods": ["card"], "expected_revision": "rev_1"})
);
}
#[tokio::test]
async fn retrieve_member_permission_overrides_decodes_areas() {
let (client, mock) = client_with(vec![Step::ok(PERMISSION_OVERRIDES)]);
let out = client
.users()
.retrieve_member_permission_overrides("usr/1")
.await
.unwrap();
assert_eq!(out.areas[0].override_level.as_deref(), Some("read"));
assert_eq!(out.overrides[0].level, "read");
assert!(out.refusal.is_none());
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/permission-overrides"
);
}
#[tokio::test]
async fn update_member_permission_overrides_puts_the_complete_list() {
let (client, mock) = client_with(vec![Step::ok(PERMISSION_OVERRIDES)]);
let req = UpdateMemberPermissionOverridesRequest::new(
vec![PermissionOverride::new("Operations", "read")],
"rev_1",
);
client
.users()
.update_member_permission_overrides("usr/1", &req)
.await
.unwrap();
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/usr%2F1/permission-overrides"
);
assert_eq!(
seen[0].body_json(),
json!({"overrides": [{"area": "Operations", "level": "read"}],
"expected_revision": "rev_1"})
);
}
#[tokio::test]
async fn create_invitation_link_posts_the_policy_and_decodes_the_token() {
let created = INVITATION_LINK.replacen('{', r#"{"token":"invl-secret-1","#, 1);
let (client, mock) = client_with(vec![Step::ok(&created)]);
let req = CreateInvitationLinkRequest::new(
"Support",
"shop",
"role_1",
10,
"2026-12-01T00:00:00Z",
)
.profile_id("pro_1")
.restrictions(InvitationLinkRestrictions::new().countries("allow", vec!["DE".into()]));
let out = client.users().create_invitation_link(&req).await.unwrap();
assert_eq!(out.token, "invl-secret-1");
assert_eq!(out.link.id, "invl_1");
assert_eq!(out.link.restrictions.countries, ["DE"]);
assert!(!out.link.extra.contains_key("token"));
assert_eq!(out.link.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/invitation-links"
);
assert_eq!(
seen[0].body_json(),
json!({"name": "Support", "target": "shop", "profile_id": "pro_1",
"role_id": "role_1", "max_uses": 10, "expires_at": "2026-12-01T00:00:00Z",
"restrictions": {"country_rule": "allow", "countries": ["DE"]}})
);
}
#[tokio::test]
async fn create_invitation_link_is_not_retried_on_a_5xx() {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::ok(INVITATION_LINK)],
2,
);
let req = CreateInvitationLinkRequest::new("S", "merchant", "role_1", 1, "2026-12-01");
assert!(client.users().create_invitation_link(&req).await.is_err());
assert_eq!(mock.call_count(), 1);
assert!(!mock.seen.lock().unwrap()[0].had_idempotency_key());
}
#[tokio::test]
async fn list_invitation_links_gets_the_collection() {
let (client, mock) = client_with(vec![Step::ok(&format!(
r#"{{"links":[{INVITATION_LINK}],"new_field":1}}"#
))]);
let out = client.users().list_invitation_links().await.unwrap();
assert_eq!(out.links[0].remaining, 8);
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "GET");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/invitation-links"
);
}
#[tokio::test]
async fn update_invitation_link_puts_the_whole_policy() {
let (client, mock) = client_with(vec![Step::ok(INVITATION_LINK)]);
let req = UpdateInvitationLinkRequest::new(
"Support",
20,
"2027-01-01T00:00:00Z",
"2026-01-02T00:00:00Z",
)
.member_expires_at("2027-06-01T00:00:00Z");
let out = client
.users()
.update_invitation_link("invl/1", &req)
.await
.unwrap();
assert_eq!(out.status, "active");
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "PUT");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/invitation-links/invl%2F1"
);
assert_eq!(
seen[0].body_json(),
json!({"name": "Support", "max_uses": 20, "expires_at": "2027-01-01T00:00:00Z",
"member_expires_at": "2027-06-01T00:00:00Z",
"version": "2026-01-02T00:00:00Z"})
);
}
#[tokio::test]
async fn revoke_invitation_link_posts_without_a_body() {
let (client, mock) = client_with(vec![Step::ok(INVITATION_LINK)]);
let out = client
.users()
.revoke_invitation_link("invl/1")
.await
.unwrap();
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/user/employees/invitation-links/invl%2F1/revoke"
);
assert!(seen[0].body.is_none());
}
#[tokio::test]
async fn preview_invitation_link_posts_the_token() {
let (client, mock) = client_with(vec![Step::ok(
r#"{"status":"active","merchant_name":"Acme","target":"merchant",
"target_name":"Acme","role_id":"role_1","role_name":"Admin",
"expires_at":null,"member_expires_at":null,"new_field":1}"#,
)]);
let out = client
.users()
.preview_invitation_link("invl-secret-1")
.await
.unwrap();
assert_eq!(out.merchant_name.as_deref(), Some("Acme"));
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/invitation-link/preview");
assert_eq!(seen[0].body_json(), json!({"token": "invl-secret-1"}));
}
#[tokio::test]
async fn join_invitation_link_posts_the_token() {
let (client, mock) = client_with(vec![Step::ok(JOIN)]);
let out = client
.users()
.join_invitation_link("invl-secret-1")
.await
.unwrap();
assert_eq!(out.outcome, "joined");
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(seen[0].url, "https://api.test/user/invitation-link/join");
assert_eq!(seen[0].body_json(), json!({"token": "invl-secret-1"}));
}
#[tokio::test]
async fn join_invitation_link_pre_auth_posts_the_token_and_decodes_the_next_one() {
let body = JOIN.replacen('{', r#"{"token":"spt-next-1","token_type":"totp","#, 1);
let (client, mock) = client_with(vec![Step::ok(&body)]);
let out = client
.users()
.join_invitation_link_pre_auth("invl-secret-1")
.await
.unwrap();
assert_eq!(out.token, "spt-next-1");
assert_eq!(out.token_type, "totp");
assert_eq!(out.join.role_name, "Admin");
assert!(!out.join.extra.contains_key("token"));
assert_eq!(out.join.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/user/invitation-link/join/pre-auth"
);
assert_eq!(seen[0].body_json(), json!({"token": "invl-secret-1"}));
}
#[tokio::test]
async fn register_through_invitation_link_posts_the_account() {
let (client, mock) = client_with(vec![Step::ok(r#"{"is_email_sent":true,"new_field":1}"#)]);
let req = RegisterThroughInvitationLinkRequest::new(
"invl-secret-1",
"Bob",
"bob@example.com",
"pw-3",
);
let out = client
.users()
.register_through_invitation_link(&req)
.await
.unwrap();
assert!(out.is_email_sent);
assert_eq!(out.extra["new_field"], 1);
let seen = mock.seen.lock().unwrap();
assert_eq!(seen[0].method, "POST");
assert_eq!(
seen[0].url,
"https://api.test/user/invitation-link/register"
);
assert_eq!(
seen[0].body_json(),
json!({"token": "invl-secret-1", "name": "Bob", "email": "bob@example.com",
"password": "pw-3"})
);
}
#[test]
fn oauth_link_start_request_debug_redacts_the_password() {
let req = DashboardOAuthLinkStartRequest::new("github", "admin", "hash", "pw-secret-a");
let rendered = format!("{req:?}");
assert!(!rendered.contains("pw-secret-a"), "{rendered}");
assert!(rendered.contains("github"), "{rendered}");
}
#[test]
fn oauth_complete_request_debug_redacts_ticket_and_verifier() {
let req = DashboardOAuthCompleteRequest::new("tkt-secret", "ver-secret", "merchant");
let rendered = format!("{req:?}");
assert!(!rendered.contains("tkt-secret"), "{rendered}");
assert!(!rendered.contains("ver-secret"), "{rendered}");
assert!(rendered.contains("merchant"), "{rendered}");
}
#[test]
fn oauth_disconnect_request_debug_redacts_the_password() {
let rendered = format!("{:?}", DashboardOAuthDisconnectRequest::new("pw-secret-b"));
assert!(!rendered.contains("pw-secret-b"), "{rendered}");
}
#[test]
fn register_through_invitation_link_request_debug_redacts_token_and_password() {
let req = RegisterThroughInvitationLinkRequest::new(
"invl-secret-x",
"Bob",
"bob@example.com",
"pw-secret-c",
);
let rendered = format!("{req:?}");
assert!(!rendered.contains("invl-secret-x"), "{rendered}");
assert!(!rendered.contains("pw-secret-c"), "{rendered}");
assert!(rendered.contains("Bob"), "{rendered}");
}
fn de<T: serde::de::DeserializeOwned>(json: &str) -> T {
serde_json::from_str(json).expect("fixture deserializes")
}
#[test]
fn oauth_start_response_debug_redacts_the_url() {
let res: crate::core::models::user::DashboardOAuthStartResponse = de(OAUTH_START);
let rendered = format!("{res:?}");
assert!(!rendered.contains("st-secret-1"), "{rendered}");
}
#[test]
fn invite_link_response_debug_redacts_the_link() {
let res: crate::core::models::user::InviteLinkResponse =
de(r#"{"availability":"available","link":"https://dash.example/i?t=link-secret"}"#);
let rendered = format!("{res:?}");
assert!(!rendered.contains("link-secret"), "{rendered}");
assert!(rendered.contains("Some("), "{rendered}");
let none: crate::core::models::user::InviteLinkResponse =
de(r#"{"availability":"no_link"}"#);
assert!(format!("{none:?}").contains("link: None"));
}
#[test]
fn reset_team_member_password_response_debug_redacts_the_password() {
let res: crate::core::models::user::ResetTeamMemberPasswordResponse =
de(r#"{"user_id":"usr_1","temporary_password":"tmp-secret"}"#);
let rendered = format!("{res:?}");
assert!(!rendered.contains("tmp-secret"), "{rendered}");
assert!(rendered.contains("usr_1"), "{rendered}");
}
#[test]
fn create_invitation_link_response_debug_redacts_the_token() {
let created = INVITATION_LINK.replacen('{', r#"{"token":"invl-secret-z","#, 1);
let res: crate::core::models::user::CreateInvitationLinkResponse = de(&created);
let rendered = format!("{res:?}");
assert!(!rendered.contains("invl-secret-z"), "{rendered}");
assert!(rendered.contains("invl_1"), "{rendered}");
}
#[test]
fn join_invitation_link_pre_auth_response_debug_redacts_the_token() {
let body = JOIN.replacen('{', r#"{"token":"spt-secret-z","token_type":"totp","#, 1);
let res: crate::core::models::user::JoinInvitationLinkPreAuthResponse = de(&body);
let rendered = format!("{res:?}");
assert!(!rendered.contains("spt-secret-z"), "{rendered}");
assert!(rendered.contains("totp"), "{rendered}");
}
fn keyed_client_over_503s() -> (
crate::Delopay,
std::sync::Arc<crate::http::mock::MockTransport>,
) {
let (client, mock) = crate::http::mock::client_with_retries(
vec![Step::status(503, "{}"), Step::status(503, "{}")],
2,
);
(client.with_idempotency_key("client-wide-key"), mock)
}
fn assert_sent_once_unkeyed(mock: &crate::http::mock::MockTransport) {
assert_eq!(mock.call_count(), 1, "a 503 was replayed");
assert!(
!mock.seen.lock().unwrap()[0].had_idempotency_key(),
"the client-wide key was inherited"
);
}
#[tokio::test]
async fn one_shot_sign_in_steps_do_not_inherit_the_client_key() {
let (client, mock) = keyed_client_over_503s();
let params = DashboardOAuthCompleteRequest::new("ticket", "verifier", "merchant");
assert!(
client
.users()
.complete_oauth_sign_in(¶ms)
.await
.is_err()
);
assert_sent_once_unkeyed(&mock);
let (client, mock) = keyed_client_over_503s();
assert!(client.users().refresh_token().await.is_err());
assert_sent_once_unkeyed(&mock);
let (client, mock) = keyed_client_over_503s();
assert!(client.users().join_invitation_link("tok").await.is_err());
assert_sent_once_unkeyed(&mock);
}
}