Autenticación y Autorización en Comfaca Créditos

// shared/auth.d.ts
declare module "#auth-utils" {
  interface User {
    id: string
    email: string
    name: string
    roles: string[]
    username: string
    trabajador?: {
      nit: string
      estado: string
      sucursal: string
      phone: string
      email: string
    } | null
    adviser?: {
      estado: string
      phone: string
      email: string
      codigo_funcionario: string
      tipo_funcionario: string
    } | null
  }

  interface UserSession {
    loggedInAt: Date
  }
}

// shared/types/session.ts
export type SessionUser = {
  username: string
  roles: string[]
  permissions: string[]
  email: string
  tipo_documento: string
  numero_documento: string
  nombres: string
  apellidos: string
  adviser_number?: string
  asesor?: {
    full_name: string
    email: string
    celular: string
    codigo_funcionario: string
    estado: string
    tipo_funcionario: string
  }
  trabajador?: Trabajador | null
  selected_punto?: PuntoAsesoria | null
};

export type SessionData = {
  accessToken: string
  tokenType: string
  user: SessionUser | null
};

// shared/types/users-session.ts
export interface JwtPayload {
  sub: number    // ID numérico del usuario
  email: string
  roles: string[]
  iat?: number   // Emitido en (Unix timestamp)
  exp?: number   // Expira en (Unix timestamp)
}

// server/middleware/auth.ts
const PUBLIC_ROUTES: string[] = [
  "/api/auth/login",
  "/api/auth/register",
  "/api/auth/recovery",
  "/api/auth/adviser",
  "/api/auth/verify",
  "/api/auth/verify-code",
  "/api/auth/resend-code",
  "/api/health"
];

const PUBLIC_PREFIXES = [
  "/api/public/"
];

export default defineEventHandler(async (event) => {
  const url = getRequestURL(event);
  const path = url.pathname;

  // Solo intercepta rutas de la API (no páginas SSR)
  if (!path.startsWith("/api/")) return;

  // Excluir rutas internas de Nuxt (_nuxt) y payloads
  if (path.includes("/_nuxt")) return;
  if (path.endsWith("_payload.json")) return;

  // Permite rutas públicas sin autenticación
  if (PUBLIC_ROUTES.includes(path)) return;
  if (PUBLIC_PREFIXES.some(prefix => path.startsWith(prefix))) return;

  const session = await getUserSession(event).catch(() => null);

  if (!session?.user) {
    throw createError({
      statusCode: 401,
      statusMessage: "No autenticado",
      message: "Debe iniciar sesión para acceder a este recurso"
    });
  }

  // Inyectar el usuario en el contexto del evento
  event.context.user = session.user;
});

// server/middleware/admin.ts
export default defineEventHandler(async (event) => {
  if (!event.path.startsWith("/api/admin")) {
    return;
  }

  const session = await requireUserSession(event);
  const hasAdminRole = session.user.roles.includes("administrator");

  if (!hasAdminRole) {
    throw createError({
      statusCode: 401,
      message: "Unauthorized"
    });
  }

  return;
});

// server/middleware/validateSolicitudLimit.ts
const SOLICITUDES_ACTIVAS_ESTADOS = [
  "guardada",
  "enviada",
  "en_revision",
  "revision_comite"
];

const SOLICITUD_CREATE_PATHS = [
  "/api/solicitudes/guardar-solicitud",
  "/api/solicitudes/enviar-solicitud"
];

export default defineEventHandler(async (event) => {
  const path = event.path || "";
  const method = event.method || "";

  if (method !== "POST") return;

  const isSolicitudPath = SOLICITUD_CREATE_PATHS.some((p) => path.includes(p));
  if (!isSolicitudPath) return;

  const session = await getUserSession(event).catch(() => null);
  if (!session?.user?.username) return;

  try {
    // Obtener límite configurable desde la tabla de configuraciones
    const limiteStr = await configurationsService().getConfigurationByKey("limite_solicitudes");
    const limite = limiteStr ? parseInt(limiteStr, 10) : 10;

    if (isNaN(limite) || limite <= 0) return;

    const count = await prisma.solicitudes_credito.count({
      where: {
        owner_username: session.user.username,
        estado: { in: SOLICITUDES_ACTIVAS_ESTADOS }
      }
    });

    if (count >= limite) {
      setResponseStatus(event, 422);
      event.node.res.end(
        JSON.stringify(
          CustomResponse.error(
            `Has alcanzado el límite de ${limite} solicitudes activas. Completa o cancela una solicitud existente antes de crear una nueva.`,
            "Límite de solicitudes alcanzado"
          )
        )
      );
    }
  } catch (error) {
    // Si falla la consulta de config, no bloquear la operación (fail open)
    console.error("[validateSolicitudLimit] Error validando límite:", error);
  }
});

// app/middleware/auth.ts
export default defineNuxtRouteMiddleware(
  async (to: RouteLocationNormalized) => {
    if (import.meta.server) return;

    // Verificar si la ruta requiere autenticación
    if (!shouldApplyAuthMiddleware(to.path)) {
      return;
    }

    const { isAuthenticated, validateToken, clearSession, ready } = useSession();

    // Esperar a que la sesión se cargue desde el storage
    await ready;

    // Redirigir si no hay token local
    if (!isAuthenticated.value) {
      const redirect = encodeURIComponent(to.fullPath || "/");
      return navigateTo(`/login?redirect=${redirect}`);
    }

    // Validar token con backend en cada navegación
    const isValid = await validateToken();
    if (!isValid) {
      await clearSession();
      const redirect = encodeURIComponent(to.fullPath || "/");
      return navigateTo(`/login?redirect=${redirect}&expired=true`);
    }

    // Verificar permisos específicos para la ruta destino
    if (!hasPermissionForRoute(to.path, useSession().session.value.user?.roles || [])) {
      return navigateTo("/dash");
    }

    return;
  }
);