@fin.cx/einvoice 6.2.0 → 7.0.1

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

@@ -1,11 +1,69 @@
 import { Worker } from 'worker_threads';
+import { promises as fs } from 'fs';
 import type { ValidationResult } from './validation.types.js';
-import type { SchematronOptions } from './schematron.validator.js';
+import {
+  applySchematronOptions,
+  schematronReportToValidationResults,
+  type SchematronOptions,
+} from './schematron.validator.js';
 
 export interface ISchematronWorkerPoolInitializeOptions {
   isFilePath?: boolean;
 }
 
+/**
+ * The worker body. It compiles the schema once and then answers validation
+ * messages with the report, which the pool maps exactly like the in-process
+ * validator does.
+ *
+ * The engine is imported from the URL the pool resolves, because an eval'd worker
+ * resolves a bare specifier against the working directory rather than this package.
+ */
+const WORKER_SOURCE = `
+  const { parentPort } = require('worker_threads');
+  const { readFileSync } = require('fs');
+  const { dirname, resolve } = require('path');
+
+  let source = null;
+  const schemasByPhase = new Map();
+
+  const compile = async (phase) => {
+    const key = phase || '';
+    if (!schemasByPhase.has(key)) {
+      const { Schematron } = await import(source.engineUrl);
+      schemasByPhase.set(key, Schematron.fromString(source.schematronSource, {
+        phase: phase || undefined,
+        baseUri: source.baseUri || undefined,
+        resolveInclude: (href, base) =>
+          readFileSync(resolve(dirname(base || source.baseUri || '.'), href), 'utf-8'),
+      }));
+    }
+    return schemasByPhase.get(key);
+  };
+
+  parentPort.on('message', async (msg) => {
+    try {
+      if (msg.type === 'init') {
+        source = {
+          schematronSource: msg.schematronSource,
+          baseUri: msg.baseUri,
+          engineUrl: msg.engineUrl,
+        };
+        await compile(undefined);
+        parentPort.postMessage({ type: 'ready' });
+      } else if (msg.type === 'validate') {
+        if (!source) {
+          throw new Error('Worker not initialized');
+        }
+        const schema = await compile(msg.options.phase);
+        parentPort.postMessage({ type: 'result', report: schema.validate(msg.xmlContent) });
+      }
+    } catch (error) {
+      parentPort.postMessage({ type: 'error', error: error.message });
+    }
+  });
+`;
+
 /**
  * Worker pool for Schematron validation
  * Provides non-blocking validation in worker threads
@@ -20,134 +78,125 @@ export class SchematronWorkerPool {
     reject: (error: Error) => void;
   }> = [];
   private maxWorkers: number;
-  private stylesheetFileName?: string;
-  private stylesheetInternal?: unknown;
-  
+  private schematronSource?: string;
+  private baseUri?: string;
+  /** the task each busy worker is holding, so a thread that dies fails its task */
+  private tasksByWorker = new Map<Worker, { reject: (error: Error) => void }>();
+
   constructor(maxWorkers: number = 4) {
     this.maxWorkers = maxWorkers;
   }
-  
+
   /**
    * Initialize worker pool
    */
   public async initialize(
-    stylesheetSource: string,
-    options: ISchematronWorkerPoolInitializeOptions = {}
+    schematronSource: string,
+    options: ISchematronWorkerPoolInitializeOptions = {},
   ): Promise<void> {
-    this.loadStylesheet(stylesheetSource, options);
-    
-    // Create workers
-    for (let i = 0; i < this.maxWorkers; i++) {
-      await this.createWorker();
+    await this.loadSchematron(schematronSource, options);
+
+    try {
+      // Create workers
+      for (let i = 0; i < this.maxWorkers; i++) {
+        await this.createWorker();
+      }
+    } catch (error) {
+      // a pool that did not come up completely must not leave threads behind
+      await this.terminate();
+      throw error;
     }
   }
 
-  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;
+  private async loadSchematron(
+    schematronSource: string,
+    options: ISchematronWorkerPoolInitializeOptions,
+  ): Promise<void> {
+    const isFilePath = options.isFilePath ?? /\.sch$/i.test(schematronSource);
 
     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;
+      this.schematronSource = await fs.readFile(schematronSource, 'utf-8');
+      this.baseUri = schematronSource;
       return;
     }
 
-    if (!source.startsWith('{')) {
-      throw new Error('Schematron worker validation requires a precompiled Saxon-JS SEF JSON stylesheet. Raw .sch files are not executed.');
+    if (schematronSource.trim().startsWith('{')) {
+      throw new Error(
+        'Schematron worker validation takes a Schematron schema, not a compiled XSLT stylesheet (SEF).',
+      );
     }
 
-    this.stylesheetInternal = JSON.parse(source);
+    this.schematronSource = schematronSource;
+    this.baseUri = undefined;
   }
-  
+
   /**
    * Create a new worker
    */
   private async createWorker(): Promise<void> {
-    const worker = new Worker(`
-      const { parentPort } = require('worker_threads');
-      const SaxonJS = require('saxon-js');
-      
-      let stylesheetFileName = null;
-      let stylesheetInternal = null;
-      
-      parentPort.on('message', async (msg) => {
-        try {
-          if (msg.type === 'init') {
-            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 (!stylesheetFileName && !stylesheetInternal) {
-              throw new Error('Worker not initialized');
-            }
-
-            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',
-              svrl: result.principalResult
-            });
+    const worker = new Worker(WORKER_SOURCE, { eval: true });
+
+    // Compile the schema inside the worker before it joins the pool.
+    try {
+      await new Promise<void>((resolve, reject) => {
+        worker.once('error', reject);
+        worker.once('exit', (code) =>
+          reject(new Error(`Schematron worker exited with code ${code} before it was ready`)),
+        );
+        worker.once('message', (msg) => {
+          if (msg.type === 'ready') {
+            resolve();
+          } else if (msg.type === 'error') {
+            reject(new Error(msg.error));
           }
-        } catch (error) {
-          parentPort.postMessage({
-            type: 'error',
-            error: error.message
-          });
-        }
-      });
-    `, { eval: true });
-    
-    // Initialize worker with a precompiled SEF stylesheet.
-    await new Promise<void>((resolve, reject) => {
-      worker.once('message', (msg) => {
-        if (msg.type === 'ready') {
-          resolve();
-        } else if (msg.type === 'error') {
-          reject(new Error(msg.error));
-        }
-      });
-      
-      // Send initialization message
-      worker.postMessage({
-        type: 'init',
-        stylesheetFileName: this.stylesheetFileName,
-        stylesheetInternal: this.stylesheetInternal
+        });
+
+        worker.postMessage({
+          type: 'init',
+          schematronSource: this.schematronSource,
+          baseUri: this.baseUri,
+          engineUrl: import.meta.resolve('@push.rocks/smartxml/schematron'),
+        });
       });
-    });
-    
+    } catch (error) {
+      await worker.terminate();
+      throw error;
+    }
+
+    worker.removeAllListeners('exit');
+    // a thread that dies later must not take its task down with it
+    worker.on('error', (error: unknown) =>
+      this.retireWorker(worker, error instanceof Error ? error : new Error(String(error))),
+    );
+    worker.on('exit', () =>
+      this.retireWorker(worker, new Error('Schematron worker exited unexpectedly')),
+    );
+
     this.workers.push(worker);
     this.availableWorkers.push(worker);
   }
-  
+
+  /**
+   * Drops a thread that died, failing the task it was holding so no caller waits
+   * for an answer that can never come.
+   */
+  private retireWorker(worker: Worker, error: Error): void {
+    this.workers = this.workers.filter((candidate) => candidate !== worker);
+    this.availableWorkers = this.availableWorkers.filter((candidate) => candidate !== worker);
+    const holder = this.tasksByWorker.get(worker);
+    if (holder) {
+      this.tasksByWorker.delete(worker);
+      holder.reject(error);
+    }
+    this.processTasks();
+  }
+
   /**
    * Validate XML using worker pool
    */
   public async validate(
     xmlContent: string,
-    options: SchematronOptions = {}
+    options: SchematronOptions = {},
   ): Promise<ValidationResult[]> {
     return new Promise((resolve, reject) => {
       // Add task to queue
@@ -155,7 +204,7 @@ export class SchematronWorkerPool {
       this.processTasks();
     });
   }
-  
+
   /**
    * Process queued validation tasks
    */
@@ -163,65 +212,72 @@ export class SchematronWorkerPool {
     while (this.taskQueue.length > 0 && this.availableWorkers.length > 0) {
       const task = this.taskQueue.shift()!;
       const worker = this.availableWorkers.shift()!;
-      
+
+      this.tasksByWorker.set(worker, task);
+
       // Set up one-time listeners
+      const finish = (settle: () => void) => {
+        this.tasksByWorker.delete(worker);
+        worker.removeListener('message', messageHandler);
+        settle();
+
+        // Return worker to pool
+        this.availableWorkers.push(worker);
+
+        // Process next task
+        this.processTasks();
+      };
+
       const messageHandler = (msg: any) => {
         if (msg.type === 'result') {
-          // Parse SVRL and return results
-          const results = this.parseSVRL(msg.svrl);
-          task.resolve(results);
-          
-          // Return worker to pool
-          this.availableWorkers.push(worker);
-          worker.removeListener('message', messageHandler);
-          
-          // Process next task
-          this.processTasks();
+          finish(() =>
+            task.resolve(
+              applySchematronOptions(schematronReportToValidationResults(msg.report), task.options),
+            ),
+          );
         } else if (msg.type === 'error') {
-          task.reject(new Error(msg.error));
-          
-          // Return worker to pool
-          this.availableWorkers.push(worker);
-          worker.removeListener('message', messageHandler);
-          
-          // Process next task
-          this.processTasks();
+          finish(() => task.reject(new Error(msg.error)));
         }
       };
-      
+
       worker.on('message', messageHandler);
-      
+
       // Send validation task
       worker.postMessage({
         type: 'validate',
         xmlContent: task.xmlContent,
-        options: task.options
+        options: task.options,
       });
     }
   }
-  
-  /**
-   * Parse SVRL output
-   */
-  private parseSVRL(svrlXml: string): ValidationResult[] {
-    const results: ValidationResult[] = [];
-    
-    // This would use the same parsing logic as SchematronValidator
-    // Simplified for brevity
-    
-    return results;
-  }
-  
+
   /**
    * Terminate all workers
    */
   public async terminate(): Promise<void> {
-    await Promise.all(this.workers.map(w => w.terminate()));
+    const workers = this.workers;
     this.workers = [];
     this.availableWorkers = [];
+
+    // nobody may keep waiting for a pool that is shutting down
+    for (const holder of this.tasksByWorker.values()) {
+      holder.reject(new Error('Schematron worker pool was terminated'));
+    }
+    this.tasksByWorker.clear();
+    for (const task of this.taskQueue) {
+      task.reject(new Error('Schematron worker pool was terminated'));
+    }
     this.taskQueue = [];
+
+    await Promise.all(
+      workers.map((worker) => {
+        worker.removeAllListeners('exit');
+        worker.removeAllListeners('error');
+        return worker.terminate();
+      }),
+    );
   }
-  
+
   /**
    * Get pool statistics
    */
@@ -233,7 +289,7 @@ export class SchematronWorkerPool {
     return {
       totalWorkers: this.workers.length,
       availableWorkers: this.availableWorkers.length,
-      queuedTasks: this.taskQueue.length
+      queuedTasks: this.taskQueue.length,
     };
   }
 }

package/ts/plugins.ts

@@ -10,9 +10,13 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 
 // XML-related imports
+import { readFileSync } from 'fs';
 import { DOMParser, XMLSerializer, xmldom } from './vendor/xmldom.js';
 import * as xpath from 'xpath';
 
+// Standards-related imports
+import * as smartxmlSchematron from '@push.rocks/smartxml/schematron';
+
 // Compression-related imports
 import { pako } from './vendor/pako.js';
 
@@ -27,10 +31,14 @@ export {
   crypto,
   
   // XML-related exports
+  readFileSync,
   DOMParser,
   XMLSerializer,
   xmldom,
   xpath,
+
+  // Standards-related exports
+  smartxmlSchematron,
   
   // Compression-related exports
   pako,

package/ts/vendor/modules.d.ts

@@ -11,22 +11,3 @@ declare module 'xmldom' {
 declare module 'pako' {
   export function inflate(input: Uint8Array | ArrayBuffer | string, options?: unknown): Uint8Array;
 }
-
-declare module 'saxon-js' {
-  export function compile(options: {
-    stylesheetText: string;
-    warnings?: string;
-    [key: string]: unknown;
-  }): Promise<unknown>;
-
-  export function transform(options: {
-    stylesheetInternal?: unknown;
-    sourceText: string;
-    destination?: string;
-    stylesheetParams?: Record<string, unknown>;
-    [key: string]: unknown;
-  }): Promise<{
-    principalResult: string;
-    [key: string]: unknown;
-  }>;
-}

package/dist_ts/vendor/saxonjs.d.ts

@@ -1,23 +0,0 @@
-export interface ISaxonJSCompileOptions {
-    stylesheetText: string;
-    warnings?: string;
-    [key: string]: unknown;
-}
-export interface ISaxonJSTransformOptions {
-    stylesheetInternal?: unknown;
-    stylesheetFileName?: string;
-    sourceText: string;
-    destination?: string;
-    stylesheetParams?: Record<string, unknown>;
-    [key: string]: unknown;
-}
-export interface ISaxonJSTransformResult {
-    principalResult: string;
-    [key: string]: unknown;
-}
-export interface ISaxonJSModule {
-    compile?: (options: ISaxonJSCompileOptions) => Promise<unknown>;
-    transform(options: ISaxonJSTransformOptions, executionMode?: 'async' | 'sync'): Promise<ISaxonJSTransformResult> | ISaxonJSTransformResult;
-    [key: string]: unknown;
-}
-export declare const loadSaxonJS: () => Promise<ISaxonJSModule>;

package/dist_ts/vendor/saxonjs.js

@@ -1,9 +0,0 @@
-let cachedSaxonJS;
-export const loadSaxonJS = async () => {
-    cachedSaxonJS ||= import('saxon-js').then((saxonJSRuntime) => {
-        const runtime = saxonJSRuntime.default ?? saxonJSRuntime;
-        return runtime;
-    });
-    return cachedSaxonJS;
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2F4b25qcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3ZlbmRvci9zYXhvbmpzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTBCQSxJQUFJLGFBQWtELENBQUM7QUFFdkQsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLEtBQUssSUFBNkIsRUFBRTtJQUM3RCxhQUFhLEtBQUssTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLGNBQWMsRUFBRSxFQUFFO1FBQzNELE1BQU0sT0FBTyxHQUFJLGNBQXNCLENBQUMsT0FBTyxJQUFJLGNBQWMsQ0FBQztRQUNsRSxPQUFPLE9BQXlCLENBQUM7SUFDbkMsQ0FBQyxDQUFDLENBQUM7SUFFSCxPQUFPLGFBQWEsQ0FBQztBQUN2QixDQUFDLENBQUMifQ==