@fin.cx/einvoice 5.1.4 → 5.2.1

package/ts/formats/validation/en16931.validator.ts

@@ -27,11 +27,11 @@ export class EN16931Validator {
   ];
 
   /**
-   * Validates that an invoice object contains all mandatory EN16931 fields
+   * Collects mandatory EN16931 field errors without throwing.
    * @param invoice The invoice object to validate
-   * @throws Error if mandatory fields are missing
+   * @returns List of validation error messages
    */
-  public static validateMandatoryFields(invoice: any): void {
+  public static collectMandatoryFieldErrors(invoice: any): string[] {
     const errors: string[] = [];
 
     // BR-01: Invoice number is mandatory
@@ -49,7 +49,7 @@ export class EN16931Validator {
       errors.push('BR-06: Seller name is mandatory');
     }
 
-    // BR-07: Buyer name is mandatory  
+    // BR-07: Buyer name is mandatory
     if (!invoice.to?.name) {
       errors.push('BR-07: Buyer name is mandatory');
     }
@@ -67,11 +67,10 @@ export class EN16931Validator {
     // BR-05: Invoice currency code is mandatory
     if (!invoice.currency) {
       errors.push('BR-05: Invoice currency code is mandatory');
-    } else {
-      // Validate currency format
-      if (!this.VALID_CURRENCIES.includes(invoice.currency.toUpperCase())) {
-        errors.push(`Invalid currency code: ${invoice.currency}. Must be a valid ISO 4217 currency code`);
-      }
+    } else if (!this.VALID_CURRENCIES.includes(invoice.currency.toUpperCase())) {
+      errors.push(
+        `BR-05: Invalid currency code: ${invoice.currency}. Must be a valid ISO 4217 currency code`
+      );
     }
 
     // BR-08: Seller postal address is mandatory
@@ -84,6 +83,17 @@ export class EN16931Validator {
       errors.push('BR-10: Buyer postal address (city, postal code, country) is mandatory');
     }
 
+    return errors;
+  }
+
+  /**
+   * Validates that an invoice object contains all mandatory EN16931 fields
+   * @param invoice The invoice object to validate
+   * @throws Error if mandatory fields are missing
+   */
+  public static validateMandatoryFields(invoice: any): void {
+    const errors = this.collectMandatoryFieldErrors(invoice);
+
     if (errors.length > 0) {
       throw new Error(`EN16931 validation failed:\n${errors.join('\n')}`);
     }
@@ -132,4 +142,4 @@ export class EN16931Validator {
       throw new Error(`EN16931 XML validation failed:\n${errors.join('\n')}`);
     }
   }
-}
+}

package/ts/formats/validation/integrated.validator.ts

@@ -60,7 +60,8 @@ export class MainValidator {
       this.schematronEnabled = true;
       console.log(`Schematron validation enabled for ${standard} ${format}`);
     } catch (error) {
-      console.warn(`Failed to initialize Schematron: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Failed to initialize Schematron: ${errorMessage}`);
     }
   }
   
@@ -121,7 +122,8 @@ export class MainValidator {
         );
         results.push(...schematronResults);
       } catch (error) {
-        console.warn(`Schematron validation error: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Schematron validation error: ${errorMessage}`);
       }
     }
     
@@ -402,4 +404,4 @@ export async function createValidator(
 }
 
 // Export for convenience
-export type { ValidationReport, ValidationResult, ValidationOptions } from './validation.types.js';
+export type { ValidationReport, ValidationResult, ValidationOptions } from './validation.types.js';

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

@@ -79,7 +79,6 @@ export const SCHEMATRON_SOURCES: Record<string, SchematronSource[]> = {
  */
 export class SchematronDownloader {
   private cacheDir: string;
-  private smartfile: any;
   
   constructor(cacheDir: string = 'assets_downloaded/schematron') {
     this.cacheDir = cacheDir;
@@ -90,7 +89,6 @@ export class SchematronDownloader {
    */
   public async initialize(): Promise<void> {
     // Ensure cache directory exists
-    this.smartfile = await import('@push.rocks/smartfile');
     await fs.mkdir(this.cacheDir, { recursive: true });
   }
   
@@ -139,7 +137,8 @@ export class SchematronDownloader {
       console.log(`Successfully downloaded: ${fileName}`);
       return filePath;
     } catch (error) {
-      throw new Error(`Failed to download ${source.name}: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to download ${source.name}: ${errorMessage}`);
     }
   }
   
@@ -160,7 +159,8 @@ export class SchematronDownloader {
         const path = await this.download(source);
         paths.push(path);
       } catch (error) {
-        console.warn(`Failed to download ${source.name}: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to download ${source.name}: ${errorMessage}`);
       }
     }
     
@@ -209,7 +209,8 @@ export class SchematronDownloader {
         }
       }
     } catch (error) {
-      console.warn(`Failed to list cached files: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Failed to list cached files: ${errorMessage}`);
     }
     
     return files;
@@ -230,7 +231,8 @@ export class SchematronDownloader {
       
       console.log('Schematron cache cleared');
     } catch (error) {
-      console.warn(`Failed to clear cache: ${error.message}`);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Failed to clear cache: ${errorMessage}`);
     }
   }
   
@@ -296,9 +298,10 @@ export async function downloadISOSkeletons(targetDir: string = 'assets_downloade
       
       console.log(`Downloaded: ${name}`);
     } catch (error) {
-      console.warn(`Failed to download ${name}: ${error.message}`);
+      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

@@ -61,10 +61,13 @@ export class IntegratedValidator {
     try {
       await fs.access(schematronPath);
     } catch {
-      throw new Error(`Schematron file not found: ${schematronPath}. Run 'npm run download-schematron' first.`);
+      throw new Error(`Schematron file not found: ${schematronPath}. Run 'pnpm run download-schematron' first.`);
     }
     
     await this.schematronValidator.loadSchematron(schematronPath, true);
+    if (!this.schematronValidator.canValidate()) {
+      throw new Error(`Schematron file is not a precompiled Saxon-JS SEF resource: ${schematronPath}`);
+    }
     this.schematronLoaded = true;
   }
   
@@ -146,7 +149,8 @@ export class IntegratedValidator {
         });
         results.push(...schematronResults);
       } catch (error) {
-        console.warn(`Schematron validation failed: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Schematron validation failed: ${errorMessage}`);
       }
     }
     
@@ -224,7 +228,8 @@ export class IntegratedValidator {
       try {
         await this.loadSchematron('EN16931', format);
       } catch (error) {
-        console.warn(`Could not load Schematron: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Could not load Schematron: ${errorMessage}`);
       }
     }
     
@@ -278,8 +283,9 @@ export async function createStandardValidator(
   try {
     await validator.loadSchematron(standard, format);
   } catch (error) {
-    console.warn(`Schematron not available for ${standard} ${format}: ${error.message}`);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`Schematron not available for ${standard} ${format}: ${errorMessage}`);
   }
   
   return validator;
-}
+}

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

@@ -1,6 +1,6 @@
 import * as plugins from '../../plugins.js';
-import * as SaxonJS from 'saxon-js';
 import type { ValidationResult } from './validation.types.js';
+import { loadSaxonJS, type ISaxonJSTransformOptions, type ISaxonJSTransformResult } from '../../vendor/saxonjs.js';
 
 /**
  * Schematron validation options
@@ -12,14 +12,17 @@ export interface SchematronOptions {
   maxErrors?: number; // Maximum errors before stopping
 }
 
+type TSchematronSourceKind = 'none' | 'schematron' | 'sef';
+
 /**
  * Schematron validation engine using Saxon-JS
  * Provides official standards validation through Schematron rules
  */
 export class SchematronValidator {
-  private compiledStylesheet: any;
   private schematronRules: string;
-  private isCompiled: boolean = false;
+  private sourceKind: TSchematronSourceKind = 'none';
+  private stylesheetFileName?: string;
+  private stylesheetInternal?: unknown;
   
   constructor(schematronRules?: string) {
     this.schematronRules = schematronRules || '';
@@ -29,43 +32,25 @@ export class SchematronValidator {
    * Load Schematron rules from file or string
    */
   public async loadSchematron(source: string, isFilePath: boolean = true): Promise<void> {
+    let sourceContent: string;
+
     if (isFilePath) {
-      // Load from file
-      const smartfile = await import('@push.rocks/smartfile');
-      this.schematronRules = await smartfile.SmartFile.fromFilePath(source).then(f => f.contentBuffer.toString());
+      sourceContent = await plugins.fs.readFile(source, 'utf-8');
     } else {
-      // Use provided string
-      this.schematronRules = source;
+      sourceContent = source;
     }
-    
-    // Reset compilation state
-    this.isCompiled = false;
-  }
-  
-  /**
-   * Compile Schematron to XSLT using ISO Schematron skeleton
-   */
-  private async compileSchematron(): Promise<void> {
-    if (this.isCompiled) return;
-    
-    // The Schematron to XSLT transformation requires the ISO Schematron skeleton
-    // For now, we'll use a simplified approach with direct XSLT generation
-    // In production, we would use the official ISO Schematron skeleton XSLTs
-    
-    try {
-      // Convert Schematron to XSLT
-      // This is a simplified version - in production we'd use the full ISO skeleton
-      const xslt = this.generateXSLTFromSchematron(this.schematronRules);
-      
-      // Compile the XSLT with Saxon-JS
-      this.compiledStylesheet = await SaxonJS.compile({
-        stylesheetText: xslt,
-        warnings: 'silent'
-      });
-      
-      this.isCompiled = true;
-    } catch (error) {
-      throw new Error(`Failed to compile Schematron: ${error.message}`);
+
+    this.schematronRules = sourceContent;
+    this.sourceKind = this.detectSourceKind(source, sourceContent, isFilePath);
+    this.stylesheetFileName = undefined;
+    this.stylesheetInternal = undefined;
+
+    if (this.sourceKind === 'sef') {
+      if (isFilePath) {
+        this.stylesheetFileName = source;
+      } else {
+        this.stylesheetInternal = JSON.parse(sourceContent);
+      }
     }
   }
   
@@ -80,19 +65,28 @@ export class SchematronValidator {
       throw new Error('No Schematron rules loaded');
     }
     
-    // Ensure Schematron is compiled
-    await this.compileSchematron();
-    
     const results: ValidationResult[] = [];
+
+    if (!this.canValidate()) {
+      return [this.createUnavailableResult()];
+    }
     
     try {
-      // Transform the XML with the compiled Schematron XSLT
-      const transformResult = await SaxonJS.transform({
-        stylesheetInternal: this.compiledStylesheet,
+      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));
@@ -108,11 +102,12 @@ export class SchematronValidator {
       
       return results;
     } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
       results.push({
         ruleId: 'SCHEMATRON-ERROR',
         source: 'SCHEMATRON',
         severity: 'error',
-        message: `Schematron validation failed: ${error.message}`,
+        message: `Schematron validation failed: ${errorMessage}`,
         btReference: undefined,
         bgReference: undefined
       });
@@ -190,43 +185,46 @@ export class SchematronValidator {
     };
   }
   
-  /**
-   * Generate simplified XSLT from Schematron
-   * This is a placeholder - in production, use ISO Schematron skeleton
-   */
-  private generateXSLTFromSchematron(schematron: string): string {
-    // This is a simplified transformation
-    // In production, we would use the official ISO Schematron skeleton XSLTs
-    // (iso_schematron_skeleton.xsl, iso_svrl_for_xslt2.xsl, etc.)
-    
-    // For now, return a basic XSLT that creates SVRL output
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet version="3.0" 
-    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-    xmlns:svrl="http://purl.oclc.org/dsdl/svrl">
-    
-  <xsl:output method="xml" indent="yes"/>
-  
-  <xsl:template match="/">
-    <svrl:schematron-output>
-      <!-- This is a placeholder transformation -->
-      <!-- Real implementation would process Schematron patterns and rules -->
-      <svrl:active-pattern>
-        <xsl:attribute name="document">
-          <xsl:value-of select="base-uri(/)"/>
-        </xsl:attribute>
-      </svrl:active-pattern>
-    </svrl:schematron-output>
-  </xsl:template>
-</xsl:stylesheet>`;
-  }
-  
   /**
    * Check if validator has rules loaded
    */
   public hasRules(): boolean {
     return !!this.schematronRules;
   }
+
+  /**
+   * Check if loaded rules can be executed by Saxon-JS.
+   */
+  public canValidate(): boolean {
+    return this.sourceKind === 'sef' && Boolean(this.stylesheetFileName || this.stylesheetInternal);
+  }
+
+  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 {
+    return {
+      ruleId: 'SCHEMATRON-UNCOMPILED',
+      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.'
+    };
+  }
   
   /**
    * Get list of available phases from Schematron
@@ -323,7 +321,8 @@ export class HybridValidator {
       try {
         results.push(...validator.validate(xmlContent));
       } catch (error) {
-        console.warn(`TS validator failed: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`TS validator failed: ${errorMessage}`);
       }
     }
     
@@ -333,7 +332,8 @@ export class HybridValidator {
         const schematronResults = await this.schematronValidator.validate(xmlContent, options);
         results.push(...schematronResults);
       } catch (error) {
-        console.warn(`Schematron validation failed: ${error.message}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.warn(`Schematron validation failed: ${errorMessage}`);
       }
     }
     
@@ -345,4 +345,4 @@ export class HybridValidator {
       return true;
     });
   }
-}
+}

package/ts/formats/validation/schematron.worker.ts

@@ -1,8 +1,11 @@
 import { Worker } from 'worker_threads';
-import * as path from 'path';
 import type { ValidationResult } from './validation.types.js';
 import type { SchematronOptions } from './schematron.validator.js';
 
+export interface ISchematronWorkerPoolInitializeOptions {
+  isFilePath?: boolean;
+}
+
 /**
  * Worker pool for Schematron validation
  * Provides non-blocking validation in worker threads
@@ -17,7 +20,8 @@ export class SchematronWorkerPool {
     reject: (error: Error) => void;
   }> = [];
   private maxWorkers: number;
-  private schematronRules: string = '';
+  private stylesheetFileName?: string;
+  private stylesheetInternal?: unknown;
   
   constructor(maxWorkers: number = 4) {
     this.maxWorkers = maxWorkers;
@@ -26,48 +30,81 @@ export class SchematronWorkerPool {
   /**
    * Initialize worker pool
    */
-  public async initialize(schematronRules: string): Promise<void> {
-    this.schematronRules = schematronRules;
+  public async initialize(
+    stylesheetSource: string,
+    options: ISchematronWorkerPoolInitializeOptions = {}
+  ): Promise<void> {
+    this.loadStylesheet(stylesheetSource, options);
     
     // Create workers
     for (let i = 0; i < this.maxWorkers; i++) {
       await this.createWorker();
     }
   }
+
+  private loadStylesheet(
+    stylesheetSource: string,
+    options: ISchematronWorkerPoolInitializeOptions
+  ): void {
+    const source = stylesheetSource.trim();
+    const isFilePath = options.isFilePath ?? /\.sef\.json$/i.test(stylesheetSource);
+
+    this.stylesheetFileName = undefined;
+    this.stylesheetInternal = undefined;
+
+    if (isFilePath) {
+      if (!/\.sef\.json$/i.test(stylesheetSource)) {
+        throw new Error('Schematron worker validation requires a precompiled Saxon-JS SEF JSON stylesheet file.');
+      }
+      this.stylesheetFileName = stylesheetSource;
+      return;
+    }
+
+    if (!source.startsWith('{')) {
+      throw new Error('Schematron worker validation requires a precompiled Saxon-JS SEF JSON stylesheet. Raw .sch files are not executed.');
+    }
+
+    this.stylesheetInternal = JSON.parse(source);
+  }
   
   /**
    * Create a new worker
    */
   private async createWorker(): Promise<void> {
-    const workerPath = path.join(import.meta.url, 'schematron.worker.impl.js');
-    
     const worker = new Worker(`
       const { parentPort } = require('worker_threads');
       const SaxonJS = require('saxon-js');
       
-      let compiledStylesheet = null;
+      let stylesheetFileName = null;
+      let stylesheetInternal = null;
       
       parentPort.on('message', async (msg) => {
         try {
           if (msg.type === 'init') {
-            // Compile Schematron to XSLT
-            compiledStylesheet = await SaxonJS.compile({
-              stylesheetText: msg.xslt,
-              warnings: 'silent'
-            });
+            stylesheetFileName = msg.stylesheetFileName || null;
+            stylesheetInternal = msg.stylesheetInternal || null;
+            if (!stylesheetFileName && !stylesheetInternal) {
+              throw new Error('Worker not initialized with a SEF stylesheet');
+            }
             parentPort.postMessage({ type: 'ready' });
           } else if (msg.type === 'validate') {
-            if (!compiledStylesheet) {
+            if (!stylesheetFileName && !stylesheetInternal) {
               throw new Error('Worker not initialized');
             }
-            
-            // Transform XML with compiled Schematron
-            const result = await SaxonJS.transform({
-              stylesheetInternal: compiledStylesheet,
+
+            const transformOptions = {
               sourceText: msg.xmlContent,
               destination: 'serialized',
               stylesheetParams: msg.options.parameters || {}
-            });
+            };
+
+            if (stylesheetFileName) {
+              transformOptions.stylesheetFileName = stylesheetFileName;
+            } else {
+              transformOptions.stylesheetInternal = stylesheetInternal;
+            }
+
+            const result = await SaxonJS.transform(transformOptions, 'async');
             
             parentPort.postMessage({
               type: 'result',
@@ -83,7 +120,7 @@ export class SchematronWorkerPool {
       });
     `, { eval: true });
     
-    // Initialize worker with Schematron rules
+    // Initialize worker with a precompiled SEF stylesheet.
     await new Promise<void>((resolve, reject) => {
       worker.once('message', (msg) => {
         if (msg.type === 'ready') {
@@ -96,7 +133,8 @@ export class SchematronWorkerPool {
       // Send initialization message
       worker.postMessage({
         type: 'init',
-        xslt: this.generateXSLTFromSchematron(this.schematronRules)
+        stylesheetFileName: this.stylesheetFileName,
+        stylesheetInternal: this.stylesheetInternal
       });
     });
     
@@ -174,26 +212,6 @@ export class SchematronWorkerPool {
     return results;
   }
   
-  /**
-   * Generate XSLT from Schematron (simplified)
-   */
-  private generateXSLTFromSchematron(schematron: string): string {
-    // Simplified - would use ISO Schematron skeleton in production
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<xsl:stylesheet version="3.0" 
-    xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
-    xmlns:svrl="http://purl.oclc.org/dsdl/svrl">
-    
-  <xsl:output method="xml" indent="yes"/>
-  
-  <xsl:template match="/">
-    <svrl:schematron-output>
-      <svrl:active-pattern document="{base-uri(/)}"/>
-    </svrl:schematron-output>
-  </xsl:template>
-</xsl:stylesheet>`;
-  }
-  
   /**
    * Terminate all workers
    */
@@ -218,4 +236,4 @@ export class SchematronWorkerPool {
       queuedTasks: this.taskQueue.length
     };
   }
-}
+}

package/ts/index.ts

@@ -144,11 +144,12 @@ export function validateXml(
     const validator = ValidatorFactory.createValidator(xml);
     return validator.validate(level);
   } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
     return {
       valid: false,
       errors: [{
         code: 'VAL-ERROR',
-        message: `Validation error: ${error.message}`
+        message: `Validation error: ${errorMessage}`
       }],
       level
     };

package/ts/interfaces/common.ts

@@ -1,5 +1,3 @@
-import { business, finance } from '../plugins.js';
-
 /**
  * Supported electronic invoice formats
  */
@@ -88,4 +86,4 @@ export type { TCreditNote } from '@tsclass/tsclass/dist_ts/finance/index.js';
 export type { TDebitNote } from '@tsclass/tsclass/dist_ts/finance/index.js';
 export type { TContact } from '@tsclass/tsclass/dist_ts/business/index.js';
 export type { TLetterEnvelope } from '@tsclass/tsclass/dist_ts/business/index.js';
-export type { TDocumentEnvelope } from '@tsclass/tsclass/dist_ts/business/index.js';
+export type { TDocumentEnvelope } from '@tsclass/tsclass/dist_ts/business/index.js';