@omersx/bemms 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,178 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createMaintenanceTaskSchema,
+  assignMaintenanceTaskSchema,
+  updateMaintenanceTaskStageSchema,
+  completeMaintenanceTaskSchema,
+  cancelMaintenanceTaskSchema,
+  createMaintenancePlanSchema,
+} from '../maintenance';
+
+describe('Maintenance Validators', () => {
+  const validUUID1 = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11';
+  const validUUID2 = 'b0eebc99-9c0b-4ef8-bb6d-6bb9bd380a22';
+  const validUUID3 = 'c0eebc99-9c0b-4ef8-bb6d-6bb9bd380a33';
+
+  describe('createMaintenanceTaskSchema', () => {
+    it('validates a valid corrective maintenance task', () => {
+      const data = {
+        organizationId: validUUID1,
+        hospitalId: validUUID2,
+        deviceId: validUUID3,
+        maintenanceType: 'corrective_maintenance',
+        technicalProblemCategory: 'electrical_power',
+        title: 'Repair ventilator power supply',
+        description: 'Blown capacitor on secondary DC rail',
+        priorityCode: 'p1_critical',
+      };
+
+      const result = createMaintenanceTaskSchema.safeParse(data);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.title).toBe('Repair ventilator power supply');
+        expect(result.data.priorityCode).toBe('p1_critical');
+      }
+    });
+
+    it('validates a preventive maintenance task with default priority', () => {
+      const data = {
+        organizationId: validUUID1,
+        hospitalId: validUUID2,
+        deviceId: validUUID3,
+        maintenanceType: 'preventive_maintenance',
+        title: '6-Month Anesthesia PM Routine',
+      };
+
+      const result = createMaintenanceTaskSchema.safeParse(data);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.priorityCode).toBe('p3_normal');
+      }
+    });
+
+    it('rejects title shorter than 5 characters', () => {
+      const data = {
+        organizationId: validUUID1,
+        hospitalId: validUUID2,
+        deviceId: validUUID3,
+        maintenanceType: 'corrective_maintenance',
+        title: 'Fix',
+      };
+
+      const result = createMaintenanceTaskSchema.safeParse(data);
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects invalid maintenance type', () => {
+      const data = {
+        organizationId: validUUID1,
+        hospitalId: validUUID2,
+        deviceId: validUUID3,
+        maintenanceType: 'magical_repair',
+        title: 'Fix defibrillator',
+      };
+
+      const result = createMaintenanceTaskSchema.safeParse(data);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('assignMaintenanceTaskSchema', () => {
+    it('validates engineer assignment with optional handoff note', () => {
+      const result = assignMaintenanceTaskSchema.safeParse({
+        assignedEngineerUserId: validUUID1,
+        handoffNote: 'Device is located in ICU Room 4',
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('fails if assignedEngineerUserId is missing or not a UUID', () => {
+      const result = assignMaintenanceTaskSchema.safeParse({
+        assignedEngineerUserId: 'not-a-uuid',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('updateMaintenanceTaskStageSchema', () => {
+    it('validates waiting dependency details', () => {
+      const result = updateMaintenanceTaskStageSchema.safeParse({
+        waitingDependencyType: 'parts',
+        waitingReason: 'Awaiting OEM pressure sensor delivery',
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('rejects waitingReason shorter than 5 chars if provided', () => {
+      const result = updateMaintenanceTaskStageSchema.safeParse({
+        waitingDependencyType: 'vendor',
+        waitingReason: 'Wait',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('completeMaintenanceTaskSchema', () => {
+    it('validates completion payload with final result and device release status', () => {
+      const payload = {
+        diagnosis: 'Defective power supply board',
+        rootCause: 'Electrical mains surge',
+        workPerformed: 'Replaced main PCB, verified voltage rails, passed electrical safety testing',
+        finalResultCode: 'passed',
+        finalDeviceStatusCode: 'operational',
+      };
+
+      const result = completeMaintenanceTaskSchema.safeParse(payload);
+      expect(result.success).toBe(true);
+    });
+
+    it('rejects workPerformed if shorter than 10 characters', () => {
+      const payload = {
+        workPerformed: 'Done fix',
+        finalResultCode: 'passed',
+        finalDeviceStatusCode: 'operational',
+      };
+
+      const result = completeMaintenanceTaskSchema.safeParse(payload);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('cancelMaintenanceTaskSchema', () => {
+    it('requires a cancellation reason with at least 10 chars', () => {
+      const valid = cancelMaintenanceTaskSchema.safeParse({
+        cancellationReason: 'Device decommissioned before scheduled repair',
+      });
+      expect(valid.success).toBe(true);
+
+      const invalid = cancelMaintenanceTaskSchema.safeParse({
+        cancellationReason: 'Too short',
+      });
+      expect(invalid.success).toBe(false);
+    });
+  });
+
+  describe('createMaintenancePlanSchema', () => {
+    it('validates PM plan creation parameters', () => {
+      const plan = {
+        organizationId: validUUID1,
+        hospitalId: validUUID2,
+        deviceId: validUUID3,
+        title: 'Quarterly Defibrillator Safety & Calibration',
+        planTypeCode: 'preventive_maintenance' as const,
+        calculationMethod: 'fixed_calendar' as const,
+        frequencyInterval: 3,
+        frequencyUnit: 'months' as const,
+        startBaselineDate: '2026-11-01T00:00:00.000Z',
+        leadTimeDays: 7,
+      };
+
+      const result = createMaintenancePlanSchema.safeParse(plan);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.frequencyInterval).toBe(3);
+        expect(result.data.frequencyUnit).toBe('months');
+      }
+    });
+  });
+});

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

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('@/lib/auth', () => ({
+  auth: vi.fn(),
+}));
+
+vi.mock('@/lib/db', () => ({
+  db: {
+    query: {},
+    select: vi.fn(),
+    insert: vi.fn(),
+    update: vi.fn(),
+    transaction: vi.fn(),
+  },
+}));
+
+import {
+  createSignaturePolicySchema,
+  signActionSchema,
+  signatureRequirementSchema,
+} from '../signatures';
+import { getAttestationText } from '@/lib/utils/attestations';
+
+describe('Signature Validators', () => {
+  describe('signatureRequirementSchema', () => {
+    it('validates a correct signature requirement', () => {
+      const valid = {
+        purpose: 'perform',
+        allowedRoles: ['BME_TECHNICIAN', 'BME_ENGINEER'],
+        required: true,
+      };
+      const result = signatureRequirementSchema.safeParse(valid);
+      expect(result.success).toBe(true);
+    });
+
+    it('rejects an empty allowedRoles array', () => {
+      const invalid = {
+        purpose: 'perform',
+        allowedRoles: [],
+        required: true,
+      };
+      const result = signatureRequirementSchema.safeParse(invalid);
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects an invalid purpose', () => {
+      const invalid = {
+        purpose: 'invalid_purpose',
+        allowedRoles: ['BME_ENGINEER'],
+        required: true,
+      };
+      const result = signatureRequirementSchema.safeParse(invalid);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('createSignaturePolicySchema', () => {
+    it('validates a complete signature policy input', () => {
+      const valid = {
+        actionType: 'complete_corrective',
+        criticalityLevel: 'high',
+        requiredSignatures: [
+          { purpose: 'perform', allowedRoles: ['BME_TECHNICIAN'], required: true },
+          { purpose: 'review', allowedRoles: ['BME_ENGINEER', 'BME_MANAGER'], required: true },
+        ],
+        requireIndependentReview: true,
+        performerCanRelease: false,
+        requireReauth: true,
+      };
+      const result = createSignaturePolicySchema.safeParse(valid);
+      expect(result.success).toBe(true);
+    });
+
+    it('applies defaults for optional flags', () => {
+      const minimal = {
+        actionType: 'complete_pm',
+        requiredSignatures: [
+          { purpose: 'perform', allowedRoles: ['BME_ENGINEER'], required: true },
+        ],
+      };
+      const parsed = createSignaturePolicySchema.parse(minimal);
+      expect(parsed.requireIndependentReview).toBe(false);
+      expect(parsed.performerCanRelease).toBe(true);
+      expect(parsed.requireReauth).toBe(true);
+      expect(parsed.policyVersion).toBe('1.0');
+    });
+
+    it('rejects an invalid actionType', () => {
+      const invalid = {
+        actionType: 'non_existent_action',
+        requiredSignatures: [
+          { purpose: 'perform', allowedRoles: ['BME_ENGINEER'], required: true },
+        ],
+      };
+      const result = createSignaturePolicySchema.safeParse(invalid);
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('signActionSchema', () => {
+    it('validates a valid sign action payload with password and comments', () => {
+      const valid = {
+        signaturePurpose: 'perform',
+        password: 'SecurePassword123!',
+        comments: 'Checklist completed with no anomalies.',
+      };
+      const result = signActionSchema.safeParse(valid);
+      expect(result.success).toBe(true);
+    });
+
+    it('rejects an empty password', () => {
+      const invalid = {
+        signaturePurpose: 'perform',
+        password: '',
+      };
+      const result = signActionSchema.safeParse(invalid);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.issues[0].message).toContain('Password is required');
+      }
+    });
+
+    it('accepts all standard signature purposes', () => {
+      const purposes = [
+        'accept', 'perform', 'review', 'approve',
+        'release', 'resolve', 'close', 'reject',
+        'amend', 'void',
+      ];
+      for (const purpose of purposes) {
+        const result = signActionSchema.safeParse({
+          signaturePurpose: purpose,
+          password: 'secret',
+        });
+        expect(result.success).toBe(true);
+      }
+    });
+  });
+});
+
+describe('getAttestationText', () => {
+  it('returns specific attestation text for known purposes', () => {
+    expect(getAttestationText('perform')).toContain('performed the recorded maintenance');
+    expect(getAttestationText('review')).toContain('reviewed the performed work');
+    expect(getAttestationText('release')).toContain('authorize the release of this medical device');
+    expect(getAttestationText('approve')).toContain('approve the recorded work');
+    expect(getAttestationText('reject')).toContain('returning this work for correction');
+  });
+
+  it('returns fallback attestation for unknown purpose', () => {
+    const text = getAttestationText('custom_action');
+    expect(text).toContain('I confirm this custom_action action');
+  });
+});
+

package/src/lib/validators/__tests__/system-settings.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import {
+  localizationSettingsSchema,
+  securitySettingsSchema,
+  retentionSettingsSchema,
+  systemSettingsSchema,
+} from '../system-settings';
+
+describe('localizationSettingsSchema', () => {
+  it('accepts valid localization settings', () => {
+    const result = localizationSettingsSchema.safeParse({
+      timezone: 'Africa/Cairo',
+      dateFormat: 'YYYY-MM-DD',
+      timeFormat: '24h',
+      language: 'en',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts Arabic language setting per Section 14.1', () => {
+    const result = localizationSettingsSchema.safeParse({
+      timezone: 'Asia/Riyadh',
+      dateFormat: 'DD/MM/YYYY',
+      timeFormat: '12h',
+      language: 'ar',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects unsupported language', () => {
+    const result = localizationSettingsSchema.safeParse({
+      timezone: 'UTC',
+      dateFormat: 'YYYY-MM-DD',
+      timeFormat: '24h',
+      language: 'es',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid date format', () => {
+    const result = localizationSettingsSchema.safeParse({
+      timezone: 'UTC',
+      dateFormat: 'DD-MM-YYYY', // unsupported delimiter
+      timeFormat: '24h',
+      language: 'en',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('securitySettingsSchema', () => {
+  it('accepts standard 21 CFR Part 11 security settings', () => {
+    const result = securitySettingsSchema.safeParse({
+      sessionTimeoutMinutes: 15,
+      passwordExpiryDays: 90,
+      requireReAuthForSignatures: true,
+      maxLoginAttempts: 5,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects timeout below minimum threshold', () => {
+    const result = securitySettingsSchema.safeParse({
+      sessionTimeoutMinutes: 2, // min is 5
+      passwordExpiryDays: 90,
+      requireReAuthForSignatures: true,
+      maxLoginAttempts: 5,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('coerces string inputs to numbers gracefully', () => {
+    const result = securitySettingsSchema.safeParse({
+      sessionTimeoutMinutes: '30',
+      passwordExpiryDays: '60',
+      requireReAuthForSignatures: false,
+      maxLoginAttempts: '3',
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.sessionTimeoutMinutes).toBe(30);
+      expect(result.data.passwordExpiryDays).toBe(60);
+      expect(result.data.maxLoginAttempts).toBe(3);
+    }
+  });
+});
+
+describe('retentionSettingsSchema', () => {
+  it('accepts valid retention policies', () => {
+    const result = retentionSettingsSchema.safeParse({
+      auditLogRetentionDays: 365,
+      pmAlertWindowDays: 14,
+      attachmentQuotaMb: 10000,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects audit log retention less than 30 days', () => {
+    const result = retentionSettingsSchema.safeParse({
+      auditLogRetentionDays: 10,
+      pmAlertWindowDays: 14,
+      attachmentQuotaMb: 5000,
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('systemSettingsSchema', () => {
+  it('provides complete defaults when given empty object', () => {
+    const result = systemSettingsSchema.safeParse({});
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.localization.timezone).toBe('UTC');
+      expect(result.data.security.requireReAuthForSignatures).toBe(true);
+      expect(result.data.retention.pmAlertWindowDays).toBe(14);
+    }
+  });
+});
+

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

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createTicketSchema,
+  triageTicketSchema,
+  resolveTicketSchema,
+  updateTicketDeviceStatusSchema,
+} from '../tickets';
+
+describe('createTicketSchema', () => {
+  const validUuid = '123e4567-e89b-12d3-a456-426614174000';
+
+  it('validates a valid ticket creation request', () => {
+    const result = createTicketSchema.safeParse({
+      organizationId: validUuid,
+      hospitalId: validUuid,
+      departmentId: validUuid,
+      source: 'qr_scan',
+      ticketType: 'device_problem',
+      title: 'Display screen flickering constantly',
+      description: 'The unit screen flickers on startup and powers off unexpectedly after 5 minutes.',
+      reportedImpact: 'device_not_usable',
+      reportedProblemCategory: 'display_interface',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects title shorter than 5 characters', () => {
+    const result = createTicketSchema.safeParse({
+      organizationId: validUuid,
+      hospitalId: validUuid,
+      departmentId: validUuid,
+      source: 'manual_entry',
+      title: 'Bad',
+      description: 'The device is completely broken and unusable.',
+      reportedImpact: 'device_not_usable',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects description shorter than 10 characters', () => {
+    const result = createTicketSchema.safeParse({
+      organizationId: validUuid,
+      hospitalId: validUuid,
+      departmentId: validUuid,
+      source: 'manual_entry',
+      title: 'Broken button on front panel',
+      description: 'Broken',
+      reportedImpact: 'device_usable',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('triageTicketSchema', () => {
+  it('validates a triage assignment', () => {
+    const result = triageTicketSchema.safeParse({
+      priorityCode: 'p1_critical',
+      priorityReason: 'Life support equipment non-functional in ICU',
+      selectedMaintenanceType: 'corrective_maintenance',
+      selectedTechnicalCategory: 'electrical_power',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid priority code', () => {
+    const result = triageTicketSchema.safeParse({
+      priorityCode: 'urgent',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('resolveTicketSchema', () => {
+  it('accepts valid resolution with operational device status', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Power supply board replaced and tested according to manufacturer calibration spec.',
+      finalDeviceStatusCode: 'operational',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts valid resolution with operational_with_limitations', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Primary channel calibrated; secondary probe port disabled pending replacement part.',
+      finalDeviceStatusCode: 'operational_with_limitations',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts valid resolution with operational_with_limitations and limitationsNote', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Primary channel calibrated; secondary probe port disabled pending replacement part.',
+      finalDeviceStatusCode: 'operational_with_limitations',
+      limitationsNote: 'Secondary probe port disabled. Use Channel 1 only.',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts valid resolution with awaiting_release, standby, and decommissioned', () => {
+    for (const status of ['awaiting_release', 'standby', 'decommissioned'] as const) {
+      const result = resolveTicketSchema.safeParse({
+        resolutionSummary: 'Maintenance procedure completed in full compliance with protocol.',
+        finalDeviceStatusCode: status,
+      });
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it('accepts valid resolution with out_of_service (unrepairable / condemned)', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Main motherboard cracked beyond repair. Equipment condemned and recommended for decommissioning.',
+      finalDeviceStatusCode: 'out_of_service',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects resolving a ticket with under_repair device status', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Device is still being worked on by external biomedical service engineer.',
+      finalDeviceStatusCode: 'under_repair',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects resolving a ticket with waiting_for_parts device status', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Part ordered from Philips Medical, expected next Tuesday.',
+      finalDeviceStatusCode: 'waiting_for_parts',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects resolution summary shorter than 10 characters', () => {
+    const result = resolveTicketSchema.safeParse({
+      resolutionSummary: 'Fixed it',
+      finalDeviceStatusCode: 'operational',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('updateTicketDeviceStatusSchema', () => {
+  it('accepts interim under_repair status with progress note', () => {
+    const result = updateTicketDeviceStatusSchema.safeParse({
+      deviceStatusCode: 'under_repair',
+      notes: 'Disassembled unit on bench; isolating display inverter circuit.',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts waiting_for_parts status with note', () => {
+    const result = updateTicketDeviceStatusSchema.safeParse({
+      deviceStatusCode: 'waiting_for_parts',
+      notes: 'Waiting for replacement oxygen cell sensor from vendor.',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts operational_with_limitations with limitationsNote', () => {
+    const result = updateTicketDeviceStatusSchema.safeParse({
+      deviceStatusCode: 'operational_with_limitations',
+      notes: 'Calibrated main unit; SpO2 module pending replacement.',
+      limitationsNote: 'SpO2 sensor offline; NIBP and ECG operational.',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects notes shorter than 3 characters', () => {
+    const result = updateTicketDeviceStatusSchema.safeParse({
+      deviceStatusCode: 'under_repair',
+      notes: 'ok',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+