@smart-pay-chain/otp 2.0.0

package/dist/otp-client.js

@@ -0,0 +1,314 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtpClient = void 0;
+const http_client_1 = require("./http-client");
+const types_1 = require("./types");
+/**
+ * Main OTP client for interacting with the OTP verification service
+ *
+ * @example
+ * ```typescript
+ * const client = new OtpClient({ apiKey: 'your-api-key' });
+ *
+ * // Send an OTP
+ * const result = await client.sendOtp({
+ *   phoneNumber: '+995555123456',
+ *   channel: OtpChannel.SMS,
+ * });
+ *
+ * // Verify the OTP
+ * const verification = await client.verifyOtp({
+ *   requestId: result.requestId,
+ *   code: '123456',
+ * });
+ * ```
+ */
+class OtpClient {
+    /**
+     * Create a new OTP client
+     *
+     * @param config - Configuration options
+     */
+    constructor(config) {
+        this.serverConfig = null;
+        this.serverConfigFetchedAt = null;
+        this.CONFIG_CACHE_TTL = 3600000; // 1 hour in milliseconds
+        if (!config.apiKey) {
+            throw new Error('API key is required');
+        }
+        this.http = new http_client_1.HttpClient(config);
+        // Auto-fetch configuration if requested
+        if (config.autoConfig) {
+            this.getConfig().catch((error) => {
+                // Silent fail for auto-config, log warning
+                console.warn('Failed to auto-fetch SDK configuration:', error.message);
+            });
+        }
+    }
+    /**
+     * Send an OTP to a phone number
+     *
+     * @param options - Options for sending the OTP
+     * @returns Promise resolving to the OTP request details
+     *
+     * @example
+     * ```typescript
+     * const result = await client.sendOtp({
+     *   phoneNumber: '+995555123456',
+     *   channel: OtpChannel.SMS,
+     *   ttl: 300,
+     *   length: 6,
+     *   metadata: { userId: '12345' }
+     * });
+     *
+     * console.log(result.requestId); // Save this for verification
+     * console.log(result.expiresAt);
+     * ```
+     */
+    async sendOtp(options) {
+        this.validatePhoneNumber(options.phoneNumber);
+        const body = {
+            phoneNumber: options.phoneNumber,
+            channel: options.channel || types_1.OtpChannel.SMS,
+            ttl: options.ttl || 300,
+            length: options.length || 6,
+            metadata: options.metadata,
+        };
+        const headers = {};
+        // Auto-generate idempotency key if not provided
+        headers['X-Idempotency-Key'] = options.idempotencyKey || this.generateIdempotencyKey();
+        const response = await this.http.post('/api/v1/otp/send', body, {
+            headers,
+        });
+        // Convert string date to Date object
+        return {
+            ...response,
+            expiresAt: new Date(response.expiresAt),
+        };
+    }
+    /**
+     * Verify an OTP code
+     *
+     * @param options - Options for verifying the OTP
+     * @returns Promise resolving to the verification result
+     *
+     * @example
+     * ```typescript
+     * const result = await client.verifyOtp({
+     *   requestId: 'req_123456',
+     *   code: '123456',
+     *   ipAddress: '192.168.1.1',
+     *   userAgent: 'Mozilla/5.0...'
+     * });
+     *
+     * if (result.success) {
+     *   console.log('OTP verified successfully!');
+     * }
+     * ```
+     */
+    async verifyOtp(options) {
+        if (!options.requestId) {
+            throw new Error('Request ID is required');
+        }
+        if (!options.code || options.code.length < 4 || options.code.length > 8) {
+            throw new Error('Code must be between 4 and 8 characters');
+        }
+        const body = {
+            requestId: options.requestId,
+            code: options.code,
+            ipAddress: options.ipAddress,
+            userAgent: options.userAgent,
+        };
+        return await this.http.post('/api/v1/otp/verify', body);
+    }
+    /**
+     * Resend an OTP (generates a new code for the same phone number)
+     *
+     * @param options - Options for resending the OTP
+     * @returns Promise resolving to the new OTP request details
+     *
+     * @example
+     * ```typescript
+     * const result = await client.resendOtp({
+     *   requestId: 'req_123456'
+     * });
+     *
+     * console.log('New OTP sent:', result.requestId);
+     * ```
+     */
+    async resendOtp(options) {
+        if (!options.requestId) {
+            throw new Error('Request ID is required');
+        }
+        // Auto-generate idempotency key for resend operations
+        const headers = {
+            'X-Idempotency-Key': this.generateIdempotencyKey(),
+        };
+        const response = await this.http.post(`/api/v1/otp/${options.requestId}/resend`, undefined, { headers });
+        // Convert string date to Date object
+        return {
+            ...response,
+            expiresAt: new Date(response.expiresAt),
+        };
+    }
+    /**
+     * Get OTP status (authenticated endpoint)
+     *
+     * @param requestId - The request ID from sendOtp()
+     * @returns Promise resolving to the OTP status
+     *
+     * @example
+     * ```typescript
+     * const status = await client.getStatus('req_123456');
+     * console.log(status.status); // 'PENDING' | 'SENT' | 'VERIFIED' | 'EXPIRED' | 'FAILED'
+     * console.log(status.attempts); // Number of verification attempts
+     * console.log(status.isExpired); // Whether OTP is expired
+     * ```
+     */
+    async getStatus(requestId) {
+        if (!requestId) {
+            throw new Error('Request ID is required');
+        }
+        const response = await this.http.get(`/api/v1/otp/${requestId}`);
+        // Convert string dates to Date objects
+        return {
+            ...response,
+            expiresAt: new Date(response.expiresAt),
+            verifiedAt: response.verifiedAt ? new Date(response.verifiedAt) : null,
+            createdAt: new Date(response.createdAt),
+        };
+    }
+    /**
+     * Get OTP status with code (public endpoint for testing/development)
+     *
+     * ⚠️ WARNING: This endpoint returns the actual OTP code and should ONLY be used
+     * in development/testing environments! Never use in production client code.
+     *
+     * This method polls for up to 30 seconds waiting for SMS delivery.
+     *
+     * @param requestId - The request ID from sendOtp()
+     * @returns Promise resolving to the OTP status with code
+     *
+     * @example
+     * ```typescript
+     * // For automated testing only!
+     * const status = await client.getStatusWithCode('req_123456');
+     * console.log(status.otpCode); // The actual OTP code
+     * console.log(status.smsProvider); // Which provider was used
+     * ```
+     */
+    async getStatusWithCode(requestId) {
+        if (!requestId) {
+            throw new Error('Request ID is required');
+        }
+        const response = await this.http.get(`/api/v1/otp/${requestId}/status`);
+        // Convert string dates to Date objects
+        return {
+            ...response,
+            expiresAt: new Date(response.expiresAt),
+            verifiedAt: response.verifiedAt ? new Date(response.verifiedAt) : null,
+            createdAt: new Date(response.createdAt),
+        };
+    }
+    /**
+     * Get SDK configuration from server
+     *
+     * Fetches and caches configuration from the server. The configuration includes
+     * rate limits, supported features, test mode status, and more. Results are
+     * cached for 1 hour.
+     *
+     * @param forceRefresh - Force refresh the cached configuration
+     * @returns Promise resolving to the SDK configuration
+     *
+     * @example
+     * ```typescript
+     * const config = await client.getConfig();
+     * console.log(config.features.testMode); // Check if test mode is enabled
+     * console.log(config.otpConfig.length); // Default OTP length
+     * console.log(config.rateLimits); // Rate limit information
+     * ```
+     */
+    async getConfig(forceRefresh = false) {
+        // Return cached config if valid
+        if (!forceRefresh &&
+            this.serverConfig &&
+            this.serverConfigFetchedAt &&
+            Date.now() - this.serverConfigFetchedAt < this.CONFIG_CACHE_TTL) {
+            return this.serverConfig;
+        }
+        // Fetch new configuration
+        const config = await this.http.get('/api/v1/sdk/config');
+        // Cache the configuration
+        this.serverConfig = config;
+        this.serverConfigFetchedAt = Date.now();
+        // Log warning if test mode is enabled
+        if (config.features.testMode) {
+            console.warn('⚠️  Test mode is enabled on the server. Use test phone numbers for testing:', config.testMode?.testPhoneNumbers);
+        }
+        return config;
+    }
+    /**
+     * Test connectivity to the OTP service
+     *
+     * @returns Promise resolving to true if connection is successful
+     *
+     * @example
+     * ```typescript
+     * const isConnected = await client.testConnection();
+     * if (isConnected) {
+     *   console.log('✓ Connected to OTP service');
+     * }
+     * ```
+     */
+    async testConnection() {
+        try {
+            await this.http.get('/api/v1/sdk/test');
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Check if server is in test mode
+     *
+     * @returns Promise resolving to true if test mode is enabled
+     *
+     * @example
+     * ```typescript
+     * const testMode = await client.isTestMode();
+     * if (testMode) {
+     *   console.log('Server is in test mode - use test phone numbers');
+     * }
+     * ```
+     */
+    async isTestMode() {
+        try {
+            const config = await this.getConfig();
+            return config.features.testMode || false;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Generate a unique idempotency key
+     *
+     * @returns A unique idempotency key in the format `{timestamp}-{random}`
+     */
+    generateIdempotencyKey() {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 15);
+        return `${timestamp}-${random}`;
+    }
+    /**
+     * Validate phone number format (E.164)
+     */
+    validatePhoneNumber(phoneNumber) {
+        const e164Regex = /^\+[1-9]\d{1,14}$/;
+        if (!e164Regex.test(phoneNumber)) {
+            throw new Error('Invalid phone number format. Must be in E.164 format (e.g., +995555123456)');
+        }
+    }
+}
+exports.OtpClient = OtpClient;

package/dist/types.d.ts

@@ -0,0 +1,275 @@
+/**
+ * OTP Channel types
+ */
+export declare enum OtpChannel {
+    SMS = "SMS",
+    WHATSAPP = "WHATSAPP",
+    VOICE = "VOICE"
+}
+/**
+ * Error codes returned by the API
+ */
+export declare enum ErrorCode {
+    AUTHENTICATION_FAILED = "AUTHENTICATION_FAILED",
+    INVALID_API_KEY = "INVALID_API_KEY",
+    API_KEY_REVOKED = "API_KEY_REVOKED",
+    INVALID_PHONE_NUMBER = "INVALID_PHONE_NUMBER",
+    PHONE_NUMBER_BLOCKED = "PHONE_NUMBER_BLOCKED",
+    OTP_EXPIRED = "OTP_EXPIRED",
+    OTP_MAX_ATTEMPTS = "OTP_MAX_ATTEMPTS",
+    INVALID_OTP_CODE = "INVALID_OTP_CODE",
+    OTP_NOT_FOUND = "OTP_NOT_FOUND",
+    OTP_ALREADY_VERIFIED = "OTP_ALREADY_VERIFIED",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    INSUFFICIENT_BALANCE = "INSUFFICIENT_BALANCE",
+    PAYMENT_REQUIRED = "PAYMENT_REQUIRED",
+    NO_BRAND_CONFIGURED = "NO_BRAND_CONFIGURED",
+    BRAND_NOT_AUTHORIZED = "BRAND_NOT_AUTHORIZED",
+    BRAND_PENDING_APPROVAL = "BRAND_PENDING_APPROVAL",
+    BRAND_CREATION_FAILED = "BRAND_CREATION_FAILED",
+    SMS_SEND_FAILED = "SMS_SEND_FAILED",
+    PROVIDER_UNAVAILABLE = "PROVIDER_UNAVAILABLE",
+    VALIDATION_ERROR = "VALIDATION_ERROR",
+    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
+    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE",
+    IDEMPOTENCY_KEY_CONFLICT = "IDEMPOTENCY_KEY_CONFLICT"
+}
+/**
+ * SDK Platform types
+ */
+export type SdkPlatform = 'node' | 'browser' | 'react-native' | 'unknown';
+/**
+ * SDK Language types
+ */
+export type SdkLanguage = 'typescript' | 'javascript';
+/**
+ * Configuration options for the OTP client
+ */
+export interface OtpClientConfig {
+    /** Your API key for authentication */
+    apiKey: string;
+    /** Base URL of the OTP service (default: https://otp.smartpaychain.com) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum number of retry attempts for failed requests (default: 3) */
+    maxRetries?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+    /** SDK platform (auto-detected if not provided) */
+    platform?: SdkPlatform;
+    /** SDK language (auto-detected if not provided) */
+    language?: SdkLanguage;
+    /** Auto-fetch configuration from server on initialization (default: false) */
+    autoConfig?: boolean;
+}
+/**
+ * Options for sending an OTP
+ */
+export interface SendOtpOptions {
+    /** Phone number in E.164 format (e.g., +995555123456) */
+    phoneNumber: string;
+    /** Delivery channel (default: SMS) */
+    channel?: OtpChannel;
+    /** Time-to-live in seconds (60-600, default: 300) */
+    ttl?: number;
+    /** OTP code length (4-8 digits, default: 6) */
+    length?: number;
+    /** Custom metadata to attach to the OTP request */
+    metadata?: Record<string, any>;
+    /** Idempotency key to prevent duplicate requests */
+    idempotencyKey?: string;
+}
+/**
+ * Response from sending an OTP
+ */
+export interface SendOtpResponse {
+    /** Unique request ID for this OTP */
+    requestId: string;
+    /** When the OTP will expire */
+    expiresAt: Date;
+    /** Current status of the OTP request */
+    status: string;
+}
+/**
+ * Options for verifying an OTP
+ */
+export interface VerifyOtpOptions {
+    /** The request ID from sendOtp() */
+    requestId: string;
+    /** The OTP code to verify */
+    code: string;
+    /** IP address of the user verifying (optional but recommended) */
+    ipAddress?: string;
+    /** User agent of the user verifying (optional) */
+    userAgent?: string;
+}
+/**
+ * Response from verifying an OTP
+ */
+export interface VerifyOtpResponse {
+    /** Whether verification was successful */
+    success: boolean;
+    /** Message describing the result */
+    message: string;
+}
+/**
+ * Options for resending an OTP
+ */
+export interface ResendOtpOptions {
+    /** The request ID from the original sendOtp() call */
+    requestId: string;
+}
+/**
+ * Error response from the API
+ */
+export interface ApiErrorResponse {
+    success: false;
+    error: {
+        code: ErrorCode;
+        message: string;
+        statusCode: number;
+        retryable: boolean;
+        details?: Record<string, any>;
+    };
+    meta: {
+        requestId: string;
+        timestamp: string;
+    };
+}
+/**
+ * Success response wrapper
+ */
+export interface ApiSuccessResponse<T> {
+    success: true;
+    data: T;
+    meta?: {
+        requestId?: string;
+        timestamp?: string;
+        rateLimit?: {
+            limit: number;
+            remaining: number;
+            reset: number;
+        };
+    };
+}
+/**
+ * OTP Status response (authenticated endpoint)
+ */
+export interface OtpStatus {
+    /** Request ID */
+    id: string;
+    /** Phone number (masked) */
+    phoneNumber: string;
+    /** Delivery channel */
+    channel: OtpChannel;
+    /** Current status */
+    status: 'PENDING' | 'SENT' | 'VERIFIED' | 'EXPIRED' | 'FAILED';
+    /** Number of verification attempts */
+    attempts: number;
+    /** Maximum allowed attempts */
+    maxAttempts: number;
+    /** When the OTP expires */
+    expiresAt: Date;
+    /** When the OTP was verified (if verified) */
+    verifiedAt: Date | null;
+    /** When the OTP was created */
+    createdAt: Date;
+    /** Whether the OTP is expired */
+    isExpired: boolean;
+}
+/**
+ * OTP Status with code response (public endpoint for testing/development)
+ * WARNING: Only use this endpoint in development/testing!
+ */
+export interface OtpStatusWithCode extends OtpStatus {
+    /** The actual OTP code (for testing only!) */
+    otpCode: string;
+    /** SMS provider used */
+    smsProvider: string | null;
+    /** SMS message ID from provider */
+    smsMessageId: string | null;
+}
+/**
+ * SDK Configuration from server
+ */
+export interface SdkConfiguration {
+    /** API version */
+    version: string;
+    /** OTP configuration */
+    otpConfig: {
+        /** Default OTP length */
+        length: number;
+        /** Default TTL in seconds */
+        ttl: number;
+        /** Maximum verification attempts */
+        maxAttempts: number;
+    };
+    /** Rate limits */
+    rateLimits: {
+        perPhone: {
+            limit: number;
+            window: string;
+        };
+        perAccount: {
+            limit: number;
+            window: string;
+        };
+        perIP: {
+            limit: number;
+            window: string;
+        };
+    };
+    /** Supported countries */
+    supportedCountries: string[];
+    /** Pricing information */
+    pricing: {
+        currency: string;
+        regions: Record<string, any>;
+        defaultPrice: number;
+    };
+    /** Supported features */
+    features: {
+        georgianLanguage: boolean;
+        customBranding: boolean;
+        webhooks: boolean;
+        idempotency: boolean;
+        testMode: boolean;
+        longPolling: boolean;
+        batchOperations: boolean;
+    };
+    /** API endpoints */
+    endpoints: {
+        base: string;
+        docs: string;
+        status: string;
+    };
+    /** Test mode information (if enabled) */
+    testMode?: {
+        enabled: boolean;
+        testPhoneNumbers: string[];
+        fixedOtpCode: string;
+    };
+}
+/**
+ * Test phone numbers for testing/development
+ * Only work when server is in test mode
+ */
+export declare const TEST_PHONE_NUMBERS: Readonly<{
+    /** Always succeeds */
+    SUCCESS: "+15005550006";
+    /** Always fails with SMS send error */
+    SMS_FAIL: "+15005550007";
+    /** Always fails with rate limit exceeded */
+    RATE_LIMIT: "+15005550008";
+    /** Always fails with insufficient balance */
+    INSUFFICIENT_BALANCE: "+15005550009";
+    /** Always fails with brand not authorized */
+    BRAND_NOT_AUTH: "+15005550010";
+}>;
+/**
+ * Fixed OTP code for test mode
+ */
+export declare const TEST_OTP_CODE = "123456";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEST_OTP_CODE = exports.TEST_PHONE_NUMBERS = exports.ErrorCode = exports.OtpChannel = void 0;
+/**
+ * OTP Channel types
+ */
+var OtpChannel;
+(function (OtpChannel) {
+    OtpChannel["SMS"] = "SMS";
+    OtpChannel["WHATSAPP"] = "WHATSAPP";
+    OtpChannel["VOICE"] = "VOICE";
+})(OtpChannel || (exports.OtpChannel = OtpChannel = {}));
+/**
+ * Error codes returned by the API
+ */
+var ErrorCode;
+(function (ErrorCode) {
+    // Authentication & Authorization
+    ErrorCode["AUTHENTICATION_FAILED"] = "AUTHENTICATION_FAILED";
+    ErrorCode["INVALID_API_KEY"] = "INVALID_API_KEY";
+    ErrorCode["API_KEY_REVOKED"] = "API_KEY_REVOKED";
+    // Phone Number
+    ErrorCode["INVALID_PHONE_NUMBER"] = "INVALID_PHONE_NUMBER";
+    ErrorCode["PHONE_NUMBER_BLOCKED"] = "PHONE_NUMBER_BLOCKED";
+    // OTP
+    ErrorCode["OTP_EXPIRED"] = "OTP_EXPIRED";
+    ErrorCode["OTP_MAX_ATTEMPTS"] = "OTP_MAX_ATTEMPTS";
+    ErrorCode["INVALID_OTP_CODE"] = "INVALID_OTP_CODE";
+    ErrorCode["OTP_NOT_FOUND"] = "OTP_NOT_FOUND";
+    ErrorCode["OTP_ALREADY_VERIFIED"] = "OTP_ALREADY_VERIFIED";
+    // Rate Limiting
+    ErrorCode["RATE_LIMIT_EXCEEDED"] = "RATE_LIMIT_EXCEEDED";
+    // Billing
+    ErrorCode["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+    ErrorCode["PAYMENT_REQUIRED"] = "PAYMENT_REQUIRED";
+    // Brand
+    ErrorCode["NO_BRAND_CONFIGURED"] = "NO_BRAND_CONFIGURED";
+    ErrorCode["BRAND_NOT_AUTHORIZED"] = "BRAND_NOT_AUTHORIZED";
+    ErrorCode["BRAND_PENDING_APPROVAL"] = "BRAND_PENDING_APPROVAL";
+    ErrorCode["BRAND_CREATION_FAILED"] = "BRAND_CREATION_FAILED";
+    // SMS Provider
+    ErrorCode["SMS_SEND_FAILED"] = "SMS_SEND_FAILED";
+    ErrorCode["PROVIDER_UNAVAILABLE"] = "PROVIDER_UNAVAILABLE";
+    // Validation
+    ErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    ErrorCode["MISSING_REQUIRED_FIELD"] = "MISSING_REQUIRED_FIELD";
+    // Server
+    ErrorCode["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    // Idempotency
+    ErrorCode["IDEMPOTENCY_KEY_CONFLICT"] = "IDEMPOTENCY_KEY_CONFLICT";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+/**
+ * Test phone numbers for testing/development
+ * Only work when server is in test mode
+ */
+exports.TEST_PHONE_NUMBERS = Object.freeze({
+    /** Always succeeds */
+    SUCCESS: '+15005550006',
+    /** Always fails with SMS send error */
+    SMS_FAIL: '+15005550007',
+    /** Always fails with rate limit exceeded */
+    RATE_LIMIT: '+15005550008',
+    /** Always fails with insufficient balance */
+    INSUFFICIENT_BALANCE: '+15005550009',
+    /** Always fails with brand not authorized */
+    BRAND_NOT_AUTH: '+15005550010',
+});
+/**
+ * Fixed OTP code for test mode
+ */
+exports.TEST_OTP_CODE = '123456';