@fin.cx/einvoice 6.2.0 → 7.0.1

package/ts/formats/validation/schematron.validator.ts

@@ -1,190 +1,207 @@
 import * as plugins from '../../plugins.js';
 import type { ValidationResult } from './validation.types.js';
-import { loadSaxonJS, type ISaxonJSTransformOptions, type ISaxonJSTransformResult } from '../../vendor/saxonjs.js';
 
 /**
  * Schematron validation options
  */
 export interface SchematronOptions {
   phase?: string; // Schematron phase to activate
-  parameters?: Record<string, any>; // Parameters to pass to Schematron
   includeWarnings?: boolean; // Include warning-level messages
   maxErrors?: number; // Maximum errors before stopping
 }
 
-type TSchematronSourceKind = 'none' | 'schematron' | 'sef';
+/**
+ * Turns one failed assertion or fired report into a ValidationResult.
+ */
+export function schematronFailureToValidationResult(
+  failure: plugins.smartxmlSchematron.ISchematronFailure,
+): ValidationResult {
+  const flag = (failure.flag || failure.role || '').toLowerCase();
+  let severity: 'error' | 'warning' | 'info' = failure.kind === 'assert' ? 'error' : 'warning';
+  if (flag.includes('fatal') || flag.includes('error')) {
+    severity = 'error';
+  } else if (flag.includes('warning')) {
+    severity = 'warning';
+  } else if (flag.includes('info')) {
+    severity = 'info';
+  }
+
+  const btMatch = failure.message.match(/\[BT-(\d+)\]/);
+  const bgMatch = failure.message.match(/\[BG-(\d+)\]/);
+
+  return {
+    ruleId: failure.id || failure.patternId || 'UNKNOWN',
+    source: 'SCHEMATRON',
+    severity,
+    message: failure.message,
+    syntaxPath: failure.location,
+    expected: failure.test,
+    btReference: btMatch ? `BT-${btMatch[1]}` : undefined,
+    bgReference: bgMatch ? `BG-${bgMatch[1]}` : undefined,
+  };
+}
+
+/**
+ * Turns a whole report into results. An expression the engine could not evaluate has
+ * proven nothing, so it is reported as an error rather than passing silently.
+ */
+export function schematronReportToValidationResults(
+  report: plugins.smartxmlSchematron.ISchematronReport,
+): ValidationResult[] {
+  return [
+    ...report.failures.map(schematronFailureToValidationResult),
+    ...report.engineErrors.map((engineError) => ({
+      ruleId: 'SCHEMATRON-ENGINE-ERROR',
+      source: 'SCHEMATRON',
+      severity: 'error' as const,
+      message: `${engineError.message} (at ${engineError.origin})`,
+      expected: engineError.expression,
+    })),
+  ];
+}
 
 /**
- * Schematron validation engine using Saxon-JS
- * Provides official standards validation through Schematron rules
+ * Applies the reporting options of a validation call to a result list.
+ */
+export function applySchematronOptions(
+  results: ValidationResult[],
+  options: SchematronOptions,
+): ValidationResult[] {
+  const filtered = options.includeWarnings
+    ? results
+    : results.filter((result) => result.severity !== 'warning');
+
+  if (
+    options.maxErrors &&
+    filtered.filter((result) => result.severity === 'error').length > options.maxErrors
+  ) {
+    return filtered.slice(0, options.maxErrors);
+  }
+
+  return filtered;
+}
+
+/**
+ * Schematron validation engine.
+ *
+ * The rules are interpreted on the XPath engine of `@push.rocks/smartxml`, so the
+ * published `.sch` files of CEN, KoSIT and PEPPOL run as they are downloaded; no
+ * XSLT processor and no precompiled stylesheet is involved.
  */
 export class SchematronValidator {
   private schematronRules: string;
-  private sourceKind: TSchematronSourceKind = 'none';
-  private stylesheetFileName?: string;
-  private stylesheetInternal?: unknown;
-  
+  private schema?: plugins.smartxmlSchematron.Schematron;
+  private schemaError?: string;
+  private baseUri?: string;
+  /** one compiled schema per activated phase; a phase selects patterns at compile time */
+  private schemasByPhase = new Map<string, plugins.smartxmlSchematron.Schematron>();
+
   constructor(schematronRules?: string) {
     this.schematronRules = schematronRules || '';
+    if (this.schematronRules) {
+      this.compile();
+    }
   }
-  
+
   /**
    * Load Schematron rules from file or string
    */
   public async loadSchematron(source: string, isFilePath: boolean = true): Promise<void> {
-    let sourceContent: string;
+    this.schematronRules = isFilePath ? await plugins.fs.readFile(source, 'utf-8') : source;
+    this.baseUri = isFilePath ? source : undefined;
+    this.compile();
+  }
+
+  /**
+   * Compiles the loaded rules. A schema that does not compile keeps its reason, so
+   * validate() can report it instead of load failing far from the cause.
+   */
+  private compile(): void {
+    this.schema = undefined;
+    this.schemaError = undefined;
+    this.schemasByPhase.clear();
 
-    if (isFilePath) {
-      sourceContent = await plugins.fs.readFile(source, 'utf-8');
-    } else {
-      sourceContent = source;
+    const trimmed = this.schematronRules.trim();
+    if (!trimmed) {
+      return;
+    }
+    if (trimmed.startsWith('{')) {
+      this.schemaError =
+        'the source is a compiled XSLT stylesheet (SEF); load the Schematron .sch file instead, it is executed directly';
+      return;
     }
 
-    this.schematronRules = sourceContent;
-    this.sourceKind = this.detectSourceKind(source, sourceContent, isFilePath);
-    this.stylesheetFileName = undefined;
-    this.stylesheetInternal = undefined;
+    try {
+      this.schema = this.compileForPhase(undefined);
+      this.schemasByPhase.set('', this.schema);
+    } catch (error) {
+      this.schemaError = error instanceof Error ? error.message : String(error);
+    }
+  }
 
-    if (this.sourceKind === 'sef') {
-      if (isFilePath) {
-        this.stylesheetFileName = source;
-      } else {
-        this.stylesheetInternal = JSON.parse(sourceContent);
-      }
+  private compileForPhase(phase: string | undefined): plugins.smartxmlSchematron.Schematron {
+    return plugins.smartxmlSchematron.Schematron.fromString(this.schematronRules, {
+      phase,
+      baseUri: this.baseUri,
+      // the published rule sets split their patterns over sch:include files
+      resolveInclude: (href, base) =>
+        plugins.readFileSync(
+          plugins.path.resolve(plugins.path.dirname(base ?? this.baseUri ?? '.'), href),
+          'utf-8',
+        ),
+    });
+  }
+
+  /**
+   * The schema for one phase. A phase activates a subset of the patterns, which the
+   * engine resolves while compiling, so each phase gets its own compiled schema.
+   */
+  private schemaForPhase(phase?: string): plugins.smartxmlSchematron.Schematron {
+    const key = phase ?? '';
+    const cached = this.schemasByPhase.get(key);
+    if (cached) {
+      return cached;
     }
+    const compiled = this.compileForPhase(phase);
+    this.schemasByPhase.set(key, compiled);
+    return compiled;
   }
-  
+
   /**
    * Validate an XML document against loaded Schematron rules
    */
   public async validate(
     xmlContent: string,
-    options: SchematronOptions = {}
+    options: SchematronOptions = {},
   ): Promise<ValidationResult[]> {
     if (!this.schematronRules) {
       throw new Error('No Schematron rules loaded');
     }
-    
-    const results: ValidationResult[] = [];
 
-    if (!this.canValidate()) {
-      return [this.createUnavailableResult()];
+    if (!this.schema) {
+      return [this.createUnusableResult()];
     }
-    
-    try {
-      const transformOptions: ISaxonJSTransformOptions = {
-        sourceText: xmlContent,
-        destination: 'serialized',
-        stylesheetParams: options.parameters || {}
-      };
-
-      if (this.stylesheetFileName) {
-        transformOptions.stylesheetFileName = this.stylesheetFileName;
-      } else {
-        transformOptions.stylesheetInternal = this.stylesheetInternal;
-      }
 
-      // Transform the XML with a precompiled Saxon-JS SEF stylesheet.
-      const SaxonJS = await loadSaxonJS();
-      const transformResult = await SaxonJS.transform(transformOptions, 'async') as ISaxonJSTransformResult;
-      
-      // Parse the SVRL (Schematron Validation Report Language) output
-      results.push(...this.parseSVRL(transformResult.principalResult));
-      
-      // Apply options filters
-      if (!options.includeWarnings) {
-        return results.filter(r => r.severity !== 'warning');
-      }
-      
-      if (options.maxErrors && results.filter(r => r.severity === 'error').length > options.maxErrors) {
-        return results.slice(0, options.maxErrors);
-      }
-      
-      return results;
+    let results: ValidationResult[] = [];
+    try {
+      results = schematronReportToValidationResults(
+        this.schemaForPhase(options.phase).validate(xmlContent),
+      );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      results.push({
-        ruleId: 'SCHEMATRON-ERROR',
-        source: 'SCHEMATRON',
-        severity: 'error',
-        message: `Schematron validation failed: ${errorMessage}`,
-        btReference: undefined,
-        bgReference: undefined
-      });
-      return results;
+      return [
+        {
+          ruleId: 'SCHEMATRON-ERROR',
+          source: 'SCHEMATRON',
+          severity: 'error',
+          message: `Schematron validation failed: ${errorMessage}`,
+        },
+      ];
     }
+
+    return applySchematronOptions(results, options);
   }
-  
-  /**
-   * Parse SVRL output to ValidationResult array
-   */
-  private parseSVRL(svrlXml: string): ValidationResult[] {
-    const results: ValidationResult[] = [];
-    
-    // Parse SVRL XML
-    const parser = new plugins.xmldom.DOMParser();
-    const doc = parser.parseFromString(svrlXml, 'text/xml');
-    
-    // Get all failed assertions and successful reports
-    const failedAsserts = doc.getElementsByTagName('svrl:failed-assert');
-    const successfulReports = doc.getElementsByTagName('svrl:successful-report');
-    
-    // Process failed assertions (these are errors)
-    for (let i = 0; i < failedAsserts.length; i++) {
-      const assert = failedAsserts[i];
-      const result = this.extractValidationResult(assert, 'error');
-      if (result) results.push(result);
-    }
-    
-    // Process successful reports (these can be warnings or info)
-    for (let i = 0; i < successfulReports.length; i++) {
-      const report = successfulReports[i];
-      const result = this.extractValidationResult(report, 'warning');
-      if (result) results.push(result);
-    }
-    
-    return results;
-  }
-  
-  /**
-   * Extract ValidationResult from SVRL element
-   */
-  private extractValidationResult(
-    element: Element,
-    defaultSeverity: 'error' | 'warning'
-  ): ValidationResult | null {
-    const text = element.getElementsByTagName('svrl:text')[0]?.textContent || '';
-    const location = element.getAttribute('location') || undefined;
-    const test = element.getAttribute('test') || '';
-    const id = element.getAttribute('id') || element.getAttribute('role') || 'UNKNOWN';
-    const flag = element.getAttribute('flag') || defaultSeverity;
-    
-    // Determine severity from flag attribute
-    let severity: 'error' | 'warning' | 'info' = defaultSeverity;
-    if (flag.toLowerCase().includes('fatal') || flag.toLowerCase().includes('error')) {
-      severity = 'error';
-    } else if (flag.toLowerCase().includes('warning')) {
-      severity = 'warning';
-    } else if (flag.toLowerCase().includes('info')) {
-      severity = 'info';
-    }
-    
-    // Extract BT/BG references if present
-    const btMatch = text.match(/\[BT-(\d+)\]/);
-    const bgMatch = text.match(/\[BG-(\d+)\]/);
-    
-    return {
-      ruleId: id,
-      source: 'EN16931',
-      severity,
-      message: text,
-      syntaxPath: location,
-      btReference: btMatch ? `BT-${btMatch[1]}` : undefined,
-      bgReference: bgMatch ? `BG-${bgMatch[1]}` : undefined,
-      profile: 'EN16931'
-    };
-  }
-  
+
   /**
    * Check if validator has rules loaded
    */
@@ -193,65 +210,48 @@ export class SchematronValidator {
   }
 
   /**
-   * Check if loaded rules can be executed by Saxon-JS.
+   * Check whether the loaded rules compiled and can be executed.
    */
   public canValidate(): boolean {
-    return this.sourceKind === 'sef' && Boolean(this.stylesheetFileName || this.stylesheetInternal);
+    return Boolean(this.schema);
   }
 
-  private detectSourceKind(source: string, sourceContent: string, isFilePath: boolean): TSchematronSourceKind {
-    const trimmed = sourceContent.trim();
-    if (!trimmed) {
-      return 'none';
-    }
-
-    if (isFilePath && /\.sef\.json$/i.test(source)) {
-      return 'sef';
-    }
-
-    if (trimmed.startsWith('{')) {
-      return 'sef';
-    }
-
-    return 'schematron';
-  }
-
-  private createUnavailableResult(): ValidationResult {
+  private createUnusableResult(): ValidationResult {
     return {
-      ruleId: 'SCHEMATRON-UNCOMPILED',
+      ruleId: 'SCHEMATRON-UNUSABLE',
       source: 'SCHEMATRON',
       severity: 'error',
-      message: 'Schematron validation requires a precompiled Saxon-JS SEF JSON stylesheet. Raw .sch files are loaded for inspection only and are not executed.',
-      remediation: 'Compile Schematron rules to .sef.json with Saxon tooling and load the compiled SEF resource.'
+      message: `Schematron rules could not be compiled: ${this.schemaError ?? 'the source is empty'}`,
+      remediation: 'Load a Schematron schema whose sch:include files sit next to it.',
     };
   }
-  
+
   /**
    * Get list of available phases from Schematron
    */
   public async getPhases(): Promise<string[]> {
     if (!this.schematronRules) return [];
-    
+
     const parser = new plugins.xmldom.DOMParser();
     const doc = parser.parseFromString(this.schematronRules, 'text/xml');
     const phases = doc.getElementsByTagName('sch:phase');
-    
+
     const phaseNames: string[] = [];
     for (let i = 0; i < phases.length; i++) {
       const id = phases[i].getAttribute('id');
       if (id) phaseNames.push(id);
     }
-    
+
     return phaseNames;
   }
-  
+
   /**
    * Validate with specific phase activated
    */
   public async validateWithPhase(
     xmlContent: string,
     phase: string,
-    options: SchematronOptions = {}
+    options: SchematronOptions = {},
   ): Promise<ValidationResult[]> {
     return this.validate(xmlContent, { ...options, phase });
   }
@@ -261,10 +261,10 @@ export class SchematronValidator {
  * Factory function to create validator with standard Schematron packs
  */
 export async function createStandardValidator(
-  standard: 'EN16931' | 'XRECHNUNG' | 'PEPPOL' | 'FACTURX'
+  standard: 'EN16931' | 'XRECHNUNG' | 'PEPPOL' | 'FACTURX',
 ): Promise<SchematronValidator> {
   const validator = new SchematronValidator();
-  
+
   // Load appropriate Schematron based on standard
   // These paths would point to actual Schematron files in production
   switch (standard) {
@@ -285,7 +285,7 @@ export async function createStandardValidator(
       await validator.loadSchematron('assets_downloaded/schematron/facturx/Factur-X-EN16931-validation.sch');
       break;
   }
-  
+
   return validator;
 }
 
@@ -295,27 +295,27 @@ export async function createStandardValidator(
 export class HybridValidator {
   private schematronValidator: SchematronValidator;
   private tsValidators: Array<{ validate: (xml: string) => ValidationResult[] }> = [];
-  
+
   constructor(schematronValidator?: SchematronValidator) {
     this.schematronValidator = schematronValidator || new SchematronValidator();
   }
-  
+
   /**
    * Add a TypeScript validator to the pipeline
    */
   public addTSValidator(validator: { validate: (xml: string) => ValidationResult[] }): void {
     this.tsValidators.push(validator);
   }
-  
+
   /**
    * Run all validators and merge results
    */
   public async validate(
     xmlContent: string,
-    options: SchematronOptions = {}
+    options: SchematronOptions = {},
   ): Promise<ValidationResult[]> {
     const results: ValidationResult[] = [];
-    
+
     // Run TypeScript validators first (faster, better UX)
     for (const validator of this.tsValidators) {
       try {
@@ -325,7 +325,7 @@ export class HybridValidator {
         console.warn(`TS validator failed: ${errorMessage}`);
       }
     }
-    
+
     // Run Schematron validation if available
     if (this.schematronValidator.hasRules()) {
       try {
@@ -336,10 +336,10 @@ export class HybridValidator {
         console.warn(`Schematron validation failed: ${errorMessage}`);
       }
     }
-    
+
     // Deduplicate results by ruleId
     const seen = new Set<string>();
-    return results.filter(r => {
+    return results.filter((r) => {
       if (seen.has(r.ruleId)) return false;
       seen.add(r.ruleId);
       return true;