Jak na ověření vstupu pomocí Zod v GraphQL?

V pohodě, Zod se na ověřování vstupu v GraphQL hodí skvěle. Můžeš ho použít hned v resolveru, kde přijímáš data. Nejlepší je mít validaci hned na začátku, takže jakmile dostaneš input, tak ho protáhneš Zod schématem. Pokud validace selže, můžeš hodit chybu a tím zabránit dalšímu zpracování.

Příklad: máš třeba input pro uživatelský profil s jménem a věkem. Vytvoříš si Zod schéma pro tento input a pak to prostě zavoláš v resolveru:

const UserInputSchema = z.object({ name: z.string().min(1), age: z.number().min(0), });

async function updateUser(_, { input }) { const validatedInput = UserInputSchema.parse(input); // Tady už můžeš pracovat s validatedInput }

Můžeš mít i složitější validace nebo více typů dat – Zod to zvládne. Klidně si udělej víc schémat pro různé vstupy a pak je podle potřeby kombinuj.

Co se týče asynchronních operací, tak Zod má i metody na async validaci, pokud potřebuješ ověřovat něco, co závisí na databázi nebo podobně.

Umístění validátoru v resolveru je fakt ok, ale můžeš si taky udělat nějakou middleware funkci, která to všechno zabalí a udržuje kód čistý. Takže když děláš víc resolverů, nebudeš muset psát validaci znova a znova.

Pokud chceš používat Zod pro validaci vstupů v GraphQL, tak je to celkem jednoduchý proces. Můžeš si vytvořit Zod schema pro každý typ vstupu, který máš v API. Například, pokud máš mutation pro přidání uživatele, vytvoř si Zod schema, který definuje jaké pole očekáváš a jaké mají mít typy. Pak můžeš to schema použít přímo v resolveru předtím, než se data dostanou dál do databáze nebo logiky.

Příklad:

 import \{ z \} from 'zod';

const userInputSchema = z.object(\{
  name: z.string(),
  email: z.string().email(),
  age: z.number().int().positive(),
\});

const resolvers = \{
  Mutation: \{
    addUser: async (_, args) =\> \{
      const parsedInput = userInputSchema.parse(args.input);
      // teď můžeš použít parsedInput pro další operace
    \},
  \},
\};

Pokud potřebuješ validovat víc typů dat najednou, můžeš si udělat víc schémat a kombinovat je pomocí z.union() nebo z.intersection(). Co se týče asynchronních operací, Zod s tím umí pracovat, takže můžeš validaci provádět před každým asynchronním krokem.

A co se týče umístění validátoru, ideálně ho dej do resolveru. Tak budeš mít všechno hezky pohromadě a odladíš případné chyby hned při zavolání mutation. To ti pomůže udržet API čisté a uživatelsky přívětivé.

Pokud chceš ověřovat vstupy ve svém GraphQL API s Zod, tak to můžeš udělat docela jednoduše. Nejlepší je mít validaci přímo v resolvers, protože tam už máš přístup k datům, která chceš ověřit. Vytvoříš si schéma pomocí Zod, kde definuješ očekávané typy a validace. Třeba takhle:

 import \{ z \} from 'zod';

const UserInputSchema = z.object(\{
  name: z.string().min(1),
  email: z.string().email(),
\});

Pak v resolveru použiješ UserInputSchema.parse(input), což vyhodí chybu, pokud vstup neodpovídá schématu. Můžeš to pak zachytit a vrátit uživateli relevantní chybu.

Pokud potřebuješ validovat víc typů dat najednou, můžeš udělat další schémata nebo použít z.union() pro kombinaci. Co se týká asynchronních operací, Zod je synchronní, takže pokud potřebuješ provádět nějakou asynchronní validaci (např. kontrola unikátnosti v DB), budeš muset použít vlastní logiku nebo promisy vedle toho.

Jo a nezapomeň na error handling. Když Zod vyhodí chybu, tak ji musíš správně zpracovat a poslat klientovi srozumitelnou odpověď. S tímhle přístupem bys měl mít celkem čistý a efektivní způsob validace vstupů.