create-crm-tmp 2.0.0 → 2.1.0

package/template/src/app/api/contacts/import/route.ts

@@ -1,9 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server';
+import * as XLSX from 'xlsx';
 import { auth } from '@/lib/auth';
 import { prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
-import { handleContactDuplicate } from '@/lib/contact-duplicate';
-import { normalizePhoneNumber } from '@/lib/utils';
+import { handleContactDuplicate, markContactAsDuplicate } from '@/lib/contact-duplicate';
+import { normalizePhoneNumber, parseImportDate } from '@/lib/utils';
 
 // POST /api/contacts/import - Importer des contacts depuis un fichier CSV/Excel
 export async function POST(request: NextRequest) {
@@ -74,7 +75,6 @@ export async function POST(request: NextRequest) {
       rows = parseCSV(text);
     } else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
       try {
-        const XLSX = require('xlsx');
         const buffer = await file.arrayBuffer();
         const workbook = XLSX.read(buffer, { type: 'array' });
         const sheetName =
@@ -151,6 +151,32 @@ export async function POST(request: NextRequest) {
           assignedCommercialId = defaultCommercialId;
         }
 
+        // Construire socialNetworks depuis les colonnes mappées (linkedin, facebook, twitter, instagram)
+        const socialPlatforms: { platform: string; url: string }[] = [];
+        const socialKeys: { key: string; label: string }[] = [
+          { key: 'linkedin', label: 'LinkedIn' },
+          { key: 'facebook', label: 'Facebook' },
+          { key: 'twitter', label: 'Twitter' },
+          { key: 'instagram', label: 'Instagram' },
+        ];
+        for (const { key, label } of socialKeys) {
+          const col = mapping[key];
+          if (col) {
+            const url = getValueFromRow(row, col);
+            if (url && String(url).trim()) {
+              let href = String(url).trim();
+              if (!href.startsWith('http://') && !href.startsWith('https://')) {
+                href = `https://${href}`;
+              }
+              socialPlatforms.push({ platform: label, url: href });
+            }
+          }
+        }
+
+        const createdAtImport = mapping.createdAt
+          ? parseImportDate(getValueFromRow(row, mapping.createdAt))
+          : null;
+
         const contactData: any = {
           phone: normalizedPhone,
           civility: getValueFromRow(row, mapping.civility) || null,
@@ -163,6 +189,10 @@ export async function POST(request: NextRequest) {
           address: getValueFromRow(row, mapping.address) || null,
           city: getValueFromRow(row, mapping.city) || null,
           postalCode: getValueFromRow(row, mapping.postalCode) || null,
+          companyName: getValueFromRow(row, mapping.companyName) || null,
+          website: mapping.website ? (getValueFromRow(row, mapping.website) || null) : null,
+          jobTitle: getValueFromRow(row, mapping.jobTitle) || null,
+          socialNetworks: socialPlatforms.length > 0 ? socialPlatforms : null,
           origin: origin,
           statusId: statusId,
           assignedCommercialId: assignedCommercialId,
@@ -170,6 +200,7 @@ export async function POST(request: NextRequest) {
             ? getValueFromRow(row, mapping.assignedTeleproId) || null
             : null,
           createdById: session.user.id,
+          ...(createdAtImport && { createdAt: createdAtImport }),
         };
 
         // Collecter les notes à ajouter
@@ -200,6 +231,7 @@ export async function POST(request: NextRequest) {
     // Créer les contacts en lot
     const createdContacts = [];
     const duplicateErrors = [];
+    const duplicateContactIds: string[] = [];
 
     for (const contactDataWithNotes of contactsToCreate) {
       // Extraire les notes et les données du contact
@@ -217,28 +249,10 @@ export async function POST(request: NextRequest) {
         );
 
         if (duplicateContactId) {
-          // C'est un doublon, récupérer le contact existant
-          const existingContact = await prisma.contact.findUnique({
-            where: { id: duplicateContactId },
-            include: {
-              status: true,
-              assignedCommercial: {
-                select: { id: true, name: true, email: true },
-              },
-              assignedTelepro: {
-                select: { id: true, name: true, email: true },
-              },
-              createdBy: {
-                select: { id: true, name: true, email: true },
-              },
-            },
-          });
-          if (existingContact) {
-            createdContacts.push(existingContact);
-            duplicateErrors.push(
-              `Contact ${contactData.firstName} ${contactData.lastName} (${contactData.email}) - doublon détecté`,
-            );
-          }
+          duplicateContactIds.push(duplicateContactId);
+          duplicateErrors.push(
+            `Contact ${contactData.firstName} ${contactData.lastName} (${contactData.email}) - doublon détecté`,
+          );
           continue;
         }
 
@@ -248,6 +262,13 @@ export async function POST(request: NextRequest) {
         });
 
         if (existingByPhone) {
+          duplicateContactIds.push(existingByPhone.id);
+          await markContactAsDuplicate(
+            existingByPhone.id,
+            contactData.origin || 'Import CSV/Excel',
+            session.user.id,
+            prisma,
+          );
           duplicateErrors.push(`Téléphone ${contactData.phone} déjà existant`);
           continue;
         }
@@ -310,6 +331,15 @@ export async function POST(request: NextRequest) {
       }
     }
 
+    // Bumper le createdAt des doublons APRÈS la création des nouveaux contacts
+    // pour qu'ils remontent en haut de la liste (tri createdAt desc)
+    if (duplicateContactIds.length > 0) {
+      await prisma.contact.updateMany({
+        where: { id: { in: duplicateContactIds } },
+        data: { createdAt: new Date() },
+      });
+    }
+
     return NextResponse.json({
       success: true,
       imported: createdContacts.length,

package/template/src/app/api/contacts/import-preview/route.ts

@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from 'next/server';
+import * as XLSX from 'xlsx';
 import { auth } from '@/lib/auth';
 import { checkPermission } from '@/lib/check-permission';
 
@@ -45,7 +46,6 @@ function parseExcel(
   preview: Record<string, string>[];
   rawRows: string[][];
 } | null {
-  const XLSX = require('xlsx');
   const workbook = XLSX.read(buffer, { type: 'array' });
   const sheetNames: string[] = workbook.SheetNames;
 

package/template/src/app/api/contacts/origins/route.ts

@@ -0,0 +1,63 @@
+import { NextResponse } from 'next/server';
+import { auth } from '@/lib/auth';
+import { prisma } from '@/lib/prisma';
+import { checkPermission } from '@/lib/check-permission';
+
+/** Liste distincte des origines (tous les contacts visibles par l’utilisateur). */
+export async function GET(request: Request) {
+  try {
+    const session = await auth.api.getSession({
+      headers: request.headers,
+    });
+
+    if (!session) {
+      return NextResponse.json({ error: 'Non authentifié' }, { status: 401 });
+    }
+
+    const [canViewAll, canViewOwn, canViewUnassigned] = await Promise.all([
+      checkPermission('contacts.view_all'),
+      checkPermission('contacts.view_own'),
+      checkPermission('contacts.view_unassigned'),
+    ]);
+
+    if (!canViewAll && !canViewOwn) {
+      return NextResponse.json({ error: 'Accès refusé' }, { status: 403 });
+    }
+
+    const where: {
+      origin: { not: null };
+      AND?: object[];
+    } = {
+      origin: { not: null },
+    };
+
+    if (!canViewAll && canViewOwn) {
+      const ownershipConditions: object[] = [
+        { assignedCommercialId: session.user.id },
+        { assignedTeleproId: session.user.id },
+        { createdById: session.user.id },
+      ];
+      if (canViewUnassigned) {
+        ownershipConditions.push({
+          AND: [{ assignedCommercialId: null }, { assignedTeleproId: null }],
+        });
+      }
+      where.AND = [{ OR: ownershipConditions }];
+    }
+
+    const grouped = await prisma.contact.groupBy({
+      by: ['origin'],
+      where,
+    });
+
+    const origins = grouped
+      .map((g) => g.origin)
+      .filter((o): o is string => Boolean(o && String(o).trim()))
+      .sort((a, b) => a.localeCompare(b, 'fr'));
+
+    return NextResponse.json({ origins });
+  } catch (e) {
+    console.error('GET /api/contacts/origins:', e);
+    return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
+  }
+}

package/template/src/app/api/contacts/route.ts

@@ -1,14 +1,23 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { z } from 'zod';
 import { auth } from '@/lib/auth';
-import { prisma } from '@/lib/prisma';
+import { prisma, Prisma } from '@/lib/prisma';
 import { checkPermission } from '@/lib/check-permission';
 import { handleContactDuplicate } from '@/lib/contact-duplicate';
 import { executeWorkflowsOnContactCreated } from '@/lib/workflow-executor';
 import { normalizePhoneNumber } from '@/lib/utils';
 import { buildPrismaWhereFromFilters } from '@/lib/contact-view-filters';
+import {
+  expandRegionCodesToDepartmentCodes,
+  prismaPostalMatchesDepartmentsCondition,
+} from '@/lib/fr-geography';
 import type { ViewFilter, ViewSortConfig } from '@/types/contact-views';
 
+const socialNetworkSchema = z.object({
+  platform: z.string().trim().min(1),
+  url: z.string().trim().url(),
+});
+
 const createContactSchema = z.object({
   civility: z.enum(['M', 'MME', 'MLLE']).optional().nullable(),
   firstName: z.string().trim().min(1).optional().nullable(),
@@ -20,14 +29,50 @@ const createContactSchema = z.object({
   city: z.string().optional().nullable(),
   postalCode: z.string().optional().nullable(),
   origin: z.string().optional().nullable(),
+  companyName: z.string().trim().optional().nullable(),
   companyId: z.string().optional().nullable(),
   jobTitle: z.string().trim().optional().nullable(),
+  website: z.string().trim().url().optional().nullable().or(z.literal('')),
+  socialNetworks: z.array(socialNetworkSchema).optional().nullable(),
   statusId: z.string().optional().nullable(),
   closingReason: z.string().optional().nullable(),
   assignedCommercialId: z.string().optional().nullable(),
   assignedTeleproId: z.string().optional().nullable(),
 });
 
+function parseContactsListSortDirection(
+  sortDir: string | null,
+  sortOrder: string | null,
+): 'asc' | 'desc' | null {
+  const raw = sortDir ?? sortOrder;
+  return raw === 'asc' || raw === 'desc' ? raw : null;
+}
+
+/** Identifiants UI liste → orderBy Prisma (whitelist). */
+function contactListPrismaOrderBy(
+  uiField: string,
+  direction: 'asc' | 'desc',
+): Prisma.ContactOrderByWithRelationInput | null {
+  switch (uiField) {
+    case 'createdAt':
+      return { createdAt: direction };
+    case 'updatedAt':
+      return { updatedAt: direction };
+    case 'postalCode':
+      return { postalCode: direction };
+    case 'status':
+      return { status: { name: direction } };
+    case 'commercial':
+      return { assignedCommercial: { name: direction } };
+    case 'telepro':
+      return { assignedTelepro: { name: direction } };
+    case 'origin':
+      return { origin: direction };
+    default:
+      return null;
+  }
+}
+
 // GET /api/contacts - Récupérer tous les contacts avec filtres
 export async function GET(request: NextRequest) {
   try {
@@ -57,6 +102,8 @@ export async function GET(request: NextRequest) {
     const assignedCommercialIds = searchParams.get('assignedCommercialIds');
     const assignedTeleproIds = searchParams.get('assignedTeleproIds');
     const origins = searchParams.get('origins');
+    const departmentCodesParam = searchParams.get('departmentCodes');
+    const regionCodesParam = searchParams.get('regionCodes');
     const statusId = searchParams.get('statusId');
     const assignedCommercialId = searchParams.get('assignedCommercialId');
     const assignedTeleproId = searchParams.get('assignedTeleproId');
@@ -67,8 +114,9 @@ export async function GET(request: NextRequest) {
     const updatedAtEnd = searchParams.get('updatedAtEnd');
     const sortFieldParam = searchParams.get('sortField');
     const sortDirParam = searchParams.get('sortDir');
+    const sortOrderParam = searchParams.get('sortOrder');
     const page = Number.parseInt(searchParams.get('page') || '1');
-    const limit = Number.parseInt(searchParams.get('limit') || '50');
+    const limit = Math.min(Number.parseInt(searchParams.get('limit') || '50'), 200);
     const skip = (page - 1) * limit;
 
     const where: any = {};
@@ -119,13 +167,53 @@ export async function GET(request: NextRequest) {
     }
 
     if (search) {
+      const trimmedSearch = search.trim();
+      const searchTerms = trimmedSearch.split(/\s+/).filter(Boolean);
+      const firstTerm = searchTerms[0] || '';
+      const remainingTerms = searchTerms.slice(1).join(' ');
+
+      // Normaliser le numéro si la recherche ressemble à un téléphone
+      const digitsOnly = trimmedSearch.replace(/\D/g, '');
+      const looksLikePhone = digitsOnly.length >= 4;
+      const normalizedPhone = looksLikePhone ? normalizePhoneNumber(trimmedSearch) : null;
+
       where.AND = where.AND || [];
       where.AND.push({
         OR: [
-          { firstName: { contains: search, mode: 'insensitive' } },
-          { lastName: { contains: search, mode: 'insensitive' } },
-          { email: { contains: search, mode: 'insensitive' } },
-          { phone: { contains: search, mode: 'insensitive' } },
+          { firstName: { contains: trimmedSearch, mode: 'insensitive' } },
+          { lastName: { contains: trimmedSearch, mode: 'insensitive' } },
+          { email: { contains: trimmedSearch, mode: 'insensitive' } },
+          { phone: { contains: trimmedSearch, mode: 'insensitive' } },
+          { city: { contains: trimmedSearch, mode: 'insensitive' } },
+          { postalCode: { contains: trimmedSearch, mode: 'insensitive' } },
+          { address: { contains: trimmedSearch, mode: 'insensitive' } },
+          { secondaryPhone: { contains: trimmedSearch, mode: 'insensitive' } },
+          { origin: { contains: trimmedSearch, mode: 'insensitive' } },
+          { jobTitle: { contains: trimmedSearch, mode: 'insensitive' } },
+          { companyName: { contains: trimmedSearch, mode: 'insensitive' } },
+          { company: { name: { contains: trimmedSearch, mode: 'insensitive' } } },
+          ...(normalizedPhone
+            ? [
+                { phone: { contains: normalizedPhone, mode: 'insensitive' as const } },
+                { secondaryPhone: { contains: normalizedPhone, mode: 'insensitive' as const } },
+              ]
+            : []),
+          ...(remainingTerms
+            ? [
+                {
+                  AND: [
+                    { firstName: { contains: firstTerm, mode: 'insensitive' } },
+                    { lastName: { contains: remainingTerms, mode: 'insensitive' } },
+                  ],
+                },
+                {
+                  AND: [
+                    { firstName: { contains: remainingTerms, mode: 'insensitive' } },
+                    { lastName: { contains: firstTerm, mode: 'insensitive' } },
+                  ],
+                },
+              ]
+            : []),
         ],
       });
     }
@@ -181,6 +269,25 @@ export async function GET(request: NextRequest) {
       where.origin = origin;
     }
 
+    if (departmentCodesParam) {
+      const codes = departmentCodesParam.split(',').filter(Boolean);
+      const geoCond = prismaPostalMatchesDepartmentsCondition(codes);
+      if (geoCond) {
+        where.AND = where.AND || [];
+        where.AND.push(geoCond);
+      }
+    }
+
+    if (regionCodesParam) {
+      const codes = regionCodesParam.split(',').filter(Boolean);
+      const depts = expandRegionCodesToDepartmentCodes(codes);
+      const geoCond = prismaPostalMatchesDepartmentsCondition(depts);
+      if (geoCond) {
+        where.AND = where.AND || [];
+        where.AND.push(geoCond);
+      }
+    }
+
     if (createdAtStart || createdAtEnd) {
       where.createdAt = {};
       if (createdAtStart) {
@@ -216,11 +323,24 @@ export async function GET(request: NextRequest) {
     }
 
     // Determine sort order: explicit param > view config > default
-    let orderBy: any = { createdAt: 'desc' as const };
-    if (sortFieldParam && sortDirParam) {
-      orderBy = { [sortFieldParam]: sortDirParam };
-    } else if (viewSortConfig) {
-      orderBy = { [viewSortConfig.field]: viewSortConfig.direction };
+    let orderBy: Prisma.ContactOrderByWithRelationInput = { createdAt: 'desc' };
+    const explicitDirection = parseContactsListSortDirection(sortDirParam, sortOrderParam);
+    if (sortFieldParam && explicitDirection) {
+      const mapped = contactListPrismaOrderBy(sortFieldParam, explicitDirection);
+      if (mapped) {
+        orderBy = mapped;
+      }
+    } else if (viewSortConfig?.field) {
+      const dir =
+        viewSortConfig.direction === 'asc' || viewSortConfig.direction === 'desc'
+          ? viewSortConfig.direction
+          : null;
+      if (dir) {
+        const mapped = contactListPrismaOrderBy(viewSortConfig.field, dir);
+        if (mapped) {
+          orderBy = mapped;
+        }
+      }
     }
 
     const [contacts, total] = await Promise.all([
@@ -238,28 +358,6 @@ export async function GET(request: NextRequest) {
           createdBy: {
             select: { id: true, name: true, email: true },
           },
-          tourLinks: {
-            include: {
-              tour: {
-                select: {
-                  id: true,
-                  number: true,
-                },
-              },
-            },
-          },
-          transactions: {
-            select: {
-              id: true,
-              status: true,
-              totalAmountCents: true,
-              createdAt: true,
-            },
-            orderBy: {
-              createdAt: 'desc',
-            },
-            take: 1,
-          },
         },
         orderBy,
         skip,
@@ -268,15 +366,22 @@ export async function GET(request: NextRequest) {
       prisma.contact.count({ where }),
     ]);
 
-    return NextResponse.json({
-      contacts,
-      pagination: {
-        page,
-        limit,
-        total,
-        totalPages: Math.ceil(total / limit),
+    return NextResponse.json(
+      {
+        contacts,
+        pagination: {
+          page,
+          limit,
+          total,
+          totalPages: Math.ceil(total / limit),
+        },
       },
-    });
+      {
+        headers: {
+          'Cache-Control': 'private, no-store, max-age=0, must-revalidate',
+        },
+      },
+    );
   } catch (error: any) {
     console.error('Erreur lors de la récupération des contacts:', error);
     return NextResponse.json({ error: 'Erreur serveur' }, { status: 500 });
@@ -323,8 +428,11 @@ export async function POST(request: NextRequest) {
       city,
       postalCode,
       origin,
+      companyName,
       companyId,
       jobTitle,
+      website,
+      socialNetworks,
       statusId,
       closingReason,
       assignedCommercialId,
@@ -374,8 +482,12 @@ export async function POST(request: NextRequest) {
         city: city || null,
         postalCode: postalCode || null,
         origin: origin || null,
+        companyName: companyName && !companyId ? companyName : null,
         companyId: companyId || null,
         jobTitle: jobTitle || null,
+        website: website && website.trim() ? website : null,
+        socialNetworks:
+          socialNetworks && socialNetworks.length > 0 ? socialNetworks : Prisma.JsonNull,
         statusId: statusId || null,
         closingReason: closingReason || null,
         assignedCommercialId: assignedCommercialId || null,

package/template/src/app/api/cron/cleanup-editor-images/route.ts

@@ -0,0 +1,166 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { createClient } from '@supabase/supabase-js';
+import { prisma } from '@/lib/prisma';
+import { BUCKETS } from '@/lib/supabase-storage';
+
+const BUCKET = BUCKETS.EDITOR_IMAGES;
+const FOLDER = 'images';
+// Ne supprimer que les images de plus de 24h (laisse le temps de sauvegarder)
+const MIN_AGE_MS = 24 * 60 * 60 * 1000;
+const LIST_LIMIT = 1000;
+
+function getAdminClient() {
+  return createClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.SUPABASE_SERVICE_ROLE_KEY!,
+    { auth: { autoRefreshToken: false, persistSession: false } },
+  );
+}
+
+/**
+ * Collecte toutes les URLs d'images éditeur référencées en BDD.
+ */
+async function getReferencedImageUrls(): Promise<Set<string>> {
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL!;
+  const prefix = `${supabaseUrl}/storage/v1/object/public/${BUCKET}/`;
+
+  const urls = new Set<string>();
+
+  function extractUrls(text: string | null) {
+    if (!text) return;
+    const regex = new RegExp(
+      prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '[^"\'\\s<>]+',
+      'g',
+    );
+    for (const match of text.matchAll(regex)) {
+      urls.add(match[0]);
+    }
+  }
+
+  // Templates
+  const templates = await prisma.template.findMany({ select: { content: true } });
+  for (const t of templates) extractUrls(t.content);
+
+  // Interactions (notes, emails)
+  const interactions = await prisma.interaction.findMany({
+    where: { content: { contains: BUCKET } },
+    select: { content: true },
+  });
+  for (const i of interactions) extractUrls(i.content);
+
+  // Tasks
+  const tasks = await prisma.task.findMany({
+    where: { description: { contains: BUCKET } },
+    select: { description: true },
+  });
+  for (const t of tasks) extractUrls(t.description);
+
+  // SMTP signatures
+  const smtpConfigs = await prisma.smtpConfig.findMany({
+    where: { signature: { not: null } },
+    select: { signature: true },
+  });
+  for (const s of smtpConfigs) extractUrls(s.signature);
+
+  // Workflow actions
+  const actions = await prisma.workflowAction.findMany({
+    where: {
+      OR: [
+        { taskDescription: { contains: BUCKET } },
+        { smsMessage: { contains: BUCKET } },
+        { noteContent: { contains: BUCKET } },
+      ],
+    },
+    select: { taskDescription: true, smsMessage: true, noteContent: true },
+  });
+  for (const a of actions) {
+    extractUrls(a.taskDescription);
+    extractUrls(a.smsMessage);
+    extractUrls(a.noteContent);
+  }
+
+  return urls;
+}
+
+// GET /api/cron/cleanup-editor-images
+export async function GET(request: NextRequest) {
+  try {
+    const authHeader = request.headers.get('authorization');
+    if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
+      return NextResponse.json({ error: 'Non autorisé' }, { status: 401 });
+    }
+
+    const client = getAdminClient();
+    const now = Date.now();
+
+    // 1. Lister toutes les images du bucket
+    const allFiles: { name: string; created_at: string }[] = [];
+    let offset = 0;
+    while (true) {
+      const { data, error } = await client.storage.from(BUCKET).list(FOLDER, {
+        limit: LIST_LIMIT,
+        offset,
+        sortBy: { column: 'created_at', order: 'asc' },
+      });
+      if (error) throw new Error(`Erreur listing bucket: ${error.message}`);
+      if (!data || data.length === 0) break;
+      allFiles.push(...data.map((f) => ({ name: f.name, created_at: f.created_at ?? '' })));
+      if (data.length < LIST_LIMIT) break;
+      offset += LIST_LIMIT;
+    }
+
+    if (allFiles.length === 0) {
+      return NextResponse.json({ deleted: 0, total: 0 });
+    }
+
+    // 2. Filtrer : ne garder que les images > 24h
+    const oldFiles = allFiles.filter((f) => {
+      const createdAt = new Date(f.created_at).getTime();
+      return now - createdAt > MIN_AGE_MS;
+    });
+
+    if (oldFiles.length === 0) {
+      return NextResponse.json({ deleted: 0, total: allFiles.length, message: 'Aucune image ancienne' });
+    }
+
+    // 3. Récupérer les URLs référencées en BDD
+    const referencedUrls = await getReferencedImageUrls();
+
+    // 4. Identifier les orphelines
+    const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL!;
+    const orphanPaths: string[] = [];
+    for (const file of oldFiles) {
+      const fullUrl = `${supabaseUrl}/storage/v1/object/public/${BUCKET}/${FOLDER}/${file.name}`;
+      if (!referencedUrls.has(fullUrl)) {
+        orphanPaths.push(`${FOLDER}/${file.name}`);
+      }
+    }
+
+    // 5. Supprimer par batch de 100
+    let deleted = 0;
+    for (let i = 0; i < orphanPaths.length; i += 100) {
+      const batch = orphanPaths.slice(i, i + 100);
+      const { error } = await client.storage.from(BUCKET).remove(batch);
+      if (error) {
+        console.error(`Erreur suppression batch ${i}:`, error.message);
+      } else {
+        deleted += batch.length;
+      }
+    }
+
+    console.log(
+      `[cleanup-editor-images] ${deleted} orphelines supprimées sur ${allFiles.length} total (${referencedUrls.size} référencées)`,
+    );
+
+    return NextResponse.json({
+      deleted,
+      total: allFiles.length,
+      referenced: referencedUrls.size,
+      orphans: orphanPaths.length,
+    });
+  } catch (error: unknown) {
+    console.error('[cleanup-editor-images] Erreur:', error);
+    const message = error instanceof Error ? error.message : 'Erreur serveur';
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}