@proconnect-gouv/proconnect.identite 1.7.0 → 2.0.0

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/src/services/organization/is-public-service.ts

@@ -12,7 +12,10 @@ export const isPublicService = ({
   cached_categorie_juridique,
   cached_etat_administratif,
   siret,
-}: Organization): boolean => {
+}: Pick<
+  Organization,
+  "cached_categorie_juridique" | "cached_etat_administratif" | "siret"
+>): boolean => {
   // Check if nature juridique is undefined/null
   if (!cached_categorie_juridique) {
     return false;

package/src/types/user-organization-link.ts

@@ -75,11 +75,11 @@ export const InsertUserOrganizationLinkSchema = UserOrganizationLinkSchema.pick(
     user_id: true,
     verification_type: true,
   },
-).merge(
+).extend(
   UserOrganizationLinkSchema.pick({
     is_external: true,
     needs_official_contact_email_verification: true,
-  }).partial(),
+  }).partial().shape,
 );
 
 export type InsertUserOrganizationLink = z.output<

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({