Integrare Zod nelle procedure tRPC
Applichi direttamente gli schemi Zod agli input delle query e delle mutation tRPC per ottenere la validazione automatica.
Integrare Zod nelle procedure tRPC è una lezione tRPC End-to-End Type Safe APIs gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento tRPC End-to-End Type Safe APIs, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso tRPC End-to-End Type Safe APIs include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Zod for tRPC Inputs
Welcome! In this lesson, we'll learn how to integrate Zod schemas directly into your tRPC procedures. This powerful combination ensures your API inputs are always valid and type-safe from end-to-end.
You'll see how to apply Zod for both query and mutation procedures, making your backend more robust and developer-friendly.
Why Validate Inputs?
Input validation is a critical part of building secure and reliable APIs. It's like a quality check at the entrance of your backend.
- Security: Prevents malicious or malformed data from reaching your server logic.
- Data Integrity: Ensures your database only stores valid and expected data formats.
- Predictability: Your backend logic can trust the shape of incoming data, reducing runtime errors.
- Better DX: Developers get immediate feedback on incorrect inputs.
The `.input()` Method
tRPC makes integrating Zod incredibly simple. Each tRPC procedure (query, mutation, or subscription) has an .input() method.
This method accepts a Zod schema, which tRPC then uses to automatically validate any incoming data for that procedure. If the input doesn't match the schema, tRPC handles the error for you!
Query Input Validation
For queries, you often expect parameters like an ID or a search term. Zod helps ensure these inputs are of the correct type and format.
Let's look at an example where we want to fetch a user by their unique ID. We'll use Zod to ensure the userId is a valid UUID string.
Query Procedure Example
Here's how you define a tRPC query procedure that uses a Zod schema to validate its input:
import { initTRPC } from '@trpc/server';
import { z } from 'zod';
// Minimal tRPC context setup
const t = initTRPC.create();
// Define a query procedure with Zod input validation
const getUserById = t.procedure
.input(z.object({
userId: z.string().uuid("Invalid user ID format"),
}))
.query(({ input }) => {
// In a real app, this would fetch from a database
console.log(`Fetching user: ${input.userId}`);
return { id: input.userId, name: "Alice" }; // Mock data
});
// To use this, you'd add it to a tRPC router, e.g.:
// export const appRouter = t.router({ getUserById });Mutation Input Validation
Mutations often involve creating or updating data, which means they typically accept more complex input objects. Zod is perfect for validating these structures.
Consider a scenario where you want to create a new blog post. We'll validate its title and optional content to ensure they meet certain criteria.
Mutation Procedure Example
Here's a mutation procedure that validates input for creating a new post using a Zod object schema:
import { initTRPC } from '@trpc/server';
import { z } from 'zod';
// Minimal tRPC context setup
const t = initTRPC.create();
// Define a mutation procedure with Zod input validation
const createPost = t.procedure
.input(z.object({
title: z.string().min(5, "Title must be at least 5 characters"),
content: z.string().optional(),
authorId: z.string().uuid("Invalid author ID"),
}))
.mutation(({ input }) => {
// This would typically save data to a database
console.log(`Creating post: "${input.title}" by ${input.authorId}`);
return { id: "new-post-uuid", ...input, createdAt: new Date() }; // Mock
});
// To use this, you'd add it to a tRPC router, e.g.:
// export const appRouter = t.router({ createPost });Automatic Validation Errors
One of the biggest advantages of integrating Zod directly with tRPC is automatic error handling.
- If a client sends input that doesn't match your Zod schema, tRPC will automatically catch the validation error.
- It then sends a standardized
BAD_REQUESTerror response to the client, including details about why the validation failed. - This means you don't need to write manual
try/catchblocks for basic input validation!
Benefits of Direct Integration
Combining Zod with tRPC's .input() method provides several powerful benefits:
- End-to-End Type Safety: Your Zod schema defines the exact input type, which tRPC automatically infers and shares with your client.
- Single Source of Truth: Define validation rules once, and they apply on both the server (runtime) and client (compile-time).
- Reduced Boilerplate: No need for manual validation checks or separate DTOs (Data Transfer Objects).
- Clear API Contracts: Your procedures clearly state their input requirements through their Zod schemas.
Quick Check: Zod in tRPC
You've learned how Zod schemas are integrated into tRPC procedures. Let's test your understanding!
Recap: Zod & tRPC Synergy
Great job! You've successfully learned how to integrate Zod schemas into your tRPC procedures.
- We saw that the
.input()method is key for applying Zod schemas to both queries and mutations. - This integration provides automatic validation, end-to-end type safety, and clear API contracts.
- By leveraging Zod within tRPC, you build more robust, secure, and developer-friendly APIs with less effort.
Next up, we'll explore more advanced Zod schemas!
Impara tRPC End-to-End Type Safe APIs con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 10
- Lezioni
- 40
Domande Frequenti
La lezione «Integrare Zod nelle procedure tRPC» è gratuita?
Sì — il testo completo di «Integrare Zod nelle procedure tRPC» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso tRPC End-to-End Type Safe APIs, passa a CoddyKit PRO. Il corso tRPC End-to-End Type Safe APIs include 4 lezioni in totale.
Cosa imparerò in «Integrare Zod nelle procedure tRPC»?
Applichi direttamente gli schemi Zod agli input delle query e delle mutation tRPC per ottenere la validazione automatica. Eserciti tRPC End-to-End Type Safe APIs con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare tRPC End-to-End Type Safe APIs?
Non è richiesta alcuna esperienza precedente. tRPC End-to-End Type Safe APIs su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Integrare Zod nelle procedure tRPC»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione tRPC End-to-End Type Safe APIs?
Sì. Ogni lezione tRPC End-to-End Type Safe APIs include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Introduzione agli schemi Zod
- Definire schemi Zod complessi
- Integrare Zod nelle procedure tRPC
- Trasformare e perfezionare i dati con Zod