Współdzielenie i ponowne wykorzystanie kodu
Poznają Państwo strategie maksymalizowania ponownego wykorzystania kodu między klientem a serwerem, szczególnie w przypadku typów i narzędzi.
Współdzielenie i ponowne wykorzystanie kodu 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.
Why Share Code?
In a tRPC monorepo, you often have multiple applications (client, server, admin panel) that need to interact with the same data structures or perform similar tasks.
Code sharing is a powerful technique that helps reduce duplication, ensure consistency, and improve the overall maintainability of your project.
Types Across Client & Server
One of tRPC's biggest advantages is end-to-end type safety. This means your frontend automatically knows the types of data your backend sends and receives.
This magic relies heavily on sharing TypeScript types and interfaces between your client and server applications.
Defining a Shared Type
Let's create a simple User interface in a dedicated packages/types directory. This package will be imported by both your server and client.
/* packages/types/src/user.ts */
export interface User {
id: string;
name: string;
email: string;
}Server-side Shared Types
Now, we can use this User type to define the expected output of a tRPC query on our backend. This ensures the data sent from the server strictly adheres to the User structure.
/* packages/server/src/router/user.ts */
import { publicProcedure, router } from '../trpc';
import { User } from '@my-monorepo/types'; // Import shared type
export const userRouter = router({
getUsers: publicProcedure
.query(async () => {
const users: User[] = [
{ id: '1', name: 'Alice', email: 'alice@example.com' },
{ id: '2', name: 'Bob', email: 'bob@example.com' },
];
return users; // tRPC infers return type as User[]
}),
});Client-side Shared Types
On the client, tRPC automatically infers the types for users based on the server's definition. While explicit import isn't always needed for inference, it improves clarity and allows you to use the type for local client-side state or props.
/* packages/client/src/components/UserList.tsx */
import { trpc } from '../utils/trpc';
import { User } from '@my-monorepo/types'; // Optional, but good practice
function UserList() {
const { data: users, isLoading } = trpc.user.getUsers.useQuery();
if (isLoading) return <div>Loading users...</div>;
return (
<div>
{users?.map((user: User) => ( // 'user' is typed as User
<p key={user.id}>{user.name} ({user.email})</p>
))}
</div>
);
}Sharing Utility Functions
Beyond types, many other pieces of code can be shared. This includes common utility functions, constants, validation schemas (like Zod schemas), or even shared UI components if you're using a component library.
Sharing these helps maintain a consistent user experience and reduces redundant code across your applications.
Creating a Utility Package
Let's create a simple utility function in a packages/utils directory that formats a full name. We'll also include a shared constant.
/* packages/utils/src/format.ts */
export function formatFullName(firstName: string, lastName: string): string {
return `${firstName} ${lastName}`;
}
export const APP_NAME = 'CoddyKit Learn'; // Example constantServer-side Utilities
You can import and use these shared utility functions directly in your tRPC backend procedures. This ensures consistent logic, regardless of whether it's triggered by an API call or internal server processes.
/* packages/server/src/router/profile.ts */
import { publicProcedure, router } from '../trpc';
import { formatFullName } from '@my-monorepo/utils'; // Import shared utility
import { z } from 'zod'; // Assuming Zod is configured
export const profileRouter = router({
getUserProfile: publicProcedure
.input(z.object({ firstName: z.string(), lastName: z.string() }))
.query(({ input }) => {
const fullName = formatFullName(input.firstName, input.lastName);
return { greeting: `Hello, ${fullName}!` };
}),
});Client-side Utilities
Similarly, your client-side application can import and use the exact same utility functions and constants. This guarantees that calculations or displayed text are consistent with the server's logic.
/* packages/client/src/components/Greeting.tsx */
import { formatFullName, APP_NAME } from '@my-monorepo/utils'; // Import shared utility
function Greeting() {
const firstName = "Jane";
const lastName = "Doe";
const formattedName = formatFullName(firstName, lastName);
return (
<div>
<h1>Welcome to {APP_NAME}!</h1>
<p>User: {formattedName}</p>
</div>
);
}Best Practices for Shared Code
- Granularity: Create small, focused shared packages (e.g.,
types,utils,ui). - Dependencies: Shared packages should have minimal external dependencies to avoid bloating other apps.
- Avoid Circular Deps: Be careful not to create circular dependencies between shared packages or between app and shared packages.
- Testing: Test shared code thoroughly, as changes can affect multiple applications.
Shared Code Benefits
Which of the following are primary benefits of sharing types and utility functions between client and server in a tRPC monorepo?
Recap: Sharing is Caring!
We explored how sharing types and utility functions in a tRPC monorepo is key to maximizing efficiency. This approach reduces duplication, enhances type safety, and improves overall maintainability across your client and server applications. By structuring your project carefully, you can build robust and consistent full-stack applications.
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
Często zadawane pytania
Czy lekcja „Współdzielenie i ponowne wykorzystanie kodu” jest bezpłatna?
Tak — pełny tekst „Współdzielenie i ponowne wykorzystanie kodu” 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 „Współdzielenie i ponowne wykorzystanie kodu”?
Poznają Państwo strategie maksymalizowania ponownego wykorzystania kodu między klientem a serwerem, szczególnie w przypadku typów i narzędzi. Ć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 „Współdzielenie i ponowne wykorzystanie kodu”?
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
- Konfiguracja monorepo tRPC
- Współdzielenie i ponowne wykorzystanie kodu
- Rozszerzanie funkcjonalności tRPC
- Wersjonowanie i publikowanie współdzielonych pakietów tRPC