@aurabx/jmix-js 0.1.0

package/src/dicom/DicomProcessor.ts

@@ -0,0 +1,262 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { DicomError, DicomMetadata, Config } from '../types/index.js';
+import daikon from 'daikon';
+
+const DICOM_MAGIC_OFFSET = 128;
+const DICOM_MAGIC_SIGNATURE = 'DICM';
+
+function toArrayBuffer(buf: Buffer): ArrayBuffer {
+  const ab = new ArrayBuffer(buf.byteLength);
+  const view = new Uint8Array(ab);
+  view.set(buf);
+  return ab;
+}
+
+export class DicomProcessor {
+  /**
+   * Process a DICOM directory and extract metadata
+   */
+  async processDicomFolder(
+    dicomPath: string,
+    config?: Config
+  ): Promise<DicomMetadata> {
+    try {
+      const dicomFiles = await this.findDicomFiles(dicomPath);
+
+      if (dicomFiles.length === 0) {
+        // Fallback to config data if no DICOM files found
+        return this.createMetadataFromConfig(config);
+      }
+
+      // Parse files with Daikon and group by series
+      const images: any[] = [];
+      const seriesMap: Map<string, any[]> = new Map();
+      const modalitiesSet: Set<string> = new Set();
+
+      for (const f of dicomFiles) {
+        try {
+          const buf = await fs.readFile(f);
+          const view = new DataView(toArrayBuffer(buf));
+          const image = daikon.Series.parseImage(view);
+          if (!image) continue;
+          images.push(image);
+
+          const seriesId = image.getSeriesId ? image.getSeriesId() : path.dirname(f);
+          const arr = seriesMap.get(seriesId) || [];
+          arr.push(image);
+          seriesMap.set(seriesId, arr);
+
+          // Try to read modality if available
+          try {
+            const modality = (image.getModality && image.getModality()) || this.readTag(image, 0x0008, 0x0060) || 'UNKNOWN';
+            if (modality) modalitiesSet.add(String(modality));
+          } catch {
+            // ignore modality errors
+          }
+        } catch {
+          // skip unreadable file
+        }
+      }
+
+      const series: DicomMetadata['series'] = [];
+      for (const [sid, imgs] of seriesMap.entries()) {
+        series.push({
+          series_uid: String(sid),
+          modality: 'UNKNOWN',
+          instance_count: imgs.length,
+        });
+      }
+
+      // Attempt to extract some study-level tags from the first image
+      let study_description: string | undefined = undefined;
+      let study_uid: string | undefined = undefined;
+      let study_date: string | undefined = undefined;
+      let patient_name: string | undefined = config?.patient.name;
+      let patient_id: string | undefined = config?.patient.id;
+      let patient_dob: string | undefined = config?.patient.dob;
+      let patient_sex: string | undefined = config?.patient.sex;
+
+      const first = images[0];
+      if (first) {
+        study_description = this.readTag(first, 0x0008, 0x1030) || 'Study';
+        study_uid = this.readTag(first, 0x0020, 0x000D) || this.generateStudyUID();
+        const sd = this.readTag(first, 0x0008, 0x0020);
+        study_date = sd && String(sd).length === 8 ? DicomProcessor.formatDicomDate(String(sd)) : new Date().toISOString().split('T')[0];
+        patient_name = this.readTag(first, 0x0010, 0x0010) || patient_name;
+        patient_id = this.readTag(first, 0x0010, 0x0020) || patient_id;
+        const dob = this.readTag(first, 0x0010, 0x0030);
+        patient_dob = dob && String(dob).length === 8 ? DicomProcessor.formatDicomDate(String(dob)) : patient_dob;
+        patient_sex = this.readTag(first, 0x0010, 0x0040) || patient_sex;
+      }
+
+      const metadata: DicomMetadata = {
+        patient_name,
+        patient_id,
+        patient_dob,
+        patient_sex,
+        study_description,
+        study_uid,
+        study_date,
+        modalities: Array.from(modalitiesSet.size ? modalitiesSet : new Set(['UNKNOWN'])),
+        series_count: seriesMap.size || 1,
+        instance_count: images.length,
+        series,
+      };
+
+      return metadata;
+    } catch (error) {
+      throw new DicomError(
+        `Failed to process DICOM folder: ${dicomPath}`,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+
+  /**
+   * Recursively find DICOM files in a directory
+   */
+  private async findDicomFiles(dirPath: string): Promise<string[]> {
+    const dicomFiles: string[] = [];
+
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+
+        if (entry.isDirectory()) {
+          // Recursively search subdirectories
+          const subDirFiles = await this.findDicomFiles(fullPath);
+          dicomFiles.push(...subDirFiles);
+        } else if (entry.isFile()) {
+          if (await this.isDicomFile(fullPath)) {
+            dicomFiles.push(fullPath);
+          }
+        }
+      }
+    } catch (error) {
+      throw new DicomError(
+        `Failed to read directory: ${dirPath}`,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+
+    return dicomFiles;
+  }
+
+  /**
+   * Check if a file is a DICOM file by checking the magic signature
+   */
+  private async isDicomFile(filePath: string): Promise<boolean> {
+    try {
+      // Check file extension first (quick check)
+      const ext = path.extname(filePath).toLowerCase();
+      if (['.dcm', '.dicom'].includes(ext)) {
+        return true;
+      }
+
+      // Check for DICM magic number at offset 128
+      const fileHandle = await fs.open(filePath, 'r');
+      const buffer = Buffer.alloc(4);
+      await fileHandle.read(buffer, 0, 4, DICOM_MAGIC_OFFSET);
+      await fileHandle.close();
+
+      return buffer.toString('ascii') === DICOM_MAGIC_SIGNATURE;
+    } catch {
+      // If we can't read the file, assume it's not a DICOM file
+      return false;
+    }
+  }
+
+  /**
+   * Create metadata from config when DICOM parsing fails or no files found
+   */
+  private createMetadataFromConfig(config?: Config): DicomMetadata {
+    return {
+      patient_name: config?.patient.name,
+      patient_id: config?.patient.id,
+      patient_dob: config?.patient.dob,
+      patient_sex: config?.patient.sex,
+      study_description: 'Study from configuration',
+      study_uid: this.generateStudyUID(),
+      study_date: new Date().toISOString().split('T')[0],
+      modalities: ['UNKNOWN'],
+      series_count: 1,
+      instance_count: 0,
+      series: [],
+    };
+  }
+
+  /**
+   * Generate a study UID (placeholder implementation)
+   */
+  private generateStudyUID(): string {
+    // Simple UID generation - in production would use proper DICOM UID format
+    const timestamp = Date.now();
+    const random = Math.floor(Math.random() * 10000);
+    return `1.2.3.${timestamp}.${random}`;
+  }
+
+  /**
+   * Estimate series count based on file naming patterns or directory structure
+   */
+  private estimateSeriesCount(files: string[]): number {
+    // Simple estimation based on directory structure
+    const directories = new Set<string>();
+
+    for (const file of files) {
+      directories.add(path.dirname(file));
+    }
+
+    return Math.max(1, directories.size);
+  }
+
+  /**
+   * Attempt to read a DICOM tag value using Daikon's API (best-effort)
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private readTag(image: any, group: number, element: number): string | undefined {
+    try {
+      if (image && image.getTag && typeof image.getTag === 'function') {
+        const tag = image.getTag(group, element);
+        if (tag && tag.value && tag.value.length) {
+          return String(tag.value[0]);
+        }
+      }
+    } catch {
+      // ignore
+    }
+    return undefined;
+  }
+
+  /**
+   * Format DICOM date to ISO format
+   */
+  static formatDicomDate(dicomDate: string): string {
+    if (!dicomDate || dicomDate.length !== 8) {
+      return new Date().toISOString().split('T')[0];
+    }
+
+    const year = dicomDate.substring(0, 4);
+    const month = dicomDate.substring(4, 6);
+    const day = dicomDate.substring(6, 8);
+
+    return `${year}-${month}-${day}`;
+  }
+
+  /**
+   * Format DICOM person name to readable format
+   */
+  static formatDicomPersonName(dicomName: string): string {
+    if (!dicomName) return '';
+
+    // DICOM names are in format: "Last^First^Middle^Prefix^Suffix"
+    const parts = dicomName.split('^');
+    const last = parts[0] || '';
+    const first = parts[1] || '';
+    const middle = parts[2] || '';
+
+    return [first, middle, last].filter(Boolean).join(' ').trim();
+  }
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+// JMIX TypeScript Library - Main Entry Point
+// JSON Medical Interchange format for secure medical data exchange
+
+export { JmixBuilder, type JmixBuilderOptions } from './JmixBuilder.js';
+export {
+  SchemaValidator,
+  type SchemaValidatorOptions,
+} from './validation/SchemaValidator.js';
+export { DicomProcessor } from './dicom/DicomProcessor.js';
+
+// Export all types
+export * from './types/index.js';
+
+// Re-export key types for convenience
+export type {
+  JmixEnvelope,
+  Config,
+  Manifest,
+  Metadata,
+  Audit,
+  Files,
+  DicomMetadata,
+  Patient,
+  ContactVariant,
+  Contact,
+  Security,
+  Consent,
+  Encryption,
+  SenderAssertion,
+} from './types/index.js';

package/src/types/daikon.d.ts

@@ -0,0 +1 @@
+declare module 'daikon';

package/src/types/index.ts

@@ -0,0 +1,201 @@
+// JMIX Core Types - TypeScript interfaces for JMIX envelope components
+
+export interface Contact {
+  system?: string;
+  value: string;
+  use_field?: string;
+}
+
+export interface ContactVariant {
+  name: string;
+  id: string;
+  contact: string | Contact;
+}
+
+export interface PatientIdentifier {
+  system: string;
+  value: string;
+  use_field?: string;
+}
+
+export interface Patient {
+  name: string;
+  id: string;
+  dob?: string;
+  sex?: 'M' | 'F' | 'O' | 'U';
+  identifiers?: PatientIdentifier[];
+}
+
+export interface Consent {
+  status: 'granted' | 'denied' | 'pending';
+  scope?: string[];
+  method?: string;
+}
+
+export interface Security {
+  classification: 'public' | 'internal' | 'confidential' | 'restricted';
+  // Optional SHA-256 digest of the payload/ directory, formatted as "sha256:<hex>"
+  payload_hash?: string;
+}
+
+export interface Encryption {
+  algorithm: 'AES-256-GCM';
+  ephemeral_public_key: string; // base64 encoded
+  iv: string; // base64 encoded
+  auth_tag: string; // base64 encoded
+}
+
+export interface SenderAssertion {
+  signing_key: {
+    alg: string;
+    public_key: string;
+    fingerprint: string;
+  };
+  key_reference?: string;
+  signed_fields: string[];
+  signature: string;
+  expires_at?: string;
+  directory_attestation?: {
+    provider: string;
+    attestation_signature: string;
+    attestation_timestamp: string;
+    attestation_public_key: string;
+  };
+}
+
+export interface Manifest {
+  jmix_version: string;
+  envelope_id: string;
+  created_at: string;
+  sender: ContactVariant & { assertion?: SenderAssertion };
+  requester?: ContactVariant & { assertion?: SenderAssertion };
+  receivers: ContactVariant[];
+  patient: Patient;
+  security: Security;
+  consent?: Consent;
+  custom_tags?: string[];
+  report?: {
+    file: string;
+  };
+  deid_keys?: string[];
+  encryption?: Encryption;
+}
+
+export interface DicomMetadata {
+  patient_name?: string;
+  patient_id?: string;
+  patient_dob?: string;
+  patient_sex?: string;
+  study_description?: string;
+  study_uid?: string;
+  study_date?: string;
+  modalities: string[];
+  series_count: number;
+  instance_count: number;
+  series?: Array<{
+    series_uid: string;
+    series_description?: string;
+    modality: string;
+    instance_count: number;
+  }>;
+}
+
+export interface Metadata {
+  patient: Patient;
+  study: {
+    description?: string;
+    uid?: string;
+    date?: string;
+  };
+  dicom: DicomMetadata;
+  custom_metadata?: Record<string, unknown>;
+}
+
+export interface AuditEntityRef {
+  id: string;
+  name?: string;
+}
+
+export interface AuditEntry {
+  event: string;
+  by: AuditEntityRef;
+  to?: AuditEntityRef;
+  timestamp: string; // date-time
+  assertion?: SenderAssertion;
+}
+
+export interface Audit {
+  audit: AuditEntry[];
+}
+
+export interface FileEntry {
+  path: string;
+  size: number;
+  hash: string;
+  mime_type?: string;
+  description?: string;
+}
+
+export interface Files {
+  payload_directory: string;
+  files: FileEntry[];
+  total_size: number;
+  file_count: number;
+}
+
+export interface JmixEnvelope {
+  manifest: Manifest;
+  metadata: Metadata;
+  audit: Audit;
+  files?: Files;
+}
+
+export interface Config {
+  version: string;
+  sender: ContactVariant;
+  requester?: ContactVariant;
+  receivers: ContactVariant[];
+  patient: Patient;
+  security: Security;
+  consent?: Consent;
+  custom_tags?: string[];
+  report?: {
+    file: string;
+  };
+  deid_keys?: string[];
+}
+
+// Error types
+export class JmixError extends Error {
+  constructor(
+    message: string,
+    public readonly cause?: Error
+  ) {
+    super(message);
+    this.name = 'JmixError';
+  }
+}
+
+export class ValidationError extends JmixError {
+  constructor(
+    message: string,
+    public readonly errors: string[] = []
+  ) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+export class CryptographyError extends JmixError {
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+    this.name = 'CryptographyError';
+  }
+}
+
+export class DicomError extends JmixError {
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+    this.name = 'DicomError';
+  }
+}

package/src/validation/SchemaValidator.ts

@@ -0,0 +1,156 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ValidationError } from '../types/index.js';
+
+export interface SchemaValidatorOptions {
+  schemaPath?: string;
+  strictMode?: boolean;
+}
+
+export class SchemaValidator {
+  private ajv: Ajv;
+  private schemaPath: string;
+  private schemaCache: Map<string, object> = new Map();
+
+  constructor(options: SchemaValidatorOptions = {}) {
+    this.schemaPath =
+      options.schemaPath ||
+      process.env.JMIX_SCHEMA_PATH ||
+      path.resolve(process.cwd(), '../jmix/schemas');
+
+    this.ajv = new Ajv({
+      allErrors: true,
+      strict: options.strictMode ?? true,
+      loadSchema: this.loadSchema.bind(this),
+    });
+
+    addFormats(this.ajv);
+  }
+
+  private async loadSchema(uri: string): Promise<object> {
+    if (this.schemaCache.has(uri)) {
+      return this.schemaCache.get(uri)!;
+    }
+
+    try {
+      const schemaContent = await fs.readFile(uri, 'utf-8');
+      const schema = JSON.parse(schemaContent);
+      this.schemaCache.set(uri, schema);
+      return schema;
+    } catch (error) {
+      throw new ValidationError(`Failed to load schema from ${uri}`, [
+        error instanceof Error ? error.message : String(error),
+      ]);
+    }
+  }
+
+  private getSchemaPath(schemaName: string): string {
+    return path.join(this.schemaPath, `${schemaName}.schema.json`);
+  }
+
+  async validateManifest(data: unknown): Promise<void> {
+    await this.validate('manifest', data);
+  }
+
+  async validateMetadata(data: unknown): Promise<void> {
+    await this.validate('metadata', data);
+  }
+
+  async validateAudit(data: unknown): Promise<void> {
+    await this.validate('audit', data);
+  }
+
+  async validateFiles(data: unknown): Promise<void> {
+    await this.validate('files', data);
+  }
+
+  private async validate(schemaName: string, data: unknown): Promise<void> {
+    const schemaPath = this.getSchemaPath(schemaName);
+
+    try {
+      // Check if schema file exists
+      await fs.access(schemaPath);
+    } catch {
+      // Schema file doesn't exist, skip validation gracefully
+      console.warn(`Schema validation skipped: ${schemaPath} not found`);
+      return;
+    }
+
+    try {
+      const schema = await this.loadSchema(schemaPath);
+      const validate = this.ajv.compile(schema);
+      const valid = validate(data);
+
+      if (!valid) {
+        const errors =
+          validate.errors?.map((error) => {
+            const instancePath = error.instancePath || 'root';
+            return `${instancePath}: ${error.message}`;
+          }) || [];
+
+        throw new ValidationError(`${schemaName} validation failed`, errors);
+      }
+    } catch (error) {
+      if (
+        error instanceof ValidationError &&
+        error.message.includes('validation failed')
+      ) {
+        throw error;
+      }
+
+      // For schema loading errors, just skip validation gracefully
+      console.warn(
+        `Schema validation error for ${schemaName}, skipping: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+  }
+
+  async validateEnvelope(envelope: {
+    manifest: unknown;
+    metadata: unknown;
+    audit: unknown;
+    files?: unknown;
+  }): Promise<void> {
+    const validationPromises = [
+      this.validateManifest(envelope.manifest),
+      this.validateMetadata(envelope.metadata),
+      this.validateAudit(envelope.audit),
+    ];
+
+    if (envelope.files) {
+      validationPromises.push(this.validateFiles(envelope.files));
+    }
+
+    try {
+      await Promise.all(validationPromises);
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      throw new ValidationError('Envelope validation failed', [
+        error instanceof Error ? error.message : String(error),
+      ]);
+    }
+  }
+
+  // Check if schema files are available
+  async isSchemaAvailable(schemaName?: string): Promise<boolean> {
+    if (schemaName) {
+      try {
+        await fs.access(this.getSchemaPath(schemaName));
+        return true;
+      } catch {
+        return false;
+      }
+    }
+
+    // Check if any schema files are available
+    const schemaNames = ['manifest', 'metadata', 'audit', 'files'];
+    const checks = schemaNames.map((name) => this.isSchemaAvailable(name));
+    const results = await Promise.all(checks);
+    return results.some((available) => available);
+  }
+}

package/test-encrypt.js

@@ -0,0 +1,10 @@
+import { JmixBuilder } from './dist/index.js';
+import nacl from 'tweetnacl';
+
+(async () => {
+  const config = await JmixBuilder.loadConfig('./samples/sample_config.json');
+  const builder = new JmixBuilder();
+  const kp = nacl.box.keyPair();
+  const out = await builder.packageEncryptedToDirectory('./samples/study_1', config, './tmp', Buffer.from(kp.publicKey).toString('base64'));
+  console.log('RESULT', out);
+})().catch(e => { console.error('ERR', e); process.exit(1); });