@omersx/bemms 0.0.0-stage → 1.0.0

package/src/lib/validators/__tests__/data-management.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { parseCSV, getDeviceImportTemplateCSV, getDepartmentImportTemplateCSV } from '@/lib/utils/csv-parser';
+import { deviceImportRowSchema, departmentImportRowSchema, purgeDataSchema, exportRequestSchema } from '../data-management';
+
+describe('CSV Parser Utility', () => {
+  it('parses simple CSV text into structured records', () => {
+    const csv = `asset_number,name,model\nDEV-001,Ventilator,V-500\nDEV-002,ECG Monitor,E-200`;
+    const records = parseCSV(csv);
+    expect(records).toHaveLength(2);
+    expect(records[0]).toEqual({
+      asset_number: 'DEV-001',
+      name: 'Ventilator',
+      model: 'V-500',
+    });
+    expect(records[1].asset_number).toEqual('DEV-002');
+  });
+
+  it('handles quoted fields with commas correctly', () => {
+    const csv = `asset_number,name,location\nDEV-001,"Defibrillator, Biphasic","Room 102, Bay A"`;
+    const records = parseCSV(csv);
+    expect(records).toHaveLength(1);
+    expect(records[0].name).toBe('Defibrillator, Biphasic');
+    expect(records[0].location).toBe('Room 102, Bay A');
+  });
+
+  it('normalizes various header formats', () => {
+    const csv = `Asset-Number,Device Name,SERIAL_NUMBER\nDEV-01,Pump,SN-100`;
+    const records = parseCSV(csv);
+    expect(records[0]).toHaveProperty('asset_number');
+    expect(records[0]).toHaveProperty('device_name');
+    expect(records[0]).toHaveProperty('serial_number');
+  });
+
+  it('returns empty array when text has only headers', () => {
+    const csv = `asset_number,name,model`;
+    expect(parseCSV(csv)).toHaveLength(0);
+  });
+});
+
+describe('getDeviceImportTemplateCSV', () => {
+  it('generates a valid CSV with BOM and required BEMMS headers', () => {
+    const template = getDeviceImportTemplateCSV();
+    expect(template.startsWith('\uFEFF')).toBe(true);
+    expect(template).toContain('asset_number');
+    expect(template).toContain('category');
+    expect(template).toContain('department');
+    expect(template).toContain('manufacturer');
+
+    const parsed = parseCSV(template);
+    expect(parsed.length).toBeGreaterThanOrEqual(2);
+  });
+});
+
+describe('getDepartmentImportTemplateCSV', () => {
+  it('generates a valid CSV with BOM and department headers', () => {
+    const template = getDepartmentImportTemplateCSV();
+    expect(template.startsWith('\uFEFF')).toBe(true);
+    expect(template).toContain('name');
+    expect(template).toContain('code');
+    expect(template).toContain('hospital_name');
+
+    const parsed = parseCSV(template);
+    expect(parsed.length).toBeGreaterThanOrEqual(2);
+    expect(parsed[0]).toHaveProperty('name');
+    expect(parsed[0]).toHaveProperty('code');
+    expect(parsed[0]).toHaveProperty('hospital_name');
+  });
+});
+
+describe('departmentImportRowSchema', () => {
+  it('validates a correct department row', () => {
+    const result = departmentImportRowSchema.safeParse({
+      name: 'Intensive Care Unit',
+      code: 'ICU',
+      departmentType: 'critical_care',
+      hospitalName: 'Central Teaching Hospital',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects rows missing required fields', () => {
+    const result = departmentImportRowSchema.safeParse({
+      name: '',
+      code: '',
+      hospitalName: '',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('deviceImportRowSchema', () => {
+  it('validates a complete medical device row', () => {
+    const result = deviceImportRowSchema.safeParse({
+      assetNumber: 'DEV-100',
+      name: 'Syringe Pump',
+      model: 'SP-1000',
+      serialNumber: 'SN-789',
+      categoryName: 'Infusion Pump',
+      manufacturerName: 'B. Braun',
+      departmentName: 'Emergency',
+      locationDescription: 'Storage Room B',
+      riskClassification: 'class_iib',
+      criticalityLevel: 'high',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects rows missing required assetNumber or name', () => {
+    const result = deviceImportRowSchema.safeParse({
+      assetNumber: '',
+      name: 'Syringe Pump',
+      categoryName: 'Pump',
+      manufacturerName: 'Vendor',
+      departmentName: 'ICU',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('applies standard defaults for optional fields', () => {
+    const result = deviceImportRowSchema.safeParse({
+      assetNumber: 'DEV-200',
+      name: 'Patient Monitor',
+      categoryName: 'Monitor',
+      manufacturerName: 'GE Healthcare',
+      departmentName: 'ICU',
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.riskClassification).toBe('class_i');
+      expect(result.data.criticalityLevel).toBe('medium');
+    }
+  });
+});
+
+describe('purgeDataSchema', () => {
+  it('validates a valid test data purge request', () => {
+    const result = purgeDataSchema.safeParse({
+      scope: 'test_transactions',
+      confirmText: 'PURGE TEST DATA',
+      password: 'adminPassword123',
+      reason: 'Pre-launch test cleanup',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects missing password', () => {
+    const result = purgeDataSchema.safeParse({
+      scope: 'test_transactions',
+      confirmText: 'PURGE TEST DATA',
+      password: '',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('exportRequestSchema', () => {
+  it('accepts rounds as a valid export entity', () => {
+    const result = exportRequestSchema.safeParse({
+      entities: ['rounds'],
+      format: 'xlsx',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts full multi-entity export including rounds', () => {
+    const result = exportRequestSchema.safeParse({
+      entities: ['devices', 'departments', 'tickets', 'rounds'],
+      format: 'json',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects empty entities array', () => {
+    const result = exportRequestSchema.safeParse({
+      entities: [],
+      format: 'csv',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+

package/src/lib/validators/__tests__/devices-profile.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+import {
+  transferDeviceSchema,
+  changeDeviceStatusSchema,
+  decommissionDeviceSchema,
+} from '../devices';
+
+describe('Device Transfer & Status Change Validators', () => {
+  const validUuid1 = '123e4567-e89b-12d3-a456-426614174000';
+  const validUuid2 = '223e4567-e89b-12d3-a456-426614174000';
+
+  describe('transferDeviceSchema', () => {
+    it('validates a complete transfer payload', () => {
+      const valid = {
+        destinationHospitalId: validUuid1,
+        destinationDepartmentId: validUuid2,
+        destinationLocationId: validUuid1,
+        transferReason: 'relocation',
+        notes: 'Moved to new ICU wing room 4',
+      };
+      const result = transferDeviceSchema.safeParse(valid);
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts all valid transfer reasons', () => {
+      const reasons = [
+        'relocation',
+        'temporary_loan',
+        'department_change',
+        'correction',
+        'replacement',
+        'workshop',
+        'storage',
+        'other',
+      ];
+      for (const reason of reasons) {
+        const result = transferDeviceSchema.safeParse({
+          destinationHospitalId: validUuid1,
+          destinationDepartmentId: validUuid2,
+          transferReason: reason,
+        });
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('rejects an invalid transfer reason', () => {
+      const result = transferDeviceSchema.safeParse({
+        destinationHospitalId: validUuid1,
+        destinationDepartmentId: validUuid2,
+        transferReason: 'invalid_reason',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects missing destination hospital or department', () => {
+      const result = transferDeviceSchema.safeParse({
+        transferReason: 'relocation',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('changeDeviceStatusSchema', () => {
+    it('validates a valid status change', () => {
+      const valid = {
+        newStatusCode: 'under_maintenance',
+        reason: 'Scheduled quarterly preventive inspection',
+        notes: 'Engineer assigned and work order created',
+      };
+      const result = changeDeviceStatusSchema.safeParse(valid);
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts all 9 medical device operational statuses', () => {
+      const statuses = [
+        'operational',
+        'operational_with_limitations',
+        'under_maintenance',
+        'under_repair',
+        'waiting_for_parts',
+        'awaiting_release',
+        'out_of_service',
+        'standby',
+        'decommissioned',
+      ];
+      for (const status of statuses) {
+        const result = changeDeviceStatusSchema.safeParse({
+          newStatusCode: status,
+          reason: `Transitioning to ${status}`,
+        });
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('rejects an invalid status code', () => {
+      const result = changeDeviceStatusSchema.safeParse({
+        newStatusCode: 'broken_beyond_repair',
+        reason: 'Hardware failure',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects empty or missing reason', () => {
+      const result = changeDeviceStatusSchema.safeParse({
+        newStatusCode: 'out_of_service',
+        reason: '',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('decommissionDeviceSchema', () => {
+    it('validates a valid decommission reason', () => {
+      const valid = {
+        reason: 'Equipment reached end-of-life per manufacturer policy and safety notice.',
+      };
+      const result = decommissionDeviceSchema.safeParse(valid);
+      expect(result.success).toBe(true);
+    });
+
+    it('rejects too short decommission reason', () => {
+      const result = decommissionDeviceSchema.safeParse({
+        reason: 'old',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+});
+

package/src/lib/validators/__tests__/devices.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createDeviceSchema,
+  createDeviceCategorySchema,
+  createManufacturerSchema,
+} from '../devices';
+
+describe('createDeviceCategorySchema', () => {
+  const validUuid = '123e4567-e89b-12d3-a456-426614174000';
+
+  it('validates a correct device category', () => {
+    const result = createDeviceCategorySchema.safeParse({
+      organizationId: validUuid,
+      name: 'Infusion Pump',
+      code: 'INF-PUMP',
+      description: 'Standard volumetric infusion pump',
+      riskClassification: 'class_iib',
+      criticalityLevel: 'high',
+      defaultPmIntervalDays: 180,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid UUID for organizationId', () => {
+    const result = createDeviceCategorySchema.safeParse({
+      organizationId: 'not-a-uuid',
+      name: 'Infusion Pump',
+      code: 'INF',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid risk classification enum value', () => {
+    const result = createDeviceCategorySchema.safeParse({
+      organizationId: validUuid,
+      name: 'Infusion Pump',
+      code: 'INF',
+      riskClassification: 'invalid_class',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('createManufacturerSchema', () => {
+  const validUuid = '123e4567-e89b-12d3-a456-426614174000';
+
+  it('validates a valid manufacturer', () => {
+    const result = createManufacturerSchema.safeParse({
+      organizationId: validUuid,
+      name: 'GE Healthcare',
+      code: 'GE',
+      country: 'USA',
+      supportEmail: 'support@ge.com',
+      website: 'https://gehealthcare.com',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('allows empty string for optional email and website', () => {
+    const result = createManufacturerSchema.safeParse({
+      organizationId: validUuid,
+      name: 'Local Medtech',
+      supportEmail: '',
+      website: '',
+    });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('createDeviceSchema', () => {
+  const validUuid = '123e4567-e89b-12d3-a456-426614174000';
+
+  it('validates a complete valid device', () => {
+    const result = createDeviceSchema.safeParse({
+      organizationId: validUuid,
+      hospitalId: validUuid,
+      departmentId: validUuid,
+      name: 'Defibrillator X',
+      assetNumber: 'BME-DEF-001',
+      serialNumber: 'SN-987654321',
+      deviceCategoryId: validUuid,
+      criticalityLevel: 'critical',
+      riskClassification: 'class_iii',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects device without assetNumber or name', () => {
+    const result = createDeviceSchema.safeParse({
+      organizationId: validUuid,
+      hospitalId: validUuid,
+      departmentId: validUuid,
+      deviceCategoryId: validUuid,
+    });
+    expect(result.success).toBe(false);
+  });
+});
+

package/src/lib/validators/__tests__/engineer-rounds.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from 'vitest';
+import {
+  startRoundSchema,
+  completeDepartmentVisitSchema,
+  addVisitNoteSchema,
+  completeRoundSchema,
+  roundHistoryFilterSchema,
+  roundCalendarQuerySchema,
+} from '../engineer-rounds';
+import { featuresSettingsSchema, systemSettingsSchema } from '../system-settings';
+
+describe('featuresSettingsSchema', () => {
+  it('defaults engineerRoundEnabled to false', () => {
+    const result = featuresSettingsSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.engineerRoundEnabled).toBe(false);
+    }
+  });
+
+  it('accepts explicitly enabled engineerRoundEnabled', () => {
+    const result = featuresSettingsSchema.safeParse({ engineerRoundEnabled: true });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.engineerRoundEnabled).toBe(true);
+    }
+  });
+
+  it('integrates cleanly into systemSettingsSchema', () => {
+    const result = systemSettingsSchema.safeParse({
+      features: { engineerRoundEnabled: true },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.features.engineerRoundEnabled).toBe(true);
+    }
+  });
+});
+
+describe('startRoundSchema', () => {
+  it('accepts valid start round payload with password signature', () => {
+    const result = startRoundSchema.safeParse({
+      hospitalId: '123e4567-e89b-12d3-a456-426614174000',
+      shiftType: 'morning',
+      password: 'MySecretPassword123!',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects missing password for e-signature', () => {
+    const result = startRoundSchema.safeParse({
+      hospitalId: '123e4567-e89b-12d3-a456-426614174000',
+      shiftType: 'morning',
+      password: '',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid hospital UUID', () => {
+    const result = startRoundSchema.safeParse({
+      hospitalId: 'invalid-uuid',
+      shiftType: 'evening',
+      password: 'valid-password',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('defaults shiftType to morning if omitted', () => {
+    const result = startRoundSchema.safeParse({
+      hospitalId: '123e4567-e89b-12d3-a456-426614174000',
+      password: 'valid-password',
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.shiftType).toBe('morning');
+    }
+  });
+});
+
+describe('completeDepartmentVisitSchema', () => {
+  it('accepts completion with optional note and @device mentions', () => {
+    const result = completeDepartmentVisitSchema.safeParse({
+      visitId: '123e4567-e89b-12d3-a456-426614174001',
+      noteText: 'Checked ventilator, all operating within specifications.',
+      deviceMentions: [
+        {
+          deviceId: '123e4567-e89b-12d3-a456-426614174002',
+          deviceName: 'Ventilator 01',
+          internalCode: 'ICU-VENT-01',
+        },
+      ],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts completion without note (quick completion)', () => {
+    const result = completeDepartmentVisitSchema.safeParse({
+      visitId: '123e4567-e89b-12d3-a456-426614174001',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid visitId UUID', () => {
+    const result = completeDepartmentVisitSchema.safeParse({
+      visitId: 'not-a-uuid',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('addVisitNoteSchema', () => {
+  it('accepts non-empty note with device mentions', () => {
+    const result = addVisitNoteSchema.safeParse({
+      visitId: '123e4567-e89b-12d3-a456-426614174001',
+      noteText: 'Replaced backup battery on @Monitor-02',
+      deviceMentions: [
+        {
+          deviceId: '123e4567-e89b-12d3-a456-426614174003',
+          deviceName: 'Monitor-02',
+          internalCode: 'EMERG-MON-02',
+        },
+      ],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects empty note', () => {
+    const result = addVisitNoteSchema.safeParse({
+      visitId: '123e4567-e89b-12d3-a456-426614174001',
+      noteText: '',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('roundCalendarQuerySchema', () => {
+  it('accepts valid month and year', () => {
+    const result = roundCalendarQuerySchema.safeParse({
+      engineerId: '123e4567-e89b-12d3-a456-426614174000',
+      month: 10,
+      year: 2026,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid month numbers', () => {
+    const result = roundCalendarQuerySchema.safeParse({
+      engineerId: '123e4567-e89b-12d3-a456-426614174000',
+      month: 13,
+      year: 2026,
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('completeRoundSchema', () => {
+  it('accepts valid round UUID', () => {
+    const result = completeRoundSchema.safeParse({
+      roundId: '123e4567-e89b-12d3-a456-426614174000',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid round UUID', () => {
+    const result = completeRoundSchema.safeParse({
+      roundId: 'not-valid',
+    });
+    expect(result.success).toBe(false);
+  });
+});