Electron

import { app, BrowserWindow, dialog, ipcMain } from "electron";
import { readFile } from "node:fs/promises";
import { basename, extname, join } from "node:path";

// YOUR backend, never api.constaia.com.
const API_BASE = "https://api.your-app.com";
const MIME: Record<string, string> = {
  ".jpg": "image/jpeg",
  ".jpeg": "image/jpeg",
  ".png": "image/png",
  ".webp": "image/webp",
  ".heic": "image/heic",
  ".pdf": "application/pdf",
};

ipcMain.handle("document:verify", async (event, sessionToken: string) => {
  const win = BrowserWindow.fromWebContents(event.sender)!;
  const { canceled, filePaths } = await dialog.showOpenDialog(win, {
    properties: ["openFile"],
    filters: [{ name: "Documents", extensions: ["jpg", "jpeg", "png", "webp", "heic", "pdf"] }],
  });
  if (canceled || !filePaths[0]) return { canceled: true };

  const path = filePaths[0];
  const data = await readFile(path);
  if (data.byteLength > 20 * 1024 * 1024) {
    return { error: { code: "file_too_large", message: "20 MB maximum." } };
  }

  const form = new FormData();
  form.append("file", new Blob([data], { type: MIME[extname(path).toLowerCase()] }), basename(path));

  try {
    const res = await fetch(`${API_BASE}/api/verify-dni`, {
      method: "POST",
      headers: { authorization: `Bearer ${sessionToken}` },
      body: form,
      signal: AbortSignal.timeout(90_000),
    });
    const body = await res.json().catch(() => null);
    if (!res.ok) return { error: body?.error ?? { code: "http_error", message: `HTTP ${res.status}` } };
    return { result: body };
  } catch {
    return { error: { code: "network_error", message: "Cannot reach the server." } };
  }
});

function createWindow() {
  const win = new BrowserWindow({
    width: 900,
    height: 700,
    webPreferences: { preload: join(__dirname, "preload.js"), contextIsolation: true, sandbox: true },
  });
  win.loadFile("index.html");
}

app.whenReady().then(createWindow);
app.on("window-all-closed", () => {
  if (process.platform !== "darwin") app.quit();
});

import { contextBridge, ipcRenderer } from "electron";

contextBridge.exposeInMainWorld("documents", {
  verify: (sessionToken: string) => ipcRenderer.invoke("document:verify", sessionToken),
});

type Verdict = { status: "valid" | "invalid" | "review"; reasons: { code: string; message: string }[] };
type VerifyResponse =
  | { canceled: true }
  | { result: { id: string; status: string; verdict: Verdict | null; warnings: string[] } }
  | { error: { code: string; message: string } };

declare global {
  interface Window {
    documents: { verify(sessionToken: string): Promise<VerifyResponse> };
  }
}
declare function getSessionToken(): Promise<string>; // your login

const button = document.querySelector<HTMLButtonElement>("#verify")!;
const output = document.querySelector<HTMLDivElement>("#result")!;

button.addEventListener("click", async () => {
  button.disabled = true;
  output.textContent = "Analysing…";
  // YOUR backend's session token, obtained on your login screen.
  const response = await window.documents.verify(await getSessionToken());
  button.disabled = false;

  if ("canceled" in response) {
    output.textContent = "";
  } else if ("error" in response) {
    output.textContent = response.error.message;
  } else {
    const verdict = response.result.verdict;
    const labels = { valid: "Valid document", invalid: "Invalid document", review: "We will review it manually" };
    output.textContent = verdict
      ? `${labels[verdict.status]}. ${verdict.reasons.map((r) => r.message).join(" ")}`
      : "Analysis in progress; we will let you know when it finishes.";
  }
});

export {};