@kasuvia/sdk 0.0.2 → 0.0.5

package/src/services/consultation.service.ts

@@ -2,8 +2,9 @@
  * Consultation Service
  * 
  * Handles consultation operations for bespoke and service products.
+ * Stateless - all configuration passed as parameters.
  */
-import { storeManagementAxios } from '../client/httpClient'
+import type { SdkConfig } from '../config'
 import type {
   Consultation,
   ConsultationCreatePayload,
@@ -11,33 +12,86 @@ import type {
   ConsultationQuoteAcceptPayload,
 } from '../types/consultations'
 
-export async function createConsultation(payload: ConsultationCreatePayload): Promise<Consultation> {
-  const { data } = await storeManagementAxios.post<Consultation>('social/consultations/', payload)
-  return data
+export async function createConsultation(config: SdkConfig, accessToken: string, payload: ConsultationCreatePayload): Promise<Consultation> {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to create consultation')
+  return response.json()
 }
 
-export async function getConsultations(): Promise<Consultation[]> {
-  const { data } = await storeManagementAxios.get<Consultation[]>('social/consultations/')
-  return data
+export async function getConsultations(config: SdkConfig, accessToken: string): Promise<Consultation[]> {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to get consultations')
+  return response.json()
 }
 
-export async function getConsultation(id: string): Promise<Consultation> {
-  const { data } = await storeManagementAxios.get<Consultation>(`social/consultations/${id}`)
-  return data
+export async function getConsultation(config: SdkConfig, accessToken: string, id: string): Promise<Consultation> {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}`, {
+    headers: {
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to get consultation')
+  return response.json()
 }
 
-export async function sendMessage(id: string, payload: ConsultationMessagePayload): Promise<void> {
-  await storeManagementAxios.post(`social/consultations/${id}/messages`, payload)
+export async function sendMessage(config: SdkConfig, accessToken: string, id: string, payload: ConsultationMessagePayload): Promise<void> {
+  await fetch(`${config.backendUrls.store}/social/consultations/${id}/messages`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
 }
 
-export async function acceptQuote(id: string, payload: ConsultationQuoteAcceptPayload): Promise<Consultation> {
-  const { data } = await storeManagementAxios.post<Consultation>(`social/consultations/${id}/accept-quote`, payload)
-  return data
+export async function acceptQuote(config: SdkConfig, accessToken: string, id: string, payload: ConsultationQuoteAcceptPayload): Promise<Consultation> {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/accept-quote`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to accept quote')
+  return response.json()
 }
 
-export async function rejectQuote(id: string, reason?: string): Promise<Consultation> {
-  const { data } = await storeManagementAxios.post<Consultation>(`social/consultations/${id}/reject-quote`, { reason })
-  return data
+export async function rejectQuote(config: SdkConfig, accessToken: string, id: string, reason?: string): Promise<Consultation> {
+  const response = await fetch(`${config.backendUrls.store}/social/consultations/${id}/reject-quote`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify({ reason }),
+  })
+  if (!response.ok) throw new Error('Failed to reject quote')
+  return response.json()
 }
 
 // Service object export for backward compatibility

package/src/services/logistics.service.ts

@@ -2,8 +2,9 @@
  * Logistics Service
  * 
  * Handles shipping rates and address validation.
+ * Stateless - all configuration passed as parameters.
  */
-import { storeManagementAxios } from '../client/httpClient'
+import type { SdkConfig } from '../config'
 import type { ShippingRatesResponse } from '../types/store/shipping'
 import type { Product, ProductVariant } from '../types/store'
 
@@ -34,19 +35,26 @@ export interface ShippingRatesRequest {
  * Fetch shipping rates for a cart.
  */
 export async function getShippingRates(
+  config: SdkConfig,
   payload: ShippingRatesRequest
 ): Promise<ShippingRatesResponse> {
-  const { data } = await storeManagementAxios.post<ShippingRatesResponse>(
-    'logistics/shipping/rates',
-    payload
-  )
-  return data
+  const response = await fetch(`${config.backendUrls.store}/logistics/shipping/rates`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to get shipping rates')
+  return response.json()
 }
 
 /**
  * Fetch the seller's registered shipping address.
  */
-export async function getSellerShippingAddress(): Promise<{
+export async function getSellerShippingAddress(config: SdkConfig): Promise<{
   terminal_address_id: string | null
   address_details: {
     city: string
@@ -59,14 +67,21 @@ export async function getSellerShippingAddress(): Promise<{
   business_id: string
   message: string
 }> {
-  const { data } = await storeManagementAxios.get('logistics/shipping-address')
-  return data
+  const response = await fetch(`${config.backendUrls.store}/logistics/shipping-address`, {
+    headers: {
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to get seller shipping address')
+  return response.json()
 }
 
 /**
  * Validate a shipping address.
  */
 export async function validateShippingAddress(
+  config: SdkConfig,
   payload: {
     first_name: string
     last_name: string
@@ -83,8 +98,17 @@ export async function validateShippingAddress(
   message?: string
   data?: Array<{ name: string; city_id: string; stateCode: string; countryCode: string }>
 }> {
-  const { data } = await storeManagementAxios.post('logistics/shipping-address/validate', payload)
-  return data
+  const response = await fetch(`${config.backendUrls.store}/logistics/shipping-address/validate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to validate shipping address')
+  return response.json()
 }
 
 // Service object for backward compatibility

package/src/services/notifications.service.ts

@@ -2,8 +2,9 @@
  * Notification Service
  * 
  * Handles contact form submissions and email notifications.
+ * Stateless - all configuration passed as parameters.
  */
-import { notificationsAxios } from '../client/httpClient'
+import type { SdkConfig } from '../config'
 
 export interface ContactFormData {
   name: string
@@ -17,17 +18,24 @@ export interface ContactFormData {
 }
 
 /**
- * Send contact email to Luxe team.
+ * Send contact email to Kasuvia team.
  * POST /contact/send-contact-email
  */
 export async function sendContactEmail(
+  config: SdkConfig,
   payload: ContactFormData
 ): Promise<{ detail: string }> {
-  const { data } = await notificationsAxios.post<{ detail: string }>(
-    'contact/send-contact-email',
-    payload
-  )
-  return data
+  const response = await fetch(`${config.backendUrls.notifications}/contact/send-contact-email`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to send contact email')
+  return response.json()
 }
 
 /**
@@ -35,13 +43,20 @@ export async function sendContactEmail(
  * POST /contact/send-contact-confirmation
  */
 export async function sendContactConfirmation(
+  config: SdkConfig,
   payload: Omit<ContactFormData, 'turnstile_token'>
 ): Promise<{ detail: string }> {
-  const { data } = await notificationsAxios.post<{ detail: string }>(
-    'contact/send-contact-confirmation',
-    payload
-  )
-  return data
+  const response = await fetch(`${config.backendUrls.notifications}/contact/send-contact-confirmation`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to send contact confirmation')
+  return response.json()
 }
 
 export const notificationsService = {

package/src/services/order.service.ts

@@ -2,8 +2,9 @@
  * Order Service
  * 
  * Handles order operations including creation, lookup, and tracking.
+ * Stateless - all configuration passed as parameters.
  */
-import { storeManagementAxios, publicStoreAxios } from '../client/httpClient'
+import type { SdkConfig } from '../config'
 import type { Order, OrderStatus, FindOrderParams, CreateOrderParams, OrderItem } from '../types/store'
 import type { DeliveryAddress } from '../types/store'
 
@@ -133,37 +134,95 @@ function normaliseStorefrontOrder(raw: RawOrder): Order {
   }
 }
 
-export async function createOrder(payload: CreateOrderParams): Promise<Order> {
-  const { data } = await storeManagementAxios.post<RawOrder>('orders/storefront', payload)
+export async function createOrder(config: SdkConfig, accessToken: string, payload: CreateOrderParams): Promise<Order> {
+  const response = await fetch(`${config.backendUrls.store}/orders/storefront`, {
+    method: 'POST',
+    headers: { 
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) throw new Error('Failed to create order')
+  const data = await response.json()
   return normaliseStorefrontOrder(data)
 }
 
-export async function findOrder(params: FindOrderParams): Promise<Order> {
-  const { data } = await publicStoreAxios.get<RawOrder>('orders/find/', { params })
+export async function findOrder(config: SdkConfig, params: FindOrderParams & { guest_token?: string }): Promise<Order> {
+  const queryParams = new URLSearchParams()
+  if (params.email) queryParams.set('email', params.email)
+  if (params.order_id) queryParams.set('order_id', params.order_id)
+  if (params.guest_token) queryParams.set('guest_token', params.guest_token)
+  
+  const response = await fetch(`${config.backendUrls.store}/orders/find/?${queryParams.toString()}`, {
+    headers: { 
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to find order')
+  const data = await response.json()
   return normaliseStorefrontOrder(data)
 }
 
-export async function findOrderByToken(token: string): Promise<Order> {
-  const { data } = await publicStoreAxios.get<RawOrder>('orders/find/', {
-    params: { guest_token: token },
+export async function findOrderByToken(config: SdkConfig, token: string): Promise<Order> {
+  const response = await fetch(`${config.backendUrls.store}/orders/find/?guest_token=${token}`, {
+    headers: { 
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
   })
+  if (!response.ok) throw new Error('Failed to find order by token')
+  const data = await response.json()
   return normaliseStorefrontOrder(data)
 }
 
-export async function getOrders(params?: { email?: string; page?: number; page_size?: number }): Promise<Order[]> {
-  const { data } = await storeManagementAxios.get<RawOrder[] | { items: RawOrder[] }>('orders/', { params })
+export async function getOrders(config: SdkConfig, accessToken: string, params?: { email?: string; page?: number; page_size?: number }): Promise<Order[]> {
+  const queryParams = new URLSearchParams()
+  if (params?.email) queryParams.set('email', params.email)
+  if (params?.page) queryParams.set('page', params.page.toString())
+  if (params?.page_size) queryParams.set('page_size', params.page_size.toString())
+  
+  const response = await fetch(`${config.backendUrls.store}/orders/?${queryParams.toString()}`, {
+    headers: { 
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to get orders')
+  const data = await response.json()
   const items: RawOrder[] = Array.isArray(data) ? data : (data.items ?? [])
   return items.map(normaliseStorefrontOrder)
 }
 
-export async function cancelOrder(orderId: string, reason: string): Promise<Order> {
-  const { data } = await storeManagementAxios.post<RawOrder>(`orders/${orderId}/cancel/`, { reason })
+export async function cancelOrder(config: SdkConfig, accessToken: string, orderId: string, reason: string): Promise<Order> {
+  const response = await fetch(`${config.backendUrls.store}/orders/${orderId}/cancel/`, {
+    method: 'POST',
+    headers: { 
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify({ reason }),
+  })
+  if (!response.ok) throw new Error('Failed to cancel order')
+  const data = await response.json()
   return normaliseStorefrontOrder(data)
 }
 
-export async function trackOrder(orderId: string, token?: string): Promise<Order> {
-  const { data } = await publicStoreAxios.get<RawOrder>(`orders/track/${orderId}`, {
-    params: token ? { token } : undefined
+export async function trackOrder(config: SdkConfig, orderId: string, token?: string): Promise<Order> {
+  const queryParams = token ? `?token=${token}` : ''
+  const response = await fetch(`${config.backendUrls.store}/orders/track/${orderId}${queryParams}`, {
+    headers: { 
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
   })
+  if (!response.ok) throw new Error('Failed to track order')
+  const data = await response.json()
   return normaliseStorefrontOrder(data)
 }

package/src/services/payment.service.ts

@@ -2,8 +2,9 @@
  * Payment Service
  * 
  * Customer-facing payment API for payment initiation and verification.
+ * Stateless - all configuration passed as parameters.
  */
-import { paymentAxios } from '../client/httpClient'
+import type { SdkConfig } from '../config'
 import type {
   ConversionQuote,
   DVACreateRequest,
@@ -19,6 +20,8 @@ import type {
  * will reject non-NGN requests for this payment method.
  */
 export async function createDedicatedAccount(
+  config: SdkConfig,
+  accessToken: string,
   request: DVACreateRequest
 ): Promise<DVADetails> {
   const isValidUUID = (str: string) => {
@@ -26,17 +29,25 @@ export async function createDedicatedAccount(
     return uuidRegex.test(str);
   }
 
-  const { data } = await paymentAxios.post<DVADetails>(
-    'payments/dedicated-account',
-    {
+  const response = await fetch(`${config.backendUrls.payment}/payments/dedicated-account`, {
+    method: 'POST',
+    headers: { 
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify({
       order_id: request.order_id && isValidUUID(request.order_id) ? request.order_id : undefined,
       amount: request.amount,
       customer_email: request.customer_email,
       customer_name: request.customer_name,
       currency: request.currency,
       idempotency_key: request.idempotency_key,
-    }
-  )
+    }),
+  })
+  if (!response.ok) throw new Error('Failed to create dedicated account')
+  const data = await response.json()
   return data
 }
 
@@ -46,6 +57,8 @@ export async function createDedicatedAccount(
  * Returns a checkout_url to redirect the customer to the gateway.
  */
 export async function initiatePayment(
+  config: SdkConfig,
+  accessToken: string,
   request: PaymentInitiateRequest
 ): Promise<PaymentInitiateResponse> {
   const isValidUUID = (str: string) => {
@@ -55,25 +68,30 @@ export async function initiatePayment(
 
   const validOrderId = request.order_id && isValidUUID(request.order_id) ? request.order_id : undefined;
 
-  const { data } = await paymentAxios.post<{
-    id: string
-    gateway_ref: string
-    gateway: string
-    status: string
-    metadata_json?: { checkout_url?: string }
-  }>('payments/storefront/initiate', {
-    amount: request.amount,
-    currency: request.currency,
-    order_id: validOrderId,
-    quote_id: request.quote_id,
-    metadata_json: {
-      customer_email: request.customer_email,
-      customer_name: request.customer_name ?? '',
-      order_id: validOrderId,
-      ...(request.metadata ?? {}),
+  const response = await fetch(`${config.backendUrls.payment}/payments/storefront/initiate`, {
+    method: 'POST',
+    headers: { 
+      'Content-Type': 'application/json',
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
     },
-    idempotency_key: request.idempotency_key,
+    body: JSON.stringify({
+      amount: request.amount,
+      currency: request.currency,
+      order_id: validOrderId,
+      quote_id: request.quote_id,
+      metadata_json: {
+        customer_email: request.customer_email,
+        customer_name: request.customer_name ?? '',
+        order_id: validOrderId,
+        ...(request.metadata ?? {}),
+      },
+      idempotency_key: request.idempotency_key,
+    }),
   })
+  if (!response.ok) throw new Error('Failed to initiate payment')
+  const data = await response.json()
 
   return {
     id: data.id,
@@ -88,9 +106,20 @@ export async function initiatePayment(
  * Request a 15-minute rate-locked conversion quote for non-NGN transactions.
  */
 export async function requestQuote(
+  config: SdkConfig,
   amount: number
 ): Promise<ConversionQuote> {
-  const { data } = await paymentAxios.post<ConversionQuote>('payments/quote', { amount })
+  const response = await fetch(`${config.backendUrls.payment}/payments/quote`, {
+    method: 'POST',
+    headers: { 
+      'Content-Type': 'application/json',
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify({ amount }),
+  })
+  if (!response.ok) throw new Error('Failed to request quote')
+  const data = await response.json()
   return data
 }
 
@@ -98,11 +127,31 @@ export async function requestQuote(
  * Verify a payment after the gateway redirects back to /checkout/verify.
  */
 export async function verifyTransaction(
-  reference: string
+  configOrReference: SdkConfig | string,
+  reference?: string
 ): Promise<TransactionVerifyResponse> {
-  const { data } = await paymentAxios.post<TransactionVerifyResponse>(
-    `payments/verify/${reference}`
-  )
+  if (typeof configOrReference === 'string') {
+    const ref = configOrReference
+    const response = await fetch(`/api/payments/verify/${ref}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    })
+    if (!response.ok) throw new Error('Failed to verify transaction')
+    return response.json()
+  }
+
+  const config = configOrReference
+  const ref = reference || ''
+  const response = await fetch(`${config.backendUrls.payment}/payments/verify/${ref}`, {
+    method: 'POST',
+    headers: { 
+      'Content-Type': 'application/json',
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to verify transaction')
+  const data = await response.json()
   return data
 }
 
@@ -110,11 +159,17 @@ export async function verifyTransaction(
  * Poll transaction status by internal transaction ID.
  */
 export async function getTransactionStatus(
+  config: SdkConfig,
   transactionId: string
 ): Promise<TransactionVerifyResponse> {
-  const { data } = await paymentAxios.get<TransactionVerifyResponse>(
-    `payments/transactions/${transactionId}`
-  )
+  const response = await fetch(`${config.backendUrls.payment}/payments/transactions/${transactionId}`, {
+    headers: { 
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to get transaction status')
+  const data = await response.json()
   return data
 }