@proconnect-gouv/proconnect.identite 1.1.0 → 1.2.0

package/src/managers/certification/certification-score.test.ts

@@ -0,0 +1,309 @@
+//
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { certificationScore } from "./certification-score.js";
+
+//
+
+describe("certification scoring", () => {
+  it("perfect match - all 5 criteria", () => {
+    // All criteria match: family name, first name, gender, birthdate, birthplace
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      5,
+    );
+  });
+
+  it("family name mismatch", () => {
+    // Different family name = -1 point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "DuMoulin",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      4,
+    );
+  });
+
+  it("different birthdate", () => {
+    // Different birthdate = -1 point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1986-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      4,
+    );
+  });
+
+  it("different birthplace", () => {
+    // Different birthplace = -1 point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "13001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      4,
+    );
+  });
+
+  it("swapped first and family names", () => {
+    // Both names don't match = -2 points
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Stéphane",
+          gender: "male",
+          given_name: "Bernard",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      3,
+    );
+  });
+
+  it("different gender still matches when source gender is null", () => {
+    // Gender is null in source = still gets point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: null,
+          given_name: "Stéphane",
+        },
+      ),
+      5,
+    );
+  });
+
+  it("different gender when source has gender", () => {
+    // Different gender = -1 point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "female",
+          given_name: "Stéphane",
+        },
+      ),
+      4,
+    );
+  });
+
+  it("matches first name with hyphen normalization", () => {
+    // Jean-Pierre and Jean Pierre should match (first name is "Jean")
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Jean-Pierre",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Jean Marc",
+        },
+      ),
+      5,
+    );
+  });
+
+  it("birthplace with commune code conversion", () => {
+    // 75050 should convert to 92050
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75050",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "92050",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      5,
+    );
+  });
+
+  it("null birthplace in source still matches", () => {
+    // Null birthplace in source = still gets point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: "75001",
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+        {
+          birthcountry: null,
+          birthdate: new Date("1946-08-17"),
+          birthplace: null,
+          family_name: "Bernard",
+          gender: "male",
+          given_name: "Stéphane",
+        },
+      ),
+      5,
+    );
+  });
+
+  it("foreign person with matching country", () => {
+    // For foreigners, check country code
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: "99136",
+          birthdate: new Date("1946-08-17"),
+          birthplace: null,
+          family_name: "O'Connor",
+          gender: "male",
+          given_name: "Patrick",
+        },
+        {
+          birthcountry: "99136",
+          birthdate: new Date("1946-08-17"),
+          birthplace: null,
+          family_name: "O'Connor",
+          gender: "male",
+          given_name: "Patrick",
+        },
+      ),
+      5,
+    );
+  });
+
+  it("foreign person with different country", () => {
+    // Different country = -1 point
+    assert.equal(
+      certificationScore(
+        {
+          birthcountry: "99136", // Ireland
+          birthdate: new Date("1946-08-17"),
+          birthplace: null,
+          family_name: "O'Connor",
+          gender: "male",
+          given_name: "Patrick",
+        },
+        {
+          birthcountry: "99132", // UK
+          birthdate: new Date("1946-08-17"),
+          birthplace: null,
+          family_name: "O'Connor",
+          gender: "male",
+          given_name: "Patrick",
+        },
+      ),
+      4,
+    );
+  });
+});

package/src/managers/certification/certification-score.ts

@@ -0,0 +1,97 @@
+//
+
+import type { IdentityVector } from "#src/types";
+import { convertCommuneCode } from "./birthplace-conversion.js";
+import { extractFirstName, normalizeText } from "./normalize.js";
+
+//
+
+/**
+ * Calculates a certification score between identity from FranceConnect (IdentitePivot)
+ * and executive identity from business registries (SourceDirigeant).
+ *
+ * The scoring system awards 1 point for each matching criterion:
+ * - Family name (after normalization): 1 point
+ * - First name (first name only, after normalization): 1 point
+ * - Gender (match or absent in source): 1 point
+ * - Birth date (exact match): 1 point
+ * - Birth place:
+ *   - For French (birthcountry = 99100 or null): commune match or absent in source: 1 point
+ *   - For foreigners: country match: 1 point
+ *
+ * Maximum score: 5 points (required for certification)
+ *
+ * @param identitePivot - Identity from FranceConnect
+ * @param sourceDirigeant - Executive identity from business registry
+ * @returns Score from 0 to 5
+ */
+export function certificationScore(
+  identitePivot: IdentityVector,
+  sourceDirigeant: IdentityVector,
+): number {
+  let score = 0;
+
+  // 1. Family name match (after normalization)
+  const normalizedFamilyNamePivot = normalizeText(identitePivot.family_name);
+  const normalizedFamilyNameSource = normalizeText(sourceDirigeant.family_name);
+
+  if (
+    normalizedFamilyNamePivot &&
+    normalizedFamilyNameSource &&
+    normalizedFamilyNamePivot === normalizedFamilyNameSource
+  ) {
+    score += 1;
+  }
+
+  // 2. First name match (first name only, after normalization)
+  const firstNamePivot = extractFirstName(identitePivot.given_name);
+  const firstNameSource = extractFirstName(sourceDirigeant.given_name);
+
+  if (firstNamePivot && firstNameSource && firstNamePivot === firstNameSource) {
+    score += 1;
+  }
+
+  // 3. Gender match (match or absent in source)
+  if (
+    !sourceDirigeant.gender ||
+    identitePivot.gender === sourceDirigeant.gender
+  ) {
+    score += 1;
+  }
+
+  // 4. Birth date match (exact match)
+  if (
+    identitePivot.birthdate &&
+    sourceDirigeant.birthdate &&
+    identitePivot.birthdate.getTime() === sourceDirigeant.birthdate.getTime()
+  ) {
+    score += 1;
+  }
+
+  // 5. Birth place match (different logic for French vs foreigners)
+  const isFrench =
+    !identitePivot.birthcountry || identitePivot.birthcountry === "99100";
+
+  if (isFrench) {
+    // For French: check commune code (with conversion)
+    const communePivot = convertCommuneCode(identitePivot.birthplace);
+    const communeSource = convertCommuneCode(sourceDirigeant.birthplace);
+
+    // Match if equal or if source has no commune data
+    if (!communeSource || (communePivot && communePivot === communeSource)) {
+      score += 1;
+    }
+  } else {
+    // For foreigners: check country code (with conversion if needed from RNE)
+    // Both should already be in COG format (99XXX)
+    if (
+      identitePivot.birthcountry &&
+      sourceDirigeant.birthcountry &&
+      identitePivot.birthcountry === sourceDirigeant.birthcountry
+    ) {
+      score += 1;
+    }
+  }
+
+  return score;
+}

package/src/managers/certification/index.ts

@@ -1,4 +1,4 @@
 //
 
-export * from "./distance.js";
+export * from "./certification-score.js";
 export * from "./is-organization-dirigeant.js";

package/src/managers/certification/is-organization-dirigeant.test.ts

@@ -1,19 +1,27 @@
 //
 
-import { NotFoundError } from "#src/errors";
+import { InvalidCertificationError, NotFoundError } from "#src/errors";
+import { IdentityVectorSchema } from "#src/types";
 import {
   LiElJonsonFranceConnectUserInfo,
   RogalDornFranceConnectUserInfo,
 } from "#testing/seed/franceconnect";
+import {
+  papillon_org_info,
+  rogal_dorn_org_info,
+} from "#testing/seed/organizations";
+import {
+  RogalDornMandataire,
+  UlysseToriMandataire,
+} from "@proconnect-gouv/proconnect.api_entreprise/testing/seed/v3-infogreffe-rcs-unites_legales-siren-mandataires_sociaux";
 import {
   LiElJonsonEstablishment,
   RogalDornEstablishment,
-} from "#testing/seed/insee";
-import { UlysseToriMandataire } from "#testing/seed/mandataires";
+} from "@proconnect-gouv/proconnect.insee/testing/seed";
 import {
-  Papillon,
-  RogalDornEntrepreneur as RogalDornSireneEntrepreneur,
-} from "@proconnect-gouv/proconnect.api_entreprise/testing/seed/insee/siret";
+  RogalDornPouvoir,
+  UlysseTosiPouvoir,
+} from "@proconnect-gouv/proconnect.registre_national_entreprises/testing/seed";
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { isOrganizationDirigeantFactory } from "./is-organization-dirigeant.js";
@@ -26,20 +34,33 @@ describe("isOrganizationDirigeantFactory", () => {
       ApiEntrepriseInfogreffeRepository: {
         findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
       },
-      ApiEntrepriseInseeRepository: {
-        findBySiret: () => Promise.resolve(RogalDornSireneEntrepreneur),
+      RegistreNationalEntreprisesApiRepository: {
+        findPouvoirsBySiren: () => Promise.reject(new Error("💣")),
       },
       InseeApiRepository: {
-        findBySiret: () => Promise.resolve(RogalDornEstablishment),
+        findBySiren: () => Promise.resolve(RogalDornEstablishment),
+      },
+      FranceConnectApiRepository: {
+        getFranceConnectUserInfo: () =>
+          Promise.resolve(RogalDornFranceConnectUserInfo),
       },
-      getFranceConnectUserInfo: () =>
-        Promise.resolve(RogalDornFranceConnectUserInfo),
     });
-    const isDirigeant = await isOrganizationDirigeant(
-      RogalDornSireneEntrepreneur.siret,
-      1,
-    );
-    assert.equal(isDirigeant, true);
+
+    const isDirigeant = await isOrganizationDirigeant(rogal_dorn_org_info, 1);
+
+    assert.deepEqual(isDirigeant, {
+      cause: "exact_match",
+      details: {
+        dirigeant: {
+          ...IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+          birthplace: null, // INSEE adapter returns null for foreigners
+        },
+        score: 5,
+        identity: IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+        source: "api.insee.fr/api-sirene/private",
+      },
+      ok: true,
+    });
   });
 
   it("should not match another mandataire", async () => {
@@ -47,39 +68,105 @@ describe("isOrganizationDirigeantFactory", () => {
       ApiEntrepriseInfogreffeRepository: {
         findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
       },
-      ApiEntrepriseInseeRepository: {
-        findBySiret: () => Promise.resolve(RogalDornSireneEntrepreneur),
+      RegistreNationalEntreprisesApiRepository: {
+        findPouvoirsBySiren: () => Promise.reject(new Error("💣")),
       },
       InseeApiRepository: {
-        findBySiret: () => Promise.resolve(LiElJonsonEstablishment),
+        findBySiren: () => Promise.resolve(LiElJonsonEstablishment),
+      },
+      FranceConnectApiRepository: {
+        getFranceConnectUserInfo: () =>
+          Promise.resolve(RogalDornFranceConnectUserInfo),
       },
-      getFranceConnectUserInfo: () =>
-        Promise.resolve(RogalDornFranceConnectUserInfo),
     });
-    const isDirigeant = await isOrganizationDirigeant(
-      RogalDornSireneEntrepreneur.siret,
-      1,
-    );
-    assert.equal(isDirigeant, false);
+
+    const isDirigeant = await isOrganizationDirigeant(rogal_dorn_org_info, 1);
+
+    assert.deepEqual(isDirigeant, {
+      cause: "below_threshold",
+      details: {
+        dirigeant: {
+          ...IdentityVectorSchema.parse(LiElJonsonFranceConnectUserInfo),
+          birthcountry: null, // INSEE adapter returns null for French people
+        },
+        score: 1,
+        identity: IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+        source: "api.insee.fr/api-sirene/private",
+      },
+      ok: false,
+    });
   });
 
-  it("should match Ulysse Tori as an executive of Papillon", async () => {
+  it("should match Rogal Dorn among the executive of Papillon in RNE", async () => {
+    const isOrganizationDirigeant = isOrganizationDirigeantFactory({
+      ApiEntrepriseInfogreffeRepository: {
+        findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
+      },
+      RegistreNationalEntreprisesApiRepository: {
+        findPouvoirsBySiren: () =>
+          Promise.resolve([UlysseTosiPouvoir, RogalDornPouvoir]),
+      },
+      InseeApiRepository: {
+        findBySiren: () => Promise.reject(new Error("💣")),
+      },
+      FranceConnectApiRepository: {
+        getFranceConnectUserInfo: () =>
+          Promise.resolve(RogalDornFranceConnectUserInfo),
+      },
+    });
+
+    const isDirigeant = await isOrganizationDirigeant(papillon_org_info, 1);
+
+    assert.deepEqual(isDirigeant, {
+      cause: "exact_match",
+      details: {
+        dirigeant: {
+          ...IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+          birthplace: null, // RNE adapter returns null for foreigners
+        },
+        score: 5,
+        identity: IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+        source: "registre-national-entreprises.inpi.fr/api",
+      },
+      ok: true,
+    });
+  });
+
+  it("should match Rogal Dorn among the executive of Papillon in Infogreffe", async () => {
     const isOrganizationDirigeant = isOrganizationDirigeantFactory({
       ApiEntrepriseInfogreffeRepository: {
         findMandatairesSociauxBySiren: () =>
-          Promise.resolve([UlysseToriMandataire]),
+          Promise.resolve([UlysseToriMandataire, RogalDornMandataire]),
       },
-      ApiEntrepriseInseeRepository: {
-        findBySiret: () => Promise.resolve(Papillon),
+      RegistreNationalEntreprisesApiRepository: {
+        findPouvoirsBySiren: () => Promise.reject(new Error("💣")),
       },
       InseeApiRepository: {
-        findBySiret: () => Promise.reject(new Error("💣")),
+        findBySiren: () => Promise.reject(new Error("💣")),
+      },
+      FranceConnectApiRepository: {
+        getFranceConnectUserInfo: () =>
+          Promise.resolve(RogalDornFranceConnectUserInfo),
       },
-      getFranceConnectUserInfo: () =>
-        Promise.resolve(RogalDornFranceConnectUserInfo),
     });
-    const isDirigeant = await isOrganizationDirigeant(Papillon.siret, 1);
-    assert.equal(isDirigeant, false);
+
+    const isDirigeant = await isOrganizationDirigeant(papillon_org_info, 1);
+
+    assert.deepEqual(isDirigeant, {
+      cause: "exact_match",
+      details: {
+        dirigeant: {
+          ...IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+          birthplace: null, // API Entreprise adapter doesn't provide birthplace
+          gender: null, // API Entreprise adapter doesn't provide gender
+        },
+        score: 5,
+        identity: IdentityVectorSchema.parse(RogalDornFranceConnectUserInfo),
+        source:
+          "entreprise.api.gouv.fr/v3/infogreffe/rcs/unites_legales/{siren}/mandataires_sociaux",
+      },
+      ok: true,
+    });
   });
 
   it("❎ fail with no franceconnect user info", async () => {
@@ -87,17 +174,19 @@ describe("isOrganizationDirigeantFactory", () => {
       ApiEntrepriseInfogreffeRepository: {
         findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
       },
-      ApiEntrepriseInseeRepository: {
-        findBySiret: () => Promise.resolve(RogalDornSireneEntrepreneur),
+      RegistreNationalEntreprisesApiRepository: {
+        findPouvoirsBySiren: () => Promise.reject(new Error("💣")),
       },
       InseeApiRepository: {
-        findBySiret: () => Promise.reject(new Error("💣")),
+        findBySiren: () => Promise.reject(new Error("💣")),
+      },
+      FranceConnectApiRepository: {
+        getFranceConnectUserInfo: () => Promise.resolve(undefined),
       },
-      getFranceConnectUserInfo: () => Promise.resolve(undefined),
     });
 
     await assert.rejects(
-      isOrganizationDirigeant("94957325700019", 1),
+      isOrganizationDirigeant(rogal_dorn_org_info, 1),
       new NotFoundError("FranceConnect UserInfo not found"),
     );
   });
@@ -105,21 +194,23 @@ describe("isOrganizationDirigeantFactory", () => {
   it("❎ fail with no mandataires", async () => {
     const isOrganizationDirigeant = isOrganizationDirigeantFactory({
       ApiEntrepriseInfogreffeRepository: {
-        findMandatairesSociauxBySiren: () => Promise.resolve([]),
+        findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
       },
-      ApiEntrepriseInseeRepository: {
-        findBySiret: () => Promise.resolve(Papillon),
+      RegistreNationalEntreprisesApiRepository: {
+        findPouvoirsBySiren: () => Promise.resolve([]),
       },
       InseeApiRepository: {
-        findBySiret: () => Promise.reject(new Error("💣")),
+        findBySiren: () => Promise.reject(new Error("💣")),
+      },
+      FranceConnectApiRepository: {
+        getFranceConnectUserInfo: () =>
+          Promise.resolve(LiElJonsonFranceConnectUserInfo),
       },
-      getFranceConnectUserInfo: () =>
-        Promise.resolve(LiElJonsonFranceConnectUserInfo),
     });
 
     await assert.rejects(
-      isOrganizationDirigeant(Papillon.siret, 1),
-      new NotFoundError("No mandataires found"),
+      isOrganizationDirigeant(papillon_org_info, 1),
+      new InvalidCertificationError("No candidates found"),
     );
   });
 });