nexarch/web/mail-postfach/lib/api.ts

// UX-01: dünner Client für mail/internal/mailapi (INT-01, bereits
// fertig) — keine eigene Sortier-/Filterlogik, die läuft in
// lib/sorting.ts rein clientseitig auf der bereits mandantengebundenen
// Antwort weiter.
import { apiFetch, statusMessage } from "./http";

export interface MailboxDTO {
  name: string;
  messageCount: number;
}

export interface MessageListItemDTO {
  messageId: string;
  subject: string;
  sender: string;
  mailbox: string;
  sentAt: number;
}

// Fetcher erlaubt es Tests, einen echten Bearer-Token direkt gegen eine
// echte mailapi-Instanz zu senden, ohne den vollen Core-Anmeldefluss
// (lib/http.ts) nachzubauen — der Tenant-Isolationscode läuft dabei
// unverändert auf dem echten Server, nur die Token-Beschaffung ist
// ausgetauscht.
export type Fetcher = (input: string, init?: RequestInit) => Promise<Response>;

function apiBase(): string {
  const base = process.env.NEXT_PUBLIC_MAIL_API_URL;
  if (!base) {
    throw new Error("NEXT_PUBLIC_MAIL_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)");
  }
  return base.replace(/\/$/, "");
}

async function get<T>(path: string, fetcher: Fetcher): Promise<T> {
  const res = await fetcher(`${apiBase()}${path}`);
  if (!res.ok) {
    throw new Error(statusMessage(res, "Anfrage fehlgeschlagen"));
  }
  return res.json();
}

export async function fetchMailboxes(fetcher: Fetcher = apiFetch): Promise<MailboxDTO[]> {
  const body = await get<{ mailboxes: MailboxDTO[] }>("/mailboxes", fetcher);
  return body.mailboxes;
}

export interface MessagesQuery {
  mailbox?: string;
  q?: string;
}

export async function fetchMessages(query: MessagesQuery = {}, fetcher: Fetcher = apiFetch): Promise<MessageListItemDTO[]> {
  const params = new URLSearchParams();
  if (query.mailbox) params.set("mailbox", query.mailbox);
  if (query.q) params.set("q", query.q);
  const qs = params.toString() ? `?${params.toString()}` : "";
  const body = await get<{ messages: MessageListItemDTO[] }>(`/messages${qs}`, fetcher);
  return body.messages;
}

// UX-02: Detailansicht. Felder entsprechen bereits den "relevanten
// Headern" (Von/Betreff/Ordner/Datum/Nachricht-ID) — mailapi hat keine
// To/Cc-Felder, weil der Ingestion-Pfad sie nirgends persistiert.
export interface MessageDetailDTO {
  messageId: string;
  subject: string;
  body: string;
  sender: string;
  mailbox: string;
  sentAt: number;
}

export async function fetchMessageDetail(messageId: string, fetcher: Fetcher = apiFetch): Promise<MessageDetailDTO> {
  return get<MessageDetailDTO>(`/messages/${encodeURIComponent(messageId)}`, fetcher);
}

// AttachmentDTO hat bewusst keinen Dateinamen -- die API liefert keinen
// (siehe mailapi.attachmentListItem), nur Index/ContentType/Size aus
// den tatsaechlich gespeicherten Bytes.
export interface AttachmentDTO {
  index: number;
  contentType: string;
  size: number;
}

export async function fetchAttachments(messageId: string, fetcher: Fetcher = apiFetch): Promise<AttachmentDTO[]> {
  const body = await get<{ attachments: AttachmentDTO[] }>(`/messages/${encodeURIComponent(messageId)}/attachments`, fetcher);
  return body.attachments;
}

export async function fetchAttachmentContent(messageId: string, index: number, fetcher: Fetcher = apiFetch): Promise<Blob> {
  const res = await fetcher(`${apiBase()}/messages/${encodeURIComponent(messageId)}/attachments/${index}`);
  if (!res.ok) {
    throw new Error(statusMessage(res, "Anhang-Abruf fehlgeschlagen"));
  }
  return res.blob();
}