tRPC End-to-End Type Safe APIs · Lekcja

Implementacja procedur zapytań

Utworzą Państwo endpointy tylko do odczytu za pomocą procedur zapytań tRPC z typami wejściowymi i wyjściowymi.

Lekcja 2 z 411 kroki

Implementacja procedur zapytań to bezpłatna lekcja tRPC End-to-End Type Safe APIs na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej tRPC End-to-End Type Safe APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs tRPC End-to-End Type Safe APIs zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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.

Odpowiedz w interaktywnej lekcji

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.

Bezpłatny start

Ucz się tRPC End-to-End Type Safe APIs dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 10
Lekcje: 40

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Implementacja procedur zapytań” jest bezpłatna?

Tak — pełny tekst „Implementacja procedur zapytań” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu tRPC End-to-End Type Safe APIs, przejdź na CoddyKit PRO. Kurs tRPC End-to-End Type Safe APIs zawiera 4 lekcji w sumie.

Co nauczysz się w „Implementacja procedur zapytań”?

Utworzą Państwo endpointy tylko do odczytu za pomocą procedur zapytań tRPC z typami wejściowymi i wyjściowymi. Ćwiczysz tRPC End-to-End Type Safe APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć tRPC End-to-End Type Safe APIs?

Nie wymagamy żadnego doświadczenia. tRPC End-to-End Type Safe APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Implementacja procedur zapytań”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji tRPC End-to-End Type Safe APIs?

Tak. Każda lekcja tRPC End-to-End Type Safe APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do tRPC End-to-End Type Safe APIs