@fin.cx/einvoice 5.0.3 → 5.1.3

package/ts/formats/validation/schematron.downloader.ts

@@ -0,0 +1,304 @@
+import * as plugins from '../../plugins.js';
+import * as path from 'path';
+import { promises as fs } from 'fs';
+
+/**
+ * Schematron rule sources
+ */
+export interface SchematronSource {
+  name: string;
+  version: string;
+  url: string;
+  description: string;
+  format: 'UBL' | 'CII' | 'BOTH';
+}
+
+/**
+ * Official Schematron sources for e-invoicing standards
+ */
+export const SCHEMATRON_SOURCES: Record<string, SchematronSource[]> = {
+  EN16931: [
+    {
+      name: 'EN16931-UBL',
+      version: '1.3.14',
+      url: 'https://github.com/ConnectingEurope/eInvoicing-EN16931/raw/master/ubl/schematron/EN16931-UBL-validation.sch',
+      description: 'Official EN16931 validation rules for UBL format',
+      format: 'UBL'
+    },
+    {
+      name: 'EN16931-CII',
+      version: '1.3.14',
+      url: 'https://github.com/ConnectingEurope/eInvoicing-EN16931/raw/master/cii/schematron/EN16931-CII-validation.sch',
+      description: 'Official EN16931 validation rules for CII format',
+      format: 'CII'
+    },
+    {
+      name: 'EN16931-EDIFACT',
+      version: '1.3.14',
+      url: 'https://github.com/ConnectingEurope/eInvoicing-EN16931/raw/master/edifact/schematron/EN16931-EDIFACT-validation.sch',
+      description: 'Official EN16931 validation rules for EDIFACT format',
+      format: 'CII'
+    }
+  ],
+  XRECHNUNG: [
+    {
+      name: 'XRechnung-UBL',
+      version: '3.0.2',
+      url: 'https://github.com/itplr-kosit/xrechnung-schematron/raw/master/src/validation/schematron/ubl/XRechnung-UBL-validation.sch',
+      description: 'XRechnung CIUS validation for UBL',
+      format: 'UBL'
+    },
+    {
+      name: 'XRechnung-CII',
+      version: '3.0.2',
+      url: 'https://github.com/itplr-kosit/xrechnung-schematron/raw/master/src/validation/schematron/cii/XRechnung-CII-validation.sch',
+      description: 'XRechnung CIUS validation for CII',
+      format: 'CII'
+    }
+  ],
+  PEPPOL: [
+    {
+      name: 'PEPPOL-EN16931-UBL',
+      version: '3.0.17',
+      url: 'https://github.com/OpenPEPPOL/peppol-bis-invoice-3/raw/master/rules/sch/PEPPOL-EN16931-UBL.sch',
+      description: 'PEPPOL BIS Billing 3.0 validation rules for UBL',
+      format: 'UBL'
+    },
+    {
+      name: 'PEPPOL-EN16931-CII',
+      version: '3.0.17',
+      url: 'https://github.com/OpenPEPPOL/peppol-bis-invoice-3/raw/master/rules/sch/PEPPOL-EN16931-CII.sch',
+      description: 'PEPPOL BIS Billing 3.0 validation rules for CII',
+      format: 'CII'
+    }
+  ]
+};
+
+/**
+ * Schematron downloader and cache manager
+ */
+export class SchematronDownloader {
+  private cacheDir: string;
+  private smartfile: any;
+  
+  constructor(cacheDir: string = 'assets_downloaded/schematron') {
+    this.cacheDir = cacheDir;
+  }
+  
+  /**
+   * Initialize the downloader
+   */
+  public async initialize(): Promise<void> {
+    // Ensure cache directory exists
+    this.smartfile = await import('@push.rocks/smartfile');
+    await fs.mkdir(this.cacheDir, { recursive: true });
+  }
+  
+  /**
+   * Download a Schematron file
+   */
+  public async download(source: SchematronSource): Promise<string> {
+    const fileName = `${source.name}-v${source.version}.sch`;
+    const filePath = path.join(this.cacheDir, fileName);
+    
+    // Check if already cached
+    if (await this.isCached(filePath)) {
+      console.log(`Using cached Schematron: ${fileName}`);
+      return filePath;
+    }
+    
+    console.log(`Downloading Schematron: ${source.name} v${source.version}`);
+    
+    try {
+      // Download the file
+      const response = await fetch(source.url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      
+      const content = await response.text();
+      
+      // Validate it's actually Schematron
+      if (!content.includes('schematron') && !content.includes('sch:schema')) {
+        throw new Error('Downloaded file does not appear to be Schematron');
+      }
+      
+      // Save to cache
+      await fs.writeFile(filePath, content, 'utf-8');
+      
+      // Also save metadata
+      const metaPath = filePath.replace('.sch', '.meta.json');
+      await fs.writeFile(metaPath, JSON.stringify({
+        source: source.name,
+        version: source.version,
+        url: source.url,
+        format: source.format,
+        downloadDate: new Date().toISOString()
+      }, null, 2), 'utf-8');
+      
+      console.log(`Successfully downloaded: ${fileName}`);
+      return filePath;
+    } catch (error) {
+      throw new Error(`Failed to download ${source.name}: ${error.message}`);
+    }
+  }
+  
+  /**
+   * Download all Schematron files for a standard
+   */
+  public async downloadStandard(
+    standard: 'EN16931' | 'XRECHNUNG' | 'PEPPOL'
+  ): Promise<string[]> {
+    const sources = SCHEMATRON_SOURCES[standard];
+    if (!sources) {
+      throw new Error(`Unknown standard: ${standard}`);
+    }
+    
+    const paths: string[] = [];
+    for (const source of sources) {
+      try {
+        const path = await this.download(source);
+        paths.push(path);
+      } catch (error) {
+        console.warn(`Failed to download ${source.name}: ${error.message}`);
+      }
+    }
+    
+    return paths;
+  }
+  
+  /**
+   * Check if a file is cached
+   */
+  private async isCached(filePath: string): Promise<boolean> {
+    try {
+      await fs.access(filePath);
+      
+      // Check if file is not empty
+      const stats = await fs.stat(filePath);
+      return stats.size > 0;
+    } catch {
+      return false;
+    }
+  }
+  
+  /**
+   * Get cached Schematron files
+   */
+  public async getCachedFiles(): Promise<Array<{
+    path: string;
+    metadata: any;
+  }>> {
+    const files: Array<{ path: string; metadata: any }> = [];
+    
+    try {
+      const entries = await fs.readdir(this.cacheDir);
+      
+      for (const entry of entries) {
+        if (entry.endsWith('.sch')) {
+          const filePath = path.join(this.cacheDir, entry);
+          const metaPath = filePath.replace('.sch', '.meta.json');
+          
+          try {
+            const metadata = JSON.parse(await fs.readFile(metaPath, 'utf-8'));
+            files.push({ path: filePath, metadata });
+          } catch {
+            // No metadata file
+            files.push({ path: filePath, metadata: null });
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to list cached files: ${error.message}`);
+    }
+    
+    return files;
+  }
+  
+  /**
+   * Clear cache
+   */
+  public async clearCache(): Promise<void> {
+    try {
+      const entries = await fs.readdir(this.cacheDir);
+      
+      for (const entry of entries) {
+        if (entry.endsWith('.sch') || entry.endsWith('.meta.json')) {
+          await fs.unlink(path.join(this.cacheDir, entry));
+        }
+      }
+      
+      console.log('Schematron cache cleared');
+    } catch (error) {
+      console.warn(`Failed to clear cache: ${error.message}`);
+    }
+  }
+  
+  /**
+   * Get the appropriate Schematron for a format
+   */
+  public async getSchematronForFormat(
+    standard: 'EN16931' | 'XRECHNUNG' | 'PEPPOL',
+    format: 'UBL' | 'CII'
+  ): Promise<string | null> {
+    const sources = SCHEMATRON_SOURCES[standard];
+    if (!sources) return null;
+    
+    const source = sources.find(s => s.format === format || s.format === 'BOTH');
+    if (!source) return null;
+    
+    return await this.download(source);
+  }
+  
+  /**
+   * Update all cached Schematron files
+   */
+  public async updateAll(): Promise<void> {
+    console.log('Updating all Schematron files...');
+    
+    for (const standard of ['EN16931', 'XRECHNUNG', 'PEPPOL'] as const) {
+      await this.downloadStandard(standard);
+    }
+    
+    console.log('All Schematron files updated');
+  }
+}
+
+/**
+ * ISO Schematron skeleton URLs
+ * These are needed to compile Schematron to XSLT
+ */
+export const ISO_SCHEMATRON_SKELETONS = {
+  'iso_dsdl_include.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_dsdl_include.xsl',
+  'iso_abstract_expand.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_abstract_expand.xsl',
+  'iso_svrl_for_xslt2.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_svrl_for_xslt2.xsl',
+  'iso_schematron_skeleton_for_saxon.xsl': 'https://github.com/Schematron/schematron/raw/master/trunk/schematron/code/iso_schematron_skeleton_for_saxon.xsl'
+};
+
+/**
+ * Download ISO Schematron skeleton files
+ */
+export async function downloadISOSkeletons(targetDir: string = 'assets_downloaded/schematron/iso'): Promise<void> {
+  await fs.mkdir(targetDir, { recursive: true });
+  
+  console.log('Downloading ISO Schematron skeleton files...');
+  
+  for (const [name, url] of Object.entries(ISO_SCHEMATRON_SKELETONS)) {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      
+      const content = await response.text();
+      const filePath = path.join(targetDir, name);
+      await fs.writeFile(filePath, content, 'utf-8');
+      
+      console.log(`Downloaded: ${name}`);
+    } catch (error) {
+      console.warn(`Failed to download ${name}: ${error.message}`);
+    }
+  }
+  
+  console.log('ISO Schematron skeleton download complete');
+}

package/ts/formats/validation/schematron.integration.ts

@@ -0,0 +1,285 @@
+/**
+ * Integration of official Schematron validation with the EInvoice module
+ */
+
+import { SchematronValidator, HybridValidator } from './schematron.validator.js';
+import { EN16931BusinessRulesValidator } from './en16931.business-rules.validator.js';
+import { CodeListValidator } from './codelist.validator.js';
+import type { ValidationResult, ValidationOptions, ValidationReport } from './validation.types.js';
+import type { EInvoice } from '../../einvoice.js';
+import * as path from 'path';
+import { promises as fs } from 'fs';
+
+/**
+ * Integrated validator combining TypeScript and Schematron validation
+ */
+export class IntegratedValidator {
+  private hybridValidator: HybridValidator;
+  private schematronValidator: SchematronValidator;
+  private businessRulesValidator: EN16931BusinessRulesValidator;
+  private codeListValidator: CodeListValidator;
+  private schematronLoaded: boolean = false;
+  
+  constructor() {
+    this.schematronValidator = new SchematronValidator();
+    this.hybridValidator = new HybridValidator(this.schematronValidator);
+    this.businessRulesValidator = new EN16931BusinessRulesValidator();
+    this.codeListValidator = new CodeListValidator();
+    
+    // Add TypeScript validators to hybrid pipeline
+    this.setupTypeScriptValidators();
+  }
+  
+  /**
+   * Setup TypeScript validators in the hybrid pipeline
+   */
+  private setupTypeScriptValidators(): void {
+    // Wrap business rules validator
+    this.hybridValidator.addTSValidator({
+      validate: (xml: string) => {
+        // Note: This would need the invoice object, not XML
+        // In practice, we'd parse the XML to EInvoice first
+        return [];
+      }
+    });
+  }
+  
+  /**
+   * Load Schematron for a specific format and standard
+   */
+  public async loadSchematron(
+    standard: 'EN16931' | 'PEPPOL' | 'XRECHNUNG',
+    format: 'UBL' | 'CII'
+  ): Promise<void> {
+    const schematronPath = await this.getSchematronPath(standard, format);
+    
+    if (!schematronPath) {
+      throw new Error(`No Schematron available for ${standard} ${format}`);
+    }
+    
+    // Check if file exists
+    try {
+      await fs.access(schematronPath);
+    } catch {
+      throw new Error(`Schematron file not found: ${schematronPath}. Run 'npm run download-schematron' first.`);
+    }
+    
+    await this.schematronValidator.loadSchematron(schematronPath, true);
+    this.schematronLoaded = true;
+  }
+  
+  /**
+   * Get the path to the appropriate Schematron file
+   */
+  private async getSchematronPath(
+    standard: 'EN16931' | 'PEPPOL' | 'XRECHNUNG',
+    format: 'UBL' | 'CII'
+  ): Promise<string | null> {
+    const basePath = 'assets_downloaded/schematron';
+    
+    // Map standard and format to file pattern
+    const patterns: Record<string, Record<string, string>> = {
+      EN16931: {
+        UBL: 'EN16931-UBL-*.sch',
+        CII: 'EN16931-CII-*.sch'
+      },
+      PEPPOL: {
+        UBL: 'PEPPOL-EN16931-UBL-*.sch',
+        CII: 'PEPPOL-EN16931-CII-*.sch'
+      },
+      XRECHNUNG: {
+        UBL: 'XRechnung-UBL-*.sch',
+        CII: 'XRechnung-CII-*.sch'
+      }
+    };
+    
+    const pattern = patterns[standard]?.[format];
+    if (!pattern) return null;
+    
+    // Find matching files
+    try {
+      const files = await fs.readdir(basePath);
+      const regex = new RegExp(pattern.replace('*', '.*'));
+      const matches = files.filter(f => regex.test(f));
+      
+      if (matches.length > 0) {
+        // Return the most recent version (lexicographically last)
+        matches.sort();
+        return path.join(basePath, matches[matches.length - 1]);
+      }
+    } catch {
+      // Directory doesn't exist
+    }
+    
+    return null;
+  }
+  
+  /**
+   * Validate an invoice using all available validators
+   */
+  public async validate(
+    invoice: EInvoice,
+    xmlContent?: string,
+    options: ValidationOptions = {}
+  ): Promise<ValidationReport> {
+    const startTime = Date.now();
+    const results: ValidationResult[] = [];
+    
+    // Determine format hint
+    const formatHint = options.formatHint || this.detectFormat(xmlContent);
+    
+    // Run TypeScript validators
+    if (options.checkCodeLists !== false) {
+      results.push(...this.codeListValidator.validate(invoice));
+    }
+    
+    results.push(...this.businessRulesValidator.validate(invoice, options));
+    
+    // Run Schematron validation if XML is provided and Schematron is loaded
+    if (xmlContent && this.schematronLoaded) {
+      try {
+        const schematronResults = await this.schematronValidator.validate(xmlContent, {
+          includeWarnings: !options.strictMode,
+          parameters: {
+            profile: options.profile
+          }
+        });
+        results.push(...schematronResults);
+      } catch (error) {
+        console.warn(`Schematron validation failed: ${error.message}`);
+      }
+    }
+    
+    // Calculate statistics
+    const errorCount = results.filter(r => r.severity === 'error').length;
+    const warningCount = results.filter(r => r.severity === 'warning').length;
+    const infoCount = results.filter(r => r.severity === 'info').length;
+    
+    // Estimate rule coverage
+    const totalRules = this.estimateTotalRules(options.profile);
+    const rulesChecked = new Set(results.map(r => r.ruleId)).size;
+    
+    return {
+      valid: errorCount === 0,
+      profile: options.profile || 'EN16931',
+      timestamp: new Date().toISOString(),
+      validatorVersion: '1.0.0',
+      rulesetVersion: '1.3.14',
+      results,
+      errorCount,
+      warningCount,
+      infoCount,
+      rulesChecked,
+      rulesTotal: totalRules,
+      coverage: (rulesChecked / totalRules) * 100,
+      validationTime: Date.now() - startTime,
+      documentId: invoice.accountingDocId,
+      documentType: invoice.accountingDocType,
+      format: formatHint
+    };
+  }
+  
+  /**
+   * Detect format from XML content
+   */
+  private detectFormat(xmlContent?: string): 'UBL' | 'CII' | undefined {
+    if (!xmlContent) return undefined;
+    
+    if (xmlContent.includes('urn:oasis:names:specification:ubl:schema:xsd:Invoice-2')) {
+      return 'UBL';
+    } else if (xmlContent.includes('urn:un:unece:uncefact:data:standard:CrossIndustryInvoice')) {
+      return 'CII';
+    }
+    
+    return undefined;
+  }
+  
+  /**
+   * Estimate total number of rules for a profile
+   */
+  private estimateTotalRules(profile?: string): number {
+    const ruleCounts: Record<string, number> = {
+      EN16931: 150,
+      PEPPOL_BIS_3_0: 250,
+      XRECHNUNG_3_0: 280,
+      FACTURX_BASIC: 100,
+      FACTURX_EN16931: 150
+    };
+    
+    return ruleCounts[profile || 'EN16931'] || 150;
+  }
+  
+  /**
+   * Validate with automatic format detection
+   */
+  public async validateAuto(
+    invoice: EInvoice,
+    xmlContent?: string
+  ): Promise<ValidationReport> {
+    // Auto-detect format
+    const format = this.detectFormat(xmlContent);
+    
+    // Try to load appropriate Schematron
+    if (format && !this.schematronLoaded) {
+      try {
+        await this.loadSchematron('EN16931', format);
+      } catch (error) {
+        console.warn(`Could not load Schematron: ${error.message}`);
+      }
+    }
+    
+    return this.validate(invoice, xmlContent, {
+      formatHint: format,
+      checkCalculations: true,
+      checkVAT: true,
+      checkCodeLists: true
+    });
+  }
+  
+  /**
+   * Check if Schematron validation is available
+   */
+  public hasSchematron(): boolean {
+    return this.schematronLoaded;
+  }
+  
+  /**
+   * Get available Schematron files
+   */
+  public async getAvailableSchematron(): Promise<Array<{
+    standard: string;
+    format: string;
+    path: string;
+  }>> {
+    const available: Array<{ standard: string; format: string; path: string }> = [];
+    
+    for (const standard of ['EN16931', 'PEPPOL', 'XRECHNUNG'] as const) {
+      for (const format of ['UBL', 'CII'] as const) {
+        const schematronPath = await this.getSchematronPath(standard, format);
+        if (schematronPath) {
+          available.push({ standard, format, path: schematronPath });
+        }
+      }
+    }
+    
+    return available;
+  }
+}
+
+/**
+ * Create a pre-configured validator for a specific standard
+ */
+export async function createStandardValidator(
+  standard: 'EN16931' | 'PEPPOL' | 'XRECHNUNG',
+  format: 'UBL' | 'CII'
+): Promise<IntegratedValidator> {
+  const validator = new IntegratedValidator();
+  
+  try {
+    await validator.loadSchematron(standard, format);
+  } catch (error) {
+    console.warn(`Schematron not available for ${standard} ${format}: ${error.message}`);
+  }
+  
+  return validator;
+}