23. Banco de preguntas de entrevista y simulacros

function debounce<T extends (...args: never[]) => void>(fn: T, ms: number) {
  let id: ReturnType<typeof setTimeout> | undefined;

  // function normal, no flecha: así conserva el 'this' de la llamada
  return function (this: unknown, ...args: Parameters<T>) {
    if (id !== undefined) clearTimeout(id);
    id = setTimeout(() => fn.apply(this, args), ms);
  };
}
// Repregunta esperable: ¿y cómo lo cancelas?
// Se devuelve un objeto con la función y un método cancel() que hace clearTimeout.

// Hay TRES fugas: la suscripción al WebSocket (flujo infinito),
// el setInterval y la escucha de resize. La suscripción a this.api.refrescar()
// NO fuga: una petición HTTP se completa sola.

@Component({ selector: 'app-panel', template: '...' })
export class PanelComponent {
  private readonly ws = inject(WebSocketService);
  private readonly api = inject(TaskService);
  private readonly destroyRef = inject(DestroyRef);

  readonly datos = signal<Task[]>([]);

  constructor() {
    // 1) takeUntilDestroyed cancela al destruirse el componente
    this.ws.mensajes$
      .pipe(takeUntilDestroyed())
      .subscribe(m => this.datos.update(d => [...d, m]));

    // 2) timer de RxJS en lugar de setInterval: se cancela igual
    timer(0, 5000)
      .pipe(switchMap(() => this.api.refrescar()), takeUntilDestroyed())
      .subscribe();

    // 3) la escucha se registra y se retira explícitamente
    const alRedimensionar = () => { /* ... */ };
    window.addEventListener('resize', alRedimensionar);
    this.destroyRef.onDestroy(() =>
      window.removeEventListener('resize', alRedimensionar));
  }
}

// Opción A: cargar todo de una vez (bien si el número de tareas es moderado)
const proyectos = await em.find(Project, { teamId }, { populate: ['tasks'] });

// Opción B: si SOLO necesitas el contador, no traigas las tareas.
// Una única consulta agregada es muchísimo más barata:
const filas = await em.getConnection().execute<{ project_id: string; n: number }[]>(
  `SELECT project_id, count(*)::int AS n
     FROM tasks
    WHERE project_id = ANY(?) AND status <> 'done'
    GROUP BY project_id`,
  [proyectos.map(p => p.id)],
);
// Opción C: contador desnormalizado mantenido por trigger o suscriptor,
// si esta consulta se hace en cada carga de la pantalla principal.
//
// El criterio: A si necesitas los datos, B si solo necesitas el agregado,
// C si el agregado se pide constantemente y toleras mantenerlo.

export const ROLES_KEY = 'roles';
export const Roles = (...roles: Rol[]) => SetMetadata(ROLES_KEY, roles);

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private readonly reflector: Reflector) {}

  canActivate(ctx: ExecutionContext): boolean {
    // getAllAndOverride: el método tiene prioridad sobre el controlador
    const requeridos = this.reflector.getAllAndOverride<Rol[]>(ROLES_KEY, [
      ctx.getHandler(),
      ctx.getClass(),
    ]);
    // Sin metadatos, la ruta no exige rol concreto: dejar pasar.
    if (!requeridos?.length) return true;

    const { user } = ctx.switchToHttp().getRequest();
    if (!user) throw new UnauthorizedException();     // 401: no sé quién eres

    const permitido = requeridos.some(r => user.roles.includes(r));
    // 403 y no false: el mensaje al cliente es más honesto y depurar es más fácil.
    if (!permitido) throw new ForbiddenException('Permisos insuficientes');
    return true;
  }
}

function agruparPor<T, K extends keyof T>(
  items: readonly T[],
  clave: K,
): Map<T[K], T[]> {
  const mapa = new Map<T[K], T[]>();
  for (const item of items) {
    const k = item[clave];
    const grupo = mapa.get(k);
    if (grupo) grupo.push(item);
    else mapa.set(k, [item]);
  }
  return mapa;
}

// agruparPor(tareas, 'status')  →  Map<TaskStatus, Task[]>
// agruparPor(tareas, 'inexistente')  →  error de compilación
//
// Se usa Map y no un objeto porque la clave puede no ser string,
// y porque un objeto literal arrastra el prototipo (riesgo de colisión
// con claves como 'constructor').

// Dos problemas. 1) Dos flush independientes: si el segundo falla, el proyecto
// queda completado con tareas abiertas. 2) El correo se envía aunque después
// falle algo, y no se puede deshacer.

async completarProyecto(id: string) {
  const proyecto = await this.em.transactional(async (em) => {
    const p = await em.findOneOrFail(Project, id);
    p.completedAt = new Date();

    const tareas = await em.find(Task, { project: id, status: 'open' });
    for (const t of tareas) t.status = 'cancelled';

    return p;              // un único flush implícito al confirmar
  });

  // El efecto externo se lanza DESPUÉS de confirmar, y como trabajo en cola
  // para que un fallo del proveedor de correo no afecte a la operación
  // ni deje la transacción abierta esperando a una llamada de red.
  await this.cola.add('resumen-proyecto', { proyectoId: proyecto.id });
  return proyecto;
}

-- Forma 1: actualización atómica con la condición en el propio UPDATE.
-- La base de datos garantiza que solo una transacción lo consigue.
UPDATE projects
   SET miembros = miembros + 1
 WHERE id = ? AND miembros < max_miembros
RETURNING miembros;
-- Si no devuelve ninguna fila, el proyecto estaba lleno → 409.

-- Forma 2: bloqueo pesimista, si además hay que hacer más comprobaciones.
BEGIN;
SELECT * FROM projects WHERE id = ? FOR UPDATE;   -- los demás esperan
-- comprobar y actualizar con seguridad
COMMIT;

-- Forma 3 (bonus): bloqueo optimista con columna de versión y reintento.
-- Elegiría la 1 por sencillez y porque no mantiene bloqueos.