@xml-auditfile/auditfile 0.0.0-stage → 0.0.2-alpha.3

package/src/diagnostics/diagnostic.js

@@ -0,0 +1,53 @@
+/** Severity of a diagnostic, from least to most severe. */
+export const DiagnosticSeverity = Object.freeze({
+    /** Information only. */
+    Info: 'info',
+    /** Something to look at; the result is still usable. */
+    Warning: 'warning',
+    /** The file does not meet the standard. */
+    Error: 'error',
+    /** Reading stopped. */
+    Fatal: 'fatal',
+});
+
+const RANK = new Map([['info', 0], ['warning', 1], ['error', 2], ['fatal', 3]]);
+
+/**
+ * Orders severities: negative when `a` is less severe than `b`.
+ * @param {string} a
+ * @param {string} b
+ */
+export function compareSeverity(a, b) {
+    return RANK.get(a) - RANK.get(b);
+}
+
+/** A finding about an audit file, with a stable code from auditfile-spec. */
+export class Diagnostic {
+    /** @internal */
+    constructor(code, layer, severity, message, part, line, position, path) {
+        /** Code, e.g. "XAF-R001". */
+        this.code = code;
+        /** "xml", "version", "structure", "xsd", "rules", "dialect" or "view". */
+        this.layer = layer;
+        /** Severity, one of {@link DiagnosticSeverity}. */
+        this.severity = severity;
+        /** Message in the requested language. */
+        this.message = message;
+        /** Source part (1-based), when known; otherwise null. */
+        this.part = part;
+        /** Line number, when known; otherwise null. */
+        this.line = line;
+        /** Position on the line, when known; otherwise null. */
+        this.position = position;
+        /** XML path, when known; otherwise null. */
+        this.path = path;
+        Object.freeze(this);
+    }
+
+    toString() {
+        const severity = this.severity[0].toUpperCase() + this.severity.slice(1);
+        return this.line === null
+            ? `${this.code} ${severity}: ${this.message}`
+            : `${this.code} ${severity} (line ${this.line}): ${this.message}`;
+    }
+}

package/src/diagnostics/report.js

@@ -0,0 +1,56 @@
+import { DiagnosticSeverity } from './diagnostic.js';
+
+/** Outcome of a scan, validation or read. */
+export class AuditfileReport {
+    #counts;
+
+    /** @internal */
+    constructor(schema, parts, diagnostics, counts, truncated, rowCounts, loaded, duration) {
+        /** @type {import('../schema/schema.js').AuditfileSchema | null} The import schema, or null when the version could not be determined. */
+        this.schema = schema;
+        /** @type {readonly import('../reading/source.js').PartInfo[]} Source parts with size and SHA-256 (empty when a part was not read completely). */
+        this.parts = Object.freeze([...parts]);
+        /**
+         * @type {readonly import('./diagnostic.js').Diagnostic[]} The diagnostics, in the order they were found, at most `maxDiagnostics`
+         * plus XAF-X900 when more were found. A full list makes room for errors by leaving out infos and warnings; fatal diagnostics are always included.
+         */
+        this.diagnostics = Object.freeze([...diagnostics]);
+        /** True when diagnostics were left out of {@link AuditfileReport#diagnostics}; {@link AuditfileReport#count} still counts them. */
+        this.isTruncated = truncated;
+        /** @type {ReadonlyMap<string, number>} Rows per table. */
+        this.rowCounts = new Map(rowCounts);
+        /** True when rows were handed to the sink and completed. */
+        this.loaded = loaded;
+        /** Time taken, in milliseconds. */
+        this.duration = duration;
+        this.#counts = Object.freeze({ ...counts });
+        Object.freeze(this);
+    }
+
+    /** True when a fatal diagnostic was found: reading stopped. */
+    get hasFatal() {
+        return this.#counts.fatal > 0;
+    }
+
+    /** True when an error or fatal diagnostic was found, also when it is not in a truncated {@link AuditfileReport#diagnostics}. */
+    get hasErrors() {
+        return this.hasFatal || this.#counts.error > 0;
+    }
+
+    /** True when there are no errors and no fatal diagnostics. */
+    get isValid() {
+        return !this.hasErrors;
+    }
+
+    /**
+     * Number of diagnostics with the given severity, including the ones left out of a truncated {@link AuditfileReport#diagnostics}.
+     * @param {string} severity One of {@link DiagnosticSeverity}.
+     */
+    count(severity) {
+        if (!Object.values(DiagnosticSeverity).includes(severity)) {
+            throw new RangeError(`Unknown severity '${severity}'.`);
+        }
+
+        return this.#counts[severity];
+    }
+}