ERP-119 : revue validation front clients + évolutions écran client (types d'adresse, 2e email, saisies manuelles, redirection) (#80)

## Contexte
Branche ERP-119 — revue de la validation des formulaires clients (déclencheur : écran « Ajouter un client »), accompagnée de plusieurs évolutions de l'écran client (M1).

## Contenu

### Validation front (clients)
- Boutons « Valider » toujours actifs (retrait du gating de validité) : c'est le back qui renvoie les 422, mappées en rouge par champ.
- Champs requis adossés à une colonne non-nullable : la clé est omise du payload si vide (companyName, RIB, adresse) → 422 NotBlank au lieu d'un 400 de type.
- Onglet Contact : au moins un contact requis (l'amorce vide est soumise → 422 RG-1.05).
- Onglet Adresse : affichage inline des erreurs type / sites / catégories + RG back « au moins un type d'adresse obligatoire ».

### Nouveaux types d'adresse
- Courtier / Distributeur, types autonomes exclusifs : colonnes `is_broker` / `is_distributor` (migration + CHECK miroir d'exclusivité), entité + Callback, et front (select, drapeaux, payloads).

### Saisies manuelles
- Adresse : `allow-create` sur le champ Adresse → saisie libre si la BAN ne propose rien.
- Date de création : `MalioDate :editable` → saisie clavier JJ/MM/AAAA en plus du calendrier.

### 2e email de facturation
- Colonne `billing_email_secondary` (optionnel, max 2), miroir du téléphone secondaire. Bump `@malio/layer-ui` 1.7.8 (prop `addable`).

### Fin d'ajout d'un client
- Redirection vers la liste à la validation du dernier onglet remplissable par le rôle (Adresse pour Bureau/Commerciale, Comptabilité pour Admin) + toast « Client ajouté ». Dérivé de `tabKeys`, sans règle RBAC custom.

## Vérifications
- Back : suites Module/Commercial + Architecture vertes (Client : 124/124). Migrations appliquées (dev + test).
- Front : Vitest vert (272), ESLint OK.

> Note : le hook pré-commit flake aléatoirement (JWT 401 / timeout DB) sur des tests sans rapport (Supplier) ; les commits ont été faits après vérification des suites concernées en isolation.

Reviewed-on: #80
Co-authored-by: tristan <tristan@yuno.malio.fr>
Co-committed-by: tristan <tristan@yuno.malio.fr>

frontend/modules/commercial/utils/__tests__/clientEdit.spec.ts

@@ -61,7 +61,9 @@ function accountingDraft(overrides: Partial<AccountingFormDraft> = {}): Accounti
 // Le contact inline (nom/prenom/telephones/email) ne fait plus partie du groupe
 // main : les coordonnees vivent desormais sur la sous-ressource ClientContact.
 const MAIN_KEYS = [
-    'companyName', 'categories', 'distributor', 'broker', 'triageService',
+    // relationType : champ transitoire envoye au back pour la validation croisee
+    // « relation choisie => FK obligatoire » (RG-1.03 bis, ERP-119).
+    'companyName', 'categories', 'relationType', 'distributor', 'broker', 'triageService',
 ]
 const INFORMATION_KEYS = [
     'description', 'competitors', 'foundedAt', 'employeesCount',
@@ -99,6 +101,27 @@ describe('buildMainPayload — scoping strict groupe client:write:main', () => {
         expect(payload.distributor).toBeNull()
         expect(payload.broker).toBeNull()
     })
+
+    it('transmet relationType au back pour la validation croisee (RG-1.03 bis)', () => {
+        expect(buildMainPayload(mainDraft({ relationType: 'distributeur' })).relationType).toBe('distributeur')
+        expect(buildMainPayload(mainDraft({ relationType: 'courtier' })).relationType).toBe('courtier')
+        expect(buildMainPayload(mainDraft({ relationType: null })).relationType).toBeNull()
+    })
+
+    // ERP-119 : companyName est requis ET adosse a une colonne NON-nullable. Si le
+    // champ est vide, on OMET la cle (au lieu d'envoyer null) pour que le back
+    // renvoie une 422 NotBlank (propertyPath companyName) et non un 400 de type.
+    it('omet companyName quand il est vide (null) -> 422 NotBlank cote back', () => {
+        expect('companyName' in buildMainPayload(mainDraft({ companyName: null }))).toBe(false)
+    })
+
+    it('omet companyName quand il est une chaine vide', () => {
+        expect('companyName' in buildMainPayload(mainDraft({ companyName: '' }))).toBe(false)
+    })
+
+    it('conserve companyName quand il est renseigne', () => {
+        expect(buildMainPayload(mainDraft({ companyName: 'ACME' })).companyName).toBe('ACME')
+    })
 })
 
 describe('buildInformationPayload — scoping strict groupe client:write:information', () => {
@@ -142,19 +165,50 @@ describe('buildContactPayload / buildAddressPayload / buildRibPayload', () => {
 
     it('adresse : email facturation conserve uniquement si requis (RG-1.11)', () => {
         const address: AddressFormDraft = {
-            id: 3, isProspect: false, isDelivery: false, isBilling: true, country: 'France',
+            id: 3, isProspect: false, isDelivery: false, isBilling: true, isBroker: false, isDistributor: false, country: 'France',
             postalCode: '86100', city: 'Châtellerault', street: '1 rue X', streetComplement: null,
             categoryIris: ['/api/categories/2'], siteIris: ['/api/sites/1'], contactIris: [],
-            billingEmail: 'facturation@acme.fr',
+            billingEmail: 'facturation@acme.fr', billingEmailSecondary: 'compta@acme.fr', hasSecondaryBillingEmail: true,
         }
         expect(buildAddressPayload(address, true).billingEmail).toBe('facturation@acme.fr')
         expect(buildAddressPayload(address, false).billingEmail).toBeNull()
+        // 2e email : transmis si facturation + revele, sinon null (ERP-119).
+        expect(buildAddressPayload(address, true).billingEmailSecondary).toBe('compta@acme.fr')
+        expect(buildAddressPayload(address, false).billingEmailSecondary).toBeNull()
+        expect(buildAddressPayload({ ...address, hasSecondaryBillingEmail: false }, true).billingEmailSecondary).toBeNull()
     })
 
     it('rib : label / bic / iban transmis tels quels', () => {
         const rib: RibFormDraft = { id: 1, label: 'Compte principal', bic: 'BNPAFRPP', iban: 'FR76...' }
         expect(buildRibPayload(rib)).toEqual({ label: 'Compte principal', bic: 'BNPAFRPP', iban: 'FR76...' })
     })
+
+    // ERP-119 : un RIB partiel (IBAN seul) doit omettre label/bic vides pour
+    // declencher la 422 NotBlank par champ, pas un 400 de type a la deserialisation.
+    it('rib partiel : omet label / bic vides, conserve iban', () => {
+        const rib: RibFormDraft = { id: null, label: null, bic: null, iban: 'FR7612345' }
+        const payload = buildRibPayload(rib)
+        expect('label' in payload).toBe(false)
+        expect('bic' in payload).toBe(false)
+        expect(payload.iban).toBe('FR7612345')
+    })
+
+    // ERP-119 : une adresse partielle omet postalCode/city/street vides (NotBlank).
+    it('adresse partielle : omet postalCode / city / street vides', () => {
+        const address: AddressFormDraft = {
+            id: null, isProspect: false, isDelivery: true, isBilling: false, isBroker: false, isDistributor: false, country: 'France',
+            postalCode: null, city: '', street: null, streetComplement: null,
+            categoryIris: ['/api/categories/2'], siteIris: ['/api/sites/1'], contactIris: [],
+            billingEmail: null, billingEmailSecondary: null, hasSecondaryBillingEmail: false,
+        }
+        const payload = buildAddressPayload(address, false)
+        expect('postalCode' in payload).toBe(false)
+        expect('city' in payload).toBe(false)
+        expect('street' in payload).toBe(false)
+        // Les champs non requis / booleens restent presents.
+        expect(payload.isDelivery).toBe(true)
+        expect(payload.sites).toEqual(['/api/sites/1'])
+    })
 })
 
 describe('mapMainDraft — pre-remplissage bloc principal', () => {

frontend/modules/commercial/utils/__tests__/clientFormRules.spec.ts

@@ -18,7 +18,10 @@ import {
     isRibBlank,
     isRibComplete,
     isRibRequiredForPaymentType,
+    lastFillableTabKey,
+    omitEmptyRequired,
     showsRelationAndTriageFields,
+    type AddressFlagsDraft,
     type AddressValidityDraft,
     type ContactDraft,
     type ContactFillableDraft,
@@ -68,6 +71,24 @@ describe('buildClientFormTabKeys (gating onglet Comptabilite + onglets edit-only
     })
 })
 
+describe('lastFillableTabKey (redirection fin d\'ajout, role-aware)', () => {
+    it('Adresse pour un role sans Comptabilite (Bureau / Commerciale)', () => {
+        expect(lastFillableTabKey(buildClientFormTabKeys(false))).toBe('address')
+    })
+
+    it('Comptabilite pour un role avec accounting.view (Admin)', () => {
+        expect(lastFillableTabKey(buildClientFormTabKeys(true))).toBe('accounting')
+    })
+
+    it('ignore les onglets placeholder (Transport en dernier ne compte pas)', () => {
+        expect(lastFillableTabKey(['information', 'contact', 'address', 'transport'])).toBe('address')
+    })
+
+    it('undefined si aucun onglet remplissable (que des placeholders)', () => {
+        expect(lastFillableTabKey(['transport', 'statistics'])).toBeUndefined()
+    })
+})
+
 describe('isContactNamed (RG-1.05)', () => {
     it('vrai si le prenom est renseigne', () => {
         expect(isContactNamed({ firstName: 'Alice', lastName: null })).toBe(true)
@@ -148,83 +169,79 @@ describe('hasAtLeastOneValidContact (RG-1.14)', () => {
     })
 })
 
+/** Drapeaux d'adresse complets (5 types) avec surcharge partielle. */
+function flags(overrides: Partial<AddressFlagsDraft> = {}): AddressFlagsDraft {
+    return {
+        isProspect: false, isDelivery: false, isBilling: false, isBroker: false, isDistributor: false,
+        ...overrides,
+    }
+}
+
 describe('exclusivite Prospect / Livraison / Facturation (RG-1.06/07/08)', () => {
     it('Prospect est selectionnable tant que ni Livraison ni Facturation', () => {
-        expect(canSelectProspect({ isProspect: false, isDelivery: false, isBilling: false })).toBe(true)
-        expect(canSelectProspect({ isProspect: false, isDelivery: true, isBilling: false })).toBe(false)
-        expect(canSelectProspect({ isProspect: false, isDelivery: false, isBilling: true })).toBe(false)
+        expect(canSelectProspect(flags())).toBe(true)
+        expect(canSelectProspect(flags({ isDelivery: true }))).toBe(false)
+        expect(canSelectProspect(flags({ isBilling: true }))).toBe(false)
     })
 
     it('Livraison / Facturation selectionnables tant que pas Prospect', () => {
-        expect(canSelectDeliveryOrBilling({ isProspect: false, isDelivery: false, isBilling: false })).toBe(true)
-        expect(canSelectDeliveryOrBilling({ isProspect: true, isDelivery: false, isBilling: false })).toBe(false)
+        expect(canSelectDeliveryOrBilling(flags())).toBe(true)
+        expect(canSelectDeliveryOrBilling(flags({ isProspect: true }))).toBe(false)
     })
 
     it('cocher Prospect efface Livraison et Facturation', () => {
-        const next = applyProspectExclusivity(
-            { isProspect: false, isDelivery: true, isBilling: true },
-            'isProspect',
-            true,
-        )
-        expect(next).toEqual({ isProspect: true, isDelivery: false, isBilling: false })
+        const next = applyProspectExclusivity(flags({ isDelivery: true, isBilling: true }), 'isProspect', true)
+        expect(next).toEqual(flags({ isProspect: true }))
     })
 
     it('cocher Livraison efface Prospect', () => {
-        const next = applyProspectExclusivity(
-            { isProspect: true, isDelivery: false, isBilling: false },
-            'isDelivery',
-            true,
-        )
-        expect(next).toEqual({ isProspect: false, isDelivery: true, isBilling: false })
+        const next = applyProspectExclusivity(flags({ isProspect: true }), 'isDelivery', true)
+        expect(next).toEqual(flags({ isDelivery: true }))
     })
 
     it('cocher Facturation efface Prospect mais conserve Livraison', () => {
-        const next = applyProspectExclusivity(
-            { isProspect: true, isDelivery: true, isBilling: false },
-            'isBilling',
-            true,
-        )
-        expect(next).toEqual({ isProspect: false, isDelivery: true, isBilling: true })
+        const next = applyProspectExclusivity(flags({ isProspect: true, isDelivery: true }), 'isBilling', true)
+        expect(next).toEqual(flags({ isDelivery: true, isBilling: true }))
     })
 
     it('decocher un drapeau ne reactive rien d autre', () => {
-        const next = applyProspectExclusivity(
-            { isProspect: false, isDelivery: true, isBilling: true },
-            'isBilling',
-            false,
-        )
-        expect(next).toEqual({ isProspect: false, isDelivery: true, isBilling: false })
+        const next = applyProspectExclusivity(flags({ isDelivery: true, isBilling: true }), 'isBilling', false)
+        expect(next).toEqual(flags({ isDelivery: true }))
     })
 })
 
 describe('isBillingEmailRequired (RG-1.11)', () => {
     it('obligatoire uniquement si Facturation est coche', () => {
-        expect(isBillingEmailRequired({ isProspect: false, isDelivery: false, isBilling: true })).toBe(true)
-        expect(isBillingEmailRequired({ isProspect: false, isDelivery: true, isBilling: false })).toBe(false)
+        expect(isBillingEmailRequired(flags({ isBilling: true }))).toBe(true)
+        expect(isBillingEmailRequired(flags({ isDelivery: true }))).toBe(false)
     })
 })
 
 describe('type d\'adresse (Select front) <-> drapeaux back', () => {
     it('addressFlagsFromType mappe chaque type vers les bons drapeaux', () => {
-        expect(addressFlagsFromType('prospect')).toEqual({ isProspect: true, isDelivery: false, isBilling: false })
-        expect(addressFlagsFromType('delivery')).toEqual({ isProspect: false, isDelivery: true, isBilling: false })
-        expect(addressFlagsFromType('billing')).toEqual({ isProspect: false, isDelivery: false, isBilling: true })
-        expect(addressFlagsFromType('delivery_billing')).toEqual({ isProspect: false, isDelivery: true, isBilling: true })
+        expect(addressFlagsFromType('prospect')).toEqual(flags({ isProspect: true }))
+        expect(addressFlagsFromType('delivery')).toEqual(flags({ isDelivery: true }))
+        expect(addressFlagsFromType('billing')).toEqual(flags({ isBilling: true }))
+        expect(addressFlagsFromType('delivery_billing')).toEqual(flags({ isDelivery: true, isBilling: true }))
+        expect(addressFlagsFromType('broker')).toEqual(flags({ isBroker: true }))
+        expect(addressFlagsFromType('distributor')).toEqual(flags({ isDistributor: true }))
     })
 
-    it('addressTypeFromFlags reconstruit le type (Prospect prioritaire, livraison+facturation groupes)', () => {
-        expect(addressTypeFromFlags({ isProspect: true, isDelivery: false, isBilling: false })).toBe('prospect')
-        expect(addressTypeFromFlags({ isProspect: false, isDelivery: true, isBilling: false })).toBe('delivery')
-        expect(addressTypeFromFlags({ isProspect: false, isDelivery: false, isBilling: true })).toBe('billing')
-        expect(addressTypeFromFlags({ isProspect: false, isDelivery: true, isBilling: true })).toBe('delivery_billing')
+    it('addressTypeFromFlags reconstruit le type (Prospect/Courtier/Distributeur autonomes, livraison+facturation groupes)', () => {
+        expect(addressTypeFromFlags(flags({ isProspect: true }))).toBe('prospect')
+        expect(addressTypeFromFlags(flags({ isDelivery: true }))).toBe('delivery')
+        expect(addressTypeFromFlags(flags({ isBilling: true }))).toBe('billing')
+        expect(addressTypeFromFlags(flags({ isDelivery: true, isBilling: true }))).toBe('delivery_billing')
+        expect(addressTypeFromFlags(flags({ isBroker: true }))).toBe('broker')
+        expect(addressTypeFromFlags(flags({ isDistributor: true }))).toBe('distributor')
     })
 
     it('addressTypeFromFlags retourne null quand aucun drapeau (amorce vierge -> bouton bloque)', () => {
-        expect(addressTypeFromFlags({ isProspect: false, isDelivery: false, isBilling: false })).toBeNull()
+        expect(addressTypeFromFlags(flags())).toBeNull()
     })
 
-    it('aller-retour type -> drapeaux -> type stable pour les 4 types', () => {
-        for (const type of ['prospect', 'delivery', 'billing', 'delivery_billing'] as const) {
+    it('aller-retour type -> drapeaux -> type stable pour les 6 types', () => {
+        for (const type of ['prospect', 'delivery', 'billing', 'delivery_billing', 'broker', 'distributor'] as const) {
             expect(addressTypeFromFlags(addressFlagsFromType(type))).toBe(type)
         }
     })
@@ -324,6 +341,8 @@ describe('isAddressValid (gating « + Adresse » + validation onglet)', () => {
             isProspect: false,
             isDelivery: true,
             isBilling: false,
+            isBroker: false,
+            isDistributor: false,
             categoryIris: ['/api/client_categories/1'],
             siteIris: ['/api/sites/1'],
             billingEmail: null,
@@ -369,3 +388,33 @@ describe('isRibComplete (gating « + RIB » + RG-1.13)', () => {
         expect(isRibComplete({ label: null, bic: null, iban: null })).toBe(false)
     })
 })
+
+describe('omitEmptyRequired (ERP-119 : 422 NotBlank au lieu de 400 de type)', () => {
+    it('retire les cles requises vides (null / vide / undefined)', () => {
+        const payload = omitEmptyRequired(
+            { companyName: null, label: '', iban: undefined, categories: ['/api/categories/1'] },
+            ['companyName', 'label', 'iban'],
+        )
+        expect('companyName' in payload).toBe(false)
+        expect('label' in payload).toBe(false)
+        expect('iban' in payload).toBe(false)
+        // Les cles hors liste ne sont jamais touchees.
+        expect(payload.categories).toEqual(['/api/categories/1'])
+    })
+
+    it('conserve les cles requises renseignees', () => {
+        const payload = omitEmptyRequired({ companyName: 'ACME', bic: 'BNPAFRPP' }, ['companyName', 'bic'])
+        expect(payload).toEqual({ companyName: 'ACME', bic: 'BNPAFRPP' })
+    })
+
+    it('ne retire jamais une cle hors de la liste requise, meme vide', () => {
+        const payload = omitEmptyRequired({ streetComplement: null }, ['street'])
+        expect('streetComplement' in payload).toBe(true)
+        expect(payload.streetComplement).toBeNull()
+    })
+
+    it('false / 0 ne sont pas consideres vides (booleens / nombres preserves)', () => {
+        const payload = omitEmptyRequired({ isDelivery: false, position: 0 }, ['isDelivery', 'position'])
+        expect(payload).toEqual({ isDelivery: false, position: 0 })
+    })
+})

frontend/modules/commercial/utils/clientConsultation.ts

@@ -63,9 +63,12 @@ export interface AddressRead extends HydraRef {
     street?: string | null
     streetComplement?: string | null
     billingEmail?: string | null
+    billingEmailSecondary?: string | null
     isProspect?: boolean
     isDelivery?: boolean
     isBilling?: boolean
+    isBroker?: boolean
+    isDistributor?: boolean
     sites?: SiteRead[]
     categories?: CategoryRead[]
     // L'embed M2M des contacts d'adresse peut etre un objet (partiel) ou un IRI nu.
@@ -209,6 +212,8 @@ export function mapAddressToDraft(address: AddressRead): AddressFormDraft {
         isProspect: address.isProspect ?? false,
         isDelivery: address.isDelivery ?? false,
         isBilling: address.isBilling ?? false,
+        isBroker: address.isBroker ?? false,
+        isDistributor: address.isDistributor ?? false,
         country: address.country ?? 'France',
         postalCode: address.postalCode ?? null,
         city: address.city ?? null,
@@ -218,6 +223,8 @@ export function mapAddressToDraft(address: AddressRead): AddressFormDraft {
         siteIris: (address.sites ?? []).map(s => s['@id']),
         contactIris: (address.contacts ?? []).map(c => (typeof c === 'string' ? c : c['@id'])),
         billingEmail: address.billingEmail ?? null,
+        billingEmailSecondary: address.billingEmailSecondary ?? null,
+        hasSecondaryBillingEmail: (address.billingEmailSecondary ?? null) !== null && address.billingEmailSecondary !== '',
     }
 }
 

frontend/modules/commercial/utils/clientEdit.ts

@@ -21,6 +21,12 @@ import {
     relationOf,
     type ClientDetail,
 } from '~/modules/commercial/utils/clientConsultation'
+import {
+    ADDRESS_REQUIRED_NON_NULLABLE_KEYS,
+    MAIN_REQUIRED_NON_NULLABLE_KEYS,
+    omitEmptyRequired,
+    RIB_REQUIRED_NON_NULLABLE_KEYS,
+} from '~/modules/commercial/utils/clientFormRules'
 import type { AddressFormDraft, ContactFormDraft, RibFormDraft } from '~/modules/commercial/types/clientForm'
 
 /**
@@ -139,13 +145,21 @@ export function mapAccountingFormDraft(client: ClientDetail): AccountingFormDraf
  * que la FK correspondant au type choisi, l'autre est forcee a null.
  */
 export function buildMainPayload(main: MainFormDraft): Record<string, unknown> {
-    return {
+    // companyName omis si vide -> 422 NotBlank au lieu d'un 400 de type (ERP-119).
+    // relationType : champ transitoire (non persiste cote back) qui porte
+    // l'intention UI « ce client depend d'un distributeur / courtier ». Il sert
+    // a la validation croisee serveur (RG-1.03 bis) : si une relation est choisie,
+    // la FK correspondante devient obligatoire -> 422 sur distributor / broker.
+    // Sans equivalent derivable cote back (FK nullable), c'est la seule facon de
+    // rester sur « on soumet, le back tranche » plutot qu'une garde front-only.
+    return omitEmptyRequired({
         companyName: main.companyName,
         categories: main.categoryIris,
+        relationType: main.relationType,
         distributor: main.relationType === 'distributeur' ? main.distributorIri : null,
         broker: main.relationType === 'courtier' ? main.brokerIri : null,
         triageService: main.triageService,
-    }
+    }, MAIN_REQUIRED_NON_NULLABLE_KEYS)
 }
 
 /** Payload de l'onglet Information — groupe client:write:information UNIQUEMENT. */
@@ -198,10 +212,13 @@ export function buildAddressPayload(
     address: AddressFormDraft,
     isBillingEmailRequired: boolean,
 ): Record<string, unknown> {
-    return {
+    // postalCode / city / street omis si vides -> 422 NotBlank (ERP-119).
+    return omitEmptyRequired({
         isProspect: address.isProspect,
         isDelivery: address.isDelivery,
         isBilling: address.isBilling,
+        isBroker: address.isBroker,
+        isDistributor: address.isDistributor,
         country: address.country,
         postalCode: address.postalCode || null,
         city: address.city || null,
@@ -211,16 +228,19 @@ export function buildAddressPayload(
         sites: address.siteIris,
         contacts: address.contactIris,
         billingEmail: isBillingEmailRequired ? (address.billingEmail || null) : null,
-    }
+        billingEmailSecondary: isBillingEmailRequired && address.hasSecondaryBillingEmail ? (address.billingEmailSecondary || null) : null,
+    }, ADDRESS_REQUIRED_NON_NULLABLE_KEYS)
 }
 
 /** Payload d'un RIB (sous-ressource client_rib). */
 export function buildRibPayload(rib: RibFormDraft): Record<string, unknown> {
-    return {
+    // label / bic / iban omis si vides -> 422 NotBlank au lieu d'un 400 de type
+    // sur un RIB partiel (ex. IBAN seul). ERP-119.
+    return omitEmptyRequired({
         label: rib.label,
         bic: rib.bic,
         iban: rib.iban,
-    }
+    }, RIB_REQUIRED_NON_NULLABLE_KEYS)
 }
 
 // ── Gating par permission ────────────────────────────────────────────────────

frontend/modules/commercial/utils/clientFormRules.ts

@@ -50,6 +50,18 @@ export function buildClientFormTabKeys(
     return keys
 }
 
+/**
+ * Dernier onglet REMPLISSABLE d'un jeu d'onglets : le dernier qui n'est pas un
+ * placeholder (coquille). Role-aware sans regle ad hoc — il suffit de lui passer
+ * les `tabKeys` deja filtres par permission (l'onglet Comptabilite n'y figure que
+ * si accounting.view). Sa validation marque la fin de l'ajout (redirection liste).
+ */
+export function lastFillableTabKey(tabKeys: string[]): string | undefined {
+    return [...tabKeys].reverse().find(
+        key => !(CLIENT_FORM_PLACEHOLDER_TABS as readonly string[]).includes(key),
+    )
+}
+
 /**
  * Codes de categorie « intermediaire » : un client dont la categorie est
  * Distributeur ou Courtier n'a ni relation amont (il EST le distributeur /
@@ -81,6 +93,10 @@ export interface AddressFlagsDraft {
     isProspect: boolean
     isDelivery: boolean
     isBilling: boolean
+    /** Adresse Courtier — type autonome exclusif (comme isProspect). */
+    isBroker: boolean
+    /** Adresse Distributeur — type autonome exclusif (comme isProspect). */
+    isDistributor: boolean
 }
 
 /** Vrai si une chaine porte au moins un caractere non-espace. */
@@ -220,22 +236,30 @@ export function isBillingEmailRequired(flags: AddressFlagsDraft): boolean {
  * drapeaux isProspect / isDelivery / isBilling (aucune RG modifiee). Les seules
  * combinaisons proposees respectent l'exclusivite Prospect (RG-1.06/07/08).
  */
-export type AddressType = 'prospect' | 'delivery' | 'billing' | 'delivery_billing'
+export type AddressType = 'prospect' | 'delivery' | 'billing' | 'delivery_billing' | 'broker' | 'distributor'
 
 /**
- * Mappe le type d'adresse choisi vers les trois drapeaux back.
+ * Mappe le type d'adresse choisi vers les cinq drapeaux back.
  * « Adresse + Facturation » = livraison ET facturation sur la meme adresse.
+ * Courtier / Distributeur sont autonomes (un seul drapeau, exclusif du reste).
  */
 export function addressFlagsFromType(type: AddressType): AddressFlagsDraft {
+    const none: AddressFlagsDraft = {
+        isProspect: false, isDelivery: false, isBilling: false, isBroker: false, isDistributor: false,
+    }
     switch (type) {
         case 'prospect':
-            return { isProspect: true, isDelivery: false, isBilling: false }
+            return { ...none, isProspect: true }
         case 'delivery':
-            return { isProspect: false, isDelivery: true, isBilling: false }
+            return { ...none, isDelivery: true }
         case 'billing':
-            return { isProspect: false, isDelivery: false, isBilling: true }
+            return { ...none, isBilling: true }
         case 'delivery_billing':
-            return { isProspect: false, isDelivery: true, isBilling: true }
+            return { ...none, isDelivery: true, isBilling: true }
+        case 'broker':
+            return { ...none, isBroker: true }
+        case 'distributor':
+            return { ...none, isDistributor: true }
     }
 }
 
@@ -246,6 +270,8 @@ export function addressFlagsFromType(type: AddressType): AddressFlagsDraft {
  */
 export function addressTypeFromFlags(flags: AddressFlagsDraft): AddressType | null {
     if (flags.isProspect) return 'prospect'
+    if (flags.isBroker) return 'broker'
+    if (flags.isDistributor) return 'distributor'
     if (flags.isDelivery && flags.isBilling) return 'delivery_billing'
     if (flags.isDelivery) return 'delivery'
     if (flags.isBilling) return 'billing'
@@ -358,3 +384,38 @@ export function hasAllRequiredAccountingFields(accounting: AccountingRequiredDra
         && filled(accounting.paymentDelayIri)
         && filled(accounting.paymentTypeIri)
 }
+
+// ── Champs requis adosses a une colonne NON-nullable (ERP-119) ───────────────
+// Ces champs requis (NotBlank back) sont portes par une colonne Doctrine NON
+// nullable. Si le front envoie `null` (champ vide, desormais possible : le bouton
+// « Valider » n'est plus desactive), API Platform rejette la valeur en 400 de TYPE
+// a la deserialisation (« The type of the X attribute must be string, NULL given »)
+// AVANT le Validator -> pas de violation, donc pas d'erreur rouge cote champ.
+// La parade : OMETTRE la cle du payload quand elle est vide. Sans la cle, la
+// propriete garde son defaut null cote entite et #[Assert\NotBlank] se declenche
+// normalement -> 422 avec propertyPath, mappee en rouge sous le champ.
+// (Les champs requis a colonne NULLABLE — contacts, scalaires compta — acceptent
+// deja `null` et renvoient une 422 : inutile de les omettre.)
+export const MAIN_REQUIRED_NON_NULLABLE_KEYS = ['companyName'] as const
+export const ADDRESS_REQUIRED_NON_NULLABLE_KEYS = ['postalCode', 'city', 'street'] as const
+export const RIB_REQUIRED_NON_NULLABLE_KEYS = ['label', 'bic', 'iban'] as const
+
+/**
+ * Retire d'un payload d'ecriture les cles requises laissees vides (null / ''
+ * / undefined), pour laisser le back produire une 422 NotBlank par champ plutot
+ * qu'un 400 de type sur une colonne non-nullable. Mute et retourne le payload.
+ * A n'appliquer QU'aux cles ci-dessus (champs requis a colonne non-nullable).
+ */
+export function omitEmptyRequired<T extends Record<string, unknown>>(
+    payload: T,
+    requiredKeys: readonly string[],
+): T {
+    for (const key of requiredKeys) {
+        const value = payload[key]
+        if (value === null || value === undefined || value === '') {
+            delete payload[key]
+        }
+    }
+
+    return payload
+}