@glideidentity/web-client-sdk 4.4.8-beta.1

package/dist/core/phone-auth/strategies/desktop.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Desktop Strategy Handler
+ * Handles QR code-based authentication for desktop browsers
+ * Manages QR code display and polling for authentication status
+ */
+import type { StrategyHandler } from './types';
+import type { PrepareResponse } from '../types';
+/**
+ * QR code data structure for dual-platform support
+ */
+export interface QRCodeData {
+    iosQRCode: string;
+    androidQRCode?: string;
+    iosUrl?: string;
+    androidUrl?: string;
+}
+export interface DesktopAuthOptions {
+    /** Custom polling interval in milliseconds (overrides server-provided value) */
+    pollingInterval?: number;
+    /** Maximum polling attempts before timeout (default: 150 = 5 minutes with 2s interval) */
+    maxPollingAttempts?: number;
+    /** Custom polling endpoint (overrides backend-provided or uses configured endpoint) */
+    pollingEndpoint?: string;
+    /** Callback when QR code is ready to display */
+    onQRCodeReady?: (qrCodeData: string | QRCodeData) => void;
+    /** Callback for polling status updates */
+    onStatusUpdate?: (status: PollingStatus) => void;
+    /** Callback when authentication expires */
+    onExpired?: () => void;
+    /** Callback when authentication is cancelled by user */
+    onCancel?: () => void;
+    /** Callback when polling times out (max attempts reached) */
+    onTimeout?: () => void;
+}
+export interface PollingStatus {
+    /** Current status of the authentication */
+    status: 'pending' | 'authenticated' | 'expired' | 'cancelled' | 'error';
+    /** Optional message */
+    message?: string;
+    /** Authentication result data if status is 'authenticated' */
+    data?: any;
+}
+export interface DesktopAuthResult {
+    /** Whether authentication was successful */
+    authenticated: boolean;
+    /** Authentication credential if successful */
+    credential?: string;
+    /** Session info for subsequent requests */
+    session?: any;
+    /** Error message if authentication failed */
+    error?: string;
+}
+export declare class DesktopHandler implements StrategyHandler {
+    private pollingIntervalId?;
+    private pollingAttempts;
+    private isCancelled;
+    private onCancel?;
+    /**
+     * Maps backend HTTP status codes to client status
+     * @param httpStatus HTTP status code from backend
+     * @param bodyStatus Optional status from response body (for 200 OK responses)
+     * @returns Mapped status string for client use
+     */
+    private mapBackendStatus;
+    /**
+     * Invoke desktop authentication with QR code
+     * Returns QR code data for display and starts polling if endpoint is provided
+     */
+    invoke(data: PrepareResponse, options?: DesktopAuthOptions): Promise<DesktopAuthResult>;
+    /**
+     * Start polling for authentication status
+     */
+    private startPolling;
+    /**
+     * Stop polling
+     */
+    private stopPolling;
+    /**
+     * Format response for backend processing
+     * Desktop strategy typically returns the credential from mobile authentication
+     */
+    formatResponse(response: DesktopAuthResult): any;
+    /**
+     * Check if desktop authentication is supported
+     * Desktop auth with QR codes works in any modern browser
+     */
+    isSupported(): boolean;
+    /**
+     * Clean up resources (stop polling if active)
+     */
+    cleanup(): void;
+    /**
+     * Cancel the ongoing authentication
+     */
+    cancel(): void;
+}
+/**
+ * Helper function to display QR code in a modal or inline
+ */
+export declare function createQRCodeDisplay(qrCodeData: string, options?: {
+    container?: HTMLElement;
+    size?: number;
+    title?: string;
+    description?: string;
+}): HTMLElement;
+/**
+ * Helper function to create a modal for QR code display
+ */
+export declare function showQRCodeModal(qrCodeData: string, options?: {
+    title?: string;
+    description?: string;
+    onClose?: () => void;
+}): void;

package/dist/core/phone-auth/strategies/desktop.js

@@ -0,0 +1,502 @@
+"use strict";
+/**
+ * Desktop Strategy Handler
+ * Handles QR code-based authentication for desktop browsers
+ * Manages QR code display and polling for authentication status
+ */
+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.DesktopHandler = void 0;
+exports.createQRCodeDisplay = createQRCodeDisplay;
+exports.showQRCodeModal = showQRCodeModal;
+class DesktopHandler {
+    constructor() {
+        this.pollingAttempts = 0;
+        this.isCancelled = false;
+    }
+    /**
+     * Maps backend HTTP status codes to client status
+     * @param httpStatus HTTP status code from backend
+     * @param bodyStatus Optional status from response body (for 200 OK responses)
+     * @returns Mapped status string for client use
+     */
+    mapBackendStatus(httpStatus, bodyStatus) {
+        switch (httpStatus) {
+            case 200:
+                // For 200 OK, check the body status
+                return bodyStatus === 'completed' ? 'authenticated' : 'pending';
+            case 410:
+                return 'expired';
+            case 422:
+                return 'error'; // Failed or cancelled
+            case 404:
+                return 'error'; // Session not found
+            case 400:
+                return 'error'; // Invalid session key
+            default:
+                return 'error';
+        }
+    }
+    /**
+     * Invoke desktop authentication with QR code
+     * Returns QR code data for display and starts polling if endpoint is provided
+     */
+    invoke(data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const desktopData = data.data;
+            // Extract QR code from nested or flat structure, checking multiple field names
+            let qrCode;
+            let sessionId;
+            let pollingEndpoint;
+            let pollingInterval;
+            let expiresIn;
+            // Check nested structure first (data.data.qr_code_image or data.data.qr_code)
+            if (desktopData && desktopData.data && typeof desktopData.data === 'object') {
+                const innerData = desktopData.data;
+                // Try to extract from inner data
+                qrCode = innerData.qr_code_image || innerData.qr_code;
+                sessionId = innerData.session_id;
+                pollingEndpoint = innerData.status_url;
+                pollingInterval = innerData.polling_interval;
+                expiresIn = innerData.expires_in;
+            }
+            // Fall back to flat structure if no QR code found
+            if (!qrCode && desktopData) {
+                qrCode = desktopData.qr_code_image || desktopData.qr_code;
+                sessionId = sessionId || desktopData.session_id;
+                pollingEndpoint = pollingEndpoint || desktopData.status_url || desktopData.polling_endpoint;
+                pollingInterval = pollingInterval || desktopData.polling_interval;
+                expiresIn = expiresIn || desktopData.expires_in;
+            }
+            // Validate QR code exists
+            if (!qrCode) {
+                throw new Error('Invalid desktop authentication data: missing QR code');
+            }
+            // Validate session ID exists
+            if (!sessionId) {
+                throw new Error('Invalid desktop authentication data: missing session ID');
+            }
+            // Notify that QR code is ready
+            if (options === null || options === void 0 ? void 0 : options.onQRCodeReady) {
+                options.onQRCodeReady(qrCode);
+            }
+            // Use polling endpoint with this priority:
+            // 1. Developer-provided endpoint from options
+            // 2. Backend-provided endpoint
+            // 3. Error if none available
+            const finalPollingEndpoint = (options === null || options === void 0 ? void 0 : options.pollingEndpoint) || pollingEndpoint;
+            // If no polling endpoint available, return QR code data and let the app handle the rest
+            if (!finalPollingEndpoint) {
+                return {
+                    authenticated: false,
+                    session: data.session,
+                    error: 'No polling endpoint provided - configure endpoints.polling or ensure backend provides status_url'
+                };
+            }
+            // Start polling for authentication status
+            const finalPollingInterval = (options === null || options === void 0 ? void 0 : options.pollingInterval) || pollingInterval || 2000;
+            const maxAttempts = (options === null || options === void 0 ? void 0 : options.maxPollingAttempts) || 150; // Default to 5 minutes
+            return this.startPolling(finalPollingEndpoint, sessionId, finalPollingInterval, maxAttempts, expiresIn || 300, // Default 5 minutes expiry
+            options);
+        });
+    }
+    /**
+     * Start polling for authentication status
+     */
+    startPolling(endpoint, sessionId, interval, maxAttempts, expiresIn, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            const expiryTime = startTime + (expiresIn * 1000);
+            return new Promise((resolve, reject) => {
+                const poll = () => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // Check if cancelled
+                        if (this.isCancelled) {
+                            this.stopPolling();
+                            if (options === null || options === void 0 ? void 0 : options.onCancel) {
+                                options.onCancel();
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                options.onStatusUpdate({
+                                    status: 'cancelled',
+                                    message: 'Authentication cancelled'
+                                });
+                            }
+                            resolve({
+                                authenticated: false,
+                                error: 'Authentication cancelled'
+                            });
+                            return;
+                        }
+                        // Check if expired
+                        if (Date.now() > expiryTime) {
+                            this.stopPolling();
+                            if (options === null || options === void 0 ? void 0 : options.onExpired) {
+                                options.onExpired();
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                options.onStatusUpdate({
+                                    status: 'expired',
+                                    message: 'QR code has expired'
+                                });
+                            }
+                            resolve({
+                                authenticated: false,
+                                error: 'Authentication expired'
+                            });
+                            return;
+                        }
+                        // Check max attempts
+                        if (this.pollingAttempts >= maxAttempts) {
+                            this.stopPolling();
+                            if (options === null || options === void 0 ? void 0 : options.onTimeout) {
+                                options.onTimeout();
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                options.onStatusUpdate({
+                                    status: 'error',
+                                    message: 'Polling timeout reached'
+                                });
+                            }
+                            resolve({
+                                authenticated: false,
+                                error: 'Polling timeout'
+                            });
+                            return;
+                        }
+                        // Build public status endpoint URL - use relative path for proxied requests
+                        let statusUrl;
+                        // Extract base URL and construct public endpoint
+                        if (endpoint && (endpoint.startsWith('http://') || endpoint.startsWith('https://'))) {
+                            // Full URL provided - extract base and use public endpoint
+                            const url = new URL(endpoint);
+                            statusUrl = `${url.protocol}//${url.host}/public/public/status/${sessionId}`;
+                        }
+                        else {
+                            // Use relative path that will be proxied through the app's server
+                            // This ensures it goes through the same domain and uses the app's API configuration
+                            statusUrl = `/api/phone-auth/status/${sessionId}`;
+                        }
+                        // Poll the public endpoint - no authentication required
+                        const response = yield fetch(statusUrl, {
+                            method: 'GET',
+                            headers: {
+                                'Accept': 'application/json'
+                                // No Authorization header needed for public endpoint
+                            }
+                        });
+                        // Backend Status Code Mapping:
+                        // - 200 OK: Session exists (body has 'pending' or 'completed' status)
+                        // - 410 Gone: Session expired after timeout
+                        // - 422 Unprocessable Entity: Authentication failed or cancelled
+                        // - 404 Not Found: Session doesn't exist
+                        // - 400 Bad Request: Invalid session key format
+                        // Handle response based on HTTP status code
+                        if (response.status === 200) {
+                            const result = yield response.json();
+                            if (result.status === 'completed') {
+                                // Authentication completed successfully
+                                this.stopPolling();
+                                // Close the modal if it exists
+                                const modal = document.querySelector('[style*="position: fixed"]');
+                                if (modal && modal.querySelector('#desktop-auth-status')) {
+                                    setTimeout(() => {
+                                        modal.remove();
+                                    }, 500); // Brief delay to show success message
+                                }
+                                if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                    options.onStatusUpdate({
+                                        status: 'authenticated',
+                                        message: 'Authentication successful',
+                                        data: result
+                                    });
+                                }
+                                // Return the session data for next steps
+                                resolve({
+                                    authenticated: true,
+                                    credential: result.credential || result.session_key || sessionId,
+                                    session: result.session || {
+                                        session_key: result.session_key || sessionId,
+                                        status: result.status,
+                                        protocol: result.protocol,
+                                        created_at: result.created_at,
+                                        last_updated: result.last_updated
+                                    }
+                                });
+                            }
+                            else if (result.status === 'pending') {
+                                // Continue polling
+                                this.pollingAttempts++;
+                                if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                    options.onStatusUpdate({
+                                        status: 'pending',
+                                        message: `Waiting for authentication (attempt ${this.pollingAttempts}/${maxAttempts})`
+                                    });
+                                }
+                            }
+                        }
+                        else if (response.status === 410) {
+                            // Session expired
+                            this.stopPolling();
+                            const errorData = yield response.json().catch(() => ({ message: 'Session expired' }));
+                            // Close the modal on error
+                            const modal = document.querySelector('[style*="position: fixed"]');
+                            if (modal && modal.querySelector('#desktop-auth-status')) {
+                                setTimeout(() => {
+                                    modal.remove();
+                                }, 500);
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.onExpired) {
+                                options.onExpired();
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                options.onStatusUpdate({
+                                    status: 'expired',
+                                    message: errorData.message || 'Session has expired'
+                                });
+                            }
+                            resolve({
+                                authenticated: false,
+                                error: errorData.message || 'Session expired'
+                            });
+                        }
+                        else if (response.status === 422) {
+                            // Authentication failed
+                            this.stopPolling();
+                            const errorData = yield response.json().catch(() => ({ message: 'Authentication failed' }));
+                            // Close the modal on error
+                            const modal = document.querySelector('[style*="position: fixed"]');
+                            if (modal && modal.querySelector('#desktop-auth-status')) {
+                                setTimeout(() => {
+                                    modal.remove();
+                                }, 500);
+                            }
+                            const isUserCancelled = errorData.code === 'USER_CANCELLED';
+                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                options.onStatusUpdate({
+                                    status: 'error',
+                                    message: errorData.message || 'Authentication failed'
+                                });
+                            }
+                            resolve({
+                                authenticated: false,
+                                error: isUserCancelled
+                                    ? 'User cancelled authentication'
+                                    : (errorData.message || 'Authentication failed')
+                            });
+                        }
+                        else if (response.status === 404) {
+                            // Session not found
+                            this.stopPolling();
+                            if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                                options.onStatusUpdate({
+                                    status: 'error',
+                                    message: 'Session not found'
+                                });
+                            }
+                            resolve({
+                                authenticated: false,
+                                error: 'Session not found'
+                            });
+                        }
+                        else if (response.status === 400) {
+                            // Invalid session key
+                            this.stopPolling();
+                            const errorData = yield response.json().catch(() => ({ message: 'Invalid session key' }));
+                            resolve({
+                                authenticated: false,
+                                error: errorData.message || 'Invalid session key'
+                            });
+                        }
+                        else {
+                            // Unexpected status - continue polling
+                            this.pollingAttempts++;
+                        }
+                    }
+                    catch (error) {
+                        // Network or other error - continue polling
+                        this.pollingAttempts++;
+                        if (options === null || options === void 0 ? void 0 : options.onStatusUpdate) {
+                            options.onStatusUpdate({
+                                status: 'pending',
+                                message: `Network error, retrying... (attempt ${this.pollingAttempts}/${maxAttempts})`
+                            });
+                        }
+                    }
+                });
+                // Start initial poll
+                poll();
+                // Set up interval for subsequent polls
+                this.pollingIntervalId = setInterval(poll, interval);
+            });
+        });
+    }
+    /**
+     * Stop polling
+     */
+    stopPolling() {
+        if (this.pollingIntervalId) {
+            clearInterval(this.pollingIntervalId);
+            this.pollingIntervalId = undefined;
+        }
+        this.pollingAttempts = 0;
+    }
+    /**
+     * Format response for backend processing
+     * Desktop strategy typically returns the credential from mobile authentication
+     */
+    formatResponse(response) {
+        if (!response.authenticated || !response.credential) {
+            throw new Error('Authentication not completed');
+        }
+        return {
+            credential: response.credential,
+            session: response.session
+        };
+    }
+    /**
+     * Check if desktop authentication is supported
+     * Desktop auth with QR codes works in any modern browser
+     */
+    isSupported() {
+        // Check for required browser APIs
+        return typeof window !== 'undefined' &&
+            typeof fetch !== 'undefined' &&
+            typeof Promise !== 'undefined';
+    }
+    /**
+     * Clean up resources (stop polling if active)
+     */
+    cleanup() {
+        this.stopPolling();
+        this.isCancelled = false;
+        this.onCancel = undefined;
+    }
+    /**
+     * Cancel the ongoing authentication
+     */
+    cancel() {
+        var _a;
+        this.isCancelled = true;
+        this.stopPolling();
+        (_a = this.onCancel) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+}
+exports.DesktopHandler = DesktopHandler;
+/**
+ * Helper function to display QR code in a modal or inline
+ */
+function createQRCodeDisplay(qrCodeData, options) {
+    const container = (options === null || options === void 0 ? void 0 : options.container) || document.createElement('div');
+    container.className = 'phone-auth-qr-container';
+    // Create QR code image
+    const img = document.createElement('img');
+    img.src = qrCodeData;
+    img.alt = 'QR Code for authentication';
+    img.style.width = `${(options === null || options === void 0 ? void 0 : options.size) || 256}px`;
+    img.style.height = `${(options === null || options === void 0 ? void 0 : options.size) || 256}px`;
+    img.style.display = 'block';
+    img.style.margin = '0 auto';
+    // Add title if provided
+    if (options === null || options === void 0 ? void 0 : options.title) {
+        const title = document.createElement('h3');
+        title.textContent = options.title;
+        title.style.textAlign = 'center';
+        title.style.marginBottom = '1rem';
+        container.appendChild(title);
+    }
+    container.appendChild(img);
+    // Add description if provided
+    if (options === null || options === void 0 ? void 0 : options.description) {
+        const desc = document.createElement('p');
+        desc.textContent = options.description;
+        desc.style.textAlign = 'center';
+        desc.style.marginTop = '1rem';
+        desc.style.color = '#666';
+        container.appendChild(desc);
+    }
+    return container;
+}
+/**
+ * Helper function to create a modal for QR code display
+ */
+function showQRCodeModal(qrCodeData, options) {
+    // Create modal overlay
+    const overlay = document.createElement('div');
+    overlay.style.cssText = `
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 9999;
+  `;
+    // Create modal content
+    const modal = document.createElement('div');
+    modal.style.cssText = `
+    background: white;
+    padding: 2rem;
+    border-radius: 8px;
+    max-width: 400px;
+    position: relative;
+  `;
+    // Add close button
+    const closeBtn = document.createElement('button');
+    closeBtn.textContent = '×';
+    closeBtn.style.cssText = `
+    position: absolute;
+    top: 10px;
+    right: 10px;
+    background: none;
+    border: none;
+    font-size: 24px;
+    cursor: pointer;
+    color: #999;
+  `;
+    closeBtn.onclick = () => {
+        document.body.removeChild(overlay);
+        if (options === null || options === void 0 ? void 0 : options.onClose) {
+            options.onClose();
+        }
+    };
+    modal.appendChild(closeBtn);
+    // Add QR code display
+    const qrDisplay = createQRCodeDisplay(qrCodeData, {
+        title: (options === null || options === void 0 ? void 0 : options.title) || 'Scan QR Code to Authenticate',
+        description: (options === null || options === void 0 ? void 0 : options.description) || 'Use your mobile device to scan this QR code'
+    });
+    modal.appendChild(qrDisplay);
+    // Add loading spinner placeholder
+    const statusDiv = document.createElement('div');
+    statusDiv.id = 'desktop-auth-status';
+    statusDiv.style.cssText = `
+    text-align: center;
+    margin-top: 1rem;
+    color: #666;
+    font-size: 14px;
+  `;
+    modal.appendChild(statusDiv);
+    overlay.appendChild(modal);
+    document.body.appendChild(overlay);
+    // Close modal on overlay click
+    overlay.onclick = (e) => {
+        if (e.target === overlay) {
+            document.body.removeChild(overlay);
+            if (options === null || options === void 0 ? void 0 : options.onClose) {
+                options.onClose();
+            }
+        }
+    };
+}

package/dist/core/phone-auth/strategies/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Strategy Handlers Export
+ * Provides implementations for TS43, Link, and Desktop authentication strategies
+ */
+export type { StrategyHandler } from './types';
+export { TS43Handler } from './ts43';
+export { LinkHandler } from './link';
+export type { LinkAuthOptions, LinkAuthResult, PollingStatus as LinkPollingStatus } from './link';
+export { DesktopHandler, createQRCodeDisplay, showQRCodeModal } from './desktop';
+export type { DesktopAuthOptions, DesktopAuthResult, PollingStatus } from './desktop';
+export type { TS43Data, LinkData } from '../types';

package/dist/core/phone-auth/strategies/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Strategy Handlers Export
+ * Provides implementations for TS43, Link, and Desktop authentication strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showQRCodeModal = exports.createQRCodeDisplay = exports.DesktopHandler = exports.LinkHandler = exports.TS43Handler = void 0;
+var ts43_1 = require("./ts43");
+Object.defineProperty(exports, "TS43Handler", { enumerable: true, get: function () { return ts43_1.TS43Handler; } });
+var link_1 = require("./link");
+Object.defineProperty(exports, "LinkHandler", { enumerable: true, get: function () { return link_1.LinkHandler; } });
+var desktop_1 = require("./desktop");
+Object.defineProperty(exports, "DesktopHandler", { enumerable: true, get: function () { return desktop_1.DesktopHandler; } });
+Object.defineProperty(exports, "createQRCodeDisplay", { enumerable: true, get: function () { return desktop_1.createQRCodeDisplay; } });
+Object.defineProperty(exports, "showQRCodeModal", { enumerable: true, get: function () { return desktop_1.showQRCodeModal; } });