1// Le probleme : TypeScript fait confiance aveuglément
2interface User {
3  id: number;
4  name: string;
5  email: string;
6}
7
8// TypeScript ne verifie PAS que la reponse est conforme
9const response = await fetch('/api/users/1');
10const user: User = await response.json(); // Dangereux !
11// Si l'API renvoie { id: "abc", nom: "Jean" }, aucune erreur
12// Le crash arrive plus tard, dans un endroit inattendu

1// AVANT compilation (TypeScript)
2interface User {
3  id: number;
4  email: string;
5}
6
7const response = await fetch('/api/users/1');
8const user: User = await response.json();
9
10console.log(user.id + 1);            // On attend 2
11console.log(user.email.toUpperCase()); // On attend "JEAN@EXAMPLE.COM"
12
13// -----------------------------------------------------------
14// APRES compilation (JavaScript genere par tsc)
15// Les types ont COMPLETEMENT disparu :
16
17const response = await fetch('/api/users/1');
18const user = await response.json();  // Plus aucun type !
19
20console.log(user.id + 1);
21console.log(user.email.toUpperCase());
22
23// -----------------------------------------------------------
24// Ce qui se passe REELLEMENT quand l'API renvoie des types inattendus :
25// L'API renvoie : { id: "abc", email: 42 }
26
27user.id + 1;
28// Resultat : "abc1" (concatenation string au lieu d'addition)
29// Pas d'erreur ! Le bug se propage silencieusement.
30
31user.email.toUpperCase();
32// TypeError: user.email.toUpperCase is not a function
33// Car email est un number (42), pas un string.
34// Le crash arrive ICI, loin de la source du probleme.
35
36// TypeScript n'a RIEN pu faire : les types avaient deja ete effaces.
37// Sans validation runtime, vous decouvrez ces bugs en production.

1import { z } from 'zod';
2
3// 1. Definir le schema
4const UserSchema = z.object({
5  id: z.number(),
6  name: z.string().min(1),
7  email: z.string().email(),
8});
9
10// 2. TypeScript infere le type automatiquement
11type User = z.infer<typeof UserSchema>;
12// => { id: number; name: string; email: string }
13
14// 3. Valider les donnees a l'execution
15const response = await fetch('/api/users/1');
16const data = await response.json();
17const user = UserSchema.parse(data); // Valide ET type !
18// Si les donnees sont invalides -> ZodError avec details

1import { z } from 'zod';
2
3// Types de base
4const stringSchema = z.string();    // string
5const numberSchema = z.number();    // number
6const boolSchema = z.boolean();     // boolean
7const dateSchema = z.date();        // Date
8const bigintSchema = z.bigint();    // bigint
9
10// Types speciaux
11const undefinedSchema = z.undefined(); // undefined
12const nullSchema = z.null();           // null
13const voidSchema = z.void();           // void
14const anySchema = z.any();             // any (a eviter)
15const unknownSchema = z.unknown();     // unknown (prefere a any)
16const neverSchema = z.never();         // never
17
18// Litteraux
19const tealSchema = z.literal('teal');         // 'teal'
20const fortyTwoSchema = z.literal(42);         // 42
21const trueSchema = z.literal(true);           // true

1const emailSchema = z.string().email('Email invalide');
2const urlSchema = z.string().url('URL invalide');
3const uuidSchema = z.string().uuid('UUID invalide');
4
5// Longueur
6const usernameSchema = z.string()
7  .min(3, 'Minimum 3 caracteres')
8  .max(20, 'Maximum 20 caracteres');
9
10// Regex
11const slugSchema = z.string()
12  .regex(/^[a-z0-9-]+$/, 'Slug invalide : lettres minuscules, chiffres et tirets uniquement');
13
14// Transformations de chaines
15const normalizedEmail = z.string()
16  .email()
17  .trim()
18  .toLowerCase();
19
20// Formats courants
21const ipSchema = z.string().ip();           // IPv4 ou IPv6
22const cidrSchema = z.string().cidr();       // Notation CIDR
23const emojiSchema = z.string().emoji();     // Emojis uniquement
24const datetimeSchema = z.string().datetime(); // ISO 8601
25const nanoidSchema = z.string().nanoid();   // Nanoid

1// Contraintes numeriques
2const ageSchema = z.number()
3  .int('L\'age doit etre un entier')
4  .min(0, 'L\'age doit etre positif')
5  .max(150, 'Age invalide');
6
7const priceSchema = z.number()
8  .positive('Le prix doit etre positif')
9  .multipleOf(0.01, 'Maximum 2 decimales');
10
11const temperatureSchema = z.number()
12  .gte(-273.15, 'Impossible : en dessous du zero absolu')
13  .finite();
14
15// Raccourcis utiles
16z.number().positive();    // > 0
17z.number().nonnegative(); // >= 0
18z.number().negative();    // < 0
19z.number().nonpositive(); // <= 0
20z.number().int();         // entier
21z.number().finite();      // pas Infinity
22z.number().safe();        // dans Number.MIN_SAFE_INTEGER..MAX_SAFE_INTEGER

1const schema = z.object({
2  // Requis : doit etre present et non-null
3  name: z.string(),
4
5  // Optionnel : string | undefined
6  bio: z.string().optional(),
7
8  // Nullable : string | null
9  avatar: z.string().url().nullable(),
10
11  // Nullish : string | null | undefined
12  nickname: z.string().nullish(),
13
14  // Valeur par defaut : si absent, utilise la valeur fournie
15  role: z.enum(['admin', 'user', 'viewer']).default('viewer'),
16
17  // Optionnel avec defaut : toujours present dans le resultat
18  notifications: z.boolean().default(true),
19});
20
21type Profile = z.infer<typeof schema>;
22// {
23//   name: string;
24//   bio?: string | undefined;
25//   avatar: string | null;
26//   nickname?: string | null | undefined;
27//   role: 'admin' | 'user' | 'viewer';       // jamais undefined grace a default
28//   notifications: boolean;                    // jamais undefined grace a default
29// }

1import { z } from 'zod';
2
3const UserSchema = z.object({
4  name: z.string().min(1),
5  email: z.string().email(),
6  age: z.number().int().positive(),
7});
8
9// parse() lance une exception si invalide
10try {
11  const user = UserSchema.parse({
12    name: 'Jean Dupont',
13    email: 'jean@example.com',
14    age: 30,
15  });
16  // user est type : { name: string; email: string; age: number }
17  console.log(user.name); // 'Jean Dupont'
18} catch (error) {
19  if (error instanceof z.ZodError) {
20    console.error(error.issues);
21  }
22}

1const result = UserSchema.safeParse({
2  name: '',
3  email: 'pas-un-email',
4  age: -5,
5});
6
7if (result.success) {
8  // result.data est type { name: string; email: string; age: number }
9  console.log(result.data);
10} else {
11  // result.error est une ZodError
12  console.log(result.error.issues);
13  // [
14  //   { code: 'too_small', minimum: 1, path: ['name'], message: '...' },
15  //   { code: 'invalid_string', path: ['email'], message: 'Invalid email' },
16  //   { code: 'too_small', minimum: 0, path: ['age'], message: '...' }
17  // ]
18}

1const result = UserSchema.safeParse({ name: '', email: 'bad', age: -1 });
2
3if (!result.success) {
4  // flatten() -- ideal pour les formulaires
5  const flat = result.error.flatten();
6  // {
7  //   formErrors: [],          // erreurs globales
8  //   fieldErrors: {
9  //     name: ['String must contain at least 1 character(s)'],
10  //     email: ['Invalid email'],
11  //     age: ['Number must be greater than 0'],
12  //   }
13  // }
14
15  // format() -- structure imbriquee
16  const formatted = result.error.format();
17  // {
18  //   name: { _errors: ['String must contain at least 1 character(s)'] },
19  //   email: { _errors: ['Invalid email'] },
20  //   age: { _errors: ['Number must be greater than 0'] },
21  //   _errors: []
22  // }
23
24  // issues -- acces brut a chaque erreur
25  result.error.issues.forEach((issue) => {
26    console.log(`${issue.path.join('.')}: ${issue.message}`);
27  });
28}

1// Messages d'erreur personnalises
2const ContactSchema = z.object({
3  name: z.string({
4    required_error: 'Le nom est requis',
5    invalid_type_error: 'Le nom doit etre une chaine',
6  }).min(2, 'Le nom doit contenir au moins 2 caracteres'),
7
8  email: z.string()
9    .min(1, 'L\'email est requis')
10    .email('Format d\'email invalide'),
11
12  phone: z.string()
13    .regex(/^\+?[0-9]{10,14}$/, 'Numero de telephone invalide')
14    .optional(),
15
16  message: z.string()
17    .min(10, 'Le message doit contenir au moins 10 caracteres')
18    .max(1000, 'Le message ne peut pas depasser 1000 caracteres'),
19});
20
21// Chaque champ a des messages clairs et en francais
22const result = ContactSchema.safeParse({
23  name: 'J',
24  email: 'pas-valide',
25  message: 'Court',
26});
27// Erreurs :
28// name: 'Le nom doit contenir au moins 2 caracteres'
29// email: 'Format d\'email invalide'
30// message: 'Le message doit contenir au moins 10 caracteres'

1// SANS ZOD : erreur generique, difficile a tracer
2const user = apiResponse.data;
3console.log(user.profile.email.toUpperCase());
4// TypeError: Cannot read properties of undefined (reading 'toUpperCase')
5// D'ou vient le probleme ? profile est null ? email est undefined ? Aucune idee.
6
7// AVEC ZOD : erreur structuree, on comprend tout immediatement
8const result = UserSchema.safeParse(apiResponse.data);
9if (!result.success) {
10  console.error(result.error.issues);
11  // [
12  //   {
13  //     code: 'invalid_type',
14  //     expected: 'string',
15  //     received: 'number',
16  //     path: ['profile', 'email'],
17  //     message: 'Expected string, received number'
18  //   },
19  //   {
20  //     code: 'too_small',
21  //     minimum: 1,
22  //     type: 'string',
23  //     inclusive: true,
24  //     path: ['name'],
25  //     message: 'Le nom est requis'
26  //   }
27  // ]
28  // On sait EXACTEMENT : quel champ, quelle regle, quel type attendu vs recu
29}
30
31// Personnaliser TOUS les messages globalement avec setErrorMap
32import { z } from 'zod';
33
34const customErrorMap: z.ZodErrorMap = (issue, ctx) => {
35  // Personnaliser les erreurs de type
36  if (issue.code === z.ZodIssueCode.invalid_type) {
37    return { message: `Attendu ${issue.expected}, recu ${issue.received}` };
38  }
39  // Personnaliser les erreurs de longueur
40  if (issue.code === z.ZodIssueCode.too_small) {
41    return { message: `Minimum ${issue.minimum} caracteres requis` };
42  }
43  return { message: ctx.defaultError };
44};
45
46z.setErrorMap(customErrorMap);
47// Maintenant TOUTES les erreurs Zod utilisent vos messages personnalises

1// Pattern "double filet" : erreurs UI + console
2import { useForm } from 'react-hook-form';
3import { zodResolver } from '@hookform/resolvers/zod';
4import { z } from 'zod';
5
6const LoginSchema = z.object({
7  email: z.string().min(1, 'L\'email est requis').email('Email invalide'),
8  password: z.string().min(8, 'Minimum 8 caracteres'),
9});
10
11type LoginForm = z.infer<typeof LoginSchema>;
12
13export function LoginFormComponent() {
14  const { register, handleSubmit, formState: { errors } } = useForm<LoginForm>({
15    resolver: zodResolver(LoginSchema),
16  });
17
18  // Callback quand le formulaire est VALIDE
19  function onValid(data: LoginForm) {
20    console.log('Donnees validees :', data);
21  }
22
23  // Callback quand le formulaire est INVALIDE
24  // -> handleSubmit accepte un 2e argument pour capturer les erreurs
25  function onInvalid(errors: Record<string, unknown>) {
26    console.error('Erreurs de validation :', errors);
27    // Console affiche :
28    // {
29    //   email: { message: 'Email invalide', type: 'invalid_string', ref: input#email },
30    //   password: { message: 'Minimum 8 caracteres', type: 'too_small', ref: input#password }
31    // }
32    // -> On voit le message, le type d'erreur Zod, et la reference DOM
33  }
34
35  return (
36    <form onSubmit={handleSubmit(onValid, onInvalid)}>
37      <div>
38        <input {...register('email')} placeholder="Email" />
39        {/* L'utilisateur voit l'erreur dans l'UI */}
40        {errors.email && <p className="text-red-500 text-sm">{errors.email.message}</p>}
41      </div>
42
43      <div>
44        <input {...register('password')} type="password" placeholder="Mot de passe" />
45        {errors.password && <p className="text-red-500 text-sm">{errors.password.message}</p>}
46      </div>
47
48      <button type="submit">Se connecter</button>
49    </form>
50  );
51  // Resultat : l'utilisateur voit "Email invalide" dans le formulaire
52  // ET le developpeur voit la structure complete dans la console du navigateur
53}

1import { z } from 'zod';
2
3// Schema d'un utilisateur complet
4const UserSchema = z.object({
5  id: z.string().uuid(),
6  name: z.string().min(1),
7  email: z.string().email(),
8  age: z.number().int().positive().optional(),
9  address: z.object({
10    street: z.string(),
11    city: z.string(),
12    zipCode: z.string().regex(/^\d{5}$/),
13    country: z.string().default('FR'),
14  }),
15  tags: z.array(z.string()).default([]),
16  createdAt: z.date(),
17});
18
19type User = z.infer<typeof UserSchema>;
20// {
21//   id: string;
22//   name: string;
23//   email: string;
24//   age?: number | undefined;
25//   address: { street: string; city: string; zipCode: string; country: string };
26//   tags: string[];
27//   createdAt: Date;
28// }

1// Tableau de strings
2const tagsSchema = z.array(z.string());
3
4// Contraintes sur le tableau
5const itemsSchema = z.array(z.number())
6  .nonempty('Au moins un element requis')  // [number, ...number[]]
7  .min(2, 'Minimum 2 elements')
8  .max(100, 'Maximum 100 elements');
9
10// Tableau d'objets
11const OrderSchema = z.object({
12  id: z.string(),
13  items: z.array(z.object({
14    productId: z.string(),
15    quantity: z.number().int().positive(),
16    price: z.number().positive(),
17  })).nonempty('La commande doit contenir au moins un article'),
18  total: z.number().positive(),
19});
20
21// Tuples -- tableau avec types fixes par position
22const CoordinatesSchema = z.tuple([
23  z.number(),  // latitude
24  z.number(),  // longitude
25]);
26// type : [number, number]
27
28// Tuple avec rest element
29const LogEntrySchema = z.tuple([
30  z.date(),     // timestamp
31  z.string(),   // level
32]).rest(z.string()); // ...messages
33// type : [Date, string, ...string[]]

1// z.enum() -- enumeration Zod (recommande)
2const RoleSchema = z.enum(['admin', 'editor', 'viewer']);
3type Role = z.infer<typeof RoleSchema>; // 'admin' | 'editor' | 'viewer'
4
5// Acces aux valeurs
6RoleSchema.options; // ['admin', 'editor', 'viewer']
7RoleSchema.enum;    // { admin: 'admin', editor: 'editor', viewer: 'viewer' }
8
9// z.nativeEnum() -- enum TypeScript existante
10enum Status {
11  Active = 'active',
12  Inactive = 'inactive',
13  Pending = 'pending',
14}
15const StatusSchema = z.nativeEnum(Status);
16type StatusType = z.infer<typeof StatusSchema>; // Status
17
18// Record -- objet avec cles dynamiques
19const SettingsSchema = z.record(z.string(), z.boolean());
20// type : Record<string, boolean>
21// Valide : { darkMode: true, notifications: false }
22
23// Record avec cle contrainte
24const ScoresSchema = z.record(
25  z.enum(['math', 'french', 'english']),
26  z.number().min(0).max(20)
27);
28// type : Partial<Record<'math' | 'french' | 'english', number>>

1// Union simple -- essaie chaque schema dans l'ordre
2const StringOrNumberSchema = z.union([z.string(), z.number()]);
3// Equivalent raccourci :
4const shorthand = z.string().or(z.number());
5
6// Discriminated union -- plus performante, utilise un champ discriminant
7const EventSchema = z.discriminatedUnion('type', [
8  z.object({
9    type: z.literal('click'),
10    x: z.number(),
11    y: z.number(),
12    target: z.string(),
13  }),
14  z.object({
15    type: z.literal('keypress'),
16    key: z.string(),
17    modifiers: z.array(z.enum(['ctrl', 'shift', 'alt', 'meta'])),
18  }),
19  z.object({
20    type: z.literal('scroll'),
21    deltaX: z.number(),
22    deltaY: z.number(),
23  }),
24]);
25
26type Event = z.infer<typeof EventSchema>;
27// { type: 'click'; x: number; y: number; target: string }
28// | { type: 'keypress'; key: string; modifiers: ('ctrl' | 'shift' | 'alt' | 'meta')[] }
29// | { type: 'scroll'; deltaX: number; deltaY: number }
30
31// Avantage : Zod regarde d'abord le champ 'type'
32// pour savoir quel schema appliquer -> beaucoup plus rapide

1// Intersection -- combiner deux schemas
2const WithTimestamps = z.object({
3  createdAt: z.date(),
4  updatedAt: z.date(),
5});
6
7const PostSchema = z.object({
8  title: z.string(),
9  content: z.string(),
10});
11
12const PostWithTimestamps = z.intersection(PostSchema, WithTimestamps);
13// Equivalent raccourci :
14const shorthand = PostSchema.and(WithTimestamps);
15
16type Post = z.infer<typeof PostWithTimestamps>;
17// { title: string; content: string; createdAt: Date; updatedAt: Date }

1import { z } from 'zod';
2
3// Schema de base -- la source de verite
4const UserSchema = z.object({
5  id: z.string().uuid(),
6  name: z.string().min(1),
7  email: z.string().email(),
8  password: z.string().min(8),
9  role: z.enum(['admin', 'editor', 'viewer']),
10  avatar: z.string().url().nullable(),
11  createdAt: z.date(),
12  updatedAt: z.date(),
13});
14
15// Creation : sans id ni timestamps (generes cote serveur)
16const CreateUserSchema = UserSchema.omit({
17  id: true,
18  createdAt: true,
19  updatedAt: true,
20});
21type CreateUser = z.infer<typeof CreateUserSchema>;
22// { name: string; email: string; password: string; role: ...; avatar: string | null }
23
24// Mise a jour partielle : tout optionnel sauf l'id
25const UpdateUserSchema = UserSchema.pick({
26  name: true,
27  email: true,
28  avatar: true,
29  role: true,
30}).partial();
31type UpdateUser = z.infer<typeof UpdateUserSchema>;
32// { name?: string; email?: string; avatar?: string | null; role?: ... }
33
34// Vue publique : sans password ni timestamps
35const PublicUserSchema = UserSchema.omit({
36  password: true,
37  updatedAt: true,
38});
39type PublicUser = z.infer<typeof PublicUserSchema>;
40// { id: string; name: string; email: string; role: ...; avatar: ...; createdAt: Date }

1// extend() -- ajouter des proprietes
2const BaseArticleSchema = z.object({
3  title: z.string().min(1),
4  content: z.string(),
5});
6
7const PublishedArticleSchema = BaseArticleSchema.extend({
8  slug: z.string().regex(/^[a-z0-9-]+$/),
9  publishedAt: z.date(),
10  author: z.object({
11    name: z.string(),
12    avatar: z.string().url().optional(),
13  }),
14});
15
16// merge() -- fusionner deux schemas objets
17const TimestampSchema = z.object({
18  createdAt: z.date(),
19  updatedAt: z.date(),
20});
21
22const SoftDeleteSchema = z.object({
23  deletedAt: z.date().nullable(),
24  isActive: z.boolean(),
25});
26
27// Fusion de 3 schemas
28const FullArticleSchema = PublishedArticleSchema
29  .merge(TimestampSchema)
30  .merge(SoftDeleteSchema);
31
32type FullArticle = z.infer<typeof FullArticleSchema>;
33// Combine toutes les proprietes des 3 schemas

1const ProductSchema = z.object({
2  name: z.string(),
3  price: z.number(),
4});
5
6const input = { name: 'Widget', price: 9.99, discount: 0.1, sku: 'W-001' };
7
8// Comportement par defaut : strip (supprime les proprietes inconnues)
9ProductSchema.parse(input);
10// { name: 'Widget', price: 9.99 } -- discount et sku supprimes
11
12// strict() -- rejette les proprietes inconnues
13ProductSchema.strict().parse(input);
14// ZodError: Unrecognized key(s) in object: 'discount', 'sku'
15
16// passthrough() -- conserve les proprietes inconnues
17ProductSchema.passthrough().parse(input);
18// { name: 'Widget', price: 9.99, discount: 0.1, sku: 'W-001' }
19
20// catchall() -- valide les proprietes inconnues avec un schema
21ProductSchema.catchall(z.string()).parse({
22  name: 'Widget',
23  price: 9.99,
24  note: 'fragile',  // OK : string
25});

1// Pattern reel : schemas partages client/serveur
2// schemas/user.ts -- fichier partage
3
4import { z } from 'zod';
5
6export const UserBaseSchema = z.object({
7  name: z.string().min(1, 'Le nom est requis'),
8  email: z.string().email('Email invalide'),
9  role: z.enum(['admin', 'editor', 'viewer']).default('viewer'),
10});
11
12// Pour le formulaire d'inscription (client)
13export const SignupFormSchema = UserBaseSchema.extend({
14  password: z.string().min(8, 'Minimum 8 caracteres'),
15  confirmPassword: z.string(),
16}).refine((data) => data.password === data.confirmPassword, {
17  message: 'Les mots de passe ne correspondent pas',
18  path: ['confirmPassword'],
19});
20
21// Pour la reponse API (serveur -> client)
22export const UserResponseSchema = UserBaseSchema.extend({
23  id: z.string().uuid(),
24  createdAt: z.string().datetime(),
25});
26
27// Pour la mise a jour (client -> serveur)
28export const UpdateProfileSchema = UserBaseSchema
29  .pick({ name: true, email: true })
30  .partial();
31
32// Tous les types inferes automatiquement
33export type SignupForm = z.infer<typeof SignupFormSchema>;
34export type UserResponse = z.infer<typeof UserResponseSchema>;
35export type UpdateProfile = z.infer<typeof UpdateProfileSchema>;

1import { z } from 'zod';
2
3// Transformer une string en nombre
4const NumericStringSchema = z.string()
5  .transform((val) => parseInt(val, 10));
6// Input : string -> Output : number
7
8NumericStringSchema.parse('42');   // 42 (number)
9NumericStringSchema.parse('abc');  // NaN (attention !)
10
11// Transformer et valider le resultat avec pipe
12const SafeNumericSchema = z.string()
13  .transform((val) => parseInt(val, 10))
14  .pipe(z.number().int().positive());
15// Input : string -> parse int -> verifie que c'est un entier positif
16
17SafeNumericSchema.parse('42');   // 42
18SafeNumericSchema.parse('abc');  // ZodError (NaN n'est pas un entier positif)
19SafeNumericSchema.parse('-5');   // ZodError (pas positif)

1// z.coerce -- coercion automatique (plus simple que transform)
2const CoercedNumber = z.coerce.number();
3CoercedNumber.parse('42');     // 42
4CoercedNumber.parse(true);     // 1
5
6const CoercedDate = z.coerce.date();
7CoercedDate.parse('2024-01-15');         // Date object
8CoercedDate.parse(1705276800000);        // Date object (timestamp)
9
10const CoercedBoolean = z.coerce.boolean();
11CoercedBoolean.parse('true');   // true
12CoercedBoolean.parse('');       // false
13CoercedBoolean.parse(0);       // false
14CoercedBoolean.parse(1);       // true
15
16// Cas d'usage frequent : query parameters (toujours des strings)
17const PaginationSchema = z.object({
18  page: z.coerce.number().int().positive().default(1),
19  limit: z.coerce.number().int().min(1).max(100).default(20),
20  sort: z.enum(['asc', 'desc']).default('desc'),
21});
22
23// URL : ?page=2&limit=50&sort=asc
24PaginationSchema.parse({ page: '2', limit: '50', sort: 'asc' });
25// { page: 2, limit: 50, sort: 'asc' } -- strings converties en nombres

1// Normaliser un slug
2const SlugSchema = z.string()
3  .trim()
4  .toLowerCase()
5  .transform((val) => val.replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, ''));
6
7SlugSchema.parse('  Mon Article ! '); // 'mon-article-'
8
9// Transformer un objet complet
10const CreateOrderSchema = z.object({
11  items: z.array(z.object({
12    productId: z.string(),
13    quantity: z.number().int().positive(),
14    unitPrice: z.number().positive(),
15  })),
16  couponCode: z.string().optional(),
17}).transform((order) => ({
18  ...order,
19  itemCount: order.items.length,
20  subtotal: order.items.reduce((sum, item) => sum + item.quantity * item.unitPrice, 0),
21  hasCoupon: !!order.couponCode,
22}));
23
24type CreateOrderInput = z.input<typeof CreateOrderSchema>;
25// { items: [...]; couponCode?: string }
26
27type CreateOrderOutput = z.output<typeof CreateOrderSchema>;
28// { items: [...]; couponCode?: string; itemCount: number; subtotal: number; hasCoupon: boolean }
29
30// z.input vs z.infer (= z.output)
31// z.input  = type AVANT transform
32// z.infer  = type APRES transform (= z.output)