@omersx/bemms 0.0.0-stage → 1.0.0

package/src/app/(dashboard)/tickets/page.tsx

@@ -0,0 +1,55 @@
+import { auth } from '@/lib/auth';
+import { redirect } from 'next/navigation';
+import { hasRole } from '@/lib/auth/rbac';
+import { listTickets } from "@/lib/actions/tickets";
+import { getMyTickets } from "@/lib/actions/dashboard";
+import { PageHeader } from "@/components/shared/page-header";
+import { TicketCardsView } from "@/components/tickets/ticket-cards-view";
+import { StaffTicketsView } from "@/components/tickets/staff-tickets-view";
+import { TicketListAutoRefresh } from "@/components/tickets/ticket-list-auto-refresh";
+import { TicketsNav } from "@/components/tickets/tickets-nav";
+import { Button } from "@/components/ui/button";
+import { Plus, Filter } from "lucide-react";
+import Link from "next/link";
+
+export const dynamic = 'force-dynamic';
+
+export default async function TicketsPage() {
+  const session = await auth();
+  if (!session?.user) redirect('/login');
+
+  const user = session.user as { id: string; roles: string[] };
+  const roles = user.roles || [];
+  const isBiomed = hasRole(roles, 'BIOMED_ENG', 'BIOMED_TECH', 'BIOMED_MGR');
+  const isAdmin = hasRole(roles, 'SYS_ADMIN', 'ORG_ADMIN', 'HOSP_ADMIN');
+  const isStaffOnly = hasRole(roles, 'STAFF', 'DEPT_MGR') && !isBiomed && !isAdmin;
+
+  if (isStaffOnly) {
+    // Staff view: show only their own tickets with plain-language status, search, and filters
+    const myTickets = await getMyTickets(50);
+    return (
+      <>
+        <TicketListAutoRefresh />
+        <StaffTicketsView tickets={myTickets} />
+      </>
+    );
+  }
+
+  // Full view for BME/admin
+  const result = await listTickets();
+  const tickets = (result?.success && Array.isArray(result.data)) ? result.data : [];
+
+  return (
+    <div className="space-y-6">
+      <TicketListAutoRefresh />
+      <PageHeader
+        title="Helpdesk Tickets"
+        description="Track device problems, service requests, and maintenance progress"
+      />
+
+      <TicketsNav />
+
+      <TicketCardsView tickets={tickets as any} />
+    </div>
+  );
+}

package/src/app/(dashboard)/tickets/triage/page.tsx

@@ -0,0 +1,161 @@
+import { getTriageQueue } from "@/lib/actions/tickets"
+import { PageHeader } from "@/components/shared/page-header"
+import { DataTable } from "@/components/shared/data-table"
+import { TicketsNav } from "@/components/tickets/tickets-nav"
+import { TicketStatusBadge, TicketPriorityBadge, TicketImpactBadge } from "@/components/tickets/ticket-badges"
+import { WaitingForEngineerBanner } from "@/components/tickets/ticket-dispatch-status"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { TicketListAutoRefresh } from "@/components/tickets/ticket-list-auto-refresh"
+import { AlertTriangle, Clock, Inbox, CheckCircle2, Timer } from "lucide-react"
+import Link from "next/link"
+
+export default async function TriageQueuePage() {
+  const result = await getTriageQueue()
+  const tickets = (result?.success && Array.isArray(result.data)) ? result.data : []
+
+  // Queue metrics
+  const newCount = tickets.filter((t: any) => t.statusCode === 'new').length
+  const criticalCount = tickets.filter((t: any) =>
+    t.reportedImpact === 'patient_care_affected' && t.statusCode === 'new'
+  ).length
+  const unacceptedCount = tickets.filter((t: any) =>
+    !t.assignedEngineerUserId && t.statusCode === 'new'
+  ).length
+
+  // Calculate average wait time for new tickets
+  const newTickets = tickets.filter((t: any) => t.statusCode === 'new')
+  const avgWaitHours = newTickets.length > 0
+    ? Math.round(newTickets.reduce((sum: number, t: any) => {
+        return sum + (Date.now() - new Date(t.reportedAt).getTime()) / (1000 * 60 * 60)
+      }, 0) / newTickets.length)
+    : 0
+
+  const columns = [
+    { key: "priority", header: "Priority", render: (item: any) => (
+      <TicketPriorityBadge priority={item.priorityCode} />
+    )},
+    { key: "ticketNumber", header: "Ticket #", render: (item: any) => (
+      <Link href={`/tickets/${item.id}`} className="text-primary hover:underline font-mono text-sm">
+        {item.ticketNumber}
+      </Link>
+    )},
+    { key: "title", header: "Issue", render: (item: any) => (
+      <div className="space-y-1">
+        <Link href={`/tickets/${item.id}`} className="font-medium hover:underline line-clamp-1">
+          {item.title}
+        </Link>
+        <span className="text-xs text-muted-foreground">{item.device?.name || "No device"}</span>
+        {/* Show waiting status for unaccepted tickets */}
+        {item.statusCode === 'new' && !item.assignedEngineerUserId && (
+          <div className="flex items-center gap-1 text-xs text-amber-600 dark:text-amber-400 font-medium">
+            <Clock className="w-3 h-3 animate-pulse" />
+            <span>Waiting for engineer</span>
+          </div>
+        )}
+      </div>
+    )},
+    { key: "impact", header: "Reported Impact", render: (item: any) => (
+      <TicketImpactBadge impact={item.reportedImpact} />
+    )},
+    { key: "location", header: "Location", render: (item: any) => (
+      <span className="text-sm">{item.hospital?.name} / {item.department?.name}</span>
+    )},
+    { key: "status", header: "Status", render: (item: any) => (
+      <TicketStatusBadge status={item.statusCode} />
+    )},
+    { key: "age", header: "Age", render: (item: any) => {
+      const hours = Math.floor((Date.now() - new Date(item.reportedAt).getTime()) / (1000 * 60 * 60))
+      return (
+        <span className={`text-sm flex items-center gap-1 ${hours > 24 ? 'text-red-600 dark:text-red-400 font-medium' : hours > 4 ? 'text-amber-600 dark:text-amber-400 font-medium' : 'text-muted-foreground'}`}>
+          <Clock className="w-3 h-3" />
+          {hours < 1 ? '< 1h' : `${hours}h`}
+        </span>
+      )
+    }},
+  ]
+
+  return (
+    <div className="space-y-6">
+      <TicketListAutoRefresh />
+      <PageHeader
+        title="Triage Queue"
+        description="Review, classify, and assign incoming service requests"
+      />
+
+      <TicketsNav />
+
+      {/* Queue Metrics */}
+      <div className="grid gap-3 grid-cols-2 lg:grid-cols-4">
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Awaiting Triage</CardTitle>
+            <Inbox className="h-4 w-4 text-blue-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">{newCount}</div>
+            <p className="text-xs text-muted-foreground mt-1">New tickets to review</p>
+          </CardContent>
+        </Card>
+
+        <Card className={criticalCount > 0 ? 'border-red-300 dark:border-red-800' : ''}>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Critical</CardTitle>
+            <AlertTriangle className={`h-4 w-4 ${criticalCount > 0 ? 'text-red-600 animate-pulse' : 'text-muted-foreground'}`} />
+          </CardHeader>
+          <CardContent>
+            <div className={`text-2xl font-bold ${criticalCount > 0 ? 'text-red-600' : ''}`}>
+              {criticalCount}
+            </div>
+            <p className="text-xs text-muted-foreground mt-1">Patient care affected</p>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Unaccepted</CardTitle>
+            <Timer className="h-4 w-4 text-amber-500" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold">{unacceptedCount}</div>
+            <p className="text-xs text-muted-foreground mt-1">No engineer assigned yet</p>
+          </CardContent>
+        </Card>
+
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+            <CardTitle className="text-sm font-medium">Avg Wait</CardTitle>
+            <Clock className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className={`text-2xl font-bold ${avgWaitHours > 24 ? 'text-red-600' : avgWaitHours > 4 ? 'text-amber-600' : ''}`}>
+              {avgWaitHours}h
+            </div>
+            <p className="text-xs text-muted-foreground mt-1">Average queue time</p>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Critical Alert */}
+      {criticalCount > 0 && (
+        <div className="bg-red-50 dark:bg-red-950/30 border border-red-300 dark:border-red-800 rounded-lg p-4 flex items-start gap-3">
+          <AlertTriangle className="w-5 h-5 text-red-600 mt-0.5 shrink-0 animate-pulse" />
+          <div>
+            <h3 className="font-semibold text-red-800 dark:text-red-200">
+              {criticalCount} Critical Ticket{criticalCount > 1 ? 's' : ''} Awaiting Triage
+            </h3>
+            <p className="text-sm text-red-700 dark:text-red-300">
+              Tickets marked as affecting patient care require immediate attention. Please review and accept now.
+            </p>
+          </div>
+        </div>
+      )}
+
+      <DataTable
+        data={tickets}
+        columns={columns}
+        searchKey="title"
+        searchPlaceholder="Filter queue..."
+      />
+    </div>
+  )
+}

package/src/app/api/admin/data/export/route.ts

@@ -0,0 +1,316 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { requireAuth, requireRole } from '@/lib/auth/rbac';
+import { db } from '@/lib/db';
+import { generateCSV } from '@/lib/utils/export';
+import * as XLSX from 'xlsx';
+
+export async function GET(req: NextRequest) {
+  try {
+    const session = await requireAuth();
+    await requireRole('SYS_ADMIN', 'ORG_ADMIN', 'BIOMED_MGR', 'BIOMED_ENG');
+
+    const searchParams = req.nextUrl.searchParams;
+    const entityParam = searchParams.get('entities') || 'devices';
+    const format = (searchParams.get('format') || 'csv').toLowerCase();
+
+    const selectedEntities = entityParam.split(',').map((e) => e.trim());
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+
+    if (format === 'json') {
+      const exportPayload: Record<string, any> = {
+        metadata: {
+          system: 'BEMMS Medical Equipment Management System',
+          exportedAt: new Date().toISOString(),
+          exportedBy: session.email,
+          entities: selectedEntities,
+        },
+        data: {},
+      };
+
+      if (selectedEntities.includes('devices')) {
+        exportPayload.data.devices = await db.query.devices.findMany({
+          with: {
+            deviceCategory: true,
+            manufacturer: true,
+            department: true,
+          },
+        });
+      }
+
+      if (selectedEntities.includes('departments')) {
+        exportPayload.data.departments = await db.query.departments.findMany();
+      }
+
+      if (selectedEntities.includes('catalogs')) {
+        exportPayload.data.categories = await db.query.deviceCategories.findMany();
+        exportPayload.data.manufacturers = await db.query.manufacturers.findMany();
+      }
+
+      if (selectedEntities.includes('tickets')) {
+        exportPayload.data.tickets = await db.query.serviceTickets.findMany({
+          with: { device: true },
+        });
+      }
+
+      if (selectedEntities.includes('audit_logs')) {
+        exportPayload.data.auditLogs = await db.query.auditLogs.findMany({
+          limit: 1000,
+        });
+      }
+
+      if (selectedEntities.includes('rounds')) {
+        exportPayload.data.engineerRounds = await db.query.engineerRounds.findMany({
+          with: {
+            engineer: { columns: { id: true, fullName: true, email: true } },
+            hospital: { columns: { id: true, name: true } },
+            departmentVisits: {
+              with: {
+                department: { columns: { id: true, name: true, code: true } },
+                notes: true,
+              },
+            },
+          },
+        });
+      }
+
+      return new NextResponse(JSON.stringify(exportPayload, null, 2), {
+        headers: {
+          'Content-Type': 'application/json; charset=utf-8',
+          'Content-Disposition': `attachment; filename="bemms_export_${timestamp}.json"`,
+        },
+      });
+    }
+
+    if (format === 'xlsx') {
+      const wb = XLSX.utils.book_new();
+
+      if (selectedEntities.includes('devices')) {
+        const rawDevices = await db.query.devices.findMany({
+          with: { deviceCategory: true, manufacturer: true, department: true },
+        });
+        const formatted = rawDevices.map((d) => ({
+          'Asset Number': d.assetNumber,
+          'Device Name': d.name,
+          'Model': d.modelNameFree || '',
+          'Serial Number': d.serialNumber || '',
+          'Category': d.deviceCategory?.name || '',
+          'Manufacturer': d.manufacturer?.name || '',
+          'Department': d.department?.name || '',
+          'Location': d.exactLocationDescription || '',
+          'Status': d.currentStatusCode,
+          'Criticality': d.criticalityLevel || 'medium',
+          'Risk Class': d.riskClassification || '',
+        }));
+        const ws = XLSX.utils.json_to_sheet(formatted);
+        XLSX.utils.book_append_sheet(wb, ws, 'Devices');
+      }
+
+      if (selectedEntities.includes('departments')) {
+        const rawDeps = await db.query.departments.findMany({
+          with: { hospital: true },
+        });
+        const formatted = rawDeps.map((d) => ({
+          'Department Name': d.name,
+          'Code': d.code,
+          'Department Type': d.departmentType,
+          'Hospital Name': d.hospital?.name || '',
+          'Status': d.status || 'active',
+          'Created At': d.createdAt?.toISOString() || '',
+        }));
+        const ws = XLSX.utils.json_to_sheet(formatted);
+        XLSX.utils.book_append_sheet(wb, ws, 'Departments');
+      }
+
+      if (selectedEntities.includes('rounds')) {
+        const rawRounds = await db.query.engineerRounds.findMany({
+          with: {
+            engineer: true,
+            hospital: true,
+            departmentVisits: {
+              with: {
+                notes: true,
+              },
+            },
+          },
+        });
+
+        const formatted = rawRounds.map((r) => ({
+          'Round Date': r.roundDate,
+          'Shift': r.shiftType,
+          'Engineer': r.engineer?.fullName || '',
+          'Hospital': r.hospital?.name || '',
+          'Status': r.status,
+          'Started At': r.startedAt?.toISOString() || '',
+          'Completed At': r.completedAt?.toISOString() || '',
+          'Total Departments': r.totalDepartments,
+          'Completed Departments': r.completedDepartments,
+          'Issues Reported': r.totalIssuesReported,
+          'Total Notes': r.totalNotes,
+        }));
+        const ws = XLSX.utils.json_to_sheet(formatted);
+        XLSX.utils.book_append_sheet(wb, ws, 'Daily Rounds');
+
+        const visitRows: any[] = [];
+        for (const r of rawRounds) {
+          for (const v of r.departmentVisits || []) {
+            const notesText = (v.notes || []).map((n: any) => n.noteText).join(' | ');
+            visitRows.push({
+              'Round Date': r.roundDate,
+              'Engineer': r.engineer?.fullName || '',
+              'Department': v.departmentName,
+              'Sequence': v.sequence,
+              'Status': v.status,
+              'Started At': v.startedAt?.toISOString() || '',
+              'Completed At': v.completedAt?.toISOString() || '',
+              'Notes': notesText,
+            });
+          }
+        }
+        if (visitRows.length > 0) {
+          const wsVisits = XLSX.utils.json_to_sheet(visitRows);
+          XLSX.utils.book_append_sheet(wb, wsVisits, 'Department Visits');
+        }
+      }
+
+      const buf = XLSX.write(wb, { type: 'buffer', bookType: 'xlsx' });
+      return new NextResponse(buf, {
+        headers: {
+          'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+          'Content-Disposition': `attachment; filename="bemms_export_${timestamp}.xlsx"`,
+        },
+      });
+    }
+
+    if (format === 'csv') {
+      if (selectedEntities.includes('departments') && !selectedEntities.includes('devices')) {
+        const rawDeps = await db.query.departments.findMany({
+          with: { hospital: true },
+        });
+
+        const formatted = rawDeps.map((d) => ({
+          name: d.name,
+          code: d.code,
+          type: d.departmentType,
+          hospital: d.hospital?.name || '',
+          status: d.status || 'active',
+          createdAt: d.createdAt?.toISOString() || '',
+        }));
+
+        const columns = [
+          { key: 'name', header: 'Department Name' },
+          { key: 'code', header: 'Code' },
+          { key: 'type', header: 'Department Type' },
+          { key: 'hospital', header: 'Hospital Name' },
+          { key: 'status', header: 'Status' },
+          { key: 'createdAt', header: 'Created At' },
+        ];
+
+        const csvContent = generateCSV(formatted, columns);
+
+        return new NextResponse(csvContent, {
+          headers: {
+            'Content-Type': 'text/csv; charset=utf-8',
+            'Content-Disposition': `attachment; filename="bemms_departments_${timestamp}.csv"`,
+          },
+        });
+      }
+
+      if (selectedEntities.includes('rounds')) {
+        const rawRounds = await db.query.engineerRounds.findMany({
+          with: { engineer: true, hospital: true },
+        });
+
+        const formatted = rawRounds.map((r) => ({
+          roundDate: r.roundDate,
+          shiftType: r.shiftType,
+          engineerName: r.engineer?.fullName || '',
+          hospitalName: r.hospital?.name || '',
+          status: r.status,
+          startedAt: r.startedAt?.toISOString() || '',
+          completedAt: r.completedAt?.toISOString() || '',
+          totalDepartments: r.totalDepartments,
+          completedDepartments: r.completedDepartments,
+          totalIssuesReported: r.totalIssuesReported,
+          totalNotes: r.totalNotes,
+        }));
+
+        const columns = [
+          { key: 'roundDate', header: 'Round Date' },
+          { key: 'shiftType', header: 'Shift' },
+          { key: 'engineerName', header: 'Engineer Name' },
+          { key: 'hospitalName', header: 'Hospital' },
+          { key: 'status', header: 'Status' },
+          { key: 'startedAt', header: 'Started At' },
+          { key: 'completedAt', header: 'Completed At' },
+          { key: 'totalDepartments', header: 'Total Depts' },
+          { key: 'completedDepartments', header: 'Completed Depts' },
+          { key: 'totalIssuesReported', header: 'Issues Reported' },
+          { key: 'totalNotes', header: 'Notes' },
+        ];
+
+        const csvContent = generateCSV(formatted, columns);
+
+        return new NextResponse(csvContent, {
+          headers: {
+            'Content-Type': 'text/csv; charset=utf-8',
+            'Content-Disposition': `attachment; filename="bemms_engineer_rounds_${timestamp}.csv"`,
+          },
+        });
+      }
+
+      // Default to devices
+      const rawDevices = await db.query.devices.findMany({
+        with: {
+          deviceCategory: true,
+          manufacturer: true,
+          department: true,
+        },
+      });
+
+      const formatted = rawDevices.map((d) => ({
+        assetNumber: d.assetNumber,
+        name: d.name,
+        model: d.modelNameFree || '',
+        serialNumber: d.serialNumber || '',
+        category: d.deviceCategory?.name || '',
+        manufacturer: d.manufacturer?.name || '',
+        department: d.department?.name || '',
+        location: d.exactLocationDescription || '',
+        status: d.currentStatusCode,
+        criticality: d.criticalityLevel || 'medium',
+        riskClassification: d.riskClassification || '',
+      }));
+
+      const columns = [
+        { key: 'assetNumber', header: 'Asset Number' },
+        { key: 'name', header: 'Device Name' },
+        { key: 'model', header: 'Model' },
+        { key: 'serialNumber', header: 'Serial Number' },
+        { key: 'category', header: 'Category' },
+        { key: 'manufacturer', header: 'Manufacturer' },
+        { key: 'department', header: 'Department' },
+        { key: 'location', header: 'Location' },
+        { key: 'status', header: 'Status' },
+        { key: 'criticality', header: 'Criticality' },
+        { key: 'riskClassification', header: 'Risk Class' },
+      ];
+
+      const csvContent = generateCSV(formatted, columns);
+
+      return new NextResponse(csvContent, {
+        headers: {
+          'Content-Type': 'text/csv; charset=utf-8',
+          'Content-Disposition': `attachment; filename="bemms_devices_${timestamp}.csv"`,
+        },
+      });
+    }
+
+    return new NextResponse('Export complete', { status: 200 });
+  } catch (error: any) {
+    return new NextResponse(JSON.stringify({ error: error.message || 'Export failed' }), {
+      status: 500,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+}
+

package/src/app/api/auth/[...nextauth]/route.ts

@@ -0,0 +1,3 @@
+import { handlers } from '@/lib/auth';
+
+export const { GET, POST } = handlers;

package/src/app/api/health/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { db } from '@/lib/db';
+import { sql } from 'drizzle-orm';
+import { getLogger } from '@/lib/logger';
+
+const log = getLogger('health');
+
+/**
+ * Production health check endpoint.
+ * Used by Docker HEALTHCHECK, load balancers, and monitoring tools.
+ * Returns 200 if the app and database are healthy, 503 otherwise.
+ */
+export async function GET() {
+  const startTime = Date.now();
+
+  try {
+    // Check database connectivity
+    await db.execute(sql`SELECT 1`);
+
+    const responseTime = Date.now() - startTime;
+
+    return NextResponse.json(
+      {
+        status: 'healthy',
+        timestamp: new Date().toISOString(),
+        uptime: process.uptime(),
+        database: 'connected',
+        responseTimeMs: responseTime,
+      },
+      { status: 200 }
+    );
+  } catch (error: any) {
+    const responseTime = Date.now() - startTime;
+    log.error('Health check failed', error);
+
+    return NextResponse.json(
+      {
+        status: 'unhealthy',
+        timestamp: new Date().toISOString(),
+        database: 'disconnected',
+        responseTimeMs: responseTime,
+      },
+      { status: 503 }
+    );
+  }
+}

package/src/app/api/notifications/sse/route.ts

@@ -0,0 +1,91 @@
+import { NextRequest } from 'next/server';
+import { auth } from '@/lib/auth';
+import { db } from '@/lib/db';
+import { notifications } from '@/lib/db/schema';
+import { eq, and, isNull, desc, sql, gt } from 'drizzle-orm';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET(req: NextRequest) {
+  const session = await auth();
+  if (!session?.user?.id) {
+    return new Response('Unauthorized', { status: 401 });
+  }
+
+  const userId = (session.user as any).id;
+
+  const encoder = new TextEncoder();
+  let intervalId: NodeJS.Timeout;
+  let lastChecked = new Date();
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const poll = async () => {
+        try {
+          // 1. Send unread count
+          const countResult = await db.select({
+            count: sql<number>`count(*)::int`,
+          })
+          .from(notifications)
+          .where(and(
+            eq(notifications.recipientUserId, userId),
+            isNull(notifications.readAt),
+          ));
+
+          const count = countResult[0]?.count || 0;
+          const countData = `data: ${JSON.stringify({ type: 'unread_count', count })}\n\n`;
+          controller.enqueue(encoder.encode(countData));
+
+          // 2. Check for new notifications since last poll
+          const newNotifications = await db.select({
+            id: notifications.id,
+            notificationType: notifications.notificationType,
+            title: notifications.title,
+            body: notifications.body,
+            actionUrl: notifications.actionUrl,
+            relatedEntityType: notifications.relatedEntityType,
+            relatedEntityId: notifications.relatedEntityId,
+            createdAt: notifications.createdAt,
+          })
+          .from(notifications)
+          .where(and(
+            eq(notifications.recipientUserId, userId),
+            gt(notifications.createdAt, lastChecked),
+          ))
+          .orderBy(desc(notifications.createdAt))
+          .limit(5);
+
+          if (newNotifications.length > 0) {
+            const eventData = `data: ${JSON.stringify({
+              type: 'new_notifications',
+              notifications: newNotifications,
+            })}\n\n`;
+            controller.enqueue(encoder.encode(eventData));
+          }
+
+          lastChecked = new Date();
+        } catch (error) {
+          // Connection closed
+          clearInterval(intervalId);
+        }
+      };
+
+      // Send immediately
+      poll();
+
+      // Poll every 5 seconds for faster real-time feel
+      intervalId = setInterval(poll, 5000);
+    },
+    cancel() {
+      clearInterval(intervalId);
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+}