@omniradiology/omnirad 0.1.3

package/lib/fhir/helpers.ts

@@ -0,0 +1,73 @@
+/// <reference types="fhir" />
+import { NextResponse, NextRequest } from "next/server";
+import { FHIR_CONTENT_TYPE } from "./constants";
+import { db } from "@/db";
+import { fhirIntegrationConfig } from "@/db/schema";
+import { eq } from "drizzle-orm";
+import * as bcrypt from "bcryptjs";
+
+export function operationOutcome(
+    code: fhir4.OperationOutcomeIssue["code"],
+    diagnostics: string,
+    severity: fhir4.OperationOutcomeIssue["severity"] = "error"
+): fhir4.OperationOutcome {
+    return {
+        resourceType: "OperationOutcome",
+        issue: [
+            {
+                severity,
+                code,
+                diagnostics
+            }
+        ]
+    };
+}
+
+export function sanitizeId(id: string | null | undefined): string {
+    if (!id) return "unknown";
+    // FHIR IDs must be [A-Za-z0-9\-\.]{1,64}
+    return id.replace(/[^A-Za-z0-9\-\.]/g, "-").substring(0, 64);
+}
+
+export function fhirResponse(resource: any, status: number = 200) {
+    return NextResponse.json(resource, {
+        status,
+        headers: { "Content-Type": FHIR_CONTENT_TYPE }
+    });
+}
+
+export function fhirErrorResponse(code: fhir4.OperationOutcomeIssue["code"], message: string, status: number) {
+    return fhirResponse(operationOutcome(code, message), status);
+}
+
+export async function requireFhirAccess(request: NextRequest, scope: "read" | "write" = "read"): Promise<NextResponse | null> {
+    const config = db.select().from(fhirIntegrationConfig).where(eq(fhirIntegrationConfig.id, 1)).get();
+    
+    if (!config || !config.enabled) {
+        return fhirErrorResponse("security", "FHIR API is disabled", 403);
+    }
+
+    if (scope === "read" && !config.outboundReadEnabled) {
+        return fhirErrorResponse("security", "Outbound FHIR reads are disabled", 403);
+    }
+
+    if (scope === "write" && !config.inboundServiceRequestEnabled) {
+        return fhirErrorResponse("security", "Inbound FHIR orders are disabled", 403);
+    }
+
+    if (config.authMode === "bearer_token" && config.apiTokenHash) {
+        const authHeader = request.headers.get("authorization");
+        if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            return fhirErrorResponse("security", "Missing or invalid Authorization header", 401);
+        }
+
+        const token = authHeader.split(" ")[1];
+        const isValid = await bcrypt.compare(token, config.apiTokenHash);
+        
+        if (!isValid) {
+            return fhirErrorResponse("security", "Invalid bearer token", 401);
+        }
+    }
+
+    return null;
+}

package/lib/fhir/imaging-study.ts

@@ -0,0 +1,49 @@
+/// <reference types="fhir" />
+import { ImagingStudyInput } from "../../types/fhir";
+import { FHIR_SYSTEMS } from "./constants";
+import { sanitizeId } from "./helpers";
+
+export function toFhirImagingStudy({
+    report,
+    reportData,
+    patient
+}: ImagingStudyInput): fhir4.ImagingStudy {
+    const studyUid = report.pacsStudyUid || reportData?.pacs_info?.study_uid;
+    const seriesUid = report.pacsSeriesUid || reportData?.pacs_info?.series_uid;
+    
+    const identifiers = [];
+    if (studyUid) {
+        identifiers.push({
+            system: FHIR_SYSTEMS.OMNIRAD_STUDY_UID,
+            value: `urn:oid:${studyUid}`
+        });
+    }
+
+    const series = [];
+    if (seriesUid) {
+        const modality = report.modality || reportData?.study?.modality;
+        series.push({
+            uid: seriesUid,
+            modality: { 
+                system: "http://dicom.nema.org/resources/ontology/DCM",
+                code: modality || "UNKNOWN" 
+            }
+        });
+    }
+
+    const started = reportData?.report_header?.report_date || report.createdAt;
+
+    return {
+        resourceType: "ImagingStudy",
+        id: sanitizeId(studyUid || report.id),
+        identifier: identifiers.length > 0 ? identifiers : undefined,
+        status: studyUid ? "available" : "unknown",
+        subject: {
+            reference: patient ? `Patient/${sanitizeId(patient.id)}` : `Patient/${sanitizeId(report.patientId || "unknown")}`,
+            display: patient?.patientName || report.patientName || undefined
+        },
+        started: started ? new Date(started).toISOString() : undefined,
+        description: reportData?.study?.examination || undefined,
+        series: series.length > 0 ? series : undefined
+    };
+}

package/lib/fhir/patient.ts

@@ -0,0 +1,55 @@
+/// <reference types="fhir" />
+import { Patient } from "../../types/index";
+import { FHIR_SYSTEMS } from "./constants";
+import { sanitizeId } from "./helpers";
+
+export function toFhirPatient(patient: Patient): fhir4.Patient {
+    const names: fhir4.HumanName[] = [];
+    if (patient.patientName) {
+        const parts = patient.patientName.trim().split(/\s+/);
+        const family = parts.length > 1 ? parts.pop() || "" : "";
+        const given = parts;
+        names.push({
+            text: patient.patientName,
+            ...(family ? { family } : {}),
+            ...(given.length > 0 ? { given } : {})
+        });
+    }
+
+    let gender: fhir4.Patient["gender"] = "unknown";
+    const pGender = patient.gender?.toLowerCase() || "";
+    if (["male", "m"].includes(pGender)) gender = "male";
+    else if (["female", "f"].includes(pGender)) gender = "female";
+    else if (["other"].includes(pGender)) gender = "other";
+
+    const telecom: fhir4.ContactPoint[] = [];
+    if (patient.mobile) {
+        telecom.push({ system: "phone", value: patient.mobile });
+    }
+    if (patient.contactInfo && patient.contactInfo !== patient.mobile) {
+        if (patient.contactInfo.includes("@")) {
+            telecom.push({ system: "email", value: patient.contactInfo });
+        } else {
+            telecom.push({ system: "phone", value: patient.contactInfo });
+        }
+    }
+
+    const identifiers = [];
+    if (patient.patientIdNumber) {
+        identifiers.push({
+            system: FHIR_SYSTEMS.OMNIRAD_PATIENT_ID,
+            value: patient.patientIdNumber
+        });
+    }
+
+    return {
+        resourceType: "Patient",
+        id: sanitizeId(patient.id),
+        identifier: identifiers.length > 0 ? identifiers : undefined,
+        name: names.length > 0 ? names : undefined,
+        gender,
+        birthDate: patient.dob || undefined,
+        telecom: telecom.length > 0 ? telecom : undefined,
+        address: patient.address ? [{ text: patient.address }] : undefined
+    };
+}

package/lib/fhir/service-request.ts

@@ -0,0 +1,85 @@
+/// <reference types="fhir" />
+import { WorklistOrder, OmniRadWorklistOrderInput } from "../../types/fhir";
+import { sanitizeId } from "./helpers";
+
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        var r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
+        return v.toString(16);
+    });
+}
+
+export function parseInboundServiceRequest(resource: fhir4.ServiceRequest): OmniRadWorklistOrderInput {
+    if (resource.resourceType !== "ServiceRequest") {
+        throw new Error("Invalid resourceType: expected ServiceRequest");
+    }
+    
+    // priority mapping
+    let urgency = "Routine";
+    if (resource.priority === "urgent" || resource.priority === "asap") urgency = "Urgent";
+    else if (resource.priority === "stat") urgency = "Critical";
+
+    let patientId = null;
+    let patientName = "Unknown";
+    let patientIdentifier = "";
+    
+    if (resource.subject) {
+        if (resource.subject.reference && resource.subject.reference.startsWith("Patient/")) {
+            patientId = resource.subject.reference.replace("Patient/", "");
+        }
+        if (resource.subject.display) {
+            patientName = resource.subject.display;
+        }
+    }
+
+    let requestedProcedure = "";
+    if (resource.code?.text) {
+        requestedProcedure = resource.code.text;
+    } else if (resource.code?.coding && resource.code.coding.length > 0) {
+        requestedProcedure = resource.code.coding[0].display || resource.code.coding[0].code || "";
+    }
+
+    let reason = "";
+    if (resource.reasonCode && resource.reasonCode.length > 0) {
+        reason = resource.reasonCode[0].text || resource.reasonCode[0].coding?.[0]?.display || "";
+    }
+
+    return {
+        id: generateUUID(),
+        sourceSystem: "FHIR",
+        fhirServiceRequestId: resource.id || "",
+        patientId,
+        patientName,
+        patientIdentifier,
+        status: resource.status || "active",
+        intent: resource.intent || "order",
+        priority: resource.priority || "routine",
+        urgency,
+        modality: null,
+        requestedProcedure,
+        reason,
+        authoredOn: resource.authoredOn || new Date().toISOString(),
+        requesterDisplay: resource.requester?.display || null,
+        rawFhir: JSON.stringify(resource),
+        createdAt: new Date().toISOString(),
+        updatedAt: null
+    };
+}
+
+export function toFhirServiceRequest(order: WorklistOrder): fhir4.ServiceRequest {
+    return {
+        resourceType: "ServiceRequest",
+        id: sanitizeId(order.fhirServiceRequestId || order.id),
+        status: (order.status as fhir4.ServiceRequest["status"]) || "active",
+        intent: (order.intent as fhir4.ServiceRequest["intent"]) || "order",
+        priority: (order.priority as fhir4.ServiceRequest["priority"]) || "routine",
+        code: order.requestedProcedure ? { text: order.requestedProcedure } : undefined,
+        subject: {
+            reference: order.patientId ? `Patient/${sanitizeId(order.patientId)}` : undefined,
+            display: order.patientName || undefined
+        },
+        authoredOn: order.authoredOn || undefined,
+        reasonCode: order.reason ? [{ text: order.reason }] : undefined,
+        requester: order.requesterDisplay ? { display: order.requesterDisplay } : undefined
+    };
+}

package/lib/fhir.ts

@@ -0,0 +1,6 @@
+export * from "./fhir/constants";
+export * from "./fhir/helpers";
+export * from "./fhir/patient";
+export * from "./fhir/diagnostic-report";
+export * from "./fhir/imaging-study";
+export * from "./fhir/service-request";

package/lib/pacs/dicom-utils.ts

@@ -0,0 +1,72 @@
+/**
+ * Parses and formats a DICOM Patient Name (PN) VR.
+ * Usually in the format: "FamilyName^GivenName^MiddleName^NamePrefix^NameSuffix"
+ * DICOMweb json may already extract it as { Alphabetic: "DOE^JOHN" }
+ */
+export function formatPatientName(pnString: string | any): string {
+    if (!pnString) return "Unknown";
+    let raw = "";
+
+    if (typeof pnString === "string") {
+        raw = pnString;
+    } else if (pnString.Alphabetic) {
+        raw = pnString.Alphabetic;
+    } else {
+        return "Unknown";
+    }
+
+    // Replace carets with spaces, keeping names proper-cased roughly
+    const parts = raw.split("^").map(p => p.trim()).filter(Boolean);
+    if (parts.length === 0) return "Unknown";
+
+    // Usually family name is first in DICOM, given name second. 
+    // Example: DOE^JOHN => JOHN DOE
+    if (parts.length >= 2) {
+        return `${parts[1]} ${parts[0]}`.replace(/\b\w/g, l => l.toUpperCase());
+    }
+
+    // If only one part or unusual formatting
+    return parts[0].replace(/\b\w/g, l => l.toUpperCase());
+}
+
+/**
+ * Formats a DICOM Date (DA) VR.
+ * Format is typically "YYYYMMDD".
+ */
+export function formatDicomDate(daString?: string): string {
+    if (!daString || daString.length !== 8) return daString || "Unknown Date";
+    const year = daString.slice(0, 4);
+    const month = daString.slice(4, 6);
+    const day = daString.slice(6, 8);
+    return `${year}-${month}-${day}`;
+}
+
+/**
+ * Formats a DICOM Time (TM) VR.
+ * Format is typically "HHMMSS.FFFFFF" or "HHMMSS".
+ */
+export function formatDicomTime(tmString?: string): string {
+    if (!tmString || tmString.length < 6) return tmString || "Unknown Time";
+    const hours = tmString.slice(0, 2);
+    const minutes = tmString.slice(2, 4);
+    const seconds = tmString.slice(4, 6);
+    return `${hours}:${minutes}:${seconds}`;
+}
+
+/**
+ * Parses a DICOM Age String (AS).
+ * Format is e.g., "045Y", "006M", "014D".
+ */
+export function parseDicomAge(asString?: string): number | null {
+    if (!asString) return null;
+    const match = asString.match(/^(\d{3})([YMWD])$/);
+    if (!match) return null;
+    
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    
+    if (unit === 'Y') return value;
+    if (unit === 'M') return Math.floor(value / 12); // Approximate years from months
+    
+    return 0; // Infant/Days
+}

package/lib/pacs/dicomweb.ts

@@ -0,0 +1,72 @@
+import { DicomStudy, DicomSeries, DicomInstance } from "@/types/pacs";
+import { formatPatientName, formatDicomDate, formatDicomTime } from "./dicom-utils";
+
+/**
+ * Searches for studies using our Next.js API proxy
+ */
+export async function searchStudies(filters: Record<string, string>): Promise<DicomStudy[]> {
+    const searchParams = new URLSearchParams(filters);
+    searchParams.append('includefield', '00081030,00100030,00101010,00100040,00080061'); // Ensure StudyDescription, Age, Sex, Modalities are returned
+    const res = await fetch(`/api/pacs/qido/studies?${searchParams.toString()}`);
+    if (!res.ok) throw new Error(await res.text());
+    
+    const data = await res.json();
+    return data.map((item: any) => ({
+        id: item["0020000D"]?.Value?.[0] || "",
+        studyInstanceUid: item["0020000D"]?.Value?.[0] || "",
+        patientName: formatPatientName(item["00100010"]?.Value?.[0]?.Alphabetic || item["00100010"]?.Value?.[0] || "Unknown"),
+        patientId: item["00100020"]?.Value?.[0] || "Unknown",
+        patientBirthDate: item["00100030"]?.Value?.[0] || "",
+        patientAge: item["00101010"]?.Value?.[0] || "",
+        patientSex: item["00100040"]?.Value?.[0] || "",
+        studyDate: formatDicomDate(item["00080020"]?.Value?.[0]),
+        studyTime: formatDicomTime(item["00080030"]?.Value?.[0]),
+        accessionNumber: item["00080050"]?.Value?.[0] || "",
+        studyDescription: item["00081030"]?.Value?.[0] || "No Description",
+        modalitiesInStudy: item["00080061"]?.Value || [],
+        numberOfStudyRelatedSeries: item["00201206"]?.Value?.[0] || 0,
+        numberOfStudyRelatedInstances: item["00201208"]?.Value?.[0] || 0,
+    }));
+}
+
+/**
+ * Search series within a study
+ */
+export async function searchSeries(studyUid: string): Promise<DicomSeries[]> {
+    const res = await fetch(`/api/pacs/qido/series?studyUid=${studyUid}&includefield=0008103E`); // Ensure SeriesDescription is returned
+    if (!res.ok) throw new Error(await res.text());
+
+    const data = await res.json();
+    return data.map((item: any) => ({
+        studyInstanceUid: studyUid,
+        seriesInstanceUid: item["0020000E"]?.Value?.[0] || "",
+        seriesNumber: item["00200011"]?.Value?.[0] || 0,
+        modality: item["00080060"]?.Value?.[0] || "Unknown",
+        seriesDescription: item["0008103E"]?.Value?.[0] || "No Description",
+        numberOfSeriesRelatedInstances: item["00201209"]?.Value?.[0] || 0,
+    }));
+}
+
+/**
+ * Fetch a single instance Rendered JPEG as an object URL
+ */
+export async function fetchRenderedJpegUrl(studyUid: string, seriesUid: string, instanceUid: string, frame?: number): Promise<string> {
+    let url = `/api/pacs/wado/render?studyUid=${studyUid}&seriesUid=${seriesUid}&instanceUid=${instanceUid}`;
+    if (frame !== undefined) {
+        url += `&frame=${frame}`;
+    }
+    const res = await fetch(url);
+    if (!res.ok) throw new Error("Failed to fetch rendered image");
+    
+    const blob = await res.blob();
+    return URL.createObjectURL(blob);
+}
+
+/**
+ * Fetch study metadata
+ */
+export async function fetchStudyMetadata(studyUid: string): Promise<any> {
+    const res = await fetch(`/api/pacs/metadata?studyUid=${studyUid}`);
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+}

package/lib/pacs/server-utils.ts

@@ -0,0 +1,37 @@
+import { db } from "@/db";
+import { config } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+export async function getPacsConfigServer() {
+    const row = db.select().from(config).where(eq(config.id, 1)).get();
+    if (!row) return null;
+    
+    return {
+        pacsOrthancUrl: row.pacsOrthancUrl?.replace(/\/$/, "") || "",
+        pacsAuthType: row.pacsAuthType || "none",
+        pacsUsername: row.pacsUsername || "",
+        pacsPassword: row.pacsPassword || "",
+        pacsBearerToken: row.pacsBearerToken || "",
+        pacsAeTitle: row.pacsAeTitle || "",
+    };
+}
+
+export async function getOrthancHeaders() {
+    const pConfig = await getPacsConfigServer();
+    if (!pConfig || !pConfig.pacsOrthancUrl) {
+        throw new Error("Orthanc URL not configured");
+    }
+
+    const headers: Record<string, string> = {
+        "Accept": "application/json"
+    };
+
+    if (pConfig.pacsAuthType === "basic" && pConfig.pacsUsername && pConfig.pacsPassword) {
+        const authBase64 = Buffer.from(`${pConfig.pacsUsername}:${pConfig.pacsPassword}`).toString('base64');
+        headers["Authorization"] = `Basic ${authBase64}`;
+    } else if (pConfig.pacsAuthType === "bearer" && pConfig.pacsBearerToken) {
+        headers["Authorization"] = `Bearer ${pConfig.pacsBearerToken}`;
+    }
+
+    return { headers, baseUrl: pConfig.pacsOrthancUrl };
+}

package/lib/patients.ts

@@ -0,0 +1,25 @@
+import { randomUUID } from "crypto";
+
+import { Patient } from "@/types";
+
+// Ensure the local patients table has parity with existing reports
+export async function ensurePatientsMigrated() {
+    try {
+        // We do this by hitting an API route because server components / client components
+        // might not have direct SQLite access if we are running edge / separating concerns.
+        // Actually, we should just call an API route that does this so it accesses the DB securely.
+        const res = await fetch('/api/patients/merge', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ action: "auto-migrate" }),
+        });
+        if (res.ok) {
+            const data = await res.json();
+            if (data.migrated > 0) {
+                console.log(`[OmniRad] Migrated ${data.migrated} local reports to patient records.`);
+            }
+        }
+    } catch (e) {
+        console.warn("[OmniRad] Failed to auto-migrate patients:", e);
+    }
+}

package/lib/pdfHelper.ts

@@ -0,0 +1,119 @@
+import { ReportData } from "@/types";
+import { generateReportHtml } from "@/lib/reportHtmlGenerator";
+
+/**
+ * PDF Generation Helper - IFRAME ISOLATION APPROACH
+ *
+ * The root cause of blank PDFs: Tailwind CSS v4 injects oklab() color functions
+ * into computed styles globally. html2canvas traverses the entire DOM including
+ * inherited/computed styles and silently fails when it encounters oklab().
+ *
+ * Solution: Render the report HTML inside a hidden IFRAME. The iframe has its own
+ * document context, completely isolated from the parent page's Tailwind styles.
+ * This is exactly how professional PDF libraries work.
+ *
+ * Flow:
+ * 1. Create a hidden iframe
+ * 2. Write our clean HTML (pure inline styles) into the iframe's document
+ * 3. Point html2pdf at the iframe's body content
+ * 4. html2canvas only sees the iframe's clean DOM - no oklab, no Tailwind
+ * 5. Clean up
+ */
+
+export async function generatePDF(report: ReportData, filename: string, template: 'standard' | 'modern' | 'minimal' = 'standard', logoUrl?: string) {
+    if (!report) {
+        alert('Invalid report data.');
+        return;
+    }
+
+    // Import html2pdf dynamically to avoid SSR issues
+    // @ts-ignore
+    const html2pdfModule = await import('html2pdf.js');
+    const html2pdf = html2pdfModule.default || html2pdfModule;
+
+    // 1. Generate the Clean HTML (pure inline styles, no Tailwind)
+    const htmlContent = generateReportHtml(report, template, logoUrl);
+
+    // 2. Create a hidden iframe for COMPLETE CSS isolation
+    const iframe = document.createElement('iframe');
+    iframe.style.position = 'fixed';
+    iframe.style.left = '-10000px';
+    iframe.style.top = '0';
+    iframe.style.width = '210mm';
+    iframe.style.height = '297mm';
+    iframe.style.border = 'none';
+    iframe.style.opacity = '1'; // Must be visible for html2canvas
+    document.body.appendChild(iframe);
+
+    // 3. Write clean HTML into the iframe's document
+    const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
+    if (!iframeDoc) {
+        console.error('Could not access iframe document');
+        document.body.removeChild(iframe);
+        alert('PDF generation failed: Could not create isolated render context.');
+        return;
+    }
+
+    iframeDoc.open();
+    iframeDoc.write(`
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <style>
+                * { margin: 0; padding: 0; box-sizing: border-box; }
+                body { 
+                    background: #ffffff; 
+                    color: #000000; 
+                    font-family: Arial, Helvetica, sans-serif;
+                    -webkit-print-color-adjust: exact;
+                    print-color-adjust: exact;
+                }
+            </style>
+        </head>
+        <body>
+            ${htmlContent}
+        </body>
+        </html>
+    `);
+    iframeDoc.close();
+
+    // 4. Wait for the iframe content to fully render (images, fonts, layout)
+    await new Promise(resolve => setTimeout(resolve, 800));
+
+    // 5. Get the content element from inside the iframe
+    const contentElement = iframeDoc.body.firstElementChild as HTMLElement || iframeDoc.body;
+
+    // 6. Configure PDF Options - compact margin for single page fit
+    const opt = {
+        margin: [5, 5, 5, 5] as [number, number, number, number],
+        filename: filename,
+        image: { type: 'jpeg' as const, quality: 0.98 },
+        html2canvas: {
+            scale: 2,
+            useCORS: true,
+            logging: true, // Enable to debug in console
+            letterRendering: true,
+            allowTaint: true,
+            backgroundColor: '#ffffff',
+            // CRITICAL: Tell html2canvas to use the iframe's window context
+            windowWidth: contentElement.scrollWidth || 794, // ~210mm in px
+            windowHeight: contentElement.scrollHeight || 1123, // ~297mm in px
+        },
+        jsPDF: { unit: 'mm' as const, format: 'a4' as const, orientation: 'portrait' as const },
+        pagebreak: { mode: ['avoid-all'] },
+    };
+
+    // 7. Generate and Save
+    try {
+        await html2pdf().set(opt).from(contentElement).save();
+    } catch (err: any) {
+        console.error('PDF Generation failed:', err);
+        alert('PDF generation failed: ' + (err.message || 'Unknown error'));
+    } finally {
+        // 8. Cleanup
+        if (document.body.contains(iframe)) {
+            document.body.removeChild(iframe);
+        }
+    }
+}