@govtechsg/oobee 0.10.83 → 0.10.84

package/dist/mergeAxeResults/sentryTelemetry.js

@@ -0,0 +1,152 @@
+import * as Sentry from '@sentry/node';
+import { sentryConfig, setSentryUser } from '../constants/constants.js';
+import { categorizeWcagCriteria, getUserDataTxt, getWcagCriteriaMap } from '../utils.js';
+// Format WCAG tag in requested format: wcag111a_Occurrences
+const formatWcagTag = async (wcagId) => {
+    // Get dynamic WCAG criteria map
+    const wcagCriteriaMap = await getWcagCriteriaMap();
+    if (wcagCriteriaMap[wcagId]) {
+        const { level } = wcagCriteriaMap[wcagId];
+        return `${wcagId}${level}_Occurrences`;
+    }
+    return null;
+};
+// Send WCAG criteria breakdown to Sentry
+const sendWcagBreakdownToSentry = async (appVersion, wcagBreakdown, ruleIdJson, scanInfo, allIssues, pagesScannedCount = 0) => {
+    try {
+        // Initialize Sentry
+        Sentry.init(sentryConfig);
+        // Set user ID for Sentry tracking
+        const userData = getUserDataTxt();
+        if (userData && userData.userId) {
+            setSentryUser(userData.userId);
+        }
+        // Prepare tags for the event
+        const tags = {};
+        const wcagCriteriaBreakdown = {};
+        // Tag app version
+        tags.version = appVersion;
+        // Get dynamic WCAG criteria map once
+        const wcagCriteriaMap = await getWcagCriteriaMap();
+        // Categorize all WCAG criteria for reporting
+        const wcagIds = Array.from(new Set([...Object.keys(wcagCriteriaMap), ...Array.from(wcagBreakdown.keys())]));
+        const categorizedWcag = await categorizeWcagCriteria(wcagIds);
+        // First ensure all WCAG criteria are included in the tags with a value of 0
+        // This ensures criteria with no violations are still reported
+        for (const [wcagId, info] of Object.entries(wcagCriteriaMap)) {
+            const formattedTag = await formatWcagTag(wcagId);
+            if (formattedTag) {
+                // Initialize with zero
+                tags[formattedTag] = '0';
+                // Store in breakdown object with category information
+                wcagCriteriaBreakdown[formattedTag] = {
+                    count: 0,
+                    category: categorizedWcag[wcagId] || 'mustFix', // Default to mustFix if not found
+                };
+            }
+        }
+        // Now override with actual counts from the scan
+        for (const [wcagId, count] of wcagBreakdown.entries()) {
+            const formattedTag = await formatWcagTag(wcagId);
+            if (formattedTag) {
+                // Add as a tag with the count as value
+                tags[formattedTag] = String(count);
+                // Update count in breakdown object
+                if (wcagCriteriaBreakdown[formattedTag]) {
+                    wcagCriteriaBreakdown[formattedTag].count = count;
+                }
+                else {
+                    // If somehow this wasn't in our initial map
+                    wcagCriteriaBreakdown[formattedTag] = {
+                        count,
+                        category: categorizedWcag[wcagId] || 'mustFix',
+                    };
+                }
+            }
+        }
+        // Calculate category counts based on actual issue counts from the report
+        // rather than occurrence counts from wcagBreakdown
+        const categoryCounts = {
+            mustFix: 0,
+            goodToFix: 0,
+            needsReview: 0,
+        };
+        if (allIssues) {
+            // Use the actual report data for the counts
+            categoryCounts.mustFix = allIssues.items.mustFix.rules.length;
+            categoryCounts.goodToFix = allIssues.items.goodToFix.rules.length;
+            categoryCounts.needsReview = allIssues.items.needsReview.rules.length;
+        }
+        else {
+            // Fallback to the old way if allIssues not provided
+            Object.values(wcagCriteriaBreakdown).forEach(item => {
+                if (item.count > 0 && categoryCounts[item.category] !== undefined) {
+                    categoryCounts[item.category] += 1; // Count rules, not occurrences
+                }
+            });
+        }
+        // Add category counts as tags
+        tags['WCAG-MustFix-Count'] = String(categoryCounts.mustFix);
+        tags['WCAG-GoodToFix-Count'] = String(categoryCounts.goodToFix);
+        tags['WCAG-NeedsReview-Count'] = String(categoryCounts.needsReview);
+        // Also add occurrence counts for reference
+        if (allIssues) {
+            tags['WCAG-MustFix-Occurrences'] = String(allIssues.items.mustFix.totalItems);
+            tags['WCAG-GoodToFix-Occurrences'] = String(allIssues.items.goodToFix.totalItems);
+            tags['WCAG-NeedsReview-Occurrences'] = String(allIssues.items.needsReview.totalItems);
+            // Add number of pages scanned tag
+            tags['Pages-Scanned-Count'] = String(allIssues.totalPagesScanned);
+        }
+        else if (pagesScannedCount > 0) {
+            // Still add the pages scanned count even if we don't have allIssues
+            tags['Pages-Scanned-Count'] = String(pagesScannedCount);
+        }
+        // Send the event to Sentry
+        await Sentry.captureEvent({
+            message: 'Accessibility Scan Completed',
+            level: 'info',
+            tags: {
+                ...tags,
+                event_type: 'accessibility_scan',
+                scanType: scanInfo.scanType,
+                browser: scanInfo.browser,
+                entryUrl: scanInfo.entryUrl,
+            },
+            user: {
+                ...(scanInfo.email && scanInfo.name
+                    ? {
+                        email: scanInfo.email,
+                        username: scanInfo.name,
+                    }
+                    : {}),
+                ...(userData && userData.userId ? { id: userData.userId } : {}),
+            },
+            extra: {
+                additionalScanMetadata: ruleIdJson != null ? JSON.stringify(ruleIdJson) : '{}',
+                wcagBreakdown: wcagCriteriaBreakdown,
+                reportCounts: allIssues
+                    ? {
+                        mustFix: {
+                            issues: allIssues.items.mustFix.rules?.length ?? 0,
+                            occurrences: allIssues.items.mustFix.totalItems ?? 0,
+                        },
+                        goodToFix: {
+                            issues: allIssues.items.goodToFix.rules?.length ?? 0,
+                            occurrences: allIssues.items.goodToFix.totalItems ?? 0,
+                        },
+                        needsReview: {
+                            issues: allIssues.items.needsReview.rules?.length ?? 0,
+                            occurrences: allIssues.items.needsReview.totalItems ?? 0,
+                        },
+                    }
+                    : undefined,
+            },
+        });
+        // Wait for events to be sent
+        await Sentry.flush(2000);
+    }
+    catch (error) {
+        console.error('Error sending WCAG breakdown to Sentry:', error);
+    }
+};
+export default sendWcagBreakdownToSentry;

package/dist/mergeAxeResults/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mergeAxeResults/writeCsv.js

@@ -0,0 +1,125 @@
+import { createWriteStream } from 'fs';
+import { AsyncParser } from '@json2csv/node';
+import { a11yRuleShortDescriptionMap } from '../constants/constants.js';
+const writeCsv = async (allIssues, storagePath) => {
+    const csvOutput = createWriteStream(`${storagePath}/report.csv`, { encoding: 'utf8' });
+    const formatPageViolation = (pageNum) => {
+        if (pageNum < 0)
+            return 'Document';
+        return `Page ${pageNum}`;
+    };
+    // transform allIssues into the form:
+    // [['mustFix', rule1], ['mustFix', rule2], ['goodToFix', rule3], ...]
+    const getRulesByCategory = (issues) => {
+        return Object.entries(issues.items)
+            .filter(([category]) => category !== 'passed')
+            .reduce((prev, [category, value]) => {
+            const rulesEntries = Object.entries(value.rules);
+            rulesEntries.forEach(([, ruleInfo]) => {
+                prev.push([category, ruleInfo]);
+            });
+            return prev;
+        }, [])
+            .sort((a, b) => {
+            // sort rules according to severity, then ruleId
+            const compareCategory = -a[0].localeCompare(b[0]);
+            return compareCategory === 0 ? a[1].rule.localeCompare(b[1].rule) : compareCategory;
+        });
+    };
+    const flattenRule = (catAndRule) => {
+        const [severity, rule] = catAndRule;
+        const results = [];
+        const { rule: issueId, description: issueDescription, axeImpact, conformance, pagesAffected, helpUrl: learnMore, } = rule;
+        // format clauses as a string
+        const wcagConformance = conformance.join(',');
+        pagesAffected.sort((a, b) => a.url.localeCompare(b.url));
+        pagesAffected.forEach(affectedPage => {
+            const { url, items } = affectedPage;
+            items.forEach(item => {
+                const { html, message, xpath } = item;
+                const page = item.page;
+                const howToFix = message.replace(/(\r\n|\n|\r)/g, '\\n'); // preserve newlines as \n
+                const violation = html || formatPageViolation(page); // page is a number, not a string
+                const context = violation.replace(/(\r\n|\n|\r)/g, ''); // remove newlines
+                results.push({
+                    customFlowLabel: allIssues.customFlowLabel || '',
+                    deviceChosen: allIssues.deviceChosen || '',
+                    scanCompletedAt: allIssues.endTime ? allIssues.endTime.toISOString() : '',
+                    severity: severity || '',
+                    issueId: issueId || '',
+                    issueDescription: a11yRuleShortDescriptionMap[issueId] || issueDescription || '',
+                    wcagConformance: wcagConformance || '',
+                    url: url || '',
+                    pageTitle: affectedPage.pageTitle || 'No page title',
+                    context: context || '',
+                    howToFix: howToFix || '',
+                    axeImpact: axeImpact || '',
+                    xpath: xpath || '',
+                    learnMore: learnMore || '',
+                });
+            });
+        });
+        if (results.length === 0)
+            return {};
+        return results;
+    };
+    const opts = {
+        transforms: [getRulesByCategory, flattenRule],
+        fields: [
+            'customFlowLabel',
+            'deviceChosen',
+            'scanCompletedAt',
+            'severity',
+            'issueId',
+            'issueDescription',
+            'wcagConformance',
+            'url',
+            'pageTitle',
+            'context',
+            'howToFix',
+            'axeImpact',
+            'xpath',
+            'learnMore',
+        ],
+        includeEmptyRows: true,
+    };
+    // Create the parse stream (it's asynchronous)
+    const parser = new AsyncParser(opts);
+    const parseStream = parser.parse(allIssues);
+    // Pipe JSON2CSV output into the file, but don't end automatically
+    parseStream.pipe(csvOutput, { end: false });
+    // Once JSON2CSV is done writing all normal rows, append any "pagesNotScanned"
+    parseStream.on('end', () => {
+        if (allIssues.pagesNotScanned && allIssues.pagesNotScanned.length > 0) {
+            csvOutput.write('\n');
+            allIssues.pagesNotScanned.forEach(page => {
+                const skippedPage = {
+                    customFlowLabel: allIssues.customFlowLabel || '',
+                    deviceChosen: allIssues.deviceChosen || '',
+                    scanCompletedAt: allIssues.endTime ? allIssues.endTime.toISOString() : '',
+                    severity: 'error',
+                    issueId: 'error-pages-skipped',
+                    issueDescription: page.metadata
+                        ? page.metadata
+                        : 'An unknown error caused the page to be skipped',
+                    wcagConformance: '',
+                    url: page.url || page || '',
+                    pageTitle: 'Error',
+                    context: '',
+                    howToFix: '',
+                    axeImpact: '',
+                    xpath: '',
+                    learnMore: '',
+                };
+                csvOutput.write(`${Object.values(skippedPage).join(',')}\n`);
+            });
+        }
+        // Now close the CSV file
+        csvOutput.end();
+    });
+    parseStream.on('error', (err) => {
+        console.error('Error parsing CSV:', err);
+        csvOutput.end();
+    });
+};
+export default writeCsv;

package/dist/mergeAxeResults/writeScanDetailsCsv.js

@@ -0,0 +1,35 @@
+import fs from 'fs-extra';
+import path from 'path';
+const streamEncodedDataToFile = async (inputFilePath, writeStream, appendComma) => {
+    const readStream = fs.createReadStream(inputFilePath, { encoding: 'utf8' });
+    let isFirstChunk = true;
+    for await (const chunk of readStream) {
+        if (isFirstChunk) {
+            isFirstChunk = false;
+            writeStream.write(chunk);
+        }
+        else {
+            writeStream.write(chunk);
+        }
+    }
+    if (appendComma) {
+        writeStream.write(',');
+    }
+};
+const writeScanDetailsCsv = async (scanDataFilePath, scanItemsFilePath, scanItemsSummaryFilePath, storagePath) => {
+    const filePath = path.join(storagePath, 'scanDetails.csv');
+    const csvWriteStream = fs.createWriteStream(filePath, { encoding: 'utf8' });
+    const directoryPath = path.dirname(filePath);
+    if (!fs.existsSync(directoryPath)) {
+        fs.mkdirSync(directoryPath, { recursive: true });
+    }
+    csvWriteStream.write('scanData_base64,scanItems_base64,scanItemsSummary_base64\n');
+    await streamEncodedDataToFile(scanDataFilePath, csvWriteStream, true);
+    await streamEncodedDataToFile(scanItemsFilePath, csvWriteStream, true);
+    await streamEncodedDataToFile(scanItemsSummaryFilePath, csvWriteStream, false);
+    await new Promise((resolve, reject) => {
+        csvWriteStream.end(resolve);
+        csvWriteStream.on('error', reject);
+    });
+};
+export default writeScanDetailsCsv;

package/dist/mergeAxeResults/writeSitemap.js

@@ -0,0 +1,10 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { consoleLogger } from '../logs.js';
+const writeSitemap = async (pagesScanned, storagePath) => {
+    const sitemapPath = path.join(storagePath, 'sitemap.txt');
+    const content = pagesScanned.map(p => p.url).join('\n');
+    await fs.writeFile(sitemapPath, content, { encoding: 'utf-8' });
+    consoleLogger.info(`Sitemap written to ${sitemapPath}`);
+};
+export default writeSitemap;