@voxepay/checkout 0.4.0 → 0.5.1

package/src/api/client.ts

@@ -55,15 +55,27 @@ export type DVAPaymentStatus =
 export interface PaymentStatusResponse {
     id: string;
     transactionRef: string;
-    status: DVAPaymentStatus;
+    customerId?: string;
     amount: number;
-    paymentMethod: string;
+    currency: string;
+    paymentMethod: 'CARD' | 'BANK_TRANSFER';
+    status: DVAPaymentStatus;
+    paymentId?: string;
+    otpRequired?: boolean;
+    authorizationUrl?: string;
+    message?: string;
+    otpAttempts?: number;
+    maxOtpAttempts?: number;
+    createdAt: string;
     completedAt?: string;
     virtualAccount?: {
         account_number: string;
+        account_name: string;
+        bank_name: string;
+        bank_code: string;
+        expires_at: string;
         status: string;
     };
-    [key: string]: unknown;
 }
 
 export interface ValidateOTPRequest {
@@ -91,13 +103,22 @@ export interface ResendOTPRequest {
 
 export class VoxePayApiClient {
     private apiKey: string;
+    private bearerToken?: string;
     private baseUrl: string;
 
-    constructor(apiKey: string, baseUrl?: string) {
+    constructor(apiKey: string, baseUrl?: string, bearerToken?: string) {
         this.apiKey = apiKey;
+        this.bearerToken = bearerToken;
         this.baseUrl = baseUrl || DEFAULT_BASE_URL;
     }
 
+    /**
+     * Set Bearer token for authenticated endpoints (like getPaymentStatus)
+     */
+    setBearerToken(token: string): void {
+        this.bearerToken = token;
+    }
+
     private async request<T>(endpoint: string, body: unknown): Promise<T> {
         const url = `${this.baseUrl}${endpoint}`;
 
@@ -125,15 +146,22 @@ export class VoxePayApiClient {
         return data as T;
     }
 
-    private async get<T>(endpoint: string): Promise<T> {
+    private async get<T>(endpoint: string, useBearerAuth = false): Promise<T> {
         const url = `${this.baseUrl}${endpoint}`;
 
+        const headers: Record<string, string> = {
+            'Accept': 'application/json',
+        };
+
+        if (useBearerAuth && this.bearerToken) {
+            headers['Authorization'] = `Bearer ${this.bearerToken}`;
+        } else {
+            headers['X-API-Key'] = this.apiKey;
+        }
+
         const response = await fetch(url, {
             method: 'GET',
-            headers: {
-                'X-API-Key': this.apiKey,
-                'Accept': 'application/json',
-            },
+            headers,
         });
 
         const data = await response.json();
@@ -144,6 +172,7 @@ export class VoxePayApiClient {
             error.code = data?.errorCode || data?.code || `HTTP_${response.status}`;
             error.status = response.status;
             error.data = data;
+            error.success = data?.success;
             throw error;
         }
 
@@ -181,11 +210,40 @@ export class VoxePayApiClient {
 
     /**
      * Get payment status by transaction reference (used for polling DVA payments)
+     * Uses public endpoint - no authentication required
+     * @param transactionRef - The transaction reference to check
+     * @param options - Optional query parameters (simulateWebhook, bypassKey)
      */
-    async getPaymentStatus(transactionRef: string): Promise<PaymentStatusResponse> {
-        const response = await this.get<{ success: boolean; data: PaymentStatusResponse }>(
-            `/api/v1/payments/${encodeURIComponent(transactionRef)}`
+    async getPaymentStatus(
+        transactionRef: string,
+        options?: { simulateWebhook?: boolean; bypassKey?: string }
+    ): Promise<PaymentStatusResponse> {
+        let endpoint = `/api/v1/payments/public/${encodeURIComponent(transactionRef)}`;
+
+        // Add query parameters if provided
+        const queryParams: string[] = [];
+        if (options?.simulateWebhook !== undefined) {
+            queryParams.push(`simulateWebhook=${options.simulateWebhook}`);
+        }
+        if (options?.bypassKey) {
+            queryParams.push(`bypassKey=${encodeURIComponent(options.bypassKey)}`);
+        }
+        if (queryParams.length > 0) {
+            endpoint += `?${queryParams.join('&')}`;
+        }
+
+        const response = await this.get<{ success: boolean; message: string; data: PaymentStatusResponse; errorCode?: string }>(
+            endpoint,
+            false // Use X-API-Key (public endpoint doesn't need Bearer token)
         );
+
+        if (!response.success) {
+            const error: any = new Error(response.message || 'Payment not found');
+            error.code = response.errorCode || 'PAYMENT_NOT_FOUND';
+            error.success = false;
+            throw error;
+        }
+
         return response.data;
     }
 }

package/src/components/modal.ts

@@ -999,7 +999,13 @@ export class VoxePayModal {
       if (!this.apiClient || !this.state.transactionRef) return;
 
       try {
-        const statusData = await this.apiClient.getPaymentStatus(this.state.transactionRef);
+        const statusData = await this.apiClient.getPaymentStatus(
+          this.state.transactionRef,
+          {
+            simulateWebhook: this.options._sdkConfig?.simulateWebhook,
+            bypassKey: this.options._sdkConfig?.bypassKey,
+          }
+        );
         this.handlePollingStatusUpdate(statusData.status, statusData);
       } catch (error: any) {
         console.error('[VoxePay] Status polling error:', error);

package/src/types.ts

@@ -18,6 +18,16 @@ export interface VoxePayConfig {
     locale?: string;
     /** Custom CSS variables to override default theme */
     customStyles?: Partial<VoxePayTheme>;
+    /**
+     * Simulate webhook on payment status polling (useful for testing in dev/sandbox).
+     * When true, the API will trigger a simulated webhook on each status check.
+     */
+    simulateWebhook?: boolean;
+    /**
+     * Bypass key required when simulateWebhook is true.
+     * Only needed in sandbox/testing environments.
+     */
+    bypassKey?: string;
 }
 
 /**
@@ -83,6 +93,8 @@ export interface CheckoutOptions {
         apiKey: string;
         organizationId: string;
         baseUrl?: string;
+        simulateWebhook?: boolean;
+        bypassKey?: string;
     };
     /** Callback when payment succeeds */
     onSuccess: (result: PaymentResult) => void;

package/src/voxepay.ts

@@ -109,6 +109,8 @@ class VoxePaySDK {
                 apiKey: this.config!.apiKey,
                 organizationId: this.config!.organizationId,
                 baseUrl: this.config!.baseUrl,
+                simulateWebhook: this.config!.simulateWebhook,
+                bypassKey: this.config!.bypassKey,
             },
             onClose: () => {
                 this.currentModal = null;