tRPC End-to-End Type Safe APIs · 课时

在 tRPC 过程中集成 Zod

直接将 Zod 模式应用于 tRPC 查询和变更的输入，实现自动验证。

在 tRPC 过程中集成 Zod 是 CoddyKit 上的免费 tRPC End-to-End Type Safe APIs 课时。这是第 3 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 tRPC End-to-End Type Safe APIs 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 tRPC End-to-End Type Safe APIs 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

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_REQUEST error response to the client, including details about why the validation failed.
This means you don't need to write manual try/catch blocks 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!

常见问题解答

「在 tRPC 过程中集成 Zod」课时是免费的吗？

是的 — 「在 tRPC 过程中集成 Zod」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 tRPC End-to-End Type Safe APIs 课程的其余内容，请升级到 CoddyKit PRO。 tRPC End-to-End Type Safe APIs 课程共包含 4 节课。

「在 tRPC 过程中集成 Zod」这节课中我会学到什么？

直接将 Zod 模式应用于 tRPC 查询和变更的输入，实现自动验证。你通过在浏览器中直接运行的动手代码来练习 tRPC End-to-End Type Safe APIs，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 tRPC End-to-End Type Safe APIs 需要有经验吗？

无需任何先前经验。CoddyKit 上的 tRPC End-to-End Type Safe APIs 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 4 节。

「在 tRPC 过程中集成 Zod」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 tRPC End-to-End Type Safe APIs 课中编写并运行代码吗？

能。每节 tRPC End-to-End Type Safe APIs 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 tRPC End-to-End Type Safe APIs