tRPC:n toiminnallisuuden laajentaminen
Tutustukaa edistyneisiin tapoihin laajentaa tRPC:tä mukautetuilla rakentajilla, liitännäisillä ja integroinneilla muiden kirjastojen kanssa.
tRPC:n toiminnallisuuden laajentaminen on ilmainen tRPC:n tyyppiturvalliset API:t päästä päähän-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu tRPC:n tyyppiturvalliset API:t päästä päähän-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. tRPC:n tyyppiturvalliset API:t päästä päähän-kurssilla on yhteensä 4 oppituntia.
tRPC:n ytimen laajentaminen
tRPC on erittäin tehokas sellaisenaan, mutta joskus sovellus tarvitsee enemmän mukautettavuutta ja erikoistunutta toimintaa. Tässä oppitunnissa näytetään, kuinka tRPC:tä laajennetaan perusmiddlewarea pidemmälle.
Tutkimme mukautettuja proseduurirakentajia erikoistuneiden API-päätepisteiden luomiseen ja käsittelemme, kuinka tRPC integroidaan saumattomasti muiden kirjastojen, kuten ORM:ien, kanssa.
Miksi mukautettuja rakentajia?
Vakiomiddleware sopii erinomaisesti yhteisen logiikan, kuten todennuksen tai lokituksen, soveltamiseen kaikkiin proseduureihin tai niiden ryhmään.
Entä jos haluatte määritellä tietynlaisia proseduureja, kuten adminProcedure- tai publicProcedure-proseduureja, joilla kullakin on yksilölliset kontekstiominaisuudet tai valmiiksi määritetyt middleware-ketjut? Mukautetut proseduurirakentajat sopivat tähän täydellisesti!
Rakentajan luominen `createBuilder`-toiminnolla
tRPC tarjoaa createBuilder-aputoiminnon, jonka avulla voitte määritellä oman proseduuritehtaan. Tämä rakentaja voi laajentaa kontekstia (ctx), lisätä metatietoja tai ottaa middleware-toiminnon automaattisesti käyttöön kaikissa sillä rakennetuissa proseduureissa.
Sen avulla voitte abstrahoida yleisen alustamislogiikan uudelleenkäytettäväksi rakenteeksi, jolloin API-määrittelyistä tulee selkeämpiä ja yhdenmukaisempia.
Rakentajaesimerkki: admin-proseduuri
Luodaan adminProcedure. Tämä rakentaja varmistaa, että käyttäjä on kirjautunut sisään (protectedProcedure-proseduurin kautta) ja että hänen kontekstissaan on asetettu isAdmin-lippu. Logiikka otetaan sitten automaattisesti käyttöön kaikissa adminProcedure-proseduuria käyttävissä proseduureissa.
// 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.");Mukautettujen rakentajien hyödyt
Mukautetuilla rakentajilla on useita merkittäviä etuja:
- Uudelleenkäytettävyys: Määritelkää monimutkainen logiikka kerran ja käyttäkää sitä monissa proseduureissa.
- Tyyppiturvallisuus: Pakottakaa tietynlaiset kontekstityypit proseduuriryhmille.
- Luettavuus: Proseduureista tulee itseään dokumentoivia (esim.
adminProcedure.query(...)ilmaisee selkeästi vaatimuksensa). - Yhdenmukaisuus: Varmistakaa, että kaikki tietynlaiset proseduurit noudattavat tiettyjä sääntöjä ja tarkistuksia.
Integrointi ulkoisiin kirjastoihin
tRPC ei ota kantaa datakerrokseenne. Voitte siis integroida sen helposti mihin tahansa haluamaanne ORM:iin (kuten Prismaan tai Drizzleen), tietokanta-asiakasohjelmaan tai ulkoiseen API-palveluun.
Saumattoman integraation kannalta keskeistä on usein alustaa näiden asiakkaiden ilmentymät ja liittää ne tRPC-kontekstiin. Näin ne ovat helposti kaikkien proseduurien käytettävissä.
ORM:n kontekstualisointi (Prisma)
tRPC-sovelluksissa hyvin yleinen toimintamalli on alustaa ORM-asiakas (esim. Prisma Client) ja liittää kyseinen ilmentymä tRPC-kontekstiobjektiin.
Näin kaikki tRPC-proseduurit voivat käyttää tietokanta-asiakasta ctx.prisma-ominaisuuden kautta. Samalla sen hallinta keskitetään ja tyyppiturvallisuus säilyy.
// 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 }));Pluginien voima (käsitteellinen)
Rakentajien lisäksi tRPC tarjoaa kokeellisen createTRPCPlugin-API:n. Pluginien avulla tRPC:n sisäisiin toimintoihin saa vielä syvempiä kytkentäpisteitä, joiden avulla voi mukauttaa virheiden muotoilua, lisätä mukautettuja datamuuntajia tai muokata pyynnön elinkaarta edistyneillä tavoilla.
Ne on tarkoitettu todella monimutkaisiin ydintason laajennuksiin, jotka vaikuttavat tRPC:n toimintaan perustavanlaatuisella tasolla.
Milloin mitäkin kannattaa käyttää?
Valinta mukautettujen rakentajien ja pluginien välillä riippuu laajennustarpeistanne:
- Mukautetut rakentajat: Sopivat parhaiten tietynlaisten proseduurien määrittämiseen, kontekstiobjektin rikastamiseen tai yleisten middleware-ketjujen käyttöönottoon. Ne toimivat proseduurien määrittelytasolla.
- Pluginien: Sopivat tRPC:n ydintoiminnan muokkaamiseen, kuten mukautettuun virheenkäsittelyyn, datan serialisointiin ja deserialisointiin tai integrointiin ulkoisten järjestelmien kanssa globaalilla ja perustavanlaatuisella tasolla.
Pikatarkistus
Mitkä seuraavista ovat mukautettujen tRPC-proseduurirakentajien keskeisiä hyötyjä?
Laajennusten yhteenveto
Tässä oppitunnissa tutkimme, kuinka tRPC:n ominaisuuksia laajennetaan. Opimme käyttämään mukautettuja proseduurirakentajia erikoistuneiden ja uudelleenkäytettävien proseduurien, kuten adminProcedure-proseduurin, luomiseen sekä uudelleenkäytettävyyden, tyyppiturvallisuuden ja yhdenmukaisuuden parantamiseen.
Näimme myös, kuinka ulkoisia kirjastoja, kuten ORM:iä, integroidaan liittämällä ne tRPC-kontekstiin. Lopuksi tutustuimme lyhyesti tRPC-pluginien edistyneisiin mahdollisuuksiin ytimen syvällisemmässä muokkaamisessa. Näiden työkalujen avulla voitte mukauttaa tRPC:n sovelluksenne yksilöllisiin tarpeisiin.
Opi tRPC:n tyyppiturvalliset API:t päästä päähän tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 10
- Oppitunnit
- 40
Usein kysytyt kysymykset
Onko oppitunti ”tRPC:n toiminnallisuuden laajentaminen” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa tRPC:n tyyppiturvalliset API:t päästä päähän-oppimispolun 3 oppituntia, myös oppitunnin “tRPC:n toiminnallisuuden laajentaminen”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. tRPC:n tyyppiturvalliset API:t päästä päähän-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”tRPC:n toiminnallisuuden laajentaminen”?
Tutustukaa edistyneisiin tapoihin laajentaa tRPC:tä mukautetuilla rakentajilla, liitännäisillä ja integroinneilla muiden kirjastojen kanssa. Harjoittelet tRPC:n tyyppiturvalliset API:t päästä päähän-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni tRPC:n tyyppiturvalliset API:t päästä päähän-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin tRPC:n tyyppiturvalliset API:t päästä päähän-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.
Kuinka kauan ”tRPC:n toiminnallisuuden laajentaminen”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä tRPC:n tyyppiturvalliset API:t päästä päähän-oppitunnilla?
Kyllä. Jokainen tRPC:n tyyppiturvalliset API:t päästä päähän-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- tRPC-monorepon määrittäminen
- Koodin jakaminen ja uudelleenkäyttö
- tRPC:n toiminnallisuuden laajentaminen
- Jaettujen tRPC-pakettien versiointi ja julkaisu