écrits/tutorial/2026/11
● Tutorial18 nov. 2026·22 min

Saoudisation des achats à 70 % : un contrôle TypeScript pour 12 codes

La décision ministérielle 77050 impose 70 % de Saoudiens dans les métiers des achats depuis le 31 mai 2026, et son guide double la liste à 12 codes, magasiniers et responsables d'entrepôt compris. Construisez le contrôle en TypeScript : périmètre, arrondi, remplacement ou recrutement, et comparaison avec les règles de 2023.

Le 30 novembre 2025, le ministère saoudien des Ressources humaines et du Développement social a publié la décision ministérielle 77050 et un guide de procédure pour les métiers des achats. La période de grâce de six mois a pris fin le 31 mai 2026. Depuis, tout établissement privé qui emploie trois personnes ou plus dans ces métiers doit compter 70 % de Saoudiens parmi elles.

Beaucoup de systèmes RH contiennent encore la règle de 2023 : décision 141612, 50 %, six métiers. Passer le taux de 50 à 70 se fait en une ligne. Le vrai changement est la liste. Le guide 2026 nomme douze métiers, et les six nouveaux ne sont pas des acheteurs : magasinier, responsable et spécialiste d'entrepôt, responsable des services logistiques, spécialiste du commerce électronique et spécialiste des études de marché. Une entreprise dont l'équipe achats était conforme en 2025 peut ne plus l'être aujourd'hui à cause de son entrepôt.

Ce tutoriel construit le contrôle en TypeScript, à partir des deux guides officiels, avec des tests que vous pouvez exécuter. Il s'adresse au développeur ou au responsable des systèmes RH qui doit rendre les chiffres justes. Comme la décision est déjà appliquée, le module indique depuis combien de jours une entité est hors conformité, et non combien de temps il reste.

Prérequis

  • Node.js 20 ou plus récent et TypeScript 5
  • Un export de vos effectifs avec, pour chaque salarié : la nationalité, le code de métier enregistré dans Qiwa, l'agence, et l'entité à laquelle il appartient
  • Une colonne que la plupart des exports n'ont pas : la personne exerce-t-elle réellement le travail du métier ? Elle vient des responsables directs, pas du système
  • Des notions de base sur Qiwa et Nitaqat

Ce que vous allez construire

Un petit module qui répond à cinq questions pour chaque entité :

  1. Combien de salariés entrent dans le périmètre du guide 2026, et la décision s'applique-t-elle ?
  2. Combien de Saoudiens sont exigés, avec l'arrondi du guide ?
  3. Quel est l'écart si vous remplacez des non-Saoudiens, et quel est-il si vous ne faites que recruter ?
  4. Qui est entré dans le périmètre le 31 mai 2026, par rapport aux règles de 2023 que votre système contient peut-être encore ?
  5. Quels salariés créent un risque parce que leur code et leur travail réel ne concordent pas ?

Le résultat est un plan d'action lisible par les RH, séparé entre les métiers d'achat et les métiers d'entrepôt, de logistique et de marché ajoutés à la liste.

Étape 1 : ce que dit réellement le guide

Tout ce qui suit provient du guide de procédure de sept pages publié sur le site du ministère pour la décision 77050, lu en parallèle avec le guide de 2023 qu'il remplace.

Le taux. 70 % dans les établissements où trois salariés ou plus occupent les métiers des achats du tableau (section 3.1).

Le périmètre. La section 3.3 applique la décision aux établissements privés actifs sur le marché saoudien qui emploient trois salariés ou plus dans les métiers du tableau 2. Un établissement qui en emploie deux n'est pas concerné. Les définitions précisent que l'établissement visé est une entité enregistrée auprès du ministère, et que le taux se calcule sur l'établissement lui-même.

Les métiers. Le tableau 2 liste douze codes de la Classification saoudienne unifiée des professions :

CodeMétier
132417Responsable des achats
332302Délégué aux achats
122105Responsable des contrats
243104Spécialiste des appels d'offres
243102Spécialiste des achats
332301Spécialiste de l'approvisionnement en marques propres
132415Responsable des services logistiques
132418Responsable d'entrepôt
313907Magasinier
243107Spécialiste du commerce électronique
243108Spécialiste des études de marché
241110Spécialiste d'entrepôt

Le guide donne un seul tableau. Le découpage en « achats » (les six premiers, tous présents en 2023) et « chaîne d'approvisionnement » (les six nouveaux) est le nôtre, uniquement pour rendre le rapport lisible.

L'arrondi. La section 4 indique que le nombre exigé est arrondi à l'entier : 0,49 et moins vers le bas, 0,5 et plus vers le haut. Son exemple chiffré prend 70 salariés dans les métiers visés, dont 20 Saoudiens, dans un établissement de 500 personnes. 70 fois 70 % donne 49 Saoudiens : l'établissement doit employer 29 Saoudiens de plus dans ces métiers. Le total de 500 n'intervient pas dans le calcul. Une note ajoute que l'établissement doit maintenir le taux atteint lors d'un remplacement ou d'un recrutement.

Chevauchement. Si des décisions antérieures ou ultérieures visent les métiers des achats à des taux différents, le taux le plus élevé s'applique (section 3.3). La FAQ dit la même chose des mémorandums régionaux de saoudisation signés avec les émirats des régions.

Dates. Publication le 30 novembre 2025, six mois de grâce, application à partir du 31 mai 2026 (section « période de grâce » du guide et sa frise). Ensuite, les sanctions s'appliquent à tout établissement sous le taux.

Sanctions. La section 6 renvoie au barème des infractions de la décision ministérielle 75913 (19/5/1445 H) et de la décision ministérielle 44558 (3/4/1446 H). Elle nomme aussi une infraction précise : confier une tâche de ces métiers à un non-Saoudien, directement ou indirectement, sous n'importe quel autre intitulé de poste.

La FAQ ajoute trois points qui comptent pour le code :

  • La décision s'applique quelle que soit la bande Nitaqat de l'établissement, et la bande ne change pas le calcul du taux des achats.
  • Elle s'applique aux intitulés de métier et au travail réellement exercé.
  • Le ministère révise les taux périodiquement. Traitez 70 % comme une valeur qui changera, pas comme une constante.

Ce qui a changé depuis le guide de 2023

Le guide de 2023 pour la décision 141612 (11/09/1444 H) fixait 50 % après neuf mois de grâce, jusqu'au 11/06/1445 H (24 décembre 2023). Il diffère sur quatre points :

  • Six métiers, pas douze. Responsable des achats, délégué aux achats, responsable des contrats, spécialiste de l'approvisionnement en marques propres, spécialiste des appels d'offres et spécialiste des achats. Les six codes de la chaîne d'approvisionnement n'y figuraient pas.
  • Neuf codes pour ces six métiers. Trois métiers portaient aussi un ancien code à sept chiffres : 1214041 responsable des achats, 5112033 délégué aux achats et 1217361 responsable des contrats. Le tableau de 2026 supprime les trois.
  • 50 % au lieu de 70 %. Son exemple chiffré utilisait les mêmes 70 salariés et 20 Saoudiens : 35 exigés, 15 à recruter.
  • D'autres sanctions. Il renvoyait à la décision 92768 (5/5/1443 H) et à un tableau de services Qiwa suspendus, comme les permis de travail et le recrutement à l'étranger.

Aucun des deux guides ne fixe de salaire minimum pour qu'un Saoudien soit compté. Contrairement aux décisions sur la gestion de projet et l'ingénierie, il n'y a pas ici de plancher GOSI à modéliser.

Étape 2 : les règles comme données

Gardez chaque guide sous forme d'enregistrement, jamais en constantes dispersées dans le code. Quand le ministère publiera la prochaine mise à jour, vous ajouterez un enregistrement et les tests vous diront ce qui a changé.

// src/rules.ts
export type Family = "purchasing" | "supply-chain";
 
export interface Occupation {
  title: string;
  family: Family;
}
 
export interface QuotaRule {
  decision: string;
  guideIssued: string;   // ISO date
  effectiveFrom: string; // ISO date, end of the grace period
  ratePercent: number;   // whole percent, e.g. 70
  minWorkers: number;    // the rule applies from this many workers in scope
  codes: Record<string, Occupation>;
}
 
// Procedural guide for Ministerial Decision 77050 (30 Nov 2025)
export const PROC_2026: QuotaRule = {
  decision: "77050",
  guideIssued: "2025-11-30",
  effectiveFrom: "2026-05-31",
  ratePercent: 70,
  minWorkers: 3,
  codes: {
    "132417": { title: "Procurement manager", family: "purchasing" },
    "332302": { title: "Procurement representative", family: "purchasing" },
    "122105": { title: "Contracts manager", family: "purchasing" },
    "243104": { title: "Tenders specialist", family: "purchasing" },
    "243102": { title: "Procurement specialist", family: "purchasing" },
    "332301": { title: "Private-label supply specialist", family: "purchasing" },
    "132415": { title: "Logistics services manager", family: "supply-chain" },
    "132418": { title: "Warehouse manager", family: "supply-chain" },
    "313907": { title: "Storekeeper", family: "supply-chain" },
    "243107": { title: "E-commerce specialist", family: "supply-chain" },
    "243108": { title: "Market research specialist", family: "supply-chain" },
    "241110": { title: "Warehouse specialist", family: "supply-chain" },
  },
};
 
// Procedural guide for Ministerial Decision 141612 (11/09/1444 AH),
// enforced from 11/06/1445 AH (24 Dec 2023)
export const PROC_2023: QuotaRule = {
  decision: "141612",
  guideIssued: "2023-04-02",
  effectiveFrom: "2023-12-24",
  ratePercent: 50,
  minWorkers: 3,
  codes: {
    "132417": { title: "Procurement manager", family: "purchasing" },
    "1214041": { title: "Procurement manager (old code)", family: "purchasing" },
    "332302": { title: "Procurement representative", family: "purchasing" },
    "5112033": { title: "Procurement representative (old code)", family: "purchasing" },
    "122105": { title: "Contracts manager", family: "purchasing" },
    "1217361": { title: "Contracts manager (old code)", family: "purchasing" },
    "332301": { title: "Private-label supply specialist", family: "purchasing" },
    "243104": { title: "Tenders specialist", family: "purchasing" },
    "243102": { title: "Procurement specialist", family: "purchasing" },
  },
};

Le taux est un pourcentage entier à dessein. L'étape 3 explique pourquoi.

Étape 3 : arrondir sans virgule flottante

En JavaScript, 45 * 0.7 donne 31.499999999999996, et non 31,5. Math.round renvoie alors 31 là où la règle du guide donne 32 : un Saoudien de moins, avec un rapport qui vous déclare conforme. Même chose à 85, 165 et 175 salariés. Travailler en pourcentage entier évite le problème : multipliez l'effectif par 70, ajoutez 50, divisez par 100 et gardez la partie entière. C'est l'arrondi à l'entier le plus proche avec les demis vers le haut, comme le décrit le guide.

// src/quota.ts
// Saudis required for a headcount, rounded to the nearest whole number
// (0.49 and below goes down, 0.5 and above goes up, as the guide says).
// Integer arithmetic only: 45 * 0.7 is 31.499999999999996 in floating point.
export function requiredSaudis(headcount: number, ratePercent: number): number {
  return Math.floor((headcount * ratePercent + 50) / 100);
}
 
// Replacement: swap non-Saudis for Saudis, headcount stays the same.
export function gapByReplacement(
  headcount: number,
  saudis: number,
  ratePercent: number,
): number {
  return Math.max(0, requiredSaudis(headcount, ratePercent) - saudis);
}
 
// Hiring only: each new Saudi raises both sides of the ratio.
export function gapByHiring(
  headcount: number,
  saudis: number,
  ratePercent: number,
): number {
  if (ratePercent >= 100) {
    return saudis >= headcount ? 0 : Number.POSITIVE_INFINITY;
  }
  let hires = 0;
  while (saudis + hires < requiredSaudis(headcount + hires, ratePercent)) {
    hires += 1;
  }
  return hires;
}

Les deux fonctions d'écart répondent à des questions différentes. Le remplacement garde l'effectif : on remplace un non-Saoudien par un Saoudien et seul le numérateur bouge. Le recrutement ajoute des personnes : chaque nouveau Saoudien fait monter le numérateur et le dénominateur ensemble.

L'écart est important à 70 %. Sur l'exemple du guide, 70 salariés dont 20 Saoudiens, le remplacement demande 29 personnes. Le recrutement seul en demande 96, parce que chaque Saoudien ajouté augmente aussi le total sur lequel on prend les 70 %. La formule du guide, « employer 29 Saoudiens », ne tient que si 29 non-Saoudiens quittent ces postes en même temps. La boucle s'arrête parce qu'à tout taux inférieur à 100 % la part des Saoudiens augmente à chaque recrutement. La garde à 100 % permet à la même fonction de servir les décisions qui réservent entièrement un métier.

Étape 4 : le périmètre, c'est le code et le travail

La FAQ est explicite : la décision s'applique à l'intitulé classé et au travail réel. Cela donne deux cas de défaillance, et le module enregistre les deux :

  • Un salarié porte l'un des douze codes mais n'en exerce pas le travail. Nous le laissons hors périmètre. La bonne correction est de rectifier l'enregistrement, et le rapport doit le montrer plutôt que compter la personne.
  • Un salarié fait un travail d'achat ou d'entrepôt sous un autre code. Pour un non-Saoudien, la section 6 en fait une infraction à part entière. Pour un Saoudien, c'est une personne perdue pour le décompte : elle n'aide votre taux qu'une fois le bon code enregistré.

Le second cas est fréquent en entrepôt. Un magasinier enregistré comme ouvrier, ou un coordinateur logistique enregistré sous un code administratif, est invisible dans le décompte mais visible pour un inspecteur.

// src/assess.ts
import { Family, QuotaRule } from "./rules";
import { requiredSaudis, gapByReplacement, gapByHiring } from "./quota";
 
export interface Worker {
  id: string;
  entityId: string;          // the establishment as the ministry groups it
  branchId: string;
  saudi: boolean;
  occupationCode: string;    // as registered in Qiwa / GOSI
  doesProcurementWork: boolean; // what the person actually does, from the line manager
}
 
export interface Finding {
  kind: "title-mismatch";
  workerId: string;
  saudi: boolean;
}
 
export interface EntityResult {
  entityId: string;
  inScope: number;
  saudis: number;
  applies: boolean;
  required: number;
  rate: number;              // percent, one decimal
  byReplacement: number;
  byHiring: number;
  byFamily: Record<Family, { inScope: number; saudis: number }>;
  findings: Finding[];
}
 
export function assessEntity(
  entityId: string,
  workers: Worker[],
  rule: QuotaRule,
): EntityResult {
  const mine = workers.filter((w) => w.entityId === entityId);
  const findings: Finding[] = [];
 
  // Duties without the code. For a non-Saudi the guide calls this a breach;
  // a Saudi in the same position is simply not counted.
  for (const w of mine) {
    if (w.doesProcurementWork && !(w.occupationCode in rule.codes)) {
      findings.push({ kind: "title-mismatch", workerId: w.id, saudi: w.saudi });
    }
  }
 
  // Scope is the registered code AND the actual work.
  const scoped = mine.filter(
    (w) => w.occupationCode in rule.codes && w.doesProcurementWork,
  );
  const byFamily: EntityResult["byFamily"] = {
    purchasing: { inScope: 0, saudis: 0 },
    "supply-chain": { inScope: 0, saudis: 0 },
  };
  for (const w of scoped) {
    const f = byFamily[rule.codes[w.occupationCode].family];
    f.inScope += 1;
    if (w.saudi) f.saudis += 1;
  }
 
  const n = scoped.length;
  const s = scoped.filter((w) => w.saudi).length;
  const applies = n >= rule.minWorkers;
  return {
    entityId,
    inScope: n,
    saudis: s,
    applies,
    required: applies ? requiredSaudis(n, rule.ratePercent) : 0,
    rate: n === 0 ? 0 : Math.round((s / n) * 1000) / 10,
    byReplacement: applies ? gapByReplacement(n, s, rule.ratePercent) : 0,
    byHiring: applies ? gapByHiring(n, s, rule.ratePercent) : 0,
    byFamily,
    findings,
  };
}

Trois détails de cette fonction viennent directement du guide :

  • Les salariés sont filtrés par entityId, pas par agence : le seuil de trois et les 70 % se calculent sur l'ensemble des agences de l'établissement.
  • Le test de seuil est n >= rule.minWorkers. Deux salariés, c'est hors champ ; trois, c'est dedans, et seuls les salariés des douze codes comptent.
  • byFamily n'influe pas sur la conformité. Il montre aux RH où se trouve l'écart, ce qui compte : recruter un magasinier saoudien et recruter un spécialiste saoudien des appels d'offres sont deux recherches très différentes.

Le taux est affiché avec une décimale, mais la conformité ne l'utilise jamais. Elle compare des effectifs, parce que le guide raisonne en personnes entières.

Étape 5 : quand deux décisions couvrent un même code

Le guide et sa FAQ disent tous deux que le taux le plus élevé l'emporte quand une autre décision ou un mémorandum régional vise le même métier. La fonction ci-dessous ne devine pas quelles autres décisions existent ; elle applique cette règle aux décisions que vous lui fournissez, en ne retenant que celles déjà en vigueur à la date demandée.

// src/overlap.ts
import { QuotaRule } from "./rules";
 
// When two decisions cover the same code, the higher rate applies.
// Only decisions already in force on the date are considered.
export function ruleFor(
  code: string,
  onDate: string,
  rules: QuotaRule[],
): QuotaRule | undefined {
  return rules
    .filter((r) => code in r.codes && r.effectiveFrom <= onDate)
    .sort((a, b) => b.ratePercent - a.ratePercent)[0];
}

Elle gère aussi la transition. Jusqu'au 30 mai 2026, la règle de 2023 à 50 % régissait les six métiers d'achat et rien ne régissait les codes d'entrepôt. Depuis le 31 mai, la règle de 2026 à 70 % régit les douze. Si vous conservez l'historique, appelez la fonction pour chaque date et vos rapports du premier semestre 2026 resteront justes.

Étape 6 : comparer les listes de 2023 et 2026

C'est l'étape qui attrape les erreurs coûteuses. Appliquez l'ancienne et la nouvelle règle aux mêmes effectifs et listez qui a bougé.

// src/diff.ts
import { QuotaRule } from "./rules";
import { Worker } from "./assess";
 
export interface RuleDiff {
  codesAdded: string[];
  codesRemoved: string[];
  workersJoining: string[];  // in scope under the new rule only
  workersLeaving: string[];  // in scope under the old rule only
  rateChange: [number, number];
}
 
export function diffRules(
  oldRule: QuotaRule,
  newRule: QuotaRule,
  workers: Worker[],
): RuleDiff {
  const oldCodes = Object.keys(oldRule.codes);
  const newCodes = Object.keys(newRule.codes);
  const inOld = (w: Worker) => w.occupationCode in oldRule.codes;
  const inNew = (w: Worker) => w.occupationCode in newRule.codes;
  return {
    codesAdded: newCodes.filter((c) => !oldCodes.includes(c)),
    codesRemoved: oldCodes.filter((c) => !newCodes.includes(c)),
    workersJoining: workers.filter((w) => inNew(w) && !inOld(w)).map((w) => w.id),
    workersLeaving: workers.filter((w) => inOld(w) && !inNew(w)).map((w) => w.id),
    rateChange: [oldRule.ratePercent, newRule.ratePercent],
  };
}

À quoi vous attendre sur un vrai export :

  • Entrées : toute personne enregistrée en 132415, 132418, 313907, 243107, 243108 ou 241110. Dans une entreprise de distribution ou de commerce, ce groupe peut être plusieurs fois plus grand que l'équipe achats, et il peut faire passer au-dessus du seuil de trois une entité qui était en dessous en 2023.
  • Sorties : toute personne encore sur 1214041, 5112033 ou 1217361. Ce sont des codes de l'ancienne classification. Avant de vous réjouir d'un dénominateur plus petit, vérifiez ce que Qiwa contient aujourd'hui pour ces personnes. Si elles ont été migrées vers 132417, 332302 ou 122105, elles ne sont jamais sorties.
  • Taux : de 50 à 70. À lui seul, cela ajoute environ un Saoudien pour cinq salariés dans le périmètre.

Un piège rencontré en écrivant cette étape : les codes sont des clés d'objet qui ressemblent à des entiers, et JavaScript renvoie ces clés dans l'ordre numérique, pas dans l'ordre d'écriture. Si vous comparez des listes, triez-les ou testez contre l'ordre numérique.

Étape 7 : des constats au plan d'action

Les RH ne lisent pas des objets. Transformez le résultat en lignes actionnables. Le 31 mai 2026 étant passé, le plan compte les jours d'infraction.

// src/plan.ts
import { EntityResult } from "./assess";
 
export function phaseOn(today: string, effectiveFrom: string): "grace" | "enforced" {
  return today < effectiveFrom ? "grace" : "enforced";
}
 
export function daysBetween(from: string, to: string): number {
  return Math.round((Date.parse(to) - Date.parse(from)) / 86_400_000);
}
 
export function actionPlan(r: EntityResult, today: string, effectiveFrom: string): string[] {
  const lines: string[] = [];
  if (!r.applies) {
    lines.push(`Entity ${r.entityId}: ${r.inScope} in scope, below the threshold. Re-run on every hire.`);
    return lines;
  }
  lines.push(
    `Entity ${r.entityId}: ${r.saudis}/${r.inScope} Saudi (${r.rate}%), ` +
      `${r.required} required.`,
  );
  const sc = r.byFamily["supply-chain"];
  if (sc.inScope > 0) {
    lines.push(`Warehouse, logistics and market roles: ${sc.saudis}/${sc.inScope} Saudi.`);
  }
  if (r.byReplacement > 0) {
    lines.push(`Replace ${r.byReplacement}, or hire ${r.byHiring} additional Saudis.`);
    lines.push(
      phaseOn(today, effectiveFrom) === "grace"
        ? `${daysBetween(today, effectiveFrom)} days of grace left.`
        : `Grace ended ${effectiveFrom}: in breach for ${daysBetween(effectiveFrom, today)} days.`,
    );
  }
  for (const f of r.findings) {
    lines.push(
      f.saudi
        ? `Worker ${f.workerId} is Saudi and not counted: register the right code in Qiwa.`
        : `Worker ${f.workerId} does procurement work under another code: fix the role or the code.`,
    );
  }
  return lines;
}

Tester votre implémentation

Ces tests figent chaque chiffre donné par le guide, ainsi que les cas limites autour. Lancez-les avec npx tsx --test src/assess.test.ts.

// src/assess.test.ts
import { test } from "node:test";
import assert from "node:assert/strict";
import { PROC_2023, PROC_2026 } from "./rules";
import { requiredSaudis, gapByReplacement, gapByHiring } from "./quota";
import { assessEntity, Worker } from "./assess";
import { ruleFor } from "./overlap";
import { diffRules } from "./diff";
import { actionPlan, daysBetween } from "./plan";
 
const w = (id: string, saudi: boolean, code = "243102", extra: Partial<Worker> = {}): Worker => ({
  id, entityId: "E1", branchId: "B1", saudi, occupationCode: code,
  doesProcurementWork: true, ...extra,
});
 
test("guide example: 70 in scope, 20 Saudi, 49 required, 29 to replace", () => {
  assert.equal(requiredSaudis(70, 70), 49);
  assert.equal(gapByReplacement(70, 20, 70), 29);
  assert.equal(gapByReplacement(70, 60, 70), 0); // above the rate: no negative gap
});
 
test("the 2023 guide example at 50% still holds", () => {
  assert.equal(requiredSaudis(70, 50), 35);
  assert.equal(gapByReplacement(70, 20, 50), 15);
});
 
test("rounding is to the nearest whole number", () => {
  assert.equal(requiredSaudis(3, 70), 2);   // 2.1
  assert.equal(requiredSaudis(4, 70), 3);   // 2.8
  assert.equal(requiredSaudis(5, 70), 4);   // 3.5
  assert.equal(requiredSaudis(15, 70), 11); // 10.5
  assert.equal(requiredSaudis(45, 70), 32); // 45 * 0.7 is 31.499999999999996
});
 
test("hiring only needs far more people than replacement", () => {
  assert.equal(gapByHiring(70, 20, 70), 96);
  assert.equal(gapByHiring(5, 2, 70), 4);
  assert.equal(gapByHiring(10, 7, 70), 0);
  assert.equal(gapByHiring(3, 1, 100), Number.POSITIVE_INFINITY);
});
 
test("below three workers in scope the decision does not apply", () => {
  const r = assessEntity("E1", [w("a", false), w("b", false)], PROC_2026);
  assert.equal(r.applies, false);
  assert.equal(r.required, 0);
  assert.equal(r.byReplacement, 0);
});
 
test("only workers in the 12 codes count toward the threshold", () => {
  const ws = [w("a", false), w("b", false), w("c", false, "263101", { doesProcurementWork: false })];
  assert.equal(assessEntity("E1", ws, PROC_2026).applies, false);
});
 
test("branches of one entity are counted together, other entities are not", () => {
  const ws = [
    w("a", true),
    w("b", false, "132418", { branchId: "B2" }),
    w("c", false, "313907", { branchId: "B3" }),
    w("x", false, "243102", { entityId: "E2" }),
  ];
  const r = assessEntity("E1", ws, PROC_2026);
  assert.equal(r.inScope, 3);
  assert.equal(r.required, 2);
  assert.equal(r.byReplacement, 1);
  assert.deepEqual(r.byFamily, {
    purchasing: { inScope: 1, saudis: 1 },
    "supply-chain": { inScope: 2, saudis: 0 },
  });
});
 
test("a code without the work is out of scope; work without the code is flagged", () => {
  const ws = [
    w("a", true), w("b", true), w("c", false),
    w("d", false, "243102", { doesProcurementWork: false }),
    w("e", false, "263101"),
    w("f", true, "263101"),
    w("g", false, "263101", { doesProcurementWork: false }),
  ];
  const r = assessEntity("E1", ws, PROC_2026);
  assert.equal(r.inScope, 3);
  assert.equal(r.saudis, 2);
  assert.equal(r.rate, 66.7);
  assert.deepEqual(r.findings, [
    { kind: "title-mismatch", workerId: "e", saudi: false },
    { kind: "title-mismatch", workerId: "f", saudi: true },
  ]);
});
 
test("warehouse staff were outside the 2023 rule and are inside the 2026 one", () => {
  const ws = [w("a", true), w("b", false, "313907"), w("c", false, "132418"), w("d", false, "241110")];
  assert.equal(assessEntity("E1", ws, PROC_2023).applies, false);
  const now = assessEntity("E1", ws, PROC_2026);
  assert.equal(now.inScope, 4);
  assert.equal(now.byReplacement, 2);
});
 
test("diff between the 2023 and 2026 lists", () => {
  // Codes are integer-like keys: Object.keys returns them in numeric order.
  const ws = [w("a", true, "313907"), w("b", false, "1214041"), w("c", false, "132417")];
  const d = diffRules(PROC_2023, PROC_2026, ws);
  assert.deepEqual(d.codesAdded, ["132415", "132418", "241110", "243107", "243108", "313907"]);
  assert.deepEqual(d.codesRemoved, ["1214041", "1217361", "5112033"]);
  assert.deepEqual(d.workersJoining, ["a"]);
  assert.deepEqual(d.workersLeaving, ["b"]);
  assert.deepEqual(d.rateChange, [50, 70]);
});
 
test("higher rate wins only once in force", () => {
  assert.equal(ruleFor("243102", "2026-05-30", [PROC_2023, PROC_2026])?.decision, "141612");
  assert.equal(ruleFor("243102", "2026-05-31", [PROC_2023, PROC_2026])?.decision, "77050");
  assert.equal(ruleFor("313907", "2026-05-30", [PROC_2023, PROC_2026]), undefined);
  assert.equal(ruleFor("999999", "2026-06-01", [PROC_2026]), undefined);
});
 
test("action plan: grace days before 31 May 2026, breach days after", () => {
  assert.equal(daysBetween("2025-11-30", "2026-05-31"), 182);
  const r = assessEntity("E1", [w("a", true), w("b", false, "313907"), w("c", false)], PROC_2026);
  const before = actionPlan(r, "2026-05-01", PROC_2026.effectiveFrom);
  assert.match(before[1], /Warehouse, logistics and market roles: 0\/1 Saudi/);
  assert.match(before[2], /Replace 1, or hire 3/);
  assert.match(before[3], /30 days of grace left/);
  const now = actionPlan(r, "2026-11-18", PROC_2026.effectiveFrom);
  assert.match(now[3], /in breach for 171 days/);
  const firstDay = actionPlan(r, "2026-05-31", PROC_2026.effectiveFrom);
  assert.match(firstDay[3], /in breach for 0 days/);
});
 
test("an entity that meets the rate gets no gap lines", () => {
  const r = assessEntity("E1", [w("a", true), w("b", true), w("c", false)], PROC_2026);
  assert.deepEqual(actionPlan(r, "2026-11-18", PROC_2026.effectiveFrom), [
    "Entity E1: 2/3 Saudi (66.7%), 2 required.",
  ]);
});

Treize tests, tous réussis sur Node 20 et plus, avec tsc --strict sans erreur. Nous avons aussi modifié le code volontairement (arrondi avec 49 au lieu de 50, multiplication flottante par 0,7, seuil strict, suppression du filtre sur le travail réel, suppression du filtre d'entité, date d'effet ignorée, mauvais ordre de tri, code manquant, code dans la mauvaise famille, limite de la période de grâce décalée d'un jour, écart négatif, signalement d'incohérence sans le travail) et vérifié qu'au moins un test échoue à chaque modification. Retirer la garde à 100 % fait tourner le test de recrutement sans fin, d'où cette garde.

Une vérification que les tests ne peuvent pas faire : comparer le résultat du module avec ce que Qiwa affiche pour la même entité. Le ministère calcule à partir de ses propres registres. Si les deux divergent, la cause est presque toujours dans les données : un code enregistré différemment dans Qiwa et dans votre SIRH, ou une agence rattachée à une autre entité.

Dépannage

Qiwa affiche plus de salariés dans le périmètre que votre export. Cherchez d'abord le personnel d'entrepôt et de logistique. Ce sont les six codes que votre logique de 2023 ne connaît pas.

Un acheteur saoudien n'est pas compté. Vérifiez le code enregistré. Un Saoudien qui dirige les achats sous un code administratif générique ne compte pas, quel que soit son vrai travail. Le constat title-mismatch avec saudi: true correspond à ce cas.

Les chiffres ont bondi dans votre rapport de juin 2026. C'est la fonction qui passe de la règle à 50 % à celle à 70 % le 31 mai, et les six nouveaux codes qui entrent au dénominateur le même jour.

Vous suivez plusieurs décisions et les effectifs semblent doublés. Chaque salarié doit être évalué selon une seule règle à une date donnée. Utilisez ruleFor pour attribuer la règle par salarié, puis regroupez par règle avant d'appeler assessEntity.

L'exemple du guide dit 29 recrutements, votre module dit 96. Les deux sont justes pour des mouvements différents. 29, c'est l'écart si 29 non-Saoudiens quittent ces postes. 96, c'est le chiffre si personne ne part. La plupart des plans réels mélangent les deux ; calculez les deux et chiffrez le mélange.

Pour aller plus loin

Conclusion

Le chiffre de 70 % fait le titre, mais ce n'est pas là que les systèmes se trompent. Ils se trompent sur la liste (douze codes désormais, dont la moitié en entrepôt et logistique plutôt qu'aux achats), sur les anciens codes à sept chiffres qui ont peut-être été migrés, sur un décompte par agence au lieu de l'établissement, et sur les salariés dont l'intitulé et le travail réel ne concordent pas. Chacun de ces points tient en quelques lignes de code et un test, et la comparaison de l'étape 6 vous montre, sur vos propres données, lesquels vous concernent.

La période de grâce est terminée : chaque semaine hors conformité est une semaine d'exposition. Corriger les enregistrements dans Qiwa ne coûte rien et peut changer le décompte avant tout recrutement.

Si vous voulez que ce contrôle soit branché sur votre SIRH et exécuté avant chaque recrutement, réservez une séance de diagnostic gratuite et nous examinerons vos données avec vous à la lumière du guide 2026.

Envoyez-nous votre projet

Nous répondons sous un jour ouvré.