diff --git a/src/app/(dashboard)/commandes-auto/tabs.tsx b/src/app/(dashboard)/commandes-auto/tabs.tsx
index 4ff1652..90e2d37 100644
--- a/src/app/(dashboard)/commandes-auto/tabs.tsx
+++ b/src/app/(dashboard)/commandes-auto/tabs.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { ShoppingCart, CalendarClock } from "lucide-react";
import { Tabs, useUrlTab } from "@/components/ui/tabs";
import { CommandesAutoClient } from "./client";
diff --git a/src/app/(dashboard)/dashboard/page.tsx b/src/app/(dashboard)/dashboard/page.tsx
index 75e21a9..4653769 100644
--- a/src/app/(dashboard)/dashboard/page.tsx
+++ b/src/app/(dashboard)/dashboard/page.tsx
@@ -1,8 +1,8 @@
-import type { Metadata } from "next";
import Link from "next/link";
-import { unstable_cache } from "next/cache";
import { BarChart3, Euro, House, Receipt, ShoppingBasket, ShoppingCart, Store } from "lucide-react";
-import { pgGetDashboardData, type DashboardSiteStats, type DashboardSiteTop10, type DashboardTopItem } from "@/lib/pg-ff-client";
+import type { DashboardData, DashboardSiteStats, DashboardSiteTop10, DashboardTopItem } from "@/types/ff";
+import { fetchPage } from "@/lib/rpc";
+import { usePageResult } from "@/lib/page-data";
import { PageHeader } from "@/components/ui/page-header";
import { StatCard } from "@/components/ui/stat-card";
import { Card, CardHeader } from "@/components/ui/card";
@@ -13,15 +13,6 @@ import { LIBELLE_TOUS_MAGASINS, nomMagasin } from "@/lib/magasins";
import { fmtDecimal1, fmtEntier, fmtEur2 } from "@/lib/format";
import { couleurMarge } from "@/lib/marge";
-export const metadata: Metadata = { title: "Accueil" };
-
-const getCachedDashboardData = unstable_cache(
- pgGetDashboardData,
- ["dashboard-data"],
- // 30 minutes : ce sont les ventes de la veille, elles ne changent pas dans la journée.
- { revalidate: 1800 }
-);
-
// ---------------------------------------------------------------------------
// Calculs
// ---------------------------------------------------------------------------
@@ -203,25 +194,23 @@ function TitreSection({ titre, description }: { titre: string; description?: Rea
// Page
// ---------------------------------------------------------------------------
-export default async function DashboardPage() {
- let data;
- try {
- data = await getCachedDashboardData();
- } catch (e) {
- console.error("[Dashboard] pgGetDashboardData failed:", e);
+export default function DashboardPage() {
+ // Mis en cache 30 minutes par le serveur : ce sont les ventes de la veille.
+ const resultat = usePageResult("dashboard", () => fetchPage("dashboard"));
+ if (!resultat.ok) {
return (
>;
-}) {
- const searchParams = await props.searchParams;
+export default function HitParadePage() {
+ const searchParams = usePageSearchParams();
const defaults = defaultDates();
- const dateDebut = (searchParams.debut as string) || defaults.debut;
- const dateFin = (searchParams.fin as string) || defaults.fin;
+ const dateDebut = searchParams.debut || defaults.debut;
+ const dateFin = searchParams.fin || defaults.fin;
+
+ // Lignes de la base FF, mises en cache par le serveur.
+ const resultat = usePageResult(`hit-parade?${dateDebut}:${dateFin}`, () =>
+ fetchPage("hit-parade", { debut: dateDebut, fin: dateFin }),
+ );
let pivotted: HitParadePivotRow[] | null = null;
let erreur: string | null = null;
- try {
- const rows = await cachedFF(`hit-parade:${dateDebut}:${dateFin}`, () => pgGetHitParade(dateDebut, dateFin));
- pivotted = pivotHitParade(rows);
- } catch (e) {
- console.error("[hit-parade] chargement impossible :", e);
- erreur = e instanceof Error ? e.message : String(e);
+ if (resultat.ok) {
+ pivotted = pivotHitParade(resultat.data);
+ } else {
+ erreur = resultat.error;
}
return (
diff --git a/src/app/(dashboard)/layout.tsx b/src/app/(dashboard)/layout.tsx
index 929f166..e4cbc52 100644
--- a/src/app/(dashboard)/layout.tsx
+++ b/src/app/(dashboard)/layout.tsx
@@ -1,13 +1,23 @@
+import { useEffect, useRef } from "react";
+import { useLocation } from "react-router";
import { Sidebar } from "@/components/shared/sidebar";
import { Header } from "@/components/shared/header";
-export default async function DashboardLayout({ children }: { children: React.ReactNode }) {
+export default function DashboardLayout({ children }: { children: React.ReactNode }) {
+ const { pathname } = useLocation();
+ const contenu = useRef(null);
+
+ // Changement de page : on repart du haut, comme une navigation Next.js.
+ useEffect(() => {
+ contenu.current?.scrollTo({ top: 0 });
+ }, [pathname]);
+
return (
+ =>
+ codein
+ ? fetchPage("produit-fiche", { codein })
+ : codeCentrale
+ ? fetchPage("produit-fiche", { cc: codeCentrale })
+ : Promise.resolve(null),
+ );
return (
{children}
diff --git a/src/app/(dashboard)/produits/fiche.tsx b/src/app/(dashboard)/produits/fiche.tsx
index 65ba6b2..b14f871 100644
--- a/src/app/(dashboard)/produits/fiche.tsx
+++ b/src/app/(dashboard)/produits/fiche.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
import Link from "next/link";
import { useRouter } from "next/navigation";
diff --git a/src/app/(dashboard)/produits/opportunites.tsx b/src/app/(dashboard)/produits/opportunites.tsx
index 5594d65..9d11cce 100644
--- a/src/app/(dashboard)/produits/opportunites.tsx
+++ b/src/app/(dashboard)/produits/opportunites.tsx
@@ -1,9 +1,7 @@
-"use client";
-
import { useState } from "react";
import Link from "next/link";
import { Loader2, RefreshCw, TrendingUp } from "lucide-react";
-import type { PgOpportuniteRow } from "@/lib/pg-ff-client";
+import type { PgOpportuniteRow } from "@/types/ff";
import { Button } from "@/components/ui/button";
import { DataTable, type DataColumn } from "@/components/ui/data-table";
import { EmptyState, ErrorState } from "@/components/ui/states";
diff --git a/src/app/(dashboard)/produits/page.tsx b/src/app/(dashboard)/produits/page.tsx
index d9b4a75..422c33e 100644
--- a/src/app/(dashboard)/produits/page.tsx
+++ b/src/app/(dashboard)/produits/page.tsx
@@ -1,6 +1,7 @@
-import type { Metadata } from "next";
import { PackageSearch, SearchX } from "lucide-react";
-import { getProduitFiche, getProduitFicheByCodeCentrale } from "@/features/produits/api/get-produit-fiche";
+import type { ProduitFiche } from "@/features/produits/types";
+import { fetchPage } from "@/lib/rpc";
+import { usePageData, usePageSearchParams } from "@/lib/page-data";
import { PageHeader } from "@/components/ui/page-header";
import { EmptyState } from "@/components/ui/states";
import { Terme } from "@/components/ui/tooltip";
@@ -8,33 +9,29 @@ import { ProduitSearchBar } from "./search-bar";
import { ProduitResults } from "./results";
import { ProduitFicheView } from "./fiche";
-export const metadata: Metadata = { title: "Recherche produit" };
-
-export const dynamic = "force-dynamic";
-
/**
* Recherche produit — **Qlik d'abord**, catalogue FF Nancy ensuite.
*
* - `?q=…` → liste de résultats (chargée côté client : l'extraction Qlik
- * prend plusieurs secondes, on ne bloque pas le rendu serveur)
+ * prend plusieurs secondes, on ne bloque pas l'affichage)
* - `?codein=…` → fiche d'un produit de notre catalogue (URL partageable)
* - `?cc=…` → fiche d'un produit du réseau par son code centrale, qu'il
* soit référencé chez nous ou non
*/
-export default async function ProduitsPage(props: {
- searchParams: Promise<{ q?: string; codein?: string; cc?: string }>;
-}) {
- const searchParams = await props.searchParams;
+export default function ProduitsPage() {
+ const searchParams = usePageSearchParams();
const q = (searchParams.q ?? "").trim();
const codein = (searchParams.codein ?? "").trim();
const codeCentrale = (searchParams.cc ?? "").trim();
- const fiche = codein
- ? await getProduitFiche(codein)
- : codeCentrale
- ? await getProduitFicheByCodeCentrale(codeCentrale)
- : null;
const ficheDemandee = Boolean(codein || codeCentrale);
+ const fiche = usePageData(`produit-fiche?${codein}:${codeCentrale}`, (): Promise
diff --git a/src/app/(dashboard)/produits/results.tsx b/src/app/(dashboard)/produits/results.tsx
index ed8d4fe..d8b9142 100644
--- a/src/app/(dashboard)/produits/results.tsx
+++ b/src/app/(dashboard)/produits/results.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useEffect, useMemo, useState, type ReactNode } from "react";
import Link from "next/link";
import { PackageSearch, Loader2, RefreshCw, AlertTriangle, Database, Globe } from "lucide-react";
diff --git a/src/app/(dashboard)/produits/search-bar.tsx b/src/app/(dashboard)/produits/search-bar.tsx
index dc55282..f5bb2d6 100644
--- a/src/app/(dashboard)/produits/search-bar.tsx
+++ b/src/app/(dashboard)/produits/search-bar.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useState } from "react";
import { useRouter } from "next/navigation";
import { Search, X } from "lucide-react";
diff --git a/src/app/(dashboard)/publicites/client.tsx b/src/app/(dashboard)/publicites/client.tsx
index 56337ea..5a05a54 100644
--- a/src/app/(dashboard)/publicites/client.tsx
+++ b/src/app/(dashboard)/publicites/client.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useMemo, useTransition } from "react";
import { useRouter } from "next/navigation";
import { History, Info, Megaphone, RotateCcw } from "lucide-react";
diff --git a/src/app/(dashboard)/publicites/page.tsx b/src/app/(dashboard)/publicites/page.tsx
index 932b555..d760255 100644
--- a/src/app/(dashboard)/publicites/page.tsx
+++ b/src/app/(dashboard)/publicites/page.tsx
@@ -1,10 +1,8 @@
-import type { Metadata } from "next";
import { Megaphone } from "lucide-react";
import { PageHeader } from "@/components/ui/page-header";
+import { fetchPage } from "@/lib/rpc";
+import { usePageData, usePageSearchParams } from "@/lib/page-data";
import { PublicitesClient } from "./client";
-import { cachedFF } from "@/lib/ff-cache";
-
-export const metadata: Metadata = { title: "Publicités" };
export interface Publicite {
tcr_code: string;
@@ -44,80 +42,30 @@ export interface PubliciteHistorique {
qte_totale: number;
}
-const FF_API_BASE = process.env.FF_API_BASE_URL ?? "https://api.ffnancy.fr";
-const PAGE_SIZE = 50;
-/** Délai maximal d'un appel à l'API FF : sans lui, une API muette figeait la page. */
-const FF_API_TIMEOUT_MS = 15_000;
/**
- * Réponses de l'API gardées 10 minutes (les erreurs ne le sont jamais) : la liste
- * et l'historique étaient re-téléchargés à chaque clic sur un filtre ou une page.
+ * Données de la page, lues par le serveur sur l'API FF (réponses gardées
+ * 10 minutes, jamais les erreurs) : une API en panne est signalée dans
+ * `erreurPublicites` / `erreurHistorique`, pas par une exception.
*/
-const PUB_CACHE_TTL_MS = 10 * 60 * 1000;
-
-type PublicitesResult = { data: Publicite[]; total: number; pages: number; error?: string };
-
-function fetchPublicites(statut: string, page: number): Promise {
- return cachedFF(`publicites:${statut}:${page}`, () => fetchPublicitesApi(statut, page), {
- ttlMs: PUB_CACHE_TTL_MS,
- cacheIf: (r) => !r.error,
- });
+interface DonneesPublicites {
+ publicites: Publicite[];
+ total: number;
+ pages: number;
+ erreurPublicites?: string;
+ historique: PubliciteHistorique[];
+ erreurHistorique?: string;
+ pageSize: number;
}
-async function fetchPublicitesApi(statut: string, page: number): Promise {
- const params = new URLSearchParams({ page: String(page), limit: String(PAGE_SIZE) });
- if (statut && statut !== "toutes") params.set("statut", statut);
- try {
- const res = await fetch(`${FF_API_BASE}/api/publicites?${params}`, {
- cache: "no-store",
- signal: AbortSignal.timeout(FF_API_TIMEOUT_MS),
- });
- if (!res.ok) return { data: [], total: 0, pages: 0, error: `Erreur API: ${res.status} ${res.statusText}` };
- const json = await res.json();
- return {
- data: (json.publicites ?? []) as Publicite[],
- total: Number(json.total ?? 0),
- pages: Number(json.pages ?? 0),
- };
- } catch (e: unknown) {
- return { data: [], total: 0, pages: 0, error: `Impossible de joindre l'API: ${e instanceof Error ? e.message : String(e)}` };
- }
-}
-
-type HistoriqueResult = { data: PubliciteHistorique[]; error?: string };
-
-function fetchHistorique(): Promise {
- return cachedFF("publicites-historique", fetchHistoriqueApi, {
- ttlMs: PUB_CACHE_TTL_MS,
- cacheIf: (r) => !r.error,
- });
-}
-
-async function fetchHistoriqueApi(): Promise {
- try {
- const res = await fetch(`${FF_API_BASE}/api/publicites/historique`, {
- cache: "no-store",
- signal: AbortSignal.timeout(FF_API_TIMEOUT_MS),
- });
- if (!res.ok) return { data: [], error: `Erreur historique: ${res.status}` };
- const json = await res.json();
- return { data: (json.publicites ?? []) as PubliciteHistorique[] };
- } catch (e: unknown) {
- return { data: [], error: `Impossible de joindre l'API: ${e instanceof Error ? e.message : String(e)}` };
- }
-}
-
-export default async function PublicitesPage(props: {
- searchParams: Promise>;
-}) {
- const searchParams = await props.searchParams;
+export default function PublicitesPage() {
+ const searchParams = usePageSearchParams();
const vue = String(searchParams.vue ?? "publicites");
const statut = String(searchParams.statut ?? "toutes");
const page = Math.max(1, Number(searchParams.page) || 1);
- const [pubResult, histoResult] = await Promise.all([
- fetchPublicites(statut, page),
- fetchHistorique(),
- ]);
+ const donnees = usePageData(`publicites?${statut}:${page}`, () =>
+ fetchPage("publicites", { statut, page }),
+ );
return (
+
+ );
}
diff --git a/src/app/(dashboard)/snapshots/page.tsx b/src/app/(dashboard)/snapshots/page.tsx
index 5b117e0..dbf24df 100644
--- a/src/app/(dashboard)/snapshots/page.tsx
+++ b/src/app/(dashboard)/snapshots/page.tsx
@@ -1,6 +1,6 @@
-import { redirect } from "next/navigation";
+import { Navigate } from "react-router";
/** Ancienne adresse, conservée pour les favoris : voir /historique. */
export default function SnapshotsPage() {
- redirect("/historique");
+ return >;
-}) {
- const searchParams = await props.searchParams;
- const magasin = (searchParams.magasin as string) || "";
- const tab = (searchParams.tab as string) || "negatif";
+export default function GestionStockPage() {
+ const searchParams = usePageSearchParams();
+ const magasin = searchParams.magasin || "";
+ const tab = searchParams.tab || "negatif";
- // Données FF recopiées chaque nuit : mises en cache (cf. lib/ff-cache.ts).
- const site = magasin || undefined;
- let donnees: DonneesStock | null = null;
- let erreur: string | null = null;
- try {
- const [rowsNegatif, rowsSansVente, rowsSansVente6Mois] = await Promise.all([
- cachedFF(`stock-negatif:${magasin}`, () => pgGetStockNegatif(site)),
- cachedFF(`stock-sans-vente:${magasin}`, () => pgGetStockSansVente(site)),
- cachedFF(`stock-sans-vente-6-mois:${magasin}`, () => pgGetSansVente6Mois(site)),
- ]);
- donnees = { rowsNegatif, rowsSansVente, rowsSansVente6Mois };
- } catch (e) {
- console.error("[stock-negatif] chargement impossible :", e);
- erreur = e instanceof Error ? e.message : String(e);
- }
+ // Données FF recopiées chaque nuit : mises en cache par le serveur.
+ const resultat = usePageResult(`stock-negatif?${magasin}`, () =>
+ fetchPage("stock-negatif", { magasin }),
+ );
+ const donnees: DonneesStock | null = resultat.ok ? resultat.data : null;
+ const erreur: string | null = resultat.ok ? null : resultat.error;
const params = new URLSearchParams();
if (magasin) params.set("magasin", magasin);
diff --git a/src/app/api/admin/grid-warmup/route.ts b/src/app/api/admin/grid-warmup/route.ts
deleted file mode 100644
index 6e56bbd..0000000
--- a/src/app/api/admin/grid-warmup/route.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { adminOuReponse } from "@/lib/authz";
-import { pgGetFournisseurs } from "@/lib/pg-ff-client";
-import { getProductRows } from "@/features/grid/api/get-product-rows";
-import { listGridSuppliers } from "@/lib/grid-store";
-
-// Le préchauffage parcourt tous les fournisseurs : c'est long par nature. On rend la
-// main immédiatement et le client interroge GET pour suivre l'avancement.
-export const maxDuration = 300;
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * Préchauffage de l'instantané de grille (`grid_rows`).
- *
- * L'API `/api/v1` ne calcule jamais : elle lit un instantané écrit quand la Grille est
- * ouverte dans l'application. Sans préchauffage, un consommateur externe (ChatGPT) ne
- * verrait donc que les fournisseurs déjà consultés à la main.
- *
- * Ce job calcule chaque fournisseur une fois, séquentiellement — la persistance se fait
- * en effet de bord de `getProductRows()`. Séquentiel volontairement : le calcul est
- * lourd en SQL, le paralléliser saturerait PostgreSQL.
- */
-type WarmupStatus = "idle" | "running" | "success" | "error";
-
-interface WarmupJob {
- status: WarmupStatus;
- total: number;
- done: number;
- skipped: number;
- failed: number;
- currentFournisseur?: string;
- startedAt: string;
- finishedAt?: string;
- error?: string;
- lastErrors: string[];
-}
-
-let job: WarmupJob | null = null;
-
-function publicJob(j: WarmupJob | null) {
- if (!j) {
- return { status: "idle" as const, total: 0, done: 0, skipped: 0, failed: 0, lastErrors: [] };
- }
- return j;
-}
-
-async function runWarmup(j: WarmupJob, staleHours: number): Promise {
- try {
- const fournisseurs = await pgGetFournisseurs();
- // Les fournisseurs déjà calculés récemment sont sautés : un second passage
- // coûte alors quasiment rien, ce qui rend le bouton rejouable sans crainte.
- const existing = await listGridSuppliers();
- const freshLimit = Date.now() - staleHours * 3600_000;
- const fresh = new Set(
- existing
- .filter((s) => s.computedAt && new Date(s.computedAt).getTime() > freshLimit)
- .map((s) => s.codeFournisseur),
- );
-
- j.total = fournisseurs.length;
- console.log(`[grid-warmup] ${fournisseurs.length} fournisseurs, ${fresh.size} déjà à jour (< ${staleHours}h)`);
-
- for (const f of fournisseurs) {
- if (fresh.has(f.code)) {
- j.skipped++;
- continue;
- }
- j.currentFournisseur = `${f.code} — ${f.nom}`;
- try {
- await getProductRows({ codeFournisseur: f.code, magasin: "TOTAL", forceRefresh: true });
- j.done++;
- } catch (e) {
- j.failed++;
- const msg = `${f.code}: ${e instanceof Error ? e.message.slice(0, 120) : String(e)}`;
- // On garde une trace des derniers échecs sans faire exploser la mémoire.
- if (j.lastErrors.length < 10) j.lastErrors.push(msg);
- console.error("[grid-warmup]", msg);
- }
- }
-
- j.currentFournisseur = undefined;
- j.status = "success";
- j.finishedAt = new Date().toISOString();
- console.log(`[grid-warmup] terminé — ${j.done} calculés, ${j.skipped} à jour, ${j.failed} en échec`);
- } catch (e) {
- j.status = "error";
- j.error = e instanceof Error ? e.message : String(e);
- j.finishedAt = new Date().toISOString();
- console.error("[grid-warmup] échec global:", j.error);
- }
-}
-
-/** GET /api/admin/grid-warmup — avancement du préchauffage. */
-export async function GET() {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
- return NextResponse.json({ success: true, ...publicJob(job) });
-}
-
-/**
- * POST /api/admin/grid-warmup?staleHours=24
- * Démarre le préchauffage en arrière-plan et répond immédiatement.
- */
-export async function POST(req: NextRequest) {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- if (job?.status === "running") {
- return NextResponse.json({ success: true, ...publicJob(job) });
- }
-
- const raw = Number(req.nextUrl.searchParams.get("staleHours"));
- const staleHours = Number.isFinite(raw) ? Math.min(720, Math.max(0, raw)) : 24;
-
- job = {
- status: "running",
- total: 0,
- done: 0,
- skipped: 0,
- failed: 0,
- startedAt: new Date().toISOString(),
- lastErrors: [],
- };
- const current = job;
- console.log(`[grid-warmup] démarré (staleHours=${staleHours})`);
-
- void runWarmup(current, staleHours).catch((e) => {
- current.status = "error";
- current.error = e instanceof Error ? e.message : String(e);
- current.finishedAt = new Date().toISOString();
- });
-
- return NextResponse.json({ success: true, ...publicJob(job) });
-}
diff --git a/src/app/api/admin/sync/fournisseurs/route.ts b/src/app/api/admin/sync/fournisseurs/route.ts
deleted file mode 100644
index 292557e..0000000
--- a/src/app/api/admin/sync/fournisseurs/route.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { z } from "zod";
-import { asc, eq, inArray, sql } from "drizzle-orm";
-import { adminOuReponse } from "@/lib/authz";
-import { db } from "@/db";
-import { syncFournisseurs } from "@/db/schema";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET — la liste complète des fournisseurs paramétrés, avec l'état de leur
- * dernière synchronisation.
- *
- * Pas de pagination : quelques centaines de lignes tout au plus, et l'admin a
- * besoin de la vue d'ensemble pour décider qui cadencer.
- */
-export async function GET() {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- const rows = await db
- .select()
- .from(syncFournisseurs)
- .orderBy(asc(sql`coalesce(${syncFournisseurs.nomFournisseur}, ${syncFournisseurs.codeFournisseur})`));
-
- return NextResponse.json({
- success: true,
- fournisseurs: rows,
- resume: {
- total: rows.length,
- actifsSql: rows.filter((r) => r.actifSql).length,
- actifsQlik: rows.filter((r) => r.actifQlik).length,
- desactivesAuto: rows.filter((r) => r.desactiveMotif).length,
- enEchecSql: rows.filter((r) => r.dernierSqlStatut === "echec").length,
- enEchecQlik: rows.filter((r) => r.dernierQlikStatut === "echec").length,
- jamaisSql: rows.filter((r) => !r.dernierSqlAt).length,
- },
- });
-}
-
-const patchSchema = z.object({
- /** Codes visés. Permet d'activer ou désactiver en masse depuis la page. */
- codes: z.array(z.string().min(1)).min(1).max(2000),
- actifSql: z.boolean().optional(),
- actifQlik: z.boolean().optional(),
-}).refine((v) => v.actifSql !== undefined || v.actifQlik !== undefined, {
- message: "Préciser au moins actifSql ou actifQlik",
-});
-
-/**
- * PATCH — active ou désactive des fournisseurs, pour l'une ou l'autre source.
- *
- * Réactiver lève le motif de désactivation automatique : sans cela, un
- * fournisseur remis en service par l'admin garderait un « aucun article »
- * trompeur, alors même qu'il vient d'être rouvert volontairement.
- */
-export async function PATCH(req: NextRequest) {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- let body: unknown;
- try {
- body = await req.json();
- } catch {
- return NextResponse.json({ error: "Corps JSON invalide" }, { status: 400 });
- }
- const parsed = patchSchema.safeParse(body);
- if (!parsed.success) {
- return NextResponse.json(
- { error: "Paramètres invalides", details: parsed.error.issues.map((i) => i.message) },
- { status: 400 },
- );
- }
- const { codes, actifSql, actifQlik } = parsed.data;
-
- const reactivation = actifSql === true || actifQlik === true;
- const rows = await db
- .update(syncFournisseurs)
- .set({
- ...(actifSql !== undefined ? { actifSql } : {}),
- ...(actifQlik !== undefined ? { actifQlik } : {}),
- ...(reactivation ? { desactiveMotif: null } : {}),
- updatedAt: new Date(),
- })
- .where(codes.length === 1 ? eq(syncFournisseurs.codeFournisseur, codes[0]) : inArray(syncFournisseurs.codeFournisseur, codes))
- .returning({ code: syncFournisseurs.codeFournisseur });
-
- console.log(`[api/admin/sync] ${rows.length} fournisseur(s) mis à jour (sql=${actifSql} qlik=${actifQlik})`);
- return NextResponse.json({ success: true, misAJour: rows.length });
-}
diff --git a/src/app/api/admin/sync/route.ts b/src/app/api/admin/sync/route.ts
deleted file mode 100644
index 9989685..0000000
--- a/src/app/api/admin/sync/route.ts
+++ /dev/null
@@ -1,116 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { z } from "zod";
-import { adminOuReponse } from "@/lib/authz";
-import { readSyncSettings, saveSyncSettings } from "@/features/admin/api/sync-settings";
-import {
- getSyncSchedulerState,
- lancerRound,
- demanderArret,
- debutFenetre,
- seedSyncFournisseurs,
-} from "@/features/admin/api/sync-scheduler";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-// Un lancement manuel peut enchaîner plusieurs fournisseurs.
-export const maxDuration = 300;
-
-/** GET — réglages, état courant, et prochaine ouverture de fenêtre. */
-export async function GET() {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- const settings = await readSyncSettings();
- const maintenant = new Date();
- const debut = debutFenetre(settings, maintenant);
-
- return NextResponse.json({
- success: true,
- settings,
- state: getSyncSchedulerState(),
- /** true = on est actuellement dans la fenêtre nocturne. */
- dansLaFenetre: debut !== null,
- fenetreDebutAt: debut?.toISOString() ?? null,
- maintenant: maintenant.toISOString(),
- });
-}
-
-const settingsSchema = z.object({
- actif: z.boolean().optional(),
- heureDebut: z.coerce.number().int().min(0).max(23).optional(),
- heureFin: z.coerce.number().int().min(0).max(23).optional(),
- qlikParNuit: z.coerce.number().int().min(0).max(200).optional(),
- sqlParQlik: z.coerce.number().int().min(1).max(500).optional(),
- qlikMinJours: z.coerce.number().int().min(0).max(365).optional(),
-});
-
-/** PATCH — met à jour les réglages. */
-export async function PATCH(req: NextRequest) {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- let body: unknown;
- try {
- body = await req.json();
- } catch {
- return NextResponse.json({ error: "Corps JSON invalide" }, { status: 400 });
- }
- const parsed = settingsSchema.safeParse(body);
- if (!parsed.success) {
- return NextResponse.json(
- { error: "Paramètres invalides", details: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`) },
- { status: 400 },
- );
- }
-
- const settings = await saveSyncSettings(parsed.data);
- return NextResponse.json({ success: true, settings });
-}
-
-const actionSchema = z.object({
- action: z.enum(["start", "stop", "seed"]),
- /**
- * Lancement manuel hors de la fenêtre nocturne. Réservé à l'admin qui sait
- * ce qu'il fait : en pleine journée, la charge est visible par les magasins.
- */
- forcer: z.boolean().optional(),
-});
-
-/** POST — démarre un round manuellement, l'arrête, ou resynchronise la liste. */
-export async function POST(req: NextRequest) {
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- let body: unknown;
- try {
- body = await req.json();
- } catch {
- return NextResponse.json({ error: "Corps JSON invalide" }, { status: 400 });
- }
- const parsed = actionSchema.safeParse(body);
- if (!parsed.success) {
- return NextResponse.json({ error: "Action inconnue (start, stop ou seed)" }, { status: 400 });
- }
-
- if (parsed.data.action === "seed") {
- const n = await seedSyncFournisseurs();
- return NextResponse.json({ success: true, fournisseurs: n });
- }
-
- if (parsed.data.action === "stop") {
- demanderArret();
- return NextResponse.json({ success: true, state: getSyncSchedulerState() });
- }
-
- const etat = getSyncSchedulerState();
- if (etat.enCours) {
- return NextResponse.json({ error: "Un round est déjà en cours.", state: etat }, { status: 409 });
- }
-
- // Fire-and-forget : le round dure des minutes, le client suit via GET.
- void lancerRound("manuel", parsed.data.forcer === true).catch((e) => {
- console.error("[api/admin/sync] round manuel en échec :", e instanceof Error ? e.message : String(e));
- });
-
- return NextResponse.json({ success: true, state: getSyncSchedulerState() });
-}
diff --git a/src/app/api/auth/[...nextauth]/route.ts b/src/app/api/auth/[...nextauth]/route.ts
deleted file mode 100644
index 73228a0..0000000
--- a/src/app/api/auth/[...nextauth]/route.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import { handlers } from "@/lib/auth";
-export const { GET, POST } = handlers;
diff --git a/src/app/api/commandes-auto/route.ts b/src/app/api/commandes-auto/route.ts
deleted file mode 100644
index 8a7cf2b..0000000
--- a/src/app/api/commandes-auto/route.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { sessionOuReponse } from "@/lib/authz";
-
-const FF_API_BASE = process.env.FF_API_BASE_URL ?? "https://api.ffnancy.fr";
-
-/**
- * GET /api/commandes-auto[?site=292&codefou=N009]
- *
- * Proxy vers https://api.ffnancy.fr/api/commandes-auto
- * Transfère les query params site et codefou si présents.
- */
-export async function GET(req: NextRequest) {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- try {
- const { searchParams } = req.nextUrl;
- const params = new URLSearchParams();
- if (searchParams.get("site")) params.set("site", searchParams.get("site")!);
- if (searchParams.get("codefou")) params.set("codefou", searchParams.get("codefou")!);
-
- const qs = params.toString();
- const url = `${FF_API_BASE}/api/commandes-auto${qs ? `?${qs}` : ""}`;
-
- const res = await fetch(url, { cache: "no-store" });
- if (!res.ok) {
- return NextResponse.json({ error: `API upstream HTTP ${res.status}` }, { status: res.status });
- }
- const data = await res.json();
- return NextResponse.json(data);
- } catch (e) {
- console.error("[api/commandes-auto]", e);
- return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
- }
-}
diff --git a/src/app/api/diag/route.ts b/src/app/api/diag/route.ts
deleted file mode 100644
index 6f6c796..0000000
--- a/src/app/api/diag/route.ts
+++ /dev/null
@@ -1,294 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { db } from "@/db";
-import { sql } from "drizzle-orm";
-import { adminOuReponse } from "@/lib/authz";
-
-const FF_API_BASE = process.env.FF_API_BASE_URL ?? "https://api.ffnancy.fr";
-
-async function probe(url: string) {
- try {
- const res = await fetch(url, { cache: "no-store" });
- const text = await res.text();
- let parsed: unknown = null;
- try { parsed = JSON.parse(text); } catch { parsed = text.slice(0, 800); }
- let summary: unknown = parsed;
- if (Array.isArray(parsed)) {
- summary = { count: parsed.length, firstKeys: parsed[0] ? Object.keys(parsed[0]) : [], sample: parsed.slice(0, 2) };
- } else if (parsed && typeof parsed === "object") {
- const keys = Object.keys(parsed as object);
- const firstArrayKey = keys.find(k => Array.isArray((parsed as Record)[k]));
- if (firstArrayKey) {
- const arr = (parsed as Record)[firstArrayKey];
- summary = { wrapper: firstArrayKey, count: arr.length, firstKeys: arr[0] ? Object.keys(arr[0] as object) : [], sample: arr.slice(0, 2) };
- } else {
- // Objet simple : montrer toutes les clés et le contenu complet
- summary = { keys, full: parsed };
- }
- }
- return { status: res.status, url, summary };
- } catch (e) {
- return { error: String(e), url };
- }
-}
-
-export async function GET(req: NextRequest) {
- const acces = await adminOuReponse();
- if (acces instanceof Response) return acces;
-
- const { searchParams } = new URL(req.url);
-
- // Date range: 12 derniers mois
- const now = new Date();
- const dateFin = new Date(now.getFullYear(), now.getMonth(), 0).toISOString().slice(0, 10);
- const dateDebut = new Date(now.getFullYear(), now.getMonth() - 12, 1).toISOString().slice(0, 10);
-
- // Récupérer un codefou réel + un codein réel depuis l'API
- let codefou = searchParams.get("codefou");
- let firstCodein: string | null = searchParams.get("codein");
- const forcedNoid = searchParams.get("noid"); // ex: ?noid=129632
-
- if (!codefou) {
- try {
- const res = await fetch(`${FF_API_BASE}/api/fournisseurs?limit=1`, { cache: "no-store" });
- const data = await res.json();
- const list = Array.isArray(data) ? data : (Object.values(data).find(v => Array.isArray(v)) as unknown[] ?? []);
- if (list.length > 0) codefou = (list[0] as Record).codefou as string ?? null;
- } catch { /* ignore */ }
- codefou ??= "D005";
- }
-
- if (!firstCodein) {
- try {
- const res = await fetch(`${FF_API_BASE}/api/articles?codefou=${encodeURIComponent(codefou)}&limit=1`, { cache: "no-store" });
- const data = await res.json();
- const list = Array.isArray(data) ? data : (Object.values(data).find(v => Array.isArray(v)) as unknown[] ?? []);
- if (list.length > 0) firstCodein = (list[0] as Record).codein as string ?? null;
- } catch { /* ignore */ }
- }
-
- // Si un noid est forcé, on probe directement mensuel + referentiel pour cet article
- const mensuelNoidForced = forcedNoid
- ? probe(`${FF_API_BASE}/api/articles/${encodeURIComponent(forcedNoid)}/mensuel?dateDebut=${dateDebut}&dateFin=${dateFin}`)
- : Promise.resolve({ skipped: "no ?noid= param" });
- const referentielNoidForced = forcedNoid
- ? probe(`${FF_API_BASE}/api/articles/${encodeURIComponent(forcedNoid)}/referentiel`)
- : Promise.resolve({ skipped: "no ?noid= param" });
-
- const [
- fournisseurs,
- articles,
- mvt_dateDebut,
- mensuel_noid,
- referentiel,
- mensuel_forced,
- referentiel_forced,
- ] = await Promise.all([
- probe(`${FF_API_BASE}/api/fournisseurs?limit=2`),
- probe(`${FF_API_BASE}/api/articles?codefou=${encodeURIComponent(codefou)}&limit=2`),
- probe(`${FF_API_BASE}/api/mouvements/articles?codefou=${encodeURIComponent(codefou)}&dateDebut=${dateDebut}&dateFin=${dateFin}&limit=2`),
- // Test mensuel avec no_id auto-résolu
- firstCodein
- ? (async () => {
- try {
- const res = await fetch(`${FF_API_BASE}/api/articles?codefou=${encodeURIComponent(codefou)}&limit=1`, { cache: "no-store" });
- const data = await res.json();
- const list = Array.isArray(data) ? data : (Object.values(data).find(v => Array.isArray(v)) as unknown[] ?? []);
- const noid = list[0] ? (list[0] as Record).no_id as string : null;
- if (noid) return probe(`${FF_API_BASE}/api/articles/${encodeURIComponent(noid)}/mensuel?dateDebut=${dateDebut}&dateFin=${dateFin}`);
- } catch { /* ignore */ }
- return { skipped: "no no_id available" };
- })()
- : Promise.resolve({ skipped: "no article" }),
- // Referentiel complet (nomenclature + gamme + stock + prix)
- firstCodein
- ? (async () => {
- try {
- const res = await fetch(`${FF_API_BASE}/api/articles?codefou=${encodeURIComponent(codefou)}&limit=5`, { cache: "no-store" });
- const data = await res.json();
- const list = Array.isArray(data) ? data : (Object.values(data).find(v => Array.isArray(v)) as unknown[] ?? []);
- const art = (list[4] ?? list[0]) as Record | undefined;
- const noId = art?.no_id as string ?? null;
- if (noId) return probe(`${FF_API_BASE}/api/articles/${encodeURIComponent(noId)}/referentiel`);
- } catch { /* ignore */ }
- return { skipped: "no no_id" };
- })()
- : Promise.resolve({ skipped: "no codefou" }),
- mensuelNoidForced,
- referentielNoidForced,
- ]);
-
- // Test PostgreSQL + diagnostic ventesProduits
- let postgresql: unknown;
- let ventesProduitsDiag: unknown;
- try {
- const r = await db.execute(sql`SELECT COUNT(*) as count FROM session_snapshots`);
-
- // Diagnostic ventesProduits : cherche par les 2 codes possibles d'AUXENCE
- const vpByName = await db.execute(sql`
- SELECT code_fournisseur, COUNT(*) as nb_rows,
- COUNT(code_gamme) as nb_gamme,
- COUNT(code_gamme_init) as nb_gamme_init,
- COUNT(code3) as nb_code3
- FROM ventes_produits
- WHERE code_fournisseur IN ('AUXENCE', 'A025', ${codefou})
- GROUP BY code_fournisseur
- `);
-
- // Sample de quelques codeins dans ventesProduits pour ce fournisseur
- const vpSample = await db.execute(sql`
- SELECT codein, code_fournisseur, code_gamme, code_gamme_init, code3, libelle3
- FROM ventes_produits
- WHERE code_fournisseur IN ('AUXENCE', 'A025', ${codefou})
- LIMIT 3
- `);
-
- postgresql = {
- ok: true,
- snapshots: Number(r.rows[0]?.count ?? 0),
- };
- ventesProduitsDiag = {
- byFournisseur: vpByName.rows,
- sample: vpSample.rows,
- };
- } catch (e) {
- postgresql = { ok: false, error: String(e) };
- ventesProduitsDiag = { error: String(e) };
- }
-
- // Diagnostic analytics CA TTC
- let mvtartDiag: unknown;
- try {
- // 1. Totaux mars 2025 avec mntmvtht et mntmvtttc pour comparer avec API (HT=225k, TTC=269k)
- const totaux = await db.execute(sql`
- SELECT site,
- ABS(SUM(mntmvtht))::float AS sum_ht,
- ABS(SUM(mntmvtttc))::float AS sum_ttc,
- COUNT(*) AS nb_lignes
- FROM mvtart
- WHERE genremvt = 3
- AND TO_CHAR(datmvt, 'YYYY-MM') = '2025-03'
- AND site IN ('292', '579')
- GROUP BY site
- `);
- // 2. Distribution des valeurs de preference dans artfou1
- const prefDist = await db.execute(sql`
- SELECT preference, COUNT(*) AS nb
- FROM artfou1
- GROUP BY preference
- ORDER BY preference
- `);
- // 3. Ventes mars 2025 non attribuées (aucune ligne artfou1 avec preference=1)
- const sansPreference = await db.execute(sql`
- SELECT COUNT(DISTINCT m.artnoid) AS nb_articles_sans_pref
- FROM mvtart m
- JOIN articles a ON a.no_id = m.artnoid
- WHERE m.genremvt = 3
- AND TO_CHAR(m.datmvt, 'YYYY-MM') = '2025-03'
- AND m.site IN ('292','579')
- AND NOT EXISTS (
- SELECT 1 FROM artfou1 af
- WHERE af.art_no_id = a.no_id AND af.preference = 1
- )
- `);
- mvtartDiag = {
- totaux_202503: totaux.rows,
- artfou1_preference_distribution: prefDist.rows,
- articles_vendus_sans_pref1: sansPreference.rows,
- };
- } catch (e) {
- mvtartDiag = { error: String(e) };
- }
-
- // Diagnostic franco : colonnes DB avec "franco" + sample fouident + raw commandes-auto
- let francoDiag: unknown;
- try {
- const francoColumns = await db.execute(sql`
- SELECT table_name, column_name, data_type
- FROM information_schema.columns
- WHERE column_name ILIKE '%franco%'
- OR column_name ILIKE '%min_cmd%'
- OR column_name ILIKE '%mincde%'
- OR column_name ILIKE '%min_commande%'
- ORDER BY table_name, column_name
- `);
- // Sample des 3 premières lignes de fouident pour voir toutes les colonnes
- const fouidentSample = await db.execute(sql`SELECT * FROM fouident LIMIT 3`);
- const foucadSample = await db.execute(sql`SELECT * FROM foucad LIMIT 5`);
- francoDiag = {
- francoColumns: francoColumns.rows,
- fouidentColumns: fouidentSample.rows.length > 0 ? Object.keys(fouidentSample.rows[0] as object) : [],
- fouidentSample: fouidentSample.rows,
- foucadColumns: foucadSample.rows.length > 0 ? Object.keys(foucadSample.rows[0] as object) : [],
- foucadSample: foucadSample.rows,
- };
- } catch (e) {
- francoDiag = { error: String(e) };
- }
-
- // Raw commandes-auto : récupère toutes les lignes et filtre celles avec franco_ht manquant
- let commandesAutoFrancoAudit: unknown;
- try {
- const caRes = await fetch(`${FF_API_BASE}/api/commandes-auto`, { cache: "no-store" });
- const caData = await caRes.json();
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- const caRows: any[] = Array.isArray(caData) ? caData : (caData?.propositions ?? caData?.data ?? []);
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- const withFranco = caRows.filter((r: any) => r.franco_ht != null && Number(r.franco_ht) > 0);
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- const withoutFranco = caRows.filter((r: any) => r.franco_ht == null || Number(r.franco_ht) === 0);
- commandesAutoFrancoAudit = {
- total: caRows.length,
- avecFranco: withFranco.length,
- sansFranco: withoutFranco.length,
- lignesSansFranco: withoutFranco.map((r: any) => ({
- site: r.site, codefou: r.codefou, nom_fou: r.nom_fou,
- franco_ht: r.franco_ht, franco_atteint: r.franco_atteint,
- })),
- };
- } catch (e) {
- commandesAutoFrancoAudit = { error: String(e) };
- }
-
- // Probe des fournisseurs N/A pour trouver où est leur franco
- const [
- detailM036_292,
- detailM030_579,
- fournisseurM036,
- fournisseurM030,
- ] = await Promise.all([
- probe(`${FF_API_BASE}/api/commandes-auto/M036?site=292`),
- probe(`${FF_API_BASE}/api/commandes-auto/M030?site=579`),
- probe(`${FF_API_BASE}/api/fournisseurs/M036`),
- probe(`${FF_API_BASE}/api/fournisseurs/M030`),
- ]);
- const francoNaProbe = { detailM036_292, detailM030_579, fournisseurM036, fournisseurM030 };
-
- // Raw commandes-auto (premier fournisseur) pour voir les champs réels retournés par l'API
- const rawCommandesAuto = await probe(`${FF_API_BASE}/api/commandes-auto`);
-
- return NextResponse.json({
- timestamp: new Date().toISOString(),
- dateRange: { dateDebut, dateFin },
- codefouTested: codefou,
- firstCodeinTested: firstCodein,
- forcedNoid: forcedNoid ?? "(none — pass ?noid=129632 to test a specific article)",
- fournisseurs,
- articles,
- mouvements_dateDebut: mvt_dateDebut,
- endpoints_auto: {
- "articles/:no_id/mensuel": mensuel_noid,
- "articles/:no_id/referentiel": referentiel,
- },
- endpoints_forced_noid: {
- "articles/:noid/mensuel": mensuel_forced,
- "articles/:noid/referentiel": referentiel_forced,
- },
- postgresql,
- ventesProduitsDiag,
- mvtartDiag,
- francoDiag,
- rawCommandesAuto,
- commandesAutoFrancoAudit,
- francoNaProbe,
- });
-}
diff --git a/src/app/api/diag/stock-fournisseur/route.ts b/src/app/api/diag/stock-fournisseur/route.ts
deleted file mode 100644
index 44aa7c4..0000000
--- a/src/app/api/diag/stock-fournisseur/route.ts
+++ /dev/null
@@ -1,25 +0,0 @@
-import { NextResponse } from "next/server";
-import { pgDiagFournisseurDerniereEntree } from "@/lib/pg-ff-client";
-import { adminOuReponse } from "@/lib/authz";
-
-export const dynamic = "force-dynamic";
-
-/**
- * Diagnostic de l'attribution « fournisseur de la dernière entrée » utilisée par
- * la page Gestion de Stock.
- *
- * `colonneDetectee: null` signifie que `mvtart` ne porte aucune des colonnes
- * fournisseur connues : la page retombe alors sur `artfou1.preference = 1`.
- * `colonnesMvtart` liste ce qui existe réellement, pour compléter la liste
- * blanche `MVTART_FOU_CANDIDATES` si le nom diffère.
- */
-export async function GET() {
- const acces = await adminOuReponse();
- if (acces instanceof Response) return acces;
-
- try {
- return NextResponse.json(await pgDiagFournisseurDerniereEntree());
- } catch (e) {
- return NextResponse.json({ error: String(e) }, { status: 500 });
- }
-}
diff --git a/src/app/api/export/excel/route.ts b/src/app/api/export/excel/route.ts
deleted file mode 100644
index 7eace0c..0000000
--- a/src/app/api/export/excel/route.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import ExcelJS from "exceljs";
-import { z } from "zod";
-import { sessionOuReponse } from "@/lib/authz";
-
-const ExportSchema = z.object({
- nomFournisseur: z.string(),
- rows: z.array(z.object({
- codein: z.string(),
- libelle1: z.string(),
- code3: z.string(),
- libelle3: z.string(),
- codeGamme: z.string().nullable(),
- totalQuantite: z.number(),
- totalCa: z.number(),
- tauxMarge: z.number(),
- // Before gamme for delta
- gammeAvant: z.string().nullable().optional(),
- })),
-});
-
-export async function POST(req: NextRequest) {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- const body = await req.json();
- const parsed = ExportSchema.safeParse(body);
- if (!parsed.success) {
- return NextResponse.json({ error: "Invalid payload" }, { status: 400 });
- }
-
- const { nomFournisseur, rows } = parsed.data;
- const workbook = new ExcelJS.Workbook();
- workbook.creator = "CollectFlow";
- workbook.created = new Date();
-
- const sheet = workbook.addWorksheet("Assortiment", {
- views: [{ state: "frozen", ySplit: 1 }],
- });
-
- // Header style
- const headerStyle: Partial = {
- font: { bold: true, color: { argb: "FFFFFFFF" } },
- fill: { type: "pattern", pattern: "solid", fgColor: { argb: "FF0F172A" } },
- alignment: { horizontal: "center" },
- border: { bottom: { style: "thin", color: { argb: "FF334155" } } },
- };
-
- sheet.columns = [
- { header: "Code", key: "codein", width: 14 },
- { header: "Désignation", key: "libelle1", width: 40 },
- { header: "Nomenclature", key: "libelle3", width: 25 },
- { header: "Gamme Avant", key: "gammeAvant", width: 14 },
- { header: "Gamme Après", key: "codeGamme", width: 14 },
- { header: "Delta", key: "delta", width: 10 },
- { header: "Vol. 12m", key: "totalQuantite", width: 12 },
- { header: "CA 12m (€)", key: "totalCa", width: 14 },
- { header: "Marge (%)", key: "tauxMarge", width: 12 },
- ];
-
- // Apply header style
- sheet.getRow(1).eachCell((cell) => { Object.assign(cell, headerStyle); });
- sheet.getRow(1).height = 22;
-
- // Gamme colours
- const GAMME_COLORS: Record = {
- A: "FF064E3B", B: "FF1E3A5F", C: "FF78350F", Z: "FF4C0519",
- };
-
- for (const row of rows) {
- const delta = row.gammeAvant !== row.codeGamme ? `${row.gammeAvant ?? "—"} → ${row.codeGamme ?? "—"}` : "";
- const excelRow = sheet.addRow({
- codein: row.codein,
- libelle1: row.libelle1,
- libelle3: row.libelle3,
- gammeAvant: row.gammeAvant ?? "—",
- codeGamme: row.codeGamme ?? "—",
- delta,
- totalQuantite: Math.round(row.totalQuantite),
- totalCa: parseFloat(row.totalCa.toFixed(2)),
- tauxMarge: parseFloat(row.tauxMarge.toFixed(2)),
- });
-
- // Colour the "Gamme Après" cell
- const gammeCell = excelRow.getCell("codeGamme");
- if (row.codeGamme && GAMME_COLORS[row.codeGamme]) {
- gammeCell.fill = { type: "pattern", pattern: "solid", fgColor: { argb: GAMME_COLORS[row.codeGamme] } };
- gammeCell.font = { bold: true, color: { argb: "FFFFFFFF" } };
- }
-
- // Highlight changed rows
- if (delta) {
- excelRow.getCell("delta").font = { bold: true, color: { argb: "FFFBBF24" } };
- }
-
- // Format numbers
- excelRow.getCell("totalCa").numFmt = '#,##0.00 "€"';
- excelRow.getCell("tauxMarge").numFmt = '0.00"%"';
- }
-
- // Generate buffer
- const buffer = await workbook.xlsx.writeBuffer();
-
- const filename = `Assortiment_${nomFournisseur.replace(/\s+/g, "_")}_${new Date().toISOString().slice(0, 10)}.xlsx`;
-
- return new NextResponse(buffer, {
- headers: {
- "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
- "Content-Disposition": `attachment; filename="${filename}"`,
- },
- });
-}
diff --git a/src/app/api/export/modified-gammes/route.ts b/src/app/api/export/modified-gammes/route.ts
deleted file mode 100644
index 600817f..0000000
--- a/src/app/api/export/modified-gammes/route.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import ExcelJS from "exceljs";
-import { z } from "zod";
-import { sessionOuReponse } from "@/lib/authz";
-
-const ExportModifiedGammesSchema = z.object({
- nomFournisseur: z.string(),
- changes: z.array(z.object({
- codein: z.string(),
- gtin: z.string(),
- codeFournisseur: z.string().optional(),
- gamme: z.string(),
- })),
-});
-
-export async function POST(req: NextRequest) {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- const body = await req.json();
- const parsed = ExportModifiedGammesSchema.safeParse(body);
- if (!parsed.success) {
- return NextResponse.json({ error: "Invalid payload" }, { status: 400 });
- }
-
- const { nomFournisseur, changes } = parsed.data;
- const workbook = new ExcelJS.Workbook();
- workbook.creator = "CollectFlow";
- workbook.created = new Date();
-
- const sheet = workbook.addWorksheet("Gammes Modifiées", {
- views: [{ state: "frozen", ySplit: 1 }],
- });
-
- // Header style
- const headerStyle: Partial = {
- font: { bold: true, color: { argb: "FFFFFFFF" } },
- fill: { type: "pattern", pattern: "solid", fgColor: { argb: "FF0F172A" } },
- alignment: { horizontal: "center" },
- border: { bottom: { style: "thin", color: { argb: "FF334155" } } },
- };
-
- sheet.columns = [
- { header: "CODE FOURNISSEUR", key: "codeFournisseur", width: 22 },
- { header: "CODEIN", key: "codein", width: 18 },
- { header: "GAMME", key: "gamme", width: 12 },
- ];
-
- // Apply header style
- sheet.getRow(1).eachCell((cell) => { Object.assign(cell, headerStyle); });
- sheet.getRow(1).height = 22;
-
- for (const row of changes) {
- sheet.addRow({
- codeFournisseur: row.codeFournisseur || "—",
- codein: row.codein || "—",
- gamme: row.gamme || "—",
- });
- }
-
- // Centrer la colonne Gamme
- const gammeCol = sheet.getColumn("gamme");
- gammeCol.alignment = { horizontal: "center" };
-
- // Format en texte pour eviter la notation scientifique excel
- sheet.getColumn("codeFournisseur").numFmt = "@";
- sheet.getColumn("codein").numFmt = "@";
-
- // Generate buffer
- const buffer = await workbook.xlsx.writeBuffer();
-
- const filename = `Modifications_Gammes_${nomFournisseur.replace(/\s+/g, "_")}_${new Date().toISOString().slice(0, 10)}.xlsx`;
-
- return new NextResponse(buffer, {
- headers: {
- "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
- "Content-Disposition": `attachment; filename="${filename}"`,
- },
- });
-}
diff --git a/src/app/api/ff-status/route.ts b/src/app/api/ff-status/route.ts
deleted file mode 100644
index 02dbe50..0000000
--- a/src/app/api/ff-status/route.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { NextResponse } from "next/server";
-import { diagnostiquerApiFf } from "@/features/settings/ff-api-diagnostic";
-import { sessionOuReponse } from "@/lib/authz";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/ff-status — état de l'API REST FF Nancy.
- *
- * S'appuie sur le même diagnostic que le bouton « Tester » des Paramètres, afin
- * qu'un échec dise *pourquoi* (DNS, connexion refusée, délai dépassé, code HTTP)
- * et *quelle adresse* a été appelée. L'ancienne version renvoyait un 503 sans
- * détail, impossible à distinguer d'une simple erreur d'URL.
- */
-export async function GET() {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- const res = await diagnostiquerApiFf();
- if (!res.success) {
- return NextResponse.json(
- { error: "API FF Nancy non disponible", url: res.url, detail: res.error },
- { status: 503 },
- );
- }
- return NextResponse.json(res.status);
-}
diff --git a/src/app/api/grid/rows/route.ts b/src/app/api/grid/rows/route.ts
deleted file mode 100644
index a12e9d6..0000000
--- a/src/app/api/grid/rows/route.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-import { NextRequest } from "next/server";
-import { getProductRows } from "@/features/grid/api/get-product-rows";
-import { sessionOuReponse } from "@/lib/authz";
-import type { GridFilters } from "@/types/grid";
-
-export const dynamic = "force-dynamic";
-
-const encoder = new TextEncoder();
-
-function writeNdjson(controller: ReadableStreamDefaultController, value: unknown) {
- controller.enqueue(encoder.encode(`${JSON.stringify(value)}\n`));
-}
-
-export async function GET(request: NextRequest) {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- const searchParams = request.nextUrl.searchParams;
- const codeFournisseur = searchParams.get("fournisseur");
-
- if (!codeFournisseur) {
- return Response.json({ error: "Missing fournisseur" }, { status: 400 });
- }
-
- const magasin = searchParams.get("magasin") ?? "TOTAL";
- const chunkSize = Math.max(50, Math.min(500, Number(searchParams.get("chunkSize") ?? 150)));
- // `code3` n'est volontairement pas lu : la Grille applique ce filtre en local
- // (getProductRows ne s'en sert pas) et il accepte désormais plusieurs valeurs.
- const filters: Partial = {
- code1: searchParams.get("code1"),
- code2: searchParams.get("code2"),
- };
- const forceRefresh = searchParams.get("refresh") === "1";
-
- // Client parti (changement de fournisseur, page quittée) : on arrête de
- // sérialiser et d'envoyer. Le calcul lui-même continue — il est partagé et
- // mis en cache, la prochaine ouverture en profitera.
- let cancelled = false;
- request.signal.addEventListener("abort", () => { cancelled = true; });
-
- const stream = new ReadableStream({
- cancel() {
- cancelled = true;
- },
- async start(controller) {
- try {
- writeNdjson(controller, { type: "start", loaded: 0, total: null });
- const rows = await getProductRows({ codeFournisseur, magasin, filters, forceRefresh });
- if (cancelled) return;
- const total = rows.length;
-
- for (let start = 0; start < total; start += chunkSize) {
- if (cancelled) return;
- const chunk = rows.slice(start, start + chunkSize);
- writeNdjson(controller, {
- type: "chunk",
- rows: chunk,
- loaded: Math.min(start + chunk.length, total),
- total,
- });
- await new Promise((resolve) => setTimeout(resolve, 0));
- }
-
- writeNdjson(controller, { type: "done", loaded: total, total });
- } catch (error) {
- if (cancelled) return;
- writeNdjson(controller, {
- type: "error",
- error: error instanceof Error ? error.message : "Unknown error",
- });
- } finally {
- try {
- controller.close();
- } catch {
- /* flux déjà fermé côté client */
- }
- }
- },
- });
-
- return new Response(stream, {
- headers: {
- "Content-Type": "application/x-ndjson; charset=utf-8",
- "Cache-Control": "no-store",
- "X-Accel-Buffering": "no",
- },
- });
-}
diff --git a/src/app/api/grid/rows/store-patch/route.ts b/src/app/api/grid/rows/store-patch/route.ts
deleted file mode 100644
index 35b2263..0000000
--- a/src/app/api/grid/rows/store-patch/route.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { NextRequest } from "next/server";
-import { getStorePatch } from "@/features/grid/api/get-product-rows";
-import { MAGASINS } from "@/lib/magasins";
-import { sessionOuReponse } from "@/lib/authz";
-
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/grid/rows/store-patch?fournisseur=…&magasin=…
- *
- * Complément de l'API FF pour un magasin (cf. `features/grid/lib/store-patch.ts`).
- * La Grille charge toujours les lignes « tous magasins » et applique ce
- * complément à son arrivée : le changement de magasin n'attend plus rien.
- */
-export async function GET(request: NextRequest) {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- const codeFournisseur = request.nextUrl.searchParams.get("fournisseur");
- const magasin = request.nextUrl.searchParams.get("magasin") ?? "";
- // Un code inconnu ferait de chaque article un candidat : autant d'appels
- // inutiles à l'API FF. « Tous magasins » n'a pas de complément.
- if (!codeFournisseur || !MAGASINS.some((m) => m.code === magasin)) {
- return Response.json({ error: "Paramètres fournisseur et magasin requis." }, { status: 400 });
- }
-
- try {
- const patch = await getStorePatch(codeFournisseur, magasin);
- return Response.json(patch, { headers: { "Cache-Control": "no-store" } });
- } catch (error) {
- console.error(`[store-patch] ${codeFournisseur}/${magasin} KO:`, (error as Error).message?.slice(0, 200));
- return Response.json({ error: "Complément indisponible." }, { status: 502 });
- }
-}
diff --git a/src/app/api/logs/route.ts b/src/app/api/logs/route.ts
deleted file mode 100644
index 56adf2d..0000000
--- a/src/app/api/logs/route.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * CollectFlow — Journaux serveur des jobs (liste + téléchargement).
- *
- * `GET /api/logs` → liste des journaux disponibles (JSON)
- * `GET /api/logs?id=` → le journal complet en pièce jointe (text/plain)
- *
- * Réservé aux admins : un journal d'extraction contient les diagnostics internes
- * du modèle Qlik et les codes articles manipulés. Aucun secret n'y transite —
- * l'extracteur ne journalise que le NOM du cookie de session, jamais sa valeur,
- * et jamais le mot de passe Qlik.
- */
-
-import { NextRequest, NextResponse } from "next/server";
-import { adminOuReponse } from "@/lib/authz";
-import { listCaptures, readCapture } from "@/lib/log-capture";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-export async function GET(req: NextRequest) {
- const refus = await adminOuReponse();
- if (refus instanceof Response) return refus;
-
- const id = req.nextUrl.searchParams.get("id");
- if (!id) {
- return NextResponse.json({ success: true, logs: await listCaptures() });
- }
-
- const contenu = await readCapture(id);
- if (contenu == null) {
- return NextResponse.json({ error: "Journal introuvable ou expiré" }, { status: 404 });
- }
-
- // Nom de fichier assaini : l'id vient d'un job interne, mais il finit dans
- // un en-tête HTTP.
- const nom = `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.log`;
- return new NextResponse(contenu, {
- status: 200,
- headers: {
- "Content-Type": "text/plain; charset=utf-8",
- "Content-Disposition": `attachment; filename="${nom}"`,
- "Cache-Control": "no-store",
- },
- });
-}
diff --git a/src/app/api/produits/opportunites/route.ts b/src/app/api/produits/opportunites/route.ts
deleted file mode 100644
index 9d2ecea..0000000
--- a/src/app/api/produits/opportunites/route.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { sessionOuReponse } from "@/lib/authz";
-import { pgGetOpportunitesFamille } from "@/lib/pg-ff-client";
-import { buildLast12MonthsRange } from "@/lib/api-ff-client";
-
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/produits/opportunites?nomNoId=123
- *
- * Produits de la même nomenclature, classés par écart entre performance réseau
- * et performance locale (quantités par magasin). Chargé à la demande depuis la
- * fiche produit : la requête agrège `mvtart` sur 12 mois pour toute la famille,
- * on ne veut pas la payer au chargement de la page.
- */
-export async function GET(req: NextRequest) {
- const acces = await sessionOuReponse();
- if (acces instanceof Response) return acces;
-
- const raw = req.nextUrl.searchParams.get("nomNoId");
- const nomNoId = Number(raw);
- if (!raw || !Number.isInteger(nomNoId) || nomNoId <= 0) {
- return NextResponse.json({ error: "Param 'nomNoId' invalide" }, { status: 400 });
- }
-
- try {
- const { dateDebut, dateFin } = buildLast12MonthsRange();
- const rows = await pgGetOpportunitesFamille(nomNoId, dateDebut, dateFin);
- return NextResponse.json({ success: true, rows });
- } catch (e) {
- console.error("[api/produits/opportunites]", (e as Error).message?.slice(0, 250));
- return NextResponse.json({ error: "Erreur serveur" }, { status: 500 });
- }
-}
diff --git a/src/app/api/produits/search/route.ts b/src/app/api/produits/search/route.ts
deleted file mode 100644
index d282d95..0000000
--- a/src/app/api/produits/search/route.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { sessionOuReponse } from "@/lib/authz";
-import { demarrerRecherche, etatRecherche } from "@/features/produits/api/search-produits";
-
-// Les réponses sont immédiates (le travail Qlik tourne en tâche de fond), mais on
-// garde le runtime Node.js : Playwright/Chromium ne tourne pas en edge, et l'état
-// des jobs vit dans la mémoire du process.
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * Recherche produit **Qlik d'abord** — API asynchrone.
- *
- * `POST /api/produits/search?q=[&force=1]` démarre la recherche et rend la
- * main tout de suite. `GET /api/produits/search?q=` renvoie l'avancement,
- * puis le résultat.
- *
- * Pourquoi asynchrone : une recherche enchaîne deux allers-retours Qlik (dont une
- * extraction mensuelle) et peut dépasser la minute. Une requête HTTP maintenue
- * aussi longtemps se fait couper par le reverse proxy, qui répond une page
- * d'erreur **HTML** — le client échouait alors sur « Unexpected token '<' … is
- * not valid JSON ». Même schéma que `POST /api/qlik/sync`.
- *
- * Contrôle de session explicite en plus du middleware : il répond ici en JSON,
- * et relit le compte en base (cf. lib/authz).
- */
-
-function lireTerme(req: NextRequest): string | null {
- const q = (req.nextUrl.searchParams.get("q") ?? "").trim();
- return q.length >= 3 ? q : null;
-}
-
-export async function POST(req: NextRequest) {
- const denied = await sessionOuReponse();
- if (denied instanceof Response) return denied;
-
- const q = lireTerme(req);
- if (!q) return NextResponse.json({ error: "Saisissez au moins 3 caractères" }, { status: 400 });
-
- const force = req.nextUrl.searchParams.get("force") === "1";
- try {
- const job = demarrerRecherche(q, { force });
- return NextResponse.json({ success: true, ...job });
- } catch (e) {
- const message = (e as Error).message ?? String(e);
- console.error("[api/produits/search] POST", message.slice(0, 300));
- return NextResponse.json({ error: message.slice(0, 300) }, { status: 500 });
- }
-}
-
-export async function GET(req: NextRequest) {
- const denied = await sessionOuReponse();
- if (denied instanceof Response) return denied;
-
- const q = lireTerme(req);
- if (!q) return NextResponse.json({ error: "Saisissez au moins 3 caractères" }, { status: 400 });
-
- try {
- return NextResponse.json({ success: true, ...etatRecherche(q) });
- } catch (e) {
- const message = (e as Error).message ?? String(e);
- console.error("[api/produits/search] GET", message.slice(0, 300));
- return NextResponse.json({ error: message.slice(0, 300) }, { status: 500 });
- }
-}
diff --git a/src/app/api/qlik/sync/route.ts b/src/app/api/qlik/sync/route.ts
deleted file mode 100644
index b223f63..0000000
--- a/src/app/api/qlik/sync/route.ts
+++ /dev/null
@@ -1,429 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { adminOuReponse, sessionOuReponse } from "@/lib/authz";
-import { fetchNetworkMetricsPlaywright } from "@/lib/qlik-playwright";
-import { upsertNetworkMetrics } from "@/lib/qlik-network-cache";
-import { pgGetArticlesByFournisseur } from "@/lib/pg-ff-client";
-import {
- buildGridNetworkQlikDateFilter,
- QLIK_MONTHS_BACK_DEFAULT,
-} from "@/lib/qlik-date-range";
-import { startCapture, stopCapture } from "@/lib/log-capture";
-
-// Tâche d'extraction Qlik potentiellement très longue (hypercube paginé).
-// On accepte quand même 5 min côté plateforme Next.js, mais on rend la main au
-// client tout de suite via le state job ci-dessous.
-export const maxDuration = 300;
-// Forcer le runtime Node.js : Playwright/Chromium ne tourne pas en edge et on a
-// besoin d'un process persistant pour conserver l'état de job en mémoire.
-export const runtime = "nodejs";
-// Toujours exécuter dynamiquement (sinon Next peut essayer de cacher des POST).
-export const dynamic = "force-dynamic";
-
-/** État d'un job de sync Qlik pour un fournisseur donné. */
-type QlikSyncStatus = "idle" | "running" | "success" | "error";
-
-interface QlikSyncJob {
- jobId: string;
- /** Code fournisseur (mode fournisseur) — chaîne vide en mode produit. */
- fournisseur: string;
- /** Code centrale (mode produit) — absent en mode fournisseur. */
- codeCentrale?: string;
- status: QlikSyncStatus;
- requested: number;
- fetched: number;
- upserted: number;
- periode?: string;
- dateDebut?: string;
- dateFin?: string;
- startedAt: string;
- finishedAt?: string;
- error?: string;
- message?: string;
-}
-
-/**
- * Store en mémoire au niveau module. Une Map par fournisseur car on ne lance
- * qu'une extraction à la fois par fournisseur. C'est volontairement simple :
- * si le process redémarre, les jobs en cours sont perdus → GET renverra idle
- * et l'utilisateur pourra relancer. Suffisant pour corriger le bug UX.
- */
-const jobs = new Map();
-
-/**
- * Clé de job. Le mode fournisseur garde sa clé historique (le code fournisseur
- * brut) ; le mode produit est préfixé pour ne jamais entrer en collision.
- */
-function jobKeyForProduct(codeCentrale: string): string {
- return `cc:${codeCentrale.toUpperCase()}`;
-}
-
-/**
- * Nombre maximum d'extractions produit simultanées.
- *
- * Le mode produit est ouvert à tous les utilisateurs connectés (contrairement au
- * mode fournisseur, réservé aux admins). Une extraction sur 1 seul code est très
- * légère, mais le serveur Qlik est sujet aux saturations mémoire : on plafonne
- * la concurrence plutôt que de lui laisser prendre N requêtes en parallèle.
- */
-const MAX_CONCURRENT_PRODUCT_JOBS = 3;
-
-/** Compte les extractions produit actuellement en cours. */
-function runningProductJobs(): number {
- let n = 0;
- for (const [key, job] of jobs) {
- if (key.startsWith("cc:") && job.status === "running") n++;
- }
- return n;
-}
-
-/** Construit un jobId court et lisible. */
-function newJobId(): string {
- return `qlik_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-/** Sérialise un job pour la réponse HTTP. */
-function publicJob(job: QlikSyncJob) {
- return {
- jobId: job.jobId,
- fournisseur: job.fournisseur,
- codeCentrale: job.codeCentrale,
- status: job.status,
- requested: job.requested,
- fetched: job.fetched,
- upserted: job.upserted,
- periode: job.periode,
- dateDebut: job.dateDebut,
- dateFin: job.dateFin,
- startedAt: job.startedAt,
- finishedAt: job.finishedAt,
- error: job.error,
- message: job.message,
- };
-}
-
-/** État "idle" sérialisé (pas de job connu pour cette cible). */
-function idleJob(fournisseur: string, codeCentrale?: string) {
- return {
- jobId: null,
- fournisseur,
- codeCentrale,
- status: "idle" as const,
- requested: 0,
- fetched: 0,
- upserted: 0,
- periode: undefined,
- dateDebut: undefined,
- dateFin: undefined,
- startedAt: undefined,
- finishedAt: undefined,
- error: undefined,
- message: undefined,
- };
-}
-
-/**
- * Regex de validation d'un code centrale "raisonnable".
- *
- * Format attendu d'après l'API FF : préfixe `10000` + 6 chiffres (ex `10000167303`),
- * donc 11 caractères alphanumériques. Pour rester large et ne pas casser
- * d'éventuels codes alphanumériques fournisseur (refs internes), on autorise
- * - longueur 2..30
- * - jeu `[A-Z0-9_-]`
- * - premier caractère alphanumérique (pas `_` ni `-`)
- *
- * But : éviter d'envoyer à Qlik des chaînes vides, des `-`, des espaces
- * parasites, ou des entrées manifestement invalides qui déclenchent des
- * codes d'erreur Engine ou du gaspillage réseau. **Volontairement simple** :
- * on ne touche pas au mapping ; on filtre seulement ce qui ne ressemble à
- * aucun code plausible.
- */
-const CENTRAL_CODE_REGEX = /^[A-Z0-9][A-Z0-9_-]{1,29}$/i;
-
-/**
- * Filtre strict des codes centraux avant d'envoyer à Qlik.
- * - trim + drop vides
- * - drop "-" (placeholder déjà exclu côté agrégation mais on double-check)
- * - drop doublons (préserve l'ordre, comparaison insensible à la casse)
- * - drop codes ne matchant pas CENTRAL_CODE_REGEX (longueur / charset)
- *
- * Renvoie `{ accepted, rejected, deduped }`. Les logs n'exposent que les
- * compteurs, jamais les valeurs des codes.
- */
-function filterCentralCodes(rawCodes: Array): {
- accepted: string[];
- rejected: number;
- deduped: number;
-} {
- const seen = new Set();
- const accepted: string[] = [];
- let rejected = 0;
- let deduped = 0;
- for (const raw of rawCodes) {
- if (raw == null) {
- rejected++;
- continue;
- }
- const code = String(raw).trim();
- const key = code.toUpperCase();
- if (!code || code === "-" || code === "_") {
- rejected++;
- continue;
- }
- if (seen.has(key)) {
- deduped++;
- continue;
- }
- if (!CENTRAL_CODE_REGEX.test(code)) {
- rejected++;
- continue;
- }
- seen.add(key);
- accepted.push(code);
- }
- return { accepted, rejected, deduped };
-}
-
-/**
- * Exécute réellement l'extraction + l'upsert, en mettant à jour le job
- * au fur et à mesure (compteur fetched, puis upserted, puis finishedAt).
- */
-async function runJob(job: QlikSyncJob): Promise {
- // Journal téléchargeable depuis Paramètres. Ouvert AVANT le premier log du
- // job pour ne pas perdre l'entête (choix des champs, carte du modèle Qlik) —
- // c'est précisément la partie qu'un terminal tronque.
- startCapture(job.jobId, `sync fournisseur=${job.fournisseur} démarrée le ${job.startedAt}`);
- try {
- const articles = await pgGetArticlesByFournisseur(job.fournisseur);
- // Filtre strict des codes (trim, dedupe, exclusion vides/`-`/codes trop suspects).
- const { accepted: codes, rejected: codesRejected, deduped: codesDeduped } = filterCentralCodes(
- articles.map((a) => a.codeCentrale),
- );
- job.requested = codes.length;
- console.log(
- `[api/qlik/sync] job=${job.jobId} fournisseur=${job.fournisseur} — ${articles.length} articles, ${codes.length} codes centraux retenus, ${codesRejected} rejetés (vide/-/anormaux), ${codesDeduped} doublons supprimés`,
- );
- if (codes.length === 0) {
- job.status = "success";
- job.message = "Aucun code centrale valide pour ce fournisseur";
- job.finishedAt = new Date().toISOString();
- return;
- }
-
- // Contrat métier strict : toujours 12 mois complets glissants.
- // Une variable d'environnement ne doit pas pouvoir raccourcir la série.
- const dateFilter = buildGridNetworkQlikDateFilter(new Date(), QLIK_MONTHS_BACK_DEFAULT);
- job.periode = dateFilter.label;
- job.dateDebut = dateFilter.dateDebut;
- job.dateFin = dateFilter.dateFin;
- console.log(
- `[api/qlik/sync] job=${job.jobId} → extraction Qlik pour ${codes.length} codes — 12 mois complets ${dateFilter.label} (${dateFilter.dateDebut} → ${dateFilter.dateFin})…`,
- );
- // Le code fournisseur est transmis en plus des codes : s'il désigne dans
- // Qlik le même périmètre (couverture vérifiée côté extracteur), une seule
- // sélection remplace les dizaines de milliers de `SelectValues` par code.
- // Les codes restent le repli et le contrôle de couverture.
- const metrics = await fetchNetworkMetricsPlaywright(codes, undefined, dateFilter, job.fournisseur);
- job.fetched = metrics.size;
- console.log(`[api/qlik/sync] job=${job.jobId} ← Qlik a renvoyé ${metrics.size} produits réseau`);
- const count = await upsertNetworkMetrics([...metrics.values()]);
- job.upserted = count;
- console.log(`[api/qlik/sync] job=${job.jobId} ${count} lignes upsert dans le cache`);
- job.status = "success";
- job.finishedAt = new Date().toISOString();
- } catch (e) {
- applyJobError(job, e);
- } finally {
- await stopCapture(job.jobId, `statut final=${job.status}${job.error ? ` — ${job.error}` : ""}`);
- }
-}
-
-/**
- * Inscrit une erreur dans le job, en traduisant la saturation mémoire du
- * serveur Qlik en message actionnable (ce n'est PAS un bug CollectFlow :
- * l'app Qlik ne se charge même pas).
- */
-function applyJobError(job: QlikSyncJob, e: unknown): void {
- const msg = e instanceof Error ? e.message : String(e);
- console.error(`[api/qlik/sync] job=${job.jobId}`, msg);
- job.status = "error";
- const lower = msg.toLowerCase();
- if (lower.includes("out of memory") || lower.includes("not enough memory") || lower.includes("file corrupted") || lower.includes('"code":6') || lower.includes('"code":3002')) {
- job.error = "Serveur Qlik saturé : mémoire insuffisante pour charger l'application. Réessayez plus tard (ou faites libérer / augmenter la RAM du serveur Qlik).";
- } else {
- job.error = msg;
- }
- job.finishedAt = new Date().toISOString();
-}
-
-/**
- * Extraction Qlik pour UN seul code centrale (fiche produit).
- *
- * Beaucoup plus légère que la sync fournisseur : un seul code au lieu de
- * plusieurs centaines, sur la même fenêtre 12 mois glissants. Réutilise
- * exactement le même extracteur, donc le même détail mensuel.
- */
-async function runProductJob(job: QlikSyncJob): Promise {
- startCapture(job.jobId, `sync produit=${job.codeCentrale} démarrée le ${job.startedAt}`);
- try {
- const code = job.codeCentrale!;
- job.requested = 1;
-
- const dateFilter = buildGridNetworkQlikDateFilter(new Date(), QLIK_MONTHS_BACK_DEFAULT);
- job.periode = dateFilter.label;
- job.dateDebut = dateFilter.dateDebut;
- job.dateFin = dateFilter.dateFin;
- console.log(
- `[api/qlik/sync] job=${job.jobId} → extraction Qlik produit (1 code) — fenêtre ${dateFilter.label} (${dateFilter.dateDebut} → ${dateFilter.dateFin})…`,
- );
-
- const metrics = await fetchNetworkMetricsPlaywright([code], undefined, dateFilter);
- job.fetched = metrics.size;
- if (metrics.size === 0) {
- job.status = "success";
- job.message = "Ce code centrale est inconnu de Qlik (aucune vente réseau sur la période)";
- job.finishedAt = new Date().toISOString();
- return;
- }
- const count = await upsertNetworkMetrics([...metrics.values()]);
- job.upserted = count;
- job.status = "success";
- job.message = "Données réseau récupérées";
- job.finishedAt = new Date().toISOString();
- console.log(`[api/qlik/sync] job=${job.jobId} produit ${code} — ${count} ligne(s) upsert`);
- } catch (e) {
- applyJobError(job, e);
- } finally {
- await stopCapture(job.jobId, `statut final=${job.status}${job.error ? ` — ${job.error}` : ""}`);
- }
-}
-
-/**
- * GET /api/qlik/sync?fournisseur=XXX ou ?codeCentrale=YYY
- * Retourne l'état courant du job pour cette cible. Si aucun job n'est
- * connu, renvoie un état "idle" (avec un message explicite). Permet au
- * frontend de reprendre l'état après un reload et de poller en arrière-plan.
- */
-export async function GET(req: NextRequest) {
- const codeCentrale = req.nextUrl.searchParams.get("codeCentrale");
- const fournisseur = req.nextUrl.searchParams.get("fournisseur");
-
- // Mode produit : ouvert à tout utilisateur connecté.
- if (codeCentrale) {
- const denied = await sessionOuReponse();
- if (denied instanceof Response) return denied;
- const job = jobs.get(jobKeyForProduct(codeCentrale));
- if (!job) {
- return NextResponse.json({ success: true, ...idleJob("", codeCentrale) });
- }
- return NextResponse.json({ success: true, ...publicJob(job) });
- }
-
- // Mode fournisseur : admin uniquement (inchangé).
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- if (!fournisseur) {
- return NextResponse.json({ error: "Param 'fournisseur' ou 'codeCentrale' requis" }, { status: 400 });
- }
- const job = jobs.get(fournisseur);
- if (!job) {
- return NextResponse.json({ success: true, ...idleJob(fournisseur) });
- }
- return NextResponse.json({ success: true, ...publicJob(job) });
-}
-
-/**
- * POST /api/qlik/sync?fournisseur=XXX
- * Démarre (ou réutilise si déjà running) un job d'extraction en arrière-plan
- * et retourne *immédiatement* { success, status, jobId, ... }. Le client doit
- * ensuite poller GET pour suivre l'avancement et être notifié de la fin.
- */
-export async function POST(req: NextRequest) {
- const codeCentraleParam = req.nextUrl.searchParams.get("codeCentrale");
-
- // ─── Mode produit : 1 code centrale, ouvert à tout utilisateur connecté ───
- if (codeCentraleParam) {
- const denied = await sessionOuReponse();
- if (denied instanceof Response) return denied;
-
- // Même validation que la sync fournisseur (trim, rejet des vides / "-" /
- // codes hors charset) pour ne jamais envoyer de saleté à l'Engine Qlik.
- const { accepted } = filterCentralCodes([codeCentraleParam]);
- if (accepted.length === 0) {
- return NextResponse.json({ error: "Code centrale invalide" }, { status: 400 });
- }
- const code = accepted[0];
- const key = jobKeyForProduct(code);
-
- const existingProduct = jobs.get(key);
- if (existingProduct && existingProduct.status === "running") {
- return NextResponse.json({ success: true, ...publicJob(existingProduct) });
- }
-
- if (runningProductJobs() >= MAX_CONCURRENT_PRODUCT_JOBS) {
- return NextResponse.json(
- { error: "Trop d'extractions Qlik en cours. Réessayez dans quelques instants." },
- { status: 429 },
- );
- }
-
- const productJob: QlikSyncJob = {
- jobId: newJobId(),
- fournisseur: "",
- codeCentrale: code,
- status: "running",
- requested: 0,
- fetched: 0,
- upserted: 0,
- startedAt: new Date().toISOString(),
- };
- jobs.set(key, productJob);
- console.log(`[api/qlik/sync] job=${productJob.jobId} démarré pour codeCentrale=${code}`);
-
- void runProductJob(productJob).catch((e) => applyJobError(productJob, e));
-
- return NextResponse.json({ success: true, ...publicJob(productJob) });
- }
-
- // ─── Mode fournisseur : admin uniquement (inchangé) ──────────────────────
- const denied = await adminOuReponse();
- if (denied instanceof Response) return denied;
-
- const fournisseur = req.nextUrl.searchParams.get("fournisseur");
- if (!fournisseur) {
- return NextResponse.json({ error: "Param 'fournisseur' ou 'codeCentrale' requis" }, { status: 400 });
- }
-
- const existing = jobs.get(fournisseur);
- if (existing && existing.status === "running") {
- // Un job tourne déjà pour ce fournisseur : on le réutilise.
- return NextResponse.json({ success: true, ...publicJob(existing) });
- }
-
- const job: QlikSyncJob = {
- jobId: newJobId(),
- fournisseur,
- status: "running",
- requested: 0,
- fetched: 0,
- upserted: 0,
- startedAt: new Date().toISOString(),
- };
- jobs.set(fournisseur, job);
- console.log(`[api/qlik/sync] job=${job.jobId} démarré pour fournisseur=${fournisseur}`);
-
- // Lancement fire-and-forget. On ne `await` PAS l'extraction ici : on
- // renvoie tout de suite au client et il polle GET. Les erreurs sont
- // capturées dans runJob et inscrites dans le job.
- void runJob(job).catch((e) => {
- // Filet de sécurité (runJob ne devrait pas throw, mais on ne veut
- // jamais qu'une exception non capturée crashe le process).
- const msg = e instanceof Error ? e.message : String(e);
- console.error(`[api/qlik/sync] job=${job.jobId} crash non géré`, msg);
- job.status = "error";
- job.error = msg;
- job.finishedAt = new Date().toISOString();
- });
-
- return NextResponse.json({ success: true, ...publicJob(job) });
-}
diff --git a/src/app/api/test-db/route.ts b/src/app/api/test-db/route.ts
deleted file mode 100644
index 35dbc20..0000000
--- a/src/app/api/test-db/route.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { NextResponse } from 'next/server';
-import { db } from '@/db';
-import { sql } from 'drizzle-orm';
-import { pgGetStockForCodeins } from '@/lib/pg-ff-client';
-import { adminOuReponse } from '@/lib/authz';
-
-export async function GET(request: Request) {
- const acces = await adminOuReponse();
- if (acces instanceof Response) return acces;
-
- try {
- const { searchParams } = new URL(request.url);
- const codein = searchParams.get('codein') || '334152';
-
- const map = await pgGetStockForCodeins([codein]);
-
- const fouResult = await db.execute(sql`
- SELECT
- a.codein::text AS codein,
- COALESCE(fi.nom, af.code, 'Sans fournisseur')::text AS fournisseur
- FROM articles a
- LEFT JOIN artfou1 af ON af.art_no_id = a.no_id AND af.preference = 1
- LEFT JOIN fouident fi ON fi.code = af.code
- WHERE a.codein::text = ${codein}
- `);
-
- return NextResponse.json({
- stock: Object.fromEntries(map),
- fou: fouResult.rows,
- });
- } catch (e) {
- // Pas de pile d'appels dans la réponse : elle reste dans les journaux du serveur.
- console.error('[api/test-db]', e);
- return NextResponse.json({ error: (e as Error).message }, { status: 500 });
- }
-}
diff --git a/src/app/api/v1/fournisseurs/route.ts b/src/app/api/v1/fournisseurs/route.ts
deleted file mode 100644
index 44aba51..0000000
--- a/src/app/api/v1/fournisseurs/route.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail } from "@/lib/api-response";
-import { fournisseursQuerySchema } from "@/lib/api-schemas";
-import { listGridSuppliers } from "@/lib/grid-store";
-import { pgGetFournisseurs } from "@/lib/pg-ff-client";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/v1/fournisseurs?search=…&withData=1
- *
- * Liste des fournisseurs. Par défaut, tout le référentiel (`fouident`), enrichi de la
- * fraîcheur de l'instantané de grille quand il existe — ce qui permet à l'appelant de
- * savoir d'avance quels fournisseurs `/api/v1/grid` peut servir immédiatement.
- *
- * `withData=1` restreint aux seuls fournisseurs déjà présents dans l'instantané.
- */
-export async function GET(req: NextRequest) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const parsed = fournisseursQuerySchema.safeParse(Object.fromEntries(req.nextUrl.searchParams));
- if (!parsed.success) {
- return fail("bad_request", "Paramètres invalides.", parsed.error.issues);
- }
- const { search, withData } = parsed.data;
-
- const snapshot = await listGridSuppliers();
- const byCode = new Map(snapshot.map((s) => [s.codeFournisseur, s]));
-
- if (withData === "1") {
- const term = search?.toLowerCase();
- const data = snapshot
- .filter((s) => !term
- || s.codeFournisseur.toLowerCase().includes(term)
- || (s.nomFournisseur ?? "").toLowerCase().includes(term))
- .map((s) => ({
- code: s.codeFournisseur,
- nom: s.nomFournisseur,
- hasSnapshot: true,
- rowCount: s.rowCount,
- computedAt: s.computedAt,
- }));
- return ok(data, { meta: { total: data.length, scope: "instantané uniquement" } });
- }
-
- const fournisseurs = await pgGetFournisseurs(search);
- const data = fournisseurs.map((f) => {
- const snap = byCode.get(f.code);
- return {
- code: f.code,
- nom: f.nom,
- hasSnapshot: Boolean(snap),
- rowCount: snap?.rowCount ?? 0,
- computedAt: snap?.computedAt ?? null,
- };
- });
-
- return ok(data, { meta: { total: data.length, withSnapshot: byCode.size } });
-}
diff --git a/src/app/api/v1/gammes/route.ts b/src/app/api/v1/gammes/route.ts
deleted file mode 100644
index 1c3d019..0000000
--- a/src/app/api/v1/gammes/route.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail } from "@/lib/api-response";
-import { gammesBatchBodySchema } from "@/lib/api-schemas";
-import { affecterGammes, lireCorpsJson } from "@/lib/api-gammes";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-// Idem /api/v1/grid : le calcul à la demande peut prendre plusieurs secondes.
-export const maxDuration = 300;
-
-/**
- * POST /api/v1/gammes { "fournisseur": "…", "changes": [{ "codein": "…", "gamme": "A" }, …] }
- *
- * Propose la gamme de plusieurs articles d'un fournisseur en un appel. Les
- * propositions restent **à valider** dans la Grille (cf. lib/api-gammes).
- * Tout ou rien : un article inconnu chez le fournisseur fait échouer l'appel (404).
- */
-export async function POST(req: NextRequest) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const corps = await lireCorpsJson(req);
- if (corps instanceof Response) return corps;
- const parsed = gammesBatchBodySchema.safeParse(corps);
- if (!parsed.success) {
- return fail("bad_request", "Corps de requête invalide.", parsed.error.issues);
- }
- const { fournisseur, changes, compute } = parsed.data;
-
- const res = await affecterGammes({
- codeFournisseur: fournisseur,
- changes,
- compute,
- auteur: authCtx.subject,
- });
- if (res instanceof Response) return res;
-
- return ok(res.resultats, {
- meta: {
- codeFournisseur: res.codeFournisseur,
- nomFournisseur: res.nomFournisseur,
- demandes: res.resultats.length,
- modifies: res.resultats.filter((r) => r.modifie).length,
- aValider: res.resultats.filter((r) => r.statut === "a_valider").length,
- enregistreLe: new Date().toISOString(),
- },
- });
-}
diff --git a/src/app/api/v1/grid/route.ts b/src/app/api/v1/grid/route.ts
deleted file mode 100644
index 5409d5b..0000000
--- a/src/app/api/v1/grid/route.ts
+++ /dev/null
@@ -1,223 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail, buildPagination } from "@/lib/api-response";
-import { gridQuerySchema, pickFields, toSortKey } from "@/lib/api-schemas";
-import { queryGridRows, getGridFreshness } from "@/lib/grid-store";
-import { enrichRows } from "@/lib/api-enrich";
-import { getProductRows } from "@/features/grid/api/get-product-rows";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-// Le calcul à la demande (premier appel sur un fournisseur inconnu) enchaîne
-// plusieurs requêtes SQL sur la base miroir FF : on laisse de la marge.
-export const maxDuration = 300;
-
-/**
- * GET /api/v1/grid?fournisseur=…&gamme=&code1..3=&search=&sort=&order=&page=&limit=&fields=&compute=
- *
- * Lignes de grille d'un fournisseur, filtrées / triées / paginées **en SQL** depuis
- * l'instantané persisté (`grid_rows`).
- *
- * Si le fournisseur n'a pas encore d'instantané, l'endpoint le **calcule à la demande**
- * (`compute=1`, défaut) : sans cela, un appelant externe ne pourrait consulter que les
- * fournisseurs déjà ouverts dans la Grille par un humain. Le calcul est protégé par le
- * cache et le verrou anti-concurrence de `getProductRows()`, et il persiste l'instantané
- * au passage — les appels suivants repassent donc par le chemin rapide.
- *
- * `compute=0` restaure le comportement strict : échec immédiat en `202 not_ready`.
- */
-export async function GET(req: NextRequest) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const parsed = gridQuerySchema.safeParse(Object.fromEntries(req.nextUrl.searchParams));
- if (!parsed.success) {
- return fail("bad_request", "Paramètres invalides.", parsed.error.issues);
- }
- const q = parsed.data;
-
- // Distingue « fournisseur jamais calculé » de « filtres sans résultat » (200 vide).
- let freshness = await getGridFreshness(q.fournisseur);
- let computedOnDemand = false;
-
- if (!freshness) {
- if (q.compute === "0") {
- return fail(
- "not_ready",
- `Aucun instantané pour le fournisseur « ${q.fournisseur} ». Relancez sans « compute=0 » pour le calculer à la demande.`,
- { fournisseur: q.fournisseur },
- );
- }
-
- console.log(`[api/v1/grid] instantané absent pour ${q.fournisseur} — calcul à la demande (via ${authCtx.via})`);
- try {
- // magasin TOTAL : c'est la seule variante persistée par getProductRows,
- // et ProductRow embarque déjà les ventilations par magasin.
- await getProductRows({ codeFournisseur: q.fournisseur, magasin: "TOTAL" });
- } catch (e) {
- const msg = e instanceof Error ? e.message : String(e);
- console.error(`[api/v1/grid] calcul à la demande KO pour ${q.fournisseur}:`, msg);
- return fail(
- "internal_error",
- `Le calcul de la grille a échoué pour le fournisseur « ${q.fournisseur} ».`,
- { fournisseur: q.fournisseur },
- );
- }
-
- freshness = await getGridFreshness(q.fournisseur);
- if (!freshness) {
- // Calcul réussi mais aucune ligne : le code fournisseur n'existe pas, ou
- // il n'a aucun article. À distinguer d'une panne.
- return fail(
- "not_found",
- `Aucun article pour le fournisseur « ${q.fournisseur} ». Vérifiez le code auprès de /api/v1/fournisseurs.`,
- { fournisseur: q.fournisseur },
- );
- }
- computedOnDemand = true;
- }
-
- const filtres = {
- codeFournisseur: q.fournisseur,
- gamme: q.gamme,
- code1: q.code1,
- code2: q.code2,
- code3: q.code3,
- nomenclature: q.nomenclature,
- search: q.search,
- sort: toSortKey(q.sort),
- order: q.order,
- };
-
- // Sans `limit`, la réponse peut porter tout un fournisseur — et certains en
- // comptent plus de 130 000. Tout charger puis tout sérialiser d'un bloc ferait
- // exploser la mémoire du processus : on diffuse par lots, à mémoire constante.
- if (q.limit == null) {
- return streamAllRows(req, filtres, q, freshness, computedOnDemand);
- }
-
- const result = await queryGridRows({ ...filtres, page: q.page, limit: q.limit });
-
- // Métriques Qlik et gamme serveur relues au moment de l'appel (voir api-enrich).
- const rows = q.enrich === "1" ? await enrichRows(result.rows) : result.rows;
-
- const pagination = buildPagination(q.page, q.limit, result.total);
-
- return ok(
- rows.map((r) => pickFields(r, q.fields)),
- {
- pagination,
- meta: {
- fournisseur: q.fournisseur,
- computedAt: result.computedAt,
- snapshotComputedAt: freshness.computedAt,
- snapshotRowCount: freshness.rowCount,
- enrichi: q.enrich === "1",
- /** true = l'instantané n'existait pas et vient d'être calculé par cet appel. */
- computedOnDemand,
- /**
- * true = cette réponse contient **toutes** les lignes du fournisseur.
- * Dit explicitement à un appelant — en particulier un agent — s'il
- * peut s'arrêter là, au lieu de le laisser déduire d'une pagination
- * qu'il risque d'ignorer.
- */
- complet: !pagination.hasMore,
- ...(pagination.hasMore
- ? {
- avertissement:
- `Réponse partielle : ${rows.length} lignes sur ${result.total}, parce que « limit » a été précisé. `
- + `Retirez « limit » pour obtenir tout le fournisseur en un appel, ou passez à page=${q.page + 1}.`,
- }
- : {}),
- },
- },
- );
-}
-
-/** Lots internes : compromis entre nombre d'allers-retours SQL et mémoire retenue. */
-const STREAM_BATCH = 1000;
-
-type Filtres = Parameters[0];
-
-/**
- * Diffuse **toutes** les lignes du fournisseur en une seule réponse JSON, sans
- * jamais la construire entièrement en mémoire.
- *
- * La forme reste celle des autres réponses (`{ data, pagination, meta }`) : un
- * client existant ne voit aucune différence, il reçoit simplement les octets au
- * fil de l'eau. `pagination` et `meta` sont écrits en dernier, une fois le total
- * connu — l'ordre des clés n'a aucune importance en JSON.
- *
- * Une erreur survenant après les premiers octets ne peut plus changer le code
- * HTTP : on ferme alors le document avec `meta.erreur`, pour que l'appelant
- * détecte une réponse tronquée au lieu de la croire complète.
- */
-function streamAllRows(
- req: NextRequest,
- filtres: Filtres,
- q: { enrich: string; fields?: string; fournisseur: string },
- freshness: { rowCount: number; computedAt: string | null },
- computedOnDemand: boolean,
-): Response {
- const encoder = new TextEncoder();
-
- const stream = new ReadableStream({
- async start(controller) {
- const write = (s: string) => controller.enqueue(encoder.encode(s));
- let envoyees = 0;
- let total = 0;
- let computedAt: string | null = null;
- let erreur: string | null = null;
-
- write('{"data":[');
- try {
- for (let page = 1; ; page++) {
- const lot = await queryGridRows({ ...filtres, page, limit: STREAM_BATCH });
- if (page === 1) {
- total = lot.total;
- computedAt = lot.computedAt;
- }
- if (lot.rows.length === 0) break;
-
- const enrichies = q.enrich === "1" ? await enrichRows(lot.rows) : lot.rows;
- for (const r of enrichies) {
- write((envoyees === 0 ? "" : ",") + JSON.stringify(pickFields(r, q.fields)));
- envoyees++;
- }
- if (lot.rows.length < STREAM_BATCH) break;
- }
- } catch (e) {
- erreur = e instanceof Error ? e.message : String(e);
- console.error(`[api/v1/grid] diffusion interrompue pour ${q.fournisseur} après ${envoyees} lignes:`, erreur);
- }
-
- const complet = erreur === null && envoyees === total;
- write("]," + JSON.stringify({
- pagination: { page: 1, limit: envoyees, total, totalPages: 1, hasMore: !complet },
- meta: {
- fournisseur: q.fournisseur,
- computedAt,
- snapshotComputedAt: freshness.computedAt,
- snapshotRowCount: freshness.rowCount,
- enrichi: q.enrich === "1",
- computedOnDemand,
- diffuse: true,
- complet,
- ...(erreur
- ? { erreur: `Diffusion interrompue après ${envoyees} lignes sur ${total} : ${erreur}` }
- : {}),
- },
- }).slice(1));
- controller.close();
- },
- });
-
- return new Response(stream, {
- headers: {
- "Content-Type": "application/json; charset=utf-8",
- "Cache-Control": "no-store",
- // Empêche un proxy de tamponner la réponse entière avant de la relayer.
- "X-Accel-Buffering": "no",
- },
- });
-}
diff --git a/src/app/api/v1/network/[codeCentrale]/route.ts b/src/app/api/v1/network/[codeCentrale]/route.ts
deleted file mode 100644
index ae715b1..0000000
--- a/src/app/api/v1/network/[codeCentrale]/route.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail } from "@/lib/api-response";
-import { getNetworkMetricsByCodeCentrale } from "@/lib/qlik-network-cache";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/v1/network/:codeCentrale
- *
- * Métriques réseau Qlik d'un produit (CA, quantité, nombre de magasins, CA/magasin,
- * marge %) et sa courbe de quantités mensuelles sur 12 mois glissants.
- *
- * Lecture **exclusive** de la table `qlik_network_metrics` : aucun appel à Qlik n'est
- * déclenché. Pour interroger Qlik en direct (y compris sur des produits que nous ne
- * référençons pas), c'est la page Produits — bien plus lente, et volontairement
- * séparé de cette API.
- */
-export async function GET(
- req: NextRequest,
- ctx: { params: Promise<{ codeCentrale: string }> },
-) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const { codeCentrale } = await ctx.params;
- if (!codeCentrale) return fail("bad_request", "Paramètre 'codeCentrale' requis.");
-
- const metrics = await getNetworkMetricsByCodeCentrale([codeCentrale]);
- const found = metrics.get(codeCentrale);
- if (!found) {
- return fail(
- "not_found",
- `Aucune donnée réseau en cache pour le code centrale « ${codeCentrale} ». Lancez une synchronisation Qlik ou une recherche réseau.`,
- );
- }
-
- return ok({ codeCentrale, ...found }, { meta: { fetchedAt: found.fetchedAt, source: "cache" } });
-}
diff --git a/src/app/api/v1/nomenclatures/route.ts b/src/app/api/v1/nomenclatures/route.ts
deleted file mode 100644
index c760406..0000000
--- a/src/app/api/v1/nomenclatures/route.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail } from "@/lib/api-response";
-import { nomenclaturesQuerySchema } from "@/lib/api-schemas";
-import { listGridNomenclatures, getGridFreshness } from "@/lib/grid-store";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/v1/nomenclatures?fournisseur=…&niveau=1|2|3&parent=…
- *
- * Répartition des articles d'un fournisseur par poste de nomenclature, avec le
- * nombre d'articles et le CA de chacun.
- *
- * C'est la porte d'entrée pour traiter un gros fournisseur : certains dépassent
- * 130 000 articles, et tout récupérer d'un coup n'a de sens ni pour une IA ni
- * pour une application. On liste d'abord les postes — quelques dizaines de
- * lignes — puis on interroge `/grid?fournisseur=…&nomenclature=…` poste par poste.
- *
- * Les codes sont hiérarchiques par préfixe (6 chiffres, de 31xxxx à 40xxxx) :
- * niveau 1 = « 32 », niveau 2 = « 3202 », niveau 3 = « 320211 ». `parent` accepte
- * un préfixe pour descendre l'arborescence sans tout charger.
- */
-export async function GET(req: NextRequest) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const parsed = nomenclaturesQuerySchema.safeParse(Object.fromEntries(req.nextUrl.searchParams));
- if (!parsed.success) {
- return fail("bad_request", "Paramètres invalides.", parsed.error.issues);
- }
- const { fournisseur, niveau, parent } = parsed.data;
-
- // Même distinction que /grid : « pas encore calculé » n'est pas « vide ».
- const freshness = await getGridFreshness(fournisseur);
- if (!freshness) {
- return fail(
- "not_ready",
- `Aucun instantané pour le fournisseur « ${fournisseur} ». Appelez /api/v1/grid?fournisseur=${fournisseur} une fois pour le calculer.`,
- { fournisseur },
- );
- }
-
- const postes = await listGridNomenclatures(fournisseur, niveau, parent);
- const nbArticles = postes.reduce((s, p) => s + p.nbArticles, 0);
-
- return ok(postes, {
- meta: {
- fournisseur,
- niveau,
- parent: parent ?? null,
- nbPostes: postes.length,
- /** Total couvert par les postes listés — à rapprocher de snapshotRowCount. */
- nbArticles,
- snapshotRowCount: freshness.rowCount,
- snapshotComputedAt: freshness.computedAt,
- /**
- * Le paramètre de /grid à utiliser avec les `code` renvoyés ci-dessus.
- * `nomenclature` filtre par préfixe et fonctionne aux trois niveaux.
- */
- filtreGrid: "nomenclature",
- },
- });
-}
diff --git a/src/app/api/v1/openapi.json/route.ts b/src/app/api/v1/openapi.json/route.ts
deleted file mode 100644
index 3b2588d..0000000
--- a/src/app/api/v1/openapi.json/route.ts
+++ /dev/null
@@ -1,537 +0,0 @@
-import { NextRequest } from "next/server";
-import { GRID_SORT_KEYS } from "@/lib/grid-store";
-import { GAMMES } from "@/lib/gammes";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/v1/openapi.json — spécification OpenAPI 3.1 de l'API CollectFlow.
- *
- * **Volontairement accessible sans authentification.** Le document ne décrit que la
- * structure de l'API (chemins, paramètres, schémas) et ne contient aucune donnée
- * métier ; or ChatGPT et les autres plateformes d'agents importent le schéma par URL,
- * avant même que la clé ne soit configurée. Exiger une clé ici rendrait l'import
- * impossible.
- *
- * `servers` est construit depuis l'hôte appelant (ou COLLECTFLOW_PUBLIC_URL) : les
- * Actions ChatGPT exigent une URL **absolue**, une URL relative étant rejetée.
- */
-export async function GET(req: NextRequest) {
- const configured = process.env.COLLECTFLOW_PUBLIC_URL?.trim().replace(/\/+$/, "");
- const origin = configured || req.nextUrl.origin;
-
- const paginationParams = [
- { name: "page", in: "query", schema: { type: "integer", minimum: 1, default: 1 }, description: "Numéro de page." },
- { name: "limit", in: "query", schema: { type: "integer", minimum: 1 }, description: "Lignes par page, sans plafond. Sur /grid, OMETTRE ce paramètre renvoie toutes les lignes du fournisseur en un seul appel — c'est le mode recommandé. Sur les autres endpoints, le défaut est 100." },
- ];
- const sortParams = [
- { name: "sort", in: "query", schema: { type: "string", enum: GRID_SORT_KEYS }, description: "Colonne de tri." },
- { name: "order", in: "query", schema: { type: "string", enum: ["asc", "desc"], default: "desc" }, description: "Sens du tri." },
- {
- name: "fields",
- in: "query",
- schema: { type: "string" },
- description:
- "Colonnes à retourner, séparées par des virgules (ex. « codein,libelle1,totalCa »). "
- + "À utiliser systématiquement : une ligne complète contient les séries mensuelles et les "
- + "ventilations par magasin, ce qui est très volumineux. `codein` est toujours inclus.",
- },
- {
- name: "enrich",
- in: "query",
- schema: { type: "string", enum: ["0", "1"], default: "1" },
- description:
- "1 (défaut) : relit les métriques réseau Qlik (`network`) et la gamme serveur "
- + "(`codeGammeServeur`) au moment de l'appel. 0 : sert l'instantané brut.",
- },
- ];
-
- const codesGamme = GAMMES.map((g) => g.code);
- const legendeGammes = GAMMES.map((g) => `${g.code} (${g.nom})`).join(", ");
- const erreur = (description: string) => ({
- description,
- content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } },
- });
-
- const spec = {
- openapi: "3.1.0",
- info: {
- title: "CollectFlow API",
- version: "1.0.0",
- description:
- "Données de la grille CollectFlow : ventes sur 12 mois par magasin, stock, marges, "
- + "gammes et métriques du réseau Qlik (~270 magasins Foir'Fouille), plus la recherche de produits.\n\n"
- + "**N'importe quel fournisseur peut être interrogé directement.** Les réponses sont servies "
- + "depuis un instantané persisté ; si le fournisseur demandé n'en a pas encore, `/grid` le calcule "
- + "à la demande. Ce premier appel prend alors plusieurs secondes, les suivants sont immédiats. "
- + "Passez `compute=0` pour refuser ce calcul et obtenir un `202 not_ready` immédiat.\n\n"
- + "**Aucun endpoint ne contacte Qlik en direct** : les métriques réseau viennent d'un cache "
- + "alimenté par une synchronisation séparée.\n\n"
- + "Deux informations sont relues à chaque appel car elles évoluent indépendamment : les métriques "
- + "réseau Qlik (`network`, `null` s'il n'y en a pas) et la gamme serveur non modifiée "
- + "(`codeGammeServeur`).\n\n"
- + "**Gammes** : `PUT /products/{codein}/gamme` (un article) et `POST /gammes` (plusieurs) "
- + "**proposent** une gamme. La proposition reste **à valider** : elle apparaît dans la Grille "
- + "comme une modification non enregistrée, pour voir quels produits changent de gamme, et "
- + "n'est appliquée qu'une fois validée par un utilisateur (« Enregistrer »). D'ici là, "
- + "`codeGamme` est inchangée et la proposition figure dans `gammeAValider`. Une fois validée, "
- + "`codeGammeServeur` reste la gamme en base FF jusqu'à l'import des gammes modifiées.",
- },
- servers: [{ url: `${origin}/api/v1`, description: "API CollectFlow" }],
- security: [{ ApiKeyAuth: [] }],
- components: {
- securitySchemes: {
- ApiKeyAuth: { type: "apiKey", in: "header", name: "X-API-Key" },
- },
- schemas: {
- Error: {
- type: "object",
- properties: {
- error: {
- type: "object",
- properties: {
- code: {
- type: "string",
- enum: ["unauthorized", "forbidden", "bad_request", "not_found", "not_ready", "internal_error"],
- },
- message: { type: "string" },
- },
- },
- },
- },
- Pagination: {
- type: "object",
- properties: {
- page: { type: "integer" },
- limit: { type: "integer" },
- total: { type: "integer" },
- totalPages: { type: "integer" },
- hasMore: { type: "boolean", description: "true = il reste des pages. Sur /grid, meta.complet dit la même chose en positif." },
- },
- },
- Fournisseur: {
- type: "object",
- properties: {
- code: { type: "string", description: "Code fournisseur, à passer au paramètre `fournisseur`." },
- nom: { type: ["string", "null"] },
- hasSnapshot: { type: "boolean", description: "false = données pas encore disponibles pour ce fournisseur." },
- rowCount: { type: "integer" },
- computedAt: { type: ["string", "null"], format: "date-time" },
- },
- },
- NetworkMetrics: {
- type: ["object", "null"],
- description: "Métriques du réseau Qlik. `null` quand le produit n'a pas de données réseau.",
- properties: {
- caReseau: { type: "number" },
- qteReseau: { type: "number" },
- nbMagasinsReseau: { type: "integer", description: "Nombre de magasins du réseau vendant le produit (sur ~270)." },
- caParMagasinReseau: { type: "number", description: "CA moyen par magasin : normalise la présence, préférable au CA brut pour comparer." },
- margePctReseau: { type: "number", description: "Taux de marge, ratio brut (0.32 = 32 %)." },
- qteByMonth: { type: ["object", "null"], description: "Quantités vendues par mois, clés « YYYY-MM »." },
- fetchedAt: { type: ["string", "null"], format: "date-time" },
- },
- },
- Product: {
- type: "object",
- description:
- "Ligne de grille : un article chez un fournisseur. La liste de propriétés ci-dessous "
- + "n'est pas exhaustive — la réponse contient l'intégralité de la ligne (une soixantaine "
- + "de champs). Utilisez `fields` pour n'en garder qu'une partie.",
- properties: {
- codein: { type: "string", description: "Identifiant interne de l'article." },
- codeFournisseur: { type: "string" },
- nomFournisseur: { type: "string" },
- libelle1: { type: "string", description: "Libellé de l'article." },
- gtin: { type: "string" },
- reference: { type: "string" },
- codeCentrale: { type: "string", description: "Code centrale — clé de jointure avec le réseau Qlik." },
- codeGammeServeur: {
- type: ["string", "null"],
- description:
- "Gamme **non modifiée**, telle qu'elle existe en base. C'est celle à utiliser pour "
- + "raisonner. `null` = aucune gamme. Valeurs : " + legendeGammes + ".",
- },
- codeGamme: { type: ["string", "null"], description: "Gamme courante, modifications validées dans CollectFlow comprises." },
- gammeAValider: { type: ["string", "null"], description: "Gamme proposée par l'API et pas encore validée dans la Grille. `null` = aucune proposition en attente." },
- totalCa: { type: "number", description: "CA sur 12 mois, nos magasins." },
- totalQuantite: { type: "number" },
- totalMarge: { type: "number" },
- tauxMarge: { type: "number" },
- stockActuel: { type: "number" },
- pcb: { type: "number", description: "Conditionnement (nombre d'unités par colis)." },
- prixAchat: { type: "number" },
- prixVente: { type: "number" },
- derniereVente: { type: "string", format: "date" },
- nbJoursDerniereVente: { type: "integer" },
- sales12m: { type: "object", description: "Quantités vendues par mois, clés « YYYYMM »." },
- stock12m: { type: "object", description: "Stock de fin de mois, clés « YYYYMM »." },
- receptions12m: { type: "object", description: "Quantités reçues par mois, clés « YYYYMM »." },
- sales12mByStore: { type: "object", description: "Ventes par magasin (292, 579) puis par mois." },
- stock12mByStore: { type: "object", description: "Stock de fin de mois par magasin puis par mois." },
- receptions12mByStore: { type: "object", description: "Réceptions par magasin puis par mois." },
- qteReseauByMonth: { type: ["object", "null"], description: "Quantités vendues par le réseau, clés « YYYY-MM » — série derrière la tendance." },
- network: { $ref: "#/components/schemas/NetworkMetrics" },
- trend: { $ref: "#/components/schemas/Trend" },
- },
- },
- ResultatGamme: {
- type: "object",
- properties: {
- codein: { type: "string" },
- gamme: { type: "string", enum: codesGamme, description: "Gamme proposée." },
- gammePrecedente: { type: ["string", "null"], description: "Gamme enregistrée au moment de l'appel." },
- codeGammeServeur: { type: ["string", "null"], description: "Gamme en base FF, non modifiée par l'API." },
- modifie: { type: "boolean", description: "true = proposition déposée, à valider dans la Grille. false = l'article a déjà cette gamme (une proposition en attente pour lui est retirée)." },
- statut: { type: "string", enum: ["a_valider", "inchangee"], description: "`a_valider` : en attente de validation dans la Grille." },
- },
- },
- Trend: {
- type: ["object", "null"],
- description:
- "Tendance réseau sur 12 mois, par régression linéaire — la même que la colonne "
- + "« Tendance » de l'application. `null` si aucune série mensuelle n'est disponible.",
- properties: {
- direction: { type: "string", enum: ["up", "down", "flat"], description: "Seuil à ±8 % de variation modélisée." },
- pct: { type: ["number", "null"], description: "Variation modélisée sur la période (0.23 = +23 %)." },
- label: { type: "string", description: "Libellé prêt à afficher : « Forte hausse », « Stable »…" },
- monthsUsed: { type: "integer", description: "Nombre de mois réellement utilisés (12 au maximum)." },
- },
- },
- },
- },
- paths: {
- "/fournisseurs": {
- get: {
- operationId: "listerFournisseurs",
- summary: "Lister les fournisseurs",
- description:
- "Renvoie les fournisseurs et indique, via `hasSnapshot`, lesquels ont des données "
- + "immédiatement disponibles. À appeler en premier quand le code fournisseur est inconnu.",
- parameters: [
- { name: "search", in: "query", schema: { type: "string" }, description: "Filtre sur le nom ou le code." },
- { name: "withData", in: "query", schema: { type: "string", enum: ["0", "1"] }, description: "1 = uniquement ceux dont les données sont disponibles." },
- ],
- responses: {
- "200": {
- description: "Liste des fournisseurs",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: {
- data: { type: "array", items: { $ref: "#/components/schemas/Fournisseur" } },
- meta: { type: "object" },
- },
- },
- },
- },
- },
- "401": { description: "Clé d'API absente, invalide ou révoquée", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- },
- },
- },
- "/nomenclatures": {
- get: {
- operationId: "listerNomenclaturesFournisseur",
- summary: "Postes de nomenclature d'un fournisseur",
- description:
- "Répartition des articles d'un fournisseur par poste de nomenclature, avec le nombre "
- + "d'articles et le CA de chacun. **À utiliser avant /grid sur un gros fournisseur** : "
- + "certains dépassent 130 000 articles. On liste les postes (quelques dizaines de lignes), "
- + "puis on interroge /grid poste par poste avec le filtre indiqué par `meta.filtreGrid` "
- + "(code1, code2 ou code3).",
- parameters: [
- { name: "fournisseur", in: "query", required: true, schema: { type: "string" } },
- { name: "niveau", in: "query", schema: { type: "integer", enum: [1, 2, 3], default: 1 }, description: "1 = univers, 2 = famille, 3 = sous-famille." },
- { name: "parent", in: "query", schema: { type: "string" }, description: "Préfixe du poste parent, ex. « 32 » pour lister ses familles." },
- ],
- responses: {
- "200": {
- description: "Postes de nomenclature",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: {
- data: {
- type: "array",
- items: {
- type: "object",
- properties: {
- code: { type: "string", description: "À passer au filtre code1/code2/code3 de /grid." },
- libelle: { type: ["string", "null"] },
- nbArticles: { type: "integer" },
- totalCa: { type: "number" },
- totalQuantite: { type: "number" },
- },
- },
- },
- meta: { type: "object" },
- },
- },
- },
- },
- },
- "202": { description: "Fournisseur pas encore calculé", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- "400": { description: "Paramètres invalides", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- },
- },
- },
- "/grid": {
- get: {
- operationId: "listerProduitsFournisseur",
- summary: "Lister les produits d'un fournisseur",
- description:
- "Lignes de grille d'un fournisseur : ventes 12 mois, stock, marges, gammes et métriques "
- + "réseau. Fonctionne pour **n'importe quel** fournisseur : si ses données n'ont jamais été "
- + "calculées, l'API les calcule à la demande (premier appel de quelques secondes, "
- + "`meta.computedOnDemand = true`). Un `404` signifie que le code fournisseur n'existe pas "
- + "ou n'a aucun article — le signaler plutôt que de conclure à une panne.",
- parameters: [
- { name: "fournisseur", in: "query", required: true, schema: { type: "string" }, description: "Code fournisseur (voir listerFournisseurs)." },
- { name: "gamme", in: "query", schema: { type: "string" }, description: `Filtre sur la gamme (${codesGamme.join(", ")}).` },
- { name: "code1", in: "query", schema: { type: "string" }, description: "Filtre nomenclature niveau 1." },
- { name: "code2", in: "query", schema: { type: "string" }, description: "Filtre nomenclature niveau 2." },
- { name: "code3", in: "query", schema: { type: "string" }, description: "Filtre nomenclature niveau 3 (code exact)." },
- { name: "nomenclature", in: "query", schema: { type: "string" }, description: "Préfixe de nomenclature renvoyé par listerNomenclaturesFournisseur : 32, 3202 ou 320211. À préférer à code1/code2, qui peuvent être vides." },
- { name: "search", in: "query", schema: { type: "string" }, description: "Filtre texte : libellé, codein, GTIN, référence ou code centrale." },
- {
- name: "compute",
- in: "query",
- schema: { type: "string", enum: ["0", "1"], default: "1" },
- description:
- "1 (défaut) : calcule les données du fournisseur si elles n'existent pas encore. "
- + "0 : refuse le calcul et répond immédiatement 202 not_ready.",
- },
- ...sortParams,
- ...paginationParams,
- ],
- responses: {
- "200": {
- description: "Produits du fournisseur",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: {
- data: { type: "array", items: { $ref: "#/components/schemas/Product" } },
- pagination: { $ref: "#/components/schemas/Pagination" },
- meta: { type: "object" },
- },
- },
- },
- },
- },
- "202": { description: "Données pas encore calculées (uniquement avec compute=0)", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- "400": { description: "Paramètres invalides", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- "401": { description: "Clé d'API absente, invalide ou révoquée", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- "404": { description: "Fournisseur inconnu ou sans article", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- },
- },
- },
- "/products/search": {
- get: {
- operationId: "rechercherProduits",
- summary: "Rechercher des produits, tous fournisseurs confondus",
- description:
- "Recherche sur le libellé, le codein, le GTIN, la référence et le code centrale, sans "
- + "avoir à connaître le fournisseur. À utiliser dès qu'un produit est désigné par son nom.",
- parameters: [
- { name: "q", in: "query", required: true, schema: { type: "string", maxLength: 120 }, description: "Termes recherchés." },
- { name: "fournisseur", in: "query", schema: { type: "string" }, description: "Restreint à un fournisseur." },
- { name: "gamme", in: "query", schema: { type: "string" }, description: "Filtre sur la gamme." },
- ...sortParams,
- ...paginationParams,
- ],
- responses: {
- "200": {
- description: "Produits correspondants",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: {
- data: { type: "array", items: { $ref: "#/components/schemas/Product" } },
- pagination: { $ref: "#/components/schemas/Pagination" },
- meta: { type: "object" },
- },
- },
- },
- },
- },
- "401": { description: "Clé d'API absente, invalide ou révoquée", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- },
- },
- },
- "/products/{codein}": {
- get: {
- operationId: "obtenirProduit",
- summary: "Fiche complète d'un produit",
- description: "Toutes les données d'un article : séries mensuelles, ventilation par magasin, stock, marges, gammes et métriques réseau.",
- parameters: [
- { name: "codein", in: "path", required: true, schema: { type: "string" }, description: "Identifiant interne de l'article." },
- { name: "fournisseur", in: "query", schema: { type: "string" }, description: "Lève l'ambiguïté d'un article référencé chez plusieurs fournisseurs." },
- ],
- responses: {
- "200": {
- description: "Fiche produit",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: { data: { $ref: "#/components/schemas/Product" }, meta: { type: "object" } },
- },
- },
- },
- },
- "404": { description: "Produit absent de l'instantané", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- "401": { description: "Clé d'API absente, invalide ou révoquée", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- },
- },
- },
- "/products/{codein}/gamme": {
- put: {
- operationId: "changerGammeProduit",
- summary: "Proposer la gamme d'un produit (à valider)",
- description:
- "Propose une gamme pour un article. Elle reste à valider dans la Grille, où elle apparaît "
- + "comme une modification non enregistrée. Valeurs : " + legendeGammes + ". "
- + "`fournisseur` n'est requis que si l'article est référencé chez plusieurs fournisseurs "
- + "(réponse 400 listant les fournisseurs) ou s'il n'a encore jamais été calculé. "
- + "Pour plusieurs articles d'un même fournisseur, préférer changerGammes.",
- parameters: [
- { name: "codein", in: "path", required: true, schema: { type: "string" }, description: "Identifiant interne de l'article." },
- ],
- requestBody: {
- required: true,
- content: {
- "application/json": {
- schema: {
- type: "object",
- required: ["gamme"],
- properties: {
- gamme: { type: "string", enum: codesGamme },
- fournisseur: { type: "string", description: "Code fournisseur de l'article." },
- compute: { type: "boolean", default: true, description: "Calcule le fournisseur à la demande s'il n'a jamais été calculé." },
- },
- },
- },
- },
- },
- responses: {
- "200": {
- description: "Gamme proposée, à valider",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: {
- data: {
- allOf: [
- { $ref: "#/components/schemas/ResultatGamme" },
- { type: "object", properties: { codeFournisseur: { type: "string" }, nomFournisseur: { type: ["string", "null"] } } },
- ],
- },
- meta: { type: "object" },
- },
- },
- },
- },
- },
- "400": erreur("Gamme invalide, ou article chez plusieurs fournisseurs sans « fournisseur »"),
- "401": erreur("Clé d'API absente, invalide ou révoquée"),
- "404": erreur("Article introuvable chez ce fournisseur"),
- },
- },
- },
- "/gammes": {
- post: {
- operationId: "changerGammes",
- summary: "Proposer la gamme de plusieurs produits (à valider)",
- description:
- "Propose en un appel les gammes de plusieurs articles d'un même fournisseur, à valider "
- + "dans la Grille. Tout ou rien : si un article est inconnu chez le fournisseur, rien n'est proposé "
- + "et la réponse 404 liste les articles en cause dans `error.details.inconnus`. "
- + "Valeurs : " + legendeGammes + ".",
- requestBody: {
- required: true,
- content: {
- "application/json": {
- schema: {
- type: "object",
- required: ["fournisseur", "changes"],
- properties: {
- fournisseur: { type: "string", description: "Code fournisseur." },
- changes: {
- type: "array",
- minItems: 1,
- maxItems: 10000,
- items: {
- type: "object",
- required: ["codein", "gamme"],
- properties: {
- codein: { type: "string" },
- gamme: { type: "string", enum: codesGamme },
- },
- },
- },
- compute: { type: "boolean", default: true, description: "Calcule le fournisseur à la demande s'il n'a jamais été calculé." },
- },
- },
- },
- },
- },
- responses: {
- "200": {
- description: "Gammes proposées, à valider",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: {
- data: { type: "array", items: { $ref: "#/components/schemas/ResultatGamme" } },
- meta: { type: "object" },
- },
- },
- },
- },
- },
- "400": erreur("Corps de requête invalide"),
- "401": erreur("Clé d'API absente, invalide ou révoquée"),
- "404": erreur("Un ou plusieurs articles introuvables chez ce fournisseur"),
- },
- },
- },
- "/network/{codeCentrale}": {
- get: {
- operationId: "obtenirMetriquesReseau",
- summary: "Métriques du réseau Qlik pour un produit",
- description: "Performances du produit sur l'ensemble du réseau Foir'Fouille (~270 magasins) et courbe des quantités sur 12 mois glissants.",
- parameters: [
- { name: "codeCentrale", in: "path", required: true, schema: { type: "string" }, description: "Code centrale du produit (format 10000XXXXXX)." },
- ],
- responses: {
- "200": {
- description: "Métriques réseau",
- content: {
- "application/json": {
- schema: {
- type: "object",
- properties: { data: { $ref: "#/components/schemas/NetworkMetrics" }, meta: { type: "object" } },
- },
- },
- },
- },
- "404": { description: "Aucune donnée réseau pour ce code centrale", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- "401": { description: "Clé d'API absente, invalide ou révoquée", content: { "application/json": { schema: { $ref: "#/components/schemas/Error" } } } },
- },
- },
- },
- },
- };
-
- // CORS ouvert en lecture : le schéma est public et peut être chargé par un outil tiers.
- return Response.json(spec, { headers: { "Access-Control-Allow-Origin": "*" } });
-}
diff --git a/src/app/api/v1/products/[codein]/gamme/route.ts b/src/app/api/v1/products/[codein]/gamme/route.ts
deleted file mode 100644
index 926ffc3..0000000
--- a/src/app/api/v1/products/[codein]/gamme/route.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail } from "@/lib/api-response";
-import { productGammeBodySchema } from "@/lib/api-schemas";
-import { listGridSuppliersForCodein } from "@/lib/grid-store";
-import { affecterGammes, lireCorpsJson } from "@/lib/api-gammes";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-// Idem /api/v1/grid : le calcul à la demande peut prendre plusieurs secondes.
-export const maxDuration = 300;
-
-/**
- * PUT /api/v1/products/:codein/gamme { "gamme": "A", "fournisseur"?: "…" }
- *
- * Propose une gamme pour un article. La proposition reste **à valider** : elle
- * apparaît dans la Grille comme une modification non enregistrée, et `codeGamme`
- * ne change qu'une fois validée (« Enregistrer » dans la Grille).
- *
- * `fournisseur` n'est requis que si l'article est référencé chez plusieurs
- * fournisseurs, ou s'il n'apparaît pas encore dans l'instantané.
- */
-export async function PUT(
- req: NextRequest,
- ctx: { params: Promise<{ codein: string }> },
-) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const { codein } = await ctx.params;
- if (!codein) return fail("bad_request", "Paramètre 'codein' requis.");
-
- const corps = await lireCorpsJson(req);
- if (corps instanceof Response) return corps;
- const parsed = productGammeBodySchema.safeParse(corps);
- if (!parsed.success) {
- return fail("bad_request", "Corps de requête invalide.", parsed.error.issues);
- }
- const { gamme, compute } = parsed.data;
-
- let fournisseur = parsed.data.fournisseur;
- if (!fournisseur) {
- const fournisseurs = await listGridSuppliersForCodein(codein);
- if (fournisseurs.length === 0) {
- return fail(
- "not_found",
- `Aucun instantané pour le produit « ${codein} ». Ajoutez « fournisseur » au corps de la requête pour que l'API calcule le lot à la demande.`,
- );
- }
- if (fournisseurs.length > 1) {
- return fail(
- "bad_request",
- `Le produit « ${codein} » est référencé chez plusieurs fournisseurs : précisez « fournisseur ».`,
- { fournisseurs },
- );
- }
- fournisseur = fournisseurs[0].codeFournisseur;
- }
-
- const res = await affecterGammes({
- codeFournisseur: fournisseur,
- changes: [{ codein, gamme }],
- compute,
- auteur: authCtx.subject,
- });
- if (res instanceof Response) return res;
-
- return ok(
- { ...res.resultats[0], codeFournisseur: res.codeFournisseur, nomFournisseur: res.nomFournisseur },
- { meta: { enregistreLe: new Date().toISOString() } },
- );
-}
diff --git a/src/app/api/v1/products/[codein]/route.ts b/src/app/api/v1/products/[codein]/route.ts
deleted file mode 100644
index d52cb5f..0000000
--- a/src/app/api/v1/products/[codein]/route.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail } from "@/lib/api-response";
-import { productDetailSchema } from "@/lib/api-schemas";
-import { getGridRowByCodein } from "@/lib/grid-store";
-import { enrichRows } from "@/lib/api-enrich";
-import { getProductRows } from "@/features/grid/api/get-product-rows";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-// Idem /api/v1/grid : le calcul à la demande peut prendre plusieurs secondes.
-export const maxDuration = 300;
-
-/**
- * GET /api/v1/products/:codein?fournisseur=…
- *
- * Fiche complète d'un produit : le `ProductRow` intégral (séries mensuelles,
- * ventilations par magasin, stock, marges, gammes) enrichi des métriques réseau Qlik
- * lues **en cache** (`qlik_network_metrics`) — aucun appel à Qlik.
- *
- * `fournisseur` lève l'ambiguïté d'un article référencé chez plusieurs fournisseurs ;
- * sans lui, l'instantané le plus récent est renvoyé.
- */
-export async function GET(
- req: NextRequest,
- ctx: { params: Promise<{ codein: string }> },
-) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const { codein } = await ctx.params;
- if (!codein) return fail("bad_request", "Paramètre 'codein' requis.");
-
- const parsed = productDetailSchema.safeParse(Object.fromEntries(req.nextUrl.searchParams));
- if (!parsed.success) {
- return fail("bad_request", "Paramètres invalides.", parsed.error.issues);
- }
-
- let found = await getGridRowByCodein(codein, parsed.data.fournisseur);
-
- // Absent de l'instantané : on peut le calculer, mais seulement si l'appelant a
- // précisé le fournisseur — le calcul se fait par lot fournisseur, pas par article.
- if (!found && parsed.data.compute === "1" && parsed.data.fournisseur) {
- console.log(`[api/v1/products] ${codein} absent — calcul du lot ${parsed.data.fournisseur} à la demande`);
- try {
- await getProductRows({ codeFournisseur: parsed.data.fournisseur, magasin: "TOTAL" });
- found = await getGridRowByCodein(codein, parsed.data.fournisseur);
- } catch (e) {
- console.error(`[api/v1/products] calcul KO pour ${parsed.data.fournisseur}:`, e instanceof Error ? e.message : String(e));
- }
- }
-
- if (!found) {
- return fail(
- "not_found",
- parsed.data.fournisseur
- ? `Produit « ${codein} » introuvable chez le fournisseur « ${parsed.data.fournisseur} ».`
- : `Aucun instantané pour le produit « ${codein} ». Ajoutez « fournisseur=… » pour que l'API calcule le lot à la demande.`,
- );
- }
-
- // Métriques réseau + gamme serveur relues maintenant : le payload date du dernier
- // calcul de la grille, alors que ces deux données évoluent indépendamment.
- const [enriched] = await enrichRows([found.row]);
-
- return ok(enriched, {
- meta: {
- computedAt: found.computedAt,
- networkFetchedAt: enriched.network?.fetchedAt ?? null,
- hasNetwork: enriched.network !== null,
- },
- });
-}
diff --git a/src/app/api/v1/products/search/route.ts b/src/app/api/v1/products/search/route.ts
deleted file mode 100644
index 352a5f8..0000000
--- a/src/app/api/v1/products/search/route.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { NextRequest } from "next/server";
-import { requireApiAuth } from "@/lib/api-auth";
-import { ok, fail, buildPagination } from "@/lib/api-response";
-import { productSearchSchema, pickFields, toSortKey } from "@/lib/api-schemas";
-import { queryGridRows } from "@/lib/grid-store";
-import { enrichRows } from "@/lib/api-enrich";
-
-export const runtime = "nodejs";
-export const dynamic = "force-dynamic";
-
-/**
- * GET /api/v1/products/search?q=…&fournisseur=&gamme=&sort=&order=&page=&limit=&fields=
- *
- * **Recherche transversale** sur libellé, codein, GTIN, référence et code centrale —
- * tous fournisseurs confondus. C'est ce qu'aucune route existante ne sait faire :
- * `getProductRows()` exige un fournisseur, donc chercher un produit sans le connaître
- * était impossible.
- *
- * Lit uniquement l'instantané `grid_rows` : un fournisseur jamais ouvert dans la
- * Grille n'apparaît pas encore dans les résultats.
- */
-export async function GET(req: NextRequest) {
- const authCtx = await requireApiAuth(req);
- if (authCtx instanceof Response) return authCtx;
-
- const parsed = productSearchSchema.safeParse(Object.fromEntries(req.nextUrl.searchParams));
- if (!parsed.success) {
- return fail("bad_request", "Paramètres invalides.", parsed.error.issues);
- }
- const q = parsed.data;
-
- const result = await queryGridRows({
- codeFournisseur: q.fournisseur,
- gamme: q.gamme,
- search: q.q,
- sort: toSortKey(q.sort),
- order: q.order,
- page: q.page,
- limit: q.limit,
- });
-
- // Métriques Qlik et gamme serveur relues au moment de l'appel (voir api-enrich).
- const rows = q.enrich === "1" ? await enrichRows(result.rows) : result.rows;
-
- return ok(
- rows.map((r) => pickFields(r, q.fields)),
- {
- pagination: buildPagination(q.page, q.limit, result.total),
- meta: {
- query: q.q,
- computedAt: result.computedAt,
- scope: q.fournisseur ? `fournisseur:${q.fournisseur}` : "tous fournisseurs",
- enrichi: q.enrich === "1",
- },
- },
- );
-}
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
deleted file mode 100644
index adec33a..0000000
--- a/src/app/layout.tsx
+++ /dev/null
@@ -1,35 +0,0 @@
-import type { Metadata } from "next";
-import "./globals.css";
-import { Providers } from "./providers";
-
-export const metadata: Metadata = {
- title: { default: "CollectFlow", template: "%s · CollectFlow" },
- description: "Révision d'assortiment et suivi des ventes des magasins",
-};
-
-export default function RootLayout({
- children,
-}: Readonly<{
- children: React.ReactNode;
-}>) {
- return (
-
-
- {/* Inter chargé côté navigateur (et non au build) pour éviter toute
- dépendance réseau à Google Fonts pendant `next build` (Docker). */}
-
-
- {/* eslint-disable-next-line @next/next/no-page-custom-font */}
-
-
-
-
- {children}
-
-
-
- );
-}
diff --git a/src/app/page.tsx b/src/app/page.tsx
index 9ef1235..89ea8fd 100644
--- a/src/app/page.tsx
+++ b/src/app/page.tsx
@@ -1,5 +1,5 @@
-import { redirect } from "next/navigation";
+import { Navigate } from "react-router";
export default function HomePage() {
- redirect("/dashboard");
+ return
-
-
- {children}
-
-
-
+ // Compteur de rafraîchissement (`router.refresh()`) : relu par les données
+ // des pages et par la session.
+
+ {/* La session n'est pas relue à chaque retour sur l'onglet : elle repartait
+ sur le réseau et redessinait toute la page (Grille comprise) à chaque fois. */}
+
+
+
+ {children}
+
+
+
+
);
}
diff --git a/src/components/shared/admin-only.tsx b/src/components/shared/admin-only.tsx
new file mode 100644
index 0000000..463a0a1
--- /dev/null
+++ b/src/components/shared/admin-only.tsx
@@ -0,0 +1,14 @@
+import type { ReactNode } from "react";
+import { Navigate } from "react-router";
+import { useSessionResolue } from "next-auth/react";
+
+/**
+ * Pages réservées aux administrateurs : le serveur filtre déjà l'accès direct
+ * (rôle relu en base) ; ici, la même règle pour une navigation dans
+ * l'application — retour à l'accueil sinon.
+ */
+export function AdminOnly({ children }: { children: ReactNode }) {
+ const session = useSessionResolue();
+ if (session?.user.role !== "admin") return {
+ state: State = { error: null };
+
+ static getDerivedStateFromError(error: unknown): State {
+ return { error: error instanceof Error ? error : new Error(String(error)) };
+ }
+
+ componentDidCatch(error: Error, info: ErrorInfo): void {
+ void error;
+ void info;
+ }
+
+ private reset = () => {
+ // Nouvelle clé de données (sans transition : la silhouette s'affiche),
+ // puis nouvel essai de rendu de la page.
+ refreshPage({ transition: false });
+ this.setState({ error: null });
+ };
+
+ render(): ReactNode {
+ if (this.state.error) return this.props.fallback(this.state.error, this.reset);
+ return this.props.children;
+ }
+}
diff --git a/src/components/shared/sidebar.tsx b/src/components/shared/sidebar.tsx
index c355d18..0e068db 100644
--- a/src/components/shared/sidebar.tsx
+++ b/src/components/shared/sidebar.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { ChevronLeft, ChevronRight, Package } from "lucide-react";
import Link from "next/link";
import { usePathname } from "next/navigation";
diff --git a/src/components/shared/theme-provider.tsx b/src/components/shared/theme-provider.tsx
index b7556ec..4d51e2f 100644
--- a/src/components/shared/theme-provider.tsx
+++ b/src/components/shared/theme-provider.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { ThemeProvider as NextThemesProvider } from "next-themes";
export function ThemeProvider({ children }: { children: React.ReactNode }) {
diff --git a/src/components/ui/data-table.tsx b/src/components/ui/data-table.tsx
index b12a722..9aea8bb 100644
--- a/src/components/ui/data-table.tsx
+++ b/src/components/ui/data-table.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* Tableau de données commun : recherche, filtres, tri par colonne, pagination,
* export, état vide et ligne de totaux — identiques sur toutes les pages.
diff --git a/src/components/ui/dialog.tsx b/src/components/ui/dialog.tsx
index bf9459c..42c9ea8 100644
--- a/src/components/ui/dialog.tsx
+++ b/src/components/ui/dialog.tsx
@@ -1,5 +1,3 @@
-"use client"
-
import * as React from "react"
import { XIcon } from "lucide-react"
import { Dialog as DialogPrimitive } from "radix-ui"
diff --git a/src/components/ui/dropdown-menu.tsx b/src/components/ui/dropdown-menu.tsx
index 1c9880c..ecc78c4 100644
--- a/src/components/ui/dropdown-menu.tsx
+++ b/src/components/ui/dropdown-menu.tsx
@@ -1,5 +1,3 @@
-"use client"
-
import * as React from "react"
import { CheckIcon, ChevronRightIcon, CircleIcon } from "lucide-react"
import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui"
diff --git a/src/components/ui/feedback.tsx b/src/components/ui/feedback.tsx
index 43214f0..b20b49d 100644
--- a/src/components/ui/feedback.tsx
+++ b/src/components/ui/feedback.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* Retours à l'utilisateur, communs à toute l'application :
* - `toast.succes / toast.erreur / toast.info` : message discret en bas à droite,
diff --git a/src/components/ui/form-controls.tsx b/src/components/ui/form-controls.tsx
index 8e9b6f8..eddc738 100644
--- a/src/components/ui/form-controls.tsx
+++ b/src/components/ui/form-controls.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
import { Search, X } from "lucide-react";
import { cn } from "@/lib/utils";
diff --git a/src/components/ui/pagination.tsx b/src/components/ui/pagination.tsx
index 9ed0b15..ea471a7 100644
--- a/src/components/ui/pagination.tsx
+++ b/src/components/ui/pagination.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { ChevronLeft, ChevronRight, ChevronsLeft, ChevronsRight } from "lucide-react";
interface PaginationProps {
diff --git a/src/components/ui/tabs.tsx b/src/components/ui/tabs.tsx
index a74d3b3..efdcac2 100644
--- a/src/components/ui/tabs.tsx
+++ b/src/components/ui/tabs.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useState, type ReactNode } from "react";
import type { LucideIcon } from "lucide-react";
import { cn } from "@/lib/utils";
diff --git a/src/components/ui/tooltip.tsx b/src/components/ui/tooltip.tsx
index a0f0a77..c2e5395 100644
--- a/src/components/ui/tooltip.tsx
+++ b/src/components/ui/tooltip.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import type { ReactNode } from "react";
import { Tooltip as TooltipPrimitive } from "radix-ui";
import { Info } from "lucide-react";
diff --git a/src/db/index.ts b/src/db/index.ts
deleted file mode 100644
index a72a93a..0000000
--- a/src/db/index.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import { drizzle, NodePgDatabase } from "drizzle-orm/node-postgres";
-import { Pool } from "pg";
-import * as schema from "./schema";
-import fs from "fs";
-import path from "path";
-
-/**
- * Pool unique par processus, rangé dans `globalThis` : l'instrumentation (synchro
- * nocturne) et les routes peuvent être compilées dans des lots distincts, chacun
- * avec sa propre copie de ce module — et donc son propre pool de 20 connexions.
- * Même chose à chaque rechargement à chaud en développement.
- */
-type DbState = { pool: Pool | null; db: NodePgDatabase | null };
-const globalForDb = globalThis as typeof globalThis & { __collectflowDb?: DbState };
-const state: DbState = (globalForDb.__collectflowDb ??= { pool: null, db: null });
-
-export function getPool(): Pool {
- getDb(); // ensure pool is initialized
- return state.pool!;
-}
-
-function maskUrl(url: string | undefined) {
- if (!url) return "undefined";
- return url.replace(/:([^@]+)@/, ":****@");
-}
-
-/**
- * Initializes or returns the current database instance.
- */
-export function getDb() {
- if (state.db) return state.db;
-
- let connectionString = "";
-
- try {
- const CONFIG_PATH = path.join(process.cwd(), "data", ".db-config.json");
- if (fs.existsSync(CONFIG_PATH)) {
- console.log("[DB] Found config file at:", CONFIG_PATH);
- const config = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
- if (config.url) {
- connectionString = config.url;
- console.log("[DB] Loaded saved database URL from config.");
- }
- }
- } catch (err) {
- console.error("[DB] Error reading config file:", err);
- }
-
- // Use environment variable as fallback if no config is found
- if (!connectionString && process.env.DATABASE_URL) {
- connectionString = process.env.DATABASE_URL;
- console.log("[DB] Using environment variable as fallback.");
- }
-
- console.log("[DB] Initializing connection with:", maskUrl(connectionString));
-
- if (!connectionString) {
- console.error("[DB] CRITICAL: No database connection string available!");
- }
-
- const connectionHostname = connectionString.match(/@([^:/]+)/)?.[1] || "unknown";
- console.log(`[DB] Target Hostname: ${connectionHostname}`);
-
- // Délai maximal par requête : opt-in (les calculs nocturnes des plus gros
- // fournisseurs peuvent être longs), pour qu'une requête emballée ne monopolise
- // pas indéfiniment une des 20 connexions.
- const statementTimeout = Number(process.env.PG_STATEMENT_TIMEOUT_MS) || undefined;
-
- const pool = new Pool({
- connectionString,
- max: 20,
- idleTimeoutMillis: 30000,
- connectionTimeoutMillis: 10000,
- application_name: "collectflow",
- ...(statementTimeout ? { statement_timeout: statementTimeout } : {}),
- });
-
- pool.on('error', (err) => {
- console.error('[DB] Unexpected error on idle client', err);
- });
-
- // Pas de workers parallèles PostgreSQL : ils consomment /dev/shm, trop petit
- // dans le conteneur, et font échouer les grosses agrégations. Réglé une fois
- // par connexion (la requête est mise en file avant toute autre sur ce client)
- // au lieu d'une transaction BEGIN / SET LOCAL / COMMIT autour de chaque requête.
- pool.on('connect', (client) => {
- client.query("SET max_parallel_workers_per_gather = 0").catch((err) => {
- console.error('[DB] SET max_parallel_workers_per_gather failed:', err?.message);
- });
- });
-
- state.pool = pool;
- state.db = drizzle(pool, { schema });
- return state.db;
-}
-
-/**
- * Resets the current database connection.
- * Called when settings are updated via the UI.
- */
-export function refreshDb() {
- console.log("[DB] Refreshing database connection...");
- if (state.pool) {
- state.pool.end().catch(err => console.error("[DB] Error closing pool:", err));
- state.pool = null;
- }
- state.db = null;
-}
-
-/**
- * Proxy for the 'db' instance.
- * Allows existing imports (import { db } from "@/db") to work
- * while the underlying instance can be hot-swapped.
- */
-export const db = new Proxy({} as NodePgDatabase, {
- get(target, prop, receiver) {
- const d = getDb();
- return Reflect.get(d, prop, receiver);
- }
-});
diff --git a/src/db/schema.ts b/src/db/schema.ts
deleted file mode 100644
index a480879..0000000
--- a/src/db/schema.ts
+++ /dev/null
@@ -1,308 +0,0 @@
-import { pgTable, serial, varchar, numeric, smallint, timestamp, uniqueIndex, index, text, jsonb, integer, boolean, primaryKey } from "drizzle-orm/pg-core";
-
-export const ventesProduits = pgTable("ventes_produits", {
- id: serial("id").primaryKey(),
-
- // Identification produit
- codein: varchar("codein", { length: 20 }).notNull(),
- codeFournisseur: varchar("code_fournisseur", { length: 20 }),
- nomFournisseur: varchar("nom_fournisseur", { length: 255 }),
- libelle1: varchar("libelle1", { length: 500 }),
- gtin: varchar("gtin", { length: 30 }),
- reference: varchar("reference", { length: 100 }),
- colisage: numeric("colisage", { precision: 10, scale: 5 }),
-
- // Gamme & Nomenclature
- codeGamme: varchar("code_gamme", { length: 20 }),
- codeGammeInit: varchar("code_gamme_init", { length: 20 }),
- code3: varchar("code3", { length: 20 }),
- libelle3: varchar("libelle3", { length: 500 }),
-
- // Dimension magasin & période
- magasin: varchar("magasin", { length: 20 }).notNull(),
- codeMagasin: varchar("code_magasin", { length: 10 }),
- annee: smallint("annee"),
- mois: smallint("mois"),
- periode: varchar("periode", { length: 10 }).notNull(),
-
- // Métriques
- quantite: numeric("quantite", { precision: 12, scale: 2 }),
- montantMvt: numeric("montant_mvt", { precision: 14, scale: 4 }),
- margeMvt: numeric("marge_mvt", { precision: 14, scale: 4 }),
-
- // Métadonnées
- importedAt: timestamp("imported_at").defaultNow(),
- updatedAt: timestamp("updated_at").defaultNow(),
-}, (table) => {
- return [
- uniqueIndex("uq_ventes_produit_magasin_periode").on(table.codein, table.magasin, table.periode),
- index("idx_ventes_codein").on(table.codein),
- index("idx_ventes_fournisseur").on(table.codeFournisseur),
- index("idx_ventes_gamme").on(table.codeGamme),
- index("idx_ventes_code3").on(table.code3),
- index("idx_ventes_magasin").on(table.magasin),
- index("idx_ventes_periode").on(table.periode),
- index("idx_ventes_annee_mois").on(table.annee, table.mois),
- index("idx_ventes_updated_at").on(table.updatedAt),
- ];
-});
-
-/** User management (Epic 6) */
-export const users = pgTable("users", {
- id: serial("id").primaryKey(),
- username: varchar("username", { length: 50 }).notNull().unique(),
- /** Hashed password */
- passwordHash: text("password_hash").notNull(),
- /** 'admin' or 'user' */
- role: varchar("role", { length: 20 }).default("user").notNull(),
- createdAt: timestamp("created_at").defaultNow(),
-});
-
-/** Snapshot of a complete arbitrage session (Epic 5) */
-export const sessionSnapshots = pgTable("session_snapshots", {
- id: serial("id").primaryKey(),
- /** Link to user who created the snapshot */
- userId: integer("user_id").references(() => users.id),
- codeFournisseur: varchar("code_fournisseur", { length: 20 }).notNull(),
- nomFournisseur: varchar("nom_fournisseur", { length: 255 }),
- magasin: varchar("magasin", { length: 20 }).notNull(),
- /** JSON map of codein → { before: GammeCode, after: GammeCode } */
- changes: jsonb("changes").notNull(),
- /** Summary stats at time of snapshot */
- summaryJson: jsonb("summary_json"),
- /** Label for the snapshot */
- label: text("label"),
- /** snapshot vs export */
- type: varchar("type", { length: 20 }).default("snapshot"),
- createdAt: timestamp("created_at").defaultNow(),
-}, (table) => [
- // Créés par scripts/db-init.js (la migration réellement jouée au démarrage).
- index("idx_snapshots_fournisseur_date").on(table.codeFournisseur, table.createdAt.desc()),
- index("idx_snapshots_user_type_date").on(table.userId, table.type, table.createdAt.desc()),
-]);
-
-/**
- * Cadencier / alertes de commande par fournisseur ET par magasin.
- * Un fournisseur peut être cadencé indépendamment sur chaque site (292/579)
- * avec un intervalle propre (toutes les X semaines). L'échéance est calculée
- * à partir de la dernière commande réelle (FF Nancy) + intervalle.
- */
-export const commandeCadences = pgTable("commande_cadences", {
- id: serial("id").primaryKey(),
- /** Code fournisseur (fouident.code) */
- codeFournisseur: varchar("code_fournisseur", { length: 20 }).notNull(),
- /** Nom fournisseur dénormalisé pour l'affichage */
- nomFournisseur: varchar("nom_fournisseur", { length: 255 }),
- /** Site / magasin : "292" | "579" */
- site: varchar("site", { length: 20 }).notNull(),
- /** Fréquence de commande, en semaines */
- intervalleSemaines: integer("intervalle_semaines").notNull(),
- /** Cadence active ou non */
- actif: boolean("actif").default(true).notNull(),
- createdAt: timestamp("created_at").defaultNow(),
- updatedAt: timestamp("updated_at").defaultNow(),
-}, (table) => {
- return [
- uniqueIndex("uq_cadence_fou_site").on(table.codeFournisseur, table.site),
- index("idx_cadence_site").on(table.site),
- ];
-});
-
-/**
- * Cache des métriques réseau Qlik Sense (~270 magasins La Foir'Fouille).
- * Clé = code centrale (format 10000XXXXXX). Rafraîchi par /api/qlik/sync.
- */
-export const qlikNetworkMetrics = pgTable("qlik_network_metrics", {
- /** Code centrale article (clé jointure Qlik ↔ FF) */
- codeCentrale: varchar("code_centrale", { length: 20 }).primaryKey(),
- /** CA réseau total du produit */
- caReseau: numeric("ca_reseau", { precision: 16, scale: 2 }),
- /** Quantité vendue réseau */
- qteReseau: numeric("qte_reseau", { precision: 14, scale: 2 }),
- /** Nombre de magasins travaillant le produit (sur ~270) */
- nbMagasinsReseau: integer("nb_magasins_reseau"),
- /** CA moyen par magasin (productivité normalisée présence) */
- caParMagasinReseau: numeric("ca_par_magasin_reseau", { precision: 16, scale: 2 }),
- /** Taux de marge réseau (ratio brut Qlik) */
- margePctReseau: numeric("marge_pct_reseau", { precision: 8, scale: 4 }),
- /** Période couverte (libre, ex "12m" ou "2025") */
- periode: varchar("periode", { length: 20 }),
- /** Quantité vendue réseau par mois : { "YYYY-MM": qté } (12 derniers mois). */
- qteByMonth: jsonb("qte_by_month"),
- /**
- * Détail mensuel complet : { "YYYY-MM": { qte, ca, nbMag, caMag, margePct } }.
- * Superset de `qteByMonth`, qui reste maintenu tel quel pour la colonne
- * « Tendance / Réseau » de la Grille.
- */
- metricsByMonth: jsonb("metrics_by_month"),
- /**
- * Libellé de l'article tel que Qlik le renvoie. Renseigné par la recherche
- * produit (qui interroge la dimension libellé) ; la sync fournisseur ne
- * l'écrase pas. Permet d'afficher une fiche pour un produit réseau que le
- * catalogue Nancy ne référence pas.
- */
- libelleReseau: varchar("libelle_reseau", { length: 255 }),
- /** Fournisseur de l'article côté Qlik, même origine que `libelleReseau`. */
- fournisseurReseau: varchar("fournisseur_reseau", { length: 255 }),
- /** Dernière synchro depuis Qlik */
- fetchedAt: timestamp("fetched_at").defaultNow(),
-});
-
-/**
- * Instantané persisté des lignes de grille (une ligne par fournisseur × article).
- *
- * Raison d'être : `getProductRows()` reconstruit la grille en direct et ne la garde
- * qu'en mémoire 10 minutes — perdu à chaque redémarrage. L'API `/api/v1` ne doit
- * jamais déclencher ce calcul, elle lit donc cette table, remplie en effet de bord
- * quand quelqu'un ouvre la Grille. Aucun calcul supplémentaire n'est introduit : on
- * arrête simplement de jeter le résultat.
- *
- * Seul `magasin = TOTAL` est persisté : `payload` embarque déjà les ventilations par
- * magasin (sales12mByStore, caByStore…).
- */
-export const gridRows = pgTable("grid_rows", {
- codeFournisseur: varchar("code_fournisseur", { length: 20 }).notNull(),
- codein: varchar("codein", { length: 20 }).notNull(),
-
- // Colonnes scalaires : servent aux filtres, au tri et à la recherche en SQL.
- nomFournisseur: varchar("nom_fournisseur", { length: 255 }),
- libelle1: varchar("libelle1", { length: 500 }),
- gtin: varchar("gtin", { length: 30 }),
- reference: varchar("reference", { length: 100 }),
- codeCentrale: varchar("code_centrale", { length: 20 }),
- code1: varchar("code1", { length: 20 }),
- code2: varchar("code2", { length: 20 }),
- code3: varchar("code3", { length: 20 }),
- codeGamme: varchar("code_gamme", { length: 20 }),
- codeGammeInit: varchar("code_gamme_init", { length: 20 }),
- totalCa: numeric("total_ca", { precision: 16, scale: 2 }),
- totalQuantite: numeric("total_quantite", { precision: 14, scale: 2 }),
- totalMarge: numeric("total_marge", { precision: 16, scale: 2 }),
- tauxMarge: numeric("taux_marge", { precision: 8, scale: 4 }),
- stockActuel: numeric("stock_actuel", { precision: 14, scale: 2 }),
- caReseau: numeric("ca_reseau", { precision: 16, scale: 2 }),
- qteReseau: numeric("qte_reseau", { precision: 14, scale: 2 }),
- nbMagasinsReseau: integer("nb_magasins_reseau"),
- caParMagasinReseau: numeric("ca_par_magasin_reseau", { precision: 16, scale: 2 }),
- margePctReseau: numeric("marge_pct_reseau", { precision: 8, scale: 4 }),
-
- /** ProductRow complet (séries mensuelles, ventilations par magasin, dates…). */
- payload: jsonb("payload").notNull(),
- /** Date du calcul ayant produit cette ligne — expose la fraîcheur au consommateur. */
- computedAt: timestamp("computed_at").defaultNow().notNull(),
-}, (table) => {
- return [
- uniqueIndex("uq_grid_rows_fou_codein").on(table.codeFournisseur, table.codein),
- index("idx_grid_rows_fournisseur").on(table.codeFournisseur),
- index("idx_grid_rows_codein").on(table.codein),
- index("idx_grid_rows_gamme").on(table.codeGamme),
- index("idx_grid_rows_code_centrale").on(table.codeCentrale),
- index("idx_grid_rows_total_ca").on(table.totalCa),
- index("idx_grid_rows_libelle").on(table.libelle1),
- ];
-});
-
-/**
- * Clés d'API pour les appelants non-navigateur (scripts, outils externes).
- *
- * Seul le hachage SHA-256 est stocké : la clé en clair n'est affichée qu'une fois,
- * à la création. Une clé révoquée conserve sa ligne (traçabilité) via `revokedAt`.
- */
-export const apiKeys = pgTable("api_keys", {
- id: serial("id").primaryKey(),
- /** Nom lisible choisi à la création (ex "Export Excel comptabilité"). */
- name: varchar("name", { length: 100 }).notNull(),
- /** Préfixe en clair (ex "cf_a1b2c3") — sert à identifier la clé dans l'UI. */
- keyPrefix: varchar("key_prefix", { length: 20 }).notNull(),
- /** SHA-256 hexadécimal de la clé complète. */
- keyHash: text("key_hash").notNull().unique(),
- /** 'admin' ou 'user' — même sémantique que users.role. */
- role: varchar("role", { length: 20 }).default("user").notNull(),
- createdBy: varchar("created_by", { length: 50 }),
- createdAt: timestamp("created_at").defaultNow(),
- lastUsedAt: timestamp("last_used_at"),
- revokedAt: timestamp("revoked_at"),
-});
-
-/**
- * Paramétrage et suivi de la synchronisation nocturne, un enregistrement par
- * fournisseur.
- *
- * Deux sources aux coûts très différents, donc deux cadences distinctes :
- * l'instantané SQL prend une minute au pire, l'extraction Qlik jusqu'à huit —
- * et le serveur Qlik abandonne quand on le sollicite trop. D'où `actifSql` et
- * `actifQlik` séparés, et deux dates de dernier passage.
- *
- * L'ordre de passage se déduit de `dernier*At` (le plus ancien d'abord) : la
- * nuit suivante reprend donc naturellement là où la précédente s'est arrêtée,
- * et repart d'elle-même pour un nouveau tour quand tout a été traité. Aucun
- * curseur ni compteur de tour à maintenir.
- */
-export const syncFournisseurs = pgTable("sync_fournisseurs", {
- codeFournisseur: varchar("code_fournisseur", { length: 20 }).primaryKey(),
- nomFournisseur: varchar("nom_fournisseur", { length: 255 }),
- /** Inclus dans la rotation de l'instantané SQL. */
- actifSql: boolean("actif_sql").default(true).notNull(),
- /** Inclus dans la rotation Qlik (beaucoup plus coûteuse). */
- actifQlik: boolean("actif_qlik").default(true).notNull(),
- /**
- * Renseigné quand le planificateur a désactivé le fournisseur de lui-même —
- * typiquement « aucun article ». Évite de réessayer chaque nuit un
- * fournisseur vide, tout en gardant la raison visible pour le réactiver.
- */
- desactiveMotif: text("desactive_motif"),
-
- dernierSqlAt: timestamp("dernier_sql_at"),
- /** 'succes' | 'echec' | 'vide' */
- dernierSqlStatut: varchar("dernier_sql_statut", { length: 20 }),
- dernierSqlLignes: integer("dernier_sql_lignes"),
- dernierSqlErreur: text("dernier_sql_erreur"),
- dernierSqlMs: integer("dernier_sql_ms"),
-
- dernierQlikAt: timestamp("dernier_qlik_at"),
- dernierQlikStatut: varchar("dernier_qlik_statut", { length: 20 }),
- dernierQlikCodes: integer("dernier_qlik_codes"),
- dernierQlikErreur: text("dernier_qlik_erreur"),
- dernierQlikMs: integer("dernier_qlik_ms"),
-
- updatedAt: timestamp("updated_at").defaultNow(),
-}, (table) => {
- return [
- // Index de file d'attente : « le plus ancien d'abord », par source.
- index("idx_sync_fou_sql").on(table.actifSql, table.dernierSqlAt),
- index("idx_sync_fou_qlik").on(table.actifQlik, table.dernierQlikAt),
- ];
-});
-
-/** AI Context rules per supplier (Epic: AI Context) */
-export const aiSupplierContext = pgTable("ai_supplier_context", {
- /** Supplier code serving as the primary key */
- codeFournisseur: varchar("code_fournisseur", { length: 20 }).primaryKey(),
- /** The business rules text provided by the user */
- context: text("context").notNull(),
- /** When it was last updated */
- updatedAt: timestamp("updated_at").defaultNow(),
-});
-
-/**
- * Gammes proposées par l'API `/api/v1`, en attente de validation.
- *
- * L'API n'enregistre plus directement : chaque proposition attend ici qu'un
- * utilisateur l'examine dans la Grille, où elle apparaît comme une modification
- * non enregistrée. « Enregistrer » la valide (snapshot + `grid_rows`), « Annuler
- * les modifications » la rejette ; dans les deux cas la ligne est supprimée.
- * Une seule proposition par article et fournisseur : la dernière l'emporte.
- */
-export const gammesAValider = pgTable("gammes_a_valider", {
- codeFournisseur: varchar("code_fournisseur", { length: 20 }).notNull(),
- codein: varchar("codein", { length: 20 }).notNull(),
- /** Gamme proposée. */
- gamme: varchar("gamme", { length: 20 }).notNull(),
- /** Gamme enregistrée au moment de la proposition. */
- gammePrecedente: varchar("gamme_precedente", { length: 20 }),
- /** Nom de la clé d'API à l'origine de la proposition. */
- auteur: varchar("auteur", { length: 100 }),
- createdAt: timestamp("created_at").defaultNow().notNull(),
-}, (table) => [
- primaryKey({ columns: [table.codeFournisseur, table.codein] }),
-]);
diff --git a/src/features/admin/api/api-key-actions.ts b/src/features/admin/api/api-key-actions.ts
index 4277f26..5e068a4 100644
--- a/src/features/admin/api/api-key-actions.ts
+++ b/src/features/admin/api/api-key-actions.ts
@@ -1,19 +1,14 @@
-"use server";
-
/**
* CollectFlow — Gestion des clés de l'API `/api/v1` (administrateurs).
*
* La clé en clair n'existe qu'une fois : elle est renvoyée par `createApiKey()` et
* jamais restituée ensuite (seul son hachage SHA-256 est stocké). Une clé révoquée
* conserve sa ligne, pour garder la trace de son usage passé.
+ *
+ * Actions exécutées par le serveur Rust : `POST /api/actions/{nom}`.
*/
-import { db } from "@/db";
-import { apiKeys } from "@/db/schema";
-import { desc, eq } from "drizzle-orm";
-import { requireAdmin } from "@/lib/authz";
-import { generateApiKey } from "@/lib/api-auth";
-import { revalidatePath } from "next/cache";
+import { callAction } from "@/lib/rpc";
export interface ApiKeyRow {
id: number;
@@ -28,27 +23,7 @@ export interface ApiKeyRow {
/** Liste les clés. Ne renvoie jamais de secret — seulement le préfixe lisible. */
export async function getApiKeys(): Promise {
- await requireAdmin();
- const rows = await db
- .select({
- id: apiKeys.id,
- name: apiKeys.name,
- keyPrefix: apiKeys.keyPrefix,
- role: apiKeys.role,
- createdBy: apiKeys.createdBy,
- createdAt: apiKeys.createdAt,
- lastUsedAt: apiKeys.lastUsedAt,
- revokedAt: apiKeys.revokedAt,
- })
- .from(apiKeys)
- .orderBy(desc(apiKeys.createdAt));
-
- return rows.map((r) => ({
- ...r,
- createdAt: r.createdAt ? r.createdAt.toISOString() : null,
- lastUsedAt: r.lastUsedAt ? r.lastUsedAt.toISOString() : null,
- revokedAt: r.revokedAt ? r.revokedAt.toISOString() : null,
- }));
+ return callAction("getApiKeys", []);
}
/**
@@ -59,51 +34,15 @@ export async function createApiKey(
name: string,
role: "admin" | "user" = "user",
): Promise<{ success: true; key: string; keyPrefix: string } | { success: false; error: string }> {
- const moi = await requireAdmin();
-
- const trimmed = name.trim();
- if (!trimmed) return { success: false, error: "Le nom de la clé est obligatoire." };
- if (trimmed.length > 100) return { success: false, error: "Nom trop long (100 caractères max)." };
-
- try {
- const { key, keyHash, keyPrefix } = generateApiKey();
- await db.insert(apiKeys).values({
- name: trimmed,
- keyPrefix,
- keyHash,
- role,
- createdBy: moi.username || null,
- });
- revalidatePath("/settings");
- return { success: true, key, keyPrefix };
- } catch (err) {
- console.error("[api-keys] création KO:", err);
- return { success: false, error: "Erreur technique lors de la création de la clé." };
- }
+ return callAction("createApiKey", [name, role]);
}
/** Révoque une clé : elle est refusée dès l'appel suivant, mais reste listée. */
export async function revokeApiKey(id: number): Promise<{ success: boolean; error?: string }> {
- await requireAdmin();
- try {
- await db.update(apiKeys).set({ revokedAt: new Date() }).where(eq(apiKeys.id, id));
- revalidatePath("/settings");
- return { success: true };
- } catch (err) {
- console.error("[api-keys] révocation KO:", err);
- return { success: false, error: "Erreur lors de la révocation." };
- }
+ return callAction("revokeApiKey", [id]);
}
/** Supprime définitivement une clé révoquée (nettoyage de la liste). */
export async function deleteApiKey(id: number): Promise<{ success: boolean; error?: string }> {
- await requireAdmin();
- try {
- await db.delete(apiKeys).where(eq(apiKeys.id, id));
- revalidatePath("/settings");
- return { success: true };
- } catch (err) {
- console.error("[api-keys] suppression KO:", err);
- return { success: false, error: "Erreur lors de la suppression." };
- }
+ return callAction("deleteApiKey", [id]);
}
diff --git a/src/features/admin/api/sync-scheduler.ts b/src/features/admin/api/sync-scheduler.ts
deleted file mode 100644
index 7d80a44..0000000
--- a/src/features/admin/api/sync-scheduler.ts
+++ /dev/null
@@ -1,387 +0,0 @@
-/**
- * CollectFlow — Synchronisation nocturne des fournisseurs.
- *
- * Deux sources aux coûts très différents, donc deux files distinctes :
- * • **SQL** — l'instantané de grille (`getProductRows`), ~43 s sur le plus gros
- * fournisseur du catalogue. Alimente la Grille et `/api/v1`.
- * • **Qlik** — les métriques réseau, jusqu'à 8 min par fournisseur, sur un
- * serveur externe qui abandonne quand on le sollicite trop. Ce sont des
- * agrégats mensuels : les rafraîchir chaque nuit n'apporterait rien.
- *
- * ORDRE DE PASSAGE — le point de conception central. La file est simplement
- * « le plus ancien d'abord », en ignorant ceux déjà traités depuis l'ouverture
- * de la fenêtre courante. Il en découle, sans curseur ni compteur de tour :
- * • la nuit 2 reprend là où la nuit 1 s'est arrêtée (les non-traités sont les
- * plus anciens) ;
- * • quand plus personne n'est en attente, le tour est fini ; la nuit suivante
- * tout le monde redevient éligible et le tour recommence ;
- * • un fournisseur en échec garde une date ancienne, donc il repasse en tête —
- * le rattrapage est automatique.
- *
- * La fenêtre ne peut pas interrompre un fournisseur en cours : elle signifie
- * « ne plus en **démarrer** après l'heure de fin ».
- */
-
-import "server-only";
-
-import { and, asc, eq, isNull, lt, or, sql, type SQL } from "drizzle-orm";
-import { db } from "@/db";
-import { syncFournisseurs } from "@/db/schema";
-import { getProductRows } from "@/features/grid/api/get-product-rows";
-import { pgGetFournisseurs, pgGetArticlesByFournisseur } from "@/lib/pg-ff-client";
-import { fetchNetworkMetricsPlaywright } from "@/lib/qlik-playwright";
-import { upsertNetworkMetrics } from "@/lib/qlik-network-cache";
-import { buildGridNetworkQlikDateFilter, envMonthsBack, QLIK_MONTHS_BACK_DEFAULT } from "@/lib/qlik-date-range";
-import { readSyncSettings, type SyncSettings } from "@/features/admin/api/sync-settings";
-import { invalidateFFCache } from "@/lib/ff-cache";
-
-export type { SyncSettings };
-
-// ─── État courant, en mémoire ────────────────────────────────────────────────
-
-export interface SyncSchedulerState {
- enCours: boolean;
- /** "auto" = déclenché par la fenêtre nocturne, "manuel" = lancé depuis l'admin. */
- origine: "auto" | "manuel" | null;
- debutAt: string | null;
- finAt: string | null;
- fournisseurCourant: string | null;
- etape: "sql" | "qlik" | null;
- sqlFaits: number;
- sqlEchecs: number;
- qlikFaits: number;
- qlikEchecs: number;
- /** Renseigné quand la file s'est vidée : le tour est bouclé. */
- tourTermine: boolean;
- arretDemande: boolean;
- derniereErreur: string | null;
-}
-
-const etat: SyncSchedulerState = {
- enCours: false, origine: null, debutAt: null, finAt: null,
- fournisseurCourant: null, etape: null,
- sqlFaits: 0, sqlEchecs: 0, qlikFaits: 0, qlikEchecs: 0,
- tourTermine: false, arretDemande: false, derniereErreur: null,
-};
-
-export function getSyncSchedulerState(): SyncSchedulerState {
- return { ...etat };
-}
-
-export function demanderArret(): void {
- if (etat.enCours) etat.arretDemande = true;
-}
-
-// ─── Fenêtre horaire ─────────────────────────────────────────────────────────
-
-/**
- * Début de la fenêtre en cours, ou `null` si l'heure courante est en dehors.
- *
- * Gère le passage par minuit (ex. 22h → 5h) : dans ce cas, entre 0h et l'heure
- * de fin, la fenêtre a commencé **la veille**.
- */
-export function debutFenetre(s: SyncSettings, maintenant = new Date()): Date | null {
- const h = maintenant.getHours();
- const debutDuJour = new Date(maintenant);
- debutDuJour.setHours(s.heureDebut, 0, 0, 0);
-
- if (s.heureDebut < s.heureFin) {
- return h >= s.heureDebut && h < s.heureFin ? debutDuJour : null;
- }
- // Fenêtre à cheval sur minuit.
- if (h >= s.heureDebut) return debutDuJour;
- if (h < s.heureFin) {
- const veille = new Date(debutDuJour);
- veille.setDate(veille.getDate() - 1);
- return veille;
- }
- return null;
-}
-
-// ─── Référentiel des fournisseurs ────────────────────────────────────────────
-
-/**
- * Aligne la table de paramétrage sur le référentiel FF : ajoute les nouveaux
- * fournisseurs (actifs par défaut), rafraîchit les noms. Ne supprime rien —
- * l'historique de synchronisation d'un fournisseur disparu reste consultable.
- */
-export async function seedSyncFournisseurs(): Promise {
- const fournisseurs = await pgGetFournisseurs();
- if (fournisseurs.length === 0) return 0;
-
- const CHUNK = 500;
- for (let i = 0; i < fournisseurs.length; i += CHUNK) {
- const lot = fournisseurs.slice(i, i + CHUNK);
- await db
- .insert(syncFournisseurs)
- .values(lot.map((f) => ({ codeFournisseur: f.code, nomFournisseur: f.nom })))
- .onConflictDoUpdate({
- target: syncFournisseurs.codeFournisseur,
- // Seul le nom est réaligné : les choix d'activation appartiennent à l'admin.
- set: { nomFournisseur: sql`excluded.nom_fournisseur` },
- });
- }
- return fournisseurs.length;
-}
-
-// ─── Files d'attente ─────────────────────────────────────────────────────────
-
-/** Le plus ancien fournisseur SQL pas encore traité depuis l'ouverture de la fenêtre. */
-async function prochainSql(depuis: Date) {
- const [row] = await db
- .select()
- .from(syncFournisseurs)
- .where(and(
- eq(syncFournisseurs.actifSql, true),
- or(isNull(syncFournisseurs.dernierSqlAt), lt(syncFournisseurs.dernierSqlAt, depuis)) as SQL,
- ))
- .orderBy(asc(sql`${syncFournisseurs.dernierSqlAt} nulls first`))
- .limit(1);
- return row ?? null;
-}
-
-/** Délai avant de retenter un fournisseur Qlik en échec : la nuit suivante. */
-const QLIK_REPRISE_ECHEC_MS = 18 * 3600 * 1000;
-
-/**
- * Le plus ancien fournisseur Qlik à rafraîchir. Il l'est si :
- * - ses données dépassent `qlikMinJours` (agrégats mensuels : inutile de
- * relancer chaque nuit une extraction de plusieurs minutes) ;
- * - ou elles datent d'avant le mois en cours : la fenêtre de 12 mois a glissé,
- * son dernier mois manque, sa tendance n'est plus à jour ;
- * - ou sa dernière extraction a échoué il y a plus de 18 h. Un échec attendait
- * jusqu'ici `qlikMinJours` (7 jours) avant un nouvel essai, alors que la
- * plupart sont passagers (serveur Qlik chargé, dernier mois pas encore
- * chargé). Le plus ancien passant en premier, un fournisseur qui échoue à
- * chaque fois repart en fin de file et ne bloque personne.
- */
-async function prochainQlik(qlikMinJours: number, maintenant: Date) {
- const seuilAge = new Date(maintenant.getTime() - qlikMinJours * 24 * 3600 * 1000);
- const debutMois = new Date(maintenant.getFullYear(), maintenant.getMonth(), 1);
- const seuil = seuilAge > debutMois ? seuilAge : debutMois;
- const seuilEchec = new Date(maintenant.getTime() - QLIK_REPRISE_ECHEC_MS);
- const [row] = await db
- .select()
- .from(syncFournisseurs)
- .where(and(
- eq(syncFournisseurs.actifQlik, true),
- or(
- isNull(syncFournisseurs.dernierQlikAt),
- lt(syncFournisseurs.dernierQlikAt, seuil),
- and(eq(syncFournisseurs.dernierQlikStatut, "echec"), lt(syncFournisseurs.dernierQlikAt, seuilEchec)),
- ) as SQL,
- ))
- .orderBy(asc(sql`${syncFournisseurs.dernierQlikAt} nulls first`))
- .limit(1);
- return row ?? null;
-}
-
-// ─── Traitement d'un fournisseur ─────────────────────────────────────────────
-
-/**
- * Instantané SQL. `dernierSqlAt` est renseigné **même en cas d'échec** : sans
- * cela, un fournisseur qui échoue resterait éternellement le plus ancien et
- * bloquerait la file derrière lui.
- */
-async function traiterSql(code: string, nom: string | null): Promise {
- const t0 = Date.now();
- etat.fournisseurCourant = `${code}${nom ? ` — ${nom}` : ""}`;
- etat.etape = "sql";
- try {
- const rows = await getProductRows({ codeFournisseur: code, magasin: "TOTAL", forceRefresh: true });
- const vide = rows.length === 0;
- await db.update(syncFournisseurs).set({
- dernierSqlAt: new Date(),
- dernierSqlStatut: vide ? "vide" : "succes",
- dernierSqlLignes: rows.length,
- dernierSqlErreur: null,
- dernierSqlMs: Date.now() - t0,
- // Un fournisseur sans article n'a rien à donner : on le sort des deux
- // files plutôt que de le réessayer chaque nuit. L'admin voit le motif
- // et peut le réactiver.
- ...(vide ? { actifSql: false, actifQlik: false, desactiveMotif: "Aucun article — désactivé automatiquement" } : {}),
- updatedAt: new Date(),
- }).where(eq(syncFournisseurs.codeFournisseur, code));
- if (vide) console.log(`[sync-nuit] ${code} sans article — désactivé automatiquement`);
- else etat.sqlFaits++;
- } catch (e) {
- const msg = e instanceof Error ? e.message : String(e);
- etat.sqlEchecs++;
- etat.derniereErreur = `${code} (SQL) : ${msg}`;
- console.error(`[sync-nuit] SQL ${code} en échec :`, msg);
- await db.update(syncFournisseurs).set({
- dernierSqlAt: new Date(),
- dernierSqlStatut: "echec",
- dernierSqlErreur: msg.slice(0, 500),
- dernierSqlMs: Date.now() - t0,
- updatedAt: new Date(),
- }).where(eq(syncFournisseurs.codeFournisseur, code)).catch(() => { /* le suivi ne doit pas casser la boucle */ });
- }
-}
-
-/** Format d'un code centrale plausible — même filtre que la synchro manuelle. */
-const CODE_CENTRALE = /^[A-Z0-9][A-Z0-9_-]{1,29}$/i;
-
-/** Extraction Qlik. Même politique que le SQL sur l'horodatage en cas d'échec. */
-async function traiterQlik(code: string, nom: string | null): Promise {
- const t0 = Date.now();
- etat.fournisseurCourant = `${code}${nom ? ` — ${nom}` : ""}`;
- etat.etape = "qlik";
- try {
- const articles = await pgGetArticlesByFournisseur(code);
- const codes = [...new Set(
- articles
- .map((a) => String(a.codeCentrale ?? "").trim())
- .filter((c) => c && c !== "-" && CODE_CENTRALE.test(c)),
- )];
-
- if (codes.length === 0) {
- await db.update(syncFournisseurs).set({
- dernierQlikAt: new Date(), dernierQlikStatut: "vide", dernierQlikCodes: 0,
- dernierQlikErreur: null, dernierQlikMs: Date.now() - t0, updatedAt: new Date(),
- }).where(eq(syncFournisseurs.codeFournisseur, code));
- return;
- }
-
- const dateFilter = buildGridNetworkQlikDateFilter(new Date(), envMonthsBack("QLIK_SYNC_MONTHS_BACK", QLIK_MONTHS_BACK_DEFAULT));
- const metrics = await fetchNetworkMetricsPlaywright(codes, undefined, dateFilter, code);
- const n = await upsertNetworkMetrics([...metrics.values()]);
-
- await db.update(syncFournisseurs).set({
- dernierQlikAt: new Date(), dernierQlikStatut: "succes", dernierQlikCodes: n,
- dernierQlikErreur: null, dernierQlikMs: Date.now() - t0, updatedAt: new Date(),
- }).where(eq(syncFournisseurs.codeFournisseur, code));
- etat.qlikFaits++;
- console.log(`[sync-nuit] Qlik ${code} — ${n} codes en ${Math.round((Date.now() - t0) / 1000)} s`);
- } catch (e) {
- const msg = e instanceof Error ? e.message : String(e);
- etat.qlikEchecs++;
- etat.derniereErreur = `${code} (Qlik) : ${msg}`;
- console.error(`[sync-nuit] Qlik ${code} en échec :`, msg);
- await db.update(syncFournisseurs).set({
- dernierQlikAt: new Date(), dernierQlikStatut: "echec",
- dernierQlikErreur: msg.slice(0, 500), dernierQlikMs: Date.now() - t0, updatedAt: new Date(),
- }).where(eq(syncFournisseurs.codeFournisseur, code)).catch(() => { /* idem */ });
- }
-}
-
-// ─── Boucle de travail ───────────────────────────────────────────────────────
-
-/**
- * Traite les files jusqu'à épuisement, sortie de fenêtre, ou demande d'arrêt.
- *
- * Les deux files avancent en parallèle : une extraction Qlik est intercalée
- * tous les `sqlParQlik` fournisseurs SQL. Sans cet entrelacement, Qlik ne
- * démarrerait jamais tant que la file SQL n'est pas vide.
- */
-export async function lancerRound(origine: "auto" | "manuel", forcerHorsFenetre = false): Promise {
- if (etat.enCours) return;
-
- const s = await readSyncSettings();
- const maintenant = new Date();
- const debut = debutFenetre(s, maintenant);
- if (!forcerHorsFenetre && !debut) return;
- // Un lancement manuel hors fenêtre borne la file sur « depuis ce matin ».
- const depuis = debut ?? new Date(new Date(maintenant).setHours(0, 0, 0, 0));
-
- Object.assign(etat, {
- enCours: true, origine, debutAt: maintenant.toISOString(), finAt: null,
- fournisseurCourant: null, etape: null,
- sqlFaits: 0, sqlEchecs: 0, qlikFaits: 0, qlikEchecs: 0,
- tourTermine: false, arretDemande: false, derniereErreur: null,
- });
- console.log(`[sync-nuit] round ${origine} démarré (fenêtre ${s.heureDebut}h-${s.heureFin}h, Qlik ≤ ${s.qlikParNuit})`);
-
- try {
- await seedSyncFournisseurs();
-
- // Garde anti-boucle. L'avancement de la file repose sur l'écriture de
- // `dernier*At`, et cette écriture est volontairement non bloquante en cas
- // d'erreur. Si elle échoue, le fournisseur resterait le plus ancien et
- // serait repris sans fin : on retient donc ce qui a déjà été tenté.
- const tentes = new Set();
-
- let depuisDernierQlik = 0;
- for (;;) {
- if (etat.arretDemande) break;
- if (!forcerHorsFenetre && !debutFenetre(s, new Date())) {
- console.log("[sync-nuit] fin de fenêtre — arrêt après le fournisseur en cours");
- break;
- }
-
- const qlikPossible = etat.qlikFaits + etat.qlikEchecs < s.qlikParNuit;
-
- // Qlik prioritaire quand le quota d'entrelacement est atteint.
- if (qlikPossible && depuisDernierQlik >= s.sqlParQlik) {
- const cible = await prochainQlik(s.qlikMinJours, new Date());
- if (cible && !tentes.has(`qlik:${cible.codeFournisseur}`)) {
- tentes.add(`qlik:${cible.codeFournisseur}`);
- await traiterQlik(cible.codeFournisseur, cible.nomFournisseur);
- depuisDernierQlik = 0;
- continue;
- }
- }
-
- const cibleSql = await prochainSql(depuis);
- if (cibleSql) {
- if (tentes.has(`sql:${cibleSql.codeFournisseur}`)) {
- console.error(
- `[sync-nuit] ${cibleSql.codeFournisseur} ressort de la file après avoir été traité :`
- + " le suivi n'a pas pu être écrit. Arrêt du round pour ne pas boucler.",
- );
- break;
- }
- tentes.add(`sql:${cibleSql.codeFournisseur}`);
- await traiterSql(cibleSql.codeFournisseur, cibleSql.nomFournisseur);
- depuisDernierQlik++;
- continue;
- }
-
- // File SQL vide : on consacre le temps restant à Qlik.
- if (qlikPossible) {
- const cible = await prochainQlik(s.qlikMinJours, new Date());
- if (cible && !tentes.has(`qlik:${cible.codeFournisseur}`)) {
- tentes.add(`qlik:${cible.codeFournisseur}`);
- await traiterQlik(cible.codeFournisseur, cible.nomFournisseur);
- depuisDernierQlik = 0;
- continue;
- }
- }
-
- etat.tourTermine = true;
- console.log("[sync-nuit] plus rien en attente — tour terminé");
- break;
- }
- } catch (e) {
- etat.derniereErreur = e instanceof Error ? e.message : String(e);
- console.error("[sync-nuit] round interrompu :", etat.derniereErreur);
- } finally {
- // Les pages (stock, hit-parade, CA…) relisent la base fraîche au lieu
- // d'attendre la fin de vie de leur cache.
- invalidateFFCache();
- etat.enCours = false;
- etat.fournisseurCourant = null;
- etat.etape = null;
- etat.finAt = new Date().toISOString();
- console.log(
- `[sync-nuit] round terminé — SQL ${etat.sqlFaits} ok / ${etat.sqlEchecs} en échec,`
- + ` Qlik ${etat.qlikFaits} ok / ${etat.qlikEchecs} en échec, tour bouclé=${etat.tourTermine}`,
- );
- }
-}
-
-/**
- * Battement du minuteur : ne fait quelque chose que dans la fenêtre, et jamais
- * deux rounds à la fois. Volontairement silencieux hors fenêtre — il est appelé
- * chaque minute.
- */
-export async function tickScheduler(): Promise {
- try {
- const s = await readSyncSettings();
- if (!s.actif || etat.enCours) return;
- if (!debutFenetre(s)) return;
- await lancerRound("auto");
- } catch (e) {
- console.error("[sync-nuit] tick en erreur :", e instanceof Error ? e.message : String(e));
- }
-}
diff --git a/src/features/admin/api/sync-settings.ts b/src/features/admin/api/sync-settings.ts
deleted file mode 100644
index 541dbac..0000000
--- a/src/features/admin/api/sync-settings.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * CollectFlow — Réglages de la synchronisation nocturne.
- *
- * Rangés dans `data/.db-config.json`, comme les autres réglages de
- * l'application (base, Qlik, API FF), pour qu'il n'y ait qu'un seul endroit à
- * sauvegarder et à monter dans le conteneur.
- *
- * Module **serveur**, pas fichier d'actions : il exporte aussi des valeurs
- * (les défauts, le type), ce que `"use server"` interdit.
- */
-
-import "server-only";
-
-import fs from "fs/promises";
-import path from "path";
-
-const DATA_DIR = path.join(process.cwd(), "data");
-const CONFIG_FILE = path.join(DATA_DIR, ".db-config.json");
-
-export interface SyncSettings {
- /**
- * Désactivé par défaut : un déploiement ne doit pas se mettre à solliciter
- * Qlik et la base la nuit suivante sans que personne l'ait décidé.
- */
- actif: boolean;
- /** Heure d'ouverture de la fenêtre (0-23). */
- heureDebut: number;
- /** Heure de fermeture. Aucun fournisseur n'est **démarré** après. */
- heureFin: number;
- /**
- * Nombre maximum d'extractions Qlik par nuit. Chacune peut prendre 8 minutes
- * et le serveur abandonne quand il est trop sollicité : ce plafond est la
- * principale protection contre une nuit entièrement passée sur Qlik.
- */
- qlikParNuit: number;
- /** Une extraction Qlik est intercalée tous les N fournisseurs SQL. */
- sqlParQlik: number;
- /**
- * Âge minimal des données Qlik avant de les refaire. Ce sont des agrégats
- * mensuels : les rafraîchir toutes les nuits coûterait cher pour rien.
- */
- qlikMinJours: number;
-}
-
-export const SYNC_SETTINGS_DEFAUT: SyncSettings = {
- actif: false,
- heureDebut: 0,
- heureFin: 5,
- qlikParNuit: 6,
- sqlParQlik: 20,
- qlikMinJours: 7,
-};
-
-function borne(v: unknown, min: number, max: number, defaut: number): number {
- const n = Number(v);
- if (!Number.isFinite(n)) return defaut;
- return Math.min(max, Math.max(min, Math.trunc(n)));
-}
-
-/** Normalise ce qui vient du fichier : il est éditable à la main. */
-function normaliser(brut: Partial | undefined): SyncSettings {
- const d = SYNC_SETTINGS_DEFAUT;
- const s: SyncSettings = {
- actif: Boolean(brut?.actif),
- heureDebut: borne(brut?.heureDebut, 0, 23, d.heureDebut),
- heureFin: borne(brut?.heureFin, 0, 23, d.heureFin),
- qlikParNuit: borne(brut?.qlikParNuit, 0, 200, d.qlikParNuit),
- sqlParQlik: borne(brut?.sqlParQlik, 1, 500, d.sqlParQlik),
- qlikMinJours: borne(brut?.qlikMinJours, 0, 365, d.qlikMinJours),
- };
- // Une fenêtre de durée nulle ne s'ouvrirait jamais : on revient au défaut
- // plutôt que de laisser le planificateur muet sans explication.
- if (s.heureDebut === s.heureFin) {
- s.heureDebut = d.heureDebut;
- s.heureFin = d.heureFin;
- }
- return s;
-}
-
-export async function readSyncSettings(): Promise {
- try {
- const raw = await fs.readFile(CONFIG_FILE, "utf-8");
- const cfg = JSON.parse(raw) as { syncNuit?: Partial };
- return normaliser(cfg?.syncNuit);
- } catch {
- return { ...SYNC_SETTINGS_DEFAUT };
- }
-}
-
-export async function saveSyncSettings(patch: Partial): Promise {
- let existant: Record = {};
- try {
- existant = JSON.parse(await fs.readFile(CONFIG_FILE, "utf-8"));
- } catch {
- // Pas encore de fichier : on le crée avec les seuls réglages de synchro.
- }
- const courant = normaliser((existant.syncNuit as Partial) ?? undefined);
- const suivant = normaliser({ ...courant, ...patch });
-
- await fs.mkdir(DATA_DIR, { recursive: true });
- await fs.writeFile(CONFIG_FILE, JSON.stringify({ ...existant, syncNuit: suivant }, null, 2));
- console.log(`[sync-nuit] réglages enregistrés : ${JSON.stringify(suivant)}`);
- return suivant;
-}
diff --git a/src/features/admin/api/sync-timer.ts b/src/features/admin/api/sync-timer.ts
deleted file mode 100644
index ae1acd6..0000000
--- a/src/features/admin/api/sync-timer.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * CollectFlow — Minuteur de la synchronisation nocturne.
- *
- * Démarré une fois au boot par `src/instrumentation.ts`. Il bat chaque minute
- * et laisse `tickScheduler()` décider s'il y a quelque chose à faire : hors
- * fenêtre, ou si un round tourne déjà, le battement ne coûte rien.
- *
- * Conséquence assumée du choix « minuteur interne » plutôt que cron système :
- * rien ne tourne si l'application est arrêtée. En contrepartie, aucune
- * configuration côté hôte, et le minuteur se réarme tout seul au redémarrage.
- */
-
-import "server-only";
-
-import { tickScheduler } from "@/features/admin/api/sync-scheduler";
-
-const INTERVALLE_MS = 60_000;
-
-/**
- * Garde au niveau du module : en développement, le rechargement à chaud peut
- * réévaluer `register()` plusieurs fois, et on se retrouverait avec autant de
- * minuteurs empilés.
- */
-let minuteur: ReturnType | null = null;
-
-export function startSyncTimer(): void {
- if (minuteur) return;
-
- console.log(`[sync-nuit] minuteur démarré (battement ${INTERVALLE_MS / 1000} s)`);
- minuteur = setInterval(() => {
- // `tickScheduler` capture déjà ses propres erreurs ; ce `catch` ne couvre
- // qu'un rejet inattendu, pour qu'il ne devienne jamais une exception non
- // gérée capable d'abattre le processus.
- void tickScheduler().catch((e) => {
- console.error("[sync-nuit] battement en erreur :", e instanceof Error ? e.message : String(e));
- });
- }, INTERVALLE_MS);
-
- // Ne pas maintenir le processus en vie uniquement pour ce minuteur.
- minuteur.unref?.();
-}
diff --git a/src/features/admin/api/user-actions.ts b/src/features/admin/api/user-actions.ts
index f7a4e89..389957b 100644
--- a/src/features/admin/api/user-actions.ts
+++ b/src/features/admin/api/user-actions.ts
@@ -1,74 +1,46 @@
-"use server";
+/**
+ * Gestion des comptes (administrateurs) — actions exécutées par le serveur
+ * Rust : `POST /api/actions/{nom}`.
+ */
-import { db } from "@/db";
-import { users } from "@/db/schema";
-import { eq } from "drizzle-orm";
-import { hashPassword } from "@/features/auth/logic/auth-logic";
-import { requireAdmin } from "@/lib/authz";
-import { revalidatePath } from "next/cache";
+import { callAction } from "@/lib/rpc";
+
+export interface UtilisateurListe {
+ id: number;
+ username: string;
+ role: string;
+ /** Date ISO de création. */
+ createdAt: string | null;
+}
/**
* Récupère tous les utilisateurs (Admin seulement).
*/
-export async function getUsers() {
- await requireAdmin();
- return db.select({
- id: users.id,
- username: users.username,
- role: users.role,
- createdAt: users.createdAt
- }).from(users);
+export async function getUsers(): Promise {
+ return callAction("getUsers", []);
}
/**
* Crée un nouvel utilisateur.
*/
-export async function createUser(username: string, password: string, role: "admin" | "user" = "user") {
- await requireAdmin();
-
- try {
- await db.insert(users).values({
- username,
- passwordHash: hashPassword(password),
- role,
- });
- revalidatePath("/settings");
- return { success: true };
- } catch (err) {
- console.error("CreateUser Error:", err);
- return { success: false, error: "L'utilisateur existe déjà ou une erreur technique est survenue." };
- }
+export async function createUser(
+ username: string,
+ password: string,
+ role: "admin" | "user" = "user",
+): Promise<{ success: boolean; error?: string }> {
+ return callAction("createUser", [username, password, role]);
}
/**
* Supprime un utilisateur.
*/
-export async function deleteUser(id: number) {
- const moi = await requireAdmin();
- if (Number(moi.id) === id) {
- return { success: false, error: "Vous ne pouvez pas supprimer votre propre compte." };
- }
-
- try {
- await db.delete(users).where(eq(users.id, id));
- revalidatePath("/settings");
- return { success: true };
- } catch {
- return { success: false, error: "Erreur lors de la suppression." };
- }
+export async function deleteUser(id: number): Promise<{ success: boolean; error?: string }> {
+ return callAction("deleteUser", [id]);
}
/**
* Met à jour le mot de passe d'un utilisateur.
*/
-export async function updatePassword(id: number, newPassword: string) {
- await requireAdmin();
- try {
- await db.update(users)
- .set({ passwordHash: hashPassword(newPassword) })
- .where(eq(users.id, id));
- return { success: true };
- } catch {
- return { success: false, error: "Erreur lors de la mise à jour du mot de passe." };
- }
+export async function updatePassword(id: number, newPassword: string): Promise<{ success: boolean; error?: string }> {
+ return callAction("updatePassword", [id, newPassword]);
}
diff --git a/src/features/admin/components/api-connection-info.tsx b/src/features/admin/components/api-connection-info.tsx
index 7aee6bd..643637b 100644
--- a/src/features/admin/components/api-connection-info.tsx
+++ b/src/features/admin/components/api-connection-info.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Informations de connexion à l'API `/api/v1`.
*
diff --git a/src/features/admin/components/api-key-management.tsx b/src/features/admin/components/api-key-management.tsx
index dcc6335..8dfd917 100644
--- a/src/features/admin/components/api-key-management.tsx
+++ b/src/features/admin/components/api-key-management.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Gestion des clés de l'API `/api/v1`.
*
diff --git a/src/features/admin/components/grid-warmup.tsx b/src/features/admin/components/grid-warmup.tsx
index 614ac3e..73b1fe4 100644
--- a/src/features/admin/components/grid-warmup.tsx
+++ b/src/features/admin/components/grid-warmup.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Préchauffage des données exposées par l'API.
*
diff --git a/src/features/admin/components/user-management.tsx b/src/features/admin/components/user-management.tsx
index 13b9d48..75429e0 100644
--- a/src/features/admin/components/user-management.tsx
+++ b/src/features/admin/components/user-management.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useCallback, useEffect, useState, type FormEvent } from "react";
import { KeyRound, Loader2, Shield, Trash2, User, UserPlus } from "lucide-react";
import { getUsers, createUser, deleteUser, updatePassword } from "../api/user-actions";
diff --git a/src/features/auth/api/login-action.ts b/src/features/auth/api/login-action.ts
deleted file mode 100644
index 9b514f9..0000000
--- a/src/features/auth/api/login-action.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-"use server";
-
-import { signIn } from "@/lib/auth";
-import { AuthError } from "next-auth";
-
-/**
- * Server action to handle user login.
- */
-export async function loginAction(prevState: string | undefined, formData: FormData) {
- try {
- await signIn("credentials", {
- username: formData.get("username"),
- password: formData.get("password"),
- redirectTo: "/dashboard"
- });
- } catch (error) {
- if (error instanceof AuthError) {
- switch (error.type) {
- case "CredentialsSignin":
- return "Utilisateur ou mot de passe incorrect.";
- default:
- return "Une erreur technique est survenue.";
- }
- }
- // Next.js redirect throws a special error that must be rethrown
- throw error;
- }
-}
diff --git a/src/features/auth/components/login-form.tsx b/src/features/auth/components/login-form.tsx
index bd220d5..8aaab14 100644
--- a/src/features/auth/components/login-form.tsx
+++ b/src/features/auth/components/login-form.tsx
@@ -1,11 +1,42 @@
-"use client";
-
import { useActionState } from "react";
-import { loginAction } from "../api/login-action";
import { AlertCircle, Loader2, Lock, ShieldCheck, User } from "lucide-react";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/form-controls";
+const MESSAGE_IDENTIFIANTS = "Utilisateur ou mot de passe incorrect.";
+const MESSAGE_TECHNIQUE = "Une erreur technique est survenue.";
+
+/**
+ * Connexion : `POST /api/auth/login` (le serveur pose le cookie de session),
+ * puis chargement complet du tableau de bord pour repartir avec la session.
+ * Renvoie le message d'erreur à afficher, ou ne rend jamais la main en cas de
+ * réussite (le bouton reste « Connexion… » jusqu'au changement de page).
+ */
+async function loginAction(_prevState: string | undefined, formData: FormData): Promise {
+ let res: Response;
+ try {
+ res = await fetch("/api/auth/login", {
+ method: "POST",
+ headers: { "Content-Type": "application/json", Accept: "application/json" },
+ credentials: "same-origin",
+ body: JSON.stringify({
+ username: String(formData.get("username") ?? ""),
+ password: String(formData.get("password") ?? ""),
+ }),
+ });
+ } catch {
+ return MESSAGE_TECHNIQUE;
+ }
+ if (!res.ok) {
+ const body = (await res.json().catch(() => null)) as { error?: unknown } | null;
+ if (typeof body?.error === "string" && body.error) return body.error;
+ return res.status === 401 ? MESSAGE_IDENTIFIANTS : MESSAGE_TECHNIQUE;
+ }
+ await res.text().catch(() => "");
+ window.location.assign("/dashboard");
+ return new Promise(() => {});
+}
+
export function LoginForm() {
const [error, action, isPending] = useActionState(loginAction, undefined);
diff --git a/src/features/auth/logic/auth-logic.ts b/src/features/auth/logic/auth-logic.ts
deleted file mode 100644
index 100b79c..0000000
--- a/src/features/auth/logic/auth-logic.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { scryptSync, randomBytes, timingSafeEqual } from "crypto";
-import fs from "fs";
-import path from "path";
-
-const USERS_JSON_PATH = path.join(process.cwd(), "data", "users.json");
-
-export interface UserJson {
- id: string;
- username: string;
- passwordHash: string;
- role: string;
-}
-
-/**
- * Hashes a password using scrypt.
- * Format: salt:hash
- */
-export function hashPassword(password: string): string {
- const salt = randomBytes(16).toString("hex");
- const hash = scryptSync(password, salt, 64).toString("hex");
- return `${salt}:${hash}`;
-}
-
-/**
- * Verifies a password against a stored salt:hash string.
- */
-export function verifyPassword(password: string, storedHash: string): boolean {
- try {
- const [salt, hash] = storedHash.split(":");
- if (!salt || !hash) return false;
-
- const hashBuffer = scryptSync(password, salt, 64);
- const storedHashBuffer = Buffer.from(hash, "hex");
-
- return timingSafeEqual(hashBuffer, storedHashBuffer);
- } catch (e) {
- return false;
- }
-}
-
-/**
- * Reads users from local JSON fallback.
- */
-export function getFallbackUsers(): UserJson[] {
- try {
- if (!fs.existsSync(USERS_JSON_PATH)) {
- // Initial seed if file doesn't exist
- const defaultAdmin: UserJson = {
- id: "0",
- username: "admin",
- passwordHash: hashPassword("admin"),
- role: "admin"
- };
- saveFallbackUsers([defaultAdmin]);
- return [defaultAdmin];
- }
- const data = fs.readFileSync(USERS_JSON_PATH, "utf-8");
- return JSON.parse(data);
- } catch (e) {
- console.error("[AUTH] Error reading users.json:", e);
- return [];
- }
-}
-
-/**
- * Saves users to local JSON fallback.
- */
-export function saveFallbackUsers(users: UserJson[]) {
- try {
- const dir = path.dirname(USERS_JSON_PATH);
- if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
- fs.writeFileSync(USERS_JSON_PATH, JSON.stringify(users, null, 2));
- } catch (e) {
- console.error("[AUTH] Error writing users.json:", e);
- }
-}
diff --git a/src/features/auth/logic/seed-admin.ts b/src/features/auth/logic/seed-admin.ts
deleted file mode 100644
index 09ae497..0000000
--- a/src/features/auth/logic/seed-admin.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { db } from "@/db";
-import { users } from "@/db/schema";
-import { hashPassword, getFallbackUsers, saveFallbackUsers } from "./auth-logic";
-import { sql } from "drizzle-orm";
-
-/** Amorçage en cours ou réussi pour ce processus (remis à null en cas d'échec). */
-let amorcage: Promise | null = null;
-
-/**
- * Prépare les comptes au premier démarrage, une seule fois par processus.
- *
- * - Base joignable : crée la table `users` si besoin (auto-réparation), puis le
- * compte admin/admin **uniquement si la table est vide**. Un admin supprimé ou
- * renommé n'est donc pas recréé à chaque connexion. Le fichier de secours
- * `data/users.json` n'est pas touché.
- * - Base injoignable (première installation, base pas encore configurée) : on
- * s'assure que le fichier de secours contient un administrateur, et on
- * retentera la base à la prochaine connexion.
- *
- * Renvoie true si le compte admin/admin vient d'être créé en base.
- */
-export function ensureAdminExists(): Promise {
- if (!amorcage) {
- amorcage = amorcer().catch((err: unknown) => {
- // Échec : on retentera à la prochaine connexion.
- amorcage = null;
- console.warn("[AUTH] Database seeding failed (expected if DB not configured yet):", (err as Error)?.message ?? err);
- return false;
- });
- }
- return amorcage;
-}
-
-async function amorcer(): Promise {
- console.log("[AUTH] Testing database connection for seeding...");
- try {
- await db.execute(sql`SELECT 1`);
- } catch (err) {
- assurerAdminDeSecours();
- throw err;
- }
-
- // Auto-repair: Ensure table exists
- await db.execute(sql`
- CREATE TABLE IF NOT EXISTS "users" (
- id SERIAL PRIMARY KEY,
- username VARCHAR(50) NOT NULL UNIQUE,
- password_hash TEXT NOT NULL,
- role VARCHAR(20) NOT NULL DEFAULT 'user',
- created_at TIMESTAMP DEFAULT NOW()
- );
- `);
-
- const [{ nb }] = await db.select({ nb: sql`count(*)::int` }).from(users);
- if (nb > 0) return false;
-
- console.log("[AUTH] Table users vide : création du compte admin/admin.");
- // Si un autre processus l'a créé entre-temps, l'unicité du nom fait échouer
- // l'insertion : on la laisse sans effet plutôt que de relancer l'amorçage.
- const crees = await db.insert(users).values({
- username: "admin",
- passwordHash: hashPassword("admin"),
- role: "admin",
- }).onConflictDoNothing().returning({ id: users.id });
- return crees.length > 0;
-}
-
-/** Base injoignable : le fichier de secours doit contenir au moins un administrateur. */
-function assurerAdminDeSecours() {
- const fallbackUsers = getFallbackUsers();
- if (fallbackUsers.length === 0) {
- console.log("[AUTH] Initializing local JSON fallback with admin/admin...");
- saveFallbackUsers([{
- id: "0",
- username: "admin",
- passwordHash: hashPassword("admin"),
- role: "admin"
- }]);
- }
-}
diff --git a/src/features/commandes-auto/actions.ts b/src/features/commandes-auto/actions.ts
index c4623b2..f9916fe 100644
--- a/src/features/commandes-auto/actions.ts
+++ b/src/features/commandes-auto/actions.ts
@@ -1,11 +1,10 @@
-"use server";
+/**
+ * Cadencier des commandes fournisseurs — actions exécutées par le serveur
+ * Rust : `POST /api/actions/{nom}`.
+ */
-import { revalidatePath } from "next/cache";
-import { and, eq } from "drizzle-orm";
-import { db } from "@/db";
-import { commandeCadences } from "@/db/schema";
-import { getDerniereReceptionCached, getFournisseursCached } from "@/lib/ff-cache";
-import { requireSession, verifierSession } from "@/lib/authz";
+import { callAction } from "@/lib/rpc";
+import { refreshPage } from "@/lib/page-data";
export type CadenceStatut = "a_commander" | "bientot" | "ok" | "inconnu";
@@ -25,21 +24,18 @@ export interface CadenceView {
statut: CadenceStatut;
}
-const MS_PAR_JOUR = 24 * 60 * 60 * 1000;
-/** Seuil (en jours) en dessous duquel une cadence passe en "bientôt à commander" */
-const SEUIL_BIENTOT_JOURS = 7;
-
-function calcStatut(joursRestants: number | null): CadenceStatut {
- if (joursRestants === null) return "inconnu";
- if (joursRestants <= 0) return "a_commander";
- if (joursRestants <= SEUIL_BIENTOT_JOURS) return "bientot";
- return "ok";
+/**
+ * Les actions Next.js de modification appelaient `revalidatePath("/commandes-auto")`,
+ * dont la réponse rafraîchissait la page : même effet ici après une réussite.
+ */
+function rafraichirSiOk(resultat: R): R {
+ if (resultat.ok) refreshPage();
+ return resultat;
}
/** Liste des fournisseurs (référentiel) pour le sélecteur de cadence. */
export async function getFournisseursPourCadence(): Promise<{ code: string; nom: string }[]> {
- await requireSession();
- return getFournisseursCached();
+ return callAction("getFournisseursPourCadence", []);
}
/**
@@ -47,45 +43,7 @@ export async function getFournisseursPourCadence(): Promise<{ code: string; nom:
* de la dernière réception (FF Nancy).
*/
export async function listCadences(): Promise {
- await requireSession();
- let rows: typeof commandeCadences.$inferSelect[] = [];
- let receptions = new Map();
- try {
- rows = await db.select().from(commandeCadences);
- // Réceptions des seuls fournisseurs du cadencier : la lecture sur tout
- // l'historique de tous les fournisseurs était la plus lourde de la page.
- receptions = await getDerniereReceptionCached(rows.map((r) => r.codeFournisseur));
- } catch (e) {
- console.error("[cadence] listCadences error:", (e as Error).message);
- return [];
- }
-
- const now = Date.now();
-
- return rows.map((r) => {
- const receptionIso = receptions.get(`${r.codeFournisseur}|${r.site}`) ?? null;
-
- let echeanceIso: string | null = null;
- let joursRestants: number | null = null;
- if (receptionIso) {
- const echeance = new Date(receptionIso).getTime() + r.intervalleSemaines * 7 * MS_PAR_JOUR;
- echeanceIso = new Date(echeance).toISOString();
- joursRestants = Math.ceil((echeance - now) / MS_PAR_JOUR);
- }
-
- return {
- id: r.id,
- codefou: r.codeFournisseur,
- nomfou: r.nomFournisseur ?? r.codeFournisseur,
- site: r.site,
- intervalleSemaines: r.intervalleSemaines,
- actif: r.actif,
- derniereReception: receptionIso,
- echeance: echeanceIso,
- joursRestants,
- statut: r.actif ? calcStatut(joursRestants) : "inconnu",
- } satisfies CadenceView;
- });
+ return callAction("listCadences", []);
}
export interface UpsertCadenceInput {
@@ -98,76 +56,15 @@ export interface UpsertCadenceInput {
/** Crée ou met à jour la cadence d'un fournisseur sur un site. */
export async function upsertCadence(input: UpsertCadenceInput): Promise<{ ok: boolean; error?: string }> {
- const acces = await verifierSession();
- if (!acces.ok) return { ok: false, error: acces.message };
-
- const codefou = input.codefou?.trim();
- const site = input.site?.trim();
- const intervalle = Math.round(Number(input.intervalleSemaines));
-
- if (!codefou || !site) return { ok: false, error: "Fournisseur et magasin requis." };
- if (!Number.isFinite(intervalle) || intervalle < 1 || intervalle > 104) {
- return { ok: false, error: "L'intervalle doit être compris entre 1 et 104 semaines." };
- }
-
- try {
- await db
- .insert(commandeCadences)
- .values({
- codeFournisseur: codefou,
- nomFournisseur: input.nomfou ?? null,
- site,
- intervalleSemaines: intervalle,
- actif: input.actif ?? true,
- })
- .onConflictDoUpdate({
- target: [commandeCadences.codeFournisseur, commandeCadences.site],
- set: {
- nomFournisseur: input.nomfou ?? null,
- intervalleSemaines: intervalle,
- actif: input.actif ?? true,
- updatedAt: new Date(),
- },
- });
- revalidatePath("/commandes-auto");
- return { ok: true };
- } catch (e) {
- console.error("[cadence] upsertCadence error:", (e as Error).message);
- return { ok: false, error: "Échec de l'enregistrement." };
- }
+ return rafraichirSiOk(await callAction<{ ok: boolean; error?: string }>("upsertCadence", [input]));
}
/** Active / désactive une cadence sans la supprimer. */
export async function toggleCadence(codefou: string, site: string, actif: boolean): Promise<{ ok: boolean; error?: string }> {
- const acces = await verifierSession();
- if (!acces.ok) return { ok: false, error: acces.message };
-
- try {
- await db
- .update(commandeCadences)
- .set({ actif, updatedAt: new Date() })
- .where(and(eq(commandeCadences.codeFournisseur, codefou), eq(commandeCadences.site, site)));
- revalidatePath("/commandes-auto");
- return { ok: true };
- } catch (e) {
- console.error("[cadence] toggleCadence error:", (e as Error).message);
- return { ok: false };
- }
+ return rafraichirSiOk(await callAction<{ ok: boolean; error?: string }>("toggleCadence", [codefou, site, actif]));
}
/** Supprime définitivement une cadence. */
export async function removeCadence(codefou: string, site: string): Promise<{ ok: boolean; error?: string }> {
- const acces = await verifierSession();
- if (!acces.ok) return { ok: false, error: acces.message };
-
- try {
- await db
- .delete(commandeCadences)
- .where(and(eq(commandeCadences.codeFournisseur, codefou), eq(commandeCadences.site, site)));
- revalidatePath("/commandes-auto");
- return { ok: true };
- } catch (e) {
- console.error("[cadence] removeCadence error:", (e as Error).message);
- return { ok: false };
- }
+ return rafraichirSiOk(await callAction<{ ok: boolean; error?: string }>("removeCadence", [codefou, site]));
}
diff --git a/src/features/grid/actions.ts b/src/features/grid/actions.ts
index 80b1fc4..07e4445 100644
--- a/src/features/grid/actions.ts
+++ b/src/features/grid/actions.ts
@@ -1,23 +1,20 @@
-"use server";
+/**
+ * Actions de la Grille (ex-« server actions » Next.js), exécutées par le
+ * serveur Rust : `POST /api/actions/{nom}`.
+ */
-import { getSitesFromApi } from "@/lib/api-ff-client";
-import { getFournisseursCached } from "@/lib/ff-cache";
-import { requireSession } from "@/lib/authz";
+import { callAction } from "@/lib/rpc";
/**
* Get the list of all suppliers from PostgreSQL (fouadr1).
*/
-export async function getFournisseurs() {
- await requireSession();
- // Relu à chaque navigation dans la Grille (changement de fournisseur, de
- // magasin…) : le référentiel ne change qu'avec la recopie nocturne.
- return getFournisseursCached();
+export async function getFournisseurs(): Promise<{ code: string; nom: string }[]> {
+ return callAction("getFournisseurs", []);
}
/**
* Get the list of all stores (sites) from the FF Nancy API.
*/
-export async function getMagasins() {
- await requireSession();
- return getSitesFromApi();
+export async function getMagasins(): Promise<{ code: string; nom: string }[]> {
+ return callAction("getMagasins", []);
}
diff --git a/src/features/grid/api/enregistrer-gammes.ts b/src/features/grid/api/enregistrer-gammes.ts
deleted file mode 100644
index 8c09861..0000000
--- a/src/features/grid/api/enregistrer-gammes.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import "server-only";
-
-import { db } from "@/db";
-import { sessionSnapshots } from "@/db/schema";
-import { eq, desc } from "drizzle-orm";
-import { patchGridRowsCache } from "./get-product-rows";
-import { updateGridRowsGamme } from "@/lib/grid-store";
-
-export interface ChangementGamme {
- codein: string;
- /** Gamme avant la modification (état serveur), conservée pour l'historique. */
- codeGammeBefore: string | null;
- codeGamme: string;
-}
-
-export interface EnregistrementGammes {
- codeFournisseur: string;
- nomFournisseur?: string | null;
- magasin: string;
- changes: ChangementGamme[];
- userId: number | null;
- /** Libellé du snapshot, « Draft — date » par défaut. */
- label?: string;
-}
-
-/**
- * Enregistre des gammes pour un fournisseur — chemin unique de la Grille et de /api/v1.
- *
- * Les changements sont fusionnés par-dessus le dernier snapshot du fournisseur,
- * puis reportés dans le cache mémoire de la Grille et dans l'instantané `grid_rows`.
- * Lève une erreur si l'écriture du snapshot échoue.
- */
-export async function enregistrerGammes(input: EnregistrementGammes): Promise {
- const { codeFournisseur, nomFournisseur, magasin, changes, userId } = input;
- if (changes.length === 0) return 0;
-
- // Charger le dernier snapshot existant pour merger les changements
- const existing = await db
- .select()
- .from(sessionSnapshots)
- .where(eq(sessionSnapshots.codeFournisseur, codeFournisseur))
- .orderBy(desc(sessionSnapshots.createdAt))
- .limit(1);
-
- const prevChanges: Record =
- existing.length > 0
- ? (existing[0].changes as Record)
- : {};
-
- // Merger les nouveaux changements par-dessus l'existant
- const mergedChanges = { ...prevChanges };
- for (const c of changes) {
- mergedChanges[c.codein] = {
- before: c.codeGammeBefore,
- after: c.codeGamme,
- };
- }
-
- // Upsert : insérer un nouveau snapshot "draft" pour ce fournisseur
- await db.insert(sessionSnapshots).values({
- userId,
- codeFournisseur,
- nomFournisseur: nomFournisseur ?? null,
- magasin,
- label: input.label ?? `Draft — ${new Date().toLocaleDateString("fr-FR")}`,
- changes: mergedChanges,
- summaryJson: null,
- type: "snapshot",
- });
-
- // Les lignes en cache reçoivent les nouvelles gammes au lieu d'être jetées :
- // l'invalidation imposait un recalcul complet (jusqu'à ~40 s) à la
- // réouverture suivante. L'instantané lu par /api/v1 suit, sans bloquer.
- patchGridRowsCache(codeFournisseur, changes);
- void updateGridRowsGamme(codeFournisseur, changes).catch((e) =>
- console.error("[enregistrerGammes] mise à jour grid_rows KO:", (e as Error).message?.slice(0, 200)),
- );
-
- return changes.length;
-}
diff --git a/src/features/grid/api/gammes-a-valider-actions.ts b/src/features/grid/api/gammes-a-valider-actions.ts
index 0a7a8f9..227923d 100644
--- a/src/features/grid/api/gammes-a-valider-actions.ts
+++ b/src/features/grid/api/gammes-a-valider-actions.ts
@@ -1,37 +1,21 @@
-"use server";
+/**
+ * Gammes proposées par l'API `/api/v1`, en attente de validation dans la
+ * Grille — actions exécutées par le serveur Rust : `POST /api/actions/{nom}`.
+ */
-import { z } from "zod";
-import { verifierSession } from "@/lib/authz";
-import { listerGammesAValider, supprimerGammesAValider, type GammeAValider } from "@/lib/gammes-a-valider";
+import { callAction } from "@/lib/rpc";
+import type { GammeAValider } from "@/types/ff";
+
+export type { GammeAValider };
/** Gammes proposées par l'API pour un fournisseur, en attente de validation. */
export async function getGammesAValider(
codeFournisseur: string,
): Promise<{ success: boolean; propositions: GammeAValider[]; error?: string }> {
- const acces = await verifierSession();
- if (!acces.ok) return { success: false, propositions: [], error: acces.message };
- try {
- return { success: true, propositions: await listerGammesAValider(String(codeFournisseur)) };
- } catch (err) {
- return { success: false, propositions: [], error: err instanceof Error ? err.message : "Unknown error" };
- }
+ return callAction("getGammesAValider", [codeFournisseur]);
}
-const RejetSchema = z.object({
- codeFournisseur: z.string().min(1),
- codeins: z.array(z.string()),
-});
-
/** Rejette des propositions de l'API (« Annuler les modifications » dans la Grille). */
export async function rejeterGammesAValider(raw: unknown): Promise<{ success: boolean; error?: string }> {
- const acces = await verifierSession();
- if (!acces.ok) return { success: false, error: acces.message };
- const parsed = RejetSchema.safeParse(raw);
- if (!parsed.success) return { success: false, error: "Validation failed: " + parsed.error.message };
- try {
- await supprimerGammesAValider(parsed.data.codeFournisseur, parsed.data.codeins);
- return { success: true };
- } catch (err) {
- return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
- }
+ return callAction("rejeterGammesAValider", [raw]);
}
diff --git a/src/features/grid/api/get-product-rows.ts b/src/features/grid/api/get-product-rows.ts
deleted file mode 100644
index c9f4a6f..0000000
--- a/src/features/grid/api/get-product-rows.ts
+++ /dev/null
@@ -1,779 +0,0 @@
-import "server-only";
-
-import type { ProductRow, GammeCode, GridFilters } from "@/types/grid";
-import { buildLast12MonthsRange, getMensuelByArticles } from "@/lib/api-ff-client";
-import {
- pgGetArticlesByFournisseur,
- pgGetMensuelByFournisseur,
- pgGetGammesByFournisseur,
- pgGetNomenclatureByFournisseur,
- pgGetStockByFournisseur,
- pgGetCommandesByFournisseur,
- pgGetPrixVenteByFournisseur,
- type PgStockRow,
-} from "@/lib/pg-ff-client";
-import { db } from "@/db";
-import { sessionSnapshots } from "@/db/schema";
-import { eq, desc } from "drizzle-orm";
-import { getNetworkMetricsByCodeCentrale, type NetworkMetricCached } from "@/lib/qlik-network-cache";
-import { NB_MAGASINS_RESEAU } from "@/features/grid/lib/network-trend";
-// Persiste l'instantané lu par /api/v1 : sans lui, l'API n'aurait aucune donnée.
-import { readGridSnapshot, upsertGridRows } from "@/lib/grid-store";
-import {
- applyStorePatchInPlace,
- buildStorePatchEntries,
- storePatchCandidates,
- type StorePatch,
- type StorePatchEntry,
-} from "@/features/grid/lib/store-patch";
-
-interface GetProductRowsInput {
- codeFournisseur: string;
- magasin?: string;
- filters?: Partial;
- forceRefresh?: boolean;
-}
-
-const GRID_ROWS_CACHE_TTL_MS = 10 * 60 * 1000;
-/**
- * Bornes du cache mémoire. La synchro nocturne et le préchauffage passent par
- * `getProductRows()` pour CHAQUE fournisseur : sans plafond, le processus finissait
- * par garder toutes les grilles en mémoire (plusieurs centaines de Mo), ce qui
- * ralentissait toutes les requêtes (ramasse-miettes). Ordre d'insertion de la Map
- * = ordre d'usage : on évince les entrées les moins récemment servies.
- */
-const GRID_ROWS_CACHE_MAX_ENTRIES = Number(process.env.GRID_ROWS_CACHE_MAX_ENTRIES ?? 30);
-const GRID_ROWS_CACHE_MAX_ROWS = Number(process.env.GRID_ROWS_CACHE_MAX_ROWS ?? 150_000);
-const gridRowsCache = new Map();
-const gridRowsPending = new Map>();
-/** Nombre d'enregistrements de gammes par fournisseur (cf. patchGridRowsCache). */
-const gammeSaveVersion = new Map();
-
-function cacheGridRows(key: string, rows: ProductRow[]): void {
- gridRowsCache.delete(key);
- gridRowsCache.set(key, { rows, createdAt: Date.now() });
- let totalRows = 0;
- for (const entry of gridRowsCache.values()) totalRows += entry.rows.length;
- for (const [oldKey, entry] of gridRowsCache) {
- if (gridRowsCache.size <= 1) break;
- if (gridRowsCache.size <= GRID_ROWS_CACHE_MAX_ENTRIES && totalRows <= GRID_ROWS_CACHE_MAX_ROWS) break;
- gridRowsCache.delete(oldKey);
- totalRows -= entry.rows.length;
- }
-}
-
-function gridRowsCacheKey(input: GetProductRowsInput): string {
- return `${input.codeFournisseur}:${input.magasin ?? "TOTAL"}`;
-}
-
-export function invalidateGridRowsCache(codeFournisseur?: string) {
- if (codeFournisseur) {
- for (const key of gridRowsCache.keys()) {
- if (key.startsWith(`${codeFournisseur}:`)) gridRowsCache.delete(key);
- }
- for (const key of gridRowsPending.keys()) {
- if (key.startsWith(`${codeFournisseur}:`)) gridRowsPending.delete(key);
- }
- return;
- }
- gridRowsCache.clear();
- gridRowsPending.clear();
-}
-
-/**
- * Reporte des gammes enregistrées sur les lignes déjà en cache, au lieu de jeter
- * le cache : l'invalidation forçait un recalcul complet (jusqu'à ~40 s sur un gros
- * fournisseur) à la réouverture suivante. Le résultat est celui qu'aurait donné
- * ce recalcul : la colonne Gamme reprend la valeur du dernier snapshot (Phase 9),
- * la colonne INIT reste l'état serveur.
- */
-export function patchGridRowsCache(
- codeFournisseur: string,
- changes: ReadonlyArray<{ codein: string; codeGamme: string }>,
-): void {
- if (changes.length === 0) return;
- // Un calcul en cours pour ce fournisseur a lu les gammes avant cet
- // enregistrement : le compteur lui signale de les relire avant d'être caché.
- gammeSaveVersion.set(codeFournisseur, (gammeSaveVersion.get(codeFournisseur) ?? 0) + 1);
- const byCodein = new Map(changes.map((c) => [c.codein, c.codeGamme as GammeCode]));
- for (const [key, entry] of gridRowsCache) {
- if (!key.startsWith(`${codeFournisseur}:`)) continue;
- for (const row of entry.rows) {
- const gamme = byCodein.get(row.codein);
- if (gamme !== undefined) row.codeGamme = gamme;
- }
- }
-}
-
-/**
- * Rafraîchit UNIQUEMENT la colonne INIT (codeGammeInit = gamme serveur courante)
- * sur des lignes servies depuis le cache. La colonne Gamme (codeGamme) n'est pas
- * touchée : elle conserve la valeur issue du snapshot. Ainsi l'état serveur (INIT)
- * est toujours à jour à chaque chargement, même sur un hit du cache 10 min — et le
- * marqueur "modifié" (Gamme ≠ INIT) se résorbe dès que le serveur rattrape la modif.
- */
-async function refreshGammeInit(rows: ProductRow[], codeFournisseur: string): Promise {
- try {
- const gammeMap = await pgGetGammesByFournisseur(codeFournisseur);
- if (gammeMap.size === 0) return;
- for (const row of rows) {
- const live = gammeMap.get(row.codein);
- if (live !== undefined) row.codeGammeInit = live as GammeCode;
- }
- } catch (e) {
- console.error("[getProductRows] refreshGammeInit error:", (e as Error).message?.slice(0, 200));
- }
-}
-
-/**
- * Écrit l'instantané de grille lu par /api/v1 (table `grid_rows`).
- *
- * Seul `magasin = TOTAL` est persisté : `ProductRow` embarque déjà les ventilations
- * par magasin (sales12mByStore, caByStore…), inutile de stocker trois variantes.
- * Toute erreur est avalée : la persistance ne doit jamais casser l'affichage.
- */
-async function persistGridSnapshot(input: GetProductRowsInput, rows: ProductRow[]): Promise {
- if ((input.magasin ?? "TOTAL") !== "TOTAL") return;
- try {
- const n = await upsertGridRows(input.codeFournisseur, rows);
- console.log(`[getProductRows] instantané persisté: ${n} lignes pour ${input.codeFournisseur}`);
- } catch (e) {
- console.error("[getProductRows] persistance grid_rows KO:", (e as Error).message?.slice(0, 200));
- }
-}
-
-export async function getProductRows(input: GetProductRowsInput): Promise {
- const cacheKey = gridRowsCacheKey(input);
- const cached = gridRowsCache.get(cacheKey);
- if (!input.forceRefresh && cached && Date.now() - cached.createdAt < GRID_ROWS_CACHE_TTL_MS) {
- // Remonte l'entrée en tête de l'ordre d'usage (éviction LRU).
- gridRowsCache.delete(cacheKey);
- gridRowsCache.set(cacheKey, cached);
- // La colonne INIT doit refléter l'état serveur à CHAQUE chargement,
- // y compris sur un hit de cache (les données lourdes restent, elles, cachées).
- await refreshGammeInit(cached.rows, input.codeFournisseur);
- return cached.rows;
- }
-
- // Un calcul déjà en cours est réutilisé même en rechargement forcé : il part
- // de données fraîches, et en lancer un second en parallèle doublait la charge
- // (double clic, onglet rouvert…) sans rien apporter.
- const pending = gridRowsPending.get(cacheKey);
- if (pending) {
- return pending;
- }
-
- // Instantané persisté (calcul de la nuit ou de la dernière ouverture) : servi
- // en une lecture au lieu d'un recalcul de 10 à 40 s. Jamais en rechargement
- // forcé — c'est précisément ce que l'utilisateur demande d'éviter.
- if (!input.forceRefresh) {
- const servi = await serveFromSnapshot(input, cacheKey);
- if (servi) return servi;
- }
-
- const versionAuDepart = gammeSaveVersion.get(input.codeFournisseur) ?? 0;
- const promise = buildProductRows(input).then(async (rows) => {
- if ((gammeSaveVersion.get(input.codeFournisseur) ?? 0) !== versionAuDepart) {
- // Gammes enregistrées pendant le calcul : on reprend le dernier snapshot.
- applySnapshotChanges(rows, await loadLatestSnapshotChanges(input.codeFournisseur));
- }
- cacheGridRows(cacheKey, rows);
- gridRowsPending.delete(cacheKey);
- // Persiste l'instantané pour /api/v1 : le calcul vient d'avoir lieu, on
- // arrête simplement de jeter le résultat. Volontairement NON bloquant —
- // l'affichage de la Grille ne doit pas attendre l'écriture.
- void persistGridSnapshot(input, rows);
- return rows;
- }).catch((error) => {
- gridRowsPending.delete(cacheKey);
- throw error;
- });
-
- gridRowsPending.set(cacheKey, promise);
- return promise;
-}
-
-/** Au-delà, l'instantané est servi mais un recalcul est relancé en arrière-plan. */
-const SNAPSHOT_REFRESH_AFTER_MS = 20 * 60 * 60 * 1000;
-
-/**
- * Sert la Grille depuis `grid_rows` quand c'est possible : mêmes lignes que le
- * calcul en direct (elles en sont issues), avec la gamme FF du moment (INIT) et
- * les dernières gammes enregistrées reportées dessus. Hors « tous magasins »,
- * le rattrapage du magasin choisi est appliqué comme après un calcul.
- *
- * `null` = pas d'instantané utilisable (absent, ancien format, autre mois) :
- * l'appelant recalcule.
- */
-async function serveFromSnapshot(input: GetProductRowsInput, cacheKey: string): Promise {
- const { codeFournisseur, magasin = "TOTAL" } = input;
- let snapshot: Awaited>;
- try {
- snapshot = await readGridSnapshot(codeFournisseur);
- } catch (e) {
- console.error("[getProductRows] lecture grid_rows KO:", (e as Error).message?.slice(0, 200));
- return null;
- }
- if (!snapshot || snapshot.rows.length === 0) return null;
-
- const { rows } = snapshot;
- // Les colonnes réseau de l'instantané datent de son calcul : on les relit dans
- // le cache Qlik, comme le calcul en direct. Sans cela, une synchro Qlik faite
- // depuis (au changement de mois notamment) restait invisible jusqu'au
- // prochain recalcul, et la tendance réseau disparaissait.
- const [changes, network] = await Promise.all([
- loadLatestSnapshotChanges(codeFournisseur),
- fetchNetworkMetrics(rows.map((r) => r.codeCentrale ?? "")),
- refreshGammeInit(rows, codeFournisseur),
- ]);
- applySnapshotChanges(rows, changes);
- enrichWithNetworkMetrics(rows, network);
-
- if (magasin !== "TOTAL") {
- const { dateDebut, dateFin } = buildLast12MonthsRange();
- await reconcileSelectedStoreFromMensuelApi(rows, magasin, dateDebut, dateFin, last12Periods());
- }
-
- cacheGridRows(cacheKey, rows);
-
- // Instantané qui n'a pas été recalculé par la nuit : on le rafraîchit sans
- // faire attendre l'utilisateur (la prochaine ouverture en profitera).
- // Toujours le calcul « tous magasins » : c'est lui qui réécrit l'instantané.
- if (Date.now() - snapshot.computedAt.getTime() > SNAPSHOT_REFRESH_AFTER_MS && !gridRowsPending.has(`${codeFournisseur}:TOTAL`)) {
- void getProductRows({ codeFournisseur, magasin: "TOTAL", forceRefresh: true }).catch((e) =>
- console.error("[getProductRows] rafraîchissement en arrière-plan KO:", (e as Error).message?.slice(0, 200)),
- );
- }
- return rows;
-}
-
-/** Les 12 derniers mois complets, clés « YYYYMM » triées (même fenêtre que le calcul). */
-function last12Periods(): string[] {
- const now = new Date();
- const periods: string[] = [];
- for (let i = 12; i >= 1; i--) {
- const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
- periods.push(`${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}`);
- }
- return periods;
-}
-
-async function buildProductRows(input: GetProductRowsInput): Promise {
- const { codeFournisseur, magasin = "TOTAL" } = input;
- console.log(`\n>>> [getProductRows] supplier: ${codeFournisseur}, magasin: ${magasin}`);
-
- try {
- const { dateDebut, dateFin } = buildLast12MonthsRange();
-
- // ─── Phase 1 : 7 requêtes SQL en parallèle ────────────────────────────
- // Remplace des centaines/milliers d'appels HTTP per-article.
- const articlesPromise = pgGetArticlesByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetArticlesByFournisseur ERROR:", e); return []; });
- // Phases 8 et 9 lancées dès maintenant : elles n'attendent que la liste des
- // articles (codes centraux) ou le seul code fournisseur. Exécutées après la
- // Phase 1, elles ajoutaient deux allers-retours en série à chaque calcul.
- const networkPromise = articlesPromise.then((arts) =>
- fetchNetworkMetrics(arts.map((a) => (a.codeCentrale ? String(a.codeCentrale).trim() : ""))),
- );
- const snapshotPromise = loadLatestSnapshotChanges(codeFournisseur);
-
- const [
- articles,
- mensuelRows,
- gammeMap,
- nomMap,
- stockMap,
- commandesMap,
- prixVenteMap,
- ] = await Promise.all([
- articlesPromise,
- pgGetMensuelByFournisseur(codeFournisseur, dateDebut, dateFin).catch(e => { console.error("[getProductRows] pgGetMensuelByFournisseur ERROR:", e); return []; }),
- pgGetGammesByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetGammesByFournisseur ERROR:", e); return new Map(); }),
- pgGetNomenclatureByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetNomenclatureByFournisseur ERROR:", e); return new Map(); }),
- pgGetStockByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetStockByFournisseur ERROR:", e); return new Map(); }),
- pgGetCommandesByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetCommandesByFournisseur ERROR:", e); return new Map(); }),
- pgGetPrixVenteByFournisseur(codeFournisseur).catch(e => { console.error("[getProductRows] pgGetPrixVenteByFournisseur ERROR:", e); return new Map>(); }),
- ]);
-
- console.log(`[getProductRows] ${articles.length} articles, ${mensuelRows.length} mensuel rows, ${gammeMap.size} gammes`);
-
- // ─── Phase 2 : Fenêtre temporelle 12 mois complets ───────────────────
- const sortedPeriods = last12Periods();
- const allowedPeriods = new Set(sortedPeriods);
-
- // ─── Phase 3 : Seed productMap depuis articles ────────────────────────
- const productMap = new Map();
- for (const art of articles) {
- if (!art.codein || productMap.has(art.codein)) continue;
- productMap.set(art.codein, {
- codein: art.codein,
- codeFournisseur: art.codefou ?? codeFournisseur,
- nomFournisseur: art.nomfou ?? "",
- fournisseurPrincipalCode: art.codefou_principal ?? undefined,
- fournisseurPrincipalNom: art.nomfou_principal ?? undefined,
- libelle1: art.libelle1 ?? "",
- gtin: art.gtin ?? "",
- reference: art.reference ?? "",
- codeCentrale: art.codeCentrale ? String(art.codeCentrale).trim() : undefined,
- code1: "", libelleNiveau1: "",
- code2: "", libelleNiveau2: "",
- code3: "", libelle3: "",
- codeGamme: null,
- codeGammeInit: null,
- codeGammeDraft: null,
- sales12m: {},
- stock12m: {},
- receptions12m: {},
- totalQuantite: 0,
- totalCa: 0,
- totalMarge: 0,
- tauxMarge: 0,
- workingStores: [],
- noid: art.no_id ? Number(art.no_id) : undefined,
- pcb: art.pcb ? Number(art.pcb) : undefined,
- prixVente: art.pv_central ? Number(art.pv_central) : undefined,
- });
- }
-
- // ─── Phase 4 : Agréger mensuelRows → byPeriod par codein ─────────────
- // SQL a déjà fait l'agrégation par (codein, site, mois).
- // On somme les 2 sites (TOTAL) ET on accumule par site pour le switch client-side.
- type PeriodData = { qty: number; ca: number; marge: number; stock: number; receptions: number };
- const mensuelByCodein = new Map>();
- const mensuelBySite = new Map>>(); // codein → site → periode → data
- const storeMonthsByCodein = new Map>>();
-
- for (const row of mensuelRows) {
- const periode = row.mois.replace("-", ""); // "2026-02" → "202602"
- if (!allowedPeriods.has(periode)) continue;
-
- // Accumulation TOTAL (toujours tous sites)
- if (!mensuelByCodein.has(row.codein)) mensuelByCodein.set(row.codein, new Map());
- const byPeriod = mensuelByCodein.get(row.codein)!;
- if (!byPeriod.has(periode)) byPeriod.set(periode, { qty: 0, ca: 0, marge: 0, stock: 0, receptions: 0 });
- const p = byPeriod.get(periode)!;
- p.stock += Number(row.stock_fin_mois) || 0;
- p.qty += Number(row.qte_vendue) || 0;
- p.ca += Number(row.ca_ht) || 0;
- p.marge += Number(row.marge) || 0;
- p.receptions += Number(row.qte_recue) || 0;
-
- // Accumulation par site (pour switch client-side)
- if (!mensuelBySite.has(row.codein)) mensuelBySite.set(row.codein, new Map());
- const bySite = mensuelBySite.get(row.codein)!;
- if (!bySite.has(row.site)) bySite.set(row.site, new Map());
- const siteByPeriod = bySite.get(row.site)!;
- if (!siteByPeriod.has(periode)) siteByPeriod.set(periode, { qty: 0, ca: 0, marge: 0, stock: 0, receptions: 0 });
- const sp = siteByPeriod.get(periode)!;
- sp.qty += Number(row.qte_vendue) || 0;
- sp.ca += Number(row.ca_ht) || 0;
- sp.marge += Number(row.marge) || 0;
- sp.stock = Number(row.stock_fin_mois) || 0; // SQL donne déjà le dernier mouvement
- sp.receptions += Number(row.qte_recue) || 0;
-
- // Suivi magasins actifs (pour workingStores) : 1 vente suffit
- if (Number(row.qte_vendue) > 0) {
- if (!storeMonthsByCodein.has(row.codein)) storeMonthsByCodein.set(row.codein, new Map());
- storeMonthsByCodein.get(row.codein)!.set(row.site, new Set());
- }
- }
-
- // ─── Phase 5 : Remplir ProductRow depuis mensuelByCodein ─────────────
- for (const [codein, byPeriod] of mensuelByCodein.entries()) {
- const product = productMap.get(codein);
- if (!product) continue;
-
- let lastStock = 0;
- for (const periode of sortedPeriods) {
- const p = byPeriod.get(periode);
- if (p) {
- product.sales12m[periode] = p.qty;
- product.stock12m[periode] = p.stock;
- product.receptions12m[periode] = p.receptions;
- product.totalQuantite += p.qty;
- product.totalCa += p.ca;
- product.totalMarge += p.marge;
- lastStock = p.stock;
- } else {
- product.sales12m[periode] = 0;
- product.stock12m[periode] = lastStock; // carry-forward
- product.receptions12m[periode] = 0;
- }
- }
-
- product.tauxMarge = product.totalCa > 0 ? (product.totalMarge / product.totalCa) * 100 : 0;
-
- // Breakdowns par site pour le switch client-side
- const siteMap = mensuelBySite.get(codein);
- if (siteMap) {
- product.sales12mByStore = {};
- product.stock12mByStore = {};
- product.receptions12mByStore = {};
- product.caByStore = {};
- product.quantiteByStore = {};
- product.margeByStore = {};
- for (const [site, siteByPeriod] of siteMap.entries()) {
- product.sales12mByStore[site] = {};
- product.stock12mByStore[site] = {};
- product.receptions12mByStore![site] = {};
- let sQty = 0, sCa = 0, sMarge = 0;
- let lastSiteStock = 0;
- for (const periode of sortedPeriods) {
- const sp = siteByPeriod.get(periode);
- product.sales12mByStore[site][periode] = sp?.qty ?? 0;
- product.receptions12mByStore![site][periode] = sp?.receptions ?? 0;
- if (sp) {
- product.stock12mByStore[site][periode] = sp.stock;
- lastSiteStock = sp.stock;
- } else {
- product.stock12mByStore[site][periode] = lastSiteStock; // carry-forward
- }
- sQty += sp?.qty ?? 0;
- sCa += sp?.ca ?? 0;
- sMarge += sp?.marge ?? 0;
- }
- product.quantiteByStore[site] = sQty;
- product.caByStore[site] = sCa;
- product.margeByStore[site] = sMarge;
- }
-
- // Le stock TOTAL se recalcule ici, à partir des séries par site.
- //
- // Il était sommé plus haut depuis les lignes mensuelles brutes, ce
- // qui perdait tout magasin SANS MOUVEMENT dans le mois : le stock
- // est un niveau, pas un flux — un magasin qui n'a rien vendu ni reçu
- // détient toujours sa marchandise. Sur un produit à faible rotation,
- // « tous magasins » n'affichait donc que le site actif, en pratique
- // Frouard. Les séries par site, elles, sont reportées d'un mois sur
- // l'autre : leur somme est la bonne.
- const sites = Object.keys(product.stock12mByStore);
- if (sites.length > 0) {
- for (const periode of sortedPeriods) {
- product.stock12m[periode] = sites.reduce(
- (total, site) => total + (product.stock12mByStore![site][periode] ?? 0),
- 0,
- );
- }
- }
- }
-
- // workingStores : sites avec au moins 1 vente sur les 12 derniers mois
- const storeMonths = storeMonthsByCodein.get(codein);
- if (storeMonths) {
- product.workingStores = [...storeMonths.keys()].sort();
- }
-
- // Commandes en cours
- const cmdQty = commandesMap.get(codein);
- if (cmdQty) product.commandesEnCours = cmdQty;
- }
-
- // ─── Phase 6 : Gammes (saison active) ────────────────────────────────
- for (const [codein, gammeCode] of gammeMap.entries()) {
- const product = productMap.get(codein);
- if (!product) continue;
- product.codeGammeInit = gammeCode as GammeCode;
- product.codeGamme = gammeCode as GammeCode;
- }
-
- // ─── Phase 6b : Nomenclature (famille / sous-famille) ────────────────
- for (const [codein, nom] of nomMap.entries()) {
- const product = productMap.get(codein);
- if (!product) continue;
- product.code3 = nom.code3 ?? "";
- product.libelle3 = nom.libelle3 ?? "";
- product.code2 = nom.code2 ?? "";
- product.libelleNiveau2 = nom.libelle2 ?? "";
- product.code1 = nom.code1 ?? "";
- product.libelleNiveau1 = nom.libelle1nom ?? "";
- }
-
- // ─── Phase 7 : Stock temps réel (cube_stock) ─────────────────────────
- for (const [codein, stocks] of stockMap.entries()) {
- const product = productMap.get(codein);
- if (!product) continue;
-
- const sitesStock = stocks;
-
- product.stockActuel = sitesStock.reduce((s, r) => s + (Number(r.stockdispo) || 0), 0);
- product.stockTotal = sitesStock.reduce((s, r) => s + (Number(r.qte) || 0), 0);
- product.stockValeur = sitesStock.reduce((s, r) => s + (Number(r.valstock) || 0), 0);
-
- const withPrmp = sitesStock.find(r => Number(r.prmp) > 0);
- if (withPrmp) {
- product.pa = Number(withPrmp.prmp);
- product.prixAchat = product.pa;
- }
-
- const dernVente = sitesStock.reduce((best, r) =>
- r.dernierevente && r.dernierevente > best ? r.dernierevente : best, "");
- if (dernVente) product.derniereVente = dernVente;
-
- const dernLiv = sitesStock.reduce((best, r) =>
- r.dernierereception && r.dernierereception > best ? r.dernierereception : best, "");
- if (dernLiv) product.derniereLivraison = dernLiv;
-
- // Map store-specific delivery dates
- product.derniereLivraisonByStore = {};
- for (const r of sitesStock) {
- if (r.site && r.dernierereception) {
- product.derniereLivraisonByStore[r.site] = r.dernierereception;
- }
- }
- }
-
- // ─── Phase 7b : Prix de vente (cube_pv, sinon le PV du cube de stock) ─
- //
- // `article_infosup.prix_vente_mini`, renseigné en Phase 3, n'est qu'une
- // borne de paramétrage : elle est vide en base et laissait la colonne PV
- // entièrement creuse. Le vrai prix vit dans `cube_pv`, par article ET par
- // site. On garde le détail par magasin — deux magasins peuvent ne pas
- // pratiquer le même prix, et l'afficher vaut mieux que le moyenner.
- for (const product of productMap.values()) {
- const parSite = prixVenteMap.get(product.codein);
- if (parSite && Object.keys(parSite).length > 0) {
- product.prixVenteByStore = parSite;
- } else {
- // Filet de secours : le cube de stock porte le même PV, mais
- // seulement pour les articles qui ont une ligne de stock.
- const depuisStock: Record = {};
- for (const s of stockMap.get(product.codein) ?? []) {
- const pv = Number(s.pv);
- const site = String(s.site ?? "").trim();
- if (site && Number.isFinite(pv) && pv > 0) depuisStock[site] = pv;
- }
- if (Object.keys(depuisStock).length > 0) product.prixVenteByStore = depuisStock;
- }
-
- const prix = Object.values(product.prixVenteByStore ?? {});
- // Le plus élevé quand les magasins divergent : une moyenne inventerait
- // un prix qu'aucune caisse ne pratique. L'écart est signalé à l'écran.
- if (prix.length > 0) product.prixVente = Math.max(...prix);
- }
-
- // ─── Phase 8 : Données réseau Qlik (CA / Qté / nb magasins par code centrale) ──
- enrichWithNetworkMetrics(productMap.values(), await networkPromise);
-
- // ─── Phase 9 : Restaurer gammes depuis dernier snapshot ──────────────
- // La colonne Gamme (codeGamme) conserve la valeur du snapshot telle quelle.
- // La colonne INIT (codeGammeInit) reste, elle, l'état LIVE du serveur
- // rechargé en Phase 6 — jamais écrasée ici.
- applySnapshotChanges(productMap.values(), await snapshotPromise);
-
- // ─── Phase 10 : Filtrer gamme Y sans ventes ──────────────────────────
- const allRows = Array.from(productMap.values());
- const rows = allRows.filter(p => p.codeGamme !== "Y" || p.totalQuantite > 0);
- await reconcileSelectedStoreFromMensuelApi(rows, magasin, dateDebut, dateFin, sortedPeriods);
- const excludedY = allRows.length - rows.length;
- console.log(`[getProductRows] ${rows.length} produits (${excludedY} gamme Y sans ventes exclus), ${mensuelByCodein.size} avec ventes`);
-
- return rows;
-
- } catch (error) {
- console.error(`[getProductRows] Error for ${codeFournisseur}:`, error);
- // Ne PAS renvoyer [] : une liste vide est indiscernable d'un fournisseur
- // sans article. La Grille affichait une page blanche sans explication, et
- // la synchro nocturne prenait la panne pour un fournisseur vide — qu'elle
- // désactivait alors automatiquement. La remonter laisse chaque appelant la
- // traiter comme une erreur (bandeau rouge, statut « echec »).
- throw error instanceof Error
- ? error
- : new Error(`Calcul de la grille impossible pour ${codeFournisseur} : ${String(error)}`);
- }
-}
-
-/** Articles complétés par l'API FF, au plus, lors d'un changement de magasin. */
-function plafondComplement(): number {
- return Number(process.env.GRID_STORE_RECONCILE_MAX ?? 300);
-}
-
-/** Interroge l'API FF pour les articles du magasin à compléter (cf. store-patch). */
-async function fetchStorePatchEntries(
- rows: ProductRow[],
- magasin: string,
- dateDebut: string,
- dateFin: string,
- periods: string[],
-): Promise {
- const candidates = storePatchCandidates(rows, magasin);
- if (candidates.length === 0) return [];
-
- // Ce rattrapage fait UNE requête HTTP par article : sur un gros fournisseur,
- // les candidats se comptent par milliers et le changement de magasin se fige
- // plusieurs minutes. On le borne, et on dit ce qui a été laissé de côté
- // plutôt que de tronquer en silence.
- const PLAFOND = plafondComplement();
- const retenus = candidates.slice(0, PLAFOND);
- if (candidates.length > retenus.length) {
- console.warn(
- `[getProductRows] rattrapage magasin ${magasin} borné à ${retenus.length} articles`
- + ` sur ${candidates.length} : les autres gardent la valeur SQL.`,
- );
- }
-
- const mensuelMap = await getMensuelByArticles(
- retenus.map((row) => ({
- codein: row.codein,
- libelle1: row.libelle1,
- codefou: row.codeFournisseur,
- noid: row.noid,
- })),
- dateDebut,
- dateFin,
- 25
- );
- return buildStorePatchEntries(retenus, magasin, periods, mensuelMap);
-}
-
-async function reconcileSelectedStoreFromMensuelApi(
- rows: ProductRow[],
- magasin: string,
- dateDebut: string,
- dateFin: string,
- sortedPeriods: string[]
-) {
- if (magasin === "TOTAL") return;
- try {
- const entries = await fetchStorePatchEntries(rows, magasin, dateDebut, dateFin, sortedPeriods);
- const fixedRows = applyStorePatchInPlace(rows, magasin, sortedPeriods, entries);
- if (fixedRows > 0) {
- console.log(`[getProductRows] ${fixedRows} produits corrigés via API mensuelle pour magasin ${magasin}`);
- }
- } catch (error) {
- console.error("[getProductRows] Mensuel API reconciliation error:", error);
- }
-}
-
-/**
- * Compléments par magasin, rattachés au tableau de lignes « tous magasins » en
- * cache : ils vivent et meurent avec lui (expiration, « Actualiser », nouvel
- * enregistrement), sans autre invalidation à gérer.
- */
-const storePatches = new WeakMap>>();
-
-/**
- * Complément de l'API FF pour un magasin, calculé sur les lignes « tous
- * magasins » (jamais modifiées ici). La Grille l'applique à son arrivée, sans
- * recharger les lignes. Les demandes simultanées partagent le même calcul, et
- * un échec n'est jamais gardé.
- */
-export async function getStorePatch(codeFournisseur: string, magasin: string): Promise {
- const enCache = gridRowsCache.get(`${codeFournisseur}:TOTAL`);
- const rows = enCache && Date.now() - enCache.createdAt < GRID_ROWS_CACHE_TTL_MS
- ? enCache.rows
- : await getProductRows({ codeFournisseur, magasin: "TOTAL" });
-
- let parMagasin = storePatches.get(rows);
- if (!parMagasin) {
- parMagasin = new Map();
- storePatches.set(rows, parMagasin);
- }
- let patch = parMagasin.get(magasin);
- if (!patch) {
- const periods = last12Periods();
- const { dateDebut, dateFin } = buildLast12MonthsRange();
- const enCours = fetchStorePatchEntries(rows, magasin, dateDebut, dateFin, periods)
- .then((entries): StorePatch => ({ magasin, periods, entries }));
- const table = parMagasin;
- enCours.catch(() => {
- if (table.get(magasin) === enCours) table.delete(magasin);
- });
- parMagasin.set(magasin, enCours);
- patch = enCours;
- }
- return patch;
-}
-
-/**
- * Extrait la série « nombre de magasins vendeurs » du détail mensuel complet.
- *
- * `metricsByMonth` porte les cinq mesures Qlik du mois ; seule `nbMag` sert à la
- * deuxième courbe de la carte tendance. Renvoie `null` plutôt qu'un objet vide
- * pour que l'UI distingue « pas de donnée » de « zéro magasin ».
- */
-function nbMagParMois(
- metricsByMonth: Record | null | undefined,
-): Record | null {
- if (!metricsByMonth) return null;
- const parMois: Record = {};
- for (const [mois] of Object.entries(metricsByMonth)) {
- // Un mois PRÉSENT dans le détail est un mois extrait : s'il n'a pas de
- // `nbMag`, c'est qu'aucun magasin n'a vendu, donc zéro. Le traiter comme
- // « manquant » amputait la série et faisait disparaître toute la courbe
- // (les anciens caches n'écrivaient `nbMag` que sur les mois avec vente).
- const nb = Number(metricsByMonth[mois]?.nbMag);
- parMois[mois] = Number.isFinite(nb) ? nb : 0;
- }
- return Object.keys(parMois).length > 0 ? parMois : null;
-}
-
-type SnapshotChanges = Record;
-
-/**
- * Phase 9 : la colonne Gamme (codeGamme) reprend la valeur du snapshot ;
- * codeGammeInit reste figé (état serveur).
- */
-function applySnapshotChanges(rows: Iterable, changes: SnapshotChanges | null): void {
- if (!changes) return;
- for (const row of rows) {
- const change = changes[row.codein];
- if (change?.after) row.codeGamme = change.after as GammeCode;
- }
-}
-
-/** Dernières gammes enregistrées pour ce fournisseur (Phase 9), ou `null`. */
-async function loadLatestSnapshotChanges(codeFournisseur: string): Promise {
- try {
- const snaps = await db
- .select({ changes: sessionSnapshots.changes })
- .from(sessionSnapshots)
- .where(eq(sessionSnapshots.codeFournisseur, codeFournisseur))
- .orderBy(desc(sessionSnapshots.createdAt))
- .limit(1);
- return snaps.length > 0 ? (snaps[0].changes as SnapshotChanges) : null;
- } catch (snapErr) {
- console.error("[getProductRows] Snapshot restore error:", snapErr);
- return null;
- }
-}
-
-/**
- * Lit les metriques reseau Qlik (cache qlik_network_metrics) des codes centraux
- * donnes. `null` en cas d'erreur : la grille s'affiche alors sans donnees reseau.
- */
-async function fetchNetworkMetrics(
- codesCentrale: string[],
-): Promise | null> {
- try {
- const codes = [...new Set(codesCentrale.filter(Boolean))];
- if (codes.length === 0) return null;
- return await getNetworkMetricsByCodeCentrale(codes);
- } catch (error) {
- console.error("[getProductRows] enrichWithNetworkMetrics error:", error);
- return null;
- }
-}
-
-/**
- * Enrichit les produits avec les metriques reseau Qlik, jointes par code centrale.
- * Degradation propre si la sync Qlik n'a jamais tourne ou si le code centrale
- * n'est pas encore disponible.
- */
-function enrichWithNetworkMetrics(
- products: Iterable,
- metrics: Map | null,
-): void {
- if (!metrics || metrics.size === 0) return;
- for (const product of products) {
- const m = product.codeCentrale ? metrics.get(product.codeCentrale) : undefined;
- if (!m) continue;
- product.caReseau = m.caReseau;
- product.qteReseau = m.qteReseau;
- product.nbMagasinsReseau = m.nbMagasinsReseau;
- product.caParMagasinReseau = m.caParMagasinReseau;
- product.margePctReseau = m.margePctReseau;
- product.tauxPresenceReseau = m.nbMagasinsReseau / NB_MAGASINS_RESEAU;
- product.qteReseauByMonth = m.qteByMonth ?? null;
- product.nbMagReseauByMonth = nbMagParMois(m.metricsByMonth);
- product.networkFetchedAt = m.fetchedAt ?? undefined;
- }
-}
diff --git a/src/features/grid/api/save-draft-changes.ts b/src/features/grid/api/save-draft-changes.ts
index 1c432cd..f04b3dc 100644
--- a/src/features/grid/api/save-draft-changes.ts
+++ b/src/features/grid/api/save-draft-changes.ts
@@ -1,51 +1,25 @@
-"use server";
+/**
+ * Enregistrement des gammes modifiées dans la Grille — action exécutée par le
+ * serveur Rust : `POST /api/actions/saveDraftChanges` (validation comprise).
+ */
-import { z } from "zod";
-import { verifierSession } from "@/lib/authz";
-import { enregistrerGammes } from "./enregistrer-gammes";
-import { supprimerGammesAValider } from "@/lib/gammes-a-valider";
+import { callAction } from "@/lib/rpc";
-const SaveDraftsSchema = z.object({
- codeFournisseur: z.string(),
- nomFournisseur: z.string().optional(),
- magasin: z.string(),
- changes: z.array(
- z.object({
- codein: z.string(),
- codeGammeBefore: z.string().nullable(),
- codeGamme: z.string(),
- })
- ),
+/** Données attendues par le serveur (ex-schéma zod `SaveDraftsSchema`). */
+export interface SaveDraftsInput {
+ codeFournisseur: string;
+ nomFournisseur?: string;
+ magasin: string;
+ changes: { codein: string; codeGammeBefore: string | null; codeGamme: string }[];
/**
* Propositions de l'API examinées dans la Grille : validées (présentes dans
* `changes`) ou écartées. Elles quittent la file « à valider ».
*/
- gammesAValiderTraitees: z.array(z.string()).optional(),
-});
+ gammesAValiderTraitees?: string[];
+}
export async function saveDraftChanges(
raw: unknown
): Promise<{ success: boolean; saved: number; error?: string }> {
- const acces = await verifierSession();
- if (!acces.ok) return { success: false, saved: 0, error: acces.message };
-
- const parsed = SaveDraftsSchema.safeParse(raw);
- if (!parsed.success) {
- return { success: false, saved: 0, error: "Validation failed: " + parsed.error.message };
- }
-
- const { codeFournisseur, nomFournisseur, magasin, changes, gammesAValiderTraitees = [] } = parsed.data;
-
- const rawUserId = acces.utilisateur.id;
- const userId = rawUserId ? parseInt(rawUserId, 10) : null;
- const finalUserId = userId && !isNaN(userId) ? userId : null;
-
- try {
- const saved = await enregistrerGammes({ codeFournisseur, nomFournisseur, magasin, changes, userId: finalUserId });
- await supprimerGammesAValider(codeFournisseur, gammesAValiderTraitees);
- return { success: true, saved };
- } catch (err) {
- const msg = err instanceof Error ? err.message : "Unknown error";
- return { success: false, saved: 0, error: msg };
- }
+ return callAction("saveDraftChanges", [raw]);
}
diff --git a/src/features/grid/components/assortment-gaps-modal.tsx b/src/features/grid/components/assortment-gaps-modal.tsx
index d691a23..6c5ae58 100644
--- a/src/features/grid/components/assortment-gaps-modal.tsx
+++ b/src/features/grid/components/assortment-gaps-modal.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Trous d'assortiment : ce qu'un magasin ne travaille pas.
*
diff --git a/src/features/grid/components/bulk-action-toolbar.tsx b/src/features/grid/components/bulk-action-toolbar.tsx
index 962845d..8d4d4c3 100644
--- a/src/features/grid/components/bulk-action-toolbar.tsx
+++ b/src/features/grid/components/bulk-action-toolbar.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useGridStore } from "@/features/grid/store/use-grid-store";
import { GammeCode } from "@/types/grid";
import { cn } from "@/lib/utils";
diff --git a/src/features/grid/components/floating-summary-bar.tsx b/src/features/grid/components/floating-summary-bar.tsx
index 448c3ba..20c69e9 100644
--- a/src/features/grid/components/floating-summary-bar.tsx
+++ b/src/features/grid/components/floating-summary-bar.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import React from "react";
import { useGridStore } from "@/features/grid/store/use-grid-store";
diff --git a/src/features/grid/components/gamme-select.tsx b/src/features/grid/components/gamme-select.tsx
index 37741c5..7963b97 100644
--- a/src/features/grid/components/gamme-select.tsx
+++ b/src/features/grid/components/gamme-select.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { GammeCode } from "@/types/grid";
import { cn } from "@/lib/utils";
import { CLASSES_SANS_GAMME, GAMMES, trouverGamme } from "@/lib/gammes";
diff --git a/src/features/grid/components/grid-client.tsx b/src/features/grid/components/grid-client.tsx
index 34bf1ca..c8cccb5 100644
--- a/src/features/grid/components/grid-client.tsx
+++ b/src/features/grid/components/grid-client.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useEffect, useRef, useState } from "react";
import { HeatmapGrid } from "@/features/grid/components/heatmap-grid";
import { FloatingSummaryBar } from "@/features/grid/components/floating-summary-bar";
diff --git a/src/features/grid/components/grid-filter-bar.tsx b/src/features/grid/components/grid-filter-bar.tsx
index ea1fea0..12c6c5f 100644
--- a/src/features/grid/components/grid-filter-bar.tsx
+++ b/src/features/grid/components/grid-filter-bar.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import React, { useMemo } from "react";
import { Search, X } from "lucide-react";
import { useGridStore } from "@/features/grid/store/use-grid-store";
diff --git a/src/features/grid/components/heatmap-grid.tsx b/src/features/grid/components/heatmap-grid.tsx
index 1f9c071..2b9d896 100644
--- a/src/features/grid/components/heatmap-grid.tsx
+++ b/src/features/grid/components/heatmap-grid.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import React, { useRef, useState, useCallback, useEffect, useMemo } from "react";
import { createPortal } from "react-dom";
import {
diff --git a/src/features/grid/components/network-charts.tsx b/src/features/grid/components/network-charts.tsx
index 645999c..920b0b2 100644
--- a/src/features/grid/components/network-charts.tsx
+++ b/src/features/grid/components/network-charts.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Graphiques réseau (SVG fait main, aucune librairie de charts).
*
diff --git a/src/features/grid/components/network-monthly-modal.tsx b/src/features/grid/components/network-monthly-modal.tsx
index 26d4499..2aa19ee 100644
--- a/src/features/grid/components/network-monthly-modal.tsx
+++ b/src/features/grid/components/network-monthly-modal.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Carte « tendance réseau », ouverte depuis la colonne Tendance.
*
diff --git a/src/features/grid/components/nomenclature-ca-modal.tsx b/src/features/grid/components/nomenclature-ca-modal.tsx
index 5b7e7c6..b58aef9 100644
--- a/src/features/grid/components/nomenclature-ca-modal.tsx
+++ b/src/features/grid/components/nomenclature-ca-modal.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — CA par nomenclature : nos magasins face au réseau.
*
diff --git a/src/features/grid/components/nomenclature-filter.tsx b/src/features/grid/components/nomenclature-filter.tsx
index 867c5da..74061d6 100644
--- a/src/features/grid/components/nomenclature-filter.tsx
+++ b/src/features/grid/components/nomenclature-filter.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import * as React from "react";
import { cn } from "@/lib/utils";
import { ChevronDown, Filter, Search, X } from "lucide-react";
diff --git a/src/features/grid/components/product-monthly-modal.tsx b/src/features/grid/components/product-monthly-modal.tsx
index 3a8f6d8..a0eb99b 100644
--- a/src/features/grid/components/product-monthly-modal.tsx
+++ b/src/features/grid/components/product-monthly-modal.tsx
@@ -1,5 +1,3 @@
-"use client";
-
/**
* CollectFlow — Détail mensuel d'un produit, ouvert depuis la case « Tot. 12m ».
*
diff --git a/src/features/grid/components/stat-tile.tsx b/src/features/grid/components/stat-tile.tsx
index 7360a61..bbf6024 100644
--- a/src/features/grid/components/stat-tile.tsx
+++ b/src/features/grid/components/stat-tile.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import React from "react";
/**
diff --git a/src/features/grid/components/store-combobox.tsx b/src/features/grid/components/store-combobox.tsx
index db5949b..9c05719 100644
--- a/src/features/grid/components/store-combobox.tsx
+++ b/src/features/grid/components/store-combobox.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useMemo } from "react";
import { Segmented } from "@/components/ui/tabs";
import { CODE_TOUS_MAGASINS, LIBELLE_TOUS_MAGASINS, nomMagasin } from "@/lib/magasins";
diff --git a/src/features/grid/components/supplier-combobox.tsx b/src/features/grid/components/supplier-combobox.tsx
index fc50df9..ebad548 100644
--- a/src/features/grid/components/supplier-combobox.tsx
+++ b/src/features/grid/components/supplier-combobox.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import * as React from "react";
import { Check, ChevronsUpDown, Search } from "lucide-react";
import { cn } from "@/lib/utils";
diff --git a/src/features/grid/components/supplier-selection-landing.tsx b/src/features/grid/components/supplier-selection-landing.tsx
index 7254862..d68190e 100644
--- a/src/features/grid/components/supplier-selection-landing.tsx
+++ b/src/features/grid/components/supplier-selection-landing.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import * as React from "react";
import { LayoutGrid } from "lucide-react";
import { useRouter } from "next/navigation";
diff --git a/src/features/grid/components/sync-qlik-button.tsx b/src/features/grid/components/sync-qlik-button.tsx
index 3387492..4ba5991 100644
--- a/src/features/grid/components/sync-qlik-button.tsx
+++ b/src/features/grid/components/sync-qlik-button.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useGridStore } from "@/features/grid/store/use-grid-store";
import { Loader2, RefreshCw, CheckCircle, AlertCircle } from "lucide-react";
import { useQlikSyncJob } from "@/features/qlik-sync/use-qlik-sync-job";
diff --git a/src/features/grid/hooks/use-save-drafts.ts b/src/features/grid/hooks/use-save-drafts.ts
index 5cdc49f..2af1e64 100644
--- a/src/features/grid/hooks/use-save-drafts.ts
+++ b/src/features/grid/hooks/use-save-drafts.ts
@@ -1,5 +1,3 @@
-"use client";
-
import { useCallback } from "react";
import { useGridStore } from "@/features/grid/store/use-grid-store";
import { saveDraftChanges } from "@/features/grid/api/save-draft-changes";
diff --git a/src/features/grid/hooks/use-store-patch.ts b/src/features/grid/hooks/use-store-patch.ts
index 818c600..b72b812 100644
--- a/src/features/grid/hooks/use-store-patch.ts
+++ b/src/features/grid/hooks/use-store-patch.ts
@@ -1,5 +1,3 @@
-"use client";
-
import { useEffect } from "react";
import { rowsKeyFor, useGridStore } from "@/features/grid/store/use-grid-store";
import { CODE_TOUS_MAGASINS } from "@/lib/magasins";
diff --git a/src/features/grid/lib/store-patch.ts b/src/features/grid/lib/store-patch.ts
index dd66ade..ceb619e 100644
--- a/src/features/grid/lib/store-patch.ts
+++ b/src/features/grid/lib/store-patch.ts
@@ -10,7 +10,7 @@
*/
import type { ProductRow } from "@/types/grid";
-import type { FfMensuelEntry } from "@/lib/api-ff-client";
+import type { FfMensuelEntry } from "@/types/ff";
/** Chiffres d'un article pour le magasin complété. */
export interface StorePatchEntry {
diff --git a/src/features/grid/store/use-grid-store.ts b/src/features/grid/store/use-grid-store.ts
index 2579754..b17e013 100644
--- a/src/features/grid/store/use-grid-store.ts
+++ b/src/features/grid/store/use-grid-store.ts
@@ -1,5 +1,3 @@
-"use client";
-
import { create } from "zustand";
import { persist } from "zustand/middleware";
import { createThrottledJSONStorage } from "@/lib/throttled-json-storage";
diff --git a/src/features/produits/api/get-produit-fiche.ts b/src/features/produits/api/get-produit-fiche.ts
deleted file mode 100644
index 90fd8a1..0000000
--- a/src/features/produits/api/get-produit-fiche.ts
+++ /dev/null
@@ -1,210 +0,0 @@
-import "server-only";
-
-import {
- pgGetProduitDetail,
- pgGetCodeinByCodeCentrale,
- pgGetFournisseursByCodein,
- pgGetStockByCodein,
- pgGetCommandesByCodein,
- pgGetGammeHistoryByCodein,
- pgGetMensuelByCodein,
-} from "@/lib/pg-ff-client";
-import { buildLast12MonthsRange } from "@/lib/api-ff-client";
-import { getNetworkMetricsByCodeCentrale } from "@/lib/qlik-network-cache";
-import type { ProduitFiche, ProduitMois, ProduitTotaux } from "@/features/produits/types";
-
-/** Les 12 clés de mois "YYYYMM" glissantes, mois courant exclu. */
-function buildMonthKeys(): string[] {
- const months: string[] = [];
- const now = new Date();
- for (let i = 12; i >= 1; i--) {
- const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
- months.push(`${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}`);
- }
- return months;
-}
-
-function emptyMois(mois: string): ProduitMois {
- return { mois, qte: 0, ca: 0, marge: 0, stockFinMois: 0, qteRecue: 0 };
-}
-
-function totauxFrom(rows: ProduitMois[]): ProduitTotaux {
- const qte = rows.reduce((s, r) => s + r.qte, 0);
- const ca = rows.reduce((s, r) => s + r.ca, 0);
- const marge = rows.reduce((s, r) => s + r.marge, 0);
- return { qte, ca, marge, tauxMarge: ca > 0 ? (marge / ca) * 100 : 0 };
-}
-
-/**
- * Assemble la fiche d'un produit **à partir de son code centrale** : c'est la
- * clé du réseau Qlik, seule identité disponible pour un produit que le réseau
- * travaille mais que Nancy ne référence pas.
- *
- * Si le catalogue Nancy connaît ce code centrale, on rattache toute la partie
- * locale (identité, fournisseurs, stock, gammes, 12 mois glissants de ventes).
- * Sinon la fiche reste purement réseau, ce qui est un cas parfaitement normal
- * depuis la recherche Qlik.
- *
- * Renvoie `null` uniquement si ni Qlik ni le catalogue ne connaissent le code.
- */
-export async function getProduitFicheByCodeCentrale(codeCentrale: string): Promise {
- const cleaned = codeCentrale.trim();
- if (!cleaned) return null;
-
- const codein = await pgGetCodeinByCodeCentrale(cleaned);
- if (codein) return getProduitFiche(codein);
-
- // Produit réseau pur : aucune donnée locale à assembler.
- const map = await getNetworkMetricsByCodeCentrale([cleaned]);
- const reseau = map.get(cleaned) ?? null;
- if (!reseau) return null;
-
- const { dateDebut, dateFin } = buildLast12MonthsRange();
- const months = buildMonthKeys();
- const mensuelTotal: Record = {};
- for (const m of months) mensuelTotal[m] = emptyMois(m);
-
- return {
- detail: null,
- codeCentrale: cleaned,
- libelleReseau: reseau.libelleReseau ?? "",
- fournisseurReseau: reseau.fournisseurReseau ?? "",
- fournisseurs: [],
- stock: [],
- commandesEnCours: 0,
- gammes: [],
- months,
- mensuelTotal,
- mensuelParSite: {},
- totaux: totauxFrom(months.map((m) => mensuelTotal[m])),
- totauxParSite: {},
- sitesActifs: [],
- reseau,
- periode: { dateDebut, dateFin },
- };
-}
-
-/**
- * Assemble la fiche complète d'un produit : identité, fournisseurs, stock,
- * gammes, 12 mois glissants de ventes (total et par magasin) et métriques
- * réseau Qlik.
- *
- * Renvoie `null` si le codein est inconnu du catalogue FF.
- */
-export async function getProduitFiche(codein: string): Promise {
- const cleaned = codein.trim();
- if (!cleaned) return null;
-
- const { dateDebut, dateFin } = buildLast12MonthsRange();
-
- // Tout part en même temps : l'identité du produit était lue seule d'abord,
- // puis les cinq autres lectures, puis les métriques réseau — trois attentes
- // successives. Les métriques réseau n'attendent que l'identité (code centrale).
- const detailPromise = pgGetProduitDetail(cleaned);
- const reseauPromise = detailPromise.then(async (d) => {
- if (!d?.code_centrale) return null;
- const map = await getNetworkMetricsByCodeCentrale([d.code_centrale]);
- return map.get(d.code_centrale) ?? null;
- });
- const [detail, fournisseurs, stock, commandesEnCours, gammes, mensuelRows, reseau] = await Promise.all([
- detailPromise,
- pgGetFournisseursByCodein(cleaned),
- pgGetStockByCodein(cleaned),
- pgGetCommandesByCodein(cleaned),
- pgGetGammeHistoryByCodein(cleaned),
- pgGetMensuelByCodein(cleaned, dateDebut, dateFin),
- reseauPromise,
- ]);
- if (!detail) return null;
-
- const months = buildMonthKeys();
- const allowed = new Set(months);
-
- const mensuelTotal: Record = {};
- const mensuelParSite: Record> = {};
- for (const m of months) mensuelTotal[m] = emptyMois(m);
-
- // Mois réellement présents dans les mouvements. Indispensable pour distinguer
- // « pas de mouvement ce mois-là » (→ report du stock précédent) de « stock
- // effectivement nul » — c'est la convention de la Grille.
- const moisAvecDonnees = new Set();
- const moisAvecDonneesParSite = new Map>();
-
- for (const row of mensuelRows) {
- // SQL renvoie "YYYY-MM", la timeline de l'app utilise "YYYYMM".
- const mois = row.mois.replace("-", "");
- if (!allowed.has(mois)) continue;
- const site = String(row.site).trim();
-
- const qte = Number(row.qte_vendue) || 0;
- const ca = Number(row.ca_ht) || 0;
- const marge = Number(row.marge) || 0;
- const stockFinMois = Number(row.stock_fin_mois) || 0;
- const qteRecue = Number(row.qte_recue) || 0;
-
- moisAvecDonnees.add(mois);
- const tot = mensuelTotal[mois];
- tot.qte += qte;
- tot.ca += ca;
- tot.marge += marge;
- tot.stockFinMois += stockFinMois;
- tot.qteRecue += qteRecue;
-
- mensuelParSite[site] ??= Object.fromEntries(months.map((m) => [m, emptyMois(m)]));
- if (!moisAvecDonneesParSite.has(site)) moisAvecDonneesParSite.set(site, new Set());
- moisAvecDonneesParSite.get(site)!.add(mois);
- const cell = mensuelParSite[site][mois];
- cell.qte += qte;
- cell.ca += ca;
- cell.marge += marge;
- // Le SQL donne déjà le stock du dernier mouvement du mois pour ce site.
- cell.stockFinMois = stockFinMois;
- cell.qteRecue += qteRecue;
- }
-
- // Report du stock de fin de mois sur les mois SANS mouvement (carry-forward),
- // même convention que la Grille : un mois sans mouvement conserve le stock du
- // mois précédent, alors qu'un mois avec mouvements et un stock nul reste à 0.
- const carryForward = (serie: Record, avecDonnees: Set) => {
- let last = 0;
- for (const m of months) {
- if (avecDonnees.has(m)) last = serie[m].stockFinMois;
- else serie[m].stockFinMois = last;
- }
- };
- carryForward(mensuelTotal, moisAvecDonnees);
- for (const [site, bySite] of Object.entries(mensuelParSite)) {
- carryForward(bySite, moisAvecDonneesParSite.get(site) ?? new Set());
- }
-
- const totaux = totauxFrom(months.map((m) => mensuelTotal[m]));
- const totauxParSite: Record = {};
- for (const [site, bySite] of Object.entries(mensuelParSite)) {
- totauxParSite[site] = totauxFrom(months.map((m) => bySite[m]));
- }
-
- const sitesActifs = Object.entries(totauxParSite)
- .filter(([, t]) => t.qte > 0)
- .map(([site]) => site)
- .sort();
-
-
- return {
- detail,
- codeCentrale: detail.code_centrale ?? "",
- libelleReseau: reseau?.libelleReseau ?? "",
- fournisseurReseau: reseau?.fournisseurReseau ?? "",
- fournisseurs,
- stock,
- commandesEnCours,
- gammes,
- months,
- mensuelTotal,
- mensuelParSite,
- totaux,
- totauxParSite,
- sitesActifs,
- reseau,
- periode: { dateDebut, dateFin },
- };
-}
diff --git a/src/features/produits/api/search-produits.ts b/src/features/produits/api/search-produits.ts
deleted file mode 100644
index 02c70a5..0000000
--- a/src/features/produits/api/search-produits.ts
+++ /dev/null
@@ -1,445 +0,0 @@
-import "server-only";
-
-import { searchQlikArticles, QLIK_SEARCH_MAX_RESULTS } from "@/lib/qlik-search";
-import type { NetworkMetric } from "@/lib/qlik-client";
-import {
- getNetworkMetricsByCodeCentrale,
- upsertNetworkMetrics,
- type NetworkMetricCached,
-} from "@/lib/qlik-network-cache";
-import { pgGetProduitsByCodeCentrale, pgSearchProduits, type PgProduitSearchRow } from "@/lib/pg-ff-client";
-import { buildRolling12QlikMonths, NB_MAGASINS_RESEAU } from "@/features/grid/lib/network-trend";
-import { normalizeMargePct } from "@/features/produits/lib/compare-reseau";
-import type { ProduitRechercheResultat, ProduitRechercheRow } from "@/features/produits/types";
-
-/**
- * CollectFlow — Recherche produit **Qlik d'abord**, base FF Nancy ensuite.
- *
- * Déroulé :
- * 1. Qlik Sense, **une seule session** : les articles correspondant au terme ET
- * leurs mesures réseau sur 12 mois glissants (`searchQlikArticles`).
- * 2. Base FF Nancy : lesquels référençons-nous ? (`pgGetProduitsByCodeCentrale`)
- * 3. Cache `qlik_network_metrics` : détail mensuel quand une sync l'a déjà
- * extrait (le cube de recherche est agrégé, il ne le fournit pas).
- *
- * Une seconde session Qlik pour les mesures faisait abandonner le moteur
- * (`code 15 — Request aborted`) : deux sessions concurrentes sur la même app,
- * dont une avec une grosse sélection, et l'Engine coupe les requêtes.
- *
- * Si Qlik est injoignable, on se rabat sur la recherche catalogue local pour ne
- * pas laisser l'utilisateur sans résultat — la réponse le signale explicitement
- * (`source: "db"`).
- */
-
-/** Durée de validité d'un résultat de recherche en cache mémoire. */
-const CACHE_TTL_MS = 10 * 60 * 1000;
-
-/** Durée de conservation d'un job terminé (le client a le temps de le relire). */
-const JOB_TTL_MS = 5 * 60 * 1000;
-
-/**
- * Série « magasins vendeurs » extraite du détail mensuel du cache.
- *
- * Un mois PRÉSENT dans le détail est un mois extrait : sans `nbMag`, c'est
- * qu'aucun magasin n'a vendu, donc zéro. Le traiter comme manquant amputerait la
- * série et priverait la tendance de son dénominateur.
- */
-function nbMagParMois(
- metricsByMonth: Record | null | undefined,
-): Record | null {
- if (!metricsByMonth) return null;
- const parMois: Record = {};
- for (const mois of Object.keys(metricsByMonth)) {
- const nb = Number(metricsByMonth[mois]?.nbMag);
- parMois[mois] = Number.isFinite(nb) ? nb : 0;
- }
- return Object.keys(parMois).length > 0 ? parMois : null;
-}
-
-/** Un cache réseau n'est fiable que s'il porte explicitement les 12 mois attendus. */
-function cacheReseauComplet(
- cache: NetworkMetricCached | undefined,
- periode: string | null,
- now: Date = new Date(),
-): cache is NetworkMetricCached {
- const parMois = cache?.qteByMonth;
- if (!parMois || !periode || cache.periode !== periode) return false;
- return buildRolling12QlikMonths(now).every((mois) =>
- Object.prototype.hasOwnProperty.call(parMois, mois) &&
- Number.isFinite(Number(parMois[mois])),
- );
-}
-
-/**
- * Nombre maximum de recherches Qlik simultanées.
- *
- * Le serveur Qlik sature vite (« Out of memory », « Request aborted ») : on
- * plafonne plutôt que de lui envoyer N extractions en parallèle.
- */
-const MAX_RECHERCHES_SIMULTANEES = 1;
-
-/**
- * Cache mémoire des recherches. Une recherche coûte deux allers-retours Qlik
- * (plusieurs secondes chacun) : sans ce cache, un retour arrière du navigateur
- * ou un rafraîchissement relancerait toute l'extraction.
- */
-const cache = new Map();
-
-/**
- * Jobs de recherche, indexés par terme normalisé.
- *
- * Une recherche dure de quelques secondes à plusieurs minutes (deux allers-retours
- * Qlik dont une extraction mensuelle). Une requête HTTP maintenue aussi longtemps
- * se fait couper par le reverse proxy, qui répond une page d'erreur HTML — le
- * client recevait alors « Unexpected token '<' … is not valid JSON ». Le travail
- * tourne donc en tâche de fond et le client interroge l'état.
- */
-const jobs = new Map();
-
-export interface RechercheJob {
- jobId: string;
- terme: string;
- status: "running" | "success" | "error";
- /** Étape en cours, affichée pendant l'attente. */
- etape: string;
- startedAt: string;
- finishedAt?: string;
- error?: string;
- result?: ProduitRechercheResultat;
-}
-
-/** État renvoyé au client : le job, ou `idle` si aucune recherche connue. */
-export type RechercheEtat = RechercheJob | { status: "idle"; terme: string };
-
-function cacheKey(term: string): string {
- return term.trim().toLowerCase().replace(/\s+/g, " ");
-}
-
-/** Purge les entrées expirées (le volume reste faible, un balayage suffit). */
-function purge(): void {
- const now = Date.now();
- for (const [k, v] of cache) {
- if (now - v.at > CACHE_TTL_MS) cache.delete(k);
- }
- for (const [k, j] of jobs) {
- if (j.status !== "running" && j.finishedAt && now - Date.parse(j.finishedAt) > JOB_TTL_MS) jobs.delete(k);
- }
-}
-
-function jobsEnCours(): number {
- let n = 0;
- for (const j of jobs.values()) if (j.status === "running") n++;
- return n;
-}
-
-function jobTermine(terme: string, result: ProduitRechercheResultat): RechercheJob {
- return {
- jobId: `cache_${cacheKey(terme)}`,
- terme,
- status: "success",
- etape: "Terminé",
- startedAt: new Date().toISOString(),
- finishedAt: new Date().toISOString(),
- result,
- };
-}
-
-/**
- * Démarre (ou réutilise) une recherche et rend la main **immédiatement**.
- *
- * - résultat déjà en cache et pas de `force` → job `success` directement ;
- * - recherche déjà en cours sur le même terme → on renvoie ce job ;
- * - sinon on lance le travail en tâche de fond.
- */
-export function demarrerRecherche(
- term: string,
- options: { force?: boolean } = {},
-): RechercheJob {
- const cleaned = term.trim();
- const key = cacheKey(cleaned);
- purge();
-
- if (!options.force) {
- const hit = cache.get(key);
- if (hit) {
- console.log(`[produits/search] "${cleaned}" — servi depuis le cache mémoire`);
- return jobTermine(cleaned, hit.result);
- }
- }
-
- const existant = jobs.get(key);
- if (existant && existant.status === "running") return existant;
- if (existant && !options.force && existant.status === "success" && existant.result) return existant;
-
- if (jobsEnCours() >= MAX_RECHERCHES_SIMULTANEES) {
- return {
- jobId: `refus_${Date.now().toString(36)}`,
- terme: cleaned,
- status: "error",
- etape: "Refusé",
- startedAt: new Date().toISOString(),
- finishedAt: new Date().toISOString(),
- error: "Trop de recherches Qlik en cours. Réessayez dans quelques instants.",
- };
- }
-
- const job: RechercheJob = {
- jobId: `rech_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
- terme: cleaned,
- status: "running",
- etape: "Recherche des articles dans Qlik…",
- startedAt: new Date().toISOString(),
- };
- jobs.set(key, job);
- console.log(`[produits/search] job=${job.jobId} démarré pour "${cleaned}"`);
-
- // Fire-and-forget : le client suivra l'avancement via `etatRecherche`.
- void executerRecherche(cleaned, (etape) => { job.etape = etape; })
- .then((result) => {
- job.result = result;
- job.status = "success";
- job.etape = "Terminé";
- job.finishedAt = new Date().toISOString();
- // On ne met en cache qu'un résultat Qlik exploitable : mémoriser un
- // repli catalogue (panne Qlik passagère) le figerait 10 minutes
- // alors qu'un simple « Relancer » aurait suffi.
- if (result.source === "qlik" && !result.qlikError) {
- cache.set(key, { at: Date.now(), result });
- }
- console.log(`[produits/search] job=${job.jobId} terminé — ${result.rows.length} produit(s) en ${result.dureeMs} ms`);
- })
- .catch((e) => {
- const message = e instanceof Error ? e.message : String(e);
- job.status = "error";
- job.etape = "Échec";
- job.error = messageQlikLisible(message);
- job.finishedAt = new Date().toISOString();
- console.error(`[produits/search] job=${job.jobId} échec :`, message.slice(0, 300));
- });
-
- return job;
-}
-
-/** État courant de la recherche pour ce terme (pour le polling client). */
-export function etatRecherche(term: string): RechercheEtat {
- const cleaned = term.trim();
- const key = cacheKey(cleaned);
- purge();
- const job = jobs.get(key);
- if (job) return job;
- const hit = cache.get(key);
- if (hit) return jobTermine(cleaned, hit.result);
- return { status: "idle", terme: cleaned };
-}
-
-async function executerRecherche(
- term: string,
- onEtape: (etape: string) => void = () => {},
-): Promise {
- const started = Date.now();
-
- // La recherche catalogue local tourne en parallèle : elle sert à la fois de
- // repli si Qlik échoue, et de complément (produits Nancy sans code centrale,
- // donc invisibles côté réseau).
- const localPromise = pgSearchProduits(term).catch((e) => {
- console.error("[produits/search] recherche locale échouée:", (e as Error).message);
- return [] as PgProduitSearchRow[];
- });
-
- let qlik;
- try {
- onEtape("Recherche des articles dans Qlik…");
- qlik = await searchQlikArticles(term, QLIK_SEARCH_MAX_RESULTS);
- } catch (e) {
- const message = e instanceof Error ? e.message : String(e);
- console.error("[produits/search] Qlik indisponible, repli catalogue local:", message);
- const locaux = await localPromise;
- return {
- rows: locaux.map(rowDepuisCatalogueSeul),
- source: "db",
- qlikError: messageQlikLisible(message),
- tronque: locaux.length >= 50,
- champUtilise: null,
- locauxHorsReseau: [],
- dureeMs: Date.now() - started,
- };
- }
-
- const codes = qlik.matches.map((m) => m.codeCentrale);
- if (codes.length === 0) {
- const locaux = await localPromise;
- return {
- rows: [],
- source: "qlik",
- // `avertissement` n'est renseigné que si Qlik a répondu sans appliquer
- // le filtre : l'utilisateur doit savoir que ce n'est pas « pas de
- // produit » mais « recherche non appliquée ».
- qlikError: qlik.avertissement,
- tronque: false,
- champUtilise: qlik.champUtilise,
- locauxHorsReseau: locaux,
- dureeMs: Date.now() - started,
- };
- }
-
- // Les mesures réseau sortent DÉJÀ du cube de recherche (même session Qlik).
- // Les extraire dans une seconde session concurrente faisait abandonner le
- // moteur (`code 15 — Request aborted`) : c'est ce qui faisait « planter » la
- // recherche alors que la sync de la Grille, elle seule sur le serveur,
- // fonctionnait.
- //
- // Reste à récupérer le détail mensuel — indisponible dans ce cube. On le lit
- // dans le cache alimenté par les syncs fournisseur ; s'il manque, la fiche
- // produit propose son bouton « Actualiser depuis Qlik ».
- onEtape("Rapprochement avec notre catalogue…");
- const [cacheReseau, catalogue, locaux] = await Promise.all([
- getNetworkMetricsByCodeCentrale(codes).catch((e) => {
- console.error("[produits/search] lecture du cache réseau échouée:", (e as Error).message);
- return new Map();
- }),
- // Deux clés candidates : la dimension « Article Code » et le champ
- // `article_no_centrale`. Sur l'app FF elles n'ont pas le même format et
- // une seule joint avec `articles.artcentrale`.
- pgGetProduitsByCodeCentrale([...codes, ...qlik.matches.map((m) => m.codeCentraleAlt).filter(Boolean)]),
- localPromise,
- ]);
-
- // Le cube de recherche utilise encore les master measures annuelles pour
- // classer rapidement les résultats. Il ne doit jamais écraser une extraction
- // 12 mois déjà vérifiée : dans ce cas on republie les valeurs du cache avec
- // leur mensuel. Sans cache complet, les valeurs de découverte restent
- // temporaires jusqu'au bouton « Actualiser depuis Qlik ».
- try {
- const aPersister: NetworkMetric[] = qlik.matches.map((m) => {
- const cache = cacheReseau.get(m.codeCentrale);
- const fiable = cacheReseauComplet(cache, qlik.periode);
- return {
- codeCentrale: m.codeCentrale,
- caReseau: fiable ? cache.caReseau : m.caReseau,
- qteReseau: fiable ? cache.qteReseau : m.qteReseau,
- nbMagasinsReseau: fiable ? cache.nbMagasinsReseau : m.nbMagasinsReseau,
- caParMagasinReseau: fiable ? cache.caParMagasinReseau : m.caParMagasinReseau,
- margePctReseau: fiable ? cache.margePctReseau : m.margePctReseau,
- periode: fiable ? cache.periode ?? undefined : qlik.periode ?? undefined,
- qteByMonth: fiable ? cache.qteByMonth ?? undefined : undefined,
- metricsByMonth: fiable ? cache.metricsByMonth ?? undefined : undefined,
- libelleReseau: m.libelle || undefined,
- fournisseurReseau: m.fournisseur || undefined,
- };
- });
- const n = await upsertNetworkMetrics(aPersister);
- console.log(`[produits/search] ${n} ligne(s) réseau mises en cache`);
- } catch (e) {
- console.error("[produits/search] mise en cache des mesures échouée:", (e as Error).message);
- }
-
- const rows: ProduitRechercheRow[] = qlik.matches.map((m) => {
- const local = catalogue.get(m.codeCentrale) ?? (m.codeCentraleAlt ? catalogue.get(m.codeCentraleAlt) : undefined);
- const cache = cacheReseau.get(m.codeCentrale);
- const fiable = cacheReseauComplet(cache, qlik.periode);
- const qteReseau = fiable ? cache.qteReseau : m.qteReseau;
- const caReseau = fiable ? cache.caReseau : m.caReseau;
- const nbMag = fiable ? cache.nbMagasinsReseau : m.nbMagasinsReseau;
- const caParMagasin = fiable ? cache.caParMagasinReseau : m.caParMagasinReseau;
- const margePct = fiable ? cache.margePctReseau : m.margePctReseau;
- return {
- codeCentrale: m.codeCentrale,
- libelle: local?.libelle1 || m.libelle || m.codeCentrale,
- libelleReseau: m.libelle,
- fournisseur: local?.fournisseur || m.fournisseur || "",
- codein: local?.codein ?? null,
- nomenclature: local?.nomenclature ?? "",
- stockLocal: local ? Number(local.stock_total) || 0 : null,
- qteReseau,
- caReseau,
- nbMagasinsReseau: nbMag,
- tauxPresence: nbMag / NB_MAGASINS_RESEAU,
- qteParMagasinReseau: nbMag > 0 ? qteReseau / nbMag : 0,
- caParMagasinReseau: caParMagasin,
- prixMoyenReseau: qteReseau > 0 ? caReseau / qteReseau : null,
- margePctReseau: normalizeMargePct(margePct),
- // Le mensuel ne vient que du cache : le cube de recherche est agrégé.
- qteByMonth: fiable ? cache.qteByMonth : null,
- nbMagByMonth: fiable ? nbMagParMois(cache.metricsByMonth) : null,
- periode: qlik.periode,
- };
- });
-
- // Les plus vendus du réseau d'abord : c'est l'information utile pour
- // arbitrer, un produit que le réseau ne vend pas n'intéresse personne.
- rows.sort((a, b) => b.qteReseau - a.qteReseau || a.libelle.localeCompare(b.libelle, "fr"));
-
- // Les produits Nancy déjà couverts par un résultat réseau ne doivent pas
- // réapparaître dans la liste secondaire. On compare sur les deux clés
- // candidates, la jointure pouvant se faire par l'une ou par l'autre.
- const codesTrouves = new Set(codes);
- for (const m of qlik.matches) if (m.codeCentraleAlt) codesTrouves.add(m.codeCentraleAlt);
- const locauxHorsReseau = locaux.filter((l) => !l.code_centrale || !codesTrouves.has(l.code_centrale));
-
- // Diagnostic de la jointure : 0 rapprochement sur 40 codes signale un format
- // de clé différent entre Qlik et `articles.artcentrale`.
- if (catalogue.size === 0 && codes.length > 0) {
- console.warn(
- `[produits/search] aucun des ${codes.length} codes Qlik ne joint avec articles.artcentrale — ` +
- `échantillon Article Code=${JSON.stringify(codes.slice(0, 3))} ` +
- `article_no_centrale=${JSON.stringify(qlik.matches.slice(0, 3).map((m) => m.codeCentraleAlt))}`,
- );
- }
-
- return {
- rows,
- source: "qlik",
- qlikError: qlik.avertissement,
- tronque: qlik.tronque,
- champUtilise: qlik.champUtilise,
- locauxHorsReseau,
- dureeMs: Date.now() - started,
- };
-}
-
-/** Ligne de repli : catalogue Nancy seul, sans données réseau fiables. */
-function rowDepuisCatalogueSeul(r: PgProduitSearchRow): ProduitRechercheRow {
- const qteReseau = Number(r.qte_reseau) || 0;
- const nbMag = Number(r.nb_magasins_reseau) || 0;
- return {
- codeCentrale: r.code_centrale,
- libelle: r.libelle1 || r.codein,
- libelleReseau: "",
- fournisseur: r.fournisseur,
- codein: r.codein,
- nomenclature: r.nomenclature,
- stockLocal: Number(r.stock_total) || 0,
- qteReseau,
- caReseau: 0,
- nbMagasinsReseau: nbMag,
- tauxPresence: nbMag / NB_MAGASINS_RESEAU,
- qteParMagasinReseau: nbMag > 0 ? qteReseau / nbMag : 0,
- caParMagasinReseau: 0,
- prixMoyenReseau: null,
- margePctReseau: null,
- qteByMonth: null,
- nbMagByMonth: null,
- periode: null,
- };
-}
-
-/**
- * Traduit les pannes Qlik récurrentes en message actionnable. Les autres
- * erreurs sont renvoyées telles quelles (tronquées) pour rester diagnosticables.
- */
-function messageQlikLisible(message: string): string {
- const lower = message.toLowerCase();
- if (lower.includes("out of memory") || lower.includes("not enough memory") || lower.includes('"code":6') || lower.includes('"code":3002')) {
- return "Serveur Qlik saturé : mémoire insuffisante pour charger l'application. Réessayez plus tard.";
- }
- if (/"code"\s*:\s*15\b/.test(message) || lower.includes("request aborted")) {
- return "Qlik a interrompu la requête (recherche trop large pour le moteur). Ajoutez un mot plus précis, puis relancez.";
- }
- if (lower.includes("identifiants qlik manquants") || lower.includes("qlik_user")) {
- return "Identifiants Qlik non configurés (Paramètres → Qlik).";
- }
- if (lower.includes("timeout") || lower.includes("econnrefused") || lower.includes("enotfound")) {
- return "Serveur Qlik injoignable depuis CollectFlow (réseau ou VPN).";
- }
- return message.slice(0, 300);
-}
diff --git a/src/features/produits/types.ts b/src/features/produits/types.ts
index 4aeb292..b070138 100644
--- a/src/features/produits/types.ts
+++ b/src/features/produits/types.ts
@@ -8,8 +8,8 @@ import type {
PgProduitSearchRow,
PgProduitStockRow,
PgGammeHistoryRow,
-} from "@/lib/pg-ff-client";
-import type { NetworkMetricCached } from "@/lib/qlik-network-cache";
+ NetworkMetricCached,
+} from "@/types/ff";
/**
* Une ligne de résultat de recherche produit.
diff --git a/src/features/qlik-sync/use-qlik-sync-job.ts b/src/features/qlik-sync/use-qlik-sync-job.ts
index a2a0fa3..614131a 100644
--- a/src/features/qlik-sync/use-qlik-sync-job.ts
+++ b/src/features/qlik-sync/use-qlik-sync-job.ts
@@ -1,5 +1,3 @@
-"use client";
-
import { useCallback, useEffect, useRef, useState } from "react";
/** État serveur renvoyé par GET/POST /api/qlik/sync. */
diff --git a/src/features/settings/actions.ts b/src/features/settings/actions.ts
index dea37f4..fb51b72 100644
--- a/src/features/settings/actions.ts
+++ b/src/features/settings/actions.ts
@@ -1,17 +1,14 @@
-"use server";
-
/**
- * Actions des Paramètres — réservées aux administrateurs.
+ * Actions des Paramètres — réservées aux administrateurs, exécutées par le
+ * serveur Rust : `POST /api/actions/{nom}`.
*
* Aucun secret ne repart vers le navigateur : les mots de passe (base, Qlik) et
* les clés d'IA restent dans `data/.db-config.json`. Un mot de passe laissé vide
* dans le formulaire signifie « conserver celui qui est enregistré ».
*/
-import { Pool } from "pg";
-import { requireAdmin, verifierAdmin } from "@/lib/authz";
-import { CONFIG_FILE, readConfig, writeConfig } from "./config-file";
-import { diagnostiquerApiFf } from "./ff-api-diagnostic";
+import { callAction } from "@/lib/rpc";
+import type { FfSyncStatus } from "@/types/ff";
export interface ChampsBaseDeDonnees {
host: string;
@@ -37,181 +34,45 @@ export interface ParametresAffichables {
ffApiBaseUrl: string;
}
-/** Décode un composant d'URL, ou le garde tel quel s'il n'est pas encodé proprement. */
-function decoder(valeur: string): string {
- try {
- return decodeURIComponent(valeur);
- } catch {
- return valeur;
- }
+export interface ResultatAction {
+ success: boolean;
+ error?: string;
}
-/** Découpe l'URL `postgres://` enregistrée en champs du formulaire. */
-function lireUrlPostgres(url: string) {
- try {
- const u = new URL(url);
- return {
- host: u.hostname,
- port: u.port || "5432",
- database: decoder(u.pathname.slice(1)),
- user: decoder(u.username),
- password: decoder(u.password),
- ssl: url.includes("sslmode=require"),
- };
- } catch (e) {
- console.error("[Settings] URL de base enregistrée illisible :", (e as Error).message);
- return null;
- }
-}
-
-function construireUrlPostgres(champs: ChampsBaseDeDonnees, motDePasse: string): string {
- const user = encodeURIComponent(champs.user.trim());
- const identifiants = motDePasse ? `${user}:${encodeURIComponent(motDePasse)}` : user;
- const port = champs.port.trim() || "5432";
- return `postgres://${identifiants}@${champs.host.trim()}:${port}/${champs.database.trim()}${champs.ssl ? "?sslmode=require" : ""}`;
-}
-
-/** Mot de passe saisi, sinon celui de l'URL enregistrée. */
-async function motDePasseBase(champs: ChampsBaseDeDonnees): Promise {
- if (champs.password) return champs.password;
- const { url } = await readConfig();
- return (url && lireUrlPostgres(url)?.password) || "";
-}
+/** Diagnostic de l'API FF Nancy (bouton « Tester »). */
+export type DiagnosticApiFf =
+ | { success: true; url: string; ms: number; status: FfSyncStatus }
+ | { success: false; url: string; error: string };
/** Réglages enregistrés, sans aucun secret. */
export async function getParametresAffichables(): Promise {
- await requireAdmin();
- const config = await readConfig();
- const base = config.url ? lireUrlPostgres(config.url) : null;
- return {
- db: base
- ? {
- host: base.host,
- port: base.port,
- database: base.database,
- user: base.user,
- ssl: base.ssl,
- motDePasseEnregistre: base.password !== "",
- }
- : null,
- qlik: {
- host: config.qlikHost ?? "",
- user: config.qlikUser ?? "",
- // Même ordre de priorité que getQlikConfig() : réglage enregistré, puis variable d'environnement.
- motDePasseEnregistre: Boolean(config.qlikPassword || process.env.QLIK_PWD),
- },
- ffApiBaseUrl: config.ffApiBaseUrl ?? "",
- };
+ return callAction("getParametresAffichables", []);
}
-export async function testDatabaseConnection(champs: ChampsBaseDeDonnees) {
- const acces = await verifierAdmin();
- if (!acces.ok) return { success: false, error: acces.message };
-
- const url = construireUrlPostgres(champs, await motDePasseBase(champs));
- console.log("Testing connection to:", url.replace(/:([^@]+)@/, ":****@"));
- const pool = new Pool({
- connectionString: url,
- connectionTimeoutMillis: 5000,
- });
-
- try {
- const client = await pool.connect();
- await client.query("SELECT 1");
- client.release();
- return { success: true };
- } catch (error: unknown) {
- const errorMessage = error instanceof Error ? error.message : String(error);
- console.error("Database connection test failed:", errorMessage);
- return { success: false, error: errorMessage };
- } finally {
- await pool.end();
- }
+export async function testDatabaseConnection(champs: ChampsBaseDeDonnees): Promise {
+ return callAction("testDatabaseConnection", [champs]);
}
-export async function saveDatabaseSettings(champs: ChampsBaseDeDonnees) {
- const acces = await verifierAdmin();
- if (!acces.ok) return { success: false, error: acces.message };
-
- try {
- const url = construireUrlPostgres(champs, await motDePasseBase(champs));
- // Seule l'URL change : les clés d'IA et les réglages Qlik / API FF sont conservés.
- console.log(`[Settings] Saving config to ${CONFIG_FILE}`);
- await writeConfig({ url });
- console.log("[Settings] Database configuration saved successfully.");
-
- // Refresh the shared DB instance immediately
- const { refreshDb } = await import("@/db");
- refreshDb();
-
- return { success: true };
- } catch (error: unknown) {
- const errorMessage = error instanceof Error ? error.message : String(error);
- console.error("Failed to save database configuration:", errorMessage);
- return { success: false, error: errorMessage };
- }
+export async function saveDatabaseSettings(champs: ChampsBaseDeDonnees): Promise {
+ return callAction("saveDatabaseSettings", [champs]);
}
/** Mot de passe vide ou absent : celui qui est enregistré est conservé. */
-export async function saveQlikSettings(qlikHost: string, qlikUser: string, qlikPassword?: string) {
- const acces = await verifierAdmin();
- if (!acces.ok) return { success: false, error: acces.message };
-
- try {
- await writeConfig({ qlikHost, qlikUser, ...(qlikPassword ? { qlikPassword } : {}) });
- console.log("[Settings] Qlik configuration saved.");
- return { success: true };
- } catch (error: unknown) {
- const msg = error instanceof Error ? error.message : String(error);
- console.error("[Settings] Failed to save Qlik config:", msg);
- return { success: false, error: msg };
- }
+export async function saveQlikSettings(qlikHost: string, qlikUser: string, qlikPassword?: string): Promise {
+ return callAction("saveQlikSettings", [qlikHost, qlikUser, qlikPassword]);
}
/** Mot de passe vide ou absent : on teste avec celui qui est enregistré. */
-export async function testQlikConnection(qlikHost: string, qlikUser: string, qlikPassword?: string) {
- const acces = await verifierAdmin();
- if (!acces.ok) return { success: false, error: acces.message };
-
- try {
- const { getQlikConfig, qlikNtlmSession } = await import("@/lib/qlik-client");
- const enregistre = getQlikConfig();
- const cfg = { ...enregistre, user: qlikUser, password: qlikPassword || enregistre.password };
- if (qlikHost) cfg.host = qlikHost;
- await qlikNtlmSession(cfg);
- return { success: true };
- } catch (error: unknown) {
- const msg = error instanceof Error ? error.message : String(error);
- return { success: false, error: msg };
- }
+export async function testQlikConnection(qlikHost: string, qlikUser: string, qlikPassword?: string): Promise {
+ return callAction("testQlikConnection", [qlikHost, qlikUser, qlikPassword]);
}
/** Enregistre l'URL de l'API FF Nancy. Chaîne vide = revenir au défaut. */
-export async function saveFfApiSettings(ffApiBaseUrl: string) {
- const acces = await verifierAdmin();
- if (!acces.ok) return { success: false, error: acces.message };
-
- try {
- const cleaned = ffApiBaseUrl.trim().replace(/\/+$/, "");
- if (cleaned && !/^https?:\/\//i.test(cleaned)) {
- return { success: false, error: "L'URL doit commencer par http:// ou https://" };
- }
- await writeConfig({ ffApiBaseUrl: cleaned || undefined });
- // Sans cela, l'ancienne URL resterait servie jusqu'à 30 s après la sauvegarde.
- const { resetFfApiBaseCache } = await import("@/lib/api-ff-client");
- resetFfApiBaseCache();
- console.log(`[Settings] FF API base URL saved: ${cleaned || "(défaut)"}`);
- return { success: true };
- } catch (error: unknown) {
- const msg = error instanceof Error ? error.message : String(error);
- console.error("[Settings] Failed to save FF API config:", msg);
- return { success: false, error: msg };
- }
+export async function saveFfApiSettings(ffApiBaseUrl: string): Promise {
+ return callAction("saveFfApiSettings", [ffApiBaseUrl]);
}
-/** Teste l'API FF Nancy (voir `diagnostiquerApiFf`). */
-export async function testFfApiConnection(ffApiBaseUrl?: string): Promise>> {
- const acces = await verifierAdmin();
- if (!acces.ok) return { success: false, url: "", error: acces.message };
- return diagnostiquerApiFf(ffApiBaseUrl);
+/** Teste l'API FF Nancy (diagnostic détaillé : DNS, refus, délai, code HTTP). */
+export async function testFfApiConnection(ffApiBaseUrl?: string): Promise {
+ return callAction("testFfApiConnection", [ffApiBaseUrl]);
}
diff --git a/src/features/settings/components/server-logs.tsx b/src/features/settings/components/server-logs.tsx
index 21c53a5..e2f2588 100644
--- a/src/features/settings/components/server-logs.tsx
+++ b/src/features/settings/components/server-logs.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useCallback, useEffect, useState } from "react";
import { Download, Loader2, RefreshCw, FileText } from "lucide-react";
import { Card, CardContent, CardHeader } from "@/components/ui/card";
diff --git a/src/features/settings/config-file.ts b/src/features/settings/config-file.ts
deleted file mode 100644
index b9745bb..0000000
--- a/src/features/settings/config-file.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- * CollectFlow — Fichier de configuration `data/.db-config.json`.
- *
- * Module **serveur**, pas fichier d'actions : ses fonctions ne doivent pas être
- * appelables depuis le navigateur (le fichier contient des mots de passe et des
- * clés d'API). Les actions de `./actions.ts` les utilisent après contrôle du rôle.
- */
-
-import "server-only";
-
-import fs from "fs/promises";
-import path from "path";
-
-export const DATA_DIR = path.join(process.cwd(), "data");
-export const CONFIG_FILE = path.join(DATA_DIR, ".db-config.json");
-
-export interface DbConfig {
- url: string;
- openRouterKey?: string;
- openRouterModel?: string;
- aiProvider?: "openrouter" | "google";
- googleAiKey?: string;
- googleAiModel?: string;
- /** Qlik Sense — données réseau */
- qlikHost?: string;
- qlikUser?: string;
- qlikPassword?: string;
- /**
- * API REST FF Nancy (ex. https://api.ffnancy.fr). Sert au panneau de statut et
- * au rattrapage des ventes par magasin dans la Grille. Configurable ici pour
- * ne pas dépendre d'une variable d'environnement qu'on ne peut pas changer
- * sans redéployer.
- */
- ffApiBaseUrl?: string;
-}
-
-/** Lit la config existante (ou {} si absente). */
-export async function readConfig(): Promise> {
- try {
- const data = await fs.readFile(CONFIG_FILE, "utf-8");
- return JSON.parse(data);
- } catch {
- return {};
- }
-}
-
-/**
- * Fusionne `patch` dans la config enregistrée : les clés absentes du patch sont
- * conservées telles quelles (une clé passée à `undefined` est retirée).
- */
-export async function writeConfig(patch: Partial): Promise {
- const existing = await readConfig();
- await fs.mkdir(DATA_DIR, { recursive: true });
- await fs.writeFile(CONFIG_FILE, JSON.stringify({ ...existing, ...patch }, null, 2));
-}
diff --git a/src/features/settings/ff-api-diagnostic.ts b/src/features/settings/ff-api-diagnostic.ts
deleted file mode 100644
index 50409a9..0000000
--- a/src/features/settings/ff-api-diagnostic.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-/**
- * CollectFlow — Diagnostic de l'API FF Nancy.
- *
- * Partagé par le bouton « Tester » des Paramètres (administrateurs) et par la
- * route `/api/ff-status` (tout utilisateur connecté). Module serveur et non
- * fichier d'actions : chaque appelant fait son propre contrôle d'accès.
- */
-
-import "server-only";
-
-import { readConfig } from "./config-file";
-
-/**
- * Teste l'API FF Nancy et renvoie un diagnostic **exploitable**.
- *
- * L'ancien panneau se contentait d'un « HTTP 503 » opaque : impossible de savoir
- * si l'hôte était injoignable, l'URL erronée ou le service en panne. On distingue
- * donc ici l'échec réseau (DNS, refus de connexion, délai dépassé) du code HTTP.
- */
-export async function diagnostiquerApiFf(ffApiBaseUrl?: string) {
- const base = (ffApiBaseUrl?.trim() || (await readConfig()).ffApiBaseUrl || process.env.FF_API_BASE_URL || "https://api.ffnancy.fr").replace(/\/+$/, "");
- const url = `${base}/api/sync/status`;
- const started = Date.now();
- try {
- const res = await fetch(url, {
- cache: "no-store",
- signal: AbortSignal.timeout(8000),
- });
- const ms = Date.now() - started;
- if (!res.ok) {
- return { success: false, url, error: `Le serveur a répondu HTTP ${res.status} (${res.statusText || "sans message"}) en ${ms} ms.` };
- }
- const body = await res.json().catch(() => null);
- if (!body) {
- return { success: false, url, error: `Réponse HTTP 200 mais corps illisible (JSON attendu).` };
- }
- // La réponse brute de l'API n'a pas la forme attendue par l'interface :
- // sans cette normalisation, le panneau s'affiche vide malgré un HTTP 200.
- const { normalizeSyncStatus } = await import("@/lib/api-ff-client");
- const status = normalizeSyncStatus(body);
- if (!status) {
- return { success: false, url, error: `Réponse HTTP 200 mais format inattendu (ni « sync » ni « tables »).` };
- }
- return { success: true, url, ms, status };
- } catch (error: unknown) {
- const ms = Date.now() - started;
- const raw = error instanceof Error ? error.message : String(error);
- const name = error instanceof Error ? error.name : "";
- // fetch masque la cause réelle derrière « fetch failed » : on la déplie.
- const cause = (error as { cause?: { code?: string; message?: string } })?.cause;
- let hint = raw;
- if (name === "TimeoutError" || name === "AbortError") {
- hint = `Aucune réponse en ${ms} ms — serveur injoignable ou trop lent.`;
- } else if (cause?.code === "ENOTFOUND") {
- hint = `Nom d'hôte introuvable (DNS) — vérifiez l'URL.`;
- } else if (cause?.code === "ECONNREFUSED") {
- hint = `Connexion refusée — le service n'écoute pas sur cette adresse.`;
- } else if (cause?.code) {
- hint = `${cause.code}${cause.message ? ` — ${cause.message}` : ""}`;
- }
- console.error(`[Settings] FF API test KO (${url}):`, raw);
- return { success: false, url, error: hint };
- }
-}
diff --git a/src/features/settings/store/use-db-settings-store.ts b/src/features/settings/store/use-db-settings-store.ts
index 3afdba7..990870c 100644
--- a/src/features/settings/store/use-db-settings-store.ts
+++ b/src/features/settings/store/use-db-settings-store.ts
@@ -1,5 +1,3 @@
-"use client";
-
import { create } from "zustand";
import { persist } from "zustand/middleware";
diff --git a/src/features/snapshots/api/delete-snapshot.ts b/src/features/snapshots/api/delete-snapshot.ts
index 09ce9de..1b4fd73 100644
--- a/src/features/snapshots/api/delete-snapshot.ts
+++ b/src/features/snapshots/api/delete-snapshot.ts
@@ -1,39 +1,10 @@
-"use server";
+/**
+ * Suppression d'un enregistrement de l'historique — action exécutée par le
+ * serveur Rust : `POST /api/actions/deleteSnapshot`.
+ */
-import { db } from "@/db";
-import { sessionSnapshots } from "@/db/schema";
-import { and, eq, isNull } from "drizzle-orm";
-import { verifierSession } from "@/lib/authz";
+import { callAction } from "@/lib/rpc";
-export async function deleteSnapshot(id: number) {
- const acces = await verifierSession();
- if (!acces.ok) return { success: false, error: acces.message };
-
- const rawUserId = acces.utilisateur.id;
- const userId = rawUserId ? parseInt(rawUserId, 10) : null;
-
- console.log(`[deleteSnapshot] Request for ID: ${id}, Session UserId: ${userId}`);
-
- try {
- // Condition de sécurité : match ID ET match le propriétaire (ou anonyme)
- const userCondition = userId && !isNaN(userId)
- ? eq(sessionSnapshots.userId, userId)
- : isNull(sessionSnapshots.userId);
-
- const result = await db.delete(sessionSnapshots)
- .where(and(eq(sessionSnapshots.id, id), userCondition))
- .returning({ deletedId: sessionSnapshots.id });
-
- if (result.length === 0) {
- console.warn(`[deleteSnapshot] No rows deleted for ID ${id}. Snapshot may not exist or belongs to another user.`);
- return { success: false, error: "Snapshot non trouvé ou non autorisé" };
- }
-
- console.log(`[deleteSnapshot] Successfully deleted ID: ${id}`);
- return { success: true };
- } catch (err) {
- // Le détail technique reste dans les journaux du serveur.
- console.error("[deleteSnapshot] DB Error:", err);
- return { success: false, error: "erreur technique sur le serveur" };
- }
+export async function deleteSnapshot(id: number): Promise<{ success: boolean; error?: string }> {
+ return callAction("deleteSnapshot", [id]);
}
diff --git a/src/features/snapshots/api/get-snapshots.ts b/src/features/snapshots/api/get-snapshots.ts
index e636a2b..8d6c84f 100644
--- a/src/features/snapshots/api/get-snapshots.ts
+++ b/src/features/snapshots/api/get-snapshots.ts
@@ -1,34 +1,26 @@
-"use server";
+/**
+ * Historique des sessions de révision et des exports — action exécutée par le
+ * serveur Rust : `POST /api/actions/getSnapshots`.
+ */
-import { db } from "@/db";
-import { sessionSnapshots } from "@/db/schema";
-import { requireSession } from "@/lib/authz";
-import { and, desc, eq, isNull } from "drizzle-orm";
+import { callAction } from "@/lib/rpc";
-export async function getSnapshots(type?: "snapshot" | "export") {
- const utilisateur = await requireSession();
- try {
- const rawUserId = utilisateur.id;
- const userId = rawUserId ? parseInt(rawUserId, 10) : null;
+/** Une ligne de `session_snapshots`, telle que le serveur la renvoie. */
+export interface SnapshotRow {
+ id: number;
+ userId: number | null;
+ codeFournisseur: string;
+ nomFournisseur: string | null;
+ magasin: string;
+ /** codein → { before, after } */
+ changes: unknown;
+ summaryJson: unknown;
+ label: string | null;
+ type: string | null;
+ /** Date ISO de création. */
+ createdAt: string | null;
+}
- // Si on a un userId, on filtre par celui-ci.
- // Sinon, on filtre par userId IS NULL (mode anonyme/local)
- const userCondition = userId && !isNaN(userId)
- ? eq(sessionSnapshots.userId, userId)
- : isNull(sessionSnapshots.userId);
-
- const conditions = [userCondition];
- if (type) conditions.push(eq(sessionSnapshots.type, type));
-
- return await db.select()
- .from(sessionSnapshots)
- .where(and(...conditions))
- .orderBy(desc(sessionSnapshots.createdAt));
- } catch (err) {
- const msg = ((err as Error)?.message || String(err)).split("\n")[0];
- console.error(`[getSnapshots] ERROR (type=${type}):`, msg, err);
- // Remonter l'erreur : une liste vide faisait afficher « Aucun snapshot »
- // au lieu de signaler que le chargement a échoué.
- throw new Error("Chargement de l'historique impossible.");
- }
+export async function getSnapshots(type?: "snapshot" | "export"): Promise {
+ return callAction("getSnapshots", [type]);
}
diff --git a/src/features/snapshots/api/save-snapshot.ts b/src/features/snapshots/api/save-snapshot.ts
index 81445fc..0b30d7e 100644
--- a/src/features/snapshots/api/save-snapshot.ts
+++ b/src/features/snapshots/api/save-snapshot.ts
@@ -1,114 +1,27 @@
-"use server";
+/**
+ * Enregistrement d'une session de révision ou d'un export — action exécutée par
+ * le serveur Rust : `POST /api/actions/saveSnapshot` (validation des données
+ * comprise).
+ */
-import { db } from "@/db";
-import { sessionSnapshots } from "@/db/schema";
-import { z } from "zod";
-import { sql, and, eq } from "drizzle-orm";
-import { verifierSession } from "@/lib/authz";
-import { revalidatePath } from "next/cache";
+import { callAction } from "@/lib/rpc";
-const SaveSnapshotSchema = z.object({
- codeFournisseur: z.string(),
- nomFournisseur: z.string().optional(),
- magasin: z.string(),
- label: z.string().optional(),
- changes: z.record(z.string(), z.object({
- before: z.string().nullable(),
- after: z.string(),
- })),
- type: z.enum(["snapshot", "export"]).optional(),
- summary: z.object({
- totalRows: z.number(),
- totalCa: z.number(),
- totalMarge: z.number(),
- tauxMargeGlobal: z.number(),
- }).optional(),
-});
-
-export async function saveSnapshot(raw: unknown) {
- const acces = await verifierSession();
- if (!acces.ok) return { success: false, error: acces.message };
-
- const parsed = SaveSnapshotSchema.safeParse(raw);
- if (!parsed.success) {
- console.error("Snapshot validation failed:", parsed.error.format());
- return { success: false, error: "Validation failed: " + parsed.error.issues.map((i: any) => i.message).join(", ") };
- }
-
- const { codeFournisseur, nomFournisseur, magasin, label, changes, summary, type } = parsed.data;
- const rawUserId = acces.utilisateur.id;
- const userId = rawUserId ? parseInt(rawUserId, 10) : null;
-
- console.log(`[saveSnapshot] User: ${userId} (raw: ${rawUserId}), Supplier: ${codeFournisseur}, Type: ${type}`);
-
- const finalUserId = (userId && !isNaN(userId)) ? userId : null;
-
- try {
- const [created] = await db
- .insert(sessionSnapshots)
- .values({
- userId: finalUserId,
- codeFournisseur,
- nomFournisseur: nomFournisseur ?? null,
- magasin,
- label: label ?? `${type === 'export' ? 'Export' : 'Snapshot'} — ${new Date().toLocaleDateString("fr-FR")}`,
- changes,
- summaryJson: summary ?? null,
- type: type ?? "snapshot",
- })
- .returning({ id: sessionSnapshots.id });
-
- revalidatePath("/snapshots");
- revalidatePath("/exports");
- return { success: true, snapshotId: created?.id };
- } catch (err) {
- console.error("Initial snapshot save failed, attempting auto-repair...", err);
-
- try {
- // Tentative systématique de création de table (no-op si déjà là)
- await db.execute(sql`
- CREATE TABLE IF NOT EXISTS session_snapshots (
- id SERIAL PRIMARY KEY,
- user_id INTEGER,
- code_fournisseur VARCHAR(20) NOT NULL,
- nom_fournisseur VARCHAR(255),
- magasin VARCHAR(20) NOT NULL,
- changes JSONB NOT NULL,
- summary_json JSONB,
- label TEXT,
- type VARCHAR(20) DEFAULT 'snapshot',
- created_at TIMESTAMP DEFAULT NOW()
- );
- `);
-
- // Si la table existait déjà mais sans la colonne 'type' ou 'user_id', on les ajoute
- try {
- await db.execute(sql`ALTER TABLE session_snapshots ADD COLUMN IF NOT EXISTS type VARCHAR(20) DEFAULT 'snapshot'`);
- await db.execute(sql`ALTER TABLE session_snapshots ADD COLUMN IF NOT EXISTS user_id INTEGER`);
- } catch (e) {
- // Ignore
- }
-
- // Deuxième tentative d'insertion
- const [retryCreated] = await db
- .insert(sessionSnapshots)
- .values({
- userId: finalUserId,
- codeFournisseur,
- nomFournisseur: nomFournisseur ?? null,
- magasin,
- label: label ?? `${type === 'export' ? 'Export' : 'Snapshot'} — ${new Date().toLocaleDateString("fr-FR")}`,
- changes,
- summaryJson: summary ?? null,
- type: type ?? "snapshot",
- })
- .returning({ id: sessionSnapshots.id });
-
- return { success: true, snapshotId: retryCreated?.id };
- } catch (repairErr) {
- // Le détail technique (les deux erreurs) reste dans les journaux du serveur.
- console.error("Snapshot auto-repair/retry failed:", repairErr);
- return { success: false, error: "erreur technique sur le serveur" };
- }
- }
+/** Données attendues par le serveur (ex-schéma zod `SaveSnapshotSchema`). */
+export interface SaveSnapshotInput {
+ codeFournisseur: string;
+ nomFournisseur?: string;
+ magasin: string;
+ label?: string;
+ changes: Record;
+ type?: "snapshot" | "export";
+ summary?: {
+ totalRows: number;
+ totalCa: number;
+ totalMarge: number;
+ tauxMargeGlobal: number;
+ };
+}
+
+export async function saveSnapshot(raw: unknown): Promise<{ success: boolean; snapshotId?: number; error?: string }> {
+ return callAction("saveSnapshot", [raw]);
}
diff --git a/src/features/snapshots/components/snapshot-list.tsx b/src/features/snapshots/components/snapshot-list.tsx
index 20aa972..70a3bc7 100644
--- a/src/features/snapshots/components/snapshot-list.tsx
+++ b/src/features/snapshots/components/snapshot-list.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useCallback, useEffect, useState } from "react";
import { useRouter } from "next/navigation";
import {
diff --git a/src/instrumentation.ts b/src/instrumentation.ts
deleted file mode 100644
index 4776c24..0000000
--- a/src/instrumentation.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-/**
- * CollectFlow — Point d'entrée exécuté une fois au démarrage du serveur.
- *
- * Sert à armer le minuteur de la synchronisation nocturne. L'import est
- * dynamique et conditionné au runtime Node : `register()` est aussi évalué
- * dans le runtime Edge, où ni `setInterval` persistant ni l'accès à la base
- * n'ont de sens.
- */
-export async function register() {
- if (process.env.NEXT_RUNTIME !== "nodejs") return;
-
- try {
- const { startSyncTimer } = await import("@/features/admin/api/sync-timer");
- startSyncTimer();
- } catch (e) {
- // Un démarrage réussi prime sur le planificateur : s'il ne s'arme pas,
- // l'application doit rester utilisable et la synchro manuelle disponible.
- console.error("[instrumentation] minuteur de synchro non démarré :", e instanceof Error ? e.message : String(e));
- }
-}
diff --git a/src/lib/api-auth.ts b/src/lib/api-auth.ts
deleted file mode 100644
index b5d3cbb..0000000
--- a/src/lib/api-auth.ts
+++ /dev/null
@@ -1,131 +0,0 @@
-/**
- * CollectFlow — Authentification de l'API publique `/api/v1`.
- *
- * Deux voies d'entrée :
- * 1. **Clé d'API** (`X-API-Key` ou `Authorization: Bearer …`) — pour les appelants
- * non-navigateur : scripts, outils externes, assistant IA.
- * 2. **Session NextAuth** — le front de CollectFlow utilise donc les mêmes routes.
- *
- * En cas d'échec on renvoie un **401 JSON**, jamais une redirection : `src/middleware.ts`
- * exempte `/api/v1/*` précisément pour que ce module puisse répondre proprement.
- *
- * Seul le hachage SHA-256 des clés est stocké (table `api_keys`) ; la clé en clair
- * n'existe qu'au moment de sa création.
- */
-
-import "server-only";
-
-import { createHash, randomBytes, timingSafeEqual } from "crypto";
-import type { NextRequest } from "next/server";
-import { db } from "@/db";
-import { apiKeys } from "@/db/schema";
-import { eq } from "drizzle-orm";
-import { auth } from "@/lib/auth";
-import { fail } from "@/lib/api-response";
-
-export interface AuthContext {
- /** Origine de l'authentification — utile pour les logs et l'audit. */
- via: "api_key" | "session";
- role: string;
- /** Nom de la clé, ou identifiant de l'utilisateur connecté. */
- subject: string;
-}
-
-/** Intervalle minimal entre deux mises à jour de `last_used_at` pour une même clé. */
-const TRACE_USAGE_MS = 60_000;
-const derniereTrace = new Map();
-
-/** Préfixe des clés CollectFlow, pour les reconnaître d'un coup d'œil. */
-const KEY_PREFIX = "cf_";
-
-export function hashApiKey(key: string): string {
- return createHash("sha256").update(key, "utf8").digest("hex");
-}
-
-/**
- * Génère une clé d'API. Renvoie la clé **en clair** (à afficher une seule fois),
- * son hachage à stocker, et un préfixe lisible pour l'identifier dans l'UI.
- */
-export function generateApiKey(): { key: string; keyHash: string; keyPrefix: string } {
- const secret = randomBytes(24).toString("base64url");
- const key = `${KEY_PREFIX}${secret}`;
- return { key, keyHash: hashApiKey(key), keyPrefix: key.slice(0, 11) };
-}
-
-/** Comparaison à temps constant de deux hachages hexadécimaux. */
-function hashesEqual(a: string, b: string): boolean {
- const ba = Buffer.from(a, "hex");
- const bb = Buffer.from(b, "hex");
- if (ba.length !== bb.length || ba.length === 0) return false;
- return timingSafeEqual(ba, bb);
-}
-
-/** Extrait la clé d'un en-tête `X-API-Key` ou `Authorization: Bearer …`. */
-function readKeyFromRequest(req: NextRequest): string | null {
- const direct = req.headers.get("x-api-key");
- if (direct?.trim()) return direct.trim();
- const authz = req.headers.get("authorization");
- if (authz) {
- const m = authz.match(/^Bearer\s+(.+)$/i);
- if (m) return m[1].trim();
- }
- return null;
-}
-
-/**
- * Authentifie une requête `/api/v1`.
- *
- * Renvoie un `AuthContext` en cas de succès, ou une réponse d'erreur JSON prête à
- * être retournée par le handler. À appeler en première ligne de chaque endpoint :
- *
- * const authCtx = await requireApiAuth(req);
- * if (authCtx instanceof NextResponse) return authCtx;
- */
-export async function requireApiAuth(req: NextRequest): Promise {
- const presented = readKeyFromRequest(req);
-
- if (presented) {
- const presentedHash = hashApiKey(presented);
- // La colonne key_hash est unique : la recherche par égalité suffit, et la
- // comparaison à temps constant ci-dessous couvre le reste.
- const [row] = await db.select().from(apiKeys).where(eq(apiKeys.keyHash, presentedHash)).limit(1);
-
- if (!row || !hashesEqual(row.keyHash, presentedHash)) {
- return fail("unauthorized", "Clé d'API invalide.");
- }
- if (row.revokedAt) {
- return fail("unauthorized", "Clé d'API révoquée.");
- }
-
- // Trace d'usage — jamais bloquante, et au plus une écriture par minute et
- // par clé : un script qui pagine ne déclenche plus un UPDATE par requête.
- const maintenant = Date.now();
- if (maintenant - (derniereTrace.get(row.id) ?? 0) >= TRACE_USAGE_MS) {
- derniereTrace.set(row.id, maintenant);
- void db.update(apiKeys).set({ lastUsedAt: new Date(maintenant) }).where(eq(apiKeys.id, row.id))
- .catch((e) => console.error("[api-auth] lastUsedAt KO:", (e as Error).message?.slice(0, 120)));
- }
-
- return { via: "api_key", role: row.role, subject: row.name };
- }
-
- // Repli sur la session du navigateur (le front utilise les mêmes routes).
- const session = await auth();
- if (session?.user) {
- const user = session.user as { name?: string | null; role?: string };
- return { via: "session", role: user.role ?? "user", subject: user.name ?? "session" };
- }
-
- return fail(
- "unauthorized",
- "Authentification requise : fournissez un en-tête X-API-Key (ou Authorization: Bearer), ou connectez-vous.",
- );
-}
-
-/** Restreint un endpoint aux appelants administrateurs. */
-export function requireAdminRole(ctx: AuthContext): Response | null {
- if (ctx.role !== "admin") {
- return fail("forbidden", "Rôle administrateur requis pour cette opération.");
- }
- return null;
-}
diff --git a/src/lib/api-enrich.ts b/src/lib/api-enrich.ts
deleted file mode 100644
index 143ca9d..0000000
--- a/src/lib/api-enrich.ts
+++ /dev/null
@@ -1,157 +0,0 @@
-/**
- * CollectFlow — Enrichissement des lignes servies par `/api/v1`.
- *
- * L'instantané `grid_rows` fige la ligne au moment du calcul. Deux informations
- * doivent pourtant refléter l'état **courant** au moment de l'appel :
- *
- * 1. **Métriques réseau Qlik** — la table `qlik_network_metrics` est mise à jour par
- * les synchronisations et les recherches réseau, indépendamment du calcul de la
- * grille. On les relit donc à la lecture, et on les expose telles quelles quand
- * elles existent (`network: null` sinon).
- *
- * 2. **Gamme serveur** — `codeGamme` peut être surchargée par un snapshot de session
- * (modification locale non enregistrée côté serveur). L'API expose la gamme **non
- * modifiée**, celle réellement présente en base PostgreSQL, relue à chaque appel.
- *
- * Ce n'est pas un recalcul : deux lectures indexées bornées au nombre de lignes de la
- * page (500 au maximum), de l'ordre de quelques millisecondes.
- */
-
-import "server-only";
-
-import type { ProductRow } from "@/types/grid";
-import { getNetworkMetricsByCodeCentrale, type NetworkMetricCached } from "@/lib/qlik-network-cache";
-import { pgGetGammesByCodeins } from "@/lib/pg-ff-client";
-import { gammesAValiderParArticle } from "@/lib/gammes-a-valider";
-// Module de la Grille : l'API doit renvoyer exactement la tendance affichée dans
-// l'application, pas une seconde implémentation qui divergerait.
-import { computeNetworkTrend, trendLabel } from "@/features/grid/lib/network-trend";
-
-/** Tendance réseau 12 mois, telle qu'affichée dans la colonne « Tendance » de la Grille. */
-export interface ProductTrend {
- direction: "up" | "down" | "flat";
- /** Variation des 4 derniers mois vs les 4 premiers (0.23 = +23 %). `null` si aucune base. */
- pct: number | null;
- /** Libellé prêt à afficher : « Forte hausse », « Nouveau », « Stable »… */
- label: string;
- /**
- * `true` = tendance calculée sur la quantité **par magasin vendeur**, ce qui
- * neutralise l'effet d'un simple élargissement de la distribution. `false` =
- * repli sur les quantités brutes, faute de nombre de magasins sur 12 mois.
- */
- surQteParMagasin: boolean;
- /** Aucune vente sur les 4 premiers mois, des ventes sur les 4 derniers. */
- nouveau: boolean;
- /** Nombre de mois de la série (12 quand elle est complète). */
- monthsUsed: number;
-}
-
-export interface EnrichedProductRow extends ProductRow {
- /**
- * Gamme telle qu'elle existe sur le serveur PostgreSQL — non modifiée.
- * `null` si l'article n'a aucune gamme en base.
- */
- codeGammeServeur: string | null;
- /**
- * Gamme proposée par l'API et pas encore validée dans la Grille.
- * `null` = aucune proposition en attente.
- */
- gammeAValider: string | null;
- /** Métriques réseau Qlik en cache, ou `null` si le produit n'en a pas. */
- network: NetworkMetricCached | null;
- /**
- * Tendance réseau calculée par régression linéaire sur les 12 derniers mois.
- * `null` quand il n'y a aucune série mensuelle. Fournie pour que l'appelant —
- * en particulier un agent — n'ait pas à réimplémenter le calcul et à diverger
- * de ce que montre l'application.
- */
- trend: ProductTrend | null;
-}
-
-/**
- * Enrichit un lot de lignes. Les deux lectures sont indépendantes et lancées en
- * parallèle ; un échec de l'une n'empêche pas l'autre (l'API reste servie, avec
- * la valeur de l'instantané en repli).
- */
-export async function enrichRows(rows: ProductRow[]): Promise {
- if (rows.length === 0) return [];
-
- const codesCentraux = [...new Set(rows.map((r) => r.codeCentrale).filter((c): c is string => Boolean(c)))];
- const codeins = [...new Set(rows.map((r) => r.codein).filter(Boolean))];
-
- const [network, gammes, aValider] = await Promise.all([
- codesCentraux.length
- ? getNetworkMetricsByCodeCentrale(codesCentraux).catch((e) => {
- console.error("[api-enrich] métriques réseau KO:", (e as Error).message?.slice(0, 160));
- return new Map();
- })
- : Promise.resolve(new Map()),
- codeins.length
- ? pgGetGammesByCodeins(codeins).catch((e) => {
- console.error("[api-enrich] gammes serveur KO:", (e as Error).message?.slice(0, 160));
- return new Map();
- })
- : Promise.resolve(new Map()),
- gammesAValiderParArticle(codeins).catch((e) => {
- console.error("[api-enrich] gammes à valider KO:", (e as Error).message?.slice(0, 160));
- return new Map();
- }),
- ]);
-
- return rows.map((row) => {
- const metrics = row.codeCentrale ? network.get(row.codeCentrale) ?? null : null;
- // Gamme absente de la base = pas de gamme, et non « inconnue » : on distingue
- // explicitement par `null` plutôt que de retomber sur la valeur du snapshot.
- const gammeServeur = gammes.get(row.codein) ?? null;
-
- const enriched: EnrichedProductRow = {
- ...row,
- codeGammeServeur: gammeServeur,
- gammeAValider: aValider.get(`${row.codeFournisseur}|${row.codein}`) ?? null,
- network: metrics,
- trend: null, // renseignée plus bas, une fois la série mensuelle connue
- };
-
- // `codeGammeInit` porte déjà la sémantique « état serveur » dans la Grille :
- // on la garde alignée pour que les deux champs ne divergent jamais.
- if (gammes.size > 0) {
- enriched.codeGammeInit = gammeServeur as ProductRow["codeGammeInit"];
- }
-
- // Les colonnes réseau de la ligne datent du calcul : on les réaligne sur le
- // cache quand il a quelque chose à dire.
- if (metrics) {
- enriched.caReseau = metrics.caReseau;
- enriched.qteReseau = metrics.qteReseau;
- enriched.nbMagasinsReseau = metrics.nbMagasinsReseau;
- enriched.caParMagasinReseau = metrics.caParMagasinReseau;
- enriched.margePctReseau = metrics.margePctReseau;
- enriched.qteReseauByMonth = metrics.qteByMonth;
- enriched.networkFetchedAt = metrics.fetchedAt ?? undefined;
- }
-
- // Tendance : mêmes entrées que la colonne « Tendance » de la Grille, à
- // savoir la série des quantités **et** celle du nombre de magasins vendeurs
- // — sans la seconde, le calcul se rabat sur les quantités brutes et
- // confond « vend mieux » avec « est distribué plus largement ».
- const serie = enriched.qteReseauByMonth;
- const nbMagByMonth = metrics?.metricsByMonth
- ? Object.fromEntries(
- Object.entries(metrics.metricsByMonth).map(([mois, m]) => [mois, Number(m?.nbMag) || 0]),
- )
- : null;
- const t = computeNetworkTrend(serie, nbMagByMonth);
- if (t.hasData) {
- enriched.trend = {
- direction: t.direction,
- pct: t.pct,
- label: trendLabel(t.pct, t.nouveau),
- surQteParMagasin: t.surQteParMagasin,
- nouveau: t.nouveau,
- monthsUsed: t.values.length,
- };
- }
-
- return enriched;
- });
-}
diff --git a/src/lib/api-ff-client.ts b/src/lib/api-ff-client.ts
deleted file mode 100644
index 3a3e0aa..0000000
--- a/src/lib/api-ff-client.ts
+++ /dev/null
@@ -1,517 +0,0 @@
-/**
- * CollectFlow — API FF Nancy Client
- *
- * Client HTTP centralisé pour l'API REST https://api.ffnancy.fr
- * Sync nuit SQL Server → données fraîches J-1
- *
- * Stratégie mouvements : appeler SANS filtre genremvt (tous types)
- * - genremvt = 3 → alimenter sales12m (ventes)
- * - Tous types → lire qtestock pour reconstruire stock12m
- */
-
-import fs from "fs/promises";
-import path from "path";
-
-const CONFIG_FILE = path.join(process.cwd(), "data", ".db-config.json");
-const FF_API_BASE_DEFAULT = "https://api.ffnancy.fr";
-const FF_API_BASE_TTL_MS = 30_000;
-
-/**
- * Options de tout appel à l'API FF : jamais de cache HTTP, et un délai maximal.
- * Sans délai, une API muette figeait indéfiniment la page qui l'attendait.
- */
-const FF_FETCH_TIMEOUT_MS = Number(process.env.FF_API_TIMEOUT_MS) || 30_000;
-export function ffFetchInit(): RequestInit {
- return { cache: "no-store", signal: AbortSignal.timeout(FF_FETCH_TIMEOUT_MS) };
-}
-
-let ffApiBaseCache: { value: string; at: number } | null = null;
-
-/**
- * URL de l'API FF Nancy, résolue **au moment de l'appel**.
- *
- * Ordre de priorité : réglage enregistré dans Paramètres → variable
- * d'environnement `FF_API_BASE_URL` → valeur par défaut. Auparavant l'URL était
- * figée au chargement du module depuis l'environnement seul : impossible de la
- * corriger depuis l'application quand le serveur changeait d'adresse.
- *
- * Le résultat est mémorisé 30 s pour ne pas relire le fichier à chaque requête.
- */
-async function getFfApiBase(): Promise {
- if (ffApiBaseCache && Date.now() - ffApiBaseCache.at < FF_API_BASE_TTL_MS) {
- return ffApiBaseCache.value;
- }
- let configured: string | undefined;
- try {
- const raw = await fs.readFile(CONFIG_FILE, "utf-8");
- const parsed = JSON.parse(raw) as { ffApiBaseUrl?: string };
- configured = parsed?.ffApiBaseUrl?.trim() || undefined;
- } catch {
- // Fichier absent ou illisible : on retombe sur l'environnement.
- }
- const value = (configured || process.env.FF_API_BASE_URL || FF_API_BASE_DEFAULT).replace(/\/+$/, "");
- ffApiBaseCache = { value, at: Date.now() };
- return value;
-}
-
-/** Vide le cache — appelé après un enregistrement dans Paramètres. */
-export function resetFfApiBaseCache(): void {
- ffApiBaseCache = null;
-}
-
-// ---------------------------------------------------------------------------
-// Types API (shapes des réponses brutes)
-// ---------------------------------------------------------------------------
-
-export interface FfFournisseur {
- codefou: string;
- nomfou: string;
-}
-
-export interface FfArticle {
- codein: string;
- libelle1: string;
- codefou: string;
- nomfou?: string;
- pcb?: number; // conditionnement
- pv_central?: number; // prix de vente central
- noid?: number; // SQL Server internal ID (pour endpoint /mensuel)
- reference?: string; // référence fournisseur (ref_fou_principale)
- gtin?: string; // code-barres EAN/GTIN
- actif?: boolean; // article actif
- suspendu?: boolean; // article suspendu
-}
-
-export interface FfMouvement {
- codein: string;
- genremvt: number; // 3 = vente client
- datemvt: string; // ISO date (YYYY-MM-DD)
- qte: number; // quantité du mouvement
- montant: number; // montant HT
- marge?: number; // marge (si disponible)
- qtestock: number; // stock APRÈS ce mouvement — clé pour stock12m
- site: string; // code magasin / site
- codefou_reel?: string; // code fournisseur réel (dernière entrée avant cette vente, ou code de l'entrée)
- nom_fournisseur_reel?: string; // nom résolu du fournisseur réel
-}
-
-export interface FfStock {
- codein: string;
- site?: string;
- stockdispo: number;
- qte: number;
- valstock: number;
- prmp?: number; // PRMP (prix de revient moyen pondéré)
- pv?: number; // prix de vente
- dernieresventes?: string;
- dernierereception?: string;
- nbjoursdernsventes?: number;
-}
-
-export interface FfCommande {
- codein: string;
- qtecde: number;
-}
-
-export interface FfSyncTable {
- nom: string;
- derniereSync: string;
- nbLignes?: number;
- /** "ok" ou état d'erreur renvoyé par la synchronisation. */
- statut?: string;
- erreur?: string | null;
-}
-
-export interface FfSyncStatus {
- lastSync: string;
- tables: FfSyncTable[];
-}
-
-/**
- * Normalise la réponse de `/api/sync/status`.
- *
- * L'API renvoie `{ sync: [{ table_name, last_sync, rows_synced, status, error_msg }] }`,
- * alors que l'application attendait `{ lastSync, tables: [{ nom, derniereSync, nbLignes }] }`.
- * Les champs lus n'existaient donc pas : le panneau des Paramètres affichait une
- * coquille vide sans la moindre erreur, puisque la requête HTTP réussissait.
- *
- * Les deux formes sont acceptées ici, pour rester compatible si l'API évolue.
- */
-export function normalizeSyncStatus(raw: unknown): FfSyncStatus | null {
- if (!raw || typeof raw !== "object") return null;
- const d = raw as Record;
-
- // Forme déjà attendue par l'application.
- if (Array.isArray(d.tables)) {
- return {
- lastSync: String(d.lastSync ?? ""),
- tables: d.tables as FfSyncTable[],
- };
- }
-
- // Forme réelle de l'API FF Nancy.
- const sync = Array.isArray(d.sync) ? (d.sync as Array>) : null;
- if (!sync) return null;
-
- const tables: FfSyncTable[] = sync.map((t) => ({
- nom: String(t.table_name ?? t.nom ?? "—"),
- derniereSync: String(t.last_sync ?? t.derniereSync ?? ""),
- nbLignes: Number(t.rows_synced ?? t.nbLignes ?? 0) || 0,
- statut: t.status != null ? String(t.status) : undefined,
- erreur: t.error_msg != null ? String(t.error_msg) : null,
- }));
-
- // Pas de date globale dans la réponse : on prend la plus récente des tables.
- const lastSync = tables
- .map((t) => t.derniereSync)
- .filter(Boolean)
- .sort()
- .at(-1) ?? "";
-
- return { lastSync, tables };
-}
-
-/** Stock agrégé sur tous les sites pour un codein */
-export interface AggregatedStock {
- stockActuel: number; // sum stockdispo
- stockTotal: number; // sum qte
- stockValeur: number; // sum valstock
- pa: number; // prmp (premier site non-zéro)
- prixVente: number; // pv premier site
- derniereVente: string; // max date tous sites
- derniereLivraison: string; // max dernierereception tous sites
- nbJoursDerniereVente: number; // min tous sites
-}
-
-// ---------------------------------------------------------------------------
-// Pagination générique
-// ---------------------------------------------------------------------------
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function extractList(data: unknown): any[] {
- if (Array.isArray(data)) return data;
- const d = data as Record;
- // Essaie les wrappers courants
- for (const key of ["items", "data", "result", "results", "records", "list", "mouvements", "articles", "fournisseurs", "ventes", "stocks", "commandes"]) {
- if (Array.isArray(d[key])) return d[key] as unknown[];
- }
- // Cherche la première propriété qui est un tableau
- for (const val of Object.values(d)) {
- if (Array.isArray(val)) return val as unknown[];
- }
- return [];
-}
-
-async function fetchAllPages(
- buildUrl: (page: number) => string,
- _extractItems: (data: unknown) => T[],
- pageSize = 500
-): Promise {
- // Page 1 — récupère les items et tente d'obtenir le total pour paralléliser
- const url1 = buildUrl(1);
- console.log(`[api-ff] GET ${url1}`);
- const res1 = await fetch(url1, ffFetchInit());
- if (!res1.ok) {
- console.error(`[api-ff] HTTP ${res1.status} — ${url1}`);
- return [];
- }
- const data1 = await res1.json();
- const items1 = extractList(data1) as T[];
- console.log(`[api-ff] page 1: ${items1.length} items, keys: ${items1[0] ? Object.keys(items1[0] as object).join(",") : "empty"}`);
-
- // Si la première page est incomplète, pas besoin de continuer
- if (items1.length < pageSize) return items1;
-
- // Cherche un total dans la réponse pour paralléliser les pages suivantes
- const d1 = data1 as Record;
- const total = Number(d1.count ?? d1.total ?? d1.nb_total ?? d1.totalCount ?? 0);
-
- if (total > pageSize) {
- const totalPages = Math.ceil(total / pageSize);
- const remaining = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
- // Fetch en chunks de 10 pages en parallèle
- const all = [...items1];
- for (let i = 0; i < remaining.length; i += 10) {
- const chunk = remaining.slice(i, i + 10);
- const results = await Promise.all(chunk.map(async (p) => {
- const url = buildUrl(p);
- console.log(`[api-ff] GET ${url}`);
- const res = await fetch(url, ffFetchInit());
- if (!res.ok) return [] as T[];
- const data = await res.json();
- return extractList(data) as T[];
- }));
- for (const r of results) all.push(...r);
- }
- return all;
- }
-
- // Fallback parallèle sans total : fetch 10 pages à la fois, arrêt dès qu'une page est incomplète
- const all = [...items1];
- let startPage = 2;
- while (true) {
- const chunk = Array.from({ length: 10 }, (_, i) => startPage + i);
- const results = await Promise.all(chunk.map(async (p) => {
- const url = buildUrl(p);
- console.log(`[api-ff] GET ${url}`);
- const res = await fetch(url, ffFetchInit());
- if (!res.ok) return { p, items: [] as T[] };
- const data = await res.json();
- return { p, items: extractList(data) as T[] };
- }));
- results.sort((a, b) => a.p - b.p);
- let done = false;
- for (const { items } of results) {
- all.push(...items);
- if (items.length < pageSize) { done = true; break; }
- }
- if (done) break;
- startPage += 10;
- }
- return all;
-}
-
-// ---------------------------------------------------------------------------
-// Helpers date
-// ---------------------------------------------------------------------------
-
-/** Retourne la fenêtre des 12 mois complets précédant le mois en cours.
- * En mars 2026 → { dateDebut: "2025-03-01", dateFin: "2026-02-28" }
- */
-export function buildLast12MonthsRange(): { dateDebut: string; dateFin: string } {
- const now = new Date();
- // Fin : dernier jour du mois précédent le mois courant
- const endMonth = new Date(now.getFullYear(), now.getMonth(), 0);
- // Début : 12 mois avant le mois courant
- const startMonth = new Date(now.getFullYear(), now.getMonth() - 12, 1);
-
- return {
- dateDebut: startMonth.toISOString().slice(0, 10),
- dateFin: endMonth.toISOString().slice(0, 10),
- };
-}
-
-// ---------------------------------------------------------------------------
-// Articles
-// ---------------------------------------------------------------------------
-
-export async function getArticlesByFournisseur(
- codefou: string
-): Promise {
- const FF_API_BASE = await getFfApiBase();
- const raw = await fetchAllPages(
- (page) => `${FF_API_BASE}/api/articles?codefou=${encodeURIComponent(codefou)}&page=${page}&limit=500`,
- extractList,
- 500
- );
- // eslint-disable-next-line @typescript-eslint/no-explicit-any
- return raw.map((r: any): FfArticle => ({
- codein: r.codein ?? r.Codein ?? r.code_article ?? r.codeArticle ?? String(r.id ?? ""),
- libelle1: r.libelle1 ?? r.Libelle1 ?? r.libelle ?? r.designation ?? r.nom ?? "",
- codefou: r.codefou_principal ?? r.codefou ?? r.Codefou ?? r.code_fournisseur ?? r.codeFournisseur ?? codefou,
- nomfou: r.nom_fou_principal ?? r.nomfou ?? r.Nomfou ?? r.nom_fournisseur ?? r.nomFournisseur ?? "",
- pcb: r.pcb_principal ?? r.pcb ?? r.Pcb ?? r.conditionnement ?? r.colisage,
- pv_central: r.pv_central ?? r.PvCentral ?? r.prix_vente_mini ?? r.pv ?? r.prixVente,
- noid: r.no_id ?? r.noid ?? r.NoId,
- reference: r.ref_fou_principale ?? r.reference ?? r.ref_fournisseur ?? undefined,
- gtin: r.gtin ?? r.Gtin ?? r.ean ?? r.barcode ?? undefined,
- actif: r.actif != null ? Boolean(Number(r.actif)) : undefined,
- suspendu: r.suspendu != null ? Boolean(Number(r.suspendu)) : undefined,
- })).filter(a => a.codein);
-}
-
-// ---------------------------------------------------------------------------
-// Mouvements (ventes + stock12m)
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Mensuel — stock fin de mois + ventes + réceptions par article et par site
-// GET /api/articles/:no_id/mensuel?dateDebut=&dateFin=
-// ---------------------------------------------------------------------------
-
-export interface FfMensuelVentes {
- nb_passages: string;
- qte_vendue: string; // négatif (ex: "-2.000")
- ca_ht: string; // négatif (ex: "-26.6600")
- ca_ttc: string;
- marge: string; // positif (ex: "12.7600")
- taux_marge: string;
-}
-
-export interface FfMensuelReceptions {
- nb_receptions: string;
- qte_recue: string;
-}
-
-export interface FfMensuelEntry {
- mois: string; // "YYYY-MM"
- site: string; // code site ("292", "579")
- stock_fin_mois: string; // stock fin de mois
- prmp_fin_mois: string; // PRMP fin de mois
- ventes: FfMensuelVentes | null;
- receptions: FfMensuelReceptions | null;
-}
-
-/**
- * Récupère les données mensuelles (stock + ventes + réceptions) pour un lot d'articles.
- * Utilise no_id comme identifiant (obligatoire pour l'API).
- * Retourne Map
- */
-export async function getMensuelByArticles(
- articles: FfArticle[],
- dateDebut: string,
- dateFin: string,
- batchSize = 50
-): Promise> {
- const result = new Map();
- const FF_API_BASE = await getFfApiBase();
-
- for (let i = 0; i < articles.length; i += batchSize) {
- const batch = articles.slice(i, i + batchSize);
- await Promise.all(
- batch.map(async (art) => {
- const noId = art.noid;
- if (!noId) return;
- try {
- const url = `${FF_API_BASE}/api/articles/${encodeURIComponent(String(noId))}/mensuel?dateDebut=${dateDebut}&dateFin=${dateFin}`;
- const res = await fetch(url, ffFetchInit());
- if (!res.ok) return;
- const data = await res.json();
- const entries: FfMensuelEntry[] = Array.isArray(data.data) ? data.data : [];
- if (entries.length > 0) {
- result.set(art.codein, entries);
- }
- } catch (err) {
- console.error(`[api-ff] getMensuel error for ${art.codein}:`, err);
- }
- })
- );
- }
-
- return result;
-}
-
-// ---------------------------------------------------------------------------
-// Referentiel — article complet : nomenclature, gammes, stock, prix, fournisseurs
-// GET /api/articles/:no_id/referentiel
-// ---------------------------------------------------------------------------
-
-export interface FfReferentiel {
- article: {
- no_id: string;
- codein: string;
- nom_code: string | null; // code nomenclature (ex: "360504")
- nom_libelle: string | null; // libellé nomenclature
- nom_niveau: number | null;
- nom_chemin_pere: string | null;
- };
- gammes: {
- gamme_code: string;
- gamme_libelle: string;
- saison_code: string;
- saison_libelle: string;
- }[];
- stock: {
- site: string;
- stockdispo: string;
- qte: string;
- prmp: string;
- valstock: string;
- pv: string;
- dernierevente: string;
- dernierereception: string;
- stockmort: boolean;
- }[];
- prix: {
- achat: string | null;
- vente_par_site: { site: string; pv: string }[];
- } | null;
- fournisseurs: {
- codefou: string;
- ref_fou: string;
- pcb: string;
- prixachat: string;
- }[];
- performance: {
- derniere_vente: string | null;
- derniere_entree: string | null;
- qte_totale_vendue: string | null;
- ca_ttc_total: string | null;
- marge_totale: string | null;
- } | null;
-}
-
-/**
- * Récupère le référentiel complet (nomenclature, gamme, stock, prix) pour un lot d'articles.
- * Utilise no_id comme identifiant.
- * Retourne Map
- */
-export async function getReferentielByArticles(
- articles: FfArticle[],
- batchSize = 50
-): Promise> {
- const result = new Map();
- const FF_API_BASE = await getFfApiBase();
-
- for (let i = 0; i < articles.length; i += batchSize) {
- const batch = articles.slice(i, i + batchSize);
- await Promise.all(
- batch.map(async (art) => {
- const noId = art.noid;
- if (!noId) return;
- try {
- const url = `${FF_API_BASE}/api/articles/${encodeURIComponent(String(noId))}/referentiel`;
- const res = await fetch(url, ffFetchInit());
- if (!res.ok) return;
- const data: FfReferentiel = await res.json();
- if (data?.article) result.set(art.codein, data);
- } catch (err) {
- console.error(`[api-ff] getReferentiel error for ${art.codein}:`, err);
- }
- })
- );
- }
-
- return result;
-}
-
-// ---------------------------------------------------------------------------
-// Commandes en cours
-// ---------------------------------------------------------------------------
-
-export async function getCommandesByFournisseur(
- codefou: string
-): Promise> {
- const result = new Map();
- const FF_API_BASE = await getFfApiBase();
- try {
- const res = await fetch(
- `${FF_API_BASE}/api/commandes/articles?codefou=${encodeURIComponent(codefou)}`,
- ffFetchInit()
- );
- if (!res.ok) return result;
- const data = await res.json();
- const list: FfCommande[] = Array.isArray(data) ? data : ((data as any).items ?? (data as any).data ?? []);
- for (const c of list) {
- result.set(c.codein, (result.get(c.codein) ?? 0) + (c.qtecde ?? 0));
- }
- } catch (err) {
- console.error("[api-ff] getCommandesByFournisseur error:", err);
- }
- return result;
-}
-
-// ---------------------------------------------------------------------------
-// Statut de synchronisation
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Sites (magasins)
-// ---------------------------------------------------------------------------
-
-export async function getSitesFromApi(): Promise<{ code: string; nom: string }[]> {
- return [
- { code: "292", nom: "Frouard (Nancy)" },
- { code: "579", nom: "Houdemont" },
- ];
-}
diff --git a/src/lib/api-gammes.ts b/src/lib/api-gammes.ts
deleted file mode 100644
index f6fb1ca..0000000
--- a/src/lib/api-gammes.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-/**
- * CollectFlow — Affectation de gammes via l'API `/api/v1`.
- *
- * L'API n'enregistre pas la gamme : elle la **propose**. La proposition est
- * rangée dans `gammes_a_valider` et apparaît dans la Grille comme une
- * modification non enregistrée — on y voit donc quels produits changent de gamme
- * avant de valider (« Enregistrer », même chemin que toute modification de la
- * Grille) ou de rejeter (« Annuler les modifications »). Tant qu'elle n'est pas
- * validée, `codeGamme` reste inchangée et la proposition est exposée dans
- * `gammeAValider`.
- *
- * Tout ou rien : si un seul article est inconnu chez le fournisseur, rien n'est
- * proposé et la réponse liste les articles en cause.
- */
-
-import "server-only";
-
-import type { NextRequest } from "next/server";
-import { fail } from "@/lib/api-response";
-import { getGridFreshness, getGridRowsGammes } from "@/lib/grid-store";
-import { getProductRows } from "@/features/grid/api/get-product-rows";
-import { proposerGammes, type PropositionGamme } from "@/lib/gammes-a-valider";
-
-export interface ResultatGamme {
- codein: string;
- /** Gamme proposée. */
- gamme: string;
- /** Gamme enregistrée au moment de l'appel (modifications validées comprises). */
- gammePrecedente: string | null;
- /** Gamme présente en base FF, non modifiée par l'API. */
- codeGammeServeur: string | null;
- /**
- * `true` = la gamme change : proposition déposée, à valider dans la Grille.
- * `false` = l'article a déjà cette gamme : rien à valider (une proposition
- * antérieure en attente pour lui est retirée).
- */
- modifie: boolean;
- /** `a_valider` quand `modifie`, sinon `inchangee`. */
- statut: "a_valider" | "inchangee";
-}
-
-export interface AffectationGammes {
- codeFournisseur: string;
- nomFournisseur: string | null;
- resultats: ResultatGamme[];
-}
-
-/** Lit un corps JSON, ou renvoie une réponse 400 prête à être retournée. */
-export async function lireCorpsJson(req: NextRequest): Promise {
- try {
- return await req.json();
- } catch {
- return fail("bad_request", "Corps de requête JSON attendu (Content-Type: application/json).");
- }
-}
-
-/**
- * Propose des gammes pour des articles d'un fournisseur (à valider dans la Grille).
- *
- * Si le fournisseur n'a encore jamais été calculé, son instantané est calculé à la
- * demande (`compute`), comme sur `/grid` : sans lui, impossible de vérifier que les
- * articles lui appartiennent.
- */
-export async function affecterGammes(input: {
- codeFournisseur: string;
- changes: ReadonlyArray<{ codein: string; gamme: string }>;
- compute: boolean;
- /** Nom de la clé d'API ou de l'utilisateur — affiché dans la Grille avec la proposition. */
- auteur: string;
-}): Promise {
- const { codeFournisseur, compute, auteur } = input;
-
- // Un même article cité deux fois : la dernière valeur l'emporte.
- const demandes = new Map(input.changes.map((c) => [c.codein, c.gamme]));
- const codeins = [...demandes.keys()];
-
- if (compute && !(await getGridFreshness(codeFournisseur))) {
- console.log(`[api/v1/gammes] instantané absent pour ${codeFournisseur} — calcul à la demande`);
- try {
- await getProductRows({ codeFournisseur, magasin: "TOTAL" });
- } catch (e) {
- console.error(`[api/v1/gammes] calcul KO pour ${codeFournisseur}:`, e instanceof Error ? e.message : String(e));
- return fail("internal_error", `Le calcul de la grille a échoué pour le fournisseur « ${codeFournisseur} ».`);
- }
- }
-
- const actuelles = await getGridRowsGammes(codeFournisseur, codeins);
- const inconnus = codeins.filter((c) => !actuelles.has(c));
- if (inconnus.length > 0) {
- return fail(
- "not_found",
- `${inconnus.length} article(s) introuvable(s) chez le fournisseur « ${codeFournisseur} » : aucune gamme n'a été enregistrée.`,
- { fournisseur: codeFournisseur, inconnus },
- );
- }
-
- const resultats: ResultatGamme[] = [];
- const propositions: PropositionGamme[] = [];
- const annules: string[] = [];
- let nomFournisseur: string | null = null;
-
- for (const [codein, gamme] of demandes) {
- const actuelle = actuelles.get(codein)!;
- nomFournisseur ??= actuelle.nomFournisseur;
- const modifie = actuelle.codeGamme !== gamme;
- resultats.push({
- codein,
- gamme,
- gammePrecedente: actuelle.codeGamme,
- codeGammeServeur: actuelle.codeGammeInit,
- modifie,
- statut: modifie ? "a_valider" : "inchangee",
- });
- if (modifie) propositions.push({ codein, gamme, gammePrecedente: actuelle.codeGamme });
- else annules.push(codein);
- }
-
- try {
- await proposerGammes({ codeFournisseur, propositions, annules, auteur });
- } catch (e) {
- console.error(`[api/v1/gammes] proposition KO pour ${codeFournisseur}:`, e instanceof Error ? e.message : String(e));
- return fail("internal_error", "L'enregistrement des gammes à valider a échoué.");
- }
-
- console.log(`[api/v1/gammes] ${codeFournisseur} — ${propositions.length} gamme(s) à valider proposée(s) par ${auteur}`);
- return { codeFournisseur, nomFournisseur, resultats };
-}
diff --git a/src/lib/api-response.ts b/src/lib/api-response.ts
deleted file mode 100644
index f4a821d..0000000
--- a/src/lib/api-response.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-/**
- * CollectFlow — Enveloppe de réponse de l'API publique `/api/v1`.
- *
- * Une forme unique pour tout : `{ data, pagination?, meta }` en succès,
- * `{ error: { code, message } }` en échec, avec de vrais statuts HTTP.
- * Les consommateurs (scripts, IA, outils externes) peuvent ainsi traiter
- * toutes les réponses de la même manière.
- */
-
-import { NextResponse } from "next/server";
-
-export type ApiErrorCode =
- | "unauthorized"
- | "forbidden"
- | "bad_request"
- | "not_found"
- | "not_ready"
- | "internal_error";
-
-const STATUS_BY_CODE: Record = {
- unauthorized: 401,
- forbidden: 403,
- bad_request: 400,
- not_found: 404,
- not_ready: 202,
- internal_error: 500,
-};
-
-export interface Pagination {
- page: number;
- limit: number;
- total: number;
- totalPages: number;
- /** `true` s'il reste des pages à lire — évite d'avoir à comparer page et totalPages. */
- hasMore: boolean;
-}
-
-export function buildPagination(page: number, limit: number, total: number): Pagination {
- const totalPages = Math.max(1, Math.ceil(total / limit));
- // `hasMore` explicite : un agent qui doit comparer page et totalPages oublie
- // souvent de le faire et conclut à tort qu'il a tout récupéré.
- return { page, limit, total, totalPages, hasMore: page < totalPages };
-}
-
-/** Réponse de succès. `meta` porte la fraîcheur de la donnée (`computedAt`). */
-export function ok(
- data: T,
- opts: { pagination?: Pagination; meta?: Record } = {},
-): NextResponse {
- return NextResponse.json({
- data,
- ...(opts.pagination ? { pagination: opts.pagination } : {}),
- meta: { ...(opts.meta ?? {}) },
- });
-}
-
-/**
- * Réponse d'erreur. `details` sert notamment aux erreurs de validation zod.
- *
- * Note : `not_ready` renvoie un 202 — ce n'est pas un échec mais une donnée pas
- * encore calculée (voir /api/v1/grid sur un fournisseur jamais ouvert).
- */
-export function fail(
- code: ApiErrorCode,
- message: string,
- details?: unknown,
-): NextResponse {
- return NextResponse.json(
- { error: { code, message, ...(details !== undefined ? { details } : {}) } },
- { status: STATUS_BY_CODE[code] },
- );
-}
diff --git a/src/lib/api-schemas.ts b/src/lib/api-schemas.ts
deleted file mode 100644
index 7e0af74..0000000
--- a/src/lib/api-schemas.ts
+++ /dev/null
@@ -1,168 +0,0 @@
-/**
- * CollectFlow — Validation des paramètres de l'API `/api/v1` (zod).
- *
- * Toute entrée utilisateur passe par ici : bornes de pagination, listes blanches
- * de tri, projection de champs. Les erreurs remontent en `400 bad_request` avec
- * le détail zod, pour que l'appelant sache quoi corriger.
- */
-
-import { z } from "zod";
-import { GRID_SORT_KEYS, type GridSortKey } from "@/lib/grid-store";
-import { GAMMES, type CodeGamme } from "@/lib/gammes";
-
-const SORT_KEYS = GRID_SORT_KEYS as readonly string[];
-
-export const paginationShape = {
- page: z.coerce.number().int().min(1).default(1),
- /**
- * Aucun plafond : l'appelant décide de la taille qu'il veut recevoir.
- * Le défaut reste modeste (100) pour que les endpoints de recherche, non
- * bornés par un fournisseur, ne renvoient pas tout le catalogue par accident.
- * `/grid` redéfinit ce paramètre : sans `limit`, il renvoie tout.
- */
- limit: z.coerce.number().int().min(1).default(100),
-};
-
-const sortShape = {
- sort: z
- .string()
- .refine((v) => SORT_KEYS.includes(v), {
- message: `Tri inconnu. Valeurs acceptées : ${SORT_KEYS.join(", ")}`,
- })
- .optional(),
- order: z.enum(["asc", "desc"]).default("desc"),
- /** Liste de champs de ProductRow à conserver, séparés par des virgules. */
- fields: z.string().optional(),
- /**
- * `1` (défaut) : relit les métriques réseau Qlik et la gamme serveur au moment
- * de l'appel. `0` : sert l'instantané brut, un peu plus rapide.
- */
- enrich: z.enum(["0", "1"]).default("1"),
-};
-
-/** `/api/v1/grid` — le fournisseur est obligatoire (recherche transversale : /products/search). */
-export const gridQuerySchema = z.object({
- fournisseur: z.string().min(1, "Paramètre 'fournisseur' requis"),
- gamme: z.string().min(1).optional(),
- code1: z.string().min(1).optional(),
- code2: z.string().min(1).optional(),
- code3: z.string().min(1).optional(),
- /**
- * Préfixe de nomenclature (« 32 », « 3202 », « 320211 »), tel que renvoyé par
- * /api/v1/nomenclatures. À préférer à code1/code2, qui peuvent être vides
- * quand la hiérarchie n'a pas pu être remontée depuis la base FF.
- */
- nomenclature: z.string().min(1).max(20).regex(/^[0-9]+$/, "La nomenclature doit être un préfixe numérique (ex. 32, 3202, 320211)").optional(),
- search: z.string().min(1).optional(),
- /**
- * `1` (défaut) : si le fournisseur n'a pas encore d'instantané, l'API le calcule
- * à la demande au lieu de répondre `not_ready`. C'est ce qui permet à une app ou
- * à un agent externe d'interroger n'importe quel fournisseur sans qu'un humain
- * ait ouvert la Grille avant. Le premier appel est alors plus lent (plusieurs
- * secondes) ; les suivants sont servis depuis l'instantané.
- * `0` : comportement strict, échoue vite en `not_ready`.
- */
- compute: z.enum(["0", "1"]).default("1"),
- ...sortShape,
- ...paginationShape,
- /**
- * **Aucun plafond, et aucune valeur par défaut** : sans `limit`, `/grid`
- * renvoie *toutes* les lignes du fournisseur.
- *
- * C'est l'objectif de cet endpoint — qu'une app ou un agent récupère un
- * fournisseur entier en un appel. Paginer par défaut condamnait l'appelant à
- * boucler, ce que les agents font mal : ils s'arrêtent à la première page et
- * raisonnent sur un catalogue tronqué.
- *
- * Réponse volumineuse : une ligne complète porte les séries mensuelles et les
- * ventilations par magasin. Combiner avec `fields` est vivement conseillé.
- */
- limit: z.coerce.number().int().min(1).optional(),
-});
-
-/** `/api/v1/products/search` — `fournisseur` facultatif : c'est la recherche transversale. */
-export const productSearchSchema = z.object({
- q: z.string().min(1, "Paramètre 'q' requis").max(120),
- fournisseur: z.string().min(1).optional(),
- gamme: z.string().min(1).optional(),
- ...sortShape,
- ...paginationShape,
-});
-
-export const fournisseursQuerySchema = z.object({
- search: z.string().min(1).optional(),
- /** true = uniquement les fournisseurs déjà présents dans l'instantané de grille. */
- withData: z.enum(["0", "1"]).optional(),
-});
-
-/** `/api/v1/nomenclatures` — inventaire des postes d'un fournisseur. */
-export const nomenclaturesQuerySchema = z.object({
- fournisseur: z.string().min(1, "Paramètre 'fournisseur' requis"),
- /**
- * 1 = univers, 2 = famille, 3 = sous-famille (selon la nomenclature FF).
- * Le `transform` ne fait que redonner le type littéral : les bornes ont déjà
- * été validées juste avant, la valeur ne peut être que 1, 2 ou 3.
- */
- niveau: z.coerce.number().int().min(1).max(3).default(1).transform((n) => n as 1 | 2 | 3),
- /** Restreint à un poste parent : un code1 pour niveau=2, un code2 pour niveau=3. */
- parent: z.string().min(1).optional(),
-});
-
-export const productDetailSchema = z.object({
- fournisseur: z.string().min(1).optional(),
- /**
- * `1` (défaut) : calcule l'instantané à la demande si le produit n'y figure pas
- * encore. Nécessite `fournisseur`, le calcul se faisant par lot fournisseur.
- */
- compute: z.enum(["0", "1"]).default("1"),
-});
-
-const CODES_GAMME = GAMMES.map((g) => g.code) as [CodeGamme, ...CodeGamme[]];
-const gammeShape = z.enum(CODES_GAMME, {
- message: `Gamme inconnue. Valeurs acceptées : ${CODES_GAMME.join(", ")}`,
-});
-
-/** `PUT /api/v1/products/:codein/gamme` — affecte ou change la gamme d'un article. */
-export const productGammeBodySchema = z.object({
- gamme: gammeShape,
- /** Obligatoire seulement si l'article est référencé chez plusieurs fournisseurs. */
- fournisseur: z.string().min(1).optional(),
- /** `true` (défaut) : calcule l'instantané du fournisseur s'il n'existe pas encore. */
- compute: z.boolean().default(true),
-});
-
-/** `POST /api/v1/gammes` — affecte des gammes à plusieurs articles d'un fournisseur. */
-export const gammesBatchBodySchema = z.object({
- fournisseur: z.string().min(1, "Champ 'fournisseur' requis"),
- changes: z
- .array(z.object({ codein: z.string().min(1), gamme: gammeShape }))
- .min(1, "Au moins un changement attendu")
- .max(10_000, "10 000 changements au maximum par appel"),
- compute: z.boolean().default(true),
-});
-
-/**
- * Projection de champs : `?fields=codein,libelle1,totalCa`.
- *
- * Sert à alléger la réponse — un `ProductRow` complet porte les séries mensuelles
- * et les ventilations par magasin, ce qui est volumineux sur plusieurs centaines de
- * lignes. `codein` est toujours conservé pour que la ligne reste identifiable.
- */
-export function pickFields(row: T, fields?: string): Partial {
- if (!fields) return row;
- const wanted = new Set(
- fields.split(",").map((f) => f.trim()).filter(Boolean),
- );
- if (wanted.size === 0) return row;
- wanted.add("codein");
- const out: Record = {};
- for (const key of wanted) {
- if (key in row) out[key] = (row as unknown as Record)[key];
- }
- return out as Partial;
-}
-
-/** Normalise le tri validé vers la clé attendue par grid-store. */
-export function toSortKey(sort?: string): GridSortKey | undefined {
- return sort as GridSortKey | undefined;
-}
diff --git a/src/lib/auth.config.ts b/src/lib/auth.config.ts
deleted file mode 100644
index 35703da..0000000
--- a/src/lib/auth.config.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import type { NextAuthConfig } from "next-auth";
-
-export const authConfig = {
- pages: {
- signIn: "/login",
- },
- callbacks: {
- async jwt({ token, user }) {
- if (user) {
- token.role = (user as any).role;
- token.id = user.id;
- }
- return token;
- },
- async session({ session, token }) {
- if (session.user) {
- (session.user as any).role = token.role as string;
- (session.user as any).id = token.id as string;
- }
- return session;
- },
- },
- providers: [], // Les providers seront ajoutés dans auth.ts
-} satisfies NextAuthConfig;
diff --git a/src/lib/auth.ts b/src/lib/auth.ts
deleted file mode 100644
index 9f0927f..0000000
--- a/src/lib/auth.ts
+++ /dev/null
@@ -1,73 +0,0 @@
-import NextAuth from "next-auth";
-import Credentials from "next-auth/providers/credentials";
-import { db } from "@/db";
-import { users } from "@/db/schema";
-import { eq } from "drizzle-orm";
-import { verifyPassword, getFallbackUsers } from "@/features/auth/logic/auth-logic";
-import { ensureAdminExists } from "@/features/auth/logic/seed-admin";
-import { authConfig } from "./auth.config";
-
-export const { handlers, auth, signIn, signOut } = NextAuth({
- ...authConfig,
- providers: [
- Credentials({
- name: "Credentials",
- credentials: {
- username: { label: "Utilisateur", type: "text" },
- password: { label: "Mot de passe", type: "password" }
- },
- async authorize(credentials) {
- await ensureAdminExists();
-
- if (!credentials?.username || !credentials?.password) return null;
-
- try {
- console.log(`[AUTH] Checking user "${credentials.username}"...`);
-
- let user: { id: number | string; username: string; passwordHash: string; role: string } | undefined;
-
- // Try DB first
- try {
- const [dbUser] = await db.select()
- .from(users)
- .where(eq(users.username, credentials.username as string));
- user = dbUser;
- console.log(`[AUTH] DB check: User found: ${!!user}`);
- } catch {
- // Base injoignable uniquement : un compte absent de la base ne doit
- // pas pouvoir se connecter avec le fichier de secours (admin/admin).
- console.warn("[AUTH] DB unreachable, falling back to JSON.");
- const fallbackUsers = getFallbackUsers();
- user = fallbackUsers.find(u => u.username === credentials.username);
- console.log(`[AUTH] JSON check: User found: ${!!user}`);
- }
-
- if (!user) {
- console.warn(`[AUTH] User "${credentials.username}" not found anywhere.`);
- return null;
- }
-
- const isValid = verifyPassword(credentials.password as string, user.passwordHash);
- console.log(`[AUTH] Password valid for "${credentials.username}": ${isValid}`);
-
- if (!isValid) {
- console.warn(`[AUTH] Invalid password for user "${credentials.username}".`);
- return null;
- }
-
- return {
- id: user.id.toString(),
- // `name` est repris dans la session : sans lui, l'en-tête ne
- // pouvait pas afficher qui est connecté.
- name: user.username,
- username: user.username,
- role: user.role,
- };
- } catch (err: any) {
- console.error("[AUTH] CRITICAL ERROR during authorize callback:", err.message || err);
- return null;
- }
- }
- })
- ],
-});
diff --git a/src/lib/authz.ts b/src/lib/authz.ts
deleted file mode 100644
index fc90420..0000000
--- a/src/lib/authz.ts
+++ /dev/null
@@ -1,164 +0,0 @@
-/**
- * CollectFlow — Contrôle d'accès commun aux actions serveur, routes et pages.
- *
- * Le jeton de session (JWT) seul ne suffit pas : il reste valide jusqu'à son
- * expiration, même si le compte a été supprimé ou rétrogradé entre-temps. On
- * relit donc l'utilisateur dans la table `users` (avec un cache court), et le
- * rôle enregistré en base l'emporte sur celui du jeton.
- *
- * Base injoignable : on se contente du jeton (mode dégradé), sans quoi le compte
- * de secours `data/users.json` ne pourrait plus rien faire — y compris configurer
- * la base.
- */
-
-import "server-only";
-
-import { NextResponse } from "next/server";
-import { eq } from "drizzle-orm";
-import { auth } from "@/lib/auth";
-import { db } from "@/db";
-import { users } from "@/db/schema";
-
-export interface UtilisateurCourant {
- id: string;
- username: string;
- role: string;
-}
-
-const MESSAGE_SESSION = "Session expirée : reconnectez-vous.";
-const MESSAGE_ADMIN = "Action réservée aux administrateurs.";
-
-/** Refus d'accès. `statut` sert aux routes : 401 sans session valide, 403 sans le rôle requis. */
-export class AccesRefuse extends Error {
- constructor(message: string, readonly statut: 401 | 403 = 403) {
- super(message);
- this.name = "AccesRefuse";
- }
-}
-
-// ── Relecture du compte en base ──────────────────────────────────────────────
-
-/** Durée pendant laquelle une relecture de la table `users` est réutilisée. */
-const CACHE_TTL_MS = 60_000;
-/** Après un échec de connexion, on ne réessaie pas avant ce délai (chaque essai peut durer 10 s). */
-const PAUSE_BASE_INJOIGNABLE_MS = 15_000;
-
-interface FicheUtilisateur {
- exists: boolean;
- role: string;
- username: string;
- at: number;
-}
-
-const cache = new Map();
-let baseInjoignableDepuis = 0;
-
-/** Plus grand entier accepté par la colonne `users.id` (serial). */
-const ID_MAX = 2_147_483_647;
-
-/**
- * Fiche de l'utilisateur en base, ou `null` si la base n'a pas pu répondre.
- * Un identifiant qui ne peut pas exister (compte de secours « 0 », valeur non
- * numérique) est cherché tel quel : introuvable si la base répond.
- */
-async function lireFiche(id: string): Promise {
- const maintenant = Date.now();
- const enCache = cache.get(id);
- if (enCache && maintenant - enCache.at < CACHE_TTL_MS) return enCache;
- if (maintenant - baseInjoignableDepuis < PAUSE_BASE_INJOIGNABLE_MS) return null;
-
- const n = /^\d+$/.test(id) ? Number(id) : -1;
- const idNumerique = Number.isSafeInteger(n) && n <= ID_MAX ? n : -1;
-
- try {
- const [ligne] = await db
- .select({ username: users.username, role: users.role })
- .from(users)
- .where(eq(users.id, idNumerique))
- .limit(1);
- const fiche: FicheUtilisateur = ligne
- ? { exists: true, role: ligne.role, username: ligne.username, at: maintenant }
- : { exists: false, role: "", username: "", at: maintenant };
- cache.set(id, fiche);
- return fiche;
- } catch (e) {
- baseInjoignableDepuis = maintenant;
- console.warn("[authz] Base injoignable, contrôle sur le seul jeton de session :", (e as Error).message?.slice(0, 200));
- return null;
- }
-}
-
-// ── Contrôles ────────────────────────────────────────────────────────────────
-
-/** Utilisateur connecté, relu en base. Lève `AccesRefuse` (401) sinon. */
-export async function requireSession(): Promise {
- const session = await auth();
- const jeton = session?.user as { id?: string | number; name?: string | null; role?: string } | undefined;
- if (!jeton) throw new AccesRefuse(MESSAGE_SESSION, 401);
-
- const id = jeton.id != null ? String(jeton.id) : "";
- const fiche = await lireFiche(id);
-
- if (!fiche) {
- // Mode dégradé : le jeton fait foi.
- return { id, username: jeton.name ?? "", role: jeton.role ?? "user" };
- }
- if (!fiche.exists) throw new AccesRefuse(MESSAGE_SESSION, 401);
- return { id, username: fiche.username, role: fiche.role };
-}
-
-/** Administrateur connecté. Lève `AccesRefuse` (401 ou 403) sinon. */
-export async function requireAdmin(): Promise {
- const utilisateur = await requireSession();
- if (utilisateur.role !== "admin") throw new AccesRefuse(MESSAGE_ADMIN, 403);
- return utilisateur;
-}
-
-// ── Variantes sans exception ─────────────────────────────────────────────────
-
-export type Autorisation =
- | { ok: true; utilisateur: UtilisateurCourant }
- | { ok: false; message: string; statut: 401 | 403 };
-
-async function verifier(controle: () => Promise): Promise {
- try {
- return { ok: true, utilisateur: await controle() };
- } catch (e) {
- if (e instanceof AccesRefuse) return { ok: false, message: e.message, statut: e.statut };
- throw e;
- }
-}
-
-/**
- * Pour les actions qui renvoient un résultat `{ success: false, error }` plutôt
- * que de lever une exception, et pour les pages (le `redirect()` doit être appelé
- * hors d'un try/catch).
- */
-export function verifierSession(): Promise {
- return verifier(requireSession);
-}
-
-export function verifierAdmin(): Promise {
- return verifier(requireAdmin);
-}
-
-// ── Variantes pour les routes ────────────────────────────────────────────────
-
-function reponse(a: Autorisation): UtilisateurCourant | Response {
- return a.ok ? a.utilisateur : NextResponse.json({ error: a.message }, { status: a.statut });
-}
-
-/**
- * Utilisateur connecté, ou réponse JSON 401 à renvoyer telle quelle :
- *
- * const acces = await sessionOuReponse();
- * if (acces instanceof Response) return acces;
- */
-export async function sessionOuReponse(): Promise {
- return reponse(await verifierSession());
-}
-
-/** Administrateur connecté, ou réponse JSON 401 / 403 à renvoyer telle quelle. */
-export async function adminOuReponse(): Promise {
- return reponse(await verifierAdmin());
-}
diff --git a/src/lib/ff-cache.ts b/src/lib/ff-cache.ts
deleted file mode 100644
index be2c94c..0000000
--- a/src/lib/ff-cache.ts
+++ /dev/null
@@ -1,114 +0,0 @@
-/**
- * CollectFlow — Cache mémoire des lectures « FF » (base miroir et API FF Nancy).
- *
- * Les tables FF (`mvtart`, `cube_stock`, `articles`…) ne sont recopiées qu'une
- * fois par nuit depuis SQL Server : recalculer à chaque visite les mêmes
- * agrégations lourdes (stock, hit-parade, CA mensuel…) coûtait plusieurs
- * secondes par page pour un résultat identique.
- *
- * Pourquoi pas `unstable_cache` : il sérialise en JSON (une `Map` devient `{}`,
- * une `Date` une chaîne) et ne peut pas être invalidé hors d'une requête — or
- * c'est la synchro nocturne, lancée par un minuteur, qui sait quand les données
- * changent. Ici :
- * - une durée de vie bornée (FF_CACHE_TTL_S, 30 min par défaut) ;
- * - les appels simultanés pour la même clé partagent une seule requête ;
- * - une erreur n'est jamais mise en cache ;
- * - `invalidateFFCache()` vide tout (appelé en fin de synchro nocturne).
- */
-
-import "server-only";
-
-import { pgGetDerniereReceptionParFournisseur, pgGetFournisseurs } from "@/lib/pg-ff-client";
-
-const TTL_MS = (Number(process.env.FF_CACHE_TTL_S) || 30 * 60) * 1000;
-/** Plafond d'entrées : les clés incluent des paramètres (dates, mois, magasin). */
-const MAX_ENTRIES = 100;
-
-interface Entry {
- value?: unknown;
- expiresAt: number;
- pending?: Promise;
-}
-
-// Rangé dans globalThis : un seul cache par processus, même si ce module est
-// présent dans plusieurs lots compilés (routes, instrumentation).
-const globalForFFCache = globalThis as typeof globalThis & {
- __collectflowFFCache?: { store: Map; generation: number };
-};
-const cache = (globalForFFCache.__collectflowFFCache ??= { store: new Map(), generation: 0 });
-const store = cache.store;
-
-interface CachedOptions {
- /** Durée de vie propre à cette clé, en millisecondes. */
- ttlMs?: number;
- /**
- * Ne garder le résultat que s'il passe ce test. Sert aux lectures qui
- * avalent leurs erreurs et renvoient une liste vide : sans ce garde-fou,
- * une panne passagère resterait affichée pendant toute la durée de vie.
- */
- cacheIf?: (value: T) => boolean;
-}
-
-export async function cachedFF(key: string, load: () => Promise, options: CachedOptions = {}): Promise {
- const now = Date.now();
- const entry = store.get(key);
- if (entry && "value" in entry && entry.expiresAt > now) return entry.value as T;
- if (entry?.pending) return entry.pending as Promise;
-
- // Une invalidation pendant le chargement rend son résultat suspect : il est
- // alors renvoyé à l'appelant, mais pas conservé.
- const generation = cache.generation;
- const pending = load().then(
- (value) => {
- if (generation !== cache.generation) return value;
- if (options.cacheIf && !options.cacheIf(value)) {
- store.delete(key);
- } else {
- store.delete(key); // réinsertion en fin : ordre d'éviction = ancienneté
- store.set(key, { value, expiresAt: Date.now() + (options.ttlMs ?? TTL_MS) });
- while (store.size > MAX_ENTRIES) {
- const oldest = store.keys().next().value;
- if (oldest === undefined) break;
- store.delete(oldest);
- }
- }
- return value;
- },
- (error) => {
- if (generation === cache.generation) store.delete(key);
- throw error;
- },
- );
- // Une éventuelle valeur expirée est remplacée : seule la requête en cours compte.
- store.set(key, { expiresAt: 0, pending });
- return pending;
-}
-
-/** Vide tout le cache FF (fin de synchro nocturne, données fraîches). */
-export function invalidateFFCache(): void {
- cache.generation++;
- store.clear();
-}
-
-// ---------------------------------------------------------------------------
-// Lectures partagées par plusieurs pages
-// ---------------------------------------------------------------------------
-
-/** Référentiel fournisseurs (Grille, cadencier). Vide = erreur avalée, non gardé. */
-export function getFournisseursCached(): Promise<{ code: string; nom: string }[]> {
- return cachedFF("fournisseurs", () => pgGetFournisseurs(), { cacheIf: (rows) => rows.length > 0 });
-}
-
-/**
- * Dernière réception par fournisseur et magasin, pour les fournisseurs du
- * cadencier seulement : de loin la lecture la plus lourde de la page Commandes.
- * Clé = liste triée, donc recalculée quand une cadence est ajoutée ou retirée.
- * Vide = erreur avalée (ou aucune réception), non gardé.
- */
-export function getDerniereReceptionCached(codes: string[]): Promise> {
- const liste = [...new Set(codes.map((c) => c.trim()))].sort();
- if (liste.length === 0) return Promise.resolve(new Map());
- return cachedFF(`derniere-reception:${liste.join(",")}`, () => pgGetDerniereReceptionParFournisseur(liste), {
- cacheIf: (map) => map.size > 0,
- });
-}
diff --git a/src/lib/gammes-a-valider.ts b/src/lib/gammes-a-valider.ts
deleted file mode 100644
index 4ba91d1..0000000
--- a/src/lib/gammes-a-valider.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-/**
- * CollectFlow — Gammes proposées par l'API, en attente de validation.
- *
- * L'API `/api/v1` ne change plus une gamme directement : elle dépose une
- * proposition, que la Grille affiche comme une modification non enregistrée.
- * L'utilisateur voit ainsi quels produits changent de gamme, puis valide
- * (« Enregistrer ») ou rejette (« Annuler les modifications »).
- */
-
-import "server-only";
-
-import { and, eq, inArray, sql } from "drizzle-orm";
-import { db } from "@/db";
-import { gammesAValider } from "@/db/schema";
-
-export interface PropositionGamme {
- codein: string;
- /** Gamme proposée. */
- gamme: string;
- /** Gamme enregistrée au moment de la proposition. */
- gammePrecedente: string | null;
-}
-
-export interface GammeAValider extends PropositionGamme {
- auteur: string | null;
- /** Date ISO de la proposition. */
- proposeeLe: string;
-}
-
-/**
- * Dépose des propositions (la dernière l'emporte pour un même article) et retire
- * celles des articles `annules` — redemander la gamme déjà enregistrée annule la
- * proposition en attente.
- */
-export async function proposerGammes(input: {
- codeFournisseur: string;
- propositions: PropositionGamme[];
- annules: string[];
- auteur: string;
-}): Promise {
- const { codeFournisseur, propositions, annules, auteur } = input;
- await db.transaction(async (tx) => {
- if (annules.length > 0) {
- await tx
- .delete(gammesAValider)
- .where(and(eq(gammesAValider.codeFournisseur, codeFournisseur), inArray(gammesAValider.codein, annules)));
- }
- if (propositions.length > 0) {
- const maintenant = new Date();
- await tx
- .insert(gammesAValider)
- .values(propositions.map((p) => ({
- codeFournisseur,
- codein: p.codein,
- gamme: p.gamme,
- gammePrecedente: p.gammePrecedente,
- auteur: auteur.slice(0, 100),
- createdAt: maintenant,
- })))
- .onConflictDoUpdate({
- target: [gammesAValider.codeFournisseur, gammesAValider.codein],
- set: {
- gamme: sql`excluded.gamme`,
- gammePrecedente: sql`excluded.gamme_precedente`,
- auteur: sql`excluded.auteur`,
- createdAt: sql`excluded.created_at`,
- },
- });
- }
- });
-}
-
-/** Propositions en attente pour un fournisseur. */
-export async function listerGammesAValider(codeFournisseur: string): Promise {
- const rows = await db
- .select()
- .from(gammesAValider)
- .where(eq(gammesAValider.codeFournisseur, codeFournisseur));
- return rows.map((r) => ({
- codein: r.codein,
- gamme: r.gamme,
- gammePrecedente: r.gammePrecedente,
- auteur: r.auteur,
- proposeeLe: r.createdAt.toISOString(),
- }));
-}
-
-/** Propositions en attente pour une liste d'articles, indexées par `fournisseur|codein`. */
-export async function gammesAValiderParArticle(codeins: string[]): Promise> {
- if (codeins.length === 0) return new Map();
- const rows = await db
- .select({ codeFournisseur: gammesAValider.codeFournisseur, codein: gammesAValider.codein, gamme: gammesAValider.gamme })
- .from(gammesAValider)
- .where(inArray(gammesAValider.codein, codeins));
- return new Map(rows.map((r) => [`${r.codeFournisseur}|${r.codein}`, r.gamme]));
-}
-
-/** Retire des propositions, une fois validées ou rejetées dans la Grille. */
-export async function supprimerGammesAValider(codeFournisseur: string, codeins: string[]): Promise {
- if (codeins.length === 0) return;
- await db
- .delete(gammesAValider)
- .where(and(eq(gammesAValider.codeFournisseur, codeFournisseur), inArray(gammesAValider.codein, codeins)));
-}
diff --git a/src/lib/grid-store.ts b/src/lib/grid-store.ts
deleted file mode 100644
index db29e82..0000000
--- a/src/lib/grid-store.ts
+++ /dev/null
@@ -1,485 +0,0 @@
-/**
- * CollectFlow — Instantané persisté de la grille (table `grid_rows`).
- *
- * `getProductRows()` reconstruit la grille en direct (6 requêtes SQL sur la base
- * miroir FF + jointure Qlik) et ne la garde qu'en mémoire 10 minutes. L'API `/api/v1`
- * ne doit **jamais** déclencher ce calcul : elle lit cette table, remplie en effet de
- * bord quand quelqu'un ouvre la Grille.
- *
- * On n'introduit donc aucun calcul supplémentaire — on arrête de jeter un résultat
- * qui existe déjà, et il survit désormais aux redémarrages.
- */
-
-import "server-only";
-
-import { db } from "@/db";
-import { gridRows } from "@/db/schema";
-import { and, asc, desc, eq, ilike, inArray, or, sql, lt, type SQL } from "drizzle-orm";
-import type { ProductRow } from "@/types/grid";
-
-/** Colonnes autorisées au tri — liste blanche, jamais l'entrée utilisateur brute. */
-const SORTABLE = {
- libelle1: gridRows.libelle1,
- codein: gridRows.codein,
- codeFournisseur: gridRows.codeFournisseur,
- codeGamme: gridRows.codeGamme,
- totalCa: gridRows.totalCa,
- totalQuantite: gridRows.totalQuantite,
- totalMarge: gridRows.totalMarge,
- tauxMarge: gridRows.tauxMarge,
- stockActuel: gridRows.stockActuel,
- caReseau: gridRows.caReseau,
- qteReseau: gridRows.qteReseau,
- nbMagasinsReseau: gridRows.nbMagasinsReseau,
- caParMagasinReseau: gridRows.caParMagasinReseau,
- computedAt: gridRows.computedAt,
-} as const;
-
-export type GridSortKey = keyof typeof SORTABLE;
-export const GRID_SORT_KEYS = Object.keys(SORTABLE) as GridSortKey[];
-
-export interface GridQuery {
- codeFournisseur?: string;
- gamme?: string;
- code1?: string;
- code2?: string;
- code3?: string;
- /** Préfixe de nomenclature (« 32 », « 3202 », « 320211 ») — filtre sur code3. */
- nomenclature?: string;
- /** Recherche libre : libellé, codein, GTIN, référence, code centrale. */
- search?: string;
- sort?: GridSortKey;
- order?: "asc" | "desc";
- page?: number;
- limit?: number;
-}
-
-export interface GridQueryResult {
- rows: ProductRow[];
- total: number;
- /** Calcul le plus ancien parmi les lignes renvoyées — fraîcheur de la donnée. */
- computedAt: string | null;
-}
-
-/**
- * Version du format des lignes persistées. À incrémenter dès qu'un champ de
- * `ProductRow` est ajouté ou change de sens : les instantanés plus anciens ne
- * seront plus servis à la Grille (recalcul), mais restent lisibles par /api/v1.
- */
-export const GRID_PAYLOAD_VERSION = 1;
-
-/**
- * Persiste les lignes calculées pour un fournisseur.
- *
- * Stratégie : toutes les lignes du lot portent le même `computedAt`, puis on supprime
- * celles du fournisseur restées sur un `computedAt` antérieur. Cela purge les articles
- * disparus du catalogue sans avoir à passer des centaines de codein en paramètres.
- */
-export async function upsertGridRows(codeFournisseur: string, rows: ProductRow[]): Promise {
- if (!codeFournisseur || rows.length === 0) return 0;
- const computedAt = new Date();
-
- const values = rows
- .filter((r) => r.codein)
- .map((r) => ({
- codeFournisseur,
- codein: r.codein,
- nomFournisseur: r.nomFournisseur ?? null,
- libelle1: r.libelle1 ?? null,
- gtin: r.gtin ?? null,
- reference: r.reference ?? null,
- codeCentrale: r.codeCentrale ?? null,
- code1: r.code1 ?? null,
- code2: r.code2 ?? null,
- code3: r.code3 ?? null,
- codeGamme: r.codeGamme ?? null,
- codeGammeInit: r.codeGammeInit ?? null,
- totalCa: r.totalCa != null ? String(r.totalCa) : null,
- totalQuantite: r.totalQuantite != null ? String(r.totalQuantite) : null,
- totalMarge: r.totalMarge != null ? String(r.totalMarge) : null,
- tauxMarge: r.tauxMarge != null ? String(r.tauxMarge) : null,
- stockActuel: r.stockActuel != null ? String(r.stockActuel) : null,
- caReseau: r.caReseau != null ? String(r.caReseau) : null,
- qteReseau: r.qteReseau != null ? String(r.qteReseau) : null,
- nbMagasinsReseau: r.nbMagasinsReseau ?? null,
- caParMagasinReseau: r.caParMagasinReseau != null ? String(r.caParMagasinReseau) : null,
- margePctReseau: r.margePctReseau != null ? String(r.margePctReseau) : null,
- payload: { ...r, payloadVersion: GRID_PAYLOAD_VERSION },
- computedAt,
- }));
- if (values.length === 0) return 0;
-
- const CHUNK = 200; // payload jsonb volumineux : lots plus petits que pour des scalaires
- let written = 0;
- for (let i = 0; i < values.length; i += CHUNK) {
- const batch = values.slice(i, i + CHUNK);
- await db
- .insert(gridRows)
- .values(batch)
- .onConflictDoUpdate({
- target: [gridRows.codeFournisseur, gridRows.codein],
- set: {
- nomFournisseur: sql`excluded.nom_fournisseur`,
- libelle1: sql`excluded.libelle1`,
- gtin: sql`excluded.gtin`,
- reference: sql`excluded.reference`,
- codeCentrale: sql`excluded.code_centrale`,
- code1: sql`excluded.code1`,
- code2: sql`excluded.code2`,
- code3: sql`excluded.code3`,
- codeGamme: sql`excluded.code_gamme`,
- codeGammeInit: sql`excluded.code_gamme_init`,
- totalCa: sql`excluded.total_ca`,
- totalQuantite: sql`excluded.total_quantite`,
- totalMarge: sql`excluded.total_marge`,
- tauxMarge: sql`excluded.taux_marge`,
- stockActuel: sql`excluded.stock_actuel`,
- caReseau: sql`excluded.ca_reseau`,
- qteReseau: sql`excluded.qte_reseau`,
- nbMagasinsReseau: sql`excluded.nb_magasins_reseau`,
- caParMagasinReseau: sql`excluded.ca_par_magasin_reseau`,
- margePctReseau: sql`excluded.marge_pct_reseau`,
- payload: sql`excluded.payload`,
- computedAt: sql`excluded.computed_at`,
- },
- });
- written += batch.length;
- }
-
- // Purge des articles qui ne font plus partie du catalogue du fournisseur.
- await db.delete(gridRows).where(
- and(eq(gridRows.codeFournisseur, codeFournisseur), lt(gridRows.computedAt, computedAt)),
- );
-
- return written;
-}
-
-/**
- * Instantané complet d'un fournisseur, tel que persisté par le dernier calcul.
- *
- * Renvoie `null` (→ recalcul) si rien n'est persisté, si une ligne est d'une
- * version de format antérieure, ou si le calcul date d'un autre mois que le mois
- * en cours : la fenêtre des 12 mois glissants aurait changé entre-temps.
- * Les lignes sont rendues dans l'ordre du calcul en direct (identifiant article).
- */
-export async function readGridSnapshot(
- codeFournisseur: string,
-): Promise<{ rows: ProductRow[]; computedAt: Date } | null> {
- const found = await db
- .select({ payload: gridRows.payload, computedAt: gridRows.computedAt })
- .from(gridRows)
- .where(eq(gridRows.codeFournisseur, codeFournisseur));
- if (found.length === 0) return null;
-
- let oldest: Date | null = null;
- const rows: ProductRow[] = [];
- for (const r of found) {
- const row = r.payload as ProductRow;
- if (row.payloadVersion !== GRID_PAYLOAD_VERSION) return null;
- if (!oldest || r.computedAt < oldest) oldest = r.computedAt;
- rows.push(row);
- }
- const now = new Date();
- if (!oldest || oldest.getFullYear() !== now.getFullYear() || oldest.getMonth() !== now.getMonth()) {
- return null;
- }
- rows.sort((a, b) => (a.noid ?? 0) - (b.noid ?? 0));
- return { rows, computedAt: oldest };
-}
-
-/**
- * Reporte des gammes enregistrées dans l'instantané persisté (colonne et payload),
- * pour que /api/v1 les voie sans attendre un recalcul complet de la grille.
- */
-export async function updateGridRowsGamme(
- codeFournisseur: string,
- changes: ReadonlyArray<{ codein: string; codeGamme: string }>,
-): Promise {
- const parGamme = new Map();
- for (const c of changes) {
- const codeins = parGamme.get(c.codeGamme) ?? [];
- codeins.push(c.codein);
- parGamme.set(c.codeGamme, codeins);
- }
- const CHUNK = 5000; // bien en deçà des 65 535 paramètres liés de PostgreSQL
- for (const [gamme, codeins] of parGamme) {
- for (let i = 0; i < codeins.length; i += CHUNK) {
- await db
- .update(gridRows)
- .set({
- codeGamme: gamme,
- payload: sql`jsonb_set(${gridRows.payload}, '{codeGamme}', to_jsonb(${gamme}::text))`,
- })
- .where(and(
- eq(gridRows.codeFournisseur, codeFournisseur),
- inArray(gridRows.codein, codeins.slice(i, i + CHUNK)),
- ));
- }
- }
-}
-
-/** Construit la clause WHERE commune à la grille et à la recherche transversale. */
-function buildWhere(q: GridQuery): SQL | undefined {
- const clauses: SQL[] = [];
- if (q.codeFournisseur) clauses.push(eq(gridRows.codeFournisseur, q.codeFournisseur));
- if (q.gamme) clauses.push(eq(gridRows.codeGamme, q.gamme));
- if (q.code1) clauses.push(eq(gridRows.code1, q.code1));
- if (q.code2) clauses.push(eq(gridRows.code2, q.code2));
- if (q.code3) clauses.push(eq(gridRows.code3, q.code3));
- // Filtre par **préfixe** de nomenclature : « 32 », « 3202 » ou « 320211 ».
- // C'est celui à utiliser avec /api/v1/nomenclatures, car il ne dépend pas de
- // code1/code2 — parfois vides quand la hiérarchie n'a pas pu être remontée.
- if (q.nomenclature) clauses.push(sql`${gridRows.code3} like ${q.nomenclature + "%"}`);
- const search = q.search?.trim();
- if (search) {
- const pattern = `%${search}%`;
- const alt = or(
- ilike(gridRows.libelle1, pattern),
- ilike(gridRows.codein, pattern),
- ilike(gridRows.gtin, pattern),
- ilike(gridRows.reference, pattern),
- ilike(gridRows.codeCentrale, pattern),
- );
- if (alt) clauses.push(alt);
- }
- return clauses.length ? and(...clauses) : undefined;
-}
-
-/**
- * Lit les lignes de grille persistées : filtre, tri et pagination faits en SQL.
- * Ne déclenche aucun recalcul et ne contacte jamais Qlik.
- */
-export async function queryGridRows(q: GridQuery): Promise {
- const page = Math.max(1, q.page ?? 1);
- // `limit` absent = aucune limite : on renvoie toutes les lignes du filtre.
- // Il y avait ici un Math.min(500, …) qui re-plafonnait en silence, quelle que
- // soit la valeur demandée — la réponse était tronquée sans que rien ne le dise.
- const limit = q.limit != null ? Math.max(1, q.limit) : null;
- const where = buildWhere(q);
-
- const sortCol = SORTABLE[q.sort ?? "totalCa"] ?? gridRows.totalCa;
- // NULLS LAST dans les deux sens : un produit sans CA ne doit jamais occuper la tête.
- const orderBy = q.order === "asc" ? asc(sortCol) : desc(sortCol);
-
- const selection = db
- .select({ payload: gridRows.payload, computedAt: gridRows.computedAt })
- .from(gridRows)
- .where(where)
- .orderBy(orderBy, asc(gridRows.codein));
-
- // Comptage et page en parallèle : deux connexions du pool, un seul temps d'attente.
- const [[countRow], found] = await Promise.all([
- db.select({ total: sql`count(*)::int` }).from(gridRows).where(where),
- limit != null ? selection.limit(limit).offset((page - 1) * limit) : selection,
- ]);
-
- let oldest: Date | null = null;
- for (const r of found) {
- if (r.computedAt && (!oldest || r.computedAt < oldest)) oldest = r.computedAt;
- }
-
- return {
- rows: found.map((r) => versLigneApi(r.payload)),
- total: countRow?.total ?? 0,
- computedAt: oldest ? oldest.toISOString() : null,
- };
-}
-
-/** Ligne exposée par l'API : la version de format est un détail interne. */
-function versLigneApi(payload: unknown): ProductRow {
- const ligne = { ...(payload as ProductRow) };
- delete ligne.payloadVersion;
- return ligne;
-}
-
-/** Fiche complète d'un produit. `codeFournisseur` lève l'ambiguïté d'un article multi-fournisseurs. */
-export async function getGridRowByCodein(
- codein: string,
- codeFournisseur?: string,
-): Promise<{ row: ProductRow; computedAt: string | null } | null> {
- const clauses: SQL[] = [eq(gridRows.codein, codein)];
- if (codeFournisseur) clauses.push(eq(gridRows.codeFournisseur, codeFournisseur));
-
- const [found] = await db
- .select({ payload: gridRows.payload, computedAt: gridRows.computedAt })
- .from(gridRows)
- .where(and(...clauses))
- .orderBy(desc(gridRows.computedAt))
- .limit(1);
-
- if (!found) return null;
- return {
- row: versLigneApi(found.payload),
- computedAt: found.computedAt ? found.computedAt.toISOString() : null,
- };
-}
-
-/** Fournisseurs chez lesquels un article figure dans l'instantané. */
-export async function listGridSuppliersForCodein(
- codein: string,
-): Promise> {
- return db
- .select({ codeFournisseur: gridRows.codeFournisseur, nomFournisseur: gridRows.nomFournisseur })
- .from(gridRows)
- .where(eq(gridRows.codein, codein))
- .orderBy(asc(gridRows.codeFournisseur));
-}
-
-export interface GammeInstantane {
- /** Gamme courante, modifications enregistrées comprises. */
- codeGamme: string | null;
- /** Gamme serveur au moment du calcul de la grille. */
- codeGammeInit: string | null;
- nomFournisseur: string | null;
-}
-
-/**
- * Gammes d'articles d'un fournisseur dans l'instantané. Un codein absent de la
- * carte n'appartient pas à ce fournisseur (ou n'a pas encore été calculé).
- */
-export async function getGridRowsGammes(
- codeFournisseur: string,
- codeins: readonly string[],
-): Promise> {
- const out = new Map();
- const CHUNK = 5000; // bien en deçà des 65 535 paramètres liés de PostgreSQL
- for (let i = 0; i < codeins.length; i += CHUNK) {
- const found = await db
- .select({
- codein: gridRows.codein,
- codeGamme: gridRows.codeGamme,
- codeGammeInit: gridRows.codeGammeInit,
- nomFournisseur: gridRows.nomFournisseur,
- })
- .from(gridRows)
- .where(and(
- eq(gridRows.codeFournisseur, codeFournisseur),
- inArray(gridRows.codein, codeins.slice(i, i + CHUNK)),
- ));
- for (const r of found) {
- out.set(r.codein, { codeGamme: r.codeGamme, codeGammeInit: r.codeGammeInit, nomFournisseur: r.nomFournisseur });
- }
- }
- return out;
-}
-
-/**
- * Indique si un fournisseur a déjà été calculé au moins une fois.
- * Sert à répondre `202 not_ready` plutôt que de déclencher un calcul long.
- */
-export async function getGridFreshness(
- codeFournisseur: string,
-): Promise<{ rowCount: number; computedAt: string | null } | null> {
- const [found] = await db
- .select({
- rowCount: sql`count(*)::int`,
- computedAt: sql`max(${gridRows.computedAt})`,
- })
- .from(gridRows)
- .where(eq(gridRows.codeFournisseur, codeFournisseur));
-
- if (!found || found.rowCount === 0) return null;
- return {
- rowCount: found.rowCount,
- computedAt: found.computedAt ? new Date(found.computedAt).toISOString() : null,
- };
-}
-
-/** Fournisseurs présents dans l'instantané, avec leur fraîcheur. */
-export async function listGridSuppliers(): Promise<
- Array<{ codeFournisseur: string; nomFournisseur: string | null; rowCount: number; computedAt: string | null }>
-> {
- const found = await db
- .select({
- codeFournisseur: gridRows.codeFournisseur,
- nomFournisseur: sql`max(${gridRows.nomFournisseur})`,
- rowCount: sql`count(*)::int`,
- computedAt: sql`max(${gridRows.computedAt})`,
- })
- .from(gridRows)
- .groupBy(gridRows.codeFournisseur)
- .orderBy(asc(gridRows.codeFournisseur));
-
- return found.map((r) => ({
- codeFournisseur: r.codeFournisseur,
- nomFournisseur: r.nomFournisseur,
- rowCount: r.rowCount,
- computedAt: r.computedAt ? new Date(r.computedAt).toISOString() : null,
- }));
-}
-
-// ---------------------------------------------------------------------------
-// Inventaire des nomenclatures d'un fournisseur
-// ---------------------------------------------------------------------------
-
-/** Un poste de nomenclature, avec son poids — de quoi décider par où découper. */
-export interface GridNomenclature {
- code: string;
- /** Libellé du poste, lu dans le payload (il n'a pas de colonne dédiée). */
- libelle: string | null;
- nbArticles: number;
- totalCa: number;
- totalQuantite: number;
-}
-
-/** Longueur du code pour chaque niveau : « 32 » → « 3202 » → « 320211 ». */
-export const NOMENCLATURE_LONGUEURS: Record<1 | 2 | 3, number> = { 1: 2, 2: 4, 3: 6 };
-
-/**
- * Répartition des articles d'un fournisseur par niveau de nomenclature.
- *
- * Sans cela, un appelant qui veut découper un gros fournisseur par nomenclature
- * est coincé : le filtre existe sur `/grid`, mais rien ne lui dit **quelles**
- * valeurs existent — il devrait tout télécharger pour les découvrir, ce qui
- * annule le bénéfice du découpage.
- *
- * Les niveaux sont dérivés par **préfixe de `code3`** (codes hiérarchiques à 6
- * chiffres, de 31xxxx à 40xxxx), et non des colonnes `code1`/`code2`. Celles-ci
- * ne sont renseignées que si `pgGetNomenclatureByFournisseur` a su remonter la
- * hiérarchie, ce qui dépend d'une détection heuristique de la colonne parent de
- * la table `nomenclature` ; quand elle échoue, seul `code3` est rempli. Le
- * préfixe, lui, est toujours disponible.
- *
- * Tout est agrégé en SQL : la réponse fait quelques dizaines de lignes, même pour
- * un fournisseur de 130 000 articles.
- */
-export async function listGridNomenclatures(
- codeFournisseur: string,
- niveau: 1 | 2 | 3,
- parent?: string,
-): Promise {
- const longueur = NOMENCLATURE_LONGUEURS[niveau];
- const codeExpr = sql`left(${gridRows.code3}, ${longueur})`;
- // Les libellés n'ont pas de colonne dédiée : on les lit dans le payload.
- // Aux niveaux 1 et 2 ils peuvent être absents (même cause que ci-dessus) ;
- // le code et les compteurs, eux, restent justes.
- const libelleKey = niveau === 1 ? "libelleNiveau1" : niveau === 2 ? "libelleNiveau2" : "libelle3";
-
- const clauses: SQL[] = [
- eq(gridRows.codeFournisseur, codeFournisseur),
- sql`${gridRows.code3} is not null and length(${gridRows.code3}) >= ${longueur}`,
- ];
- // `parent` est lui aussi un préfixe : « 32 » pour descendre au niveau 2.
- if (parent) clauses.push(sql`${gridRows.code3} like ${parent + "%"}`);
-
- const rows = await db
- .select({
- code: codeExpr,
- libelle: sql`max(${gridRows.payload} ->> ${libelleKey})`,
- nbArticles: sql`count(*)::int`,
- totalCa: sql`coalesce(sum(${gridRows.totalCa}), 0)::float`,
- totalQuantite: sql`coalesce(sum(${gridRows.totalQuantite}), 0)::float`,
- })
- .from(gridRows)
- .where(and(...clauses))
- .groupBy(codeExpr)
- .orderBy(desc(sql`coalesce(sum(${gridRows.totalCa}), 0)`));
-
- return rows.map((r) => ({
- code: String(r.code ?? ""),
- libelle: r.libelle ?? null,
- nbArticles: Number(r.nbArticles) || 0,
- totalCa: Number(r.totalCa) || 0,
- totalQuantite: Number(r.totalQuantite) || 0,
- }));
-}
diff --git a/src/lib/log-capture.ts b/src/lib/log-capture.ts
deleted file mode 100644
index e3ddf71..0000000
--- a/src/lib/log-capture.ts
+++ /dev/null
@@ -1,243 +0,0 @@
-/**
- * CollectFlow — Capture des logs serveur d'un job, pour téléchargement.
- *
- * POURQUOI. Les extractions Qlik produisent plusieurs milliers de lignes
- * (`[qlik-pw][page] …`, timings, diagnostics du modèle). Or ces lignes ne
- * vivent que dans la sortie standard du conteneur : un terminal les tronque,
- * et un copier-coller ne rapporte que la fin — c'est-à-dire jamais l'entête,
- * là où se trouvent la carte du modèle Qlik et le choix des champs. Sans elle,
- * un diagnostic se fait à l'aveugle.
- *
- * COMMENT. `console.log/warn/error` est instrumenté UNE fois au chargement du
- * module. Tant qu'au moins une capture est ouverte, chaque ligne est recopiée
- * dans les captures ouvertes, puis transmise telle quelle à la console
- * d'origine (rien n'est retenu, rien ne change dans les logs du conteneur).
- *
- * ⚠️ Deux jobs simultanés partagent la sortie standard du process : leurs
- * lignes ne portent pas d'identifiant permettant de les démêler. Chaque
- * capture ouverte reçoit donc TOUTES les lignes de la période — mieux vaut un
- * peu de bruit qu'une ligne manquante dans un journal de diagnostic.
- *
- * Les captures sont écrites sur disque (répertoire temporaire) au fil de l'eau :
- * un job qui fait tomber le process laisse quand même son journal.
- */
-
-import { appendFile, mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-/** Répertoire des journaux. Volontairement hors du projet : ce sont des temporaires. */
-const LOG_DIR = join(tmpdir(), "collectflow-logs");
-
-/** Au-delà, on arrête d'accumuler : un job en boucle ne doit pas manger la RAM. */
-const MAX_LIGNES = 200_000;
-/** Une ligne pathologique (dump d'hypercube) est tronquée plutôt que gardée entière. */
-const MAX_LONGUEUR_LIGNE = 8_000;
-/** Nombre de journaux conservés sur disque. */
-const MAX_FICHIERS = 20;
-/** Écriture disque au plus toutes les N ms (seules les nouvelles lignes sont ajoutées). */
-const FLUSH_MS = 2_000;
-
-interface Capture {
- id: string;
- lignes: string[];
- tronque: boolean;
- debut: number;
- flushEnCours: boolean;
- flushDemande: boolean;
- dernierFlush: number;
- /** Nombre de lignes déjà écrites sur disque. */
- ecrites: number;
-}
-
-const captures = new Map();
-
-/** Nom de fichier sûr : l'id vient d'un job interne, on le verrouille quand même. */
-function fichierPour(id: string): string {
- return join(LOG_DIR, `${id.replace(/[^A-Za-z0-9_.-]/g, "_")}.log`);
-}
-
-function horodatage(): string {
- return new Date().toISOString();
-}
-
-/** Rend une ligne à partir des arguments variadiques de `console.*`. */
-function formater(args: unknown[]): string {
- return args
- .map((a) => {
- if (typeof a === "string") return a;
- if (a instanceof Error) return `${a.message}\n${a.stack ?? ""}`;
- try {
- return JSON.stringify(a);
- } catch {
- return String(a);
- }
- })
- .join(" ");
-}
-
-async function flush(capture: Capture): Promise {
- if (capture.flushEnCours) {
- capture.flushDemande = true;
- return;
- }
- capture.flushEnCours = true;
- try {
- await mkdir(LOG_DIR, { recursive: true });
- // Ajout des seules nouvelles lignes : réécrire tout le journal (jusqu'à
- // 200 000 lignes) toutes les 2 s bloquait le serveur pendant les synchros.
- const total = capture.lignes.length;
- const nouvelles = capture.lignes.slice(capture.ecrites, total);
- if (capture.ecrites === 0) {
- await writeFile(fichierPour(capture.id), nouvelles.join("\n") + "\n", "utf8");
- } else if (nouvelles.length > 0) {
- await appendFile(fichierPour(capture.id), nouvelles.join("\n") + "\n", "utf8");
- }
- capture.ecrites = total;
- capture.dernierFlush = Date.now();
- } catch {
- // Un journal de diagnostic ne doit jamais faire échouer le job qu'il observe.
- } finally {
- capture.flushEnCours = false;
- if (capture.flushDemande) {
- capture.flushDemande = false;
- void flush(capture);
- }
- }
-}
-
-function ajouter(ligne: string): void {
- if (captures.size === 0) return;
- const texte = ligne.length > MAX_LONGUEUR_LIGNE
- ? ligne.slice(0, MAX_LONGUEUR_LIGNE) + " …[ligne tronquée]"
- : ligne;
- const prefixe = `[${horodatage()}] `;
- for (const capture of captures.values()) {
- if (capture.lignes.length >= MAX_LIGNES) {
- if (!capture.tronque) {
- capture.tronque = true;
- capture.lignes.push(`${prefixe}[log-capture] limite de ${MAX_LIGNES} lignes atteinte — suite non enregistrée`);
- }
- continue;
- }
- capture.lignes.push(prefixe + texte);
- if (Date.now() - capture.dernierFlush >= FLUSH_MS) void flush(capture);
- }
-}
-
-/**
- * Instrumente `console` une seule fois, même en développement où le module peut
- * être réévalué à chaud (le drapeau est porté par `globalThis`).
- */
-function instrumenterConsole(): void {
- const g = globalThis as typeof globalThis & { __cfLogCaptureInstalle?: boolean };
- if (g.__cfLogCaptureInstalle) return;
- g.__cfLogCaptureInstalle = true;
-
- const methodes = ["log", "warn", "error", "info"] as const;
- for (const methode of methodes) {
- const origine = console[methode].bind(console);
- console[methode] = (...args: unknown[]) => {
- try {
- // Aucune capture ouverte (le cas courant) : on ne formate rien.
- // Sérialiser chaque argument de chaque log coûtait à toutes les requêtes.
- if (captures.size > 0) ajouter(formater(args));
- } catch {
- // idem : jamais au détriment du log réel
- }
- origine(...args);
- };
- }
-}
-
-instrumenterConsole();
-
-/** Supprime les journaux les plus anciens au-delà de `MAX_FICHIERS`. */
-async function purger(): Promise {
- try {
- const noms = (await readdir(LOG_DIR)).filter((n) => n.endsWith(".log"));
- if (noms.length <= MAX_FICHIERS) return;
- const avecDate = await Promise.all(
- noms.map(async (nom) => {
- const s = await stat(join(LOG_DIR, nom)).catch(() => null);
- return { nom, mtime: s?.mtimeMs ?? 0 };
- }),
- );
- avecDate.sort((a, b) => b.mtime - a.mtime);
- for (const { nom } of avecDate.slice(MAX_FICHIERS)) {
- await unlink(join(LOG_DIR, nom)).catch(() => undefined);
- }
- } catch {
- // purge best-effort
- }
-}
-
-/**
- * Ouvre une capture. Toutes les lignes écrites sur la console à partir de
- * maintenant (par n'importe quel code du process, cf. avertissement en tête)
- * y sont recopiées jusqu'à `stopCapture`.
- */
-export function startCapture(id: string, entete?: string): void {
- const capture: Capture = {
- id,
- lignes: [],
- tronque: false,
- debut: Date.now(),
- flushEnCours: false,
- flushDemande: false,
- dernierFlush: 0,
- ecrites: 0,
- };
- captures.set(id, capture);
- capture.lignes.push(`[${horodatage()}] [log-capture] début de capture ${id}`);
- if (entete) capture.lignes.push(`[${horodatage()}] [log-capture] ${entete}`);
- void flush(capture);
- void purger();
-}
-
-/** Ferme la capture et écrit son état final sur disque. */
-export async function stopCapture(id: string, pied?: string): Promise {
- const capture = captures.get(id);
- if (!capture) return;
- const duree = Math.round((Date.now() - capture.debut) / 1000);
- capture.lignes.push(`[${horodatage()}] [log-capture] fin de capture ${id} — ${capture.lignes.length} lignes, ${duree} s`);
- if (pied) capture.lignes.push(`[${horodatage()}] [log-capture] ${pied}`);
- captures.delete(id);
- await flush(capture);
-}
-
-/**
- * Contenu d'un journal : la capture en cours si elle est ouverte, sinon le
- * fichier laissé sur disque. `null` si aucun des deux n'existe.
- */
-export async function readCapture(id: string): Promise {
- const capture = captures.get(id);
- if (capture) return capture.lignes.join("\n") + "\n";
- try {
- return await readFile(fichierPour(id), "utf8");
- } catch {
- return null;
- }
-}
-
-/** Journaux disponibles, du plus récent au plus ancien. */
-export async function listCaptures(): Promise> {
- const resultats: Array<{ id: string; octets: number; modifieLe: string; enCours: boolean }> = [];
- try {
- for (const nom of await readdir(LOG_DIR)) {
- if (!nom.endsWith(".log")) continue;
- const s = await stat(join(LOG_DIR, nom)).catch(() => null);
- if (!s) continue;
- const id = nom.slice(0, -4);
- resultats.push({
- id,
- octets: s.size,
- modifieLe: new Date(s.mtimeMs).toISOString(),
- enCours: captures.has(id),
- });
- }
- } catch {
- // répertoire pas encore créé
- }
- return resultats.sort((a, b) => b.modifieLe.localeCompare(a.modifieLe));
-}
diff --git a/src/lib/page-data.ts b/src/lib/page-data.ts
new file mode 100644
index 0000000..d47665e
--- /dev/null
+++ b/src/lib/page-data.ts
@@ -0,0 +1,128 @@
+/**
+ * CollectFlow — Données des pages côté navigateur.
+ *
+ * Les pages Next.js étaient des composants serveur : leurs données arrivaient
+ * avec le rendu, `loading.tsx` s'affichait pendant le premier chargement et une
+ * navigation (changement de paramètres, `router.refresh()`) gardait la page à
+ * l'écran jusqu'à l'arrivée des nouvelles données.
+ *
+ * Même fonctionnement ici, avec Suspense : `usePageData` suspend la page sur la
+ * promesse de ses données. Au premier affichage, la frontière Suspense de la
+ * route montre la silhouette (`loading.tsx`) ; lors d'une navigation ou d'un
+ * rafraîchissement — toujours faits en transition — l'ancienne page reste
+ * affichée jusqu'à la réponse.
+ *
+ * Les données sont relues à chaque navigation (clé d'historique de React
+ * Router) et à chaque `router.refresh()` (compteur de rafraîchissement), mais
+ * pas quand l'interface réécrit seulement l'URL (`history.replaceState`, ex.
+ * changement d'onglet) : comme avec Next.js.
+ */
+
+import { createElement, createContext, startTransition, use, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
+import { useLocation } from "react-router";
+
+// ─── Rafraîchissement (router.refresh) ──────────────────────────────────────
+
+const RefreshContext = createContext(0);
+
+let incrementer: (() => void) | null = null;
+
+/** Fournit le compteur de rafraîchissement dont dépendent les données des pages. */
+export function RefreshProvider({ children }: { children: ReactNode }) {
+ const [version, setVersion] = useState(0);
+ useEffect(() => {
+ incrementer = () => setVersion((v) => v + 1);
+ return () => {
+ incrementer = null;
+ };
+ }, []);
+ return createElement(RefreshContext, { value: version }, children);
+}
+
+/** Numéro de rafraîchissement courant. */
+export function useRefreshVersion(): number {
+ return useContext(RefreshContext);
+}
+
+/**
+ * Relit les données de la page affichée (équivalent de `router.refresh()`).
+ * Par défaut en transition : la page reste visible pendant le chargement.
+ */
+export function refreshPage({ transition = true }: { transition?: boolean } = {}): void {
+ if (!incrementer) return;
+ if (transition) startTransition(() => incrementer?.());
+ else incrementer();
+}
+
+// ─── Cache des promesses ────────────────────────────────────────────────────
+
+const MAX_ENTREES = 40;
+const cache = new Map>();
+
+function memo(cle: string, charger: () => Promise): Promise {
+ let p = cache.get(cle) as Promise | undefined;
+ if (!p) {
+ p = charger();
+ // Évite un rejet « non géré » dans la console : l'erreur est relevée par `use`.
+ p.catch(() => {});
+ cache.set(cle, p);
+ while (cache.size > MAX_ENTREES) {
+ const plusAncienne = cache.keys().next().value;
+ if (plusAncienne === undefined) break;
+ cache.delete(plusAncienne);
+ }
+ }
+ return p;
+}
+
+/**
+ * Clé de rendu de la page courante : change à chaque navigation (nouvelle
+ * entrée d'historique) et à chaque rafraîchissement, pas sur un simple
+ * `history.replaceState` de l'interface.
+ */
+export function usePageKey(): string {
+ const { key } = useLocation();
+ const version = useRefreshVersion();
+ return `${key}#${version}`;
+}
+
+/**
+ * Données d'une page : suspend jusqu'à leur arrivée. Une erreur est relevée et
+ * remonte à la frontière d'erreur (`error.tsx`), comme l'exception d'une page
+ * serveur.
+ */
+export function usePageData(nom: string, charger: () => Promise): T {
+ const cle = `${nom}@${usePageKey()}`;
+ return use(memo(cle, charger));
+}
+
+export type Resultat = { ok: true; data: T } | { ok: false; error: string };
+
+/**
+ * Comme `usePageData`, mais l'erreur est rendue sous forme de résultat : pour
+ * les pages qui affichaient un `ErrorState` avec le message de l'exception.
+ */
+export function usePageResult(nom: string, charger: () => Promise): Resultat {
+ return usePageData>(`${nom}:resultat`, () =>
+ charger().then(
+ (data) => ({ ok: true as const, data }),
+ (e: unknown) => ({ ok: false as const, error: e instanceof Error ? e.message : String(e) }),
+ ),
+ );
+}
+
+/**
+ * Paramètres d'URL de la page, comme le `searchParams` d'une page serveur
+ * (première valeur de chaque clé). Ceux du routeur : une réécriture directe de
+ * l'URL par l'interface ne les change pas, comme avec Next.js.
+ */
+export function usePageSearchParams(): Record {
+ const { search } = useLocation();
+ return useMemo(() => {
+ const o: Record = {};
+ new URLSearchParams(search).forEach((v, k) => {
+ if (!(k in o)) o[k] = v;
+ });
+ return o;
+ }, [search]);
+}
diff --git a/src/lib/pg-ff-client.ts b/src/lib/pg-ff-client.ts
deleted file mode 100644
index 5cbe396..0000000
--- a/src/lib/pg-ff-client.ts
+++ /dev/null
@@ -1,2159 +0,0 @@
-/**
- * CollectFlow — Client PostgreSQL FF Nancy
- *
- * Remplace les appels HTTP per-article vers api.ffnancy.fr par des requêtes
- * SQL bulk directes sur la base PostgreSQL FF Nancy.
- *
- * Chaque fonction fait 1 seule requête filtrée par codefou — O(1) au lieu de O(N).
- */
-
-import { db } from "@/db";
-import { sql, type SQL } from "drizzle-orm";
-import { ffFetchInit } from "@/lib/api-ff-client";
-
-const FF_API_BASE = process.env.FF_API_BASE_URL ?? "https://api.ffnancy.fr";
-
-
-// Cache module-level pour éviter les requêtes information_schema répétées
-let _nomenclatureParentCol: string | null | undefined = undefined; // undefined = pas encore chargé
-
-// ---------------------------------------------------------------------------
-// Utilitaire : exécuter une requête sans workers parallèles PostgreSQL.
-// Les workers parallèles consomment /dev/shm (mémoire partagée Docker) et font
-// échouer les requêtes si le conteneur a un shm_size insuffisant.
-// Le réglage est désormais posé une fois par connexion du pool (src/db/index.ts) :
-// la transaction BEGIN / SET LOCAL / COMMIT qui entourait chaque requête coûtait
-// trois allers-retours de plus à chacune.
-// ---------------------------------------------------------------------------
-/**
- * `fn` sur chaque élément, au plus `simultanes` à la fois, résultats dans l'ordre
- * (même forme que Promise.allSettled). Évite de lancer des centaines d'appels à
- * l'API FF d'un coup, qui la saturent et finissent en délais dépassés.
- */
-async function parLots(items: T[], simultanes: number, fn: (item: T) => Promise): Promise[]> {
- const resultats: PromiseSettledResult[] = new Array(items.length);
- let suivant = 0;
- const ouvrier = async () => {
- while (suivant < items.length) {
- const i = suivant++;
- try {
- resultats[i] = { status: "fulfilled", value: await fn(items[i]) };
- } catch (reason) {
- resultats[i] = { status: "rejected", reason };
- }
- }
- };
- await Promise.all(Array.from({ length: Math.min(simultanes, items.length) }, ouvrier));
- return resultats;
-}
-
-async function pgNoParallel(query: SQL): Promise<{ rows: unknown[] }> {
- const r = await db.execute(query);
- return { rows: r.rows };
-}
-
-// ---------------------------------------------------------------------------
-// Types résultats SQL
-// ---------------------------------------------------------------------------
-
-export interface PgArticle {
- no_id: number;
- codein: string;
- /** Code centrale = articles.artcentrale (format 10000XXXXXX) — clé jointure Qlik "Article Code". Vide pour les articles non référencés centralement. */
- codeCentrale?: string;
- codefou: string;
- nomfou?: string;
- libelle1?: string;
- pcb?: number;
- reference?: string;
- ean13?: string;
- gtin?: string; // art_gtin.gtin (préférentiel)
- pv_central?: number; // article_infosup.prix_vente_mini
- pa?: number; // cube_pa.pa
- codefou_principal?: string; // artfou1.code où preference=1
- nomfou_principal?: string; // nom du fournisseur principal
-}
-
-export interface PgMensuelRow {
- codein: string;
- site: string;
- mois: string; // "YYYY-MM"
- qte_vendue: number;
- ca_ht: number; // mntmvtttc (à vérifier si HT ou TTC)
- marge: number;
- stock_fin_mois: number; // MAX(qtestock) sur le mois
- qte_recue: number;
-}
-
-export interface PgStockRow {
- codein: string;
- site: string;
- stockdispo: number;
- qte: number;
- valstock: number;
- prmp: number;
- /** Prix de vente du site — cube_stock.pv, filet de secours si cube_pv est vide. */
- pv?: number;
- dernierevente?: string;
- dernierereception?: string;
-}
-
-// ---------------------------------------------------------------------------
-// 0. Liste des fournisseurs
-// ---------------------------------------------------------------------------
-
-/**
- * Retourne la liste des fournisseurs depuis fouident (vrais noms) + artfou1.
- */
-export async function pgGetFournisseurs(search?: string): Promise<{ code: string; nom: string }[]> {
- try {
- const result = await db.execute(sql`
- SELECT DISTINCT fi.code, fi.nom
- FROM fouident fi
- INNER JOIN artfou1 af ON af.code = fi.code
- WHERE fi.nom IS NOT NULL
- AND fi.nom != ''
- ${search ? sql`AND (fi.nom ILIKE ${'%' + search + '%'} OR fi.code ILIKE ${'%' + search + '%'})` : sql``}
- ORDER BY fi.nom
- `);
- return (result.rows as unknown as { code: string; nom: string }[]).filter(r => r.code && r.nom);
- } catch (e) {
- console.error("[pg-ff] pgGetFournisseurs error:", (e as Error).message?.slice(0, 200));
- return [];
- }
-}
-
-// ---------------------------------------------------------------------------
-// 1. Articles du fournisseur
-// ---------------------------------------------------------------------------
-
-/**
- * Retourne tous les articles d'un fournisseur avec leurs métadonnées.
- * 1 seule requête SQL — remplace getArticlesByFournisseur() + per-article fetches.
- */
-export async function pgGetArticlesByFournisseur(codefou: string): Promise {
- // DISTINCT ON (a.no_id) car artfou1 peut avoir plusieurs lignes par article/fournisseur.
- // Pas de filtre "actif" : on retourne tous les articles pour ne pas exclure les articles
- // d'une session précédente (snapshot) qui n'ont pas de gamme DB ni de ventes récentes.
- // Le filtrage gamme-Y sans ventes est fait en aval dans getProductRows (Phase 10).
- // afpref : fournisseur préférentiel (preference=1) de l'article — peut différer du fournisseur consulté.
- const result = await pgNoParallel(sql`
- SELECT DISTINCT ON (a.no_id)
- a.no_id,
- a.codein,
- a.artcentrale AS "codeCentrale",
- af.code AS codefou,
- fi.nom AS nomfou,
- a.libelle1,
- af.pcb,
- af.reference,
- af.ean13,
- COALESCE(ag.gtin, af.ean13) AS gtin,
- ai.prix_vente_mini AS pv_central,
- pa.pa,
- last_fournisseur.codefou_dernier AS codefou_principal,
- last_fournisseur.nomfou_dernier AS nomfou_principal
- FROM artfou1 af
- JOIN articles a ON a.no_id = af.art_no_id
- LEFT JOIN fouident fi ON fi.code = af.code
- LEFT JOIN article_infosup ai ON ai.artnoid = a.no_id
- LEFT JOIN cube_pa pa ON pa.artnoid = a.no_id
- LEFT JOIN art_gtin ag ON ag.idarticle = a.no_id AND ag.preferentiel = 1
- LEFT JOIN LATERAL (
- SELECT af2.code AS codefou_dernier, fi2.nom AS nomfou_dernier
- FROM artfou1 af2
- LEFT JOIN fouident fi2 ON fi2.code = af2.code
- WHERE af2.art_no_id = a.no_id
- ORDER BY af2.no_id DESC
- LIMIT 1
- ) last_fournisseur ON true
- WHERE af.code = ${codefou}
- AND a.codein IS NOT NULL
- AND (af.suspendu IS NULL OR af.suspendu::text NOT IN ('1', 'true', 't', 'yes', 'y', 'on'))
- AND (a.suspendu IS NULL OR a.suspendu::text NOT IN ('1', 'true', 't', 'yes', 'y', 'on'))
- ORDER BY a.no_id, af.no_id
- `);
-
- console.log(`[pg-ff] Articles: ${result.rows.length} pour ${codefou}`);
- return (result.rows as unknown as PgArticle[]).filter(r => r.codein);
-}
-
-// ---------------------------------------------------------------------------
-// 2. Données mensuelles (ventes + stock + réceptions)
-// ---------------------------------------------------------------------------
-
-/**
- * Retourne les données mensuelles agrégées par (codein, site, mois).
- * 1 seule requête SQL — remplace getMensuelByArticles() (N appels HTTP).
- *
- * genremvt = 3 → ventes clients
- * genremvt 1/2 → réceptions (à confirmer selon nomenclature FF Nancy)
- * qtestock → stock après mouvement (MAX du mois ≈ stock fin de mois)
- */
-export async function pgGetMensuelByFournisseur(
- codefou: string,
- dateDebut: string,
- dateFin: string
-): Promise {
- // IMPORTANT : utiliser DISTINCT sur artfou1 pour éviter les doublons de mouvements.
- // Un article peut avoir plusieurs lignes artfou1 pour le même fournisseur (pcb/ref différents),
- // ce qui multiplierait chaque mouvement et gonflerait les totaux.
- //
- // stock_fin_mois = qtestock du DERNIER mouvement du mois (tri par datmvt DESC).
- // MAX(qtestock) donnait le stock de début de mois (avant les premières ventes), ce qui était faux.
- const result = await pgNoParallel(sql`
- WITH base AS (
- SELECT
- a.codein,
- m.site,
- TO_CHAR(m.datmvt, 'YYYY-MM') AS mois,
- m.qtemvt,
- m.mntmvtttc,
- m.margemvt,
- m.genremvt,
- m.qtestock,
- ROW_NUMBER() OVER (
- PARTITION BY a.codein, m.site, TO_CHAR(m.datmvt, 'YYYY-MM')
- ORDER BY m.datmvt DESC
- ) AS rn_last
- FROM mvtart m
- JOIN articles a ON a.no_id = m.artnoid
- JOIN (SELECT DISTINCT art_no_id FROM artfou1 WHERE code = ${codefou}) af
- ON af.art_no_id = a.no_id
- WHERE m.datmvt BETWEEN ${dateDebut}::date AND ${dateFin}::date
- AND m.site IN ('292', '579')
- )
- SELECT
- codein,
- site,
- mois,
- SUM(CASE WHEN genremvt = 3 THEN -qtemvt ELSE 0 END)::float AS qte_vendue,
- SUM(CASE WHEN genremvt = 3 THEN -mntmvtttc ELSE 0 END)::float AS ca_ht,
- SUM(CASE WHEN genremvt = 3 THEN margemvt ELSE 0 END)::float AS marge,
- MAX(CASE WHEN rn_last = 1 THEN qtestock ELSE NULL END)::float AS stock_fin_mois,
- SUM(CASE WHEN genremvt IN (1, 2) THEN qtemvt ELSE 0 END)::float AS qte_recue
- FROM base
- GROUP BY codein, site, mois
- ORDER BY codein, site, mois
- `);
-
- return result.rows as unknown as PgMensuelRow[];
-}
-
-// ---------------------------------------------------------------------------
-// 3. Gammes (saison active)
-// ---------------------------------------------------------------------------
-
-/**
- * Retourne la gamme courante (saison active) pour chaque article du fournisseur.
- * 1 requête SQL — remplace getReferentielByArticles() pour la partie gammes.
- */
-export async function pgGetGammesByFournisseur(codefou: string): Promise> {
- // DISTINCT ON (codein) → 1 gamme par article, saison la plus récente en premier
- // saisons n'a PAS de colonne "actif" → pas de filtre actif
- const result = await pgNoParallel(sql`
- SELECT DISTINCT ON (a.codein)
- a.codein,
- g.code AS gamme_code
- FROM art_gamme_saison ags
- JOIN articles a ON a.no_id = ags.artnoid
- JOIN artfou1 af ON af.art_no_id = a.no_id AND af.code = ${codefou}
- JOIN gammes g ON g.no_id = ags.idgamme
- JOIN saisons s ON s.no_id = ags.idsaison
- ORDER BY a.codein, s.no_id DESC
- `);
-
- const map = new Map();
- for (const row of result.rows as unknown as { codein: string; gamme_code: string }[]) {
- if (row.codein && row.gamme_code) map.set(row.codein, String(row.gamme_code).trim());
- }
- return map;
-}
-
-/**
- * Gammes **serveur** pour une liste de codein, tous fournisseurs confondus.
- *
- * Variante de `pgGetGammesByFournisseur` sans la jointure `artfou1` : la recherche
- * de l'API `/api/v1` est transversale, on ne connaît donc pas le fournisseur.
- * C'est la gamme telle qu'elle existe en base — non modifiée, indépendante des
- * snapshots de session qui peuvent surcharger `codeGamme` dans la Grille.
- */
-export async function pgGetGammesByCodeins(codeins: string[]): Promise> {
- const unique = [...new Set(codeins.map(c => String(c ?? "").trim()).filter(Boolean))];
- if (unique.length === 0) return new Map();
-
- // Découpage obligatoire : chaque codein devient un paramètre lié, or PostgreSQL
- // en accepte 65535 au maximum. Un gros fournisseur dépasse 130 000 articles —
- // la requête échouait alors purement et simplement.
- const CHUNK = 2000;
- const map = new Map
@@ -130,13 +78,13 @@ export default async function PublicitesPage(props: {
vueInitiale={vue === "historique" ? "historique" : "publicites"}
statut={statut}
page={page}
- pageSize={PAGE_SIZE}
- publicites={pubResult.data}
- total={pubResult.total}
- pages={pubResult.pages}
- erreurPublicites={pubResult.error}
- historique={histoResult.data}
- erreurHistorique={histoResult.error}
+ pageSize={donnees.pageSize}
+ publicites={donnees.publicites}
+ total={donnees.total}
+ pages={donnees.pages}
+ erreurPublicites={donnees.erreurPublicites}
+ historique={donnees.historique}
+ erreurHistorique={donnees.erreurHistorique}
/>
);
diff --git a/src/app/(dashboard)/settings/client.tsx b/src/app/(dashboard)/settings/client.tsx
index 6a15b0c..0cb70b7 100644
--- a/src/app/(dashboard)/settings/client.tsx
+++ b/src/app/(dashboard)/settings/client.tsx
@@ -1,5 +1,3 @@
-"use client";
-
import { useCallback, useEffect, useState, type ReactNode } from "react";
import {
AlertCircle,
diff --git a/src/app/(dashboard)/settings/page.tsx b/src/app/(dashboard)/settings/page.tsx
index b6997ea..de20149 100644
--- a/src/app/(dashboard)/settings/page.tsx
+++ b/src/app/(dashboard)/settings/page.tsx
@@ -1,21 +1,19 @@
-import type { Metadata } from "next";
-import { redirect } from "next/navigation";
-import { verifierAdmin } from "@/lib/authz";
+import { AdminOnly } from "@/components/shared/admin-only";
+import { usePageSearchParams } from "@/lib/page-data";
import { ParametresClient } from "./client";
-export const metadata: Metadata = { title: "Paramètres" };
-
/**
* Paramètres (administrateurs) : connexions aux sources de données, comptes
* utilisateurs, accès à l'API et journal serveur, rangés en onglets.
*
- * Composant serveur minimal : il lit l'onglet demandé (`?onglet=`) pour que le
- * lien se partage et survive au rechargement, puis rend la page cliente.
+ * Page minimale : elle lit l'onglet demandé (`?onglet=`) pour que le lien se
+ * partage et survive au rechargement, puis rend la page cliente.
*/
-export default async function SettingsPage(props: { searchParams: Promise<{ onglet?: string }> }) {
- // Le middleware filtre déjà sur le rôle du jeton ; ici, rôle relu en base.
- if (!(await verifierAdmin()).ok) redirect("/dashboard");
-
- const { onglet } = await props.searchParams;
- return