0Pricing
tRPC End-to-End Type Safe APIs · บทเรียน

การขยายความสามารถของ tRPC

ค้นพบวิธีขั้นสูงในการขยาย tRPC ด้วยตัวสร้างแบบกำหนดเอง ปลั๊กอิน และการผสานรวมกับไลบรารีอื่น

การขยายความสามารถของ tRPC เป็นบทเรียน tRPC End-to-End Type Safe APIs ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน tRPC End-to-End Type Safe APIs และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส tRPC End-to-End Type Safe APIs มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Extend tRPC's Core

tRPC is incredibly powerful out-of-the-box, but sometimes your application needs more custom control and specialized behavior. This lesson will show you how to extend tRPC beyond basic middleware.

We'll explore custom procedure builders for creating specialized API endpoints and discuss how to integrate tRPC seamlessly with other libraries like ORMs.

Why Custom Builders?

Standard middleware is great for applying common logic to all or a group of procedures, such as authentication or logging.

But what if you need to define specific types of procedures, like adminProcedure or publicProcedure, each with unique context properties or pre-configured middleware chains? Custom procedure builders are perfect for this!

Crafting a Builder with `createBuilder`

tRPC provides the createBuilder utility to help you define your own procedure factory. This builder can extend the context (ctx), add metadata, or apply middleware automatically to any procedure built with it.

It allows you to abstract common setup logic into a reusable pattern, making your API definitions cleaner and more consistent.

Builder Example: Admin Procedure

Let's create an adminProcedure. This builder ensures the user is not only logged in (via protectedProcedure) but also has an isAdmin flag set in their context. This logic is then automatically applied to any procedure using adminProcedure.

// Minimal tRPC-like setup for demonstration
type Context = { user?: { id: number; isAdmin?: boolean } };

const mockProcedure = {
  use: (middleware: any) => ({
    use: (nextMiddleware: any) => ({
      _isBuilder: true,
      _middlewares: [middleware, nextMiddleware]
    }),
    _isBuilder: true,
    _middlewares: [middleware]
  }),
  _isBuilder: true,
  _middlewares: []
};

const t = {
  procedure: mockProcedure
};

// --- Actual tRPC Builder Code ---
const protectedProcedure = t.procedure.use(async ({ ctx, next }: any) => {
  if (!ctx.user) {
    throw new Error('Not authenticated');
  }
  return next({ ctx: { ...ctx, user: ctx.user } });
});

const adminProcedure = protectedProcedure.use(async ({ ctx, next }: any) => {
  if (!ctx.user?.isAdmin) {
    throw new Error('Not an admin!');
  }
  return next({ ctx: { ...ctx, user: ctx.user } });
});

console.log("Protected procedure builder defined.");
console.log("Admin procedure builder defined.");
console.log("Admin procedure has " + adminProcedure._middlewares.length + " middlewares.");

Benefits of Custom Builders

Custom builders offer several significant advantages:

  • Reusability: Define complex logic once and apply it across many procedures.
  • Type Safety: Enforce specific context types for groups of procedures.
  • Readability: Procedures become self-documenting (e.g., adminProcedure.query(...) clearly indicates its requirements).
  • Consistency: Ensure all procedures of a certain type adhere to specific rules and checks.

Integration with External Libraries

tRPC is unopinionated about your data layer. This means you can easily integrate it with any ORM (like Prisma, Drizzle), database client, or external API service you prefer.

The key to this seamless integration is often to initialize instances of these clients and attach them to your tRPC context. This makes them readily available to all your procedures.

Contextualizing an ORM (Prisma)

A very common pattern in tRPC applications is to initialize your ORM client (e.g., Prisma Client) and then attach that instance to your tRPC context object.

This allows all your tRPC procedures to access the database client via ctx.prisma, centralizing its management and providing type safety.

// Minimal tRPC-like setup for demonstration
type MockPrismaClient = {
  user: {
    findUnique: (args: { where: { id: number } }) => { id: number; name: string } | null;
  };
};

type ContextWithPrisma = {
  prisma: MockPrismaClient;
};

const mockProcedure = {
  query: (handler: (opts: { ctx: ContextWithPrisma }) => any) => ({
    _handler: handler,
    _isQuery: true
  })
};

const t = {
  procedure: mockProcedure
};

// --- Actual tRPC Context Integration ---
const publicProcedure = t.procedure;

const getUserProcedure = publicProcedure.query(async ({ ctx }) => {
  const user = await ctx.prisma.user.findUnique({ where: { id: 1 } });
  return user ? `User name: ${user.name}` : 'User not found.';
});

// --- Demonstration (conceptual execution) ---
const mockPrisma: MockPrismaClient = {
  user: {
    findUnique: (args) => {
      if (args.where.id === 1) {
        return { id: 1, name: 'Alice' };
      }
      return null;
    }
  }
};

const mockContext: ContextWithPrisma = { prisma: mockPrisma };

console.log("Prisma client attached to context type.");
console.log("Conceptual handler output for user 1:");
console.log(await getUserProcedure._handler({ ctx: mockContext }));

The Power of Plugins (Conceptual)

Beyond builders, tRPC offers an experimental createTRPCPlugin API. Plugins provide even deeper hooks into tRPC's internals, allowing you to customize error formatting, add custom data transformers, or modify the request lifecycle in advanced ways.

They are designed for truly complex, core-level extensions that affect how tRPC operates at a foundational level.

When to Use What?

Choosing between custom builders and plugins depends on your extension needs:

  • Custom Builders: Best for defining specific types of procedures, enriching the context object, or applying common middleware chains. They operate at the procedure definition level.
  • Plugins: Ideal for modifying tRPC's core behavior, such as custom error handling, data serialization/deserialization, or integrating with external systems at a global, foundational level.

Quick Check

Which of the following are key benefits of using custom tRPC procedure builders?

Summary of Extensions

In this lesson, we explored how to extend tRPC's capabilities. We learned to use custom procedure builders to create specialized, reusable procedures like adminProcedure, enhancing reusability, type safety, and consistency.

We also saw how to integrate external libraries like ORMs by attaching them to the tRPC context. Finally, we touched upon the advanced potential of tRPC plugins for deeper core modifications. These tools empower you to tailor tRPC to your application's unique needs.

คำถามที่พบบ่อย

บทเรียน “การขยายความสามารถของ tRPC” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การขยายความสามารถของ tRPC” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส tRPC End-to-End Type Safe APIs ให้อัปเกรดเป็น CoddyKit PRO คอร์ส tRPC End-to-End Type Safe APIs มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การขยายความสามารถของ tRPC”

ค้นพบวิธีขั้นสูงในการขยาย tRPC ด้วยตัวสร้างแบบกำหนดเอง ปลั๊กอิน และการผสานรวมกับไลบรารีอื่น คุณปฏิบัติ tRPC End-to-End Type Safe APIs ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน tRPC End-to-End Type Safe APIs หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน tRPC End-to-End Type Safe APIs บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การขยายความสามารถของ tRPC” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน tRPC End-to-End Type Safe APIs นี้ได้ไหม

ได้ บทเรียน tRPC End-to-End Type Safe APIs ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การตั้งค่าโมโนรีโป tRPC
  2. การแบ่งปันโค้ดและการนำกลับมาใช้ใหม่
  3. การขยายความสามารถของ tRPC
  4. การกำหนดเวอร์ชันและเผยแพร่แพ็กเกจ tRPC ที่ใช้ร่วมกัน
← กลับไปที่ tRPC End-to-End Type Safe APIs