@fin.cx/einvoice 6.2.0 → 7.0.1

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

@@ -93,55 +93,140 @@ export class SchematronDownloader {
   }
   
   /**
-   * Download a Schematron file
+   * Download a Schematron file together with every file it includes.
+   *
+   * The published rule sets split their patterns over sch:include files, so a lone
+   * entry document cannot be validated with. The upstream directory layout is
+   * mirrored under the cache so those relative includes still resolve.
    */
   public async download(source: SchematronSource): Promise<string> {
-    const fileName = `${source.name}-v${source.version}.sch`;
-    const filePath = path.join(this.cacheDir, fileName);
-    
+    const filePath = this.entryPathFor(source);
+
     // Check if already cached
     if (await this.isCached(filePath)) {
-      console.log(`Using cached Schematron: ${fileName}`);
+      console.log(`Using cached Schematron: ${source.name} v${source.version}`);
       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');
-      
+      const fileCount = await this.fetchWithIncludes(source.url, filePath, new Set<string>());
+
       // Also save metadata
-      const metaPath = filePath.replace('.sch', '.meta.json');
+      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,
+        fileCount,
         downloadDate: new Date().toISOString()
       }, null, 2), 'utf-8');
-      
-      console.log(`Successfully downloaded: ${fileName}`);
+
+      await this.writeIndexEntry(source, filePath);
+
+      console.log(`Successfully downloaded: ${source.name} (${fileCount} file${fileCount === 1 ? '' : 's'})`);
       return filePath;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to download ${source.name}: ${errorMessage}`);
     }
   }
-  
+
+  /**
+   * Where the entry document of a source lands: one directory per source and
+   * version, holding the upstream path so relative includes keep working.
+   */
+  private entryPathFor(source: SchematronSource): string {
+    return path.join(this.cacheDir, `${source.name}-v${source.version}`, this.repositoryPath(source.url));
+  }
+
+  /**
+   * The part of a raw URL below the repository and its ref, e.g.
+   * `ubl/schematron/EN16931-UBL-validation.sch`.
+   */
+  private repositoryPath(url: string): string {
+    const { pathname } = new URL(url);
+    const match = /\/raw\/[^/]+\/(.+)$/.exec(pathname);
+    return match ? match[1] : pathname.replace(/^\//, '');
+  }
+
+  /**
+   * Fetches one document and, recursively, every sch:include and sch:extends it
+   * names. Returns how many files were written.
+   */
+  private async fetchWithIncludes(url: string, filePath: string, seen: Set<string>): Promise<number> {
+    if (seen.has(url)) {
+      return 0;
+    }
+    seen.add(url);
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText} for ${url}`);
+    }
+
+    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: ${url}`);
+    }
+
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+
+    let fileCount = 1;
+    for (const href of SchematronDownloader.extractIncludes(content)) {
+      const includePath = path.resolve(path.dirname(filePath), href);
+      if (!includePath.startsWith(path.resolve(this.cacheDir) + path.sep)) {
+        throw new Error(`Schematron include escapes the cache directory: ${href}`);
+      }
+      fileCount += await this.fetchWithIncludes(new URL(href, url).toString(), includePath, seen);
+    }
+
+    return fileCount;
+  }
+
+  /**
+   * The href of every sch:include and sch:extends in a schema, whatever prefix the
+   * document binds the Schematron namespace to.
+   */
+  private static extractIncludes(content: string): string[] {
+    const hrefs: string[] = [];
+    const pattern = /<(?:[A-Za-z0-9_.-]+:)?(?:include|extends)\s+[^>]*href\s*=\s*"([^"]+)"/g;
+    let match: RegExpExecArray | null;
+    while ((match = pattern.exec(content)) !== null) {
+      hrefs.push(match[1]);
+    }
+    return hrefs;
+  }
+
+  /**
+   * Records the entry document of each source, so a consumer finds it without
+   * guessing at file names.
+   */
+  private async writeIndexEntry(source: SchematronSource, filePath: string): Promise<void> {
+    const indexPath = path.join(this.cacheDir, 'index.json');
+    let index: Record<string, unknown> = {};
+    try {
+      index = JSON.parse(await fs.readFile(indexPath, 'utf-8'));
+    } catch {
+      // no index yet
+    }
+
+    index[source.name] = {
+      entry: path.relative(this.cacheDir, filePath),
+      version: source.version,
+      format: source.format,
+      url: source.url,
+      downloadDate: new Date().toISOString(),
+    };
+
+    await fs.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, 'utf-8');
+  }
+
   /**
    * Download all Schematron files for a standard
    */
@@ -190,52 +275,56 @@ export class SchematronDownloader {
     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 });
-          }
-        }
+
+    for (const [name, entry] of Object.entries(await this.readIndex())) {
+      const filePath = path.join(this.cacheDir, (entry as { entry: string }).entry);
+      if (await this.isCached(filePath)) {
+        files.push({ path: filePath, metadata: { source: name, ...(entry as object) } });
       }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn(`Failed to list cached files: ${errorMessage}`);
     }
-    
+
     return files;
   }
-  
+
+  /**
+   * The index of downloaded entry documents; empty when nothing was downloaded yet.
+   */
+  public async readIndex(): Promise<Record<string, { entry: string; version: string; format: string; url: string }>> {
+    try {
+      return JSON.parse(await fs.readFile(path.join(this.cacheDir, 'index.json'), 'utf-8'));
+    } catch {
+      return {};
+    }
+  }
+
+  /**
+   * The entry document of one source, or null when it was not downloaded.
+   */
+  public async getCachedEntry(sourceName: string): Promise<string | null> {
+    const entry = (await this.readIndex())[sourceName];
+    if (!entry) {
+      return null;
+    }
+    const filePath = path.join(this.cacheDir, entry.entry);
+    return (await this.isCached(filePath)) ? filePath : null;
+  }
+
   /**
    * 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));
-        }
+      for (const entry of await fs.readdir(this.cacheDir)) {
+        await fs.rm(path.join(this.cacheDir, entry), { recursive: true, force: true });
       }
-      
+
       console.log('Schematron cache cleared');
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.warn(`Failed to clear cache: ${errorMessage}`);
     }
   }
-  
+
   /**
    * Get the appropriate Schematron for a format
    */
@@ -265,43 +354,3 @@ export class SchematronDownloader {
     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) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn(`Failed to download ${name}: ${errorMessage}`);
-    }
-  }
-  
-  console.log('ISO Schematron skeleton download complete');
-}

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

@@ -3,11 +3,11 @@
  */
 
 import { SchematronValidator, HybridValidator } from './schematron.validator.js';
+import { SchematronDownloader } from './schematron.downloader.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';
 
 /**
@@ -66,57 +66,34 @@ export class IntegratedValidator {
     
     await this.schematronValidator.loadSchematron(schematronPath, true);
     if (!this.schematronValidator.canValidate()) {
-      throw new Error(`Schematron file is not a precompiled Saxon-JS SEF resource: ${schematronPath}`);
+      throw new Error(`Schematron file could not be compiled: ${schematronPath}`);
     }
     this.schematronLoaded = true;
   }
   
   /**
-   * Get the path to the appropriate Schematron file
+   * Get the path to the appropriate Schematron file.
+   *
+   * The downloader records the entry document of every rule set in its index, so the
+   * file is looked up by name rather than guessed from a pattern; an include of the
+   * rule set must never be mistaken for an entry document.
    */
   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 sourceNames: Record<string, Record<string, string>> = {
+      EN16931: { UBL: 'EN16931-UBL', CII: 'EN16931-CII' },
+      PEPPOL: { UBL: 'PEPPOL-EN16931-UBL', CII: 'PEPPOL-EN16931-CII' },
+      XRECHNUNG: { UBL: 'XRechnung-UBL', CII: 'XRechnung-CII' }
     };
-    
-    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;
+
+    const sourceName = sourceNames[standard]?.[format];
+    if (!sourceName) return null;
+
+    return new SchematronDownloader().getCachedEntry(sourceName);
   }
-  
+
   /**
    * Validate an invoice using all available validators
    */
@@ -142,10 +119,7 @@ export class IntegratedValidator {
     if (xmlContent && this.schematronLoaded) {
       try {
         const schematronResults = await this.schematronValidator.validate(xmlContent, {
-          includeWarnings: !options.strictMode,
-          parameters: {
-            profile: options.profile
-          }
+          includeWarnings: !options.strictMode
         });
         results.push(...schematronResults);
       } catch (error) {