@kasuvia/sdk 0.0.2 → 0.0.4

package/src/services/wishlist.service.ts

@@ -2,14 +2,15 @@
  * Wishlist Service
  * 
  * Handles wishlist operations.
+ * Stateless - all configuration passed as parameters.
  */
-import { storeManagementAxios } from '../client/httpClient'
-import { getGraphQLClient } from '../client/graphqlClient'
+import { GraphQLClient } from 'graphql-request'
+import type { SdkConfig } from '../config'
 import type { WishlistItem, WishlistListResponse, WishlistCheckResponse } from '../types/store'
 
-const GET_WISHLIST = `
-  query GetWishlist($page: Int!, $pageSize: Int!) {
-    wishlist(page: $page, pageSize: $pageSize) {
+const GET_STOREFRONT_WISHLIST = `
+  query GetStorefrontWishlist($page: Int!, $pageSize: Int!) {
+    storefront_wishlist(page: $page, pageSize: $pageSize) {
       items {
         id
         product_id
@@ -18,6 +19,7 @@ const GET_WISHLIST = `
         product_name
         product_slug
         product_price
+        currency
         product_image
       }
       total
@@ -28,57 +30,99 @@ const GET_WISHLIST = `
   }
 `
 
-const CHECK_IN_WISHLIST = `
-  query CheckInWishlist($productId: String!) {
-    check_in_wishlist(productId: $productId) {
+const CHECK_IN_STOREFRONT_WISHLIST = `
+  query CheckInStorefrontWishlist($productId: String!) {
+    check_in_storefront_wishlist(productId: $productId) {
       in_wishlist
     }
   }
 `
 
+/**
+ * Create GraphQL client with provided config
+ */
+function createGraphQLClient(config: SdkConfig, accessToken?: string): GraphQLClient {
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json',
+    'X-Storefront-Key': config.storefrontApiKey,
+    'X-Business-ID': config.businessId,
+  }
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`
+  }
+  return new GraphQLClient(`${config.backendUrls.store}/graphql`, { headers })
+}
+
 /**
  * Fetch the customer's wishlist for the current business.
  */
-export async function getWishlist(params?: { page?: number; pageSize?: number }): Promise<WishlistListResponse> {
-  const client = getGraphQLClient()
+export async function getWishlist(config: SdkConfig, accessToken: string, params?: { page?: number; pageSize?: number }): Promise<WishlistListResponse> {
+  const client = createGraphQLClient(config, accessToken)
   const variables = {
     page: params?.page || 1,
     pageSize: params?.pageSize || 20,
   }
-  const data = await client.request(GET_WISHLIST, variables)
-  return data.wishlist
+  const data = await client.request(GET_STOREFRONT_WISHLIST, variables)
+  return data.storefront_wishlist
 }
 
 /**
  * Check if a product is in the customer's wishlist.
  */
-export async function checkInWishlist(productId: string): Promise<WishlistCheckResponse> {
-  const client = getGraphQLClient()
-  const data = await client.request(CHECK_IN_WISHLIST, { productId })
-  return data.check_in_wishlist
+export async function checkInWishlist(config: SdkConfig, accessToken: string, productId: string): Promise<WishlistCheckResponse> {
+  const client = createGraphQLClient(config, accessToken)
+  const data = await client.request(CHECK_IN_STOREFRONT_WISHLIST, { productId })
+  return data.check_in_storefront_wishlist
 }
 
 /**
  * Add a product to the customer's wishlist.
  */
-export async function addToWishlist(productId: string, notes?: string): Promise<WishlistItem> {
-  const { data } = await storeManagementAxios.post<WishlistItem>("wishlist/", {
-    product_id: productId,
-    notes: notes || undefined,
+export async function addToWishlist(config: SdkConfig, accessToken: string, productId: string, notes?: string): Promise<WishlistItem> {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+    body: JSON.stringify({
+      product_id: productId,
+      notes: notes || undefined,
+    }),
   })
-  return data
+  if (!response.ok) throw new Error('Failed to add to wishlist')
+  return response.json()
 }
 
 /**
  * Remove an item from the customer's wishlist by item ID.
  */
-export async function removeFromWishlist(itemId: string): Promise<void> {
-  await storeManagementAxios.delete(`wishlist/${itemId}`)
+export async function removeFromWishlist(config: SdkConfig, accessToken: string, itemId: string): Promise<void> {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/${itemId}`, {
+    method: 'DELETE',
+    headers: {
+      'Authorization': `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to remove from wishlist')
 }
 
 /**
  * Remove a product from the customer's wishlist by product ID.
  */
-export async function removeProductFromWishlist(productId: string): Promise<void> {
-  await storeManagementAxios.delete(`wishlist/product/${productId}`)
+export async function removeProductFromWishlist(config: SdkConfig, accessToken: string, productId: string): Promise<void> {
+  const response = await fetch(`${config.backendUrls.store}/wishlist/product/${productId}`, {
+    method: 'DELETE',
+    headers: {
+      'Authorization': `Bearer ${accessToken}`,
+      "X-Storefront-Key": config.storefrontApiKey,
+      "X-Business-ID": config.businessId,
+    },
+  })
+  if (!response.ok) throw new Error('Failed to remove product from wishlist')
 }

package/src/types/auth/index.ts

@@ -1,5 +1,5 @@
 /**
- * Simplified customer auth types for luxe-storefront.
+ * Simplified customer auth types for kasuvia-storefront.
  * Customers only need enough to track their orders — no RBAC, MFA, or complex profiles.
  */
 
@@ -33,7 +33,7 @@ export interface CustomerUser {
   provider: 'google' | 'facebook' | 'email';
 }
 
-/** GET/PUT /auth/profile/ — matches luxe-auth UserSerializer */
+/** GET/PUT /auth/profile/ — matches kasuvia-auth UserSerializer */
 export interface AuthUserResponse {
   id: string;
   email: string;
@@ -111,8 +111,8 @@ export interface CustomerLoginPayload {
 /** POST /auth/register/customer/ */
 export interface CustomerRegisterPayload {
   tenant_id: string;    // config.api.storefrontBusinessId
-  /** Full name — backend splits this into firstname and lastname on the Profile */
-  full_name: string;
+  first_name?: string;
+  last_name?: string;
   email: string;
   password: string;
 }
@@ -144,4 +144,6 @@ export interface AuthContextValue {
   closeModal: () => void;
   setCustomer: (user: CustomerUser | null) => void;
   logout: () => Promise<void>;
+  login: (payload: Omit<CustomerLoginPayload, 'tenant_id'>) => Promise<void>;
+  register: (payload: Omit<CustomerRegisterPayload, 'tenant_id'>) => Promise<{ requires_verification: boolean }>;
 }

package/src/types/business/index.ts

@@ -1,6 +1,11 @@
 export interface BusinessConfig {
   business_id: string;
-  store_name: string;
-  store_currency: string;
+  storefront_business_id: string;
+  name: string;
+  currency: string;
+  settlement_currency: string;
+  country: string;
+  region: string;
+  is_verified: boolean;
   is_active: boolean;
 }

package/src/types/payments/index.ts

@@ -1,6 +1,6 @@
 /**
  * @file types/payments/index.ts
- * @description All customer-facing payment types for the Luxe Payment System.
+ * @description All customer-facing payment types for the Kasuvia Payment System.
  *
  * Auth model:
  *   - X-Storefront-Key  → identifies the business storefront
@@ -9,8 +9,8 @@
  *
  * Payment flow:
  *   Customer → Business Owner : Monnify (NGN) | Flutterwave (non-NGN)
- *   Business Owner → Luxe     : Subscription (separate, JWT-auth)
- *   Luxe → Business Owner     : Payout (separate, JWT-auth)
+ *   Business Owner → Kasuvia     : Subscription (separate, JWT-auth)
+ *   Kasuvia → Business Owner     : Payout (separate, JWT-auth)
  */
 
 // ── Configuration Types ─────────────────────────────────────────────────────────

package/src/types/services/index.ts

@@ -2,9 +2,6 @@
  * Service booking types for customer-facing storefront
  */
 
-export type ServiceLocationType = "remote" | "physical" | "both";
-export type ServiceType = "appointment" | "project" | "recurring";
-
 export type AppointmentStatus =
   | "pending"
   | "confirmed"
@@ -29,7 +26,7 @@ export interface ServiceAppointment {
   appointment_date: string;
   start_time: string;
   end_time: string;
-  location_type: ServiceLocationType;
+  location_type: import("../store").ServiceLocationType;
   customer_address: Record<string, unknown> | null;
   meeting_link: string | null;
   customer_notes: string | null;
@@ -45,7 +42,7 @@ export interface ServiceAppointmentCreatePayload {
   product_id: string;
   scheduled_date: string;
   scheduled_time: string;
-  location_type?: ServiceLocationType;
+  location_type?: import("../store").ServiceLocationType;
   customer_address?: Record<string, unknown>;
   customer_notes?: string;
 }

package/src/types/store/index.ts

@@ -5,8 +5,29 @@ export type { DeliveryAddress };
 
 export type ProductType = "physical" | "digital" | "service" | "bespoke";
 
+export enum ServiceTypeEnum {
+  APPOINTMENT = 'appointment',
+  PROJECT = 'project',
+  RECURRING = 'recurring',
+}
+
+export type ServiceType = ServiceTypeEnum | 'appointment' | 'project' | 'recurring'
 
+export enum ServiceLocationTypeEnum {
+  REMOTE = 'remote',
+  PHYSICAL = 'physical',
+  BOTH = 'both',
+}
 
+export type ServiceLocationType = ServiceLocationTypeEnum | 'remote' | 'physical' | 'both'
+
+export enum ServiceRecurringIntervalEnum {
+  WEEKLY = 'weekly',
+  MONTHLY = 'monthly',
+  YEARLY = 'yearly',
+}
+
+export type ServiceRecurringInterval = ServiceRecurringIntervalEnum | 'weekly' | 'monthly' | 'yearly' | ''
 
 export interface Address {
   street: string
@@ -22,7 +43,7 @@ export interface Collection {
   name: string
   slug: string
   description?: string
-  image?: { url: string; alt?: string; id?: string }
+  image?: string
   collection_type?: string
   rules?: Record<string, unknown>
   status?: string
@@ -53,7 +74,7 @@ export interface ProductVariant {
   sku?: string
   attributes: Record<string, string>
   price?: number
-  images: Array<{ url: string; alt?: string; id?: string }>
+  images: string[]
   weight_kg?: number
   is_active: boolean
   inventory?: Inventory
@@ -81,9 +102,13 @@ export interface Product {
   requires_shipping: boolean
   is_consumable: boolean
   is_bespoke: boolean
+  is_physical?: boolean | null  // For bespoke products: indicates if custom item requires physical delivery
   base_price: number
   currency: string
-  images: Array<{ url: string; alt?: string; id?: string }>
+  sale_price?: number
+  sale_start?: string
+  sale_end?: string
+  images: string[]
   tags: string[]
   custom_fields: CustomField[]
   is_published: boolean
@@ -94,6 +119,16 @@ export interface Product {
   digital_file_key?: string
   download_limit?: number
   download_expires_at?: string
+  // Service-specific fields
+  service_type?: ServiceType | null
+  service_duration_minutes?: number | null
+  service_location_type?: ServiceLocationType | null
+  service_requires_consultation?: boolean
+  service_max_capacity_per_slot?: number | null
+  service_buffer_minutes?: number
+  service_is_recurring?: boolean
+  service_recurring_interval?: ServiceRecurringInterval | null
+  service_project_based?: boolean
   weight_kg: number
   length_cm?: number
   width_cm?: number

package/src/utils/error-handler.ts

@@ -1,14 +1,19 @@
-import axios from 'axios';
-
 /**
  * Type-safe way to extract an error message from an API error.
+ * Updated for fetch-based errors (no axios dependency).
  */
 export function getErrorMessage(error: unknown, fallback: string = "Something went wrong"): string {
-    if (axios.isAxiosError(error)) {
-        return error.response?.data?.detail || error.response?.data?.message || error.message || fallback;
-    }
     if (error instanceof Error) {
         return error.message;
     }
+    // Handle fetch Response objects that might be thrown
+    if (error instanceof Response) {
+        return `HTTP ${error.status}: ${error.statusText}`;
+    }
+    // Handle objects with detail or message properties (from API responses)
+    if (typeof error === 'object' && error !== null) {
+        const err = error as { detail?: string; message?: string; status?: number };
+        return err.detail || err.message || fallback;
+    }
     return fallback;
 }

package/src/utils/storage.ts

@@ -2,32 +2,39 @@
  * @file storage.ts
  * @description Centralized tenant-isolated storage utility for sessionStorage and localStorage.
  * Automatically prefixes all keys with the storefront Business ID to guarantee multi-tenant segregation.
+ * Stateless - requires businessId parameter.
  */
-import { getRuntimeConfig } from '../config'
 
-function getPrefixedKey(key: string): string {
-  const config = getRuntimeConfig()
-  const bid = config.businessId
-  const cleanKey = key.startsWith('luxe_') ? key.substring(5) : key
-  return bid ? `luxe-sf-${bid}-${cleanKey}` : `luxe-sf-anon-${cleanKey}`
+function getPrefixedKey(businessId: string, key: string): string {
+  const cleanKey = key.startsWith('kasuvia_') ? key.substring(5) : key
+  return businessId ? `kasuvia-sf-${businessId}-${cleanKey}` : `kasuvia-sf-anon-${cleanKey}`
 }
 
 export const sessionStore = {
-  get: (key: string): string | null => {
+  get: (businessIdOrKey: string, key?: string): string | null => {
     if (typeof window === 'undefined') return null
-    return sessionStorage.getItem(getPrefixedKey(key))
+    const bId = key ? businessIdOrKey : ''
+    const k = key || businessIdOrKey
+    return sessionStorage.getItem(getPrefixedKey(bId, k))
   },
-  set: (key: string, value: string): void => {
+  set: (businessIdOrKey: string, keyOrVal: string, val?: string): void => {
     if (typeof window === 'undefined') return
-    sessionStorage.setItem(getPrefixedKey(key), value)
+    const bId = val !== undefined ? businessIdOrKey : ''
+    const k = val !== undefined ? keyOrVal : businessIdOrKey
+    const v = val !== undefined ? val : keyOrVal
+    sessionStorage.setItem(getPrefixedKey(bId, k), v)
   },
-  remove: (key: string): void => {
+  remove: (businessIdOrKey: string, key?: string): void => {
     if (typeof window === 'undefined') return
-    sessionStorage.removeItem(getPrefixedKey(key))
+    const bId = key ? businessIdOrKey : ''
+    const k = key || businessIdOrKey
+    sessionStorage.removeItem(getPrefixedKey(bId, k))
   },
-  getJSON: <T = unknown>(key: string): T | null => {
+  getJSON: <T = unknown>(businessIdOrKey: string, key?: string): T | null => {
     if (typeof window === 'undefined') return null
-    const value = sessionStorage.getItem(getPrefixedKey(key))
+    const bId = key ? businessIdOrKey : ''
+    const k = key || businessIdOrKey
+    const value = sessionStorage.getItem(getPrefixedKey(bId, k))
     if (!value) return null
     try {
       return JSON.parse(value) as T
@@ -35,28 +42,40 @@ export const sessionStore = {
       return null
     }
   },
-  setJSON: (key: string, value: unknown): void => {
+  setJSON: (businessIdOrKey: string, keyOrVal: unknown, val?: unknown): void => {
     if (typeof window === 'undefined') return
-    sessionStorage.setItem(getPrefixedKey(key), JSON.stringify(value))
+    const bId = val !== undefined ? (businessIdOrKey as string) : ''
+    const k = val !== undefined ? (keyOrVal as string) : (businessIdOrKey as string)
+    const v = val !== undefined ? val : keyOrVal
+    sessionStorage.setItem(getPrefixedKey(bId, k), JSON.stringify(v))
   },
 }
 
 export const localStore = {
-  get: (key: string): string | null => {
+  get: (businessIdOrKey: string, key?: string): string | null => {
     if (typeof window === 'undefined') return null
-    return localStorage.getItem(getPrefixedKey(key))
+    const bId = key ? businessIdOrKey : ''
+    const k = key || businessIdOrKey
+    return localStorage.getItem(getPrefixedKey(bId, k))
   },
-  set: (key: string, value: string): void => {
+  set: (businessIdOrKey: string, keyOrVal: string, val?: string): void => {
     if (typeof window === 'undefined') return
-    localStorage.setItem(getPrefixedKey(key), value)
+    const bId = val !== undefined ? businessIdOrKey : ''
+    const k = val !== undefined ? keyOrVal : businessIdOrKey
+    const v = val !== undefined ? val : keyOrVal
+    localStorage.setItem(getPrefixedKey(bId, k), v)
   },
-  remove: (key: string): void => {
+  remove: (businessIdOrKey: string, key?: string): void => {
     if (typeof window === 'undefined') return
-    localStorage.removeItem(getPrefixedKey(key))
+    const bId = key ? businessIdOrKey : ''
+    const k = key || businessIdOrKey
+    localStorage.removeItem(getPrefixedKey(bId, k))
   },
-  getJSON: <T = unknown>(key: string): T | null => {
+  getJSON: <T = unknown>(businessIdOrKey: string, key?: string): T | null => {
     if (typeof window === 'undefined') return null
-    const value = localStorage.getItem(getPrefixedKey(key))
+    const bId = key ? businessIdOrKey : ''
+    const k = key || businessIdOrKey
+    const value = localStorage.getItem(getPrefixedKey(bId, k))
     if (!value) return null
     try {
       return JSON.parse(value) as T
@@ -64,8 +83,11 @@ export const localStore = {
       return null
     }
   },
-  setJSON: (key: string, value: unknown): void => {
+  setJSON: (businessIdOrKey: string, keyOrVal: unknown, val?: unknown): void => {
     if (typeof window === 'undefined') return
-    localStorage.setItem(getPrefixedKey(key), JSON.stringify(value))
+    const bId = val !== undefined ? (businessIdOrKey as string) : ''
+    const k = val !== undefined ? (keyOrVal as string) : (businessIdOrKey as string)
+    const v = val !== undefined ? val : keyOrVal
+    localStorage.setItem(getPrefixedKey(bId, k), JSON.stringify(v))
   },
 }

package/src/utils/validators.ts

@@ -0,0 +1,85 @@
+/**
+ * Form validation utilities for kasuvia-sdk
+ * Provides realtime validation for email, password, name, confirm password, and message fields
+ */
+
+export function validateEmail(email: string): string | null {
+  if (!email || email.trim() === "") {
+    return "Email is required";
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return "Please enter a valid email address";
+  }
+  return null;
+}
+
+export function validatePassword(password: string): string | null {
+  if (!password || password.trim() === "") {
+    return "Password is required";
+  }
+  if (password.length < 8) {
+    return "Password must be at least 8 characters";
+  }
+  if (password.length > 72) {
+    return "Password cannot exceed 72 characters";
+  }
+  if (!/[A-Z]/.test(password)) {
+    return "Password must contain at least one uppercase letter";
+  }
+  if (!/[a-z]/.test(password)) {
+    return "Password must contain at least one lowercase letter";
+  }
+  if (!/[0-9]/.test(password)) {
+    return "Password must contain at least one number";
+  }
+  return null;
+}
+
+export function validateName(name: string, fieldName: string = "Name"): string | null {
+  if (!name || name.trim() === "") {
+    return `${fieldName} is required`;
+  }
+  if (name.trim().length < 2) {
+    return `${fieldName} must be at least 2 characters`;
+  }
+  if (name.trim().length > 50) {
+    return `${fieldName} cannot exceed 50 characters`;
+  }
+  // Allow letters, spaces, hyphens, and apostrophes
+  const nameRegex = /^[a-zA-Z\s\-'\u00C0-\u017F]+$/;
+  if (!nameRegex.test(name.trim())) {
+    return `${fieldName} can only contain letters, spaces, hyphens, and apostrophes`;
+  }
+  return null;
+}
+
+export function validateRequired(value: string, fieldName: string): string | null {
+  if (!value || value.trim() === "") {
+    return `${fieldName} is required`;
+  }
+  return null;
+}
+
+/**
+ * Validates the confirm-password field.
+ * Returns null (no error) when the field is empty — avoids nagging the user
+ * before they've had a chance to type anything.
+ */
+export function validateConfirmPassword(password: string, confirmPassword: string): string | null {
+  if (!confirmPassword) return null;
+  if (confirmPassword !== password) {
+    return "Passwords do not match";
+  }
+  return null;
+}
+
+export function validateMessage(message: string): string | null {
+  if (!message || message.trim() === "") {
+    return "Message is required";
+  }
+  if (message.trim().length < 10) {
+    return "Message must be at least 10 characters";
+  }
+  return null;
+}