@kasuvia/sdk 0.0.7 → 0.0.9

package/src/services/auth.service.ts

@@ -4,75 +4,88 @@
  */
 import type { SdkConfig } from '../config'
 import { STORAGE_KEYS } from '../constants'
+import { apiRequest, ApiError, storefrontHeaders, authHeaders, JSON_HEADERS } from '../utils/http-client'
+import { buildFullName, splitFullName } from '../utils/customer'
 import type {
   CustomerAuthResponse,
   CustomerLoginPayload,
   CustomerRegisterPayload,
+  CustomerPasswordlessRequestPayload,
+  CustomerPasswordlessVerifyPayload,
+  CustomerForgotPasswordPayload,
+  CustomerResetPasswordPayload,
+  CustomerDeactivatePayload,
+  DeactivateAccountResult,
+  DeactivateConfirmationRequired,
+  CustomerReactivatePayload,
+  CustomerReactivateVerifyPayload,
   LogoutPayload,
   RefreshTokenResponse,
   CustomerUser,
   AuthUserResponse,
   UpdateProfilePayload,
+  StorefrontBusinessInfo,
+  ChangePasswordPayload,
+  CustomerAddress,
+  CreateCustomerAddressPayload,
+  UpdateCustomerAddressPayload,
 } from '../types/auth'
 
+import type { MediaAsset } from '../types/media'
+
 // ── Auth API Calls ────────────────────────────────────────────────────────────
 
 /**
  * POST /auth/login/customer/
- * The `tenant_id` is automatically filled from config.businessId.
+ * Business is identified by the X-Storefront-Key + X-Business-ID headers
+ * (config.storefrontApiKey / config.businessId) — never a body field (see
+ * plan: Customer Storefront Identity Enforcement).
  */
 export async function loginCustomer(
   config: SdkConfig,
-  payload: Omit<CustomerLoginPayload, 'tenant_id'>
+  payload: CustomerLoginPayload,
+  guestSessionId?: string | null
 ): Promise<CustomerAuthResponse> {
-  const response = await fetch(`${config.backendUrls.auth}/auth/login/customer/`, {
+  const headers: Record<string, string> = { ...JSON_HEADERS, ...storefrontHeaders(config) }
+  // REAL FEATURE FOUND (2026-09-21): kasuvia-auth's login/register/OTP-verify
+  // views already run a real server-side guest-cart merge the moment tokens
+  // are minted (customer.py's _run_post_login_merge, reading this exact
+  // header) — deliberately built to replace depending on a frontend
+  // remembering to call kasuvia-cart-management's /cart/merge afterward (see
+  // cart_merge_client.py's own doc comment). This was simply never wired:
+  // nothing in the storefront ever sent this header on login.
+  if (guestSessionId) {
+    headers['X-Guest-Session'] = guestSessionId
+  }
+  return apiRequest<CustomerAuthResponse>(`${config.backendUrls.auth}/auth/login/customer/`, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'X-Storefront-Key': config.storefrontApiKey,
-      'X-Business-ID': config.businessId,
-    },
-    body: JSON.stringify({
-      ...payload,
-      tenant_id: config.businessId,
-    }),
+    headers,
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Login failed',
   })
-
-  if (!response.ok) {
-    throw new Error('Login failed')
-  }
-
-  const data = await response.json()
-  return data
 }
 
 /**
  * POST /auth/register/customer/
- * The `tenant_id` is automatically filled from config.businessId.
+ * Business identified via headers, see loginCustomer.
  */
 export async function registerCustomer(
   config: SdkConfig,
-  payload: Omit<CustomerRegisterPayload, 'tenant_id'>
+  payload: CustomerRegisterPayload,
+  guestSessionId?: string | null
 ): Promise<CustomerAuthResponse> {
-  const response = await fetch(`${config.backendUrls.auth}/auth/register/customer/`, {
+  const headers: Record<string, string> = { ...JSON_HEADERS, ...storefrontHeaders(config) }
+  // See loginCustomer's identical comment — same real, already-built
+  // server-side merge, same header.
+  if (guestSessionId) {
+    headers['X-Guest-Session'] = guestSessionId
+  }
+  return apiRequest<CustomerAuthResponse>(`${config.backendUrls.auth}/auth/register/customer/`, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'X-Storefront-Key': config.storefrontApiKey,
-      'X-Business-ID': config.businessId,
-    },
-    body: JSON.stringify({
-      ...payload,
-      tenant_id: config.businessId,
-    }),
+    headers,
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Registration failed',
   })
-
-  if (!response.ok) {
-    throw new Error('Registration failed')
-  }
-
-  const data = await response.json()
-  return data
 }
 
 /** POST /auth/token/refresh/
@@ -81,38 +94,44 @@ export async function refreshToken(
   config: SdkConfig,
   refresh: string
 ): Promise<RefreshTokenResponse> {
-  const response = await fetch(`${config.backendUrls.auth}/auth/token/refresh/`, {
+  return apiRequest<RefreshTokenResponse>(`${config.backendUrls.auth}/auth/token/refresh/`, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
+    headers: JSON_HEADERS,
     body: JSON.stringify({ refresh }),
+    fallbackErrorMessage: 'Token refresh failed',
   })
-
-  if (!response.ok) {
-    throw new Error('Token refresh failed')
-  }
-
-  const data = await response.json()
-  return data
 }
 
-/** POST /auth/logout/ — revokes the server-side session. */
+/**
+ * POST /auth/logout/ — revokes the server-side session.
+ *
+ * Never throws: a customer's own logout must always clear their local
+ * session client-side (caller does this regardless of this promise's
+ * outcome) even if the backend is unreachable — an unrevoked server-side
+ * session in that case is a availability tradeoff, not a security one (the
+ * refresh token still expires on its own TTL). What CLAUDE.md forbids is
+ * failing SILENTLY; the failure is now always logged with real context so
+ * it's visible to whoever is debugging a report of "sessions not clearing
+ * server-side", instead of vanishing into a bare `catch {}`.
+ */
 export async function logout(
   config: SdkConfig,
   refresh?: string
 ): Promise<void> {
   const payload: LogoutPayload = refresh ? { refresh } : {}
   try {
-    await fetch(`${config.backendUrls.auth}/auth/logout/`, {
+    await apiRequest(`${config.backendUrls.auth}/auth/logout/`, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
+      headers: JSON_HEADERS,
       body: JSON.stringify(payload),
+      fallbackErrorMessage: 'Server-side logout failed',
     })
-  } catch {
-    // Swallow server errors
+  } catch (err) {
+    if (err instanceof ApiError) {
+      console.error(`[auth.service] Server-side logout failed with status ${err.status}; local session will still be cleared.`)
+    } else {
+      console.error('[auth.service] Server-side logout request failed; local session will still be cleared.', err)
+    }
   }
 }
 
@@ -124,25 +143,154 @@ export async function verifySocialToken(
   provider: 'google' | 'facebook',
   token: string
 ): Promise<CustomerAuthResponse> {
-  const response = await fetch(`${config.backendUrls.auth}/auth/social/verify/${provider}/`, {
+  return apiRequest<CustomerAuthResponse>(`${config.backendUrls.auth}/auth/social/verify/${provider}/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...storefrontHeaders(config) },
+    body: JSON.stringify({ id_token: token }),
+    fallbackErrorMessage: 'Social token verification failed',
+  })
+}
+
+/**
+ * POST /auth/login/customer/passwordless/request/
+ * Sends a one-time login code to the customer's email. Always resolves
+ * successfully (the backend never reveals whether the email is registered).
+ * Business identified via headers, see loginCustomer.
+ */
+export async function requestCustomerOtp(
+  config: SdkConfig,
+  payload: CustomerPasswordlessRequestPayload
+): Promise<void> {
+  await apiRequest(`${config.backendUrls.auth}/auth/login/customer/passwordless/request/`, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      id_token: token,
-      storefront_key: config.storefrontApiKey,
-    }),
+    headers: { ...JSON_HEADERS, ...storefrontHeaders(config) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to send login code',
   })
+}
 
-  if (!response.ok) {
-    throw new Error('Social token verification failed')
+/**
+ * POST /auth/login/customer/passwordless/verify/
+ * Verifies a one-time login code and returns tokens, auto-creating the
+ * customer account on first use (same as social login).
+ * Business identified via headers, see loginCustomer.
+ */
+export async function verifyCustomerOtp(
+  config: SdkConfig,
+  payload: CustomerPasswordlessVerifyPayload,
+  guestSessionId?: string | null
+): Promise<CustomerAuthResponse> {
+  const headers: Record<string, string> = { ...JSON_HEADERS, ...storefrontHeaders(config) }
+  // See loginCustomer's identical comment — same real, already-built
+  // server-side merge, same header.
+  if (guestSessionId) {
+    headers['X-Guest-Session'] = guestSessionId
   }
+  return apiRequest<CustomerAuthResponse>(`${config.backendUrls.auth}/auth/login/customer/passwordless/verify/`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Invalid or expired code',
+  })
+}
 
-  const data = await response.json()
-  return data
+/**
+ * POST /auth/forgot-password/customer/
+ * Request a customer password reset OTP (business-scoped via headers).
+ */
+export async function forgotPasswordCustomer(
+  config: SdkConfig,
+  payload: CustomerForgotPasswordPayload
+): Promise<{ detail: string }> {
+  return apiRequest<{ detail: string }>(`${config.backendUrls.auth}/auth/forgot-password/customer/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...storefrontHeaders(config) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to request password reset',
+  })
+}
+
+/**
+ * POST /auth/reset-password/customer/
+ * Verify OTP and reset customer password (business-scoped via headers).
+ */
+export async function resetPasswordCustomer(
+  config: SdkConfig,
+  payload: CustomerResetPasswordPayload
+): Promise<{ detail: string }> {
+  return apiRequest<{ detail: string }>(`${config.backendUrls.auth}/auth/reset-password/customer/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...storefrontHeaders(config) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Invalid or expired reset code',
+  })
+}
+
+/**
+ * POST /auth/customer/deactivate/
+ * Self-service account deactivation for customers.
+ */
+export async function deactivateCustomerAccount(
+  config: SdkConfig,
+  accessToken: string,
+  payload?: CustomerDeactivatePayload
+): Promise<DeactivateAccountResult> {
+  try {
+    const data = await apiRequest<{ detail: string }>(`${config.backendUrls.auth}/auth/customer/deactivate/`, {
+      method: 'POST',
+      headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
+      body: JSON.stringify(payload || {}),
+      fallbackErrorMessage: 'Failed to deactivate account',
+    })
+    return { status: 'success', detail: data.detail }
+  } catch (err) {
+    // REAL BUG FIXED (2026-09-20): a 409 here is NOT a failure — it's step 1
+    // of require_destructive_confirmation's real two-step contract (see
+    // DeactivateConfirmationRequired's doc comment). The FIRST call with no
+    // confirmation_code ALWAYS 409s by design, so this function as written
+    // before could never actually succeed — it threw a generic Error on every
+    // real call, discarding the impact list and confirmation_code the caller
+    // needs to complete the flow.
+    if (err instanceof ApiError && err.status === 409) {
+      return { status: 'confirmation_required', data: err.body as DeactivateConfirmationRequired }
+    }
+    throw err
+  }
+}
+
+/**
+ * POST /auth/customer/reactivate/
+ * Request reactivation code for a deactivated customer account.
+ */
+export async function requestCustomerReactivation(
+  config: SdkConfig,
+  payload: CustomerReactivatePayload
+): Promise<{ detail: string }> {
+  return apiRequest<{ detail: string }>(`${config.backendUrls.auth}/auth/customer/reactivate/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...storefrontHeaders(config) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to request reactivation',
+  })
+}
+
+/**
+ * POST /auth/customer/reactivate/verify/
+ * Verify reactivation OTP and restore customer account.
+ */
+export async function verifyCustomerReactivation(
+  config: SdkConfig,
+  payload: CustomerReactivateVerifyPayload
+): Promise<{ detail: string }> {
+  return apiRequest<{ detail: string }>(`${config.backendUrls.auth}/auth/customer/reactivate/verify/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...storefrontHeaders(config) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Invalid or expired reactivation code',
+  })
 }
 
+
 /** Decode a JWT payload without verifying signature (client-side use only). */
 function parseJwtPayload(token: string): Record<string, unknown> {
   try {
@@ -211,47 +359,38 @@ function buildCustomerFromClaims(claims: Record<string, unknown>): CustomerUser
 /** GET /auth/profile/ */
 export async function getMe(config?: SdkConfig, accessToken?: string): Promise<CustomerUser> {
   if (!config || !accessToken) {
-    const response = await fetch('/api/auth/me', { credentials: 'include' })
-    if (!response.ok) throw new Error('Failed to fetch profile')
-    const data = await response.json()
-    return data.user
+    // `/api/auth/me` proxies the raw AuthUserResponse shape (nested
+    // `.profile.firstname` etc) under `data.user` — it must be mapped the
+    // same way the config+accessToken branch below maps it, otherwise every
+    // field on the returned "CustomerUser" is silently undefined.
+    const data = await apiRequest<{ user: AuthUserResponse }>('/api/auth/me', {
+      credentials: 'include',
+      fallbackErrorMessage: 'Failed to fetch profile',
+    })
+    return mapAuthUserToCustomer(data.user)
   }
 
-  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
-    headers: {
-      'Authorization': `Bearer ${accessToken}`,
-    },
+  const data = await apiRequest<AuthUserResponse>(`${config.backendUrls.auth}/auth/profile/`, {
+    headers: authHeaders(config, accessToken),
+    fallbackErrorMessage: 'Failed to fetch profile',
   })
-
-  if (!response.ok) {
-    throw new Error('Failed to fetch profile')
-  }
-
-  const data = await response.json()
   return mapAuthUserToCustomer(data)
 }
 
 /** GET /auth/profile/ - alias for getMe for backward compatibility */
 export async function getAuthUser(config?: SdkConfig, accessToken?: string): Promise<AuthUserResponse> {
   if (!config || !accessToken) {
-    const response = await fetch('/api/auth/me', { credentials: 'include' })
-    if (!response.ok) throw new Error('Failed to fetch auth user')
-    const data = await response.json()
+    const data = await apiRequest<{ user: AuthUserResponse }>('/api/auth/me', {
+      credentials: 'include',
+      fallbackErrorMessage: 'Failed to fetch auth user',
+    })
     return data.user
   }
 
-  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
-    headers: {
-      'Authorization': `Bearer ${accessToken}`,
-    },
+  return apiRequest<AuthUserResponse>(`${config.backendUrls.auth}/auth/profile/`, {
+    headers: authHeaders(config, accessToken),
+    fallbackErrorMessage: 'Failed to fetch auth user',
   })
-
-  if (!response.ok) {
-    throw new Error('Failed to fetch auth user')
-  }
-
-  const data = await response.json()
-  return data
 }
 
 /** PUT /auth/profile/ — update firstname, lastname, phone */
@@ -263,35 +402,148 @@ export async function updateProfile(
   const isArg1Config = typeof configOrPayload === 'object' && configOrPayload !== null && 'businessId' in configOrPayload
   if (!isArg1Config) {
     const payload = configOrPayload as UpdateProfilePayload
-    const response = await fetch('/api/auth/profile', {
+    return apiRequest<CustomerUser>('/api/auth/profile', {
       method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
+      headers: JSON_HEADERS,
       credentials: 'include',
       body: JSON.stringify(payload),
+      fallbackErrorMessage: 'Failed to update profile',
     })
-    if (!response.ok) throw new Error('Failed to update profile')
-    return response.json()
   }
 
   const config = configOrPayload as SdkConfig
   const accessToken = accessTokenOrPayload as string
   const payload = payloadParam as UpdateProfilePayload
 
-  const response = await fetch(`${config.backendUrls.auth}/auth/profile/`, {
+  // REAL BUG FIXED (2026-09-20): hardcoded generic message discarded real
+  // CustomerProfileUpdateSerializer validation errors (e.g. invalid phone
+  // format) — apiRequest's shared extractor handles this DRF dict shape.
+  const data = await apiRequest<AuthUserResponse>(`${config.backendUrls.auth}/auth/profile/`, {
     method: 'PUT',
-    headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${accessToken}`,
-    },
+    headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
     body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to update profile',
   })
+  return mapAuthUserToCustomer(data)
+}
 
-  if (!response.ok) {
-    throw new Error('Failed to update profile')
-  }
+/**
+ * POST /auth/change-password/ — identity-mode-agnostic; the backend
+ * branches on the JWT's identity_mode (kasuvia-auth/authentication/api/v1/
+ * views/core.py:353, ChangePasswordView) to mutate the right underlying
+ * profile (customer/staff/owner). Used here for a logged-in storefront
+ * customer. `old_password` may be omitted only if the account genuinely has
+ * no password yet (a social/passwordless-only customer setting one for the
+ * first time) — the backend itself enforces this, not the frontend.
+ */
+export async function changePassword(
+  config: SdkConfig,
+  accessToken: string,
+  payload: ChangePasswordPayload
+): Promise<{ detail: string }> {
+  return apiRequest<{ detail: string }>(`${config.backendUrls.auth}/auth/change-password/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to change password',
+  })
+}
 
-  const data = await response.json()
-  return mapAuthUserToCustomer(data)
+/**
+ * GET /auth/storefront/business-info/
+ * Public, unauthenticated — only needs the storefront key (no access token,
+ * no X-Business-ID; PublicBusinessInfoView resolves the business from the
+ * key itself). Real gap fixed 2026-09-17: this endpoint existed on the
+ * backend with zero SDK coverage.
+ */
+export async function getStorefrontBusinessInfo(config: SdkConfig): Promise<StorefrontBusinessInfo> {
+  // PublicBusinessInfoView resolves the business from X-Storefront-Key alone
+  // and never reads X-Business-ID — storefrontHeaders() sends both anyway
+  // for consistency with every other call site; the extra header is inert
+  // here (verified against the real view before making this change).
+  return apiRequest<StorefrontBusinessInfo>(`${config.backendUrls.auth}/auth/storefront/business-info/`, {
+    headers: storefrontHeaders(config),
+    fallbackErrorMessage: 'Failed to fetch business info',
+  })
+}
+
+export interface PresignedUploadUrlParams {
+  filename: string
+  content_type: string
+  business_id: string
+  context: string
+  entity_id: string
+  owner_id?: string
+  affiliation?: string
+}
+
+export interface PresignedUploadUrlResponse {
+  presigned_url: string
+  storage_path: string
+  bucket: string
+  expires_in: number
+  asset_id?: string
+}
+
+/**
+ * POST /auth/media/presigned-url/ — kasuvia-auth's thin proxy in front of
+ * kasuvia-media-system. Params are sent as a query string (not a JSON
+ * body) to match every other caller of this endpoint.
+ */
+export async function getPresignedUploadUrl(
+  config: SdkConfig,
+  accessToken: string,
+  params: PresignedUploadUrlParams
+): Promise<PresignedUploadUrlResponse> {
+  const query = new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v !== undefined) as [string, string][]
+  )
+  // Bearer-only, deliberately not storefrontHeaders() — this endpoint's real
+  // header contract was never verified to also accept/require X-Storefront-
+  // Key/X-Business-ID, unlike getStorefrontBusinessInfo above.
+  return apiRequest<PresignedUploadUrlResponse>(
+    `${config.backendUrls.auth}/auth/media/presigned-url/?${query.toString()}`,
+    {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${accessToken}` },
+      fallbackErrorMessage: 'Failed to get presigned upload URL',
+    }
+  )
+}
+
+export interface ConfirmMediaUploadParams {
+  storage_path: string
+  business_id: string
+  entity_id: string
+  original_filename: string
+  content_type: string
+  size: number
+  context: string
+  owner_id?: string
+  affiliation?: string
+}
+
+/**
+ * POST /auth/media/confirm-upload/ — confirms a completed direct-to-R2
+ * upload and returns the resulting MediaAsset. Params are sent as a query
+ * string (not a JSON body) to match every other caller of this endpoint.
+ */
+export async function confirmMediaUpload(
+  config: SdkConfig,
+  accessToken: string,
+  params: ConfirmMediaUploadParams
+): Promise<MediaAsset> {
+  const query = new URLSearchParams(
+    Object.entries(params).filter(([, v]) => v !== undefined) as [string, string][]
+  )
+  return apiRequest<MediaAsset>(
+    `${config.backendUrls.auth}/auth/media/confirm-upload/?${query.toString()}`,
+    {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${accessToken}` },
+      fallbackErrorMessage: 'Failed to confirm upload',
+    }
+  )
 }
 
 /**
@@ -312,32 +564,17 @@ export async function silentRefresh(
     const user = buildCustomerFromClaims(claims)
     const provider = user.provider
     return { user, provider, newAccessToken: data.access, newRefreshToken: data.refresh }
-  } catch {
+  } catch (err) {
+    // REAL BUG FIXED (2026-09-20): bare `catch {}` silently discarded the
+    // real reason (network failure vs. an actually-revoked/expired refresh
+    // token) — `null` here correctly means "not currently logged in" to the
+    // caller (a legitimate outcome, not swallowed), but CLAUDE.md still
+    // requires the failure itself be logged, not silently dropped.
+    console.error('[auth.service] Silent token refresh failed:', err)
     return null
   }
 }
 
-// ── Helper Functions ─────────────────────────────────────────────────────────
-
-function buildFullName(firstname?: string, lastname?: string): string {
-  if (firstname && lastname) return `${firstname} ${lastname}`
-  return firstname || lastname || ''
-}
-
-function splitFullName(fullName?: string): { firstname: string; lastname: string } {
-  if (!fullName) return { firstname: '', lastname: '' }
-
-  const parts = fullName.trim().split(/\s+/)
-  if (parts.length === 1) {
-    return { firstname: parts[0], lastname: '' }
-  }
-
-  return {
-    firstname: parts[0],
-    lastname: parts.slice(1).join(' ')
-  }
-}
-
 /**
  * Store tokens in localStorage (client-side utility)
  * This is a convenience function for storefronts to store auth tokens
@@ -371,3 +608,56 @@ export function getStoredTokens(): { accessToken: string | null; refreshToken: s
     refreshToken: localStorage.getItem(STORAGE_KEYS.REFRESH_TOKEN),
   }
 }
+
+// ── Customer saved-address book ─────────────────────────────────────────────
+// REAL FEATURE WIRED (2026-09-22): CustomerProfile.address_book existed as a
+// backend JSONField with no real write path anywhere (see
+// CustomerAddressListView's own doc comment in kasuvia-auth). This is the
+// SDK-side coverage for the real, now-validated endpoints.
+
+/** GET /auth/profile/addresses/ */
+export async function getCustomerAddresses(config: SdkConfig, accessToken: string): Promise<CustomerAddress[]> {
+  const data = await apiRequest<{ results: CustomerAddress[] }>(`${config.backendUrls.auth}/auth/profile/addresses/`, {
+    headers: authHeaders(config, accessToken),
+    fallbackErrorMessage: 'Failed to fetch saved addresses',
+  })
+  return data.results
+}
+
+/** POST /auth/profile/addresses/ */
+export async function createCustomerAddress(
+  config: SdkConfig,
+  accessToken: string,
+  payload: CreateCustomerAddressPayload
+): Promise<CustomerAddress> {
+  return apiRequest<CustomerAddress>(`${config.backendUrls.auth}/auth/profile/addresses/`, {
+    method: 'POST',
+    headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to save address',
+  })
+}
+
+/** PATCH /auth/profile/addresses/{id}/ */
+export async function updateCustomerAddress(
+  config: SdkConfig,
+  accessToken: string,
+  addressId: string,
+  payload: UpdateCustomerAddressPayload
+): Promise<CustomerAddress> {
+  return apiRequest<CustomerAddress>(`${config.backendUrls.auth}/auth/profile/addresses/${addressId}/`, {
+    method: 'PATCH',
+    headers: { ...JSON_HEADERS, ...authHeaders(config, accessToken) },
+    body: JSON.stringify(payload),
+    fallbackErrorMessage: 'Failed to update address',
+  })
+}
+
+/** DELETE /auth/profile/addresses/{id}/ */
+export async function deleteCustomerAddress(config: SdkConfig, accessToken: string, addressId: string): Promise<void> {
+  await apiRequest(`${config.backendUrls.auth}/auth/profile/addresses/${addressId}/`, {
+    method: 'DELETE',
+    headers: authHeaders(config, accessToken),
+    fallbackErrorMessage: 'Failed to delete address',
+  })
+}