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).
    if (error.code === '23505') {
      const detail = typeof error.detail === 'string' ? error.detail : ''
      const fieldMatch = detail.match(/Key \(([^)]+)\)=/)
      const field = fieldMatch?.[1]?.split(',')[0]?.trim()
      ctx.response.status(422)
      return ctx.response.json({
        errors: [
          {
            code: 'duplicate',
            message: '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'
}