Biblia de entrevistas — Full Stack Angular + .NET

• InjectionToken<ProductSearchService> con el método search(term): Observable<Product[]>.
• FormControl + valueChanges → debounceTime(300) → distinctUntilChanged() → switchMap.
• catchError que devuelve of([]) — un error no debe completar el stream.
• finalize para apagar el loading (también corre al cancelar).
• Estado en signals: loading, error, results. Desuscripción con takeUntilDestroyed().

export interface Product { sku: string; nombre: string; precio: number; }
export interface ProductSearchService { search(term: string): Observable<Product[]>; }
export const PRODUCT_SEARCH = new InjectionToken<ProductSearchService>('PRODUCT_SEARCH');

@Injectable()
export class InMemoryProductSearch implements ProductSearchService {
  private readonly catalogo: Product[] = [
    { sku: 'VT-001', nombre: 'Colágeno Hidrolizado', precio: 599 },
    { sku: 'VT-002', nombre: 'Omega 3', precio: 449 },
  ];
  search(term: string): Observable<Product[]> {
    const q = term.trim().toLowerCase();
    const r = q ? this.catalogo.filter(p =>
      p.nombre.toLowerCase().includes(q) || p.sku.toLowerCase().includes(q)) : [];
    return of(r).pipe(delay(150));
  }
}

@Component({
  selector: 'app-product-search',
  standalone: true,
  imports: [ReactiveFormsModule, CurrencyPipe],
  template: `
    <input type="search" [formControl]="term" placeholder="Buscar producto o SKU…" />
    @if (loading()) { <p>Buscando…</p> }
    @else if (error()) { <p class="error">{{ error() }}</p> }
    @else if (term.value && results().length === 0) { <p>Sin resultados</p> }
    @else {
      <ul>@for (p of results(); track p.sku) {
        <li>{{ p.sku }} — {{ p.nombre }} ({{ p.precio | currency:'MXN' }})</li>
      }</ul>
    }`,
})
export class ProductSearchComponent {
  private readonly api = inject(PRODUCT_SEARCH);
  readonly term = new FormControl('', { nonNullable: true });
  readonly loading = signal(false);
  readonly error = signal<string | null>(null);
  readonly results = signal<Product[]>([]);

  constructor() {
    this.term.valueChanges.pipe(
      debounceTime(300),
      map(t => t.trim()),
      distinctUntilChanged(),
      tap(() => this.error.set(null)),
      switchMap(t => {
        if (!t) { this.results.set([]); return EMPTY; }
        this.loading.set(true);
        return this.api.search(t).pipe(
          catchError(() => { this.error.set('Error al buscar'); return of([] as Product[]); }),
          finalize(() => this.loading.set(false)),
        );
      }),
      takeUntilDestroyed(),
    ).subscribe(list => this.results.set(list));
  }
}

// Provider:  { provide: PRODUCT_SEARCH, useClass: InMemoryProductSearch }

• Un signal query = signal({ page: 1, pageSize: 10, sortBy: 'fecha', sortDir: 'desc' }).
• toObservable(query) → switchMap al servicio; o rxResource({ request: () => query(), loader: ... }).
• Total de páginas = Math.ceil(totalCount / pageSize).
• Cambiar de orden resetea a página 1.

type Query = { page: number; pageSize: number; sortBy: string; sortDir: 'asc'|'desc' };

@Component({ /* ... */ })
export class OrdersTableComponent {
  private readonly api = inject(ORDERS_API);
  readonly query = signal<Query>({ page: 1, pageSize: 10, sortBy: 'fecha', sortDir: 'desc' });

  private readonly page$ = toObservable(this.query).pipe(
    switchMap(q => this.api.list(q).pipe(startWith(null))),  // null = loading
  );
  readonly result = toSignal(this.page$, { initialValue: null });

  readonly totalPages = computed(() => {
    const r = this.result(); const q = this.query();
    return r ? Math.ceil(r.totalCount / q.pageSize) : 0;
  });

  sortBy(col: string) {
    this.query.update(q => ({
      ...q, page: 1, sortBy: col,
      sortDir: q.sortBy === col && q.sortDir === 'asc' ? 'desc' : 'asc',
    }));
  }
  goTo(page: number) { this.query.update(q => ({ ...q, page })); }
}

const form = this.fb.nonNullable.group({
  sku: ['', [Validators.required, Validators.pattern(/^[A-Z]{2}-\d{3,}$/)]],
  precio: [0, [Validators.required, Validators.min(0.01)]],
  precioOferta: [null as number | null],
}, { validators: ofertaMenorQuePrecio });

function ofertaMenorQuePrecio(g: AbstractControl): ValidationErrors | null {
  const precio = g.get('precio')?.value;
  const oferta = g.get('precioOferta')?.value;
  return oferta != null && oferta >= precio ? { ofertaInvalida: true } : null;
}

Template: @if (form.controls.sku.touched && form.controls.sku.errors?.['required'])… y [disabled]="form.invalid" en el botón.

export const apiInterceptor: HttpInterceptorFn = (req, next) => {
  const auth = inject(AuthService);
  const token = auth.token();
  const authReq = token ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } }) : req;

  return next(authReq).pipe(
    map(event => {
      if (event instanceof HttpResponse && event.body?.processCorrect === false) {
        throw new HttpErrorResponse({ error: event.body, status: 422, url: req.url });
      }
      return event;
    }),
    catchError((err: HttpErrorResponse) => {
      if (err.status === 401) auth.logout();
      const msg = err.error?.messageError ?? 'Error de red';
      inject(ToastService).error(msg);
      return throwError(() => err);
    }),
  );
};

export const rolGuard = (rol: string): CanActivateFn => () => {
  const auth = inject(AuthService);
  const router = inject(Router);
  return auth.tieneRol(rol) ? true : router.createUrlTree(['/sin-acceso']);
};

// spec
it('redirige si no tiene el rol', () => {
  TestBed.configureTestingModule({
    providers: [
      { provide: AuthService, useValue: { tieneRol: () => false } },
      { provide: Router, useValue: { createUrlTree: jasmine.createSpy().and.returnValue('URLTREE') } },
    ],
  });
  const result = TestBed.runInInjectionContext(() => rolGuard('admin')(null!, null!));
  expect(result).toBe('URLTREE' as any);
});

describe('DisponibilidadService', () => {
  let svc: DisponibilidadService;
  let http: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      imports: [HttpClientTestingModule],
      providers: [DisponibilidadService],
    });
    svc = TestBed.inject(DisponibilidadService);
    http = TestBed.inject(HttpTestingController);
  });
  afterEach(() => http.verify());

  it('devuelve la lista en éxito', () => {
    let out: any;
    svc.porSku('VT-001').subscribe(r => (out = r));
    http.expectOne('/api/productos/VT-001/disponibilidad')
        .flush([{ almacen: 'CDMX', cantidad: 40 }]);
    expect(out.length).toBe(1);
  });

  it('propaga el error de red', () => {
    let err: any;
    svc.porSku('X').subscribe({ error: e => (err = e) });
    http.expectOne(() => true).flush('boom', { status: 500, statusText: 'Server Error' });
    expect(err.status).toBe(500);
  });

  it('trata processCorrect=false como error', () => {
    let err: any;
    svc.porSku('X').subscribe({ error: e => (err = e) });
    http.expectOne(() => true).flush({ processCorrect: false, messageError: 'no existe' });
    expect(err.message).toContain('no existe');
  });
});

// ---- Envelope ----
public class Result<T>
{
    public bool   ProcessCorrect { get; set; }
    public string TypeError      { get; set; } = "";
    public string MessageError   { get; set; } = "";
    public T?     Data           { get; set; }
    public static Result<T> Ok(T data) => new() { ProcessCorrect = true, Data = data };
    public static Result<T> Fail(string type, string msg) =>
        new() { ProcessCorrect = false, TypeError = type, MessageError = msg };
}

// ---- DTO ----
public sealed record DisponibilidadAlmacen(string Almacen, int Cantidad);

// ---- Servicio ----
public interface IInventarioService
{
    Task<Result<IReadOnlyList<DisponibilidadAlmacen>>> PorSkuAsync(string sku, CancellationToken ct = default);
}

public sealed class InventarioService(IDbConnection db, ILogger<InventarioService> log) : IInventarioService
{
    private const string Sql = """
        SELECT   s.Almacen, s.Cantidad
        FROM     dbo.StockPorAlmacen AS s
        WHERE    s.Sku = @Sku AND s.Cantidad > 0
        ORDER BY s.Cantidad DESC;
        """;

    public async Task<Result<IReadOnlyList<DisponibilidadAlmacen>>> PorSkuAsync(
        string sku, CancellationToken ct = default)
    {
        if (string.IsNullOrWhiteSpace(sku))
            return Result<IReadOnlyList<DisponibilidadAlmacen>>.Fail("Validation", "El SKU es obligatorio.");
        try
        {
            var cmd  = new CommandDefinition(Sql, new { Sku = sku }, cancellationToken: ct);
            var rows = (await db.QueryAsync<DisponibilidadAlmacen>(cmd)).AsList();
            return rows.Count == 0
                ? Result<IReadOnlyList<DisponibilidadAlmacen>>.Fail("NotFound", $"Sin disponibilidad para {sku}.")
                : Result<IReadOnlyList<DisponibilidadAlmacen>>.Ok(rows);
        }
        catch (SqlException ex)
        {
            log.LogError(ex, "Error consultando disponibilidad de {Sku}", sku);
            return Result<IReadOnlyList<DisponibilidadAlmacen>>.Fail("Exception", "Error al consultar la disponibilidad.");
        }
    }
}

// ---- Endpoint (Minimal API) ----
app.MapGet("/api/productos/{sku}/disponibilidad",
    async (string sku, IInventarioService svc, CancellationToken ct) =>
        Results.Ok(await svc.PorSkuAsync(sku, ct)));

// ---- o Controller ----
[ApiController, Route("api/productos")]
public class ProductosController(IInventarioService svc) : ControllerBase
{
    [HttpGet("{sku}/disponibilidad")]
    public async Task<IActionResult> Disponibilidad(string sku, CancellationToken ct)
        => Ok(await svc.PorSkuAsync(sku, ct));
}

public async Task<Result<int>> CrearPedidoAsync(NuevoPedido input, CancellationToken ct)
{
    if (input.Lineas is null or { Count: 0 })
        return Result<int>.Fail("Validation", "El pedido necesita al menos una línea.");

    using var conn = new SqlConnection(_cs);
    await conn.OpenAsync(ct);
    using var tx = conn.BeginTransaction();
    try
    {
        var pedidoId = await conn.ExecuteScalarAsync<int>(new CommandDefinition(
            "INSERT INTO dbo.[Order](Fecha, ClienteId) OUTPUT INSERTED.OrderId VALUES(SYSUTCDATETIME(), @ClienteId);",
            new { input.ClienteId }, tx, cancellationToken: ct));

        foreach (var l in input.Lineas)
            await conn.ExecuteAsync(new CommandDefinition(
                "INSERT INTO dbo.OrderLine(OrderId, ProductId, Cantidad, Precio) VALUES(@pedidoId, @ProductId, @Cantidad, @Precio);",
                new { pedidoId, l.ProductId, l.Cantidad, l.Precio }, tx, cancellationToken: ct));

        tx.Commit();
        return Result<int>.Ok(pedidoId);
    }
    catch (Exception ex)
    {
        tx.Rollback();
        _log.LogError(ex, "Rollback creando pedido");
        return Result<int>.Fail("Exception", "No se pudo crear el pedido.");
    }
}

public sealed record PageRequest(int Page = 1, int PageSize = 20, string? Search = null);
public sealed record PagedResponse<T>(IReadOnlyList<T> Data, long TotalCount, int Page, int TotalPages);

private const string Sql = """
    SELECT p.Sku, p.Nombre, p.Precio
    FROM   dbo.Product p
    WHERE  (@Search IS NULL OR p.Nombre LIKE '%' + @Search + '%')
    ORDER BY p.Nombre
    OFFSET (@Page - 1) * @PageSize ROWS FETCH NEXT @PageSize ROWS ONLY;

    SELECT COUNT(*)
    FROM   dbo.Product p
    WHERE  (@Search IS NULL OR p.Nombre LIKE '%' + @Search + '%');
    """;

public async Task<PagedResponse<ProductDto>> ListAsync(PageRequest req, CancellationToken ct)
{
    using var multi = await _db.QueryMultipleAsync(new CommandDefinition(Sql, req, cancellationToken: ct));
    var data  = (await multi.ReadAsync<ProductDto>()).AsList();
    var total = await multi.ReadSingleAsync<long>();
    var pages = (int)Math.Ceiling(total / (double)req.PageSize);
    return new(data, total, req.Page, pages);
}

public sealed class ExceptionToResultMiddleware(RequestDelegate next, ILogger<ExceptionToResultMiddleware> log)
{
    public async Task Invoke(HttpContext ctx)
    {
        try { await next(ctx); }
        catch (Exception ex)
        {
            log.LogError(ex, "Excepción no controlada en {Path}", ctx.Request.Path);
            ctx.Response.StatusCode = StatusCodes.Status200OK;   // estilo envelope
            ctx.Response.ContentType = "application/json";
            await ctx.Response.WriteAsJsonAsync(new
            {
                processCorrect = false,
                typeError = "Exception",
                messageError = "Ocurrió un error inesperado.",
            });
        }
    }
}
// app.UseMiddleware<ExceptionToResultMiddleware>();  // lo más arriba posible

public static IReadOnlyList<string> Top3PorMonto(IEnumerable<(string Sku, decimal Monto)> ventas) =>
    ventas.GroupBy(v => v.Sku)
          .Select(g => (Sku: g.Key, Total: g.Sum(x => x.Monto)))
          .OrderByDescending(x => x.Total)
          .Take(3)
          .Select(x => x.Sku)
          .ToList();