@proconnect-gouv/proconnect.identite 1.7.1 → 3.0.0

package/src/managers/certification/process-certification-dirigeant.ts

@@ -7,8 +7,8 @@ import {
   type IdentityVector,
   type Organization,
 } from "#src/types";
-import type { ApiEntrepriseInfogreffeRepository } from "@proconnect-gouv/proconnect.api_entreprise/api";
-import type { FindUniteLegaleBySirenHandler } from "@proconnect-gouv/proconnect.insee/api";
+import type { ApiEntrepriseClient } from "@proconnect-gouv/proconnect.api_entreprise/api";
+import type { ApiInseeClient } from "@proconnect-gouv/proconnect.insee/api";
 import type { FindPouvoirsBySirenHandler } from "@proconnect-gouv/proconnect.registre_national_entreprises/api";
 import { match } from "ts-pattern";
 import z from "zod/v4";
@@ -21,13 +21,12 @@ import { certificationScore } from "./certification-score.js";
 //
 
 type ProcessCertificationDirigeantConfig = {
-  ApiEntrepriseInfogreffeRepository: Pick<
-    ApiEntrepriseInfogreffeRepository,
+  ApiEntrepriseClient: Pick<
+    ApiEntrepriseClient,
     "findMandatairesSociauxBySiren"
   >;
-  EQUALITY_THRESHOLD?: number;
-  InseeApiRepository: { findBySiren: FindUniteLegaleBySirenHandler };
-  RegistreNationalEntreprisesApiRepository: {
+  InseeApiClient: ApiInseeClient;
+  RegistreNationalEntreprisesApiClient: {
     findPouvoirsBySiren: FindPouvoirsBySirenHandler;
   };
 };
@@ -61,14 +60,14 @@ export function getCertificationDirigeantDataSourceLabels(
 
 async function getMandatairesSociaux(
   {
-    RegistreNationalEntreprisesApiRepository,
-    ApiEntrepriseInfogreffeRepository,
+    RegistreNationalEntreprisesApiClient,
+    ApiEntrepriseClient,
   }: ProcessCertificationDirigeantConfig,
   siren: string,
 ) {
   try {
     const pouvoirs =
-      await RegistreNationalEntreprisesApiRepository.findPouvoirsBySiren(siren);
+      await RegistreNationalEntreprisesApiClient.findPouvoirsBySiren(siren);
     const dirigeants = pouvoirs.map(RNE.toIdentityVector);
 
     return {
@@ -81,9 +80,7 @@ async function getMandatairesSociaux(
   } catch (error) {
     console.error(error);
     const mandataires =
-      await ApiEntrepriseInfogreffeRepository.findMandatairesSociauxBySiren(
-        siren,
-      );
+      await ApiEntrepriseClient.findMandatairesSociauxBySiren(siren);
     const dirigeants = mandataires.map(ApiEntreprise.toIdentityVector);
 
     return {
@@ -132,7 +129,7 @@ function match_identity_to_dirigeant(
 export function processCertificationDirigeantFactory(
   config: ProcessCertificationDirigeantConfig,
 ) {
-  const { InseeApiRepository } = config;
+  const { InseeApiClient } = config;
 
   return async function processCertificationDirigeant(
     organization: Organization,
@@ -166,7 +163,7 @@ export function processCertificationDirigeantFactory(
 
     const { dirigeants, source } = await match(preferredDataSource)
       .with("api.insee.fr/api-sirene/private", async () => ({
-        dirigeants: await InseeApiRepository.findBySiren(siren)
+        dirigeants: await InseeApiClient.findBySiren(siren)
           .then(INSEE.toIdentityVector)
           .then((vector) => [vector]),
         source:

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

@@ -2,7 +2,7 @@
 
 import { InvalidSiretError, NotFoundError } from "#src/errors";
 import { type OrganizationInfo } from "#src/types";
-import type { ApiEntrepriseInseeRepository } from "@proconnect-gouv/proconnect.api_entreprise/api";
+import type { ApiEntrepriseClient } from "@proconnect-gouv/proconnect.api_entreprise/api";
 import {
   ApiEntrepriseConnectionError,
   ApiEntrepriseInvalidSiret,
@@ -11,9 +11,7 @@ import * as ApiEntreprise from "./adapters/api_entreprise.js";
 
 //
 
-export function getOrganizationInfoFactory(
-  config: ApiEntrepriseInseeRepository,
-) {
+export function getOrganizationInfoFactory(config: ApiEntrepriseClient) {
   const { findBySiren, findBySiret } = config;
 
   return async function getOrganizationInfo(

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

@@ -1,89 +1,75 @@
+//
+
 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 { context, emptyDatabase, migrate, pg } from "#testing";
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
+import { before, beforeEach, describe, it } from "node:test";
 import { markDomainAsVerifiedFactory } from "./mark-domain-as-verified.js";
 
 //
 
+const markDomainAsVerified = markDomainAsVerifiedFactory(context);
+
 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),
-      );
+  before(migrate);
+  beforeEach(emptyDatabase);
 
-    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:
-              "no_verification_means_for_entreprise_unipersonnelle",
-          } as User & BaseUserOrganizationLink,
-        ]),
-      ),
-      updateUserOrganizationLink,
-    });
+  it("should update organization members", async () => {
+    await pg.sql`
+      INSERT INTO organizations
+        (id, cached_libelle, cached_nom_complet, siret, created_at, updated_at)
+      VALUES
+        (1, 'Dark Angels', 'Dark Angels Legion', '🦁', '4444-04-04', '4444-04-04')
+      ;
+    `;
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (1, 'lion.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Lion', 'El''Jonson', '0', 'Primarque')
+    `;
+    await pg.sql`
+      INSERT INTO users_organizations
+        (user_id, organization_id, created_at, updated_at, is_external, verification_type, needs_official_contact_email_verification, official_contact_email_verification_token, official_contact_email_verification_sent_at)
+      VALUES
+        (1, 1, '4444-04-04', '4444-04-04', false, 'no_verification_means_for_entreprise_unipersonnelle', false, null, null)
+      ;
+    `;
+    await pg.sql`
+      INSERT INTO email_domains (organization_id, domain, verification_type)
+      VALUES (1, 'darkangels.world', 'not_verified_yet')
+    `;
 
     await markDomainAsVerified({
       domain: "darkangels.world",
       domain_verification_type: "verified",
-      organization_id: 42,
+      organization_id: 1,
     });
 
-    await t.test("should call updateUserOrganizationLink with", async (t) => {
-      t.assert.snapshot(updateUserOrganizationLink.mock.calls);
-    });
+    // user verification_type should be updated to "domain"
+    const { rows: userLinks } = await pg.sql`
+      SELECT user_id, verification_type
+      FROM users_organizations
+      WHERE organization_id = 1
+    `;
+    assert.deepEqual(userLinks, [{ user_id: 1, verification_type: "domain" }]);
 
-    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);
-    });
+    // old email_domain records should be replaced with "verified"
+    const { rows: emailDomains } = await pg.sql`
+      SELECT domain, verification_type
+      FROM email_domains
+      WHERE organization_id = 1
+      ORDER BY verification_type
+    `;
+    assert.deepEqual(emailDomains, [
+      { domain: "darkangels.world", verification_type: "verified" },
+    ]);
   });
 
   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,
+        organization_id: 999,
       }),
       new NotFoundError(""),
     );

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

@@ -1,16 +1,8 @@
 //
 
+import type { Context } from "#src/connectors";
 import { NotFoundError } from "#src/errors";
 import { assignUserVerificationTypeToDomainFactory } from "#src/managers/user";
-import type {
-  AddDomainHandler,
-  DeleteEmailDomainsByVerificationTypesHandler,
-} from "#src/repositories/email-domain";
-import type {
-  FindByIdHandler,
-  GetUsersByOrganizationHandler,
-} from "#src/repositories/organization";
-import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
 import {
   type EmailDomainApprovedVerificationType,
   EmailDomainApprovedVerificationTypes,
@@ -26,26 +18,14 @@ 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) {
+export function markDomainAsVerifiedFactory(context: Context) {
   const assignUserVerificationTypeToDomain =
-    assignUserVerificationTypeToDomainFactory({
-      getUsers,
-      updateUserOrganizationLink,
-    });
+    assignUserVerificationTypeToDomainFactory(context);
+
+  const {
+    repository: { email_domains, organizations },
+  } = context;
+
   return async function markDomainAsVerified({
     organization_id,
     domain,
@@ -55,7 +35,7 @@ export function markDomainAsVerifiedFactory({
     domain: string;
     domain_verification_type: EmailDomainNoPendingVerificationType;
   }) {
-    const organization = await findOrganizationById(organization_id);
+    const organization = await organizations.findById(organization_id);
 
     if (isEmpty(organization)) {
       throw new NotFoundError();
@@ -94,7 +74,7 @@ export function markDomainAsVerifiedFactory({
     domain: string;
     domain_verification_type: EmailDomainApprovedVerificationType;
   }) {
-    await deleteEmailDomainsByVerificationTypes({
+    await email_domains.deleteEmailDomainsByVerificationTypes({
       organization_id,
       domain,
       domain_verification_types: [
@@ -102,7 +82,7 @@ export function markDomainAsVerifiedFactory({
         ...EmailDomainPendingVerificationTypes,
       ],
     });
-    return addDomain({
+    return email_domains.addDomain({
       organization_id,
       domain,
       verification_type:
@@ -119,7 +99,7 @@ export function markDomainAsVerifiedFactory({
     domain: string;
     domain_verification_type: EmailDomainRejectedVerificationType;
   }) {
-    await deleteEmailDomainsByVerificationTypes({
+    await email_domains.deleteEmailDomainsByVerificationTypes({
       organization_id,
       domain,
       domain_verification_types: [
@@ -127,7 +107,7 @@ export function markDomainAsVerifiedFactory({
         ...EmailDomainRejectedVerificationTypes,
       ],
     });
-    return addDomain({
+    return email_domains.addDomain({
       organization_id,
       domain,
       verification_type:

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

@@ -1,97 +1,106 @@
 //
 
+import { context, emptyDatabase, migrate, pg } from "#testing";
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
+import { before, beforeEach, describe, it } from "node:test";
 import { assignUserVerificationTypeToDomainFactory } from "./assign-user-verification-type-to-domain.js";
 
 //
 
+const assignUserVerificationTypeToDomain =
+  assignUserVerificationTypeToDomainFactory(context);
+
 describe("assignUserVerificationTypeToDomain", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
   it("should update some organization members", async () => {
-    const updateUserOrganizationLink = mock.fn(() =>
-      Promise.resolve({} as any),
-    );
-    const assignUserVerificationTypeToDomain =
-      assignUserVerificationTypeToDomainFactory({
-        getUsers: () =>
-          Promise.resolve([
-            { email: "foo@bar.world" },
-            { email: "foo@darkangels.world" },
-            {
-              email: "foo@darkangels.world",
-              verification_type: "verified",
-            },
-            {
-              id: 42,
-              email: "lion.eljonson@darkangels.world",
-              verification_type: "no_validation_means_available",
-            },
-            {
-              id: 43,
-              email: "cat.eljonson@darkangels.world",
-              verification_type:
-                "no_verification_means_for_entreprise_unipersonnelle",
-            },
-            {
-              id: 44,
-              email: "tiger.eljonson@darkangels.world",
-              verification_type: "no_verification_means_for_small_association",
-            },
-            {
-              id: 45,
-              email: "mouse.eljonson@darkangels.world",
-              verification_type: "domain_not_verified_yet",
-            },
-          ] as any),
-        updateUserOrganizationLink,
-      });
+    await pg.sql`
+      INSERT INTO organizations
+        (id, cached_libelle, cached_nom_complet, siret, created_at, updated_at)
+      VALUES
+        (1, 'Dark Angels', 'Dark Angels Legion', '🦁', '4444-04-04', '4444-04-04')
+      ;
+    `;
+    // user from a different domain — should not be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (1, 'foo@bar.world', '4444-04-04', '4444-04-04', 'Foo', 'Bar', '0', 'None')
+    `;
+    // user matching domain but already "verified" — should not be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (2, 'foo@darkangels.world', '4444-04-04', '4444-04-04', 'Foo', 'DA', '0', 'None')
+    `;
+    // user with no_validation_means_available — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (3, 'lion.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Lion', 'El''Jonson', '0', 'Primarque')
+    `;
+    // user with no_verification_means_for_entreprise_unipersonnelle — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (4, 'cat.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Cat', 'El''Jonson', '0', 'Scout')
+    `;
+    // user with no_verification_means_for_small_association — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (5, 'tiger.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Tiger', 'El''Jonson', '0', 'Scout')
+    `;
+    // user with domain_not_verified_yet — should be updated
+    await pg.sql`
+      INSERT INTO users (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+      VALUES (6, 'mouse.eljonson@darkangels.world', '4444-04-04', '4444-04-04', 'Mouse', 'El''Jonson', '0', 'Scout')
+    `;
 
-    await assignUserVerificationTypeToDomain(111, "darkangels.world");
+    // link all users to the organization
+    await pg.sql`
+      INSERT INTO users_organizations
+        (user_id, organization_id, created_at, updated_at, is_external, verification_type, needs_official_contact_email_verification, official_contact_email_verification_token, official_contact_email_verification_sent_at)
+      VALUES
+        (1, 1, '4444-04-04', '4444-04-04', false, 'no_validation_means_available', false, null, null),
+        (2, 1, '4444-04-04', '4444-04-04', false, 'verified', false, null, null),
+        (3, 1, '4444-04-04', '4444-04-04', false, 'no_validation_means_available', false, null, null),
+        (4, 1, '4444-04-04', '4444-04-04', false, 'no_verification_means_for_entreprise_unipersonnelle', false, null, null),
+        (5, 1, '4444-04-04', '4444-04-04', false, 'no_verification_means_for_small_association', false, null, null),
+        (6, 1, '4444-04-04', '4444-04-04', false, 'domain_not_verified_yet', false, null, null)
+      ;
+    `;
 
-    const [lion, cat, tiger, mouse] = updateUserOrganizationLink.mock.calls;
-    assert.deepEqual(lion.arguments, [
-      111,
-      42,
-      {
-        verification_type: "domain",
-      },
-    ]);
-    assert.deepEqual(cat.arguments, [
-      111,
-      43,
-      {
-        verification_type: "domain",
-      },
-    ]);
-    assert.deepEqual(tiger.arguments, [
-      111,
-      44,
-      {
-        verification_type: "domain",
-      },
-    ]);
-    assert.deepEqual(mouse.arguments, [
-      111,
-      45,
-      {
-        verification_type: "domain",
-      },
+    await assignUserVerificationTypeToDomain(1, "darkangels.world");
+
+    // verify that the 4 matching users were updated to "domain"
+    const { rows } = await pg.sql`
+      SELECT user_id, verification_type
+      FROM users_organizations
+      WHERE organization_id = 1
+      ORDER BY user_id
+    `;
+
+    assert.deepEqual(rows, [
+      { user_id: 1, verification_type: "no_validation_means_available" }, // different domain
+      { user_id: 2, verification_type: "verified" }, // already verified
+      { user_id: 3, verification_type: "domain" },
+      { user_id: 4, verification_type: "domain" },
+      { user_id: 5, verification_type: "domain" },
+      { user_id: 6, verification_type: "domain" },
     ]);
-    assert.equal(updateUserOrganizationLink.mock.callCount(), 4);
   });
 
   it("❎ should update nothing if no organization members", async () => {
-    const updateUserOrganizationLink = mock.fn(() =>
-      Promise.reject(new Error("💣")),
-    );
-    const assignUserVerificationTypeToDomain =
-      assignUserVerificationTypeToDomainFactory({
-        getUsers: () => Promise.resolve([]),
-        updateUserOrganizationLink,
-      });
+    await pg.sql`
+      INSERT INTO organizations
+        (id, cached_libelle, cached_nom_complet, siret, created_at, updated_at)
+      VALUES
+        (1, 'Empty', 'Empty Org', '🫥', '4444-04-04', '4444-04-04')
+      ;
+    `;
 
-    await assignUserVerificationTypeToDomain(42, "darkangels.world");
+    await assignUserVerificationTypeToDomain(1, "darkangels.world");
 
-    assert.deepEqual(updateUserOrganizationLink.mock.calls, []);
+    const { rows } = await pg.sql`
+      SELECT * FROM users_organizations WHERE organization_id = 1
+    `;
+    assert.deepEqual(rows, []);
   });
 });

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

@@ -1,27 +1,20 @@
 //
 
-import type { GetUsersByOrganizationHandler } from "#src/repositories/organization";
-import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
+import type { Context } from "#src/connectors";
 import { LinkTypes, SuperWeakLinkTypes, UnverifiedLinkTypes } from "#src/types";
 import { getEmailDomain } from "@proconnect-gouv/proconnect.core/services/email";
 import { match } from "ts-pattern";
 
 //
 
-type FactoryDependencies = {
-  getUsers: GetUsersByOrganizationHandler;
-  updateUserOrganizationLink: UpdateUserOrganizationLinkHandler;
-};
-
 export function assignUserVerificationTypeToDomainFactory({
-  getUsers,
-  updateUserOrganizationLink,
-}: FactoryDependencies) {
+  repository: { organizations, users_organizations },
+}: Context) {
   return async function assignUserVerificationTypeToDomain(
     organization_id: number,
     domain: string,
   ) {
-    const usersInOrganization = await getUsers(organization_id);
+    const usersInOrganization = await organizations.getUsers(organization_id);
 
     await Promise.all(
       usersInOrganization.map(
@@ -33,7 +26,7 @@ export function assignUserVerificationTypeToDomainFactory({
               .with(...UnverifiedLinkTypes, ...SuperWeakLinkTypes, () => true)
               .otherwise(() => false)
           ) {
-            return updateUserOrganizationLink(organization_id, id, {
+            return users_organizations.update(organization_id, id, {
               verification_type: LinkTypes.enum.domain,
             });
           }
@@ -44,7 +37,3 @@ export function assignUserVerificationTypeToDomainFactory({
     );
   };
 }
-
-export type AssignUserVerificationTypeToDomainFactoryHandler = ReturnType<
-  typeof assignUserVerificationTypeToDomainFactory
->;

package/testing/index.ts

@@ -4,10 +4,12 @@ import { PGlite } from "@electric-sql/pglite";
 import { noop } from "lodash-es";
 import { runner } from "node-pg-migrate";
 import { join } from "path";
+import { createContext } from "../src/connectors/index.js";
 
 //
 
 export const pg = new PGlite();
+export const context = createContext(pg as any);
 
 export function migrate() {
   return runner({