VetPulse

DrVeto (reseller ReqVet)
  └── VetPulse Admin   [REQVET_RESELLER_API_KEY]  →  /admin
        ├── Clinique du Parc       →  VetPulse Clinique A  [REQVET_API_KEY=rqv_live_AAA]
        ├── Cabinet Laval Animaux  →  VetPulse Clinique B  [REQVET_API_KEY=rqv_live_BBB]
        └── Clinique Saint-Ex...   →  VetPulse Clinique C  [REQVET_API_KEY=rqv_live_CCC]

// lib/reqvet.ts — Singleton côté serveur (jamais importé d'un composant client)
// Pattern proxy : la clé API reste ici, jamais exposée au navigateur
import ReqVet from "@reqvet-sdk/sdk";

if (!process.env.REQVET_API_KEY) {
  throw new Error("REQVET_API_KEY manquante dans .env.local");
}

export const reqvet = new ReqVet(process.env.REQVET_API_KEY, {
  baseUrl: process.env.REQVET_BASE_URL ?? "https://api.reqvet.com",
  pollInterval: 5000,
  timeout: 5 * 60 * 1000,
});

// lib/reqvet-admin.ts — Client SDK avec clé reseller
// Utilisé uniquement dans les routes /api/admin/*
import ReqVet from "@reqvet-sdk/sdk";

let _client: ReqVet | null = null;

export function getResellerClient(): ReqVet {
  if (!process.env.REQVET_RESELLER_API_KEY) {
    throw new Error("REQVET_RESELLER_API_KEY manquante — pas configuré en mode admin.");
  }
  if (!_client) {
    _client = new ReqVet(process.env.REQVET_RESELLER_API_KEY, {
      baseUrl: process.env.REQVET_BASE_URL ?? "https://api.reqvet.com",
    });
  }
  return _client;
}

// app/api/reqvet/generate/route.ts — le proxy le plus important
export async function POST(req: NextRequest) {
  const form = await req.formData();
  const audio = form.get("audio") as File;
  const animalName = form.get("animalName") as string;
  const animalBreed = form.get("animalBreed") as string | undefined;
  const animalAge   = form.get("animalAge")   as string | undefined;
  const templateId = form.get("templateId") as string;
  const consultationId = form.get("consultationId") as string;

  // 1a. URL signée Supabase (requête JSON légère)
  const { uploadUrl, path: audioPath } = await reqvet.getSignedUploadUrl(
    audio.name || "consultation.webm",
    audio.type || "audio/webm",
  );

  // 1b. PUT direct vers Supabase (bypass Vercel 4,5 Mo)
  await fetch(uploadUrl, {
    method: "PUT",
    headers: { "Content-Type": audio.type || "audio/webm" },
    body: Buffer.from(await audio.arrayBuffer()),
  });

  // 2. Créer le job avec callbackUrl vers notre webhook
  const callbackUrl = `${process.env.NEXT_PUBLIC_APP_URL}/api/reqvet/webhook`;
  const job = await reqvet.createJob({
    audioFile: audioPath,
    animalName, animalBreed, animalAge,
    templateId, callbackUrl,
    metadata: { consultationId, source: "vetpulse" },
  });

  // 3. Persister le mapping local ↔ ReqVet en base Turso
  const localJobId = randomUUID();
  await createJob({
    id: localJobId,
    consultationId,
    reqvetJobId: job.job_id,
    templateId,
    status: job.status,
    metadata: { consultationId },
  });

  return NextResponse.json({ job_id: job.job_id, local_job_id: localJobId }, { status: 201 });
}

// app/api/reqvet/webhook/route.ts — reçoit les résultats ReqVet
import { verifyWebhookSignature } from "@reqvet-sdk/sdk/webhooks";

export async function POST(req: NextRequest) {
  // 1. Raw body AVANT JSON.parse (obligatoire pour HMAC)
  const rawBody = await req.text();

  // 2. Vérifier signature HMAC + anti-replay 5 min
  const result = verifyWebhookSignature({
    secret: process.env.REQVET_WEBHOOK_SECRET,
    rawBody,
    signature: req.headers.get("x-reqvet-signature") ?? "",
    timestamp: req.headers.get("x-reqvet-timestamp") ?? "",
    maxSkewMs: 5 * 60 * 1000,
  });
  if (!result.ok) return new NextResponse("Unauthorized", { status: 401 });

  const event = JSON.parse(rawBody);

  // 3. Idempotence — dedup sur (job_id, event_type)
  const existing = await db.execute({
    sql: "SELECT id FROM webhook_events WHERE job_id = ? AND event_type = ?",
    args: [event.job_id, event.event],
  });
  if (existing.rows.length > 0) return NextResponse.json({ ok: true, deduplicated: true });

  await db.execute({
    sql: "INSERT INTO webhook_events (id, job_id, event_type) VALUES (?, ?, ?)",
    args: [`${event.job_id}:${event.event}`, event.job_id, event.event],
  });

  // 4. Router selon l'event
  switch (event.event) {
    case "job.completed":
    case "job.amended":
    case "job.regenerated":
      await updateJobFromWebhook({
        reqvetJobId: event.job_id,
        status: "completed",
        html: event.html,
        transcription: event.transcription,
        fields: event.fields,
        amendmentNumber: event.amendment_number,
      });
      break;
    case "job.failed":
    case "job.amend_failed":
      await updateJobFromWebhook({
        reqvetJobId: event.job_id,
        status: event.event === "job.failed" ? "failed" : "completed",
        error: event.error,
      });
      break;
  }
  return NextResponse.json({ ok: true });
}

// app/api/reqvet/job/route.ts — polling côté frontend
// Deux sources : (1) Turso (mise à jour par le webhook), (2) API ReqVet (fallback)
export async function GET(req: NextRequest) {
  const jobId = req.nextUrl.searchParams.get("jobId")!;

  // 1. D'abord la base (webhook déjà passé ?)
  const localJob = await getJob(jobId);
  if (localJob?.status === "completed") {
    return NextResponse.json({
      status: "completed",
      html: localJob.html,
      transcription: localJob.transcription,
      fields: localJob.fields ? JSON.parse(localJob.fields) : null,
    });
  }
  if (localJob?.status === "failed") {
    return NextResponse.json({ status: "failed", error: localJob.error });
  }

  // 2. Fallback API ReqVet (webhook en retard)
  const remoteJob = await reqvet.getJob(jobId);
  return NextResponse.json({
    status: remoteJob.status,
    html: remoteJob.result?.html ?? null,
    transcription: remoteJob.transcription ?? null,
    fields: remoteJob.result?.fields ?? null,
  });
}

// app/api/admin/clinics/route.ts — provisionner une clinique
export async function POST(req: NextRequest) {
  const { name, contactEmail, monthlyQuota, notes } = await req.json();
  const reqvetAdmin = getResellerClient();

  // UUID local généré en avance → sert d'externalId pour l'idempotence
  const localId = randomUUID();

  const result = await reqvetAdmin.createOrganization({
    name: name.trim(),
    contactEmail,
    monthlyQuota: monthlyQuota ? Number(monthlyQuota) : undefined,
    externalId: localId,   // ← clé d'idempotence : re-appel = pas de doublon
  });

  // L'org existait déjà (idempotence) — pas de credentials retournés
  if (result.message) {
    const existing = await getClinicByReqvetOrgId(result.organization.id);
    return NextResponse.json({
      organization: result.organization,
      already_existed: true,
      local_id: existing?.id ?? null,
    });
  }

  // Nouvelle org — sauvegarder en local SANS la clé (elle reste chez la clinique)
  await createClinicRecord({
    id: localId,
    reqvetOrgId: result.organization.id,
    name: result.organization.name,
    notes: notes?.trim() || null,
  });

  // Retourner api_key + webhook_secret UNE SEULE FOIS
  return NextResponse.json({
    organization: result.organization,
    local_id: localId,
    api_key: result.api_key,
    webhook_secret: result.webhook_secret,
  }, { status: 201 });
}

vetpulse/
├── app/
│   ├── admin/                       # UI reseller (mode DrVeto)
│   │   ├── page.tsx                 # server component : garde REQVET_RESELLER_API_KEY
│   │   ├── ClinicDashboard.tsx      # client component : liste + création
│   │   ├── clinics/, costs/, overview/, templates/
│   │   └── AdminSidebar.tsx
│   ├── api/
│   │   ├── admin/clinics/           # GET list · POST create · [id] PATCH/DELETE
│   │   ├── consultations/           # PATCH motif/CR/conclusion en Turso
│   │   └── reqvet/                  # ← Le cœur du proxy backend
│   │       ├── generate/route.ts    # getSignedUploadUrl + createJob
│   │       ├── webhook/route.ts     # verifyWebhookSignature + updateJob
│   │       ├── job/route.ts         # getJob (poll)
│   │       ├── templates/route.ts   # listTemplates
│   │       ├── reformulate/route.ts # reformulateReport
│   │       └── amend/route.ts       # getSignedUploadUrl + amendJob
│   ├── consultation/page.tsx        # UI vétérinaire
│   ├── layout.tsx
│   └── globals.css
├── components/
│   └── ConsultationView.tsx         # MediaRecorder + polling + éditeur riche
├── lib/
│   ├── reqvet.ts                    # SDK clinique (REQVET_API_KEY)
│   ├── reqvet-admin.ts              # SDK reseller (REQVET_RESELLER_API_KEY)
│   ├── db.ts                        # Turso client + helpers + types
│   └── db-setup.mjs                 # script d'initialisation du schéma
├── .env.example
└── package.json

# Installer les dépendances
npm install

# Créer la base Turso
turso db create vetpulse
turso db show vetpulse --url      # → TURSO_DATABASE_URL
turso db tokens create vetpulse   # → TURSO_AUTH_TOKEN

# Initialiser le schéma (idempotent)
npm run db:setup
# → crée consultations, jobs, reformulations, webhook_events, clinics

# .env.local — Instance ADMIN (DrVeto)
REQVET_RESELLER_API_KEY=rqv_live_reseller_...   # clé reseller fournie par ReqVet
REQVET_BASE_URL=https://api.reqvet.com

# Turso — base centrale DrVeto (liste des cliniques)
TURSO_DATABASE_URL=libsql://vetpulse-drveto.turso.io
TURSO_AUTH_TOKEN=eyJ...

NEXT_PUBLIC_APP_URL=https://admin.drveto.fr

npm run dev
# → http://localhost:3000/admin
# → cliquer "Ajouter une clinique" → remplir → modal credentials one-time

# .env.local — Instance CLINIQUE
REQVET_API_KEY=rqv_live_clinic_...          # clé clinique (obtenue via /admin DrVeto)
REQVET_WEBHOOK_SECRET=whsec_...              # secret webhook (obtenu en même temps)
REQVET_BASE_URL=https://api.reqvet.com

# Turso — base propre à cette clinique
TURSO_DATABASE_URL=libsql://vetpulse-clinique-du-parc.turso.io
TURSO_AUTH_TOKEN=eyJ...

# URL publique (tunnel ngrok en dev, domaine en prod)
NEXT_PUBLIC_APP_URL=https://xxxx.ngrok-free.app

# Exposer le webhook en dev (ngrok)
ngrok http 3000
# → copier l'URL https://xxxx.ngrok-free.app dans NEXT_PUBLIC_APP_URL

# Initialiser la base Turso propre à cette clinique
npm run db:setup

# Lancer
npm run dev
# → http://localhost:3000/consultation

// 1. Requête JSON légère → URL signée
const { uploadUrl, path } = await reqvet.getSignedUploadUrl(fileName, contentType);

// 2. PUT direct vers Supabase — aucune limite de taille
await fetch(uploadUrl, { method: "PUT", body: audioBuffer });

// 3. path (identifiant canonique côté Supabase) passé à createJob
await reqvet.createJob({ audioFile: path, ... });

ConsultationRow.patient_breed  →  form "animalBreed"  →  reqvet.createJob({ animalBreed })
ConsultationRow.patient_age    →  form "animalAge"    →  reqvet.createJob({ animalAge })

// Côté ReqVet, injecté dans le prompt LLM :
SIGNALEMENT DU PATIENT :
- Nom : Rex
- Race : Labrador Retriever
- Âge : 5 ans

const localId = randomUUID();   // généré AVANT l'appel API
const result = await reqvetAdmin.createOrganization({
  name, contactEmail, monthlyQuota,
  externalId: localId,          // ← clé d'idempotence
});

if (result.message) {
  // L'org existait déjà — pas de nouvelles credentials, on remonte l'existante
  return { organization: result.organization, already_existed: true };
}
// Nouvelle org — result.api_key + result.webhook_secret retournés une seule fois