akasharender
Version:
Rendering support for generating static HTML websites or EPUB eBooks
324 lines • 40.1 kB
JavaScript
/**
*
* Copyright 2014-2025 David Herron
*
* This file is part of AkashaCMS (http://akashacms.com/).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _SitemapValidator_config, _SitemapValidator_sitemapFilename;
/**
* Sitemap Validator
*
* Validates generated sitemap XML files against the local rendered output directory.
* Ensures that every URL in the sitemap corresponds to an actual file in the output.
*
* @module sitemap-validator
*/
import { promises as fsp } from 'node:fs';
import fs from 'node:fs';
import path from 'node:path';
import { XMLToSitemapItemStream } from 'sitemap';
/**
* Sitemap Validator Class
*
* Validates generated sitemap XML files against the local rendered output directory.
*/
export class SitemapValidator {
/**
* Create a new SitemapValidator
*
* @param config - AkashaRender configuration object
* @param sitemapFilename - Name of the sitemap file (default: 'sitemap.xml')
*/
constructor(config, sitemapFilename = 'sitemap.xml') {
_SitemapValidator_config.set(this, void 0);
_SitemapValidator_sitemapFilename.set(this, void 0);
if (!config) {
throw new Error('Configuration is required');
}
if (!config.root_url) {
throw new Error('Configuration must have root_url set');
}
if (!config.renderDestination) {
throw new Error('Configuration must have renderDestination set');
}
__classPrivateFieldSet(this, _SitemapValidator_config, config, "f");
__classPrivateFieldSet(this, _SitemapValidator_sitemapFilename, sitemapFilename, "f");
}
/**
* Main validation method
*
* Validates the sitemap file against the rendered output directory.
*
* @returns Promise resolving to validation result
*/
async validate() {
const sitemapPath = path.join(__classPrivateFieldGet(this, _SitemapValidator_config, "f").renderDestination, __classPrivateFieldGet(this, _SitemapValidator_sitemapFilename, "f"));
const result = {
sitemapPath,
totalEntries: 0,
validEntries: 0,
invalidEntries: 0,
missingFiles: [],
xmlValidation: {
valid: true,
namespace: true,
wellFormed: true,
errors: []
},
errors: [],
warnings: []
};
// Check if sitemap file exists
if (!fs.existsSync(sitemapPath)) {
result.errors.push(`Sitemap file not found: ${sitemapPath}`);
result.xmlValidation.valid = false;
return result;
}
try {
// Read and validate XML structure
const xmlContent = await fsp.readFile(sitemapPath, 'utf8');
result.xmlValidation = this.validateXMLStructure(xmlContent);
if (!result.xmlValidation.valid) {
result.errors.push(...result.xmlValidation.errors);
return result;
}
// Parse sitemap entries
const entries = await this.parseSitemap(sitemapPath);
result.totalEntries = entries.length;
// Validate each entry
for (const entry of entries) {
try {
const entryValidation = await this.validateEntry(entry);
if (entryValidation.valid) {
result.validEntries++;
}
else {
result.invalidEntries++;
result.missingFiles.push(entryValidation);
}
}
catch (err) {
result.invalidEntries++;
result.errors.push(`Error validating entry ${entry.loc}: ${err.message}`);
}
}
}
catch (err) {
result.errors.push(`Error during validation: ${err.message}`);
}
return result;
}
/**
* Parse sitemap XML file
*
* Uses the sitemap package's XMLToSitemapItemStream to parse the sitemap.
*
* @param sitemapPath - Path to the sitemap file
* @returns Promise resolving to array of sitemap entries
*/
async parseSitemap(sitemapPath) {
return new Promise((resolve, reject) => {
const entries = [];
fs.createReadStream(sitemapPath)
.pipe(new XMLToSitemapItemStream())
.on('data', (item) => {
entries.push({
loc: item.url,
lastmod: item.lastmod,
changefreq: item.changefreq,
priority: item.priority
});
})
.on('end', () => resolve(entries))
.on('error', (err) => reject(err));
});
}
/**
* Map sitemap URL to filesystem path
*
* Converts a sitemap URL to the corresponding filesystem path in the output directory.
*
* @param url - Full URL from sitemap
* @returns Filesystem path where the file should exist
*/
urlToFilePath(url) {
// 1. Parse the URL
const urlObj = new URL(url);
// 2. Validate base URL matches config.root_url
const expectedBase = new URL(__classPrivateFieldGet(this, _SitemapValidator_config, "f").root_url);
if (urlObj.origin !== expectedBase.origin) {
throw new Error(`URL origin mismatch: ${urlObj.origin} (expected: ${expectedBase.origin})`);
}
// 3. Get pathname (e.g., "/blog/post.html")
let pathname = urlObj.pathname;
// 4. Remove leading slash
if (pathname.startsWith('/')) {
pathname = pathname.substring(1);
}
// 5. Handle empty pathname (root)
if (pathname === '' || pathname === '/') {
pathname = 'index.html';
}
// 6. Handle directory paths (trailing slash)
if (pathname.endsWith('/')) {
pathname = pathname + 'index.html';
}
// 7. Construct full filesystem path
const filePath = path.join(__classPrivateFieldGet(this, _SitemapValidator_config, "f").renderDestination, pathname);
return filePath;
}
/**
* Check if file exists
*
* @param filePath - Path to check
* @returns Promise resolving to true if file exists
*/
async fileExists(filePath) {
try {
await fsp.access(filePath, fs.constants.F_OK);
return true;
}
catch {
return false;
}
}
/**
* Validate a single sitemap entry
*
* @param entry - Sitemap entry to validate
* @returns Promise resolving to entry validation result
*/
async validateEntry(entry) {
const filePath = this.urlToFilePath(entry.loc);
const fileExists = await this.fileExists(filePath);
return {
entry,
valid: fileExists,
filePath,
fileExists,
error: fileExists ? undefined : 'File does not exist'
};
}
/**
* Validate XML structure
*
* Performs basic XML structure validation:
* - Checks for XML declaration
* - Validates sitemap namespace
* - Checks for required elements
*
* @param xml - XML content as string
* @returns XML validation result
*/
validateXMLStructure(xml) {
const result = {
valid: true,
namespace: true,
wellFormed: true,
errors: [],
warnings: []
};
// Check for XML declaration
if (!xml.includes('<?xml')) {
result.warnings.push('Missing XML declaration');
}
// Check for sitemap namespace
if (!xml.includes('http://www.sitemaps.org/schemas/sitemap/0.9')) {
result.namespace = false;
result.valid = false;
result.errors.push('Missing or incorrect sitemap namespace');
}
// Check for urlset or sitemapindex root element
if (!xml.includes('<urlset') && !xml.includes('<sitemapindex')) {
result.wellFormed = false;
result.valid = false;
result.errors.push('Missing root element (<urlset> or <sitemapindex>)');
}
// Check for loc elements
if (!xml.includes('<loc>')) {
result.wellFormed = false;
result.valid = false;
result.errors.push('No <loc> elements found');
}
return result;
}
/**
* Format validation result as human-readable text
*
* @param result - Validation result to format
* @returns Formatted report as string
*/
static formatReport(result) {
let report = 'Sitemap Validation Report\n';
report += '=========================\n\n';
report += `Sitemap: ${result.sitemapPath}\n`;
report += `Total Entries: ${result.totalEntries}\n`;
report += `Valid Entries: ${result.validEntries}\n`;
report += `Invalid Entries: ${result.invalidEntries}\n\n`;
if (result.missingFiles.length > 0) {
report += 'Missing Files:\n';
for (const missing of result.missingFiles) {
report += ` ✗ ${missing.filePath}\n`;
report += ` URL: ${missing.entry.loc}\n`;
}
report += '\n';
}
report += 'XML Validation: ';
if (result.xmlValidation.valid) {
report += '✓ Valid\n';
report += ` - Namespace: ✓ Correct\n`;
report += ` - Well-formed: ✓ Yes\n`;
}
else {
report += '✗ Invalid\n';
for (const error of result.xmlValidation.errors) {
report += ` - ${error}\n`;
}
}
report += '\n';
if (result.errors.length > 0) {
report += 'Errors:\n';
for (const error of result.errors) {
report += ` - ${error}\n`;
}
report += '\n';
}
if (result.warnings.length > 0) {
report += 'Warnings:\n';
for (const warning of result.warnings) {
report += ` - ${warning}\n`;
}
report += '\n';
}
const summary = result.invalidEntries === 0 && result.errors.length === 0
? '✓ Validation passed'
: `✗ Validation failed: ${result.invalidEntries} invalid entries, ${result.errors.length} errors`;
report += `Summary: ${summary}\n`;
return report;
}
}
_SitemapValidator_config = new WeakMap(), _SitemapValidator_sitemapFilename = new WeakMap();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sitemap-validator.js","sourceRoot":"","sources":["../lib/sitemap-validator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n *\n * Copyright 2014-2025 David Herron\n *\n * This file is part of AkashaCMS (http://akashacms.com/).\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\");\n *  you may not use this file except in compliance with the License.\n *  You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  Unless required by applicable law or agreed to in writing, software\n *  distributed under the License is distributed on an \"AS IS\" BASIS,\n *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *  See the License for the specific language governing permissions and\n *  limitations under the License.\n */\n\n/**\n * Sitemap Validator\n * \n * Validates generated sitemap XML files against the local rendered output directory.\n * Ensures that every URL in the sitemap corresponds to an actual file in the output.\n * \n * @module sitemap-validator\n */\n\nimport { promises as fsp } from 'node:fs';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { XMLToSitemapItemStream } from 'sitemap';\nimport type { Configuration } from './index.js';\n\n/**\n * Represents a single entry from a sitemap XML file\n */\nexport interface SitemapEntry {\n    /** Full URL from <loc> element */\n    loc: string;\n    /** Last modification date */\n    lastmod?: string;\n    /** Change frequency */\n    changefreq?: string;\n    /** Priority (0.0-1.0) */\n    priority?: number;\n}\n\n/**\n * Validation result for a single sitemap entry\n */\nexport interface EntryValidation {\n    /** The sitemap entry being validated */\n    entry: SitemapEntry;\n    /** Whether the entry is valid */\n    valid: boolean;\n    /** Filesystem path where the file should exist */\n    filePath: string;\n    /** Whether the file exists on the filesystem */\n    fileExists: boolean;\n    /** Error message if validation failed */\n    error?: string;\n}\n\n/**\n * XML structure validation result\n */\nexport interface XMLValidation {\n    /** Whether the XML is valid overall */\n    valid: boolean;\n    /** Whether the namespace is correct */\n    namespace: boolean;\n    /** Whether the XML is well-formed */\n    wellFormed: boolean;\n    /** List of validation errors */\n    errors: string[];\n    /** List of validation warnings */\n    warnings?: string[];\n}\n\n/**\n * Complete validation result\n */\nexport interface ValidationResult {\n    /** Path to the sitemap file that was validated */\n    sitemapPath: string;\n    /** Total number of entries in the sitemap */\n    totalEntries: number;\n    /** Number of valid entries */\n    validEntries: number;\n    /** Number of invalid entries */\n    invalidEntries: number;\n    /** List of entries with missing files */\n    missingFiles: EntryValidation[];\n    /** XML structure validation result */\n    xmlValidation: XMLValidation;\n    /** List of errors encountered during validation */\n    errors: string[];\n    /** List of warnings encountered during validation */\n    warnings: string[];\n}\n\n/**\n * Sitemap Validator Class\n * \n * Validates generated sitemap XML files against the local rendered output directory.\n */\nexport class SitemapValidator {\n    #config: Configuration;\n    #sitemapFilename: string;\n\n    /**\n     * Create a new SitemapValidator\n     * \n     * @param config - AkashaRender configuration object\n     * @param sitemapFilename - Name of the sitemap file (default: 'sitemap.xml')\n     */\n    constructor(config: Configuration, sitemapFilename: string = 'sitemap.xml') {\n        if (!config) {\n            throw new Error('Configuration is required');\n        }\n        if (!config.root_url) {\n            throw new Error('Configuration must have root_url set');\n        }\n        if (!config.renderDestination) {\n            throw new Error('Configuration must have renderDestination set');\n        }\n        \n        this.#config = config;\n        this.#sitemapFilename = sitemapFilename;\n    }\n\n    /**\n     * Main validation method\n     * \n     * Validates the sitemap file against the rendered output directory.\n     * \n     * @returns Promise resolving to validation result\n     */\n    async validate(): Promise<ValidationResult> {\n        const sitemapPath = path.join(this.#config.renderDestination, this.#sitemapFilename);\n        \n        const result: ValidationResult = {\n            sitemapPath,\n            totalEntries: 0,\n            validEntries: 0,\n            invalidEntries: 0,\n            missingFiles: [],\n            xmlValidation: {\n                valid: true,\n                namespace: true,\n                wellFormed: true,\n                errors: []\n            },\n            errors: [],\n            warnings: []\n        };\n\n        // Check if sitemap file exists\n        if (!fs.existsSync(sitemapPath)) {\n            result.errors.push(`Sitemap file not found: ${sitemapPath}`);\n            result.xmlValidation.valid = false;\n            return result;\n        }\n\n        try {\n            // Read and validate XML structure\n            const xmlContent = await fsp.readFile(sitemapPath, 'utf8');\n            result.xmlValidation = this.validateXMLStructure(xmlContent);\n            \n            if (!result.xmlValidation.valid) {\n                result.errors.push(...result.xmlValidation.errors);\n                return result;\n            }\n\n            // Parse sitemap entries\n            const entries = await this.parseSitemap(sitemapPath);\n            result.totalEntries = entries.length;\n\n            // Validate each entry\n            for (const entry of entries) {\n                try {\n                    const entryValidation = await this.validateEntry(entry);\n                    \n                    if (entryValidation.valid) {\n                        result.validEntries++;\n                    } else {\n                        result.invalidEntries++;\n                        result.missingFiles.push(entryValidation);\n                    }\n                } catch (err) {\n                    result.invalidEntries++;\n                    result.errors.push(`Error validating entry ${entry.loc}: ${(err as Error).message}`);\n                }\n            }\n        } catch (err) {\n            result.errors.push(`Error during validation: ${(err as Error).message}`);\n        }\n\n        return result;\n    }\n\n    /**\n     * Parse sitemap XML file\n     * \n     * Uses the sitemap package's XMLToSitemapItemStream to parse the sitemap.\n     * \n     * @param sitemapPath - Path to the sitemap file\n     * @returns Promise resolving to array of sitemap entries\n     */\n    async parseSitemap(sitemapPath: string): Promise<SitemapEntry[]> {\n        return new Promise((resolve, reject) => {\n            const entries: SitemapEntry[] = [];\n            \n            fs.createReadStream(sitemapPath)\n                .pipe(new XMLToSitemapItemStream())\n                .on('data', (item: any) => {\n                    entries.push({\n                        loc: item.url,\n                        lastmod: item.lastmod,\n                        changefreq: item.changefreq,\n                        priority: item.priority\n                    });\n                })\n                .on('end', () => resolve(entries))\n                .on('error', (err) => reject(err));\n        });\n    }\n\n    /**\n     * Map sitemap URL to filesystem path\n     * \n     * Converts a sitemap URL to the corresponding filesystem path in the output directory.\n     * \n     * @param url - Full URL from sitemap\n     * @returns Filesystem path where the file should exist\n     */\n    urlToFilePath(url: string): string {\n        // 1. Parse the URL\n        const urlObj = new URL(url);\n        \n        // 2. Validate base URL matches config.root_url\n        const expectedBase = new URL(this.#config.root_url);\n        if (urlObj.origin !== expectedBase.origin) {\n            throw new Error(`URL origin mismatch: ${urlObj.origin} (expected: ${expectedBase.origin})`);\n        }\n        \n        // 3. Get pathname (e.g., \"/blog/post.html\")\n        let pathname = urlObj.pathname;\n        \n        // 4. Remove leading slash\n        if (pathname.startsWith('/')) {\n            pathname = pathname.substring(1);\n        }\n        \n        // 5. Handle empty pathname (root)\n        if (pathname === '' || pathname === '/') {\n            pathname = 'index.html';\n        }\n        \n        // 6. Handle directory paths (trailing slash)\n        if (pathname.endsWith('/')) {\n            pathname = pathname + 'index.html';\n        }\n        \n        // 7. Construct full filesystem path\n        const filePath = path.join(this.#config.renderDestination, pathname);\n        \n        return filePath;\n    }\n\n    /**\n     * Check if file exists\n     * \n     * @param filePath - Path to check\n     * @returns Promise resolving to true if file exists\n     */\n    async fileExists(filePath: string): Promise<boolean> {\n        try {\n            await fsp.access(filePath, fs.constants.F_OK);\n            return true;\n        } catch {\n            return false;\n        }\n    }\n\n    /**\n     * Validate a single sitemap entry\n     * \n     * @param entry - Sitemap entry to validate\n     * @returns Promise resolving to entry validation result\n     */\n    async validateEntry(entry: SitemapEntry): Promise<EntryValidation> {\n        const filePath = this.urlToFilePath(entry.loc);\n        const fileExists = await this.fileExists(filePath);\n        \n        return {\n            entry,\n            valid: fileExists,\n            filePath,\n            fileExists,\n            error: fileExists ? undefined : 'File does not exist'\n        };\n    }\n\n    /**\n     * Validate XML structure\n     * \n     * Performs basic XML structure validation:\n     * - Checks for XML declaration\n     * - Validates sitemap namespace\n     * - Checks for required elements\n     * \n     * @param xml - XML content as string\n     * @returns XML validation result\n     */\n    validateXMLStructure(xml: string): XMLValidation {\n        const result: XMLValidation = {\n            valid: true,\n            namespace: true,\n            wellFormed: true,\n            errors: [],\n            warnings: []\n        };\n\n        // Check for XML declaration\n        if (!xml.includes('<?xml')) {\n            result.warnings.push('Missing XML declaration');\n        }\n\n        // Check for sitemap namespace\n        if (!xml.includes('http://www.sitemaps.org/schemas/sitemap/0.9')) {\n            result.namespace = false;\n            result.valid = false;\n            result.errors.push('Missing or incorrect sitemap namespace');\n        }\n\n        // Check for urlset or sitemapindex root element\n        if (!xml.includes('<urlset') && !xml.includes('<sitemapindex')) {\n            result.wellFormed = false;\n            result.valid = false;\n            result.errors.push('Missing root element (<urlset> or <sitemapindex>)');\n        }\n\n        // Check for loc elements\n        if (!xml.includes('<loc>')) {\n            result.wellFormed = false;\n            result.valid = false;\n            result.errors.push('No <loc> elements found');\n        }\n\n        return result;\n    }\n\n    /**\n     * Format validation result as human-readable text\n     * \n     * @param result - Validation result to format\n     * @returns Formatted report as string\n     */\n    static formatReport(result: ValidationResult): string {\n        let report = 'Sitemap Validation Report\\n';\n        report += '=========================\\n\\n';\n        \n        report += `Sitemap: ${result.sitemapPath}\\n`;\n        report += `Total Entries: ${result.totalEntries}\\n`;\n        report += `Valid Entries: ${result.validEntries}\\n`;\n        report += `Invalid Entries: ${result.invalidEntries}\\n\\n`;\n\n        if (result.missingFiles.length > 0) {\n            report += 'Missing Files:\\n';\n            for (const missing of result.missingFiles) {\n                report += `  ✗ ${missing.filePath}\\n`;\n                report += `    URL: ${missing.entry.loc}\\n`;\n            }\n            report += '\\n';\n        }\n\n        report += 'XML Validation: ';\n        if (result.xmlValidation.valid) {\n            report += '✓ Valid\\n';\n            report += `  - Namespace: ✓ Correct\\n`;\n            report += `  - Well-formed: ✓ Yes\\n`;\n        } else {\n            report += '✗ Invalid\\n';\n            for (const error of result.xmlValidation.errors) {\n                report += `  - ${error}\\n`;\n            }\n        }\n        report += '\\n';\n\n        if (result.errors.length > 0) {\n            report += 'Errors:\\n';\n            for (const error of result.errors) {\n                report += `  - ${error}\\n`;\n            }\n            report += '\\n';\n        }\n\n        if (result.warnings.length > 0) {\n            report += 'Warnings:\\n';\n            for (const warning of result.warnings) {\n                report += `  - ${warning}\\n`;\n            }\n            report += '\\n';\n        }\n\n        const summary = result.invalidEntries === 0 && result.errors.length === 0\n            ? '✓ Validation passed'\n            : `✗ Validation failed: ${result.invalidEntries} invalid entries, ${result.errors.length} errors`;\n        \n        report += `Summary: ${summary}\\n`;\n\n        return report;\n    }\n}\n"]}