@aurabx/jmix-js 0.1.0

package/tests/JmixBuilder.test.ts

@@ -0,0 +1,170 @@
+import { JmixBuilder, Config } from '../src/index.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+describe('JmixBuilder', () => {
+  let builder: JmixBuilder;
+  const tempDir = './tmp/test';
+
+  beforeEach(() => {
+    builder = new JmixBuilder({ outputPath: tempDir });
+  });
+
+  afterEach(async () => {
+    // Clean up temp files
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe('constructor', () => {
+    it('should create a JmixBuilder instance', () => {
+      expect(builder).toBeInstanceOf(JmixBuilder);
+      expect(builder.getValidator()).toBeDefined();
+      expect(builder.getDicomProcessor()).toBeDefined();
+    });
+
+    it('should use custom options', () => {
+      const customBuilder = new JmixBuilder({
+        outputPath: './custom-tmp',
+        schemaValidatorOptions: {
+          schemaPath: './custom-schemas',
+          strictMode: false,
+        },
+      });
+      expect(customBuilder).toBeInstanceOf(JmixBuilder);
+    });
+  });
+
+
+  describe('loadConfig', () => {
+    it('should load configuration from sample file', async () => {
+      const sampleConfigPath = path.resolve('./samples/sample_config.json');
+
+      // Check if sample config exists
+      try {
+        await fs.access(sampleConfigPath);
+        const config = await JmixBuilder.loadConfig(sampleConfigPath);
+
+        expect(config.version).toBeDefined();
+        expect(config.sender).toBeDefined();
+        expect(config.patient).toBeDefined();
+      } catch {
+        console.warn('Sample config file not found, skipping test');
+      }
+    });
+
+    it('should throw error for invalid config path', async () => {
+      await expect(
+        JmixBuilder.loadConfig('./invalid/path.json')
+      ).rejects.toThrow('Failed to load configuration');
+    });
+  });
+
+  describe('buildFromDicom', () => {
+    it('should build envelope from empty directory with config fallback', async () => {
+      const config = await JmixBuilder.loadConfig(path.resolve('./samples/sample_config.json'));
+      const testDir = path.resolve('./samples/study_1');
+      
+      // Ensure directory exists (may be empty in some environments)
+      await fs.mkdir(testDir, { recursive: true });
+      
+      const envelope = await builder.buildFromDicom(testDir, config);
+      
+      expect(envelope.manifest).toBeDefined();
+      expect(envelope.metadata).toBeDefined();
+      expect(envelope.audit).toBeDefined();
+      
+      expect(envelope.manifest.jmix_version).toBe(config.version);
+      expect(envelope.manifest.sender.name).toBe(config.sender.name);
+      expect(envelope.manifest.patient.name).toBe(config.patient.name);
+      
+      expect(envelope.metadata.patient.name).toBe(config.patient.name);
+      expect(Array.isArray(envelope.metadata.dicom.modalities)).toBe(true);
+      
+      expect(Array.isArray(envelope.audit.audit)).toBe(true);
+      expect(envelope.audit.audit.length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should handle non-existent directory gracefully', async () => {
+      const config = await JmixBuilder.loadConfig(path.resolve('./samples/sample_config.json'));
+      
+      await expect(
+        builder.buildFromDicom('./non-existent-dir', config)
+      ).rejects.toThrow('Failed to build JMIX envelope');
+    });
+  });
+
+  describe('saveToFiles', () => {
+    it('should save envelope to JSON files', async () => {
+      const config = await JmixBuilder.loadConfig(path.resolve('./samples/sample_config.json'));
+      const testDir = path.resolve('./samples/study_1');
+      const outputDir = path.join(tempDir, 'output');
+      
+      // Ensure directory exists (may be empty in some environments)
+      await fs.mkdir(testDir, { recursive: true });
+      
+      const envelope = await builder.buildFromDicom(testDir, config);
+      await builder.saveToFiles(envelope, outputDir);
+
+      // Check that files were created
+      const manifestPath = path.join(outputDir, 'manifest.json');
+      const metadataPath = path.join(outputDir, 'metadata.json');
+      const auditPath = path.join(outputDir, 'audit.json');
+
+      await expect(fs.access(manifestPath)).resolves.not.toThrow();
+      await expect(fs.access(metadataPath)).resolves.not.toThrow();
+      await expect(fs.access(auditPath)).resolves.not.toThrow();
+
+      // Verify file contents are valid JSON
+      const manifestContent = await fs.readFile(manifestPath, 'utf-8');
+      const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+      const auditContent = await fs.readFile(auditPath, 'utf-8');
+
+      expect(() => JSON.parse(manifestContent)).not.toThrow();
+      expect(() => JSON.parse(metadataContent)).not.toThrow();
+      expect(() => JSON.parse(auditContent)).not.toThrow();
+    });
+
+    it('should use default output path when none specified', async () => {
+      const config = await JmixBuilder.loadConfig(path.resolve('./samples/sample_config.json'));
+      const testDir = path.resolve('./samples/study_1');
+      
+      // Ensure directory exists (may be empty in some environments)
+      await fs.mkdir(testDir, { recursive: true });
+      
+      const envelope = await builder.buildFromDicom(testDir, config);
+      await builder.saveToFiles(envelope); // No output path specified
+
+      // Check that files were created in default path
+      const defaultOutputPath = tempDir; // From constructor
+      const manifestPath = path.join(defaultOutputPath, 'manifest.json');
+
+      await expect(fs.access(manifestPath)).resolves.not.toThrow();
+    });
+  });
+
+  describe('integration', () => {
+    it('should create a complete JMIX envelope with realistic data', async () => {
+      const config: Config = await JmixBuilder.loadConfig(path.resolve('./samples/sample_config.json'));
+
+      const testDir = path.resolve('./samples/study_1');
+      await fs.mkdir(testDir, { recursive: true });
+
+      const envelope = await builder.buildFromDicom(testDir, config);
+
+      // Verify envelope structure
+      expect(envelope.manifest.custom_tags).toEqual(['radiology', 'urgent']);
+      expect(envelope.manifest.consent?.status).toBe('granted');
+      expect(envelope.manifest.patient.identifiers).toHaveLength(1);
+
+      expect(envelope.metadata.patient.sex).toBe('M');
+      expect(typeof envelope.metadata.dicom.patient_name).toBe('string');
+      
+      expect(Array.isArray(envelope.audit.audit)).toBe(true);
+      expect(envelope.audit.audit.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+});

package/tests/SchemaValidator.test.ts

@@ -0,0 +1,196 @@
+import { SchemaValidator, ValidationError } from '../src/index.js';
+import * as path from 'path';
+
+describe('SchemaValidator', () => {
+  let validator: SchemaValidator;
+
+  beforeEach(() => {
+    validator = new SchemaValidator();
+  });
+
+  describe('constructor', () => {
+    it('should create a validator with default options', () => {
+      expect(validator).toBeInstanceOf(SchemaValidator);
+    });
+
+    it('should use custom schema path from options', () => {
+      const customValidator = new SchemaValidator({
+        schemaPath: './custom-schemas',
+        strictMode: false,
+      });
+      expect(customValidator).toBeInstanceOf(SchemaValidator);
+    });
+
+    it('should use schema path from environment variable', () => {
+      const originalEnv = process.env.JMIX_SCHEMA_PATH;
+      process.env.JMIX_SCHEMA_PATH = './env-schemas';
+
+      const envValidator = new SchemaValidator();
+      expect(envValidator).toBeInstanceOf(SchemaValidator);
+
+      // Restore original environment
+      if (originalEnv) {
+        process.env.JMIX_SCHEMA_PATH = originalEnv;
+      } else {
+        delete process.env.JMIX_SCHEMA_PATH;
+      }
+    });
+  });
+
+  describe('isSchemaAvailable', () => {
+    it('should check if schema files are available', async () => {
+      const available = await validator.isSchemaAvailable();
+      // This may be false if ../jmix/schemas doesn't exist, which is fine
+      expect(typeof available).toBe('boolean');
+    });
+
+    it('should check specific schema availability', async () => {
+      const manifestAvailable = await validator.isSchemaAvailable('manifest');
+      expect(typeof manifestAvailable).toBe('boolean');
+    });
+  });
+
+  describe('validation methods', () => {
+    const sampleManifest = {
+      jmix_version: '1.0',
+      envelope_id: '12345678-1234-5678-9012-123456789012',
+      created_at: new Date().toISOString(),
+      sender: {
+        name: 'Test Sender',
+        id: 'org:test.sender',
+        contact: 'test@sender.org',
+      },
+      receivers: [
+        {
+          name: 'Test Receiver',
+          id: 'org:test.receiver',
+          contact: 'test@receiver.org',
+        },
+      ],
+      patient: {
+        name: 'Test Patient',
+        id: 'PAT001',
+      },
+      security: {
+        classification: 'confidential',
+      },
+    };
+
+    const sampleMetadata = {
+      patient: {
+        name: 'Test Patient',
+        id: 'PAT001',
+      },
+      study: {
+        description: 'Test Study',
+      },
+      dicom: {
+        modalities: ['CT'],
+        series_count: 1,
+        instance_count: 5,
+      },
+    };
+
+    const sampleAudit = {
+      audit: [
+        {
+          event: 'envelope_created',
+          by: { id: 'org:test.sender', name: 'Test Sender' },
+          to: { id: 'org:test.receiver', name: 'Test Receiver' },
+          timestamp: new Date().toISOString(),
+        },
+      ],
+    };
+
+    it('should validate manifest without throwing when schemas not available', async () => {
+      // This should not throw even if schemas are missing
+      await expect(
+        validator.validateManifest(sampleManifest)
+      ).resolves.not.toThrow();
+    });
+
+    it('should validate metadata without throwing when schemas not available', async () => {
+      await expect(
+        validator.validateMetadata(sampleMetadata)
+      ).resolves.not.toThrow();
+    });
+
+    it('should validate audit without throwing when schemas not available', async () => {
+      await expect(validator.validateAudit(sampleAudit)).resolves.not.toThrow();
+    });
+
+    it('should validate complete envelope', async () => {
+      const envelope = {
+        manifest: sampleManifest,
+        metadata: sampleMetadata,
+        audit: sampleAudit,
+      };
+
+      await expect(validator.validateEnvelope(envelope)).resolves.not.toThrow();
+    });
+
+    it('should handle invalid data gracefully when schemas not available', async () => {
+      const invalidManifest = {
+        invalid: 'data',
+      };
+
+      // Should not throw when schemas are not available
+      await expect(
+        validator.validateManifest(invalidManifest)
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle ValidationError properly', () => {
+      const error = new ValidationError('Test validation error', [
+        'Field is required',
+      ]);
+
+      expect(error).toBeInstanceOf(ValidationError);
+      expect(error.message).toBe('Test validation error');
+      expect(error.errors).toEqual(['Field is required']);
+      expect(error.name).toBe('ValidationError');
+    });
+
+    it('should create ValidationError with default empty errors', () => {
+      const error = new ValidationError('Test error');
+
+      expect(error.errors).toEqual([]);
+    });
+  });
+
+  describe('with custom schema path', () => {
+    it('should use custom schema path', () => {
+      const customPath = path.resolve('./custom-schemas');
+      const customValidator = new SchemaValidator({
+        schemaPath: customPath,
+      });
+
+      expect(customValidator).toBeInstanceOf(SchemaValidator);
+    });
+
+    it('should handle non-existent custom schema path gracefully', async () => {
+      const customValidator = new SchemaValidator({
+        schemaPath: './non-existent-schemas',
+      });
+
+      const sampleData = { test: 'data' };
+
+      // Should not throw when schemas don't exist
+      await expect(
+        customValidator.validateManifest(sampleData)
+      ).resolves.not.toThrow();
+    });
+  });
+
+  describe('strict mode', () => {
+    it('should work in non-strict mode', () => {
+      const nonStrictValidator = new SchemaValidator({
+        strictMode: false,
+      });
+
+      expect(nonStrictValidator).toBeInstanceOf(SchemaValidator);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "lib": ["ES2022"],
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "tests", "__tests__", "**/*.test.ts"]
+}