@erosolaraijs/cure 1.0.0

package/dist/integrations/ehr/fhir.js

@@ -0,0 +1,859 @@
+/**
+ * HL7 FHIR Integration Layer
+ *
+ * Connects to Electronic Health Record systems using the FHIR R4 standard.
+ * Supports Epic, Cerner, AllScripts, and other FHIR-compliant EHR systems.
+ *
+ * IMPORTANT: This module requires proper HIPAA compliance setup before use.
+ * All PHI access must be logged and patient consent must be verified.
+ */
+import { EventEmitter } from 'events';
+// ═══════════════════════════════════════════════════════════════════════════════
+// FHIR CLIENT IMPLEMENTATION
+// ═══════════════════════════════════════════════════════════════════════════════
+export class FHIRClient extends EventEmitter {
+    config;
+    accessToken;
+    tokenExpiry;
+    auditLogger;
+    constructor(config) {
+        super();
+        this.config = {
+            timeout: 30000,
+            retryAttempts: 3,
+            ...config
+        };
+    }
+    /**
+     * Set audit logger for HIPAA compliance
+     */
+    setAuditLogger(logger) {
+        this.auditLogger = logger;
+    }
+    /**
+     * Authenticate with the FHIR server
+     */
+    async authenticate() {
+        const startTime = Date.now();
+        try {
+            switch (this.config.authType) {
+                case 'smart-on-fhir':
+                    await this.smartOnFhirAuth();
+                    break;
+                case 'client-credentials':
+                    await this.clientCredentialsAuth();
+                    break;
+                case 'oauth2':
+                    await this.oauth2Auth();
+                    break;
+                case 'basic':
+                    // Basic auth doesn't require pre-authentication
+                    break;
+                default:
+                    throw new Error(`Unsupported auth type: ${this.config.authType}`);
+            }
+            await this.logAudit({
+                action: 'authenticate',
+                resourceType: 'System',
+                outcome: 'success',
+                duration: Date.now() - startTime
+            });
+        }
+        catch (error) {
+            await this.logAudit({
+                action: 'authenticate',
+                resourceType: 'System',
+                outcome: 'failure',
+                duration: Date.now() - startTime,
+                errorMessage: error instanceof Error ? error.message : 'Unknown error'
+            });
+            throw error;
+        }
+    }
+    async smartOnFhirAuth() {
+        // SMART on FHIR authentication flow
+        // This is a simplified version - production would need full OAuth2 flow
+        const tokenEndpoint = await this.discoverTokenEndpoint();
+        const response = await this.httpRequest(tokenEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            body: new URLSearchParams({
+                grant_type: 'client_credentials',
+                client_id: this.config.clientId,
+                client_secret: this.config.clientSecret || '',
+                scope: this.config.scopes.join(' ')
+            }).toString()
+        });
+        const data = JSON.parse(response);
+        this.accessToken = data.access_token;
+        this.tokenExpiry = new Date(Date.now() + (data.expires_in * 1000));
+    }
+    async clientCredentialsAuth() {
+        const tokenEndpoint = `${this.config.baseUrl}/oauth2/token`;
+        const response = await this.httpRequest(tokenEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                'Authorization': `Basic ${Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString('base64')}`
+            },
+            body: new URLSearchParams({
+                grant_type: 'client_credentials',
+                scope: this.config.scopes.join(' ')
+            }).toString()
+        });
+        const data = JSON.parse(response);
+        this.accessToken = data.access_token;
+        this.tokenExpiry = new Date(Date.now() + (data.expires_in * 1000));
+    }
+    async oauth2Auth() {
+        // OAuth2 flow - similar to client credentials for server-to-server
+        await this.clientCredentialsAuth();
+    }
+    async discoverTokenEndpoint() {
+        const wellKnown = `${this.config.baseUrl}/.well-known/smart-configuration`;
+        try {
+            const response = await this.httpRequest(wellKnown, { method: 'GET' });
+            const config = JSON.parse(response);
+            return config.token_endpoint;
+        }
+        catch {
+            // Fall back to standard OAuth2 endpoint
+            return `${this.config.baseUrl}/oauth2/token`;
+        }
+    }
+    /**
+     * Get a patient by ID
+     */
+    async getPatient(patientId) {
+        return await this.read('Patient', patientId);
+    }
+    /**
+     * Search for patients
+     */
+    async searchPatients(params) {
+        return await this.search('Patient', params);
+    }
+    /**
+     * Get cancer diagnosis for a patient
+     */
+    async getCancerDiagnosis(patientId) {
+        const bundle = await this.search('Condition', {
+            patient: patientId,
+            category: 'encounter-diagnosis',
+            'code:below': '363346000' // SNOMED CT code for malignant neoplasm
+        });
+        const diagnoses = [];
+        for (const entry of bundle.entry || []) {
+            const condition = entry.resource;
+            if (condition.resourceType === 'Condition') {
+                diagnoses.push(this.mapConditionToCancerDiagnosis(condition, patientId));
+            }
+        }
+        return diagnoses;
+    }
+    /**
+     * Get biomarkers and genomic data for a patient
+     */
+    async getBiomarkers(patientId) {
+        // Get lab observations
+        const labBundle = await this.search('Observation', {
+            patient: patientId,
+            category: 'laboratory',
+            _sort: '-date',
+            _count: '100'
+        });
+        // Get genomic observations
+        const genomicBundle = await this.search('Observation', {
+            patient: patientId,
+            category: 'genomic-variant',
+            _sort: '-date',
+            _count: '100'
+        });
+        // Get diagnostic reports (for NGS results)
+        const reportBundle = await this.search('DiagnosticReport', {
+            patient: patientId,
+            category: 'GE', // Genetics
+            _sort: '-date',
+            _count: '50'
+        });
+        return this.aggregateBiomarkerData(patientId, labBundle, genomicBundle, reportBundle);
+    }
+    /**
+     * Get treatment history for a patient
+     */
+    async getTreatmentHistory(patientId) {
+        const [medications, procedures] = await Promise.all([
+            this.search('MedicationRequest', {
+                patient: patientId,
+                _sort: '-authoredon',
+                _count: '200'
+            }),
+            this.search('Procedure', {
+                patient: patientId,
+                _sort: '-date',
+                _count: '200'
+            })
+        ]);
+        return this.aggregateTreatmentHistory(patientId, medications, procedures);
+    }
+    /**
+     * Get all observations for a patient
+     */
+    async getObservations(patientId, category) {
+        const params = {
+            patient: patientId,
+            _sort: '-date',
+            _count: '100'
+        };
+        if (category) {
+            params.category = category;
+        }
+        const bundle = await this.search('Observation', params);
+        return (bundle.entry || [])
+            .map(e => e.resource)
+            .filter((r) => r?.resourceType === 'Observation');
+    }
+    /**
+     * Get all medications for a patient
+     */
+    async getMedications(patientId) {
+        const bundle = await this.search('MedicationRequest', {
+            patient: patientId,
+            _sort: '-authoredon'
+        });
+        return (bundle.entry || [])
+            .map(e => e.resource)
+            .filter((r) => r?.resourceType === 'MedicationRequest');
+    }
+    /**
+     * Get diagnostic reports for a patient
+     */
+    async getDiagnosticReports(patientId) {
+        const bundle = await this.search('DiagnosticReport', {
+            patient: patientId,
+            _sort: '-date'
+        });
+        return (bundle.entry || [])
+            .map(e => e.resource)
+            .filter((r) => r?.resourceType === 'DiagnosticReport');
+    }
+    /**
+     * Create a comprehensive cancer patient summary
+     */
+    async getComprehensiveCancerSummary(patientId) {
+        const [patient, diagnoses, biomarkers, treatmentHistory, recentLabs] = await Promise.all([
+            this.getPatient(patientId),
+            this.getCancerDiagnosis(patientId),
+            this.getBiomarkers(patientId),
+            this.getTreatmentHistory(patientId),
+            this.getObservations(patientId, 'laboratory')
+        ]);
+        // Get performance status (ECOG/KPS)
+        const performanceObs = await this.search('Observation', {
+            patient: patientId,
+            code: '89247-1', // LOINC for ECOG performance status
+            _sort: '-date',
+            _count: '1'
+        });
+        let performanceStatus;
+        const perfEntry = performanceObs.entry?.[0]?.resource;
+        if (perfEntry?.valueQuantity?.value !== undefined) {
+            performanceStatus = {
+                score: perfEntry.valueQuantity.value,
+                scale: 'ECOG',
+                date: new Date(perfEntry.effectiveDateTime || Date.now())
+            };
+        }
+        return {
+            patient,
+            diagnoses,
+            biomarkers,
+            treatmentHistory,
+            recentLabs: recentLabs.slice(0, 20),
+            performanceStatus
+        };
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // CORE FHIR OPERATIONS
+    // ═══════════════════════════════════════════════════════════════════════════════
+    /**
+     * Read a resource by ID
+     */
+    async read(resourceType, id) {
+        const url = `${this.config.baseUrl}/${resourceType}/${id}`;
+        const startTime = Date.now();
+        try {
+            const response = await this.httpRequest(url, {
+                method: 'GET',
+                headers: await this.getAuthHeaders()
+            });
+            await this.logAudit({
+                action: 'read',
+                resourceType,
+                resourceId: id,
+                outcome: 'success',
+                duration: Date.now() - startTime
+            });
+            return JSON.parse(response);
+        }
+        catch (error) {
+            await this.logAudit({
+                action: 'read',
+                resourceType,
+                resourceId: id,
+                outcome: 'failure',
+                duration: Date.now() - startTime,
+                errorMessage: error instanceof Error ? error.message : 'Unknown error'
+            });
+            throw error;
+        }
+    }
+    /**
+     * Search for resources
+     */
+    async search(resourceType, params) {
+        const searchParams = new URLSearchParams(params);
+        const url = `${this.config.baseUrl}/${resourceType}?${searchParams.toString()}`;
+        const startTime = Date.now();
+        try {
+            const response = await this.httpRequest(url, {
+                method: 'GET',
+                headers: await this.getAuthHeaders()
+            });
+            await this.logAudit({
+                action: 'search',
+                resourceType,
+                outcome: 'success',
+                duration: Date.now() - startTime,
+                details: { searchParams: params }
+            });
+            return JSON.parse(response);
+        }
+        catch (error) {
+            await this.logAudit({
+                action: 'search',
+                resourceType,
+                outcome: 'failure',
+                duration: Date.now() - startTime,
+                errorMessage: error instanceof Error ? error.message : 'Unknown error'
+            });
+            throw error;
+        }
+    }
+    /**
+     * Create a resource
+     */
+    async create(resource) {
+        const url = `${this.config.baseUrl}/${resource.resourceType}`;
+        const startTime = Date.now();
+        try {
+            const response = await this.httpRequest(url, {
+                method: 'POST',
+                headers: {
+                    ...await this.getAuthHeaders(),
+                    'Content-Type': 'application/fhir+json'
+                },
+                body: JSON.stringify(resource)
+            });
+            await this.logAudit({
+                action: 'create',
+                resourceType: resource.resourceType,
+                outcome: 'success',
+                duration: Date.now() - startTime
+            });
+            return JSON.parse(response);
+        }
+        catch (error) {
+            await this.logAudit({
+                action: 'create',
+                resourceType: resource.resourceType,
+                outcome: 'failure',
+                duration: Date.now() - startTime,
+                errorMessage: error instanceof Error ? error.message : 'Unknown error'
+            });
+            throw error;
+        }
+    }
+    /**
+     * Update a resource
+     */
+    async update(resource) {
+        const url = `${this.config.baseUrl}/${resource.resourceType}/${resource.id}`;
+        const startTime = Date.now();
+        try {
+            const response = await this.httpRequest(url, {
+                method: 'PUT',
+                headers: {
+                    ...await this.getAuthHeaders(),
+                    'Content-Type': 'application/fhir+json'
+                },
+                body: JSON.stringify(resource)
+            });
+            await this.logAudit({
+                action: 'update',
+                resourceType: resource.resourceType,
+                resourceId: resource.id,
+                outcome: 'success',
+                duration: Date.now() - startTime
+            });
+            return JSON.parse(response);
+        }
+        catch (error) {
+            await this.logAudit({
+                action: 'update',
+                resourceType: resource.resourceType,
+                resourceId: resource.id,
+                outcome: 'failure',
+                duration: Date.now() - startTime,
+                errorMessage: error instanceof Error ? error.message : 'Unknown error'
+            });
+            throw error;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════════════════════
+    // HELPER METHODS
+    // ═══════════════════════════════════════════════════════════════════════════════
+    async getAuthHeaders() {
+        // Check if token needs refresh
+        if (this.tokenExpiry && new Date() >= this.tokenExpiry) {
+            await this.authenticate();
+        }
+        const headers = {
+            'Accept': 'application/fhir+json'
+        };
+        if (this.accessToken) {
+            headers['Authorization'] = `Bearer ${this.accessToken}`;
+        }
+        else if (this.config.authType === 'basic') {
+            headers['Authorization'] = `Basic ${Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString('base64')}`;
+        }
+        return headers;
+    }
+    async httpRequest(url, options) {
+        // Use native fetch in Node.js 18+
+        const response = await fetch(url, {
+            method: options.method,
+            headers: options.headers,
+            body: options.body,
+            signal: AbortSignal.timeout(this.config.timeout || 30000)
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`FHIR request failed: ${response.status} ${response.statusText} - ${errorBody}`);
+        }
+        return await response.text();
+    }
+    mapConditionToCancerDiagnosis(condition, patientId) {
+        const icdCoding = condition.code.coding?.find(c => c.system?.includes('icd-10') || c.system?.includes('icd-9'));
+        const snomedCoding = condition.code.coding?.find(c => c.system?.includes('snomed'));
+        const stageInfo = condition.stage?.[0];
+        let stage;
+        if (stageInfo?.summary) {
+            const stageCode = stageInfo.summary.coding?.[0]?.code || stageInfo.summary.text || '';
+            stage = {
+                system: this.determineStageSystem(stageCode),
+                stage: stageCode
+            };
+        }
+        return {
+            patientId,
+            conditionId: condition.id,
+            cancerType: condition.code.text || condition.code.coding?.[0]?.display || 'Unknown',
+            icdCode: icdCoding?.code || '',
+            snomedCode: snomedCoding?.code,
+            primarySite: condition.bodySite?.[0]?.text || condition.bodySite?.[0]?.coding?.[0]?.display,
+            stage,
+            diagnosisDate: new Date(condition.onsetDateTime || condition.recordedDate || Date.now()),
+            verificationStatus: this.mapVerificationStatus(condition.verificationStatus)
+        };
+    }
+    determineStageSystem(stageCode) {
+        const code = stageCode.toUpperCase();
+        if (code.includes('AJCC') || /^[IV]+[ABC]?$/.test(code) || code.includes('TNM')) {
+            return 'ajcc';
+        }
+        if (code.includes('FIGO'))
+            return 'figo';
+        if (code.includes('RAI'))
+            return 'rai';
+        if (code.includes('BINET'))
+            return 'binet';
+        if (code.includes('ISS'))
+            return 'iss';
+        return 'other';
+    }
+    mapVerificationStatus(status) {
+        const code = status.coding?.[0]?.code?.toLowerCase() || '';
+        if (code.includes('confirmed'))
+            return 'confirmed';
+        if (code.includes('provisional'))
+            return 'provisional';
+        if (code.includes('differential'))
+            return 'differential';
+        if (code.includes('refuted'))
+            return 'refuted';
+        return 'confirmed';
+    }
+    aggregateBiomarkerData(patientId, labBundle, genomicBundle, reportBundle) {
+        const biomarkers = [];
+        const genomicAlterations = [];
+        let latestDate = new Date(0);
+        // Process lab observations
+        for (const entry of labBundle.entry || []) {
+            const obs = entry.resource;
+            if (obs.resourceType !== 'Observation')
+                continue;
+            const date = new Date(obs.effectiveDateTime || Date.now());
+            if (date > latestDate)
+                latestDate = date;
+            // Map common cancer biomarkers
+            const biomarker = this.mapObservationToBiomarker(obs);
+            if (biomarker)
+                biomarkers.push(biomarker);
+        }
+        // Process genomic observations
+        for (const entry of genomicBundle.entry || []) {
+            const obs = entry.resource;
+            if (obs.resourceType !== 'Observation')
+                continue;
+            const date = new Date(obs.effectiveDateTime || Date.now());
+            if (date > latestDate)
+                latestDate = date;
+            const alteration = this.mapObservationToGenomicAlteration(obs);
+            if (alteration)
+                genomicAlterations.push(alteration);
+        }
+        // Process diagnostic reports for additional genomic data
+        for (const entry of reportBundle.entry || []) {
+            const report = entry.resource;
+            if (report.resourceType !== 'DiagnosticReport')
+                continue;
+            const date = new Date(report.effectiveDateTime || Date.now());
+            if (date > latestDate)
+                latestDate = date;
+        }
+        if (biomarkers.length === 0 && genomicAlterations.length === 0) {
+            return null;
+        }
+        // Extract special biomarkers
+        const tmbObs = this.findBiomarker(biomarkers, ['TMB', 'tumor mutational burden']);
+        const msiObs = this.findBiomarker(biomarkers, ['MSI', 'microsatellite']);
+        const pdl1Obs = this.findBiomarker(biomarkers, ['PD-L1', 'PDL1']);
+        const hrdObs = this.findBiomarker(biomarkers, ['HRD', 'homologous recombination']);
+        return {
+            patientId,
+            collectionDate: latestDate,
+            biomarkers,
+            genomicAlterations: genomicAlterations.length > 0 ? genomicAlterations : undefined,
+            tumorMutationalBurden: tmbObs ? {
+                value: typeof tmbObs.value === 'number' ? tmbObs.value : parseFloat(String(tmbObs.value)) || 0,
+                unit: 'mutations/Mb',
+                status: this.categorizeTMB(tmbObs.value)
+            } : undefined,
+            microsatelliteInstability: msiObs ? {
+                status: this.categorizeMSI(msiObs.value),
+                method: 'NGS'
+            } : undefined,
+            pdl1Expression: pdl1Obs ? {
+                score: typeof pdl1Obs.value === 'number' ? pdl1Obs.value : parseFloat(String(pdl1Obs.value)) || 0,
+                scoreType: 'TPS'
+            } : undefined,
+            hrdStatus: hrdObs ? {
+                status: hrdObs.status === 'positive' ? 'positive' : 'negative',
+                score: typeof hrdObs.value === 'number' ? hrdObs.value : undefined
+            } : undefined
+        };
+    }
+    mapObservationToBiomarker(obs) {
+        const name = obs.code.text || obs.code.coding?.[0]?.display;
+        if (!name)
+            return null;
+        let value;
+        let status;
+        if (obs.valueQuantity?.value !== undefined) {
+            value = obs.valueQuantity.value;
+            status = 'positive'; // Will be refined based on interpretation
+        }
+        else if (obs.valueCodeableConcept) {
+            value = obs.valueCodeableConcept.text || obs.valueCodeableConcept.coding?.[0]?.display || '';
+            status = this.interpretBiomarkerStatus(value);
+        }
+        else if (obs.valueString) {
+            value = obs.valueString;
+            status = this.interpretBiomarkerStatus(value);
+        }
+        else {
+            return null;
+        }
+        // Check interpretation if available
+        if (obs.interpretation?.[0]?.coding?.[0]?.code) {
+            const interpCode = obs.interpretation[0].coding[0].code;
+            if (interpCode === 'POS' || interpCode === 'H')
+                status = 'positive';
+            else if (interpCode === 'NEG' || interpCode === 'N')
+                status = 'negative';
+            else if (interpCode === 'IND')
+                status = 'equivocal';
+        }
+        return {
+            name,
+            value,
+            unit: obs.valueQuantity?.unit,
+            status,
+            loincCode: obs.code.coding?.find(c => c.system?.includes('loinc'))?.code
+        };
+    }
+    mapObservationToGenomicAlteration(obs) {
+        // This would need to be expanded to handle the full mCode/genomics-reporting IG
+        const geneComponent = obs.component?.find(c => c.code.coding?.some(coding => coding.code === '48018-6') // Gene studied
+        );
+        const variantComponent = obs.component?.find(c => c.code.coding?.some(coding => coding.code === '81252-9') // DNA change
+        );
+        if (!geneComponent || !variantComponent)
+            return null;
+        const gene = geneComponent.valueCodeableConcept?.text ||
+            geneComponent.valueCodeableConcept?.coding?.[0]?.display || '';
+        const alteration = variantComponent.valueString ||
+            variantComponent.valueCodeableConcept?.text || '';
+        if (!gene || !alteration)
+            return null;
+        return {
+            gene,
+            alteration,
+            type: this.determineAlterationType(alteration)
+        };
+    }
+    determineAlterationType(alteration) {
+        const lower = alteration.toLowerCase();
+        if (lower.includes('amp') || lower.includes('gain'))
+            return 'amplification';
+        if (lower.includes('del') || lower.includes('loss'))
+            return 'deletion';
+        if (lower.includes('fusion') || lower.includes('::'))
+            return 'fusion';
+        if (lower.includes('rearr') || lower.includes('transloc'))
+            return 'rearrangement';
+        return 'mutation';
+    }
+    interpretBiomarkerStatus(value) {
+        const lower = String(value).toLowerCase();
+        if (lower.includes('positive') || lower.includes('detected') || lower === 'yes')
+            return 'positive';
+        if (lower.includes('negative') || lower.includes('not detected') || lower === 'no')
+            return 'negative';
+        if (lower.includes('equivocal') || lower.includes('indeterminate') || lower.includes('borderline'))
+            return 'equivocal';
+        return 'positive'; // Default to positive if we have a value
+    }
+    findBiomarker(biomarkers, keywords) {
+        return biomarkers.find(b => keywords.some(k => b.name.toLowerCase().includes(k.toLowerCase())));
+    }
+    categorizeTMB(value) {
+        const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+        if (isNaN(numValue))
+            return 'low';
+        if (numValue >= 10)
+            return 'high';
+        if (numValue >= 6)
+            return 'intermediate';
+        return 'low';
+    }
+    categorizeMSI(value) {
+        const strValue = String(value).toUpperCase();
+        if (strValue.includes('MSI-H') || strValue.includes('HIGH') || strValue.includes('UNSTABLE'))
+            return 'MSI-H';
+        if (strValue.includes('MSI-L') || strValue.includes('LOW'))
+            return 'MSI-L';
+        return 'MSS';
+    }
+    aggregateTreatmentHistory(patientId, medications, procedures) {
+        const treatments = [];
+        // Process medications
+        for (const entry of medications.entry || []) {
+            const med = entry.resource;
+            if (med.resourceType !== 'MedicationRequest')
+                continue;
+            const drugName = med.medicationCodeableConcept?.text ||
+                med.medicationCodeableConcept?.coding?.[0]?.display ||
+                'Unknown medication';
+            const treatment = this.categorizeTreatment(drugName);
+            treatments.push({
+                id: med.id,
+                type: treatment.type,
+                regimen: treatment.regimen,
+                drugs: [{
+                        name: drugName,
+                        dose: med.dosageInstruction?.[0]?.text,
+                        route: med.dosageInstruction?.[0]?.route?.text,
+                        rxNormCode: med.medicationCodeableConcept?.coding?.find(c => c.system?.includes('rxnorm'))?.code
+                    }],
+                startDate: new Date(med.authoredOn || Date.now()),
+                status: this.mapMedicationStatus(med.status)
+            });
+        }
+        // Process procedures (surgery, radiation)
+        for (const entry of procedures.entry || []) {
+            const proc = entry.resource;
+            if (proc.resourceType !== 'Procedure')
+                continue;
+            const procName = proc.code.text || proc.code.coding?.[0]?.display || 'Unknown procedure';
+            const isSurgery = this.isSurgicalProcedure(procName);
+            const isRadiation = this.isRadiationProcedure(procName);
+            if (isSurgery || isRadiation) {
+                treatments.push({
+                    id: proc.id,
+                    type: isRadiation ? 'radiation' : 'surgery',
+                    drugs: [],
+                    startDate: new Date(proc.performedDateTime || proc.performedPeriod?.start || Date.now()),
+                    endDate: proc.performedPeriod?.end ? new Date(proc.performedPeriod.end) : undefined,
+                    status: this.mapProcedureStatus(proc.status)
+                });
+            }
+        }
+        // Sort by date
+        treatments.sort((a, b) => b.startDate.getTime() - a.startDate.getTime());
+        return { patientId, treatments };
+    }
+    categorizeTreatment(drugName) {
+        const lower = drugName.toLowerCase();
+        // Immunotherapy
+        const immunotherapyDrugs = ['pembrolizumab', 'nivolumab', 'ipilimumab', 'atezolizumab', 'durvalumab',
+            'avelumab', 'cemiplimab', 'dostarlimab', 'relatlimab', 'tremelimumab'];
+        if (immunotherapyDrugs.some(d => lower.includes(d))) {
+            return { type: 'immunotherapy' };
+        }
+        // Targeted therapy
+        const targetedDrugs = ['imatinib', 'erlotinib', 'gefitinib', 'osimertinib', 'crizotinib', 'alectinib',
+            'palbociclib', 'ribociclib', 'abemaciclib', 'olaparib', 'rucaparib', 'niraparib', 'trastuzumab',
+            'pertuzumab', 'lapatinib', 'vemurafenib', 'dabrafenib', 'trametinib', 'sotorasib', 'adagrasib',
+            'venetoclax', 'ibrutinib', 'acalabrutinib', 'lenvatinib', 'sorafenib', 'regorafenib', 'cabozantinib',
+            'bevacizumab', 'cetuximab', 'panitumumab', 'rituximab'];
+        if (targetedDrugs.some(d => lower.includes(d))) {
+            return { type: 'targeted-therapy' };
+        }
+        // Hormone therapy
+        const hormoneDrugs = ['tamoxifen', 'letrozole', 'anastrozole', 'exemestane', 'fulvestrant',
+            'enzalutamide', 'abiraterone', 'apalutamide', 'darolutamide', 'lupron', 'leuprolide'];
+        if (hormoneDrugs.some(d => lower.includes(d))) {
+            return { type: 'hormone-therapy' };
+        }
+        // CAR-T
+        const carTDrugs = ['tisagenlecleucel', 'axicabtagene', 'brexucabtagene', 'lisocabtagene',
+            'idecabtagene', 'ciltacabtagene', 'kymriah', 'yescarta', 'tecartus', 'breyanzi', 'abecma', 'carvykti'];
+        if (carTDrugs.some(d => lower.includes(d))) {
+            return { type: 'car-t' };
+        }
+        // Chemotherapy (catch-all for cytotoxic agents)
+        const chemoDrugs = ['carboplatin', 'cisplatin', 'oxaliplatin', 'paclitaxel', 'docetaxel',
+            'doxorubicin', 'epirubicin', 'cyclophosphamide', 'fluorouracil', '5-fu', 'capecitabine',
+            'gemcitabine', 'pemetrexed', 'etoposide', 'irinotecan', 'vincristine', 'vinblastine',
+            'methotrexate', 'cytarabine', 'azacitidine', 'decitabine', 'temozolomide'];
+        if (chemoDrugs.some(d => lower.includes(d))) {
+            return { type: 'chemotherapy' };
+        }
+        return { type: 'other' };
+    }
+    mapMedicationStatus(status) {
+        switch (status) {
+            case 'active': return 'active';
+            case 'completed': return 'completed';
+            case 'stopped': return 'stopped';
+            case 'on-hold': return 'on-hold';
+            case 'draft': return 'planned';
+            default: return 'active';
+        }
+    }
+    mapProcedureStatus(status) {
+        switch (status) {
+            case 'completed': return 'completed';
+            case 'in-progress': return 'active';
+            case 'preparation': return 'planned';
+            case 'on-hold': return 'on-hold';
+            case 'stopped': return 'stopped';
+            default: return 'completed';
+        }
+    }
+    isSurgicalProcedure(name) {
+        const surgeryKeywords = ['surgery', 'resection', 'excision', 'mastectomy', 'lobectomy',
+            'colectomy', 'gastrectomy', 'prostatectomy', 'nephrectomy', 'hysterectomy',
+            'lymphadenectomy', 'biopsy', 'debulking', 'whipple', 'hepatectomy'];
+        return surgeryKeywords.some(k => name.toLowerCase().includes(k));
+    }
+    isRadiationProcedure(name) {
+        const radiationKeywords = ['radiation', 'radiotherapy', 'sbrt', 'imrt', 'proton',
+            'brachytherapy', 'cyberknife', 'gamma knife', 'external beam'];
+        return radiationKeywords.some(k => name.toLowerCase().includes(k));
+    }
+    async logAudit(event) {
+        if (!this.auditLogger)
+            return;
+        const fullEvent = {
+            timestamp: new Date(),
+            userId: 'system',
+            ipAddress: '0.0.0.0',
+            action: event.action || 'unknown',
+            resourceType: event.resourceType || 'unknown',
+            outcome: event.outcome || 'unknown',
+            ...event
+        };
+        try {
+            await this.auditLogger(fullEvent);
+        }
+        catch (error) {
+            console.error('Failed to log audit event:', error);
+        }
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// EHR VENDOR-SPECIFIC ADAPTERS
+// ═══════════════════════════════════════════════════════════════════════════════
+export class EpicFHIRClient extends FHIRClient {
+    constructor(config) {
+        super({ ...config, ehrVendor: 'epic' });
+    }
+    /**
+     * Epic-specific: Get MyChart patient context
+     */
+    async getMyChartContext(launchToken) {
+        // Epic SMART launch context parsing
+        const decoded = Buffer.from(launchToken, 'base64').toString();
+        return JSON.parse(decoded);
+    }
+}
+export class CernerFHIRClient extends FHIRClient {
+    constructor(config) {
+        super({ ...config, ehrVendor: 'cerner' });
+    }
+    /**
+     * Cerner-specific: Handle Millennium-specific extensions
+     */
+    parseMillenniumExtensions(resource) {
+        const extensions = {};
+        if ('extension' in resource && resource.extension) {
+            for (const ext of resource.extension) {
+                if (ext.url.includes('cerner.com')) {
+                    const key = ext.url.split('/').pop() || ext.url;
+                    extensions[key] = ext.valueString || ext.valueCode || ext.valueBoolean || ext.valueCoding;
+                }
+            }
+        }
+        return extensions;
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════════
+// FACTORY FUNCTION
+// ═══════════════════════════════════════════════════════════════════════════════
+export function createFHIRClient(config) {
+    switch (config.ehrVendor) {
+        case 'epic':
+            return new EpicFHIRClient(config);
+        case 'cerner':
+            return new CernerFHIRClient(config);
+        default:
+            return new FHIRClient(config);
+    }
+}
+export default FHIRClient;
+//# sourceMappingURL=fhir.js.map