Parse, don't validate, ou transformer l'inconnu en prouvé Parse, don't validate, or turning unknown into proven

Valider puis caster rouvre le trou. Parser le ferme en un seul geste.Validate then cast reopens the hole. Parsing shuts it in one move.

Le numéro précédent a posé le diagnostic : au bord, la donnée est unknown. Reste à la rendre typée honnêtement. Le réflexe courant — valider — vérifie un booléen, puis caste en as vers le type attendu. Deux gestes, deux trous : le check et le type dérivent (le guard menteur du 2.3), et le as est une promesse non vérifiée (4.3). Parser fait l'inverse : une fonction qui prend unknown et rend une valeur typée prouvée, ou échoue. La donnée n'est jamais castée — elle est transformée.The previous issue gave the diagnosis: at the edge, data is unknown. What remains is to make it honestly typed. The common reflex — validate — checks a boolean, then casts with as to the expected type. Two moves, two holes: the check and the type drift (the lying guard of 2.3), and the as is an unchecked promise (4.3). Parsing does the opposite: a function that takes unknown and returns a proven typed value, or fails. The data is never cast — it's transformed.

function isUser(x: unknown): boolean {        // valide : rend un boolean
  return typeof x === "object" && x !== null && "name" in x;
}

if (isUser(data)) {
  const user = data as User;   // ✗ on a vérifié 'name', on caste vers User ENTIER
  user.email.trim();           // 💥 email jamais vérifié — le 'as' a comblé l'écart
}

const User = z.object({ name: z.string(), email: z.string() });

const user = User.parse(data);   // ✓ valide ET produit un User — ou lève ICI, au bord
user.email.trim();               // user : z.infer<typeof User> — prouvé, zéro 'as'

Le schéma est le type. On l'écrit une fois ; z.infer en déduit le reste.The schema is the type. You write it once; z.infer deduces the rest.

La surprise pour qui découvre les schémas : on n'écrit pas le type d'un côté et le validateur de l'autre. On écrit le schéma, et le type en est dérivé par z.infer. Une seule source de vérité. Ajoute un champ au schéma, et le type statique comme le contrôle à l'exécution se mettent à jour ensemble — impossible de les désynchroniser. C'est le réflexe « calculer, pas recopier » du Vol 6, appliqué à l'endroit où il compte le plus : la frontière.The surprise for newcomers to schemas: you don't write the type on one side and the validator on the other. You write the schema, and the type is derived from it via z.infer. One source of truth. Add a field to the schema, and both the static type and the runtime check update together — impossible to desync. It's Vol 6's 'compute, don't copy' reflex, applied where it matters most: the boundary.

interface User { name: string; email: string; age: number }   // ← 1re vérité

function isUser(x: unknown): x is User {                       // ← 2e vérité, à la main
  return typeof x === "object" && x !== null
    && "name" in x && "email" in x;     // 'age' oublié — le guard ment (2.3), et dérive
}

Le type dit trois champs, le validateur n'en vérifie que deux : deux descriptions de la même chose, que rien n'oblige à concorder. C'est exactement le guard menteur du 2.3 et la dérive du 6.1 — rejouée à l'endroit le plus dangereux, l'entrée des données.The type says three fields, the validator checks only two: two descriptions of the same thing, nothing forcing them to agree. It's exactly the lying guard of 2.3 and the drift of 6.1 — replayed at the most dangerous spot, the data entry.

Un objet runtime qui sait vérifier — et dont z.infer tire le type.A runtime object that knows how to check — and from which z.infer draws the type.

Le schéma est une valeur, vivante à l'exécution, qui sait contrôler une donnée. .parse(x) lève si elle ne colle pas ; .safeParse(x) rend plutôt une union discriminée { success: true, data } | { success: false, error } — exactement le Vol 3, qu'on narrowe sur .success. Et z.infer<typeof S> extrait le type statique. Les schémas se composent : objets, tableaux, optionnels, enums. Ce qui en sort est un DTO : la donnée typée et prouvée à laquelle tout le reste du programme peut enfin se fier.The schema is a value, alive at runtime, that knows how to check data. .parse(x) throws if it doesn't fit; .safeParse(x) instead returns a discriminated union { success: true, data } | { success: false, error } — exactly Vol 3, narrowed on .success. And z.infer<typeof S> extracts the static type. Schemas compose: objects, arrays, optionals, enums. What comes out is a DTO: the typed, proven data the rest of the program can finally trust.

const result = User.safeParse(data);   // ne lève pas — rend une union discriminée

if (result.success) {
  result.data.email;       // ✓ result.data : User — prouvé (Vol 3 : on narrowe sur .success)
} else {
  log(result.error);       // l'erreur structurée, à traiter au bord
}

const Order = z.object({
  id: z.string().uuid(),
  items: z.array(z.object({ sku: z.string(), qty: z.number().int().positive() })),
  coupon: z.string().optional(),
  status: z.enum(["pending", "paid", "shipped"]),   // → union discriminée typée
});
type Order = z.infer<typeof Order>;   // tout le type, dérivé du schéma composé

Le as ApiResponse sur un .json() : zéro vérification, crash repoussé.The as ApiResponse on a .json(): zero verification, deferred crash.

C'est le contre-exemple obligatoire. interface ApiResponse + fetch().json() as ApiResponse a tout d'un code typé : une forme déclarée, un type partout en aval, un build vert. Mais aucune ligne ne regarde la donnée reçue : le as ordonne de croire, et le crash n'est que repoussé au premier champ manquant, à des écrans de la cause. À l'opposé, l'excès inverse guette aussi : parser la même donnée à chaque fonction interne. La discipline est nette — parser une seule fois, au bord, puis se fier au cœur typé.This is the mandatory counter-example. interface ApiResponse + fetch().json() as ApiResponse has every look of typed code: a declared shape, a type everywhere downstream, a green build. But no line looks at the received data: the as orders belief, and the crash is merely deferred to the first missing field, screens from the cause. At the other extreme, the opposite excess lurks too: parsing the same data at every internal function. The discipline is sharp — parse once, at the edge, then trust the typed core.

interface ApiResponse { items: Item[] }

const data = await res.json() as ApiResponse;   // ✗ as : ZÉRO vérification
data.items.map(render);   // 💥 si 'items' est absent : crash au premier accès
// l'interface décrit un espoir ; le as ordonne au compilateur d'y croire.

Le as ne convertit ni ne vérifie rien (Vol 4.3) : il rebaptise un any en ApiResponse. La forme déclarée est un vœu, pas un contrôle — le runtime ne la lit jamais. C'est l'anti-parse par excellence : tout le décorum du typé, aucune de sa garantie.The as neither converts nor checks anything (Vol 4.3): it renames an any into ApiResponse. The declared shape is a wish, not a check — the runtime never reads it. It's the anti-parse par excellence: all the trappings of typed code, none of its guarantee.