@kasuvia/sdk 0.0.1

package/src/services/collection.service.ts

@@ -0,0 +1,77 @@
+/**
+ * Collection Service
+ * 
+ * Handles collection operations using GraphQL.
+ */
+import { getGraphQLClient } from '../client/graphqlClient'
+import type { Collection, PaginatedResponse, ListParams } from '../types/store'
+
+const GET_STOREFRONT_COLLECTIONS = `
+  query GetStorefrontCollections($page: Int!, $pageSize: Int!) {
+    storefront_collections(page: $page, pageSize: $pageSize) {
+      items {
+        id
+        business_id
+        name
+        slug
+        description
+        image { url alt id }
+        collection_type
+        rules
+        status
+        sort_order
+        created_at
+        updated_at
+      }
+      total
+      page
+      page_size
+      total_pages
+    }
+  }
+`
+
+const GET_STOREFRONT_COLLECTION_BY_SLUG = `
+  query GetStorefrontCollectionBySlug($slug: String!) {
+    storefront_collection_by_slug(slug: $slug) {
+      id
+      business_id
+      name
+      slug
+      description
+      image { url alt id }
+      collection_type
+      rules
+      status
+      sort_order
+      created_at
+      updated_at
+    }
+  }
+`
+
+/**
+ * Fetch paginated active collections for the storefront.
+ */
+export async function getStorefrontCollections(
+  params?: ListParams
+): Promise<PaginatedResponse<Collection>> {
+  const client = getGraphQLClient()
+  const variables = {
+    page: params?.page || 1,
+    pageSize: params?.pageSize || 20,
+  }
+  const data = await client.request(GET_STOREFRONT_COLLECTIONS, variables)
+  return data.storefront_collections
+}
+
+/**
+ * Fetch a single collection by its slug.
+ */
+export async function getStorefrontCollectionBySlug(
+  slug: string
+): Promise<Collection> {
+  const client = getGraphQLClient()
+  const data = await client.request(GET_STOREFRONT_COLLECTION_BY_SLUG, { slug })
+  return data.storefront_collection_by_slug
+}

package/src/services/config.service.ts

@@ -0,0 +1,42 @@
+/**
+ * Config Service
+ *
+ * Handles configuration endpoints (languages, currencies, locales, business config).
+ */
+import { paymentAxios, publicStoreAxios } from '../client/httpClient'
+import type { BackendLanguage, SupportedLanguagesResponse, SupportedCurrenciesResponse } from '../types/payments'
+import type { BusinessConfig } from '../types/business'
+
+/**
+ * Fetch supported languages from the payment system.
+ * Resolves to: {luxePaymentBackendUrl}/config/supported-languages
+ */
+export async function getSupportedLanguages(): Promise<SupportedLanguagesResponse> {
+  const { data } = await paymentAxios.get<SupportedLanguagesResponse>('/config/supported-languages')
+  return data
+}
+
+/**
+ * Fetch supported currencies from the payment system.
+ * Resolves to: {luxePaymentBackendUrl}/config/supported-currencies
+ */
+export async function getSupportedCurrencies(): Promise<SupportedCurrenciesResponse> {
+  const { data } = await paymentAxios.get<SupportedCurrenciesResponse>('/config/supported-currencies')
+  return data
+}
+
+/**
+ * Fetch the business's public configuration, including store_currency.
+ * Uses publicStoreAxios (X-Storefront-Key + X-Business-ID — no user JWT required).
+ * Resolves to: {luxeStoreBackendUrl}/business/profile
+ */
+export async function getBusinessConfig(): Promise<BusinessConfig> {
+  const { data } = await publicStoreAxios.get<BusinessConfig>('business/profile')
+  return data
+}
+
+export const configService = {
+  getSupportedLanguages,
+  getSupportedCurrencies,
+  getBusinessConfig,
+} as const

package/src/services/consultation.service.ts

@@ -0,0 +1,51 @@
+/**
+ * Consultation Service
+ * 
+ * Handles consultation operations for bespoke and service products.
+ */
+import { storeManagementAxios } from '../client/httpClient'
+import type {
+  Consultation,
+  ConsultationCreatePayload,
+  ConsultationMessagePayload,
+  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 getConsultations(): Promise<Consultation[]> {
+  const { data } = await storeManagementAxios.get<Consultation[]>('social/consultations/')
+  return data
+}
+
+export async function getConsultation(id: string): Promise<Consultation> {
+  const { data } = await storeManagementAxios.get<Consultation>(`social/consultations/${id}`)
+  return data
+}
+
+export async function sendMessage(id: string, payload: ConsultationMessagePayload): Promise<void> {
+  await storeManagementAxios.post(`social/consultations/${id}/messages`, 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 rejectQuote(id: string, reason?: string): Promise<Consultation> {
+  const { data } = await storeManagementAxios.post<Consultation>(`social/consultations/${id}/reject-quote`, { reason })
+  return data
+}
+
+// Service object export for backward compatibility
+export const consultationService = {
+  createConsultation,
+  getConsultations,
+  getConsultation,
+  sendMessage,
+  acceptQuote,
+  rejectQuote,
+}

package/src/services/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Services Barrel Export
+ * 
+ * Central export point for all service modules.
+ */
+
+export * from './cart.service'
+export * from './order.service'
+export * from './auth.service'
+export * from './product.service'
+export * from './collection.service'
+export * from './wishlist.service'
+export * from './payment.service'
+export * from './consultation.service'
+export * from './logistics.service'
+export * from './bespoke.service'
+export * from './service-booking.service'
+export * from './notifications.service'
+export * from './app.service'
+export * from './config.service'
+export * from './cms.service'

package/src/services/logistics.service.ts

@@ -0,0 +1,95 @@
+/**
+ * Logistics Service
+ * 
+ * Handles shipping rates and address validation.
+ */
+import { storeManagementAxios } from '../client/httpClient'
+import type { ShippingRatesResponse } from '../types/store/shipping'
+import type { Product, ProductVariant } from '../types/store'
+
+export interface CartItemPayload {
+  product: {
+    name: string
+    price: number
+    weight: number
+  }
+  variant: ProductVariant | null
+  quantity: number
+}
+
+export interface RateAddress {
+  city: string
+  state: string
+  country: string
+}
+
+export interface ShippingRatesRequest {
+  cart_items: CartItemPayload[]
+  origin_address: RateAddress
+  destination_address: RateAddress
+  currency?: string
+}
+
+/**
+ * Fetch shipping rates for a cart.
+ */
+export async function getShippingRates(
+  payload: ShippingRatesRequest
+): Promise<ShippingRatesResponse> {
+  const { data } = await storeManagementAxios.post<ShippingRatesResponse>(
+    'logistics/shipping/rates',
+    payload
+  )
+  return data
+}
+
+/**
+ * Fetch the seller's registered shipping address.
+ */
+export async function getSellerShippingAddress(): Promise<{
+  terminal_address_id: string | null
+  address_details: {
+    city: string
+    state: string
+    country: string
+    line1: string
+    line2: string
+    zip: string
+  } | null
+  business_id: string
+  message: string
+}> {
+  const { data } = await storeManagementAxios.get('logistics/shipping-address')
+  return data
+}
+
+/**
+ * Validate a shipping address.
+ */
+export async function validateShippingAddress(
+  payload: {
+    first_name: string
+    last_name: string
+    phone: string
+    address_line1: string
+    address_line2?: string
+    city: string
+    state: string
+    country: string
+    postal_code?: string
+  }
+): Promise<{
+  valid: boolean
+  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
+}
+
+// Service object for backward compatibility
+export const logisticsService = {
+  getShippingRates,
+  getSellerShippingAddress,
+  validateShippingAddress,
+}

package/src/services/notifications.service.ts

@@ -0,0 +1,50 @@
+/**
+ * Notification Service
+ * 
+ * Handles contact form submissions and email notifications.
+ */
+import { notificationsAxios } from '../client/httpClient'
+
+export interface ContactFormData {
+  name: string
+  email: string
+  subject: string
+  message: string
+  source?: string
+  company_name?: string
+  current_year?: number
+  turnstile_token?: string
+}
+
+/**
+ * Send contact email to Luxe team.
+ * POST /contact/send-contact-email
+ */
+export async function sendContactEmail(
+  payload: ContactFormData
+): Promise<{ detail: string }> {
+  const { data } = await notificationsAxios.post<{ detail: string }>(
+    'contact/send-contact-email',
+    payload
+  )
+  return data
+}
+
+/**
+ * Send confirmation email to user.
+ * POST /contact/send-contact-confirmation
+ */
+export async function sendContactConfirmation(
+  payload: Omit<ContactFormData, 'turnstile_token'>
+): Promise<{ detail: string }> {
+  const { data } = await notificationsAxios.post<{ detail: string }>(
+    'contact/send-contact-confirmation',
+    payload
+  )
+  return data
+}
+
+export const notificationsService = {
+  sendContactEmail,
+  sendContactConfirmation,
+} as const

package/src/services/order.service.ts

@@ -0,0 +1,169 @@
+/**
+ * Order Service
+ * 
+ * Handles order operations including creation, lookup, and tracking.
+ */
+import { storeManagementAxios, publicStoreAxios } from '../client/httpClient'
+import type { Order, OrderStatus, FindOrderParams, CreateOrderParams, OrderItem } from '../types/store'
+import type { DeliveryAddress } from '../types/store'
+
+export type { FindOrderParams, CreateOrderParams, OrderStatus }
+
+interface RawOrderItem {
+  id: string
+  product_name?: string
+  productName?: string
+  image?: string
+  quantity?: number
+  unit_price?: number
+  price?: number
+}
+
+interface RawShippingAddress {
+  first_name?: string
+  last_name?: string
+  phone?: string
+  street?: string
+  city?: string
+  state?: string
+  country?: string
+  postal?: string
+  lga?: string
+}
+
+interface RawOrder {
+  id: string
+  display_id?: string
+  items?: RawOrderItem[]
+  total_amount?: number
+  total?: number
+  status: OrderStatus
+  customer_email?: string
+  customer_name?: string
+  guest_email?: string
+  guest_phone?: string
+  guest_name?: string
+  guest_token?: string
+  shipping_address?: RawShippingAddress | string | null
+  delivery_method?: string
+  tracking_number?: string
+  delivery_status?: string
+  carrier_name?: string
+  terminal_shipment_id?: string
+  product_type?: string
+  bespoke_stage?: string
+  bespoke_brief?: string
+  created_at?: string
+  updated_at?: string
+  cancellation_reason?: string
+}
+
+function deriveCustomerName(raw: RawOrder): string {
+  if (raw.customer_name) return raw.customer_name
+  if (raw.guest_name) return raw.guest_name
+
+  const addr = typeof raw.shipping_address === 'object' && raw.shipping_address !== null
+    ? raw.shipping_address as RawShippingAddress
+    : null
+  if (addr) {
+    const full = `${addr.first_name ?? ''} ${addr.last_name ?? ''}`.trim()
+    if (full) return full
+  }
+
+  const email = raw.guest_email ?? raw.customer_email ?? ''
+  if (email) return email.split('@')[0]
+
+  return ''
+}
+
+function normaliseStorefrontOrder(raw: RawOrder): Order {
+  const items: OrderItem[] = (raw.items ?? []).map((item) => ({
+    id: item.id,
+    productName: item.product_name ?? item.productName ?? '',
+    image: item.image ?? '',
+    quantity: item.quantity ?? 1,
+    price: item.unit_price ?? item.price ?? 0,
+  }))
+
+  const addr = typeof raw.shipping_address === 'object' && raw.shipping_address !== null
+    ? raw.shipping_address as RawShippingAddress
+    : null
+
+  return {
+    id: raw.id,
+    display_id: raw.display_id,
+    items,
+    total: raw.total_amount ?? raw.total ?? 0,
+    status: raw.status,
+    customerEmail: raw.guest_email ?? raw.customer_email ?? '',
+    customerName: deriveCustomerName(raw),
+    createdAt: raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
+    updatedAt: raw.updated_at ? new Date(raw.updated_at).getTime() : Date.now(),
+    deliveryMethod: raw.delivery_method,
+    trackingNumber: raw.tracking_number,
+    deliveryAddress: typeof raw.shipping_address === 'string'
+      ? raw.shipping_address
+      : addr
+        ? `${addr.street}, ${addr.city}, ${addr.state}, ${addr.country}`
+        : undefined,
+    shippingAddress: addr
+      ? {
+          first_name: addr.first_name ?? '',
+          last_name: addr.last_name ?? '',
+          phone: addr.phone ?? '',
+          street: addr.street ?? '',
+          city: addr.city ?? '',
+          state: addr.state ?? '',
+          lga: addr.lga ?? '',
+          country: addr.country ?? '',
+          postal: addr.postal ?? '',
+        }
+      : undefined,
+    cancellationReason: raw.cancellation_reason,
+    hasBespoke: raw.product_type === 'bespoke',
+    bespokeStage: raw.bespoke_stage as Order['bespokeStage'],
+    bespokeBrief: raw.bespoke_brief,
+    deliveryStatus: raw.delivery_status,
+    carrierName: raw.carrier_name,
+    terminalShipmentId: raw.terminal_shipment_id,
+    guestToken: raw.guest_token,
+    guestEmail: raw.guest_email,
+    guestPhone: raw.guest_phone,
+    guestName: raw.guest_name,
+  }
+}
+
+export async function createOrder(payload: CreateOrderParams): Promise<Order> {
+  const { data } = await storeManagementAxios.post<RawOrder>('orders/storefront', payload)
+  return normaliseStorefrontOrder(data)
+}
+
+export async function findOrder(params: FindOrderParams): Promise<Order> {
+  const { data } = await publicStoreAxios.get<RawOrder>('orders/find/', { params })
+  return normaliseStorefrontOrder(data)
+}
+
+export async function findOrderByToken(token: string): Promise<Order> {
+  const { data } = await publicStoreAxios.get<RawOrder>('orders/find/', {
+    params: { guest_token: token },
+  })
+  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 })
+  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 })
+  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
+  })
+  return normaliseStorefrontOrder(data)
+}

package/src/services/payment.service.ts

@@ -0,0 +1,127 @@
+/**
+ * Payment Service
+ * 
+ * Customer-facing payment API for payment initiation and verification.
+ */
+import { paymentAxios } from '../client/httpClient'
+import type {
+  ConversionQuote,
+  DVACreateRequest,
+  DVADetails,
+  PaymentInitiateRequest,
+  PaymentInitiateResponse,
+  TransactionVerifyResponse,
+} from '../types/payments/index'
+
+/**
+ * Create a Monnify Dedicated Virtual Account so the customer can pay via
+ * bank transfer. Note: Monnify DVA only supports NGN currency - the backend
+ * will reject non-NGN requests for this payment method.
+ */
+export async function createDedicatedAccount(
+  request: DVACreateRequest
+): Promise<DVADetails> {
+  const isValidUUID = (str: string) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+  }
+
+  const { data } = await paymentAxios.post<DVADetails>(
+    'payments/dedicated-account',
+    {
+      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,
+    }
+  )
+  return data
+}
+
+/**
+ * Initiate a card payment (customer → business owner).
+ * Routes to Monnify (NGN) or Flutterwave (non-NGN) on the backend.
+ * Returns a checkout_url to redirect the customer to the gateway.
+ */
+export async function initiatePayment(
+  request: PaymentInitiateRequest
+): Promise<PaymentInitiateResponse> {
+  const isValidUUID = (str: string) => {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+  }
+
+  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 ?? {}),
+    },
+    idempotency_key: request.idempotency_key,
+  })
+
+  return {
+    id: data.id,
+    gateway_ref: data.gateway_ref,
+    gateway: data.gateway,
+    status: data.status,
+    checkout_url: data.metadata_json?.checkout_url ?? '',
+  }
+}
+
+/**
+ * Request a 15-minute rate-locked conversion quote for non-NGN transactions.
+ */
+export async function requestQuote(
+  amount: number
+): Promise<ConversionQuote> {
+  const { data } = await paymentAxios.post<ConversionQuote>('payments/quote', { amount })
+  return data
+}
+
+/**
+ * Verify a payment after the gateway redirects back to /checkout/verify.
+ */
+export async function verifyTransaction(
+  reference: string
+): Promise<TransactionVerifyResponse> {
+  const { data } = await paymentAxios.post<TransactionVerifyResponse>(
+    `payments/verify/${reference}`
+  )
+  return data
+}
+
+/**
+ * Poll transaction status by internal transaction ID.
+ */
+export async function getTransactionStatus(
+  transactionId: string
+): Promise<TransactionVerifyResponse> {
+  const { data } = await paymentAxios.get<TransactionVerifyResponse>(
+    `payments/transactions/${transactionId}`
+  )
+  return data
+}
+
+export const paymentService = {
+  createDedicatedAccount,
+  initiatePayment,
+  requestQuote,
+  verifyTransaction,
+  getTransactionStatus,
+} as const