qa360 2.3.0 → 2.3.1

package/dist/core/crawler/error-tracking-handler.js

@@ -0,0 +1,378 @@
+/**
+ * Error Tracking Handler
+ *
+ * P1 - Global error tracking and monitoring
+ *
+ * Supports:
+ * - JavaScript error capture
+ * - Unhandled rejection tracking
+ * - Error aggregation and deduplication
+ * - Error context collection
+ * - Error reporting
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers
+ */
+/**
+ * Error Tracking Handler class
+ */
+export class ErrorTrackingHandler {
+    page;
+    errors = [];
+    resourceErrors = [];
+    trackingEnabled = false;
+    consoleErrors = [];
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Setup global error tracking
+     */
+    async setupTracking() {
+        if (this.trackingEnabled)
+            return;
+        await this.page.evaluate(() => {
+            // Storage for errors
+            if (!window.__errorTracker) {
+                window.__errorTracker = {
+                    errors: [],
+                    resourceErrors: [],
+                    consoleErrors: [],
+                };
+            }
+            const tracker = window.__errorTracker;
+            // Track JavaScript errors
+            window.addEventListener('error', (event) => {
+                const errorInfo = {
+                    name: 'Error',
+                    message: event.message,
+                    stack: event.error?.stack || '',
+                    filename: event.filename,
+                    line: event.lineno,
+                    column: event.colno,
+                    type: 'error',
+                    timestamp: Date.now(),
+                    userAgent: navigator.userAgent,
+                    pageUrl: window.location.href,
+                };
+                tracker.errors.push(errorInfo);
+            });
+            // Track unhandled promise rejections
+            window.addEventListener('unhandledrejection', (event) => {
+                const error = event.reason;
+                const errorInfo = {
+                    name: error?.name || 'UnhandledRejection',
+                    message: error?.message || String(error),
+                    stack: error?.stack || '',
+                    type: 'unhandledrejection',
+                    timestamp: Date.now(),
+                    userAgent: navigator.userAgent,
+                    pageUrl: window.location.href,
+                };
+                tracker.errors.push(errorInfo);
+            });
+            // Track resource loading errors
+            window.addEventListener('error', (event) => {
+                const target = event.target;
+                if (target && (target.tagName === 'SCRIPT' ||
+                    target.tagName === 'LINK' ||
+                    target.tagName === 'IMG')) {
+                    const src = target.src || target.href;
+                    if (src) {
+                        tracker.resourceErrors.push({
+                            url: src,
+                            type: target.tagName.toLowerCase(),
+                            status: 0,
+                            message: 'Failed to load resource',
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+            }, true);
+            // Override console.error to capture console errors
+            const originalError = console.error;
+            console.error = function (...args) {
+                tracker.consoleErrors.push(args.map(a => String(a)).join(' '));
+                originalError.apply(console, args);
+            };
+        });
+        // Listen for console events from Playwright
+        this.page.on('console', (msg) => {
+            if (msg.type() === 'error') {
+                this.consoleErrors.push(msg.text());
+            }
+        });
+        // Listen for page errors
+        this.page.on('pageerror', (error) => {
+            this.errors.push({
+                name: error.name,
+                message: error.message,
+                stack: error.stack || '',
+                type: 'error',
+                timestamp: Date.now(),
+                userAgent: 'unknown',
+                pageUrl: this.page.url(),
+            });
+        });
+        // Listen for request failures (resource errors)
+        this.page.on('requestfailed', (request) => {
+            const failure = request.failure();
+            if (failure) {
+                this.resourceErrors.push({
+                    url: request.url(),
+                    type: request.resourceType(),
+                    status: 0,
+                    message: failure || 'Request failed',
+                    timestamp: Date.now(),
+                });
+            }
+        });
+        this.trackingEnabled = true;
+    }
+    /**
+     * Get all captured errors from the page
+     */
+    async getErrors() {
+        if (!this.trackingEnabled) {
+            await this.setupTracking();
+        }
+        const pageErrors = await this.page.evaluate(() => {
+            return window.__errorTracker?.errors || [];
+        });
+        // Combine page errors and handler errors
+        return [...pageErrors, ...this.errors];
+    }
+    /**
+     * Get all resource errors
+     */
+    async getResourceErrors() {
+        if (!this.trackingEnabled) {
+            await this.setupTracking();
+        }
+        const pageResourceErrors = await this.page.evaluate(() => {
+            return window.__errorTracker?.resourceErrors || [];
+        });
+        return [...pageResourceErrors, ...this.resourceErrors];
+    }
+    /**
+     * Get console errors
+     */
+    async getConsoleErrors() {
+        if (!this.trackingEnabled) {
+            await this.setupTracking();
+        }
+        const pageConsoleErrors = await this.page.evaluate(() => {
+            return window.__errorTracker?.consoleErrors || [];
+        });
+        return [...pageConsoleErrors, ...this.consoleErrors];
+    }
+    /**
+     * Generate error report
+     */
+    async generateReport() {
+        const errors = await this.getErrors();
+        const resourceErrors = await this.getResourceErrors();
+        const consoleErrors = await this.getConsoleErrors();
+        // Group errors
+        const grouped = this.groupErrors(errors);
+        // Count by type
+        const errorsByType = {};
+        for (const error of errors) {
+            errorsByType[error.type] = (errorsByType[error.type] || 0) + 1;
+        }
+        // Find most frequent
+        let mostFrequent = null;
+        for (const group of grouped) {
+            if (!mostFrequent || group.count > mostFrequent.count) {
+                mostFrequent = group;
+            }
+        }
+        // Count unhandled rejections
+        const unhandledRejections = errors.filter(e => e.type === 'unhandledrejection').length;
+        return {
+            totalErrors: errors.length,
+            errorsByType,
+            groupedErrors: grouped,
+            resourceErrors,
+            mostFrequent,
+            unhandledRejections,
+            consoleErrors: consoleErrors.length,
+        };
+    }
+    /**
+     * Group errors by similarity
+     */
+    groupErrors(errors) {
+        const groups = new Map();
+        for (const error of errors) {
+            // Create a key based on error name and message (simplified)
+            const key = `${error.name}:${error.message.slice(0, 100)}`;
+            let group = groups.get(key);
+            if (!group) {
+                group = {
+                    key,
+                    name: error.name,
+                    message: error.message,
+                    count: 0,
+                    firstSeen: error.timestamp,
+                    lastSeen: error.timestamp,
+                    stack: error.stack,
+                    pages: [],
+                };
+                groups.set(key, group);
+            }
+            group.count++;
+            group.lastSeen = error.timestamp;
+            if (!group.pages.includes(error.pageUrl)) {
+                group.pages.push(error.pageUrl);
+            }
+        }
+        return Array.from(groups.values()).sort((a, b) => b.count - a.count);
+    }
+    /**
+     * Capture error with additional context
+     */
+    async captureError(error, context) {
+        const pageContext = await this.page.evaluate((ctxKeys) => {
+            const result = {};
+            for (const key of ctxKeys) {
+                result[key] = window[key];
+            }
+            return result;
+        }, Object.keys(context || {}));
+        this.errors.push({
+            name: error.name,
+            message: error.message,
+            stack: error.stack || '',
+            type: 'error',
+            timestamp: Date.now(),
+            userAgent: 'unknown',
+            pageUrl: this.page.url(),
+            context: {
+                ...context,
+                ...pageContext,
+            },
+        });
+    }
+    /**
+     * Clear all captured errors
+     */
+    async clearErrors() {
+        this.errors = [];
+        this.resourceErrors = [];
+        this.consoleErrors = [];
+        await this.page.evaluate(() => {
+            if (window.__errorTracker) {
+                window.__errorTracker.errors = [];
+                window.__errorTracker.resourceErrors = [];
+                window.__errorTracker.consoleErrors = [];
+            }
+        });
+    }
+    /**
+     * Get errors by type
+     */
+    async getErrorsByType(type) {
+        const allErrors = await this.getErrors();
+        return allErrors.filter(e => e.type === type);
+    }
+    /**
+     * Get errors by page URL
+     */
+    async getErrorsByPage(pageUrl) {
+        const allErrors = await this.getErrors();
+        return allErrors.filter(e => e.pageUrl === pageUrl);
+    }
+    /**
+     * Check if there are any critical errors
+     */
+    async hasCriticalErrors() {
+        const errors = await this.getErrors();
+        const criticalTypes = ['error', 'unhandledrejection'];
+        return errors.some(e => criticalTypes.includes(e.type) &&
+            !e.message.includes('ResizeObserver') &&
+            !e.message.includes('slow') &&
+            !e.message.includes('network'));
+    }
+    /**
+     * Get error statistics
+     */
+    async getStatistics() {
+        const errors = await this.getErrors();
+        const byType = {};
+        let critical = 0;
+        for (const error of errors) {
+            byType[error.type] = (byType[error.type] || 0) + 1;
+            if (error.type === 'error' || error.type === 'unhandledrejection') {
+                critical++;
+            }
+        }
+        // Calculate unique errors
+        const unique = this.groupErrors(errors).length;
+        // Calculate errors per minute
+        const now = Date.now();
+        const oneMinuteAgo = now - 60000;
+        const recentErrors = errors.filter(e => e.timestamp > oneMinuteAgo);
+        const avgPerMinute = recentErrors.length;
+        return {
+            total: errors.length,
+            byType,
+            critical,
+            unique,
+            avgPerMinute,
+        };
+    }
+    /**
+     * Export errors as JSON
+     */
+    async exportErrors() {
+        const report = await this.generateReport();
+        return JSON.stringify(report, null, 2);
+    }
+    /**
+     * Setup error threshold monitoring
+     */
+    async setupThresholdMonitoring(threshold, callback) {
+        let intervalId = null;
+        const check = async () => {
+            const errors = await this.getErrors();
+            const recent = errors.filter(e => Date.now() - e.timestamp < 60000);
+            if (recent.length >= threshold) {
+                await callback(recent);
+            }
+        };
+        intervalId = setInterval(check, 5000);
+        return () => {
+            if (intervalId) {
+                clearInterval(intervalId);
+                intervalId = null;
+            }
+        };
+    }
+    /**
+     * Check if tracking is enabled
+     */
+    isEnabled() {
+        return this.trackingEnabled;
+    }
+    /**
+     * Disable error tracking
+     */
+    async disableTracking() {
+        if (!this.trackingEnabled)
+            return;
+        await this.page.evaluate(() => {
+            // Remove event listeners by reloading the page state
+            if (window.__errorTracker) {
+                delete window.__errorTracker;
+            }
+        });
+        this.trackingEnabled = false;
+    }
+}
+/**
+ * Factory function to create Error Tracking Handler
+ */
+export function createErrorTrackingHandler(page) {
+    return new ErrorTrackingHandler(page);
+}
+export default ErrorTrackingHandler;

package/dist/core/crawler/form-handler.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Form Handler
+ *
+ * P1 - Advanced form interactions
+ *
+ * Supports:
+ * - Auto-detect form fields
+ * - Smart field type detection (input, select, textarea, checkbox, radio)
+ * - Fill forms with data
+ * - Form validation detection
+ * - Submit handling
+ *
+ * @see https://playwright.dev/docs/input
+ */
+export interface FormField {
+    /** Field selector */
+    selector: string;
+    /** Field type */
+    type: 'input' | 'select' | 'textarea' | 'checkbox' | 'radio' | 'file' | 'date' | 'email' | 'tel' | 'number';
+    /** Field name/label */
+    name?: string;
+    /** Current value */
+    value?: string;
+    /** Required flag */
+    required?: boolean;
+    /** Disabled flag */
+    disabled?: boolean;
+    /** Options (for select/radio) */
+    options?: string[];
+}
+export interface FormData {
+    /** Form selector */
+    selector?: string;
+    /** Fields in the form */
+    fields: FormField[];
+    /** Submit button selector */
+    submitButton?: string;
+}
+export interface FormConfig {
+    /** Form selector (optional, defaults to first form) */
+    formSelector?: string;
+    /** Auto-detect fields */
+    autoDetect?: boolean;
+    /** Fill timeout per field */
+    timeout?: number;
+    /** Clear before fill */
+    clearBeforeFill?: boolean;
+}
+export interface FormFillData {
+    /** Field values by name/label */
+    [fieldName: string]: string | string[] | boolean | number;
+}
+export interface FormResult {
+    success: boolean;
+    filled?: number;
+    errors?: string[];
+    validationErrors?: string[];
+}
+/**
+ * Form Handler class
+ */
+export declare class FormHandler {
+    /**
+     * Detect form fields on a page
+     */
+    detectFormFields(page: any, config?: FormConfig): Promise<FormData>;
+    /**
+     * Fill a form with data
+     */
+    fillForm(page: any, data: FormFillData, config?: FormConfig): Promise<FormResult>;
+    /**
+     * Fill a single field
+     */
+    fillField(page: any, field: FormField, value: string | string[] | boolean | number, config?: FormConfig): Promise<void>;
+    /**
+     * Submit a form
+     */
+    submitForm(page: any, config?: FormConfig): Promise<void>;
+    /**
+     * Detect form validation errors
+     */
+    detectValidationErrors(page: any, config?: FormConfig): Promise<string[]>;
+    /**
+     * Fill and submit a form in one action
+     */
+    fillAndSubmit(page: any, data: FormFillData, config?: FormConfig): Promise<FormResult>;
+    /**
+     * Get form data as object (extract current values)
+     */
+    getFormData(page: any, config?: FormConfig): Promise<Record<string, string | boolean>>;
+    /**
+     * Clear all form fields
+     */
+    clearForm(page: any, config?: FormConfig): Promise<void>;
+}
+/**
+ * Factory function to create Form Handler
+ */
+export declare function createFormHandler(): FormHandler;
+export default FormHandler;