0Pricing
TypeScript Academy · Lección

Definición de routers y procedimientos

Cree queries y mutaciones con validación de entradas.

Definición de routers y procedimientos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Inicialización de tRPC

Todo backend de tRPC comienza creando una instancia con initTRPC. Esta devuelve constructores para routers y procedimientos. Normalmente se crea una sola vez y se exportan las piezas necesarias.

import { initTRPC } from '@trpc/server';

const t = initTRPC.create();
export const router = t.router;
export const publicProcedure = t.procedure;

Un primer procedimiento

Un procedimiento es un único endpoint de API. El más sencillo es una consulta que devuelve un valor. publicProcedure.query define un endpoint de solo lectura sin entrada.

import { router, publicProcedure } from './trpc';

const appRouter = router({
  health: publicProcedure.query(() => 'ok'),
});

Validación de la entrada

Los procedimientos declaran su entrada mediante un validador, normalmente un esquema de zod. .input(schema) valida durante la ejecución y, a la vez, infiere el tipo de entrada para el resolver y el cliente.

import { z } from 'zod';

const greet = publicProcedure
  .input(z.object({ name: z.string() }))
  .query(({ input }) => 'Hello, ' + input.name);

Lectura de la entrada

Dentro del resolver, la entrada validada está disponible como input y tiene completamente tipada su forma, derivada del esquema. No es necesario hacer conversiones de tipo manuales; zod y tRPC infieren la estructura conjuntamente.

const byId = publicProcedure
  .input(z.object({ id: z.number() }))
  .query(({ input }) => {
    // input.id is number
    return { id: input.id, name: 'Alice' };
  });

Mutaciones

Utilice .mutation para las operaciones que modifican datos. La estructura es la misma que la de una consulta, pero indica una escritura, lo que afecta al almacenamiento en caché del cliente y al método HTTP.

const createUser = publicProcedure
  .input(z.object({ name: z.string() }))
  .mutation(({ input }) => {
    return { id: 1, name: input.name };
  });

Creación del App Router

Reúna los procedimientos en un router pasando un objeto a router(...). Cada clave se convierte en el nombre de un procedimiento invocable. Este appRouter constituye toda la API.

const appRouter = router({
  greet,
  byId,
  createUser,
});

Routers anidados

Los routers se pueden anidar para organizar API grandes. Un valor del objeto del router puede ser a su vez otro router, lo que produce llamadas con espacio de nombres como user.byId.

const userRouter = router({ byId, createUser });

const appRouter = router({
  user: userRouter,
  greet,
});
// call paths: user.byId, user.createUser, greet

Exportación del tipo del router

La exportación más importante es el tipo del router. El cliente lo importará para obtener una seguridad de tipos completa. Exporte el valor para el adaptador del servidor y el tipo para el cliente.

export const appRouter = router({ user: userRouter });
export type AppRouter = typeof appRouter;

Conexión de un adaptador

Para ofrecer el router mediante HTTP, conecte un adaptador. tRPC proporciona adaptadores para Node independiente, Express, Next.js, Fetch y otros entornos. El adaptador convierte las solicitudes entrantes en llamadas a procedimientos.

import { createHTTPServer } from '@trpc/server/adapters/standalone';

createHTTPServer({ router: appRouter }).listen(3000);

Organización de los archivos

Una estructura habitual incluye un archivo trpc.ts con initTRPC y los elementos router/publicProcedure exportados, routers de funcionalidades en sus propios archivos y un appRouter raíz que los combina. Mantener initTRPC en un único lugar evita crear varias instancias.

// trpc.ts: initTRPC.create(), export router + publicProcedure
// routers/user.ts: userRouter
// router.ts: appRouter = router({ user: userRouter })

Resumen de la inferencia de entradas

Como .input(schema) valida e infiere a la vez, se escribe el esquema una sola vez y se obtiene tanto una protección durante la ejecución como un tipo estático. El cliente verá exactamente la entrada que espera cada procedimiento, derivada de estos esquemas.

const search = publicProcedure
  .input(z.object({ q: z.string(), page: z.number().optional() }))
  .query(({ input }) => ({ q: input.q, page: input.page ?? 1 }));

Comprobación rápida

Compruebe su comprensión de los routers y los procedimientos.

Resumen

Ha creado un backend de tRPC.

  • initTRPC.create() proporciona constructores de router y procedure.
  • .input(schema) valida e infiere la entrada.
  • .query lee; .mutation escribe.
  • Combine los procedimientos en appRouter y exporte type AppRouter = typeof appRouter.

Siguiente: consumirlo con un cliente completamente tipado.

Preguntas frecuentes

¿La lección «Definición de routers y procedimientos» es gratis?

Sí — el texto completo de «Definición de routers y procedimientos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Definición de routers y procedimientos»?

Cree queries y mutaciones con validación de entradas. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Definición de routers y procedimientos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. La arquitectura de tRPC
  2. Definición de routers y procedimientos
  3. Inferencia de tipos entre cliente y servidor
  4. Middleware y contexto
← Volver a TypeScript Academy