@airxpay/sdk-ui 1.0.5 → 1.0.7

package/dist/api/client.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Frontend SDK - API Client
+ * Axios instance with interceptors for token management and refresh
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const tokenStorage_1 = require("../utils/tokenStorage");
+const BASE_URL = 'https://api.airxpay.com/api/merchant';
+let isRefreshing = false;
+let failedQueue = [];
+const processQueue = (error, token = null) => {
+    failedQueue.forEach(prom => {
+        if (error) {
+            prom.reject(error);
+        }
+        else {
+            prom.resolve(token);
+        }
+    });
+    failedQueue = [];
+};
+const createApiClient = (publicKey) => {
+    const client = axios_1.default.create({
+        baseURL: BASE_URL,
+        timeout: 30000,
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Public-Key': publicKey,
+        },
+    });
+    // Request interceptor - automatically attach token
+    client.interceptors.request.use((config) => __awaiter(void 0, void 0, void 0, function* () {
+        const token = yield (0, tokenStorage_1.getStoredToken)();
+        if (token) {
+            config.headers.Authorization = `Bearer ${token}`;
+        }
+        return config;
+    }), (error) => Promise.reject(error));
+    // Response interceptor - handle 401 and token refresh
+    client.interceptors.response.use((response) => response, (error) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const originalRequest = error.config;
+        if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) !== 401 || originalRequest._retry) {
+            return Promise.reject(error);
+        }
+        if (isRefreshing) {
+            // Queue failed requests while refreshing
+            return new Promise((resolve, reject) => {
+                failedQueue.push({ resolve, reject });
+            })
+                .then(token => {
+                originalRequest.headers.Authorization = `Bearer ${token}`;
+                return client(originalRequest);
+            })
+                .catch(err => Promise.reject(err));
+        }
+        originalRequest._retry = true;
+        isRefreshing = true;
+        try {
+            const currentToken = yield (0, tokenStorage_1.getStoredToken)();
+            if (!currentToken) {
+                throw new Error('No token to refresh');
+            }
+            // Call refresh token endpoint
+            const response = yield axios_1.default.post(`${BASE_URL}/merchant/refresh-token`, null, {
+                headers: { Authorization: `Bearer ${currentToken}` },
+            });
+            const { token: newToken } = response.data;
+            if (!newToken) {
+                throw new Error('No token in refresh response');
+            }
+            yield (0, tokenStorage_1.setStoredToken)(newToken);
+            // Update auth header
+            originalRequest.headers.Authorization = `Bearer ${newToken}`;
+            processQueue(null, newToken);
+            return client(originalRequest);
+        }
+        catch (refreshError) {
+            processQueue(refreshError, null);
+            // Clear invalid token
+            yield (0, tokenStorage_1.clearStoredToken)();
+            return Promise.reject(refreshError);
+        }
+        finally {
+            isRefreshing = false;
+        }
+    }));
+    return client;
+};
+exports.createApiClient = createApiClient;

package/dist/api/merchant.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Frontend SDK - Merchant API
+ * All merchant-related API calls
+ */
+import { AxiosInstance } from 'axios';
+import { CreateMerchantPayload, MerchantCreateResponse, MerchantStatus, KycStatus } from '../types/merchantTypes';
+export declare const initializeApi: (publicKey: string) => void;
+export declare const getApiClient: () => AxiosInstance;
+/**
+ * Verify public key during initialization
+ */
+export declare const verifyPublicKey: (publicKey: string) => Promise<{
+    valid: boolean;
+    merchantData?: any;
+}>;
+/**
+ * Create new merchant
+ * Automatically stores returned token
+ */
+export declare const createMerchant: (payload: CreateMerchantPayload) => Promise<MerchantCreateResponse>;
+/**
+ * Get merchant status
+ */
+export declare const getMerchantStatus: () => Promise<{
+    success: boolean;
+    status: MerchantStatus;
+    mode: "test" | "live";
+    isKycCompleted: boolean;
+    isBankDetailsCompleted: boolean;
+    kycStatus: KycStatus;
+    bankDetails?: any;
+}>;

package/dist/api/merchant.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Frontend SDK - Merchant API
+ * All merchant-related API calls
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMerchantStatus = exports.createMerchant = exports.verifyPublicKey = exports.getApiClient = exports.initializeApi = void 0;
+const client_1 = require("./client");
+const tokenStorage_1 = require("../utils/tokenStorage");
+let apiClient = null;
+const initializeApi = (publicKey) => {
+    if (!(publicKey === null || publicKey === void 0 ? void 0 : publicKey.trim())) {
+        throw new Error('Public key is required');
+    }
+    apiClient = (0, client_1.createApiClient)(publicKey);
+};
+exports.initializeApi = initializeApi;
+const getApiClient = () => {
+    if (!apiClient) {
+        throw new Error('API not initialized. Call initializeApi() first.');
+    }
+    return apiClient;
+};
+exports.getApiClient = getApiClient;
+/**
+ * Verify public key during initialization
+ */
+const verifyPublicKey = (publicKey) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const client = (0, exports.getApiClient)();
+        const response = yield client.post('/verify', { publicKey });
+        return response.data;
+    }
+    catch (error) {
+        throw new Error('Invalid public key');
+    }
+});
+exports.verifyPublicKey = verifyPublicKey;
+/**
+ * Create new merchant
+ * Automatically stores returned token
+ */
+const createMerchant = (payload) => __awaiter(void 0, void 0, void 0, function* () {
+    const client = (0, exports.getApiClient)();
+    const response = yield client.post('/create', payload);
+    if (response.data.token) {
+        yield (0, tokenStorage_1.setStoredToken)(response.data.token);
+    }
+    return response.data;
+});
+exports.createMerchant = createMerchant;
+/**
+ * Get merchant status
+ */
+const getMerchantStatus = () => __awaiter(void 0, void 0, void 0, function* () {
+    const client = (0, exports.getApiClient)();
+    const response = yield client.get('/status');
+    return response.data;
+});
+exports.getMerchantStatus = getMerchantStatus;

package/dist/components/common/FileUploader.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Mode } from '../../types/sellertypes';
+import { Mode } from '../../types/merchantTypes';
 interface FileUploaderProps {
     label: string;
     required?: boolean;

package/dist/components/common/StepIndicator.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { StepConfig, Mode } from '../../types/sellertypes';
+import { StepConfig, Mode } from '../../types/merchantTypes';
 interface StepIndicatorProps {
     currentStep: number;
     steps: StepConfig[];

package/dist/components/steps/BankDetails.d.ts

@@ -1,9 +1,9 @@
 import React from 'react';
-import { Seller, Mode } from '../../types/sellertypes';
+import { Merchant, Mode } from '../../types/merchantTypes';
 interface BankDetailsProps {
-    initialData: Partial<Seller>;
+    initialData: Partial<Merchant>;
     mode: Mode;
-    onNext: (data: Partial<Seller>) => void;
+    onNext: (data: Partial<Merchant>) => void;
     onBack: () => void;
 }
 declare const BankDetails: React.FC<BankDetailsProps>;