Relaciones y joins con tipos
Modele relaciones para que los resultados de los joins tengan los tipos correctos.
Relaciones y joins con tipos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 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.
Relaciones con tipos y resultados anidados
Los esquemas reales tienen relaciones: un usuario tiene muchas publicaciones y una publicación pertenece a un usuario. Un ORM con tipado seguro permite declarar estas relaciones y después devuelve resultados anidados y con los tipos correctos a partir de consultas relacionales.
Declaración de relaciones
Junto a las tablas, defina un objeto de relaciones que describa cómo se conectan. Estos metadatos impulsan tanto la generación de SQL como el tipo de resultado.
import { relations } from "drizzle-orm";
export const usersRelations = relations(users, ({ many }) => ({
posts: many(posts),
}));
export const postsRelations = relations(posts, ({ one }) => ({
author: one(users, {
fields: [posts.authorId],
references: [users.id],
}),
}));Una consulta relacional
La API de consultas permite solicitar filas relacionadas mediante with. El resultado anida los datos relacionados bajo el nombre de la relación.
const result = await db.query.users.findMany({
with: { posts: true },
});
// result: (User & { posts: Post[] })[]one frente a many determina el tipo
Una relación many produce un array; una relación one produce un único objeto (o null). El tipo anidado coincide con la cardinalidad que ha declarado.
const r = await db.query.posts.findMany({
with: { author: true },
});
// r: (Post & { author: User })[] // author is a single objectSelección de columnas dentro de las relaciones
Puede restringir tanto las filas principales como las anidadas. El tipo de resultado se restringe de forma independiente en cada nivel.
const r = await db.query.users.findMany({
columns: { id: true, name: true },
with: {
posts: { columns: { title: true } },
},
});
// r: { id: number; name: string; posts: { title: string }[] }[]Uniones manuales con columnas con tipos
Las uniones de nivel inferior también conservan los tipos. El predicado de unión utiliza referencias de columnas con tipos y la selección determina la forma plana del resultado.
const rows = await db
.select({ author: users.name, title: posts.title })
.from(posts)
.innerJoin(users, eq(users.id, posts.authorId));
// rows: { author: string; title: string }[]left join introduce nulabilidad
Un LEFT JOIN puede producir filas ausentes en el lado derecho, por lo que las columnas unidas se vuelven anulables en el tipo de resultado. El ORM lo refleja automáticamente.
const rows = await db
.select({ name: users.name, title: posts.title })
.from(users)
.leftJoin(posts, eq(posts.authorId, users.id));
// rows: { name: string; title: string | null }[]Resultados anidados frente a planos
Las consultas relacionales (findMany + with) proporcionan objetos anidados; las uniones manuales proporcionan filas planas. Elija resultados anidados cuando quiera grafos de objetos y resultados planos cuando quiera proyecciones tabulares.
Cómo se asignan tipos al anidamiento
Los metadatos de las relaciones se leen en el nivel de tipos. El tipo de consulta interseca la fila base con un objeto cuyas claves son las relaciones solicitadas; cada una se asigna a un array o a un tipo individual según su cardinalidad.
type WithPosts = User & { posts: Post[] };
// "many" -> Post[], "one" -> User (or User | null for optional)Relaciones profundamente anidadas
Las relaciones se pueden combinar. Puede solicitar una relación de otra relación y el tipo se anida con la misma profundidad, todo de forma inferida.
await db.query.users.findMany({
with: { posts: { with: { comments: true } } },
});
// User & { posts: (Post & { comments: Comment[] })[] }Por qué es importante
Escribir manualmente los tipos de los resultados de uniones anidadas propicia errores y hace que se desincronicen del esquema. Derivarlos de las relaciones declaradas mantiene sincronizados el tipo del grafo de objetos y el SQL, de modo que cambiar el nombre de una relación provoca un error de compilación y no una sorpresa en producción.
Comprobación rápida
Compruebe su dominio de las relaciones y uniones con tipos.
Resumen
Ha declarado relaciones y después ha dejado que el ORM produzca resultados anidados con tipos: many proporciona arrays, one proporciona objetos individuales, las selecciones parciales restringen cada nivel, los LEFT JOIN introducen nulabilidad y las relaciones profundamente anidadas se pueden combinar. Los metadatos de las relaciones impulsan tanto el SQL como los tipos de resultado y los mantienen sincronizados.
Aprende TypeScript con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 101
- Lecciones
- 352
Preguntas frecuentes
¿La lección «Relaciones y joins con tipos» es gratis?
Sí — el texto completo de «Relaciones y joins con tipos» 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 «Relaciones y joins con tipos»?
Modele relaciones para que los resultados de los joins tengan los tipos correctos. 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 4 de 4.
¿Cuánto tiempo toma la lección «Relaciones y joins con tipos»?
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
- Mapeo de esquemas a tipos
- Construcción de queries segura
- Inferencia de estructuras de resultados de queries
- Relaciones y joins con tipos