@proconnect-gouv/proconnect.identite 1.1.0 → 1.2.0

package/src/managers/certification/adapters/insee.test.ts.snapshot

@@ -0,0 +1,21 @@
+exports[`toIdentityVector > LiElJonsonEstablishment 1`] = `
+{
+  "birthcountry": null,
+  "birthdate": "+028500-02-05T00:00:00.000Z",
+  "birthplace": "75056",
+  "family_name": "EL'JONSON",
+  "gender": "male",
+  "given_name": "LION"
+}
+`;
+
+exports[`toIdentityVector > RogalDornEstablishment 1`] = `
+{
+  "birthcountry": "99102",
+  "birthdate": "+029000-01-07T00:00:00.000Z",
+  "birthplace": null,
+  "family_name": "DORN",
+  "gender": "male",
+  "given_name": "ROGAL"
+}
+`;

package/src/managers/certification/adapters/insee.ts

@@ -0,0 +1,39 @@
+import type { IdentityVector } from "#src/types";
+import { formatBirthdate } from "@proconnect-gouv/proconnect.insee/formatters";
+import type { InseSirenUniteLegale } from "@proconnect-gouv/proconnect.insee/types";
+import { match } from "ts-pattern";
+
+//
+
+export function toIdentityVector(
+  uniteLegale: InseSirenUniteLegale,
+): IdentityVector {
+  let birthdate: Date | null = null;
+  const nomUniteLegale = uniteLegale.periodesUniteLegale?.at(0)?.nomUniteLegale;
+
+  if (uniteLegale?.dateNaissanceUniteLegale) {
+    const parsedDate = formatBirthdate(
+      String(uniteLegale.dateNaissanceUniteLegale),
+    );
+    birthdate = isNaN(parsedDate.getTime()) ? null : parsedDate;
+  }
+
+  return {
+    birthcountry: uniteLegale?.codePaysNaissanceUniteLegale ?? null,
+    birthdate,
+    birthplace: uniteLegale?.codeCommuneNaissanceUniteLegale ?? null,
+    family_name: nomUniteLegale ?? null,
+    gender: match(uniteLegale?.sexeUniteLegale)
+      .with("M", () => "male" as const)
+      .with("F", () => "female" as const)
+      .otherwise(() => null),
+    given_name: [
+      uniteLegale?.prenom1UniteLegale,
+      uniteLegale?.prenom2UniteLegale,
+      uniteLegale?.prenom3UniteLegale,
+      uniteLegale?.prenom4UniteLegale,
+    ]
+      .filter(Boolean)
+      .join(" "),
+  };
+}

package/src/managers/certification/adapters/rne.test.ts

@@ -0,0 +1,276 @@
+//
+
+import {
+  RogalDornPouvoir,
+  UlysseTosiPouvoir,
+} from "@proconnect-gouv/proconnect.registre_national_entreprises/testing/seed";
+import assert from "node:assert/strict";
+import { suite, test } from "node:test";
+import { toIdentityVector } from "./rne.js";
+
+suite("RNE adapter - toIdentityVector", () => {
+  test("converts valid pouvoir with all fields", () => {
+    const result = toIdentityVector(UlysseTosiPouvoir);
+
+    assert.deepEqual(result, {
+      birthcountry: "99100",
+      birthdate: new Date(Date.UTC(1992, 8, 7)), // September (month 8) 7, 1992
+      birthplace: "13055",
+      family_name: "TOSI",
+      gender: "male",
+      given_name: "Ulysse",
+    });
+  });
+
+  test("converts pouvoir with multiple prenoms", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1985-06-15",
+          lieuDeNaissance: "Paris",
+          nom: "DUPONT",
+          prenoms: ["Jean", "Paul", "Marie"],
+          genre: "1",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+
+    assert.equal(result.given_name, "Jean Paul Marie");
+    assert.equal(result.family_name, "DUPONT");
+    assert.equal(result.gender, "male");
+  });
+
+  test("handles invalid date format - returns null birthdate", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "invalid-date",
+          lieuDeNaissance: "Lyon",
+          nom: "MARTIN",
+          prenoms: ["Alice"],
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+
+    assert.equal(result.birthdate, null);
+    assert.equal(result.family_name, "MARTIN");
+  });
+
+  test("handles missing optional fields - returns null", () => {
+    const result = toIdentityVector({});
+
+    assert.deepEqual(result, {
+      birthcountry: null,
+      birthdate: null,
+      birthplace: null,
+      family_name: null,
+      gender: null,
+      given_name: null,
+    });
+  });
+
+  test("handles empty prenoms array", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Marseille",
+          nom: "BERNARD",
+          prenoms: [],
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+
+    assert.equal(result.given_name, "");
+    assert.equal(result.family_name, "BERNARD");
+  });
+
+  test("handles far future date (RogalDorn from year 29000)", () => {
+    const result = toIdentityVector(RogalDornPouvoir);
+
+    // Year 29000 should be parsed correctly
+    assert.deepEqual(result, {
+      birthcountry: "99102", // ISL (Iceland) converts to 99102
+      birthdate: new Date(Date.UTC(29000, 0, 7)), // January 7, 29000
+      birthplace: null,
+      family_name: "DORN",
+      gender: "male",
+      given_name: "ROGAL",
+    });
+  });
+
+  test("handles partial date components", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "2000-12-31",
+          lieuDeNaissance: "Bordeaux",
+          nom: "LAURENT",
+          prenoms: ["Sophie"],
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+
+    assert.deepEqual(result.birthdate, new Date(Date.UTC(2000, 11, 31))); // December 31, 2000
+  });
+
+  test("handles undefined individu fields gracefully", () => {
+    const pouvoir = {};
+
+    const result = toIdentityVector(pouvoir);
+
+    assert.deepEqual(result, {
+      birthcountry: null,
+      birthdate: null,
+      birthplace: null,
+      family_name: null,
+      gender: null,
+      given_name: null,
+    });
+  });
+
+  test("maps genre 1 to male", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Paris",
+          nom: "DUPONT",
+          prenoms: ["Jean"],
+          genre: "1",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.gender, "male");
+  });
+
+  test("maps genre 2 to female", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Paris",
+          nom: "MARTIN",
+          prenoms: ["Marie"],
+          genre: "2",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.gender, "female");
+  });
+
+  test("returns null for unknown genre", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Paris",
+          nom: "BERNARD",
+          prenoms: ["Alex"],
+          genre: "3",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.gender, null);
+  });
+
+  test("ignores codeInseeGeographique when codePostalNaissance is missing", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Lyon",
+          nom: "DUPONT",
+          prenoms: ["Jean"],
+          codeInseeGeographique: "69123",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.birthplace, null);
+  });
+
+  test("ignores codeInseeGeographique when format is invalid", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Lyon",
+          nom: "DUPONT",
+          prenoms: ["Jean"],
+          codeInseeGeographique: "1234", // Invalid: only 4 digits
+          codePostalNaissance: "69001",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.birthplace, null);
+  });
+
+  test("ignores codeInseeGeographique when it starts with 99 (foreign country)", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Foreign",
+          nom: "DUPONT",
+          prenoms: ["Jean"],
+          codeInseeGeographique: "99123", // Foreign country code
+          codePostalNaissance: "69001",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.birthplace, null);
+  });
+
+  test("converts codePaysNaissance from ISO 3166 to COG format", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          lieuDeNaissance: "Dublin",
+          nom: "O'CONNOR",
+          prenoms: ["Sean"],
+          codePaysNaissance: "IRL",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.birthcountry, "99136");
+  });
+
+  test("returns null for birthcountry when codePaysNaissance is invalid", () => {
+    const pouvoir = {
+      individu: {
+        descriptionPersonne: {
+          dateDeNaissance: "1990-01-01",
+          nom: "DUPONT",
+          prenoms: ["Jean"],
+          codePaysNaissance: "XXX",
+        },
+      },
+    };
+
+    const result = toIdentityVector(pouvoir);
+    assert.equal(result.birthcountry, null);
+  });
+});

package/src/managers/certification/adapters/rne.ts

@@ -0,0 +1,64 @@
+import type { IdentityVector } from "#src/types";
+import type { FindPouvoirsBySirenHandler } from "@proconnect-gouv/proconnect.registre_national_entreprises/api";
+import { match } from "ts-pattern";
+import {
+  convertCountryIsoToCog,
+  isValidBirthplaceFormat,
+} from "../birthplace-conversion.js";
+
+//
+
+export function toIdentityVector(
+  pouvoir: NonNullable<Awaited<ReturnType<FindPouvoirsBySirenHandler>>[number]>,
+): IdentityVector {
+  const descriptionPersonne = pouvoir.individu?.descriptionPersonne;
+
+  const dateMatch = String(descriptionPersonne?.dateDeNaissance).match(
+    /^(?<year>\d+)-(?<month>\d{2})-(?<day>\d{2})$/,
+  );
+  const { day, month, year } = dateMatch?.groups ?? {
+    day: NaN,
+    month: NaN,
+    year: NaN,
+  };
+  const date = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day)));
+  const birthdate = isNaN(date.getTime()) ? null : date;
+
+  // For RNE:
+  // birthplace: Use codeInseeGeographique only if:
+  //   - codePostalNaissance is present
+  //   - codeInseeGeographique has valid format (5 digits or 2A/2B + 3 digits)
+  //   - first 2 chars are not "99" (not a foreign country code)
+  let birthplace: string | null = null;
+  const codeInseeGeographique = descriptionPersonne?.codeInseeGeographique;
+  const codePostalNaissance = descriptionPersonne?.codePostalNaissance;
+
+  if (
+    codePostalNaissance &&
+    codeInseeGeographique &&
+    isValidBirthplaceFormat(codeInseeGeographique) &&
+    !codeInseeGeographique.startsWith("99")
+  ) {
+    birthplace = codeInseeGeographique;
+  }
+
+  // birthcountry: Convert paysNaissance from ISO 3166 to COG format
+  let birthcountry: string | null = null;
+  const codePaysNaissance = descriptionPersonne?.codePaysNaissance;
+
+  if (codePaysNaissance) {
+    birthcountry = convertCountryIsoToCog(codePaysNaissance);
+  }
+
+  return {
+    birthcountry,
+    birthdate,
+    birthplace,
+    family_name: descriptionPersonne?.nom ?? null,
+    gender: match(descriptionPersonne?.genre)
+      .with("1", () => "male" as const)
+      .with("2", () => "female" as const)
+      .otherwise(() => null),
+    given_name: descriptionPersonne?.prenoms?.join(" ") ?? null,
+  };
+}

package/src/managers/certification/birthplace-conversion.test.ts

@@ -0,0 +1,76 @@
+//
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import {
+  convertCommuneCode,
+  convertCountryIsoToCog,
+  isValidBirthplaceFormat,
+} from "./birthplace-conversion.js";
+
+//
+
+describe("convertCommuneCode", () => {
+  it("converts old commune code to new code", () => {
+    assert.equal(convertCommuneCode("75050"), "92050");
+  });
+
+  it("returns original code if no conversion exists", () => {
+    assert.equal(convertCommuneCode("75056"), "75056");
+  });
+
+  it("handles null and undefined", () => {
+    assert.equal(convertCommuneCode(null), null);
+    assert.equal(convertCommuneCode(undefined), null);
+  });
+});
+
+describe("convertCountryIsoToCog", () => {
+  it("converts France", () => {
+    assert.equal(convertCountryIsoToCog("FRA"), "99100");
+  });
+
+  it("converts Ireland", () => {
+    assert.equal(convertCountryIsoToCog("IRL"), "99136");
+  });
+
+  it("converts Iceland with 2-letter code", () => {
+    assert.equal(convertCountryIsoToCog("IS"), "99102");
+  });
+
+  it("handles lowercase", () => {
+    assert.equal(convertCountryIsoToCog("fra"), "99100");
+  });
+
+  it("returns null for unknown country", () => {
+    assert.equal(convertCountryIsoToCog("XXX"), null);
+  });
+
+  it("handles null and undefined", () => {
+    assert.equal(convertCountryIsoToCog(null), null);
+    assert.equal(convertCountryIsoToCog(undefined), null);
+  });
+});
+
+describe("isValidBirthplaceFormat", () => {
+  it("validates 5-digit codes", () => {
+    assert.equal(isValidBirthplaceFormat("75001"), true);
+    assert.equal(isValidBirthplaceFormat("92050"), true);
+  });
+
+  it("validates Corsican codes (2A/2B)", () => {
+    assert.equal(isValidBirthplaceFormat("2A001"), true);
+    assert.equal(isValidBirthplaceFormat("2B042"), true);
+  });
+
+  it("rejects invalid formats", () => {
+    assert.equal(isValidBirthplaceFormat("1234"), false);
+    assert.equal(isValidBirthplaceFormat("123456"), false);
+    assert.equal(isValidBirthplaceFormat("ABC12"), false);
+  });
+
+  it("handles null and undefined", () => {
+    assert.equal(isValidBirthplaceFormat(null), false);
+    assert.equal(isValidBirthplaceFormat(undefined), false);
+  });
+});

package/src/managers/certification/birthplace-conversion.ts

@@ -0,0 +1,58 @@
+//
+
+import {
+  COMMUNE_CODE_CONVERSION,
+  COUNTRY_ISO_TO_COG,
+} from "#src/data/certification";
+
+/**
+ * Converts a commune code to a canonical representation,
+ * ensuring consistency across historical and current versions.
+ * If the code is not in the conversion table, returns the original code.
+ *
+ * @param communeCode - The commune code to convert (format: XXXXX or 2AXXX or 2BXXX)
+ * @returns The converted code, or the original if no conversion is needed
+ */
+export function convertCommuneCode(
+  communeCode: string | null | undefined,
+): string | null {
+  if (!communeCode) return null;
+
+  // Check if the code needs conversion
+  const converted = COMMUNE_CODE_CONVERSION[communeCode];
+  return converted || communeCode;
+}
+
+/**
+ * Converts an ISO 3166 country code (2 or 3-letter) to COG format (5-digit).
+ *
+ * @param iso3166Code - The ISO 3166 country code (e.g., "IRL", "FRA")
+ * @returns The COG code (e.g., "99136"), or null if not found
+ */
+export function convertCountryIsoToCog(
+  iso3166Code: string | null | undefined,
+): string | null {
+  if (!iso3166Code) return null;
+
+  const cogCode = COUNTRY_ISO_TO_COG[iso3166Code.toUpperCase()];
+  return cogCode || null;
+}
+
+/**
+ * Validates if a birthplace code has the correct COG format.
+ * Valid formats:
+ * - 5 digits (e.g., "75001")
+ * - 2A or 2B + 3 digits (e.g., "2A001", "2B042" for Corsica)
+ *
+ * @param birthplaceCode - The birthplace code to validate
+ * @returns true if the format is valid, false otherwise
+ */
+export function isValidBirthplaceFormat(
+  birthplaceCode: string | null | undefined,
+): boolean {
+  if (!birthplaceCode) return false;
+
+  // Match either 5 digits or 2A/2B + 3 digits
+  const validFormat = /^(\d{5}|2[AB]\d{3})$/;
+  return validFormat.test(birthplaceCode);
+}