Sistema de Control de Inventario y Préstamos

import { PoolClient } from 'pg';
import { EquipmentAlreadyLoanedException, UserBlockedException } from '../exceptions';

export class LoanService {
  constructor(private readonly dbPool: any) {}

  /**
   * Registra un préstamo asegurando atomicidad y prevención de race conditions.
   */
  async registrarPrestamo(equipoId: string, usuarioId: string, operadorId: string): Promise<PrestamoResult> {
    const client: PoolClient = await this.dbPool.connect();

    try {
      await client.query('BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED');

      // 1. Bloqueo pesimista sobre la fila del equipo: previene carreras concurrentes
      const equipRes = await client.query(
        'SELECT id, estado, modelo FROM equipos WHERE id = $1 FOR UPDATE',
        [equipoId]
      );

      if (equipRes.rows.length === 0) {
        throw new Error('El equipo especificado no existe en inventario');
      }

      const equipo = equipRes.rows[0];
      if (equipo.estado !== 'DISPONIBLE') {
        throw new EquipmentAlreadyLoanedException(
          `El equipo ${equipo.modelo} no está disponible (Estado actual: ${equipo.estado})`
        );
      }

      // 2. Validar que el usuario solicitante esté activo
      const userRes = await client.query(
        'SELECT id, activo FROM usuarios WHERE id = $1',
        [usuarioId]
      );
      if (!userRes.rows[0]?.activo) {
        throw new UserBlockedException('El agente solicitante se encuentra inhabilitado');
      }

      // 3. Insertar el préstamo y mutar el estado del equipo de forma atómica
      const insertLoanQuery = `
        INSERT INTO prestamos (equipo_id, usuario_id, operador_id, estado, fecha_prestamo)
        VALUES ($1, $2, $3, 'ACTIVO', NOW())
        RETURNING id, fecha_prestamo;
      `;
      const loanRes = await client.query(insertLoanQuery, [equipoId, usuarioId, operadorId]);

      await client.query(
        'UPDATE equipos SET estado = \'PRESTADO\' WHERE id = $1',
        [equipoId]
      );

      await client.query('COMMIT');

      return {
        prestamoId: loanRes.rows[0].id,
        fechaPrestamo: loanRes.rows[0].fecha_prestamo,
        exitoso: true
      };
    } catch (error) {
      await client.query('ROLLBACK');
      throw error;
    } finally {
      client.release();
    }
  }
}

-- =========================================================================
-- DDL: Sistema de Control de Inventario & Préstamos Operativos
-- Motor: PostgreSQL 15+ (ACID compliant)
-- =========================================================================

CREATE TYPE estado_equipo AS ENUM ('DISPONIBLE', 'PRESTADO', 'TALLER', 'BAJA');
CREATE TYPE estado_prestamo AS ENUM ('ACTIVO', 'FINALIZADO_OK', 'FINALIZADO_CON_NOVEDAD');

-- Tabla de Inventario de Equipamiento
CREATE TABLE equipos (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    codigo_inventario VARCHAR(30) NOT NULL UNIQUE,
    modelo VARCHAR(120) NOT NULL,
    categoria VARCHAR(50) NOT NULL,
    estado estado_equipo NOT NULL DEFAULT 'DISPONIBLE',
    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
);

-- Tabla Transaccional de Préstamos
CREATE TABLE prestamos (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    equipo_id UUID NOT NULL REFERENCES equipos(id) ON DELETE RESTRICT,
    usuario_id UUID NOT NULL REFERENCES usuarios(id),
    operador_id UUID NOT NULL REFERENCES usuarios(id),
    fecha_prestamo TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
    fecha_devolucion TIMESTAMPTZ NULL,
    estado estado_prestamo NOT NULL DEFAULT 'ACTIVO',
    observaciones TEXT NULL
);

-- ÍNDICE ÚNICO PARCIAL: IMPOSIBILITA MATEMÁTICAMENTE DOBLE PRÉSTAMO ACTIVO
CREATE UNIQUE INDEX idx_equipo_prestamo_activo 
ON prestamos (equipo_id) 
WHERE estado = 'ACTIVO';

-- Índice para búsquedas rápidas en terminal de guardia
CREATE INDEX idx_equipos_estado_categoria ON equipos (estado, categoria);

import { LoanService } from './loan.service';
import { EquipmentAlreadyLoanedException } from '../exceptions';

describe('LoanService - Pruebas Unitarias de Reglas de Negocio', () => {
  let loanService: LoanService;
  let mockDbClient: any;
  let mockPool: any;

  beforeEach(() => {
    mockDbClient = {
      query: jest.fn(),
      release: jest.fn(),
    };
    mockPool = {
      connect: jest.fn().mockResolvedValue(mockDbClient),
    };
    loanService = new LoanService(mockPool);
  });

  it('debe rechazar el préstamo y hacer ROLLBACK si el equipo ya está en custodia', async () => {
    // Simulamos que la consulta FOR UPDATE devuelve un equipo ya PRESTADO
    mockDbClient.query
      .mockResolvedValueOnce({}) // BEGIN
      .mockResolvedValueOnce({
        rows: [{ id: 'eq-123', modelo: 'Handy Motorola', estado: 'PRESTADO' }]
      }); // SELECT FOR UPDATE

    await expect(
      loanService.registrarPrestamo('eq-123', 'user-456', 'op-789')
    ).rejects.toThrow(EquipmentAlreadyLoanedException);

    // Verificamos que se abortó la transacción para evitar datos corruptos
    expect(mockDbClient.query).toHaveBeenCalledWith('ROLLBACK');
    expect(mockDbClient.release).toHaveBeenCalled();
  });
});