0Pricing
tRPC End-to-End Type Safe APIs · 강의

쿼리 절차 구현

입력 및 출력 형식과 함께 tRPC 쿼리 절차를 사용하여 읽기 전용 데이터 조회 엔드포인트를 만듭니다.

쿼리 절차 구현은(는) CoddyKit의 무료 tRPC End-to-End Type Safe APIs 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 tRPC End-to-End Type Safe APIs 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. tRPC End-to-End Type Safe APIs 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

What are tRPC Queries?

Queries are like asking a question to your server. They are designed for fetching data, not changing it. Think of them as the "GET" requests in a traditional REST API.

  • Read-only: Queries should never change data on your server.
  • Idempotent: Running a query multiple times should produce the same result.
  • Cached: Clients can often cache query results for better performance.

They are the foundation for retrieving information in your tRPC application.

Defining a Simple Query

In tRPC, you define queries within a router using .query(). Let's look at the basic structure.

First, you need to initialize tRPC (usually done once in your server setup):

const t = initTRPC.create();

Then, define your router and add a query:

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

// 1. Initialize tRPC
const t = initTRPC.create();

// 2. Create a router
const appRouter = t.router({
  // 3. Define a query named 'hello'
  hello: t.procedure.query(() => {
    return 'Hello from tRPC!';
  }),
});
// This snippet shows the core definition.
// A full server setup is needed to run it.

Your First Runnable Query (Server)

Let's put it all together into a minimal, runnable tRPC server. This server will host our hello query.

Save this as server.ts and run with ts-node server.ts (after npm install @trpc/server @trpc/server-adapters ts-node typescript).

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

const t = initTRPC.create();

const appRouter = t.router({
  hello: t.procedure.query(() => {
    console.log('Hello query called on server!');
    return 'Hello from tRPC!';
  }),
});

export type AppRouter = typeof appRouter;

const server = createHTTPServer({
  router: appRouter,
});

server.listen(2025);
console.log('tRPC server listening on http://localhost:2025');

Calling a Query from the Client

Now that our server is running, let's call the hello query from a client application. We'll use @trpc/client to create a proxy that mirrors our server's API.

Save this as client.ts. You'll need the server.ts running first.

import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';

// Simplified AppRouter type for this example
type AppRouter = {
  hello: {
    _def: {
      _input_in: undefined;
      _input_out: undefined;
      _output_in: string;
      _output_out: string;
    };
  };
};

const trpc = createTRPCProxyClient<AppRouter>({
  links: [
    httpBatchLink({
      url: 'http://localhost:2025',
    }),
  ],
});

async function callHello() {
  try {
    const greeting = await trpc.hello.query();
    console.log(greeting); // Expected: Hello from tRPC!
  } catch (error) {
    console.error('Error calling hello query:', error);
  }
}

callHello();

Passing Data to Queries

Often, you need to send data to your queries, for example, to fetch a specific user by ID. tRPC handles this beautifully with input schemas.

You define the expected input using a validation library like Zod. This ensures your input is always type-safe and valid, both on the client and server.

  • Use .input() after t.procedure.
  • Provide a Zod schema to define the shape of your input.
  • The input will be available in the input property of the resolve function's arguments.

Querying with an ID (Server)

Let's modify our server to fetch a "user" by their ID. We'll use Zod to validate that the input is a number.

Update your server.ts with this new procedure:

import { initTRPC } from '@trpc/server';
import { createHTTPServer } from '@trpc/server/adapters/standalone';
import { z } from 'zod'; // Import Zod

const t = initTRPC.create();

const appRouter = t.router({
  getUserById: t.procedure
    .input(z.object({ id: z.number() })) // Define input schema
    .query(({ input }) => { // Access input here
      console.log(`Fetching user with ID: ${input.id}`);
      // In a real app, you'd fetch from a database
      const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
      return users.find(user => user.id === input.id) || null;
    }),
});

export type AppRouter = typeof appRouter;

const server = createHTTPServer({
  router: appRouter,
});

server.listen(2025);
console.log('tRPC server listening on http://localhost:2025');

Calling Query with Input (Client)

Now, from the client, we can call our getUserById query and pass the required id. tRPC will ensure the input matches the Zod schema defined on the server, giving you type safety from end-to-end.

Update your client.ts to call this new query:

import { createTRPCProxyClient, httpBatchLink } from '@trpc/client';

// Simplified AppRouter for example
type AppRouter = {
  getUserById: {
    _def: {
      _input_in: { id: number };
      _input_out: { id: number };
      _output_in: { id: number; name: string } | null;
      _output_out: { id: number; name: string } | null;
    };
  };
};

const trpc = createTRPCProxyClient<AppRouter>({
  links: [
    httpBatchLink({
      url: 'http://localhost:2025',
    }),
  ],
});

async function callGetUser() {
  try {
    const user1 = await trpc.getUserById.query({ id: 1 });
    console.log('User 1:', user1); // Expected: User 1: { id: 1, name: 'Alice' }

    const user3 = await trpc.getUserById.query({ id: 3 });
    console.log('User 3:', user3); // Expected: User 3: null
  } catch (error) {
    console.error('Error calling getUserById query:', error);
  }
}

callGetUser();

Type Safety in Query Outputs

One of tRPC's biggest advantages is its end-to-end type safety. When you define a query, tRPC automatically infers the output type based on what your resolve function returns.

  • No need to manually define response interfaces.
  • If your server's return type changes, your client code will automatically show a TypeScript error.
  • This catches bugs early, before runtime!

For our getUserById query, tRPC correctly infers the return type as { id: number; name: string } | null.

Query Best Practices

As you build more queries, keep these tips in mind:

  • Keep it Read-Only: Never perform side effects (like database writes) in a query.
  • Clear Naming: Name your queries descriptively (e.g., getUserById, listPosts).
  • Granular Inputs: Use specific Zod schemas for inputs to ensure strict validation.
  • Error Handling: While tRPC propagates errors, consider specific error types for better client feedback (more on this in a later lesson!).

Queries are fundamental for fetching data. Next, we'll look at Mutations for changing data.

Query Procedure Check

You've learned how to define and use tRPC query procedures. Let's test your understanding.

Recap: Query Procedures

Great job! In this lesson, you learned about tRPC Query procedures.

  • Queries are for fetching read-only data from your server.
  • You define them using t.procedure.query(...) within your router.
  • You can add input validation using .input(z.object(...)) with Zod.
  • tRPC provides end-to-end type safety by inferring output types automatically.

You now have the tools to build powerful, type-safe data fetching endpoints! Next, we'll explore Mutations for data manipulation.

자주 묻는 질문

“쿼리 절차 구현” 강의는 무료인가요?

네 — “쿼리 절차 구현” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 tRPC End-to-End Type Safe APIs 강의 전체를 잠금 해제할 수 있습니다. tRPC End-to-End Type Safe APIs 강의에는 총 4개의 강의가 포함되어 있습니다.

“쿼리 절차 구현”에서 뭘 배우나요?

입력 및 출력 형식과 함께 tRPC 쿼리 절차를 사용하여 읽기 전용 데이터 조회 엔드포인트를 만듭니다. 브라우저에서 직접 실행하는 실습 코드로 tRPC End-to-End Type Safe APIs을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

tRPC End-to-End Type Safe APIs을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 tRPC End-to-End Type Safe APIs은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“쿼리 절차 구현” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 tRPC End-to-End Type Safe APIs 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 tRPC End-to-End Type Safe APIs 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. tRPC 라우터로 구조화하기
  2. 쿼리 절차 구현
  3. 변형 절차 개발
  4. 라우터 병합과 중첩
← tRPC End-to-End Type Safe APIs(으)로 돌아가기