@glideidentity/web-client-sdk 5.0.1 → 5.1.1-beta.1

package/dist/esm/core/client.js

@@ -19,6 +19,7 @@ export class SDKClient {
                 'Content-Type': 'application/json',
             },
         });
+        // Initialize Phone Auth client
         this.phoneAuth = new PhoneAuthClient({
             endpoints: config.phoneAuthEndpoints ? {
                 prepare: config.phoneAuthEndpoints.prepareRequest,
@@ -26,6 +27,7 @@ export class SDKClient {
             } : 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}`;
@@ -33,12 +35,22 @@ export class SDKClient {
             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) {

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

@@ -1,3 +1,7 @@
+/**
+ * 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,
@@ -14,6 +18,9 @@ export interface Logger {
     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;
@@ -24,15 +31,28 @@ export declare class ConsoleLogger implements Logger {
     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;
@@ -48,23 +68,56 @@ export declare class RemoteLogger implements Logger {
     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;

package/dist/esm/core/logger.js

@@ -1,3 +1,7 @@
+/**
+ * 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) {
@@ -15,6 +19,9 @@ export var LogLevel;
     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;
@@ -44,7 +51,9 @@ export class ConsoleLogger {
     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]) => {
@@ -53,6 +62,7 @@ export class ConsoleLogger {
             console.groupEnd();
         }
         else {
+            // Standard logging with or without fields
             if (Object.keys(sanitizedFields).length > 0) {
                 console[level](formattedMessage, sanitizedFields);
             }
@@ -61,6 +71,9 @@ export class ConsoleLogger {
             }
         }
     }
+    /**
+     * Sanitize sensitive data from log fields
+     */
     sanitizeFields(fields) {
         const sanitized = {};
         for (const [key, value] of Object.entries(fields)) {
@@ -68,7 +81,11 @@ export class ConsoleLogger {
         }
         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',
@@ -78,6 +95,7 @@ export class ConsoleLogger {
             '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) {
@@ -86,52 +104,69 @@ export class ConsoleLogger {
                 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;
+        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());
         }
     }
@@ -157,7 +192,9 @@ export class RemoteLogger {
             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();
         }
@@ -179,11 +216,17 @@ export class RemoteLogger {
                 });
             }
             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':
@@ -203,7 +246,11 @@ export function parseLogLevel(level) {
             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) {
@@ -214,6 +261,7 @@ export function getLogLevelFromEnv() {
             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');
@@ -226,19 +274,31 @@ export function getLogLevelFromEnv() {
     }
     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);
@@ -249,29 +309,49 @@ export class PerformanceTimer {
         }
     }
 }
+/**
+ * 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);
     }
 }