@proconnect-gouv/proconnect.identite 1.0.0

package/src/managers/organization/get-organization-info.ts

@@ -0,0 +1,58 @@
+//
+
+import { InvalidSiretError, NotFoundError } from "#src/errors";
+import { OrganizationInfoMapper } from "#src/mappers";
+import { type OrganizationInfo } from "#src/types";
+import type { EntrepriseApiInseeRepository } from "@proconnect-gouv/proconnect.entreprise/api";
+import {
+  EntrepriseApiConnectionError,
+  EntrepriseApiInvalidSiret,
+} from "@proconnect-gouv/proconnect.entreprise/types";
+
+//
+
+export function getOrganizationInfoFactory(
+  config: EntrepriseApiInseeRepository,
+) {
+  const { findBySiren, findBySiret } = config;
+
+  return async function getOrganizationInfo(
+    siretOrSiren: string,
+  ): Promise<OrganizationInfo> {
+    try {
+      let establishment: OrganizationInfo;
+
+      if (siretOrSiren.match(/^\d{14}$/)) {
+        establishment = OrganizationInfoMapper.fromSiret(
+          await findBySiret(siretOrSiren),
+        );
+      } else if (siretOrSiren.match(/^\d{9}$/)) {
+        establishment = OrganizationInfoMapper.fromSiret(
+          await findBySiren(siretOrSiren),
+        );
+      } else {
+        throw new InvalidSiretError();
+      }
+
+      const { statutDiffusion } = establishment;
+
+      if (statutDiffusion === "non_diffusible") {
+        throw new NotFoundError();
+      }
+
+      return establishment;
+    } catch (e) {
+      if (EntrepriseApiInvalidSiret.isInvalidSiret(e))
+        throw new InvalidSiretError();
+
+      throw new EntrepriseApiConnectionError(
+        "unknown error while fetching entreprise.api.gouv.fr",
+        { cause: e },
+      );
+    }
+  };
+}
+
+export type GetOrganizationInfoHandler = ReturnType<
+  typeof getOrganizationInfoFactory
+>;

package/src/managers/organization/index.ts

@@ -0,0 +1,5 @@
+//
+
+export * from "./force-join-organization.js";
+export * from "./get-organization-info.js";
+export * from "./mark-domain-as-verified.js";

package/src/managers/organization/mark-domain-as-verified.test.ts

@@ -0,0 +1,90 @@
+import { NotFoundError } from "#src/errors";
+import {
+  type AddDomainHandler,
+  type DeleteEmailDomainsByVerificationTypesHandler,
+} from "#src/repositories/email-domain";
+import type {
+  FindByIdHandler,
+  GetUsersByOrganizationHandler,
+} from "#src/repositories/organization";
+import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
+import type { BaseUserOrganizationLink, Organization, User } from "#src/types";
+import assert from "node:assert/strict";
+import { describe, it, mock } from "node:test";
+import { markDomainAsVerifiedFactory } from "./mark-domain-as-verified.js";
+
+//
+
+describe("markDomainAsVerified", () => {
+  it("should update organization members", async (t) => {
+    const addDomain = mock.fn<AddDomainHandler>(() =>
+      Promise.resolve({} as any),
+    );
+    const deleteEmailDomainsByVerificationTypes =
+      mock.fn<DeleteEmailDomainsByVerificationTypesHandler>(() =>
+        Promise.resolve({} as any),
+      );
+    const updateUserOrganizationLink =
+      mock.fn<UpdateUserOrganizationLinkHandler>(() =>
+        Promise.resolve({} as any),
+      );
+
+    const markDomainAsVerified = markDomainAsVerifiedFactory({
+      addDomain,
+      deleteEmailDomainsByVerificationTypes,
+      findOrganizationById: mock.fn<FindByIdHandler>(() =>
+        Promise.resolve({ id: 42 } as Organization),
+      ),
+      getUsers: mock.fn<GetUsersByOrganizationHandler>(() =>
+        Promise.resolve([
+          {
+            id: 42,
+            email: "lion.eljonson@darkangels.world",
+            verification_type: null,
+          } as User & BaseUserOrganizationLink,
+        ]),
+      ),
+      updateUserOrganizationLink,
+    });
+
+    await markDomainAsVerified({
+      domain: "darkangels.world",
+      domain_verification_type: "verified",
+      organization_id: 42,
+    });
+
+    await t.test("should call updateUserOrganizationLink with", async (t) => {
+      t.assert.snapshot(updateUserOrganizationLink.mock.calls);
+    });
+
+    await t.test(
+      "should call deleteEmailDomainsByVerificationTypes with",
+      async (t) => {
+        t.assert.snapshot(deleteEmailDomainsByVerificationTypes.mock.calls);
+      },
+    );
+
+    await t.test("should call addDomain with", async (t) => {
+      t.assert.snapshot(addDomain.mock.calls);
+    });
+  });
+
+  it("❎ throws NotFoundError for unknown organization", async () => {
+    const markDomainAsVerified = markDomainAsVerifiedFactory({
+      addDomain: () => Promise.reject(),
+      deleteEmailDomainsByVerificationTypes: () => Promise.reject(),
+      findOrganizationById: () => Promise.resolve(undefined),
+      getUsers: () => Promise.reject(),
+      updateUserOrganizationLink: () => Promise.reject(),
+    });
+
+    await assert.rejects(
+      markDomainAsVerified({
+        domain: "darkangels.world",
+        domain_verification_type: "verified",
+        organization_id: 42,
+      }),
+      new NotFoundError(""),
+    );
+  });
+});

package/src/managers/organization/mark-domain-as-verified.test.ts.snapshot

@@ -0,0 +1,52 @@
+exports[`markDomainAsVerified > should update organization members > should call addDomain with 1`] = `
+[
+  {
+    "arguments": [
+      {
+        "organization_id": 42,
+        "domain": "darkangels.world",
+        "verification_type": "verified"
+      }
+    ],
+    "result": {},
+    "stack": {}
+  }
+]
+`;
+
+exports[`markDomainAsVerified > should update organization members > should call deleteEmailDomainsByVerificationTypes with 1`] = `
+[
+  {
+    "arguments": [
+      {
+        "organization_id": 42,
+        "domain": "darkangels.world",
+        "domain_verification_types": [
+          "official_contact",
+          "trackdechets_postal_mail",
+          "verified",
+          null
+        ]
+      }
+    ],
+    "result": {},
+    "stack": {}
+  }
+]
+`;
+
+exports[`markDomainAsVerified > should update organization members > should call updateUserOrganizationLink with 1`] = `
+[
+  {
+    "arguments": [
+      42,
+      42,
+      {
+        "verification_type": "domain"
+      }
+    ],
+    "result": {},
+    "stack": {}
+  }
+]
+`;

package/src/managers/organization/mark-domain-as-verified.ts

@@ -0,0 +1,140 @@
+//
+
+import { NotFoundError } from "#src/errors";
+import { assignUserVerificationTypeToDomainFactory } from "#src/managers/user";
+import type { GetUsersByOrganizationHandler } from "#src/repositories/organization";
+import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
+import type {
+  AddDomainHandler,
+  DeleteEmailDomainsByVerificationTypesHandler,
+} from "@proconnect-gouv/proconnect.identite/repositories/email-domain";
+import type { FindByIdHandler } from "@proconnect-gouv/proconnect.identite/repositories/organization";
+import {
+  EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES,
+  EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES,
+  type EmailDomainApprovedVerificationType,
+  type EmailDomainRejectedVerificationType,
+  type EmailDomainVerificationType,
+} from "@proconnect-gouv/proconnect.identite/types";
+import { isEmpty } from "lodash-es";
+import { match } from "ts-pattern";
+
+//
+
+type FactoryDependencies = {
+  addDomain: AddDomainHandler;
+  deleteEmailDomainsByVerificationTypes: DeleteEmailDomainsByVerificationTypesHandler;
+  findOrganizationById: FindByIdHandler;
+  getUsers: GetUsersByOrganizationHandler;
+  updateUserOrganizationLink: UpdateUserOrganizationLinkHandler;
+};
+
+export function markDomainAsVerifiedFactory({
+  addDomain,
+  deleteEmailDomainsByVerificationTypes,
+  findOrganizationById,
+  getUsers,
+  updateUserOrganizationLink,
+}: FactoryDependencies) {
+  const assignUserVerificationTypeToDomain =
+    assignUserVerificationTypeToDomainFactory({
+      getUsers,
+      updateUserOrganizationLink,
+    });
+  return async function markDomainAsVerified({
+    organization_id,
+    domain,
+    domain_verification_type,
+  }: {
+    organization_id: number;
+    domain: string;
+    domain_verification_type: NonNullable<EmailDomainVerificationType>;
+  }) {
+    const organization = await findOrganizationById(organization_id);
+
+    if (isEmpty(organization)) {
+      throw new NotFoundError();
+    }
+
+    return match(domain_verification_type)
+      .with(
+        EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES.enum.official_contact,
+        EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES.enum.trackdechets_postal_mail,
+        EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES.enum.verified,
+        ...EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES.options,
+        async (approved_verification_type) => {
+          await assignUserVerificationTypeToDomain(organization_id, domain);
+          return markDomainAsApproved({
+            organization_id,
+            domain,
+            domain_verification_type: approved_verification_type,
+          });
+        },
+      )
+      .with(
+        EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES.enum.blacklisted,
+        EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES.enum.external,
+        EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES.enum.refused,
+        ...EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES.options,
+        (rejected_verification_type) =>
+          markDomainAsRejected({
+            organization_id,
+            domain,
+            domain_verification_type: rejected_verification_type,
+          }),
+      )
+      .exhaustive();
+  };
+
+  async function markDomainAsApproved({
+    organization_id,
+    domain,
+    domain_verification_type,
+  }: {
+    organization_id: number;
+    domain: string;
+    domain_verification_type: EmailDomainApprovedVerificationType;
+  }) {
+    await deleteEmailDomainsByVerificationTypes({
+      organization_id,
+      domain,
+      domain_verification_types: [
+        ...EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES.options,
+        null,
+      ],
+    });
+    return addDomain({
+      organization_id,
+      domain,
+      verification_type: domain_verification_type,
+    });
+  }
+
+  async function markDomainAsRejected({
+    organization_id,
+    domain,
+    domain_verification_type,
+  }: {
+    organization_id: number;
+    domain: string;
+    domain_verification_type: EmailDomainRejectedVerificationType;
+  }) {
+    await deleteEmailDomainsByVerificationTypes({
+      organization_id,
+      domain,
+      domain_verification_types: [
+        null,
+        ...EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES.options,
+      ],
+    });
+    return addDomain({
+      organization_id,
+      domain,
+      verification_type: domain_verification_type,
+    });
+  }
+}
+
+export type MarkDomainAsVerifiedHandler = ReturnType<
+  typeof markDomainAsVerifiedFactory
+>;

package/src/managers/user/assign-user-verification-type-to-domain.ts

@@ -0,0 +1,50 @@
+//
+
+import type { GetUsersByOrganizationHandler } from "#src/repositories/organization";
+import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
+import { getEmailDomain } from "@proconnect-gouv/proconnect.core/services/email";
+
+//
+
+type FactoryDependencies = {
+  getUsers: GetUsersByOrganizationHandler;
+  updateUserOrganizationLink: UpdateUserOrganizationLinkHandler;
+};
+
+export function assignUserVerificationTypeToDomainFactory({
+  getUsers,
+  updateUserOrganizationLink,
+}: FactoryDependencies) {
+  return async function assignUserVerificationTypeToDomain(
+    organization_id: number,
+    domain: string,
+  ) {
+    const usersInOrganization = await getUsers(organization_id);
+
+    await Promise.all(
+      usersInOrganization.map(
+        ({ id, email, verification_type: link_verification_type }) => {
+          const userDomain = getEmailDomain(email);
+          if (
+            userDomain === domain &&
+            [
+              null,
+              "no_verification_means_available",
+              "no_verification_means_for_entreprise_unipersonnelle",
+            ].includes(link_verification_type)
+          ) {
+            return updateUserOrganizationLink(organization_id, id, {
+              verification_type: "domain",
+            });
+          }
+
+          return null;
+        },
+      ),
+    );
+  };
+}
+
+export type AssignUserVerificationTypeToDomainFactoryHandler = ReturnType<
+  typeof assignUserVerificationTypeToDomainFactory
+>;

package/src/managers/user/index.ts

@@ -0,0 +1 @@
+export * from "./assign-user-verification-type-to-domain.js";

package/src/mappers/certification/index.ts

@@ -0,0 +1,18 @@
+//
+
+import type { IdentityVector } from "#src/types";
+import type { InfogreffeSirenMandatairesSociaux } from "@proconnect-gouv/proconnect.entreprise/types";
+
+//
+
+export function fromInfogreffe(
+  mandataire: InfogreffeSirenMandatairesSociaux,
+): IdentityVector {
+  const birthdate = new Date(mandataire.date_naissance_timestamp || NaN);
+  return {
+    birthplace: mandataire.lieu_naissance ?? null,
+    birthdate: isNaN(birthdate.getTime()) ? null : birthdate,
+    family_name: mandataire.nom ?? null,
+    given_name: mandataire.prenom ?? null,
+  };
+}

package/src/mappers/index.ts

@@ -0,0 +1,3 @@
+//
+
+export * as OrganizationInfoMapper from "./organization/index.js";

package/src/mappers/organization/from-siret.test.ts

@@ -0,0 +1,26 @@
+//
+
+import {
+  AppleEuropeInc,
+  MaireClamart,
+  RogalDornEntrepreneur,
+} from "@proconnect-gouv/proconnect.entreprise/testing/seed/insee/siret";
+import { suite, test } from "node:test";
+import { fromSiret } from "./from-siret.js";
+
+suite("fromSiret", () => {
+  test("AppleEuropeInc", (t) => {
+    const organization = fromSiret(AppleEuropeInc);
+    t.assert.snapshot(organization);
+  });
+
+  test("Commune de clamart - Mairie", (t) => {
+    const organization = fromSiret(MaireClamart);
+    t.assert.snapshot(organization);
+  });
+
+  test("RogalDornEntrepreneur", (t) => {
+    const organization = fromSiret(RogalDornEntrepreneur);
+    t.assert.snapshot(organization);
+  });
+});

package/src/mappers/organization/from-siret.test.ts.snapshot

@@ -0,0 +1,68 @@
+exports[`fromSiret > AppleEuropeInc 1`] = `
+{
+  "activitePrincipale": "70.22Z",
+  "adresse": "100 west ten wilmington delawa, 99404, ETATS-UNIS",
+  "categorieJuridique": "3120",
+  "codeOfficielGeographique": "",
+  "codePostal": null,
+  "enseigne": "",
+  "estActive": false,
+  "estDiffusible": true,
+  "etatAdministratif": "A",
+  "libelle": "Apple europe inc.",
+  "libelleActivitePrincipale": "70.22Z - Conseil pour les affaires et autres conseils de gestion",
+  "libelleCategorieJuridique": "Société commerciale étrangère immatriculée au RCS",
+  "libelleTrancheEffectif": "",
+  "nomComplet": "Apple europe inc.",
+  "siret": "32122785200019",
+  "statutDiffusion": "diffusible",
+  "trancheEffectifs": null,
+  "trancheEffectifsUniteLegale": "31"
+}
+`;
+
+exports[`fromSiret > Commune de clamart - Mairie 1`] = `
+{
+  "activitePrincipale": "84.11Z",
+  "adresse": "1 place maurice gunsbourg, 92140 Clamart",
+  "categorieJuridique": "7210",
+  "codeOfficielGeographique": "92023",
+  "codePostal": "92140",
+  "enseigne": "MAIRIE",
+  "estActive": true,
+  "estDiffusible": true,
+  "etatAdministratif": "A",
+  "libelle": "Commune de clamart - Mairie",
+  "libelleActivitePrincipale": "84.11Z - Administration publique générale",
+  "libelleCategorieJuridique": "Commune et commune nouvelle",
+  "libelleTrancheEffectif": "1 000 à 1 999 salariés, en 2022",
+  "nomComplet": "Commune de clamart",
+  "siret": "21920023500014",
+  "statutDiffusion": "diffusible",
+  "trancheEffectifs": "42",
+  "trancheEffectifsUniteLegale": "42"
+}
+`;
+
+exports[`fromSiret > RogalDornEntrepreneur 1`] = `
+{
+  "activitePrincipale": "62.02A",
+  "adresse": "06155 Vallauris",
+  "categorieJuridique": "1000",
+  "codeOfficielGeographique": "06155",
+  "codePostal": "06155",
+  "enseigne": "",
+  "estActive": true,
+  "estDiffusible": false,
+  "etatAdministratif": "A",
+  "libelle": "Nom inconnu",
+  "libelleActivitePrincipale": "62.02A - Conseil en systèmes et logiciels informatiques",
+  "libelleCategorieJuridique": "Entrepreneur individuel",
+  "libelleTrancheEffectif": "",
+  "nomComplet": "Nom inconnu",
+  "siret": "94957325700019",
+  "statutDiffusion": "partiellement_diffusible",
+  "trancheEffectifs": null,
+  "trancheEffectifsUniteLegale": null
+}
+`;

package/src/mappers/organization/from-siret.ts

@@ -0,0 +1,75 @@
+//
+
+import "#src/types";
+import { OrganizationInfoSchema, type OrganizationInfo } from "#src/types";
+import {
+  formatAddress,
+  formatMainActivity,
+  formatNomComplet,
+  libelleFromCodeEffectif,
+} from "@proconnect-gouv/proconnect.entreprise/formatters";
+import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.entreprise/types";
+import { capitalize } from "lodash-es";
+
+//
+
+export function fromSiret(
+  siretData: InseeSireneEstablishmentSiretResponseData,
+): OrganizationInfo {
+  const isPartiallyNonDiffusible =
+    siretData.status_diffusion === "partiellement_diffusible";
+  const enseigne = siretData.enseigne ?? "";
+  const nomComplet = isPartiallyNonDiffusible
+    ? "Nom inconnu"
+    : formatNomComplet({
+        denominationUniteLegale:
+          siretData.unite_legale.personne_morale_attributs.raison_sociale ?? "",
+        nomUniteLegale:
+          siretData.unite_legale.personne_physique_attributs.nom_naissance,
+        nomUsageUniteLegale:
+          siretData.unite_legale.personne_physique_attributs.nom_usage,
+        prenomUsuelUniteLegale:
+          siretData.unite_legale.personne_physique_attributs.prenom_usuel,
+        sigleUniteLegale:
+          siretData.unite_legale.personne_morale_attributs.sigle,
+      });
+  const libelle = isPartiallyNonDiffusible
+    ? "Nom inconnu"
+    : `${nomComplet}${enseigne ? ` - ${capitalize(enseigne)}` : ""}`;
+
+  const trancheEffectifs = isPartiallyNonDiffusible
+    ? null
+    : siretData.tranche_effectif_salarie.code;
+  const trancheEffectifsUniteLegale = isPartiallyNonDiffusible
+    ? null
+    : siretData.unite_legale.tranche_effectif_salarie.code;
+  const codePostal = isPartiallyNonDiffusible
+    ? siretData.adresse.code_commune
+    : siretData.adresse.code_postal;
+
+  return OrganizationInfoSchema.parse({
+    activitePrincipale: siretData.activite_principale.code ?? "",
+    adresse: formatAddress(siretData.adresse),
+    categorieJuridique: siretData.unite_legale.forme_juridique.code ?? "",
+    codeOfficielGeographique: siretData.adresse.code_commune ?? "",
+    codePostal,
+    enseigne,
+    estActive: siretData.etat_administratif === "A",
+    estDiffusible: siretData.status_diffusion === "diffusible",
+    etatAdministratif: siretData.unite_legale.etat_administratif,
+    libelle,
+    libelleActivitePrincipale: formatMainActivity(
+      siretData.activite_principale,
+    ),
+    libelleCategorieJuridique: siretData.unite_legale.forme_juridique.libelle,
+    libelleTrancheEffectif: libelleFromCodeEffectif(
+      siretData.tranche_effectif_salarie.intitule,
+      siretData.tranche_effectif_salarie.date_reference,
+    ),
+    nomComplet,
+    siret: siretData.siret,
+    statutDiffusion: siretData.status_diffusion,
+    trancheEffectifs,
+    trancheEffectifsUniteLegale,
+  } satisfies OrganizationInfo);
+}

package/src/mappers/organization/index.ts

@@ -0,0 +1,3 @@
+//
+
+export * from "./from-siret.js";

package/src/repositories/email-domain/add-domain.test.ts

@@ -0,0 +1,43 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, mock, suite, test } from "node:test";
+import { addDomainFactory } from "./add-domain.js";
+
+//
+
+const addDomain = addDomainFactory({ pg: pg as any });
+
+suite("addDomainFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  test("should add domain", async () => {
+    await pg.sql`
+      INSERT INTO organizations
+        (id, siret, created_at, updated_at)
+      VALUES
+        (1, '66204244933106', '3333-03-03', '3333-04-04')
+      ;
+    `;
+    mock.timers.enable({ apis: ["Date"], now: new Date("4444-04-04") });
+
+    const emailDomain = await addDomain({
+      domain: "darkangels.world",
+      organization_id: 1,
+      verification_type: "verified",
+    });
+
+    assert.deepEqual(emailDomain, {
+      can_be_suggested: true,
+      created_at: new Date("4444-04-04"),
+      domain: "darkangels.world",
+      id: 1,
+      organization_id: 1,
+      updated_at: new Date("4444-04-04"),
+      verification_type: "verified",
+      verified_at: new Date("4444-04-04"),
+    });
+  });
+});