rubis/apps/api/app/exceptions/handler.ts

import app from '@adonisjs/core/services/app'
import { type HttpContext, ExceptionHandler } from '@adonisjs/core/http'
import * as Sentry from '@sentry/node'

/**
 * Exception handler API JSON-only. Normalise toutes les erreurs vers la
 * shape `{ errors: [{ code, message, field? }] }` documentée dans
 * backend.md §6.
 *
 * Conversions :
 *  - PG 23505 (unique violation) → 422 `duplicate` avec field extrait
 *  - E_INVALID_CREDENTIALS → 401 `invalid_credentials`
 *  - Vine validation errors → 422 (déjà géré par Adonis, on relaie)
 *  - Exception custom avec code & status → propage tel quel sous shape errors
 *  - Reste → fallback super.handle()
 */
export default class HttpExceptionHandler extends ExceptionHandler {
  protected debug = !app.inProduction

  async handle(error: unknown, ctx: HttpContext) {
    if (!isObject(error)) return super.handle(error, ctx)

    // Postgres unique violation → 422 propre (pas un 500 avec stack pg-protocol).
    //
    // Format du detail PG : `Key (col1, col2)=(val1, val2) already exists.`
    //
    // On veut un message lisible côté SPA. Pour les contraintes composites
    // multi-tenant (qui contiennent toujours `organization_id` comme 1re
    // colonne sur ce projet), `organization_id` n'est pas la colonne en
    // faute — c'est l'autre colonne (numero, slug, email…). On reporte
    // donc la 1re colonne NON-`organization_id` comme `field`, avec la
    // valeur correspondante pour un message explicite.
    if (error.code === '23505') {
      const detail = typeof error.detail === 'string' ? error.detail : ''
      const m = detail.match(/Key \(([^)]+)\)=\(([^)]+)\)/)
      const columns = m?.[1]?.split(',').map((s) => s.trim()) ?? []
      const values = m?.[2]?.split(',').map((s) => s.trim()) ?? []
      // Index de la 1re colonne != organization_id, sinon fallback sur 0.
      const idx = Math.max(
        0,
        columns.findIndex((c) => c !== 'organization_id')
      )
      const field = columns[idx]
      const value = values[idx]
      ctx.response.status(422)
      return ctx.response.json({
        errors: [
          {
            code: 'duplicate',
            message:
              field && value
                ? `${humanizeField(field)} « ${value} » existe déjà.`
                : 'Cette valeur existe déjà.',
            field: field ?? undefined,
          },
        ],
      })
    }

    // Adonis auth — mauvais credentials. Le default est 400, on veut 401.
    if (error.code === 'E_INVALID_CREDENTIALS') {
      ctx.response.status(401)
      return ctx.response.json({
        errors: [
          {
            code: 'invalid_credentials',
            message: 'Email ou mot de passe incorrect',
          },
        ],
      })
    }

    // Vine — validation errors. Adonis sort déjà des messages structurés,
    // on les relaie en `errors[]`.
    if (error.code === 'E_VALIDATION_ERROR' && Array.isArray(error.messages)) {
      ctx.response.status(422)
      return ctx.response.json({
        errors: error.messages.map((m) => ({
          code: 'validation_failed',
          message: typeof m === 'object' && m && 'message' in m ? String(m.message) : '',
          field: typeof m === 'object' && m && 'field' in m ? String(m.field) : undefined,
          rule: typeof m === 'object' && m && 'rule' in m ? String(m.rule) : undefined,
        })),
      })
    }

    // Custom Exception levée par les controllers : on a `status` + `code`
    // + `message`. On les passe en shape `errors[]`.
    if (
      typeof error.status === 'number' &&
      typeof error.code === 'string' &&
      typeof error.message === 'string' &&
      error.status >= 400 &&
      error.status < 600
    ) {
      ctx.response.status(error.status)
      return ctx.response.json({
        errors: [
          {
            code: error.code,
            message: error.message,
          },
        ],
      })
    }

    return super.handle(error, ctx)
  }

  async report(error: unknown, ctx: HttpContext) {
    // Capture seulement les vraies erreurs serveur (pas les 4xx attendues
    // type validation, auth invalide, etc. — déjà filtrées par beforeSend
    // dans start/sentry.ts mais on garde une 2ème ligne de défense ici).
    if (error instanceof Error) {
      const status = (error as { status?: number }).status
      const isServerError = !status || status >= 500
      if (isServerError) {
        // SÉCURITÉ : on log le PATTERN de la route ("/api/v1/checkin/:token/paid")
        // et pas l'URL réelle, sinon les codes OAuth (?code=...) et les
        // tokens de check-in (dans le path) fuiteraient dans les tags
        // Sentry, qui sont indexés et consultables par toute l'équipe.
        // ctx.request.url(false) strip la query string en fallback.
        const route = (ctx as unknown as { route?: { pattern?: string } }).route
        const safeUrl = route?.pattern ?? ctx.request.url(false)
        Sentry.captureException(error, {
          tags: {
            url: safeUrl,
            method: ctx.request.method(),
            status: status?.toString() ?? '500',
          },
          user: ctx.auth?.user
            ? { id: String((ctx.auth.user as { id: unknown }).id) }
            : undefined,
        })
      }
    }
    return super.report(error, ctx)
  }
}

function isObject(v: unknown): v is Record<string, unknown> {
  return v !== null && typeof v === 'object'
}

/**
 * Mappe un nom de colonne DB en libellé lisible pour les messages d'erreur
 * côté SPA. Volontairement court et conservateur — on ne traduit que les
 * champs qui peuvent réellement remonter sur une UNIQUE violation.
 */
function humanizeField(col: string): string {
  const map: Record<string, string> = {
    numero: 'Le numéro de facture',
    slug: 'Le slug',
    email: "L'email",
    siret: 'Le SIRET',
    powens_user_id: "L'identifiant utilisateur Powens",
    stripe_customer_id: "L'identifiant client Stripe",
    stripe_subscription_id: "L'identifiant abonnement Stripe",
  }
  return map[col] ?? `Le champ ${col}`
}