tRPC:n tyyppiturvalliset API:t päästä päähän · Oppitunti

Mukautetut middleware-ketjut

Rakentakaa mukautettua middlewarea lokitusta, nopeusrajoitusta tai valtuutusta varten ja ketjuttakaa ne yhteen.

Oppitunti 3/411 vaihetta

Mukautetut middleware-ketjut 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.

Useiden middlewarejen ketjuttaminen

tRPC:ssä middlewarellä voi suorittaa logiikkaa ennen proseduurin suorittamista. Entä jos yksittäiselle API-kutsulle tarvitaan useita tarkistuksia, kuten lokitus, todennus ja validointi?

Tässä middleware-ketjut ovat hyödyksi! Niiden avulla useita middleware-funktioita voidaan pinota ja suorittaa peräkkäin.

Ketjuttamisen hyödyt

Middlewaren ketjuttaminen tarjoaa useita etuja:

Modulaarisuus: Kukin middleware keskittyy yhteen vastuuseen, kuten lokitukseen tai todennukseen.
Uudelleenkäytettävyys: Luokaa yleiskäyttöisiä middlewarejä, joita voidaan soveltaa eri proseduureihin tai reitittimiin.
Suoritusjärjestys: Hallitkaa tarkasti toimintojen järjestystä ennen pääproseduurin logiikan suorittamista.
Varhainen poistuminen: Middleware voi pysäyttää ketjun aikaisin, jos ehto ei täyty, esimerkiksi luvattoman käytön tapauksessa.

Miten `next()` toimii

Muistattehan, että tRPC-middleware saa next-funktion. Kun next()-funktiota kutsutaan, ohjaus siirtyy ketjun seuraavalle middlewarelle tai viimeisen middlewaren tapauksessa varsinaiselle proseduurikäsittelijälle.

Jos middleware ei kutsu next()-funktiota, ketju pysähtyy eikä proseduurikäsittelijää suoriteta. Tämä on ratkaisevan tärkeää esimerkiksi todennustarkistuksissa!

Ensimmäinen: lokitusmiddleware

Luodaan yksinkertainen lokitusmiddleware. Se kirjaa lokiin, milloin pyyntö alkaa ja kuinka kauan sen käsittely kestää. Tämä on yleinen valvontakäytäntö.

Huomaattehan, että next()-funktion valmistumista odotetaan, jotta proseduurin ja sitä seuraavien middlewarejen suoritus ehtii päättyä ennen keston kirjaamista.

type Context = { userId: string | null };
const trpc = {
  middleware: (handler: any) => handler,
  procedure: {
    use: (mw: any) => ({
      query: (f: any) => f,
      mutation: (f: any) => f
    }),
    query: (f: any) => f,
    mutation: (f: any) => f
  },
  router: (cfg: any) => cfg,
};

const logMiddleware = trpc.middleware(async ({ path, type, next }) => {
  console.log(`[${type}] Request to ${path} started.`);
  const start = Date.now();
  const result = await next();
  const durationMs = Date.now() - start;
  console.log(`[${type}] Request to ${path} finished in ${durationMs}ms.`);
  return result;
});

const appRouter = trpc.router({
  example: trpc.procedure
    .use(logMiddleware)
    .query(() => "Data fetched!")
});

Toinen: todennusmiddleware

Seuraavaksi rakennetaan todennusmiddleware. Tämä middleware tarkistaa, onko käyttäjä kirjautunut sisään eli onko ctx.userId olemassa. Jos ei ole, se heittää virheen ja pysäyttää käytännössä proseduurin suorittamisen.

Muistakaa, että ctx- eli kontekstiobjekti välitetään middlewarelle, joten pyyntökohtaiset tiedot ovat sen käytettävissä.

type Context = { userId: string | null };
const trpc = {
  middleware: (handler: any) => handler,
  procedure: {
    use: (mw: any) => ({
      query: (f: any) => f,
      mutation: (f: any) => f
    }),
    query: (f: any) => f,
    mutation: (f: any) => f
  },
  router: (cfg: any) => cfg,
};

const isAuthenticated = trpc.middleware(async ({ ctx, next }) => {
  if (!ctx.userId) {
    throw new Error("UNAUTHORIZED: Please log in.");
  }
  return next();
});

const appRouter = trpc.router({
  protected: trpc.procedure
    .use(isAuthenticated)
    .query(({ ctx }) => `Welcome, user ${ctx.userId}!`)
});

Middleware-ketjun rakentaminen

Yhdistetään nyt logMiddleware- ja isAuthenticated-middlewaret. Järjestyksellä on väliä: ensin tehdään lokitus ja sen jälkeen todennus.

Käytämme yksinkertaisesti .use()-metodia useita kertoja. tRPC suorittaa middlewaret siinä järjestyksessä, jossa ne on määritelty.

type Context = { userId: string | null };
const trpc = {
  middleware: (handler: any) => handler,
  procedure: {
    use: (mw: any) => ({
      query: (f: any) => f,
      mutation: (f: any) => f
    }),
    query: (f: any) => f,
    mutation: (f: any) => f
  },
  router: (cfg: any) => cfg,
};

const logMiddleware = trpc.middleware(async ({ path, type, next }) => {
  console.log(`[${type}] Request to ${path} started.`);
  const start = Date.now();
  const result = await next();
  const durationMs = Date.now() - start;
  console.log(`[${type}] Request to ${path} finished in ${durationMs}ms.`);
  return result;
});

const isAuthenticated = trpc.middleware(async ({ ctx, next }) => {
  if (!ctx.userId) {
    throw new Error("UNAUTHORIZED: Please log in.");
  }
  return next();
});

const appRouter = trpc.router({
  protectedData: trpc.procedure
    .use(logMiddleware)
    .use(isAuthenticated)
    .query(({ ctx }) => `Secret data for ${ctx.userId}!`)
});

Suoritusjärjestys

Kun pyyntö saapuu protectedData-proseduuriin:

logMiddleware suoritetaan ensin.
Jos logMiddleware kutsuu next()-funktiota, suoritetaan isAuthenticated.
Jos isAuthenticated kutsuu next()-funktiota, varsinainen query-proseduurikäsittelijä suoritetaan.
Jos jokin middleware heittää virheen, kuten isAuthenticated, ketju pysähtyy välittömästi ja virhe palautetaan.

Dynaaminen middleware

Entä jos tarvitsette eri valtuutustasoja? Voitte luoda funktion, joka palauttaa middlewaren, jolloin määrityksiä voidaan muuttaa dynaamisesti.

Tätä mallia kutsutaan middleware-rakentajaksi, ja se on tehokas tapa luoda joustavia ja uudelleenkäytettäviä middlewarejä.

type Context = { userId: string | null; userRole: string | null };
const trpc = {
  middleware: (handler: any) => handler,
  procedure: {
    use: (mw: any) => ({
      query: (f: any) => f,
      mutation: (f: any) => f
    }),
    query: (f: any) => f,
    mutation: (f: any) => f
  },
  router: (cfg: any) => cfg,
};

const hasRole = (requiredRole: string) => {
  return trpc.middleware(async ({ ctx, next }) => {
    if (!ctx.userRole || ctx.userRole !== requiredRole) {
      throw new Error(`FORBIDDEN: ${requiredRole} role required.`);
    }
    return next();
  });
};

const appRouter = trpc.router({
  adminPanel: trpc.procedure
    .use(hasRole("admin"))
    .query(() => "Welcome, admin!")
});

Dynaamisten middlewarejen ketjuttaminen

Voitte yhdistää staattisia middlewarejä, kuten lokittimen, ja dynaamisia middleware-rakentajia, kuten roolien tarkistajaa, samaan ketjuun.

Näin API-päätepisteistä voidaan tehdä erittäin joustavia ja turvallisia, sillä tiettyä logiikkaa voidaan soveltaa määritysten tai suorituksenaikaisten arvojen perusteella.

type Context = { userId: string | null; userRole: string | null };
const trpc = {
  middleware: (handler: any) => handler,
  procedure: {
    use: (mw: any) => ({
      query: (f: any) => f,
      mutation: (f: any) => f
    }),
    query: (f: any) => f,
    mutation: (f: any) => f
  },
  router: (cfg: any) => cfg,
};

const logMiddleware = trpc.middleware(async ({ path, type, next }) => {
  console.log(`[${type}] Request to ${path} started.`);
  const start = Date.now();
  const result = await next();
  const durationMs = Date.now() - start;
  console.log(`[${type}] Request to ${path} finished in ${durationMs}ms.`);
  return result;
});

const hasRole = (requiredRole: string) => {
  return trpc.middleware(async ({ ctx, next }) => {
    if (!ctx.userRole || ctx.userRole !== requiredRole) {
      throw new Error(`FORBIDDEN: ${requiredRole} role required.`);
    }
    return next();
  });
};

const appRouter = trpc.router({
  adminReport: trpc.procedure
    .use(logMiddleware)
    .use(hasRole("admin"))
    .query(() => "Sensitive admin report data.")
});

Middleware-ketjun logiikka

Tarkastellaan seuraavaa tRPC-proseduurin määritelmää:

// Assume logMiddleware and authMiddleware are defined
// authMiddleware throws if ctx.userId is null
// logMiddleware always calls next()
const myProcedure = trpc.procedure
  .use(logMiddleware)
  .use(authMiddleware)
  .query(({ ctx }) => `Hello ${ctx.userId}`);

Jos pyyntö saapuu tilanteessa, jossa ctx.userId = null, mitä tapahtuu?

Vastaa interaktiivisessa oppitunnissa

Ketjujen kertaus

Hienoa työtä! Olette oppineet rakentamaan ja ketjuttamaan useita mukautettuja middlewarejä tRPC:ssä.

Middleware-ketjujen avulla voitte soveltaa useita logiikkakerroksia, kuten lokitusta, todennusta ja validointia, ennen proseduurin suorittamista.
.use()-metodilla lisätään middlewarejä, jotka suoritetaan määrittelyjärjestyksessä.
next()-funktio on keskeinen ketjun hallinnan siirtämisessä eteenpäin.
Middleware-rakentajilla voidaan luoda dynaamisia ja määritettäviä middlewarejä, mikä parantaa uudelleenkäytettävyyttä.

Tämä tehokas malli auttaa pitämään tRPC-API:n koodin selkeänä, modulaarisena ja vankkana!

Aloita maksutta

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

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Mukautetut middleware-ketjut” 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 “Mukautetut middleware-ketjut”. 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 ”Mukautetut middleware-ketjut”?

Rakentakaa mukautettua middlewarea lokitusta, nopeusrajoitusta tai valtuutusta varten ja ketjuttakaa ne yhteen. 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 ”Mukautetut middleware-ketjut”-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-kontekstin luominen
Todennusmiddleware
Mukautetut middleware-ketjut
Lokitus- ja suorituskyvyn mittausmiddleware

← Takaisin: tRPC:n tyyppiturvalliset API:t päästä päähän