Saltar a contenido

Parte 9: Teslo Shop

Una tienda en línea de ropa, hecha paso a paso. Esta parte arma el frente de la tienda (store front): la portada con la lista de productos, un navbar que se adapta al celular, las rutas por género (hombre, mujer, niños) y el servicio que pide los productos a una API. La tienda sigue en construcción: lo que se explica aquí es lo que ya está hecho, y cada módulo nuevo se agrega al final de esta página.

Esta es la novena parte de una guía que sigue un curso de Angular. El código está en angular-ufh, un repositorio de estudio con una carpeta numerada por parte (01-typescript-intro, 02-bases… 09-teslo-shop), cada una un proyecto independiente; esta parte es la carpeta 09-teslo-shop/. Es una aplicación Angular 22 creada con ng new (el comando que arma un proyecto nuevo, explicado pregunta por pregunta en el Módulo A2 de la Parte 2 (Angular)), sin zone.js (zoneless). El aspecto lo dan Tailwind CSS (clases de utilidad para los estilos) y daisyUI (componentes ya diseñados sobre Tailwind), con el tema cyberpunk; cómo se instalan está en el Módulo C1 de la Parte 4 (Country App).

Proyecto: 09-teslo-shop/. Sitio publicado: todavía no está desplegado. Para verla funcionando, clona el repositorio y usa npm install y npm start dentro de la carpeta (http://localhost:4200/). Los productos se piden a una API que corre en tu máquina (http://localhost:3000/api); por ahora la portada todavía no dibuja lo que responde, sólo una tarjeta de ejemplo, y la respuesta se ve en la consola del navegador.

Para seguirlo en tu propio proyecto. Nada de esta parte depende del repositorio: en cualquier proyecto de Angular 22 con Tailwind y daisyUI puedes copiar las rutas, el navbar y el servicio. Las rutas cortas de los imports (@products/..., @auth/...) son alias de tsconfig.json: un alias es un atajo para no escribir ../../../ en cada import. Si no los tienes, usa la ruta relativa.

Esta página va creciendo: cada módulo nuevo se agrega al final. Por ahora cubre la estructura de rutas con un layout compartido, el navbar adaptable, las fuentes y la animación propias de Tailwind y el servicio de productos.

Qué vas a aprender:

  • Módulo T1: Rutas con un layout compartido. Cómo todas las páginas de la tienda comparten el navbar sin repetirlo, qué es una ruta hija, cómo se cargan por pedido las rutas y las páginas, y para qué sirve la ruta comodín.
  • Módulo T2: Un navbar que se adapta al celular. Un menú que es horizontal en pantallas grandes y plegable en las chicas, con un input() para elegir desde qué tamaño cambia, por qué Tailwind no ve las clases armadas al ejecutar y cómo una plantilla reutilizable (ng-template) evita escribir los enlaces dos veces.
  • Módulo T3: Fuentes y animación propias. Cómo cargar una tipografía local con @font-face, cómo decirle a Tailwind que la use en toda la página y cómo crear una clase nueva (animate-fade-in) con @theme.
  • Módulo T4: Los tipos de la API y el servicio de productos. Cómo describir con interfaces lo que responde la API, por qué hace falta provideHttpClient() y cómo la portada pide los productos con rxResource.

Cada módulo sigue el mismo orden: el problema que resuelve, el código del repositorio, cómo funciona por dentro, errores comunes y preguntas de entrevista con su respuesta.

Esta página es una parte de la guía de estudio; allí están el mapa general y la ruta recomendada. Conviene haber visto antes la Parte 8: Maps App (sigue el orden del curso) y, sobre todo, lo que esta parte da por sabido: las rutas con carga perezosa, en el Módulo G2 de la Parte 3 (Gifs App), y rxResource, en el Módulo C19 de la Parte 4 (Country App).


Módulo T1: Rutas con un layout compartido y carga perezosa

El problema

En una tienda, el navbar aparece en todas las páginas: la portada, la lista de mujeres, la ficha de un producto. Si lo pegas en cada página, tienes el mismo código tres veces y, el día que cambias un enlace, lo cambias tres veces.

La solución es una ruta con hijos (child routes). Una página «madre», el layout, dibuja lo que se repite (el navbar) y deja un hueco donde Angular pone la página hija que corresponde a la dirección. Entras a /gender/men y en el hueco aparece la página de género; entras a / y aparece la portada. El navbar nunca se redibuja.

El código del repositorio

La ruta raíz del proyecto no declara páginas: delega todo a un archivo de rutas propio de la tienda (app.routes.ts):

export const routes: Routes = [
  {
    path: '',
    loadChildren: () => import('./store-front/store-front.routes'),
  },
]

Las rutas de la tienda viven en store-front.routes.ts:

export const storeFrontRoutes: Routes = [
  {
    path: '',
    loadComponent: () => import('./layouts/store-front-layout/store-front-layout.component'),
    children: [
      {
        path: '',
        title: 'Home',
        loadComponent: () => import('./pages/home-page/home-page.component'),
      },
      {
        path: 'gender/:gender',
        title: 'Gender',
        loadComponent: () => import('./pages/gender-page/gender-page.component'),
      },
      {
        path: 'product/:idSlug',
        title: 'Product',
        loadComponent: () => import('./pages/product-page/product-page.component'),
      },
      {
        path: '**',
        loadComponent: () => import('./pages/not-found-page/not-found-page.component'),
      },
    ],
  },
  {
    path: '**',
    redirectTo: '',
  },
]

export default storeFrontRoutes

Y el layout (store-front-layout.component.html) es el navbar más el hueco para la página hija:

<store-front-navbar />

<section class="container mx-auto mt-5 px-5">
  <router-outlet />
</section>

Por ahora la portada ya pide los productos a la API (se explica en el Módulo T4) y muestra una tarjeta de ejemplo; las páginas de género, de producto y de «no encontrado» existen como esqueleto (gender-page works!) y se llenan en los módulos siguientes.

Cómo funciona por dentro

URL              ruta que coincide                   qué se dibuja
/                layout  >  ''                       navbar + portada
/gender/men      layout  >  gender/:gender           navbar + página de género
/product/camisa  layout  >  product/:idSlug          navbar + página de producto
/cualquier-cosa  layout  >  **                       navbar + «no encontrado»

Tres ideas hacen que esto funcione:

  • loadChildren y loadComponent cargan por pedido. import(...) dentro de una función le dice a Angular: «descarga este archivo sólo cuando alguien entre a esta ruta». El navegador baja menos al abrir la tienda. loadChildren carga un archivo de rutas completo; loadComponent carga un componente.
  • export default hace que el import() sea corto. loadChildren espera el valor por defecto del archivo; por eso store-front.routes.ts termina con export default storeFrontRoutes y app.routes.ts no necesita escribir .then(m => m.storeFrontRoutes). Lo mismo vale para las páginas, que son export default class. El layout y las páginas se cargan por ruta, y por eso son los únicos componentes del proyecto con export default.
  • Los dos puntos de :gender son un parámetro. gender/:gender coincide con /gender/men, /gender/female o /gender/lo-que-sea, y guarda esa última parte con el nombre gender. En otro módulo la página lo leerá.

La ruta '**' es el comodín (wildcard): coincide con cualquier dirección que no encajó antes, así que va siempre al final. Aquí hay dos. La de adentro muestra la página de «no encontrado» dentro del layout, con el navbar a la vista. La de afuera es una red de seguridad que manda a la portada cualquier cosa que ni siquiera entre al layout.

title en una ruta cambia el título de la pestaña del navegador al entrar.

Errores comunes

  • Poner el comodín antes que las rutas concretas. Angular recorre las rutas en orden y se queda con la primera que coincide; un '**' al principio se traga todo y las demás nunca se usan.
  • Olvidar el <router-outlet /> en el layout. Sin el hueco, Angular no tiene dónde dibujar la página hija y sólo ves el navbar.
  • Quitar el export default y dejar el import() corto. loadChildren recibe un objeto sin rutas y la navegación falla. O se deja el default, o se escribe .then(m => m.storeFrontRoutes).
  • Importar el layout o una página con import { ... } en vez de por ruta. Pierdes la carga perezosa: el archivo viaja con el paquete inicial.

Resumen

  • Un layout con <router-outlet /> reparte lo común (el navbar) entre muchas páginas.
  • children define qué página va en el hueco según la dirección.
  • loadChildren y loadComponent descargan el código sólo cuando se visita la ruta.
  • export default deja el import() corto; el comodín '**' va al final.

Preguntas de entrevista

1. ¿Para qué sirve un layout con rutas hijas y qué ventaja tiene sobre repetir el navbar en cada página?

Respuesta:

Sirve para dibujar una sola vez lo que se repite y cambiar sólo el contenido que está dentro. El layout declara un <router-outlet /> y Angular pone ahí la ruta hija que coincide. Además de no duplicar código, el navbar no se destruye ni se vuelve a crear al navegar, así que conserva su estado (por ejemplo, un texto escrito en el buscador).

2. ¿Qué diferencia hay entre loadChildren y loadComponent?

Respuesta:

loadChildren descarga un archivo de rutas entero (un grupo de rutas con sus propias hijas) y loadComponent descarga un solo componente. Los dos usan import() para que el código se baje sólo cuando alguien visita esa ruta.

3. ¿Por qué app.routes.ts puede escribir import('./store-front/store-front.routes') sin .then(...)?

Respuesta:

Porque loadChildren toma el valor default del módulo cargado, y el archivo de rutas termina con export default storeFrontRoutes. Sin el default habría que indicar cuál export usar con .then(m => m.storeFrontRoutes).

4. ¿Por qué hay dos rutas '**' en store-front.routes.ts?

Respuesta:

La de adentro (hija del layout) muestra la página de «no encontrado» con el navbar a la vista. La de afuera atrapa lo que no entró al layout y redirige a la portada. Ambas van al final de su lista porque Angular usa la primera ruta que coincide.

Módulo T2: Un navbar que se adapta al celular

El problema

En una pantalla grande, los enlaces (Men, Women, Kids) van en fila dentro de la barra. En un celular no caben: hace falta un botón de «hamburguesa» que despliegue el menú hacia abajo. Son dos menús distintos con los mismos enlaces, y además la pantalla a partir de la cual se cambia de uno a otro (el breakpoint) debería poder elegirse sin tocar el componente por dentro.

Hay tres problemas pequeños en uno:

  1. Cómo mostrar un menú u otro según el tamaño de la pantalla.
  2. Cómo no escribir la lista de enlaces dos veces.
  3. Cómo hacer que Tailwind genere clases cuyo nombre se arma al ejecutar.

El código del repositorio

Los datos del menú son una constante (store-front.constants.ts) con su tipo en store-front.interfaces.ts:

export type Breakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl'

export interface NavLink {
  label: string
  path: string
}

export const NAV_LINKS: readonly NavLink[] = [
  { label: 'Men', path: '/gender/men' },
  { label: 'Women', path: '/gender/female' },
  { label: 'Kids', path: '/gender/kid' },
]

El componente (store-front-navbar.component.ts):

@Component({
  selector: 'store-front-navbar',
  imports: [RouterLink, RouterLinkActive, NgTemplateOutlet],
  templateUrl: './store-front-navbar.component.html',
})
export class StoreFrontNavbarComponent {
  // Screen size where the navbar switches from the mobile menu to the desktop one
  breakpoint = input<Breakpoint>('lg')
  // Links shown in both menus; the list never changes, so it is not a signal
  readonly navLinks = NAV_LINKS
}

La plantilla (store-front-navbar.component.html), resumida a lo que importa:

<div class="max-{{ breakpoint() }}:collapse bg-base-200 shadow-sm w-full rounded-md">
  <input id="navbar-1-toggle" class="peer hidden" type="checkbox" />
  ...
  <div class="collapse-title navbar container mx-auto">
    <div class="navbar-start">
      <label for="navbar-1-toggle" class="btn btn-ghost {{ breakpoint() }}:hidden">...</label>
      <a class="btn btn-ghost text-xl font-stretch-50%" routerLink="/">...</a>
    </div>
    <div class="navbar-center hidden {{ breakpoint() }}:flex">
      <ul class="menu menu-horizontal px-1">
        <ng-container [ngTemplateOutlet]="links" />
      </ul>
    </div>
    ...
  </div>

  <div class="collapse-content container mx-auto {{ breakpoint() }}:hidden z-1">
    <ul class="menu">
      <ng-container [ngTemplateOutlet]="links" />
    </ul>
  </div>
</div>

<ng-template #links>
  @for (link of navLinks; track link.path) {
    <li>
      <a class="btn" [routerLink]="link.path" routerLinkActive="btn-soft">{{ link.label }}</a>
    </li>
  }
</ng-template>

Y en tailwind.css, la lista de clases que Tailwind debe generar:

@source inline("{sm,md,lg,xl,2xl}:{hidden,flex,w-auto}");
@source inline("max-{sm,md,lg,xl,2xl}:{collapse,peer-checked:block}");

Cómo funciona por dentro

Un menú u otro según la pantalla. Tailwind tiene prefijos por tamaño: lg:flex significa «flex sólo cuando la pantalla mide lg o más» y max-lg:collapse significa «collapse sólo cuando mide menos que lg». El menú horizontal lleva hidden lg:flex (oculto, salvo en pantallas grandes) y el desplegable lleva lg:hidden (oculto en pantallas grandes). Ninguno de los dos usa JavaScript: el navegador decide con CSS.

El botón que despliega. El truco es un <input type="checkbox"> oculto. El botón de hamburguesa es un <label for="navbar-1-toggle">: al tocarlo, marca o desmarca el checkbox. Con el checkbox marcado, daisyUI abre el bloque collapse-content. No hay ninguna señal ni evento de Angular: es HTML y CSS.

El tamaño como input(). breakpoint = input<Breakpoint>('lg') deja que quien use el componente elija desde qué tamaño se pasa al menú de escritorio: <store-front-navbar breakpoint="md" />. Sin nada, vale 'lg'. El tipo Breakpoint impide escribir un tamaño que no existe.

Los enlaces, una sola vez. Un <ng-template #links> es un trozo de plantilla guardado con un nombre, que no se dibuja solo. Con <ng-container [ngTemplateOutlet]="links" /> lo dibujas donde quieras, y aquí se dibuja dos veces: en el menú horizontal y en el desplegable. Si mañana hay un cuarto enlace, se agrega a NAV_LINKS y aparece en los dos. routerLinkActive="btn-soft" le agrega esa clase al enlace de la página en la que estás.

navLinks no es una señal porque la lista nunca cambia; una señal sólo tiene sentido para datos que cambian.

Por qué existe @source inline. Tailwind no ejecuta tu código: lee los archivos como texto y genera sólo las clases que encuentra escritas enteras. En la plantilla aparece {{ breakpoint() }}:flex, y como Tailwind no sabe qué valdrá breakpoint(), no ve ninguna clase lg:flex y no la genera. @source inline(...) le dice «genera estas clases aunque no las veas»: la llave {...} expande todas las combinaciones. Quien agregue un tamaño nuevo al tipo Breakpoint tiene que agregarlo también ahí.

Errores comunes

  • Armar una clase de Tailwind con una variable y no listarla. El menú parece no reaccionar al tamaño de la pantalla porque la clase nunca se generó. O se escribe la clase entera en el código o se lista con @source inline.
  • Repetir los enlaces en los dos menús. Se desincronizan la primera vez que se cambia uno y se olvida el otro.
  • Dos menús con el mismo id de checkbox. El label for abre el primero que encuentra. Si el navbar se usa dos veces en la misma página, cada copia necesita un id distinto.
  • Usar una señal para una lista fija. Funciona, pero complica sin ganar nada.

Resumen

  • Los prefijos lg: y max-lg: de Tailwind cambian el diseño sin JavaScript.
  • Un checkbox oculto y un label abren el menú desplegable.
  • input() con un tipo cerrado (Breakpoint) permite elegir el tamaño de cambio.
  • ng-template con ngTemplateOutlet evita escribir los enlaces dos veces.
  • Las clases armadas al ejecutar hay que listarlas con @source inline.

Preguntas de entrevista

1. ¿Por qué Tailwind no genera una clase como {{ breakpoint() }}:flex?

Respuesta:

Porque Tailwind lee los archivos como texto, sin ejecutarlos, y sólo genera las clases que encuentra escritas completas. Una clase armada con una variable no existe como texto hasta que el navegador la calcula, demasiado tarde. La salida es listar las combinaciones posibles con @source inline(...) o escribir las clases enteras.

2. ¿Qué es un ng-template y qué hace ngTemplateOutlet?

Respuesta:

Un ng-template es un fragmento de plantilla guardado con un nombre que no se dibuja por sí solo. ngTemplateOutlet lo dibuja en el lugar donde lo pongas, y se puede usar varias veces. Aquí evita escribir los enlaces del menú en el bloque de escritorio y en el del celular.

3. ¿Cómo se despliega el menú del celular si no hay ningún evento de Angular?

Respuesta:

Con un checkbox oculto. El botón es un <label for="..."> apuntando a ese checkbox, así que tocarlo lo marca o desmarca. daisyUI muestra el contenido desplegable cuando el checkbox está marcado, todo con CSS.

Respuesta:

breakpoint lo decide quien usa el componente y puede cambiar, así que es un input de señal. navLinks es una lista fija que sale de una constante: no cambia, nadie la pasa desde fuera y no necesita avisar a la plantilla, por eso una señal sobraría.

Módulo T3: Fuentes y animación propias en Tailwind

El problema

Quieres que toda la tienda se vea con una tipografía de marca (Montserrat) y que las tarjetas aparezcan con un desvanecido suave en vez de saltar a la pantalla. Tailwind trae muchas utilidades, pero no tu fuente ni tu animación: hay que enseñárselas una vez, y después se usan como cualquier clase.

El código del repositorio

Todo está en tailwind.css:

@font-face {
  font-family: 'Montserrat';
  src: url('/fonts/montserrat-medium.ttf') format('truetype');
  font-weight: 500;
  font-style: normal;
  font-display: swap;
}

@font-face {
  font-family: 'Montserrat Alternates';
  src: url('/fonts/montserrat-alternates-medium.ttf') format('truetype');
  font-weight: 500;
  font-style: normal;
  font-display: swap;
}

@theme {
  --font-sans: 'Montserrat Alternates', sans-serif;
  --font-montserrat: 'Montserrat', sans-serif;

  --animate-fade-in: fade-in 0.3s ease-in-out;

  @keyframes fade-in {
    from {
      opacity: 0;
    }
    to {
      opacity: 1;
    }
  }
}

Los archivos .ttf están en la carpeta public/fonts/. La tarjeta de producto usa la animación con una clase (product-card.component.html):

<div class="card bg-base-100 shadow-sm animate-fade-in">

Cómo funciona por dentro

  • @font-face le dice al navegador: «existe una fuente llamada Montserrat, y su archivo está en esta dirección». Hace falta un bloque por cada peso (font-weight) que uses. font-display: swap muestra el texto con una fuente del sistema mientras la tuya descarga, para que la página no quede en blanco.
  • @theme es la lista de «ajustes de diseño» de Tailwind. Una variable que empieza con --font- crea una clase de fuente, una que empieza con --animate- crea una clase de animación. --font-sans es especial: es la fuente que Tailwind aplica a toda la página por defecto, así que cambiarla cambia la tipografía de todo sin tocar ningún componente. --font-montserrat crea la clase font-montserrat para usar Montserrat sólo donde la pidas.
  • --animate-fade-in crea la clase animate-fade-in. Su valor es una animación de CSS normal (nombre, duración, curva), y @keyframes define los fotogramas: empieza invisible (opacity: 0) y termina visible (opacity: 1).
  • Las rutas empiezan con / (/fonts/...) porque la carpeta public/ se sirve desde la raíz del sitio.

Errores comunes

  • Poner el archivo de la fuente fuera de public/. El navegador pide /fonts/... y no lo encuentra; la página usa la fuente de reemplazo sin avisar.
  • Pedir un peso que no declaraste. Con sólo el peso 500 declarado, el negrita (font-bold) lo inventa el navegador ensanchando las letras, y se ve distinto al peso real. Para negrita verdadera hay que declarar ese peso con su archivo.
  • Escribir @keyframes fuera de @theme y esperar la clase. La animación existe, pero no hay animate-* que la use.

Resumen

  • @font-face registra la fuente; @theme la convierte en clases de Tailwind.
  • --font-sans cambia la fuente de toda la página.
  • --animate-nombre más @keyframes crea la clase animate-nombre.

Preguntas de entrevista

1. ¿Cómo se cambia la tipografía de toda la aplicación con Tailwind?

Respuesta:

Se declara la fuente con @font-face y se asigna a --font-sans dentro de @theme. Tailwind aplica esa variable al body, así que todos los textos que no pidan otra fuente la heredan.

2. ¿Para qué sirve font-display: swap?

Respuesta:

Para que el texto se vea de inmediato con una fuente del sistema mientras la tuya se descarga, y se cambie por la tuya cuando llega. Sin eso, algunos navegadores esconden el texto hasta que la fuente está lista.

3. ¿Cómo se crea una clase de animación propia en Tailwind?

Respuesta:

Dentro de @theme se define una variable --animate-nombre con la animación (por ejemplo fade-in 0.3s ease-in-out) y se escribe el @keyframes con ese nombre. Tailwind genera la clase animate-nombre y se usa como cualquier otra.

Módulo T4: Los tipos de la API y el servicio de productos

El problema

La lista de productos no está en la aplicación: la tiene una API que corre aparte. Para usarla, Angular necesita tres cosas: saber qué forma tiene lo que responde la API (para que el editor avise si escribes product.titel), un lugar único que haga la petición y un componente que pida los datos sin dejar la página bloqueada mientras llegan.

El código del repositorio

Los tipos de la respuesta (product.interface.ts):

import { User } from '@auth/interfaces/auth.interface'

export interface ProductResponse {
  count: number
  pages: number
  products: ProductElement[]
}

export interface ProductElement {
  id: string
  title: string
  price: number
  description: string
  slug: string
  stock: number
  sizes: Size[]
  gender: Gender
  tags: string[]
  images: string[]
  user: User
}

export enum Gender {
  Kid = 'kid',
  Men = 'men',
  Unisex = 'unisex',
  Women = 'women',
}

export enum Size {
  L = 'L',
  M = 'M',
  S = 'S',
  XL = 'XL',
  XS = 'XS',
  XXL = 'XXL',
}

(El archivo también define un enum Tag, con las etiquetas hats, hoodie, jacket, shirt y sweatshirt.) User viene de auth.interface.ts: id, email, fullName, isActive y roles.

El servicio (product.service.ts), en la versión de este momento del repositorio:

@Injectable({
  providedIn: 'root',
})
export class ProductService {
  private http = inject(HttpClient)

  getProducts(): Observable<ProductResponse> {
    return this.http
      .get<ProductResponse>('http://localhost:3000/api/products')
      .pipe(tap((response) => console.log(response)))
  }
}

La configuración (app.config.ts):

export const appConfig: ApplicationConfig = {
  providers: [provideBrowserGlobalErrorListeners(), provideRouter(routes), provideHttpClient()],
}

Y la portada (home-page.component.ts):

export default class HomePageComponent {
  private productService = inject(ProductService)

  productsResource = rxResource({
    params: () => ({}),
    stream: () => this.productService.getProducts(),
  })
}

Cómo funciona por dentro

  • Las interfaces no existen en el navegador. TypeScript las borra al compilar; sólo sirven mientras escribes, para que el editor conozca los campos. ProductResponse es la respuesta completa (una página de resultados con su cuenta) y ProductElement es un producto. Los enum (Gender, Size, Tag) limitan un campo a un conjunto fijo de valores: un producto es de men, women, kid o unisex, nada más.
  • get<ProductResponse>(...) es una promesa al compilador, no una comprobación. Angular no revisa que la API devuelva esa forma; sólo le dice a TypeScript que la trate así. Si la API cambia, el error aparece al ejecutar, no al compilar.
  • provideHttpClient() es obligatorio. Sin él, inject(HttpClient) falla porque nadie lo proporcionó. Es lo primero que se olvida al crear un proyecto, y por eso el comentario del archivo lo recuerda.
  • inject() en vez del constructor es la forma actual de pedir una dependencia. providedIn: 'root' hace del servicio un único objeto para toda la app.
  • tap mira sin cambiar. Ejecuta una función con cada valor que pasa (aquí un console.log para ver la respuesta) y deja el valor igual. Es una herramienta para depurar mientras se construye.
  • rxResource pide los datos y los expone como señales. stream devuelve el Observable del servicio y el recurso ofrece value(), isLoading() y error() para la plantilla. params: () => ({}) es un objeto vacío: no depende de ninguna señal, así que pide los datos una sola vez al crear el componente. Cómo se piden con un parámetro que cambia, y todo lo que ofrece el recurso, está en el Módulo C19 de la Parte 4 (Country App).

Errores comunes

  • Olvidar provideHttpClient() en app.config.ts. La app arranca con un error de «no provider» para HttpClient.
  • Dejar la dirección de la API escrita en el servicio. Sirve en tu máquina, pero en otro entorno la dirección es otra. Lo habitual es guardarla en los archivos environment*.ts y leerla de ahí.
  • Creer que la interfaz valida la respuesta. Sólo describe lo que esperas; una API que cambia un campo rompe la pantalla sin aviso del compilador.
  • Dejar el tap con console.log al terminar. Es útil para ver la respuesta la primera vez; después se quita.

Resumen

  • Las interfaces y los enum describen la respuesta de la API para el editor.
  • El servicio concentra la petición; la portada la pide con rxResource.
  • provideHttpClient() va en app.config.ts, siempre.
  • tap sirve para mirar la respuesta mientras se construye.

Preguntas de entrevista

1. ¿Para qué sirven las interfaces de la respuesta si TypeScript las borra al compilar?

Respuesta:

Sirven mientras desarrollas: el editor completa los campos, avisa si escribes uno que no existe y obliga a tratar los casos que el tipo permite. En el navegador no existen y no validan nada; si la API devuelve otra forma, el error aparece al ejecutar.

2. ¿Qué pasa si falta provideHttpClient()?

Respuesta:

Angular no sabe crear HttpClient, y inject(HttpClient) en el servicio falla con un error de proveedor que no se encuentra. Se corrige agregándolo a los providers de app.config.ts.

3. ¿Qué hace tap en un Observable y por qué no cambia el resultado?

Respuesta:

tap ejecuta un efecto por cada valor que pasa por el flujo (por ejemplo, escribir en la consola) y devuelve el mismo valor sin tocarlo. Por eso se usa para depurar sin alterar lo que recibe quien se suscribe.

4. ¿Por qué la portada usa rxResource en vez de suscribirse al Observable?

Respuesta:

rxResource convierte el resultado en señales (value, isLoading, error) que la plantilla lee directamente, y se encarga de cancelar la petición anterior y de limpiar la suscripción cuando el componente se destruye. Con subscribe a mano habría que guardar el resultado, manejar la carga y acordarse de cancelar.