@glideidentity/web-client-sdk 5.1.2 → 6.0.0-beta.1

package/dist/esm/core/client.d.ts

@@ -1,22 +0,0 @@
-import { ClientConfig, RequestOptions, ClientResponse } from './types';
-import { PhoneAuthClient } from './phone-auth';
-export declare class SDKClient {
-    private client;
-    private config;
-    private token?;
-    phoneAuth: PhoneAuthClient;
-    constructor(config: ClientConfig);
-    /**
-     * Set authentication token for API requests
-     */
-    setToken(token: string): void;
-    /**
-     * Clear authentication token
-     */
-    clearToken(): void;
-    /**
-     * Make a GET request to the API
-     * Note: Requires baseURL to be set in the config
-     */
-    get<T = any>(path: string, options?: RequestOptions): Promise<ClientResponse<T>>;
-}

package/dist/esm/core/client.js

@@ -1,70 +0,0 @@
-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());
-    });
-};
-import axios from 'axios';
-import { PhoneAuthClient } from './phone-auth';
-export class SDKClient {
-    constructor(config) {
-        this.config = config;
-        this.client = axios.create({
-            baseURL: config.baseURL || '',
-            timeout: config.timeout || 10000,
-            headers: {
-                'Content-Type': 'application/json',
-            },
-        });
-        // Initialize Phone Auth client
-        this.phoneAuth = new PhoneAuthClient({
-            endpoints: config.phoneAuthEndpoints ? {
-                prepare: config.phoneAuthEndpoints.prepareRequest,
-                process: config.phoneAuthEndpoints.processResponse
-            } : undefined,
-            debug: config.debug
-        });
-        // Add authentication interceptor
-        this.client.interceptors.request.use((config) => __awaiter(this, void 0, void 0, function* () {
-            if (this.token) {
-                config.headers.Authorization = `Bearer ${this.token}`;
-            }
-            return config;
-        }));
-    }
-    /**
-     * Set authentication token for API requests
-     */
-    setToken(token) {
-        this.token = token;
-    }
-    /**
-     * Clear authentication token
-     */
-    clearToken() {
-        this.token = undefined;
-    }
-    /**
-     * Make a GET request to the API
-     * Note: Requires baseURL to be set in the config
-     */
-    get(path, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config.baseURL) {
-                throw new Error('baseURL is required for making API requests. Please provide it in the ClientConfig.');
-            }
-            const response = yield this.client.get(path, {
-                headers: options === null || options === void 0 ? void 0 : options.headers,
-                params: options === null || options === void 0 ? void 0 : options.params,
-            });
-            return {
-                data: response.data,
-                status: response.status,
-                headers: Object.fromEntries(Object.entries(response.headers).map(([k, v]) => [k, String(v)])),
-            };
-        });
-    }
-}

package/dist/esm/core/logger.d.ts

@@ -1,130 +0,0 @@
-/**
- * Industry-grade logging for Glide Web SDK
- * Following best practices from Stripe, Auth0, Twilio, and AWS Amplify
- */
-export declare enum LogLevel {
-    SILENT = 0,
-    ERROR = 1,
-    WARN = 2,
-    INFO = 3,
-    DEBUG = 4
-}
-export interface LogFields {
-    [key: string]: any;
-}
-export interface Logger {
-    debug(message: string, fields?: LogFields): void;
-    info(message: string, fields?: LogFields): void;
-    warn(message: string, fields?: LogFields): void;
-    error(message: string, fields?: LogFields): void;
-}
-/**
- * Default browser console logger with automatic data sanitization
- */
-export declare class ConsoleLogger implements Logger {
-    private level;
-    private prefix;
-    private enableGrouping;
-    constructor(level?: LogLevel, prefix?: string, enableGrouping?: boolean);
-    debug(message: string, fields?: LogFields): void;
-    info(message: string, fields?: LogFields): void;
-    warn(message: string, fields?: LogFields): void;
-    error(message: string, fields?: LogFields): void;
-    private log;
-    /**
-     * Sanitize sensitive data from log fields
-     */
-    private sanitizeFields;
-    /**
-     * Redact sensitive information based on field name and value patterns
-     */
-    private sanitizeValue;
-}
-/**
- * No-op logger for when logging is disabled
- */
-export declare class NoopLogger implements Logger {
-    debug(message: string, fields?: LogFields): void;
-    info(message: string, fields?: LogFields): void;
-    warn(message: string, fields?: LogFields): void;
-    error(message: string, fields?: LogFields): void;
-}
-/**
- * Remote logger for sending logs to a backend service
- * Useful for debugging production issues
- */
-export declare class RemoteLogger implements Logger {
-    private endpoint;
-    private apiKey;
-    private localLogger;
-    private buffer;
-    private flushInterval;
-    private maxBufferSize;
-    constructor(endpoint: string, apiKey: string, fallbackLogger?: Logger);
-    debug(message: string, fields?: LogFields): void;
-    info(message: string, fields?: LogFields): void;
-    warn(message: string, fields?: LogFields): void;
-    error(message: string, fields?: LogFields): void;
-    private log;
-    private flush;
-}
-/**
- * Parse log level from string
- */
-export declare function parseLogLevel(level: string): LogLevel;
-/**
- * Get log level from browser environment
- */
-export declare function getLogLevelFromEnv(): LogLevel;
-/**
- * Performance timer for measuring operation duration
- */
-export declare class PerformanceTimer {
-    private startTime;
-    private marks;
-    private logger;
-    constructor(logger: Logger);
-    /**
-     * Mark a point in time
-     */
-    mark(name: string): void;
-    /**
-     * Log elapsed time with optional fields
-     */
-    logElapsed(message: string, fields?: LogFields): void;
-    /**
-     * Log time between marks
-     */
-    logMarkDuration(fromMark: string, toMark: string, message: string, fields?: LogFields): void;
-}
-/**
- * Generate a unique request ID for distributed tracing
- */
-export declare function generateRequestId(): string;
-/**
- * Logger factory for creating loggers with consistent configuration
- */
-export declare class LoggerFactory {
-    private static defaultLevel;
-    private static defaultLogger;
-    /**
-     * Set the default log level for all new loggers
-     */
-    static setDefaultLevel(level: LogLevel): void;
-    /**
-     * Set a default logger instance to use
-     */
-    static setDefaultLogger(logger: Logger): void;
-    /**
-     * Create a logger instance based on configuration
-     */
-    static create(options?: {
-        level?: LogLevel;
-        prefix?: string;
-        remote?: {
-            endpoint: string;
-            apiKey: string;
-        };
-        custom?: Logger;
-    }): Logger;
-}

package/dist/esm/core/logger.js

@@ -1,359 +0,0 @@
-/**
- * Industry-grade logging for Glide Web SDK
- * Following best practices from Stripe, Auth0, Twilio, and AWS Amplify
- */
-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());
-    });
-};
-export var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["SILENT"] = 0] = "SILENT";
-    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
-    LogLevel[LogLevel["WARN"] = 2] = "WARN";
-    LogLevel[LogLevel["INFO"] = 3] = "INFO";
-    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
-})(LogLevel || (LogLevel = {}));
-/**
- * Default browser console logger with automatic data sanitization
- */
-export class ConsoleLogger {
-    constructor(level = LogLevel.SILENT, prefix = '[Glide]', enableGrouping = false) {
-        this.level = level;
-        this.prefix = prefix;
-        this.enableGrouping = enableGrouping;
-    }
-    debug(message, fields) {
-        if (this.level >= LogLevel.DEBUG) {
-            this.log('debug', message, fields);
-        }
-    }
-    info(message, fields) {
-        if (this.level >= LogLevel.INFO) {
-            this.log('info', message, fields);
-        }
-    }
-    warn(message, fields) {
-        if (this.level >= LogLevel.WARN) {
-            this.log('warn', message, fields);
-        }
-    }
-    error(message, fields) {
-        if (this.level >= LogLevel.ERROR) {
-            this.log('error', message, fields);
-        }
-    }
-    log(level, message, fields) {
-        const timestamp = new Date().toISOString();
-        const sanitizedFields = fields ? this.sanitizeFields(fields) : {};
-        // Format the message
-        const formattedMessage = `${this.prefix} ${timestamp} [${level.toUpperCase()}] ${message}`;
-        // Use console grouping for better readability if enabled
-        if (this.enableGrouping && Object.keys(sanitizedFields).length > 0) {
-            console.groupCollapsed(formattedMessage);
-            Object.entries(sanitizedFields).forEach(([key, value]) => {
-                console.log(`${key}:`, value);
-            });
-            console.groupEnd();
-        }
-        else {
-            // Standard logging with or without fields
-            if (Object.keys(sanitizedFields).length > 0) {
-                console[level](formattedMessage, sanitizedFields);
-            }
-            else {
-                console[level](formattedMessage);
-            }
-        }
-    }
-    /**
-     * Sanitize sensitive data from log fields
-     */
-    sanitizeFields(fields) {
-        const sanitized = {};
-        for (const [key, value] of Object.entries(fields)) {
-            sanitized[key] = this.sanitizeValue(key, value);
-        }
-        return sanitized;
-    }
-    /**
-     * Redact sensitive information based on field name and value patterns
-     */
-    sanitizeValue(key, value) {
-        // List of sensitive field patterns
-        const sensitiveFields = [
-            'apikey', 'api_key', 'apiKey',
-            'token', 'accesstoken', 'access_token', 'accessToken',
-            'password', 'passwd', 'pwd',
-            'secret', 'credential',
-            'authorization', 'auth',
-            'cookie', 'session',
-        ];
-        const lowerKey = key.toLowerCase();
-        // Check if field name indicates sensitive data
-        for (const sensitive of sensitiveFields) {
-            if (lowerKey.includes(sensitive.toLowerCase())) {
-                if (typeof value === 'string' && value.length > 4) {
-                    return value.substring(0, 4) + '****[REDACTED]';
-                }
-                return '****[REDACTED]';
-            }
-        }
-        // Handle specific value patterns
-        if (typeof value === 'string') {
-            // Phone number pattern - show area code only
-            const phoneRegex = /^\+?[1-9]\d{6,14}$/;
-            if (phoneRegex.test(value)) {
-                return value.substring(0, 6) + '****';
-            }
-            // Email pattern - show domain only
-            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-            if (emailRegex.test(value)) {
-                const [, domain] = value.split('@');
-                return '****@' + domain;
-            }
-            // URL with credentials
-            if (value.includes('://') && value.includes('@')) {
-                return value.replace(/\/\/([^:]+):([^@]+)@/, '//****:****@');
-            }
-            // JWT tokens
-            if (value.startsWith('eyJ') && value.split('.').length === 3) {
-                return value.substring(0, 10) + '****[JWT]';
-            }
-            // Credit card numbers
-            const creditCardRegex = /\b\d{13,19}\b/;
-            if (creditCardRegex.test(value)) {
-                return value.substring(0, 4) + '****' + value.substring(value.length - 4);
-            }
-        }
-        // Recursively sanitize objects
-        if (value && typeof value === 'object' && !Array.isArray(value)) {
-            return this.sanitizeFields(value);
-        }
-        // Sanitize arrays
-        if (Array.isArray(value)) {
-            return value.map((item, index) => this.sanitizeValue(`${key}[${index}]`, item));
-        }
-        return value;
-    }
-}
-/**
- * No-op logger for when logging is disabled
- */
-export class NoopLogger {
-    debug(message, fields) { }
-    info(message, fields) { }
-    warn(message, fields) { }
-    error(message, fields) { }
-}
-/**
- * Remote logger for sending logs to a backend service
- * Useful for debugging production issues
- */
-export class RemoteLogger {
-    constructor(endpoint, apiKey, fallbackLogger) {
-        this.buffer = [];
-        this.flushInterval = 5000; // 5 seconds
-        this.maxBufferSize = 100;
-        this.endpoint = endpoint;
-        this.apiKey = apiKey;
-        this.localLogger = fallbackLogger || new ConsoleLogger(LogLevel.ERROR);
-        // Set up automatic flushing
-        if (typeof window !== 'undefined') {
-            setInterval(() => this.flush(), this.flushInterval);
-            // Flush on page unload
-            window.addEventListener('beforeunload', () => this.flush());
-        }
-    }
-    debug(message, fields) {
-        this.log('debug', message, fields);
-    }
-    info(message, fields) {
-        this.log('info', message, fields);
-    }
-    warn(message, fields) {
-        this.log('warn', message, fields);
-    }
-    error(message, fields) {
-        this.log('error', message, fields);
-    }
-    log(level, message, fields) {
-        const logEntry = {
-            timestamp: new Date().toISOString(),
-            level,
-            message,
-            fields,
-            userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : undefined,
-            url: typeof window !== 'undefined' ? window.location.href : undefined,
-        };
-        this.buffer.push(logEntry);
-        // Also log locally for immediate feedback
-        this.localLogger[level](message, fields);
-        // Flush if buffer is full
-        if (this.buffer.length >= this.maxBufferSize) {
-            this.flush();
-        }
-    }
-    flush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.buffer.length === 0)
-                return;
-            const logs = [...this.buffer];
-            this.buffer = [];
-            try {
-                yield fetch(this.endpoint, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${this.apiKey}`,
-                    },
-                    body: JSON.stringify({ logs }),
-                });
-            }
-            catch (error) {
-                // Failed to send logs, log locally
-                this.localLogger.error('Failed to send logs to remote server', { error });
-                // Optionally, put logs back in buffer for retry
-                // this.buffer.unshift(...logs);
-            }
-        });
-    }
-}
-/**
- * Parse log level from string
- */
-export function parseLogLevel(level) {
-    switch (level.toLowerCase()) {
-        case 'debug':
-            return LogLevel.DEBUG;
-        case 'info':
-            return LogLevel.INFO;
-        case 'warn':
-        case 'warning':
-            return LogLevel.WARN;
-        case 'error':
-            return LogLevel.ERROR;
-        case 'silent':
-        case 'none':
-        case 'off':
-            return LogLevel.SILENT;
-        default:
-            return LogLevel.SILENT;
-    }
-}
-/**
- * Get log level from browser environment
- */
-export function getLogLevelFromEnv() {
-    // Check localStorage
-    if (typeof localStorage !== 'undefined') {
-        const storedLevel = localStorage.getItem('GLIDE_LOG_LEVEL');
-        if (storedLevel) {
-            return parseLogLevel(storedLevel);
-        }
-        const debugFlag = localStorage.getItem('GLIDE_DEBUG');
-        if (debugFlag === 'true' || debugFlag === '1') {
-            return LogLevel.DEBUG;
-        }
-    }
-    // Check URL parameters
-    if (typeof window !== 'undefined' && window.location) {
-        const params = new URLSearchParams(window.location.search);
-        const urlLogLevel = params.get('glide_log_level');
-        if (urlLogLevel) {
-            return parseLogLevel(urlLogLevel);
-        }
-        if (params.has('glide_debug')) {
-            return LogLevel.DEBUG;
-        }
-    }
-    return LogLevel.SILENT;
-}
-/**
- * Performance timer for measuring operation duration
- */
-export class PerformanceTimer {
-    constructor(logger) {
-        this.marks = new Map();
-        this.startTime = performance.now();
-        this.logger = logger;
-    }
-    /**
-     * Mark a point in time
-     */
-    mark(name) {
-        this.marks.set(name, performance.now());
-    }
-    /**
-     * Log elapsed time with optional fields
-     */
-    logElapsed(message, fields) {
-        const elapsed = performance.now() - this.startTime;
-        this.logger.debug(message, Object.assign(Object.assign({}, fields), { elapsedMs: elapsed, elapsed: `${elapsed.toFixed(2)}ms` }));
-    }
-    /**
-     * Log time between marks
-     */
-    logMarkDuration(fromMark, toMark, message, fields) {
-        const from = this.marks.get(fromMark);
-        const to = this.marks.get(toMark);
-        if (from && to) {
-            const duration = to - from;
-            this.logger.debug(message, Object.assign(Object.assign({}, fields), { durationMs: duration, duration: `${duration.toFixed(2)}ms`, fromMark,
-                toMark }));
-        }
-    }
-}
-/**
- * Generate a unique request ID for distributed tracing
- */
-export function generateRequestId() {
-    return `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-}
-/**
- * Logger factory for creating loggers with consistent configuration
- */
-export class LoggerFactory {
-    /**
-     * Set the default log level for all new loggers
-     */
-    static setDefaultLevel(level) {
-        this.defaultLevel = level;
-    }
-    /**
-     * Set a default logger instance to use
-     */
-    static setDefaultLogger(logger) {
-        this.defaultLogger = logger;
-    }
-    /**
-     * Create a logger instance based on configuration
-     */
-    static create(options) {
-        var _a, _b;
-        // Use custom logger if provided
-        if (options === null || options === void 0 ? void 0 : options.custom) {
-            return options.custom;
-        }
-        // Use default logger if set
-        if (this.defaultLogger) {
-            return this.defaultLogger;
-        }
-        // Determine log level
-        const level = (_b = (_a = options === null || options === void 0 ? void 0 : options.level) !== null && _a !== void 0 ? _a : getLogLevelFromEnv()) !== null && _b !== void 0 ? _b : this.defaultLevel;
-        // Create remote logger if configured
-        if (options === null || options === void 0 ? void 0 : options.remote) {
-            const fallbackLogger = new ConsoleLogger(level, options === null || options === void 0 ? void 0 : options.prefix);
-            return new RemoteLogger(options.remote.endpoint, options.remote.apiKey, fallbackLogger);
-        }
-        // Create console logger
-        return new ConsoleLogger(level, options === null || options === void 0 ? void 0 : options.prefix);
-    }
-}
-LoggerFactory.defaultLevel = LogLevel.SILENT;
-LoggerFactory.defaultLogger = null;