// ui/src/lib/cache.ts
const FRESH_TTL = 90_000;       // 90 s — return + no bg refresh
const STALE_TTL = 5 * 60_000;  // 5 min — return stale + bg refresh
const BG_REFRESHES = new Set<string>();

interface CacheEntry { data: unknown; timestamp: number }
const cache = new Map<string, CacheEntry>();
const pendingRequests = new Map<string, Promise<unknown>>();

export function generateCacheKey(endpoint: string, params?: Record<string, unknown>): string {
  if (!params) return endpoint;
  const sorted = Object.keys(params).sort().map(k => `${k}=${JSON.stringify(params[k])}`).join('&');
  return `${endpoint}?${sorted}`;
}

const CACHEABLE = [
  '/api/v1/protected/patients',
  '/api/v1/protected/appointments',
  '/api/v1/protected/clinic/stats',
  '/api/v1/protected/staff',
  '/api/v1/protected/inventory',
  '/api/v1/protected/lab-cases',
  '/api/v1/protected/laboratories',
  '/api/v1/protected/lab-services',
  '/api/v1/protected/services',
  '/api/v1/protected/expenses',
  '/api/v1/protected/suppliers',
];

export function shouldCache(endpoint: string): boolean {
  return CACHEABLE.some(p => endpoint.includes(p));
}

export function getCached<T>(key: string): { data: T; stale: boolean } | null {
  const entry = cache.get(key);
  if (!entry) return null;
  const age = Date.now() - entry.timestamp;
  if (age > STALE_TTL) { cache.delete(key); return null; }
  return { data: entry.data as T, stale: age > FRESH_TTL };
}

export function setCached<T>(key: string, data: T): void {
  cache.set(key, { data, timestamp: Date.now() });
}

export function invalidateCache(pattern?: string): void {
  if (!pattern) { cache.clear(); return; }
  const wildcard = pattern.endsWith('*');
  const base = wildcard ? pattern.slice(0, -1) : pattern;
  for (const key of cache.keys()) {
    if (wildcard ? key.startsWith(base) : key === pattern) cache.delete(key);
  }
}

export function clearCache(): void { cache.clear(); }

export function deduplicateRequest<T>(key: string, fn: () => Promise<T>): Promise<T> {
  const pending = pendingRequests.get(key);
  if (pending) return pending as Promise<T>;
  const promise = fn().finally(() => pendingRequests.delete(key));
  pendingRequests.set(key, promise);
  return promise;
}

export function isBgRefreshing(key: string): boolean { return BG_REFRESHES.has(key); }
export function markBgRefresh(key: string): void    { BG_REFRESHES.add(key); }
export function doneBgRefresh(key: string): void    { BG_REFRESHES.delete(key); }

const method = options.method || 'GET';
// ...
const useCache = shouldCache(method);   // <-- BUG: passes method not endpoint

const method = options.method || 'GET';
// ...
const useCache = shouldCache(endpoint); // FIXED: pass endpoint

if (shouldUseCache) {
  const cached = getCached<{ status: number; statusText: string; headers: Record<string, string>; body: string }>(cacheKey);
  if (cached) {
    // Don't serve cached 401/403 responses - they might be stale
    if (cached.status === 401 || cached.status === 403) {
      invalidateCache(cacheKey);
    } else {
      // Return cached response
      return new Response(cached.body, {
        status: cached.status,
        statusText: cached.statusText,
        headers: cached.headers,
      });
    }
  }
}

if (shouldUseCache) {
  const cached = getCached<{ status: number; statusText: string; headers: Record<string, string>; body: string }>(cacheKey);
  if (cached) {
    if (cached.data.status === 401 || cached.data.status === 403) {
      invalidateCache(cacheKey);
      // fall through to fresh fetch
    } else {
      // SWR: if stale, kick off background refresh
      if (cached.stale && !isBgRefreshing(cacheKey)) {
        markBgRefresh(cacheKey);
        void (async () => {
          try {
            const freshHeaders = new Headers({ Authorization: token ? `Bearer ${token}` : '' });
            const bgResp = await fetch(fullUrl, { method: 'GET', headers: freshHeaders, credentials: 'include' });
            if (bgResp.ok) {
              const bgHeaders: Record<string, string> = {};
              bgResp.headers.forEach((v, k) => { bgHeaders[k] = v; });
              const bgBody = await bgResp.text();
              setCached(cacheKey, { status: bgResp.status, statusText: bgResp.statusText, headers: bgHeaders, body: bgBody });
            } else if (bgResp.status === 401) {
              invalidateCache(cacheKey); // let next foreground request handle auth
            }
            // other errors: keep stale data
          } catch { /* network error — keep stale */ } finally {
            doneBgRefresh(cacheKey);
          }
        })();
      }
      return new Response(cached.data.body, {
        status: cached.data.status,
        statusText: cached.data.statusText,
        headers: cached.data.headers,
      });
    }
  }
}

cd /Users/ssh/Documents/Beta-App/odontoX/ui && npx tsc --noEmit

git add ui/src/lib/cache.ts ui/src/lib/serverComm.ts
git commit -m "perf(ui): fix broken SWR cache — shouldCache(endpoint) not method, add 90s stale-while-revalidate"

getClinicalNotesByPatient(data.patientId).then(notes => setClinicalNotes(notes.sort((a, b) => new Date(b.visitDate).getTime() - new Date(a.visitDate).getTime()))).catch(() => {});

if (has('clinical.notes.view')) {
  getClinicalNotesByPatient(data.patientId)
    .then(notes => setClinicalNotes(notes.sort((a, b) => new Date(b.visitDate).getTime() - new Date(a.visitDate).getTime())))
    .catch(() => {});
}

if (activeTab === 'treatments' || activeTab === 'overview') {
  const [notes, plans] = await Promise.all([
    import('@/lib/serverComm').then(m => m.getClinicalNotesByPatient(patient.id)),
    import('@/lib/serverComm').then(m => m.getTreatmentPlans(patient.id))
  ]);
  setClinicalNotes(notes);
  setTreatmentPlans(plans);
}

if (activeTab === 'treatments' || activeTab === 'overview') {
  const [notes, plans] = await Promise.all([
    isReceptionist
      ? Promise.resolve([])
      : import('@/lib/serverComm').then(m => m.getClinicalNotesByPatient(patient.id)),
    import('@/lib/serverComm').then(m => m.getTreatmentPlans(patient.id))
  ]);
  setClinicalNotes(notes);
  setTreatmentPlans(plans);
}

cd /Users/ssh/Documents/Beta-App/odontoX/ui && npx tsc --noEmit

git add ui/src/components/appointments/AppointmentDetailPage.tsx ui/src/components/patients/PatientDetails.tsx
git commit -m "fix(ui): guard clinical notes fetch behind permission — stops 403 spam for reception role"

notificationPreferences: jsonb('notification_preferences').$type<{
  stockAlertEmailEnabled?: boolean;
  eodEmailEnabled?: boolean;
}>(),

emailSentAt: timestamp('email_sent_at'),

cd /Users/ssh/Documents/Beta-App/odontoX/server && npm run db:push

cd /Users/ssh/Documents/Beta-App/odontoX/server && npx tsc --noEmit

git add server/src/schema/clinics.ts server/src/schema/inventory_alerts.ts
git commit -m "feat(schema): add notificationPreferences to clinics, emailSentAt to inventory_alerts"

// ui/src/components/inventory/InventoryItemFormPage.tsx
import { useEffect, useState } from 'react';
import { ChevronLeft } from 'lucide-react';
import { Button } from '@/components/ui/button';
import { Input } from '@/components/ui/input';
import { Label } from '@/components/ui/label';
import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
import { Skeleton } from '@/components/ui/skeleton';
import { toast } from 'sonner';
import {
  createInventoryItem,
  updateInventoryItem,
  getInventoryItems,
  getLaboratories,
  type InventoryItem,
  type CreateInventoryItemDto,
  type Laboratory,
} from '@/lib/serverComm';
import { numberOrUndefined, numberOrZero, parseNumberInput, type NumberInputValue } from '@/lib/number-input';

interface Props {
  itemId: 'new' | string;
  onBack: () => void;
}

type FormState = {
  name: string;
  category: string;
  sku: string;
  quantity: NumberInputValue;
  unit: string;
  minStock: NumberInputValue;
  maxStock: NumberInputValue;
  reorderPoint: NumberInputValue;
  reorderQuantity: NumberInputValue;
  unitCost: NumberInputValue;
  supplier: string;
  expiryDate: string;
  location: string;
};

const EMPTY: FormState = {
  name: '', category: 'supplies', sku: '', quantity: '', unit: 'piece',
  minStock: '', maxStock: '', reorderPoint: '', reorderQuantity: '',
  unitCost: '', supplier: '', expiryDate: '', location: '',
};

export default function InventoryItemFormPage({ itemId, onBack }: Props) {
  const isNew = itemId === 'new';
  const [form, setForm] = useState<FormState>(EMPTY);
  const [labs, setLabs] = useState<Laboratory[]>([]);
  const [loadingItem, setLoadingItem] = useState(!isNew);
  const [saving, setSaving] = useState(false);

  // Load labs for supplier dropdown
  useEffect(() => {
    getLaboratories().then(setLabs).catch(() => {});
  }, []);

  // Load existing item for edit
  useEffect(() => {
    if (isNew) return;
    setLoadingItem(true);
    getInventoryItems()
      .then(items => {
        const item = items.find((i: InventoryItem) => i.id === itemId);
        if (!item) { toast.error('Item not found'); onBack(); return; }
        setForm({
          name: item.name || '',
          category: item.category || 'supplies',
          sku: item.sku || '',
          quantity: item.quantity ?? '',
          unit: item.unit || 'piece',
          minStock: item.minStock ?? '',
          maxStock: item.maxStock ?? '',
          reorderPoint: (item.reorderPoint ?? '') as NumberInputValue,
          reorderQuantity: (item.reorderQuantity ?? '') as NumberInputValue,
          unitCost: item.unitCost ? Number(item.unitCost) : '',
          supplier: item.supplier || '',
          expiryDate: item.expiryDate || '',
          location: item.location || '',
        });
      })
      .catch(() => { toast.error('Failed to load item'); onBack(); })
      .finally(() => setLoadingItem(false));
  }, [itemId, isNew, onBack]);

  const set = (key: keyof FormState, value: unknown) =>
    setForm(prev => ({ ...prev, [key]: value }));

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    if (!form.name.trim()) { toast.error('Name is required'); return; }
    try {
      setSaving(true);
      const payload: CreateInventoryItemDto = {
        name: form.name.trim(),
        category: form.category || undefined,
        sku: form.sku.trim() || undefined,
        quantity: numberOrZero(form.quantity),
        unit: form.unit || undefined,
        minStock: numberOrUndefined(form.minStock),
        maxStock: numberOrUndefined(form.maxStock),
        reorderPoint: numberOrUndefined(form.reorderPoint),
        reorderQuantity: numberOrUndefined(form.reorderQuantity),
        unitCost: form.unitCost === '' ? undefined : String(numberOrZero(form.unitCost)),
        supplier: form.supplier.trim() || undefined,
        expiryDate: form.expiryDate.trim() || undefined,
        location: form.location.trim() || undefined,
      };
      if (isNew) {
        await createInventoryItem(payload);
        toast.success('Item added');
      } else {
        await updateInventoryItem(itemId, payload);
        toast.success('Item updated');
      }
      onBack();
    } catch (err) {
      toast.error(err instanceof Error ? err.message : 'Failed to save item');
    } finally {
      setSaving(false);
    }
  };

  if (loadingItem) {
    return (
      <div className="space-y-6">
        <Skeleton className="h-8 w-48" />
        <div className="grid grid-cols-2 gap-4">
          {[1,2,3,4,5,6].map(i => <Skeleton key={i} className="h-16 w-full" />)}
        </div>
      </div>
    );
  }

  return (
    <div className="space-y-6 max-w-3xl">
      <div className="flex items-center gap-3">
        <Button variant="ghost" size="sm" onClick={onBack} className="gap-1 -ml-1">
          <ChevronLeft className="h-4 w-4" />
          Back
        </Button>
        <div>
          <h1 className="text-xl font-bold">{isNew ? 'New inventory item' : 'Edit inventory item'}</h1>
          <p className="text-sm text-muted-foreground">
            {isNew ? 'Add a new item to the clinic inventory.' : 'Update details for this item.'}
          </p>
        </div>
      </div>

      <form onSubmit={handleSubmit} className="space-y-6">
        {/* Row 1 */}
        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
          <div className="space-y-1.5">
            <Label htmlFor="inv-name" className="text-xs">Item name *</Label>
            <Input id="inv-name" value={form.name} onChange={e => set('name', e.target.value)} required placeholder="e.g., Nitrile Gloves (M)" />
          </div>
          <div className="space-y-1.5">
            <Label htmlFor="inv-sku" className="text-xs">SKU</Label>
            <Input id="inv-sku" value={form.sku} onChange={e => set('sku', e.target.value)} placeholder="Auto-generated if empty" />
          </div>
        </div>

        {/* Row 2 */}
        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
          <div className="space-y-1.5">
            <Label className="text-xs">Category</Label>
            <Select value={form.category} onValueChange={v => set('category', v)}>
              <SelectTrigger><SelectValue /></SelectTrigger>
              <SelectContent>
                <SelectItem value="supplies">Supplies</SelectItem>
                <SelectItem value="medications">Medications</SelectItem>
                <SelectItem value="equipment">Equipment</SelectItem>
                <SelectItem value="materials">Materials</SelectItem>
              </SelectContent>
            </Select>
          </div>
          <div className="space-y-1.5">
            <Label className="text-xs">Supplier / Lab</Label>
            {labs.length > 0 ? (
              <Select value={form.supplier} onValueChange={v => set('supplier', v)}>
                <SelectTrigger><SelectValue placeholder="Select lab or supplier" /></SelectTrigger>
                <SelectContent>
                  {labs.map(lab => (
                    <SelectItem key={lab.id} value={lab.name}>{lab.name}</SelectItem>
                  ))}
                  <SelectItem value="__other__">Other (type below)</SelectItem>
                </SelectContent>
              </Select>
            ) : (
              <Input
                value={form.supplier}
                onChange={e => set('supplier', e.target.value)}
                placeholder="Supplier name — or add labs in Settings"
              />
            )}
            {labs.length > 0 && form.supplier === '__other__' && (
              <Input
                className="mt-1.5"
                value={''}
                onChange={e => set('supplier', e.target.value)}
                placeholder="Enter supplier name"
                autoFocus
              />
            )}
          </div>
        </div>

        {/* Row 3 */}
        <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
          <div className="space-y-1.5">
            <Label htmlFor="inv-qty" className="text-xs">Opening quantity *</Label>
            <Input id="inv-qty" type="number" min={0} value={form.quantity}
              onChange={e => set('quantity', parseNumberInput(e.target.value))} required />
          </div>
          <div className="space-y-1.5">
            <Label className="text-xs">Unit</Label>
            <Select value={form.unit} onValueChange={v => set('unit', v)}>
              <SelectTrigger><SelectValue /></SelectTrigger>
              <SelectContent>
                <SelectItem value="piece">Piece</SelectItem>
                <SelectItem value="box">Box</SelectItem>
                <SelectItem value="pack">Pack</SelectItem>
                <SelectItem value="bottle">Bottle</SelectItem>
                <SelectItem value="kit">Kit</SelectItem>
                <SelectItem value="roll">Roll</SelectItem>
              </SelectContent>
            </Select>
          </div>
          <div className="space-y-1.5">
            <Label htmlFor="inv-cost" className="text-xs">Unit cost</Label>
            <Input id="inv-cost" type="number" min={0} step="0.01" value={form.unitCost}
              onChange={e => set('unitCost', parseNumberInput(e.target.value))} />
          </div>
        </div>

        {/* Row 4 — stock thresholds */}
        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
          <div className="space-y-1.5">
            <Label htmlFor="inv-reorder" className="text-xs">Reorder point</Label>
            <Input id="inv-reorder" type="number" min={0} value={form.reorderPoint}
              onChange={e => set('reorderPoint', parseNumberInput(e.target.value))}
              placeholder="Triggers low-stock alert email" />
          </div>
          <div className="space-y-1.5">
            <Label htmlFor="inv-reorderqty" className="text-xs">Reorder quantity</Label>
            <Input id="inv-reorderqty" type="number" min={0} value={form.reorderQuantity}
              onChange={e => set('reorderQuantity', parseNumberInput(e.target.value))}
              placeholder="Suggested order size" />
          </div>
        </div>

        {/* Row 5 */}
        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
          <div className="space-y-1.5">
            <Label htmlFor="inv-minstock" className="text-xs">Min stock</Label>
            <Input id="inv-minstock" type="number" min={0} value={form.minStock}
              onChange={e => set('minStock', parseNumberInput(e.target.value))} />
          </div>
          <div className="space-y-1.5">
            <Label htmlFor="inv-maxstock" className="text-xs">Max stock</Label>
            <Input id="inv-maxstock" type="number" min={0} value={form.maxStock}
              onChange={e => set('maxStock', parseNumberInput(e.target.value))} />
          </div>
        </div>

        {/* Row 6 */}
        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
          <div className="space-y-1.5">
            <Label htmlFor="inv-expiry" className="text-xs">Expiry date</Label>
            <Input id="inv-expiry" type="date" value={form.expiryDate}
              onChange={e => set('expiryDate', e.target.value)} />
          </div>
          <div className="space-y-1.5">
            <Label htmlFor="inv-location" className="text-xs">Storage location</Label>
            <Input id="inv-location" value={form.location}
              onChange={e => set('location', e.target.value)}
              placeholder="e.g., Cabinet A, Shelf 2" />
          </div>
        </div>

        <div className="flex items-center gap-3 pt-2">
          <Button type="submit" disabled={saving}>
            {saving ? 'Saving…' : isNew ? 'Add item' : 'Save changes'}
          </Button>
          <Button type="button" variant="outline" onClick={onBack} disabled={saving}>Cancel</Button>
        </div>
      </form>
    </div>
  );
}

cd /Users/ssh/Documents/Beta-App/odontoX/ui && npx tsc --noEmit

git add ui/src/components/inventory/InventoryItemFormPage.tsx
git commit -m "feat(inventory): create InventoryItemFormPage — full-page create/edit with lab preset dropdown"

import InventoryItemDialog from './InventoryItemDialog';
// remove: editItem, itemDialogOpen state declarations

import InventoryItemFormPage from './InventoryItemFormPage';

onClick={() => {
  setEditItem(null);
  setItemDialogOpen(true);
}}

onClick={() => setSearchParams({ item: 'new' })}

onClick={() => {
  setEditItem(item);
  setItemDialogOpen(true);
}}

onClick={(e) => { e.stopPropagation(); setSearchParams({ item: item.id, edit: '1' }); }}

// BEFORE
if (itemId) {
  return <InventoryItemPage itemId={itemId} onBack={backToList} />;
}

// AFTER — also handle 'new' and edit flag
const editFlag = searchParams.get('edit');
if (itemId === 'new' || (itemId && editFlag === '1')) {
  return <InventoryItemFormPage itemId={itemId} onBack={backToList} />;
}
if (itemId) {
  return <InventoryItemPage itemId={itemId} onBack={backToList} />;
}

import InventoryItemDialog from './InventoryItemDialog';

// find the Edit button state: itemDialogOpen, editingItem
// replace with:
<Button
  variant="outline"
  size="sm"
  onClick={() => setSearchParams({ item: itemId, edit: '1' })}
>
  <Edit2 className="h-4 w-4 mr-1.5" />
  Edit item
</Button>

rm /Users/ssh/Documents/Beta-App/odontoX/ui/src/components/inventory/InventoryItemDialog.tsx

cd /Users/ssh/Documents/Beta-App/odontoX/ui && npx tsc --noEmit

git add -u ui/src/components/inventory/
git commit -m "feat(inventory): new/edit item uses full page, remove InventoryItemDialog modal"

export interface NotificationPreferences {
  stockAlertEmailEnabled?: boolean;
  eodEmailEnabled?: boolean;
}

export async function updateClinicNotificationPrefs(prefs: NotificationPreferences): Promise<void> {
  const response = await fetchWithAuth('/api/v1/protected/clinic', {
    method: 'PATCH',
    body: JSON.stringify({ notificationPreferences: prefs }),
  });
  if (!response.ok) throw new Error('Failed to update notification preferences');
}

export async function getClinicNotificationPrefs(): Promise<NotificationPreferences> {
  const details = await getClinicDetails();
  return (details as any).notificationPreferences ?? {};
}

// ui/src/components/settings/NotificationSettings.tsx
import { useEffect, useState } from 'react';
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
import { Switch } from '@/components/ui/switch';
import { Label } from '@/components/ui/label';
import { toast } from 'sonner';
import { Bell, Package, FileText } from 'lucide-react';
import { getClinicNotificationPrefs, updateClinicNotificationPrefs, type NotificationPreferences } from '@/lib/serverComm';

export default function NotificationSettings() {
  const [prefs, setPrefs] = useState<NotificationPreferences>({});
  const [loading, setLoading] = useState(true);
  const [saving, setSaving] = useState<string | null>(null);

  useEffect(() => {
    getClinicNotificationPrefs()
      .then(setPrefs)
      .catch(() => {})
      .finally(() => setLoading(false));
  }, []);

  const toggle = async (key: keyof NotificationPreferences) => {
    const updated = { ...prefs, [key]: !prefs[key] };
    setPrefs(updated);
    setSaving(key);
    try {
      await updateClinicNotificationPrefs(updated);
      toast.success('Preference saved');
    } catch {
      setPrefs(prefs); // rollback
      toast.error('Failed to save preference');
    } finally {
      setSaving(null);
    }
  };

  return (
    <div className="space-y-6">
      <div>
        <h2 className="text-lg font-semibold flex items-center gap-2">
          <Bell className="h-5 w-5" /> Email Notifications
        </h2>
        <p className="text-sm text-muted-foreground mt-1">
          Opt in to automated email alerts sent to all clinic admins.
        </p>
      </div>

      <Card>
        <CardHeader className="pb-3">
          <CardTitle className="text-sm flex items-center gap-2">
            <Package className="h-4 w-4" /> Inventory — Low stock alerts
          </CardTitle>
          <CardDescription className="text-xs">
            Email all admins when an item's quantity drops to or below its reorder point. Max one email per item per 24 hours.
          </CardDescription>
        </CardHeader>
        <CardContent>
          <div className="flex items-center gap-3">
            <Switch
              id="stock-alert"
              checked={!!prefs.stockAlertEmailEnabled}
              disabled={loading || saving === 'stockAlertEmailEnabled'}
              onCheckedChange={() => toggle('stockAlertEmailEnabled')}
            />
            <Label htmlFor="stock-alert" className="text-sm cursor-pointer">
              {prefs.stockAlertEmailEnabled ? 'Enabled' : 'Disabled'}
            </Label>
          </div>
        </CardContent>
      </Card>

      <Card>
        <CardHeader className="pb-3">
          <CardTitle className="text-sm flex items-center gap-2">
            <FileText className="h-4 w-4" /> Daily Close — EOD report email
          </CardTitle>
          <CardDescription className="text-xs">
            Email all admins a daily end-of-day financial summary with AI analysis and PDF attachment at 9 PM PKT every day.
          </CardDescription>
        </CardHeader>
        <CardContent>
          <div className="flex items-center gap-3">
            <Switch
              id="eod-email"
              checked={!!prefs.eodEmailEnabled}
              disabled={loading || saving === 'eodEmailEnabled'}
              onCheckedChange={() => toggle('eodEmailEnabled')}
            />
            <Label htmlFor="eod-email" className="text-sm cursor-pointer">
              {prefs.eodEmailEnabled ? 'Enabled' : 'Disabled'}
            </Label>
          </div>
        </CardContent>
      </Card>
    </div>
  );
}

import NotificationSettings from './NotificationSettings';

{ key: 'notifications', label: 'Email Notifications', icon: Bell, component: <NotificationSettings /> }

cd /Users/ssh/Documents/Beta-App/odontoX/ui && npx tsc --noEmit

git add ui/src/components/settings/NotificationSettings.tsx ui/src/components/settings/SettingsModule.tsx ui/src/lib/serverComm.ts
git commit -m "feat(settings): add opt-in notification preferences UI for stock alerts and EOD emails"

grep -rn "PATCH\|patch\|updateClinic\|'clinic'" /Users/ssh/Documents/Beta-App/odontoX/server/src/routes/ --include="*.ts" | grep -i "patch\|update" | head -10

notificationPreferences: z.object({
  stockAlertEmailEnabled: z.boolean().optional(),
  eodEmailEnabled: z.boolean().optional(),
}).optional(),

...(body.notificationPreferences !== undefined && { notificationPreferences: body.notificationPreferences }),

cd /Users/ssh/Documents/Beta-App/odontoX/server && npx tsc --noEmit

git add server/src/routes/
git commit -m "feat(server): expose notificationPreferences in clinic PATCH/GET"

// server/src/emails/StockAlertEmail.tsx
import * as React from 'react';
import { Section, Text } from '@react-email/components';
import { BaseLayout, ClinicBranding } from './components/BaseLayout';
import { ClinicButton } from './components/ClinicButton';
import * as s from './components/styles';

interface StockAlertEmailProps {
  branding: ClinicBranding;
  itemName: string;
  currentQty: number;
  reorderPoint: number;
  reorderQuantity?: number;
  unit: string;
  appUrl: string;
}

export function StockAlertEmail({
  branding,
  itemName,
  currentQty,
  reorderPoint,
  reorderQuantity,
  unit,
  appUrl,
}: StockAlertEmailProps) {
  return (
    <BaseLayout branding={branding} previewText={`Low stock alert: ${itemName}`}>
      <Section style={s.section}>
        <Text style={s.h2}>Low Stock Alert</Text>
        <Text style={s.body}>
          <strong>{itemName}</strong> has dropped to {currentQty} {unit}
          {reorderPoint !== undefined ? `, which is at or below the reorder point of ${reorderPoint} ${unit}` : ''}.
        </Text>
        {reorderQuantity && (
          <Text style={s.body}>
            Suggested reorder quantity: <strong>{reorderQuantity} {unit}</strong>
          </Text>
        )}
        <Text style={s.bodyMuted}>
          Review your inventory and place a reorder to avoid running out.
        </Text>
        <ClinicButton href={`${appUrl}?view=inventory`} branding={branding}>
          View Inventory
        </ClinicButton>
      </Section>
    </BaseLayout>
  );
}

export interface SendStockAlertEmailOptions {
  recipients: { email: string; name: string }[];
  branding: ClinicBranding;
  itemName: string;
  currentQty: number;
  reorderPoint: number;
  reorderQuantity?: number;
  unit: string;
  appUrl: string;
  customZeptoApiKey?: string;
  customFromEmail?: string;
}

export async function sendStockAlertEmail(options: SendStockAlertEmailOptions): Promise<void> {
  const { StockAlertEmail } = await import('../emails/StockAlertEmail');
  const html = await render(
    React.createElement(StockAlertEmail, {
      branding: options.branding,
      itemName: options.itemName,
      currentQty: options.currentQty,
      reorderPoint: options.reorderPoint,
      reorderQuantity: options.reorderQuantity,
      unit: options.unit,
      appUrl: options.appUrl,
    })
  );
  await sendEmailViaZepto(
    options.recipients,
    `Low stock: ${options.itemName}`,
    html,
    { customApiKey: options.customZeptoApiKey, customFromEmail: options.customFromEmail }
  );
}

cd /Users/ssh/Documents/Beta-App/odontoX/server && npx tsc --noEmit

git add server/src/emails/StockAlertEmail.tsx server/src/lib/email.ts
git commit -m "feat(email): add StockAlertEmail template and sendStockAlertEmail function"

import { sendStockAlertEmail } from '../lib/email';
import { userClinicAssignments, users } from '../schema';
import { ne } from 'drizzle-orm';

async function maybeFireStockAlert(
  db: Awaited<ReturnType<typeof getDatabase>>,
  clinicId: string,
  itemId: string,
  env: any
): Promise<void> {
  try {
    // Fetch updated item
    const [item] = await db.select()
      .from(inventoryItems)
      .where(and(eq(inventoryItems.id, itemId), eq(inventoryItems.clinicId, clinicId)))
      .limit(1);

    if (!item || item.reorderPoint === null || item.reorderPoint === undefined) return;
    if (item.quantity > item.reorderPoint) return;

    // Check clinic opt-in
    const [clinic] = await db.select({ notificationPreferences: clinics.notificationPreferences, name: clinics.name, subdomain: clinics.subdomain })
      .from(clinics)
      .where(eq(clinics.id, clinicId))
      .limit(1);

    if (!clinic?.notificationPreferences?.stockAlertEmailEnabled) return;

    // Dedup: check if alert email sent in last 24h for this item
    const [existingAlert] = await db.select({ emailSentAt: inventoryAlerts.emailSentAt })
      .from(inventoryAlerts)
      .where(and(
        eq(inventoryAlerts.clinicId, clinicId),
        eq(inventoryAlerts.itemId, itemId),
        eq(inventoryAlerts.alertType, 'reorder'),
      ))
      .orderBy(desc(inventoryAlerts.createdAt))
      .limit(1);

    const twentyFourHoursAgo = new Date(Date.now() - 24 * 60 * 60 * 1000);
    if (existingAlert?.emailSentAt && new Date(existingAlert.emailSentAt) > twentyFourHoursAgo) return;

    // Upsert alert record
    await db.insert(inventoryAlerts).values({
      clinicId,
      itemId,
      alertType: 'reorder',
      message: `${item.name} quantity (${item.quantity}) is at or below reorder point (${item.reorderPoint})`,
      severity: 'warning',
      emailSentAt: new Date(),
    }).onConflictDoNothing();

    // Fetch all admin users of this clinic
    const adminRows = await db.select({ email: users.email, firstName: users.firstName, lastName: users.lastName })
      .from(userClinicAssignments)
      .innerJoin(users, eq(userClinicAssignments.userId, users.id))
      .where(and(
        eq(userClinicAssignments.clinicId, clinicId),
        eq(userClinicAssignments.role, 'admin'),
        eq(userClinicAssignments.status, 'active'),
      ));

    const recipients = adminRows
      .filter(r => r.email)
      .map(r => ({ email: r.email!, name: `${r.firstName ?? ''} ${r.lastName ?? ''}`.trim() || r.email! }));

    if (recipients.length === 0) return;

    const appUrl = clinic.subdomain
      ? `https://${clinic.subdomain}.odontox.io`
      : 'https://app.odontox.io';

    await sendStockAlertEmail({
      recipients,
      branding: { clinicName: clinic.name ?? 'Your Clinic' },
      itemName: item.name,
      currentQty: item.quantity,
      reorderPoint: item.reorderPoint,
      reorderQuantity: item.reorderQuantity ?? undefined,
      unit: item.unit ?? 'units',
      appUrl,
      customZeptoApiKey: env?.ZEPTO_API_KEY,
      customFromEmail: env?.ZEPTO_FROM_EMAIL,
    });

    console.log(`📦 Stock alert email sent for item: ${item.name} (qty: ${item.quantity})`);
  } catch (err) {
    console.error('Stock alert email failed (non-fatal):', err);
  }
}

void maybeFireStockAlert(db, currentClinicId, itemId, c.env);

cd /Users/ssh/Documents/Beta-App/odontoX/server && npx tsc --noEmit

git add server/src/routes/inventory.ts
git commit -m "feat(inventory): fire stock alert email on stock write when qty <= reorderPoint"

// server/src/lib/eod-report.ts
import { getDatabase } from './db';
import { getDatabaseUrl } from './env';
import * as schema from '../schema';
import { eq, and, gte, lt, desc } from 'drizzle-orm';
import { sql } from 'drizzle-orm';

export interface EODReportData {
  date: string;
  clinicId: string;
  // mirror the shape returned by the existing endpoint
  dayExpenses: any[];
  payrollRuns: any[];
  todayReceipts: any[];
  todayInvoices: any[];
  todayAppointments: any[];
  arData: any[];
}

export async function fetchEODReportData(clinicId: string, date: string): Promise<EODReportData> {
  const databaseUrl = getDatabaseUrl();
  const db = await getDatabase(databaseUrl);

  const dayStart = new Date(`${date}T00:00:00.000Z`);
  const dayEnd   = new Date(`${date}T24:00:00.000Z`);

  // Paste the exact Promise.all query from expenses.ts here (lines ~126-360)
  // Replace currentClinicId with the clinicId parameter
  const [dayExpenses, payrollRuns, todayReceipts, todayInvoices, todayAppointments, arData] =
    await Promise.all([
      // ... exact queries from expenses.ts eod-report handler
    ]);

  return { date, clinicId, dayExpenses, payrollRuns, todayReceipts, todayInvoices, todayAppointments, arData };
}

import { fetchEODReportData } from '../lib/eod-report';
// ...
const reportData = await fetchEODReportData(currentClinicId, date);
const { dayExpenses, payrollRuns, todayReceipts, todayInvoices, todayAppointments, arData } = reportData;
// rest of the handler unchanged

cd /Users/ssh/Documents/Beta-App/odontoX/server && npx tsc --noEmit

git add server/src/lib/eod-report.ts server/src/routes/expenses.ts
git commit -m "refactor(server): extract EOD report query into shared eod-report.ts helper"

// server/src/emails/EODReportEmail.tsx
import * as React from 'react';
import { Section, Text, Hr } from '@react-email/components';
import { BaseLayout, ClinicBranding } from './components/BaseLayout';
import { ClinicButton } from './components/ClinicButton';
import * as s from './components/styles';

interface EODReportEmailProps {
  branding: ClinicBranding;
  date: string;           // e.g. "2026-04-29"
  aiSummary: string;      // markdown text from DeepSeek
  totalRevenue: string;   // formatted, e.g. "PKR 45,200"
  totalExpenses: string;
  netAmount: string;
  appointmentsCount: number;
  appUrl: string;
}

export function EODReportEmail({
  branding,
  date,
  aiSummary,
  totalRevenue,
  totalExpenses,
  netAmount,
  appointmentsCount,
  appUrl,
}: EODReportEmailProps) {
  return (
    <BaseLayout branding={branding} previewText={`EOD Report — ${date}`}>
      <Section style={s.section}>
        <Text style={s.h2}>End of Day Report — {date}</Text>
        <Text style={s.bodyMuted}>Daily financial close summary for {branding.clinicName}</Text>
      </Section>

      <Section style={{ ...s.section, background: '#f8fafc', borderRadius: 8, padding: '16px 24px' }}>
        <Text style={s.label}>TODAY AT A GLANCE</Text>
        <table style={{ width: '100%', borderCollapse: 'collapse' }}>
          <tbody>
            <tr>
              <td style={{ padding: '6px 0', color: '#64748b', fontSize: 13 }}>Revenue collected</td>
              <td style={{ padding: '6px 0', textAlign: 'right', fontWeight: 600, fontSize: 13 }}>{totalRevenue}</td>
            </tr>
            <tr>
              <td style={{ padding: '6px 0', color: '#64748b', fontSize: 13 }}>Expenses</td>
              <td style={{ padding: '6px 0', textAlign: 'right', fontWeight: 600, fontSize: 13 }}>{totalExpenses}</td>
            </tr>
            <tr>
              <td style={{ padding: '6px 0', color: '#64748b', fontSize: 13 }}>Net</td>
              <td style={{ padding: '6px 0', textAlign: 'right', fontWeight: 700, fontSize: 14 }}>{netAmount}</td>
            </tr>
            <tr>
              <td style={{ padding: '6px 0', color: '#64748b', fontSize: 13 }}>Appointments seen</td>
              <td style={{ padding: '6px 0', textAlign: 'right', fontWeight: 600, fontSize: 13 }}>{appointmentsCount}</td>
            </tr>
          </tbody>
        </table>
      </Section>

      <Section style={s.section}>
        <Text style={s.label}>AI ANALYSIS</Text>
        {aiSummary.split('\n').filter(Boolean).map((line, i) => (
          <Text key={i} style={s.body}>{line.replace(/^#+\s*/, '').replace(/\*\*(.*?)\*\*/g, '$1')}</Text>
        ))}
      </Section>

      <Section style={s.section}>
        <Text style={s.bodyMuted}>Full report attached as PDF.</Text>
        <ClinicButton href={`${appUrl}?view=eod`} branding={branding}>
          View in OdontoX
        </ClinicButton>
      </Section>
    </BaseLayout>
  );
}