@flixora/airxpay-sdk-init-ui 1.0.0

package/dist/plugins/tokenRefreshPlugin.js

@@ -0,0 +1,91 @@
+"use strict";
+// src/plugins/tokenRefreshPlugin.ts
+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.TokenRefreshPlugin = void 0;
+const tokenStorage_1 = require("../utils/tokenStorage");
+const merchantProxy_1 = require("../api/merchantProxy");
+class TokenRefreshPlugin {
+    static getValidToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = yield (0, tokenStorage_1.getStoredToken)();
+            if (!token) {
+                return null;
+            }
+            // Check if token is expired (simplified - in production use JWT decode)
+            const isExpired = this.isTokenExpired(token);
+            if (!isExpired) {
+                return token;
+            }
+            // Token expired, refresh it
+            return this.refreshToken();
+        });
+    }
+    static refreshToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // If already refreshing, return the existing promise
+            if (this.refreshPromise) {
+                return this.refreshPromise;
+            }
+            this.refreshPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const response = yield (0, merchantProxy_1.refreshMerchantTokenInternal)();
+                    if (response === null || response === void 0 ? void 0 : response.token) {
+                        yield (0, tokenStorage_1.setStoredToken)(response.token);
+                        this.processQueue(null, response.token);
+                        resolve(response.token);
+                    }
+                    else {
+                        throw new Error('No token in refresh response');
+                    }
+                }
+                catch (error) {
+                    yield (0, tokenStorage_1.clearStoredToken)();
+                    this.processQueue(error, null);
+                    reject(error);
+                }
+                finally {
+                    this.isRefreshing = false;
+                    this.refreshPromise = null;
+                }
+            }));
+            return this.refreshPromise;
+        });
+    }
+    static processQueue(error, token = null) {
+        this.failedQueue.forEach(promise => {
+            if (error) {
+                promise.reject(error);
+            }
+            else {
+                promise.resolve(token);
+            }
+        });
+        this.failedQueue = [];
+    }
+    static isTokenExpired(token) {
+        try {
+            const payload = JSON.parse(atob(token.split('.')[1]));
+            const exp = payload.exp * 1000; // Convert to milliseconds
+            return Date.now() >= exp - 60000; // Consider expired 1 minute before actual expiry
+        }
+        catch (_a) {
+            return true; // If can't decode, consider expired
+        }
+    }
+    static addToQueue(resolve, reject) {
+        this.failedQueue.push({ resolve, reject });
+    }
+}
+exports.TokenRefreshPlugin = TokenRefreshPlugin;
+TokenRefreshPlugin.isRefreshing = false;
+TokenRefreshPlugin.failedQueue = [];
+TokenRefreshPlugin.refreshPromise = null;

package/dist/schema/validators.d.ts

@@ -0,0 +1,9 @@
+import { CreateMerchantPayload } from '../types/merchantTypes';
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export declare class PayloadValidator {
+    static validateCreateMerchant(payload: CreateMerchantPayload): ValidationError[];
+    static validatePublicKey(publicKey: string): ValidationError[];
+}

package/dist/schema/validators.js

@@ -0,0 +1,57 @@
+"use strict";
+// src/schema/validators.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayloadValidator = void 0;
+class PayloadValidator {
+    static validateCreateMerchant(payload) {
+        var _a, _b, _c;
+        const errors = [];
+        // Merchant Name validation
+        if (!((_a = payload.merchantName) === null || _a === void 0 ? void 0 : _a.trim())) {
+            errors.push({ field: 'merchantName', message: 'Merchant name is required' });
+        }
+        else if (payload.merchantName.length < 2) {
+            errors.push({ field: 'merchantName', message: 'Name must be at least 2 characters' });
+        }
+        else if (payload.merchantName.length > 100) {
+            errors.push({ field: 'merchantName', message: 'Name must be less than 100 characters' });
+        }
+        // Email validation
+        if (!((_b = payload.merchantEmail) === null || _b === void 0 ? void 0 : _b.trim())) {
+            errors.push({ field: 'merchantEmail', message: 'Email is required' });
+        }
+        else {
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(payload.merchantEmail)) {
+                errors.push({ field: 'merchantEmail', message: 'Invalid email format' });
+            }
+        }
+        // Phone validation (optional)
+        if (payload.merchantPhone) {
+            const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+            if (!phoneRegex.test(payload.merchantPhone.replace(/[\s-]/g, ''))) {
+                errors.push({ field: 'merchantPhone', message: 'Invalid phone number format' });
+            }
+        }
+        // Business type validation
+        if (payload.businessType && !['individual', 'company'].includes(payload.businessType)) {
+            errors.push({ field: 'businessType', message: 'Invalid business type' });
+        }
+        // Business name required for companies
+        if (payload.businessType === 'company' && !((_c = payload.businessName) === null || _c === void 0 ? void 0 : _c.trim())) {
+            errors.push({ field: 'businessName', message: 'Business name is required for companies' });
+        }
+        return errors;
+    }
+    static validatePublicKey(publicKey) {
+        const errors = [];
+        if (!(publicKey === null || publicKey === void 0 ? void 0 : publicKey.trim())) {
+            errors.push({ field: 'publicKey', message: 'Public key is required' });
+        }
+        else if (publicKey.length < 16) {
+            errors.push({ field: 'publicKey', message: 'Invalid public key format' });
+        }
+        return errors;
+    }
+}
+exports.PayloadValidator = PayloadValidator;

package/dist/sdk/airxpay.d.ts

@@ -0,0 +1,9 @@
+import { AirXPayConfig } from '../types/type';
+export declare class useIsAirXPayReady {
+    private publicKey;
+    constructor(config: AirXPayConfig);
+    initialize(): Promise<{
+        valid: boolean;
+        merchantData?: any;
+    }>;
+}

package/dist/sdk/airxpay.js

@@ -0,0 +1,26 @@
+"use strict";
+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.useIsAirXPayReady = void 0;
+const merchantProxy_1 = require("../api/merchantProxy");
+class useIsAirXPayReady {
+    constructor(config) {
+        if (!config.publicKey)
+            throw new Error("Public key is required");
+        this.publicKey = config.publicKey;
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, merchantProxy_1.verifyPublicKey)(this.publicKey);
+        });
+    }
+}
+exports.useIsAirXPayReady = useIsAirXPayReady;

package/dist/services/apiService.d.ts

@@ -0,0 +1,34 @@
+import { CreateMerchantPayload, MerchantCreateResponse, MerchantStatusResponse } from '../types/merchantTypes';
+declare class AirXPayService {
+    private initialized;
+    /**
+     * Initialize the SDK with public key
+     */
+    initialize(publicKey: string): Promise<void>;
+    /**
+     * Check if SDK is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Create merchant (called on final step)
+     */
+    createMerchant(payload: CreateMerchantPayload): Promise<MerchantCreateResponse>;
+    /**
+     * Get merchant status (used in onboarding complete screen)
+     */
+    getMerchantStatus(): Promise<MerchantStatusResponse>;
+    /**
+     * Refresh merchant token
+     */
+    refreshToken(): Promise<void>;
+    /**
+     * Check if SDK is initialized
+     */
+    private checkInitialized;
+    /**
+     * Handle and normalize errors
+     */
+    private handleError;
+}
+export declare const airxpayService: AirXPayService;
+export {};

package/dist/services/apiService.js

@@ -0,0 +1,133 @@
+"use strict";
+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.airxpayService = void 0;
+// services/airxpay.service.ts
+const merchantProxy_1 = require("../api/merchantProxy");
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const PUBLIC_KEY_STORAGE = '@airxpay_public_key';
+class AirXPayService {
+    constructor() {
+        this.initialized = false;
+    }
+    /**
+     * Initialize the SDK with public key
+     */
+    initialize(publicKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!(publicKey === null || publicKey === void 0 ? void 0 : publicKey.trim())) {
+                    throw new Error('Public key is required');
+                }
+                (0, merchantProxy_1.initializeInternalApi)(publicKey);
+                yield async_storage_1.default.setItem(PUBLIC_KEY_STORAGE, publicKey);
+                this.initialized = true;
+                console.log('✅ AirXPay SDK initialized successfully');
+            }
+            catch (error) {
+                console.error('❌ Failed to initialize AirXPay SDK:', error);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Check if SDK is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Create merchant (called on final step)
+     */
+    createMerchant(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialized();
+            try {
+                console.log('📝 Creating merchant with payload:', Object.assign(Object.assign({}, payload), { merchantEmail: payload.merchantEmail }));
+                const response = yield (0, merchantProxy_1.createMerchantInternal)(payload);
+                // Token is automatically stored by the SDK
+                console.log('✅ Merchant created successfully:', response.merchant.merchantId);
+                return response;
+            }
+            catch (error) {
+                console.error('❌ Failed to create merchant:', error.message);
+                throw this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Get merchant status (used in onboarding complete screen)
+     */
+    getMerchantStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialized();
+            try {
+                console.log('🔍 Fetching merchant status...');
+                const response = yield (0, merchantProxy_1.getMerchantStatusInternal)();
+                console.log('✅ Merchant status retrieved:', response.status);
+                return response;
+            }
+            catch (error) {
+                console.error('❌ Failed to get merchant status:', error.message);
+                throw this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Refresh merchant token
+     */
+    refreshToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkInitialized();
+            try {
+                console.log('🔄 Refreshing merchant token...');
+                yield (0, merchantProxy_1.refreshMerchantTokenInternal)();
+                console.log('✅ Token refreshed successfully');
+            }
+            catch (error) {
+                console.error('❌ Failed to refresh token:', error.message);
+                throw this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Check if SDK is initialized
+     */
+    checkInitialized() {
+        if (!this.initialized) {
+            throw new Error('AirXPay SDK not initialized. Call initialize() first.');
+        }
+    }
+    /**
+     * Handle and normalize errors
+     */
+    handleError(error) {
+        var _a, _b;
+        if (error.response) {
+            // Server responded with error
+            const message = ((_a = error.response.data) === null || _a === void 0 ? void 0 : _a.message) || ((_b = error.response.data) === null || _b === void 0 ? void 0 : _b.error) || 'Server error';
+            return new Error(message);
+        }
+        else if (error.request) {
+            // Request was made but no response
+            return new Error('Network error. Please check your connection.');
+        }
+        else {
+            // Something else happened
+            return error;
+        }
+    }
+}
+// Singleton instance
+exports.airxpayService = new AirXPayService();

package/dist/types/dev.d.ts

@@ -0,0 +1 @@
+export declare const __DEV__: boolean;

package/dist/types/dev.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__DEV__ = void 0;
+exports.__DEV__ = process.env.NODE_ENV !== "production";

package/dist/types/dev.ts

@@ -0,0 +1,2 @@
+export const __DEV__ =
+  process.env.NODE_ENV !== "production";

package/dist/types/merchantTypes.d.ts

@@ -0,0 +1,111 @@
+export type BusinessType = "individual" | "company";
+export type Mode = "test" | "live";
+export type MerchantStatus = "active" | "suspended" | "blocked";
+export type KycStatus = "not_submitted" | "pending" | "verified" | "rejected";
+export interface KYCDetails {
+    panNumber?: string;
+    aadhaarNumber?: string;
+    gstNumber?: string;
+    registeredBusinessName?: string;
+    panCardUrl?: string;
+    aadhaarUrl?: string;
+    addressProofUrl?: string;
+    selfieUrl?: string;
+}
+export interface BankDetails {
+    accountHolderName: string;
+    bankName: string;
+    accountNumber: string;
+    ifscCode: string;
+    upiId?: string;
+    cancelledChequeUrl?: string;
+}
+export interface Merchant {
+    _id?: string;
+    merchantId: string;
+    status: MerchantStatus;
+    kycStatus: KycStatus;
+    isKycCompleted: boolean;
+    isBankDetailsCompleted: boolean;
+    mode: Mode;
+    merchantDID?: string;
+    walletId?: string;
+    merchantName: string;
+    merchantEmail: string;
+    merchantPhone?: string;
+    businessName?: string;
+    businessType?: BusinessType;
+    businessCategory?: string;
+    country?: string;
+    nationality?: string;
+    dob?: string;
+    kycDetails?: KYCDetails;
+    bankDetails?: BankDetails;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface CreateMerchantPayload {
+    merchantName: string;
+    merchantEmail: string;
+    merchantPhone?: string;
+    businessName?: string;
+    businessType?: BusinessType;
+    businessCategory?: string;
+    country?: string;
+    dob?: Date;
+    nationality?: string;
+    mode?: Mode;
+    metadata?: Record<string, unknown>;
+}
+export interface MerchantCreateResponse {
+    success: boolean;
+    token: string;
+    merchant: Merchant;
+}
+export interface MerchantOnboardingProps {
+    merchantId?: string;
+    mode: Mode;
+    initialStep?: number;
+    isKycCompleted: boolean;
+    isBankDetailsCompleted: boolean;
+    kycStatus: KycStatus;
+    status: MerchantStatus;
+    initialData?: Partial<Merchant>;
+    onNext: (stepData: Partial<Merchant>, step: number) => void;
+    onBack: (currentStep: number) => void;
+    onComplete: (merchantData: Merchant) => void;
+    loading?: boolean;
+}
+export interface StepConfig {
+    id: number;
+    name: string;
+    key: "basic" | "kyc" | "bank" | "complete" | "final";
+    isRequired: boolean;
+}
+export interface FormErrors {
+    [key: string]: string | undefined;
+}
+export interface StepCompletion {
+    basic: boolean;
+    kyc: boolean;
+    bank: boolean;
+}
+export interface AirXPayConfig {
+    publicKey: string;
+    customNavigation?: {
+        buttonText: string;
+        screenName: string;
+    };
+}
+export interface MerchantStatusResponse {
+    merchantId: string;
+    merchantName: string;
+    merchantEmail: string;
+    status: 'active' | 'suspended' | 'blocked' | 'pending';
+    kycStatus: 'not_submitted' | 'pending' | 'verified' | 'rejected';
+    kycCompleted: boolean;
+    bankDetailsCompleted: boolean;
+    mode: 'test' | 'live';
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/types/merchantTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/merchantTypes.ts

@@ -0,0 +1,116 @@
+export type BusinessType = "individual" | "company";
+export type Mode = "test" | "live";
+export type MerchantStatus = "active" | "suspended" | "blocked";
+export type KycStatus = "not_submitted" | "pending" | "verified" | "rejected";
+
+export interface KYCDetails {
+  panNumber?: string;
+  aadhaarNumber?: string;
+  gstNumber?: string;
+  registeredBusinessName?: string;
+  panCardUrl?: string;
+  aadhaarUrl?: string;
+  addressProofUrl?: string;
+  selfieUrl?: string;
+}
+export interface BankDetails {
+  accountHolderName: string;
+  bankName: string;
+  accountNumber: string;
+  ifscCode: string;
+  upiId?: string;
+  cancelledChequeUrl?: string;
+}
+
+export interface Merchant {
+  _id?: string;
+  merchantId: string;
+  status: MerchantStatus;
+  kycStatus: KycStatus;
+  isKycCompleted: boolean;
+  isBankDetailsCompleted: boolean;
+  mode: Mode;
+  merchantDID?: string;
+  walletId?: string;
+  merchantName: string;
+  merchantEmail: string;
+  merchantPhone?: string;
+  businessName?: string;
+  businessType?: BusinessType;
+  businessCategory?: string;
+  country?: string;
+  nationality?: string;
+  dob?: string;
+  kycDetails?: KYCDetails;
+  bankDetails?: BankDetails;
+  createdAt?: string;       // <— added
+  updatedAt?: string;       // <— added
+}
+
+export interface CreateMerchantPayload {
+  merchantName: string;
+  merchantEmail: string;
+  merchantPhone?: string;
+  businessName?: string;
+  businessType?: BusinessType;
+  businessCategory?: string;
+  country?: string;
+  dob?: Date;
+  nationality?: string;
+  mode?: Mode;
+  metadata?: Record<string, unknown>;
+}
+
+export interface MerchantCreateResponse {
+  success: boolean;
+  token: string;
+  merchant: Merchant;
+}
+
+export interface MerchantOnboardingProps {
+  merchantId?: string;
+  mode: Mode;
+  initialStep?: number;
+  isKycCompleted: boolean;
+  isBankDetailsCompleted: boolean;
+  kycStatus: KycStatus;
+  status: MerchantStatus;
+  initialData?: Partial<Merchant>;
+  onNext: (stepData: Partial<Merchant>, step: number) => void;
+  onBack: (currentStep: number) => void;
+  onComplete: (merchantData: Merchant) => void;
+  loading?: boolean;
+}
+
+export interface StepConfig {
+  id: number;
+  name: string;
+  key: "basic" | "kyc" | "bank" | "complete" | "final";
+  isRequired: boolean;
+}
+export interface FormErrors {
+  [key: string]: string | undefined;
+}
+export interface StepCompletion {
+  basic: boolean;
+  kyc: boolean;
+  bank: boolean;
+}
+
+export interface AirXPayConfig {
+  publicKey: string;
+  customNavigation?: { buttonText: string; screenName: string };
+}
+
+export interface MerchantStatusResponse {
+  merchantId: string;
+  merchantName: string;
+  merchantEmail: string;
+  status: 'active' | 'suspended' | 'blocked' | 'pending';
+  kycStatus: 'not_submitted' | 'pending' | 'verified' | 'rejected';
+  kycCompleted: boolean;
+  bankDetailsCompleted: boolean;
+  mode: 'test' | 'live';
+  createdAt: string;
+  updatedAt: string;
+}

package/dist/types/type.d.ts

@@ -0,0 +1,8 @@
+export interface AirXPayConfig {
+    publicKey: string;
+}
+export interface MerchantData {
+    merchantName: string;
+    merchantEmail: string;
+    merchantPhone?: string;
+}

package/dist/types/type.js

@@ -0,0 +1,3 @@
+"use strict";
+// types/merchantTypes.ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/type.ts

@@ -0,0 +1,11 @@
+// types/merchantTypes.ts
+
+export interface AirXPayConfig {
+  publicKey: string;
+}
+
+export interface MerchantData {
+  merchantName: string;
+  merchantEmail: string;
+  merchantPhone?: string;
+}

package/dist/utils/jwt.d.ts

@@ -0,0 +1,10 @@
+export interface JWTPayload {
+    merchantId?: string;
+    sub?: string;
+    exp?: number;
+    iat?: number;
+    [key: string]: unknown;
+}
+export declare function decodeJWT(token: string): JWTPayload | null;
+export declare function getMerchantIdFromToken(token: string): string | null;
+export declare function isTokenExpired(token: string): boolean;

package/dist/utils/jwt.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeJWT = decodeJWT;
+exports.getMerchantIdFromToken = getMerchantIdFromToken;
+exports.isTokenExpired = isTokenExpired;
+function decodeJWT(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3)
+            throw new Error('Invalid JWT format');
+        const jsonPayload = decodeURIComponent(atob(parts[1].replace(/-/g, '+').replace(/_/g, '/'))
+            .split('').map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function getMerchantIdFromToken(token) {
+    const payload = decodeJWT(token);
+    return (payload === null || payload === void 0 ? void 0 : payload.merchantId) || (payload === null || payload === void 0 ? void 0 : payload.sub) || null;
+}
+function isTokenExpired(token) {
+    const payload = decodeJWT(token);
+    if (!(payload === null || payload === void 0 ? void 0 : payload.exp))
+        return false;
+    return payload.exp < Math.floor(Date.now() / 1000);
+}

package/dist/utils/tokenStorage.d.ts

@@ -0,0 +1,5 @@
+export declare const getStoredToken: () => Promise<string | null>;
+export declare const setStoredToken: (token: string) => Promise<void>;
+export declare const clearStoredToken: () => Promise<void>;
+export declare const storeMerchantData: (data: any) => Promise<void>;
+export declare const getStoredMerchantData: () => Promise<any | null>;