@proconnect-gouv/proconnect.identite 1.6.2 → 1.7.1

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

@@ -0,0 +1,97 @@
+//
+
+import assert from "node:assert/strict";
+import { describe, it, mock } from "node:test";
+import { assignUserVerificationTypeToDomainFactory } from "./assign-user-verification-type-to-domain.js";
+
+//
+
+describe("assignUserVerificationTypeToDomain", () => {
+  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 assignUserVerificationTypeToDomain(111, "darkangels.world");
+
+    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",
+      },
+    ]);
+    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 assignUserVerificationTypeToDomain(42, "darkangels.world");
+
+    assert.deepEqual(updateUserOrganizationLink.mock.calls, []);
+  });
+});

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

@@ -1,7 +1,11 @@
 //
 
 import { hashToPostgresParams } from "#src/services/postgres";
-import type { DatabaseContext, EmailDomain } from "#src/types";
+import type {
+  DatabaseContext,
+  EmailDomain,
+  EmailDomainVerificationType,
+} from "#src/types";
 import type { QueryResult } from "pg";
 
 //
@@ -14,7 +18,7 @@ export function addDomainFactory({ pg }: DatabaseContext) {
   }: {
     organization_id: number;
     domain: string;
-    verification_type: EmailDomain["verification_type"];
+    verification_type: EmailDomainVerificationType;
   }) {
     const connection = pg;
 

package/src/repositories/email-domain/delete-email-domains-by-verification-types.test.ts

@@ -29,7 +29,7 @@ describe("deleteEmailDomainsByVerificationTypesFactory", function () {
       INSERT INTO email_domains
         (domain, organization_id, verification_type)
       VALUES
-        ('darkangels.world', 1, NULL),
+        ('darkangels.world', 1, 'not_verified_yet'),
         ('darkangels.world', 1, 'verified')
       ;
     `;
@@ -37,7 +37,7 @@ describe("deleteEmailDomainsByVerificationTypesFactory", function () {
     const result = await deleteEmailDomainsByVerificationTypes({
       domain: "darkangels.world",
       organization_id: 1,
-      domain_verification_types: [null, "verified"],
+      domain_verification_types: ["not_verified_yet", "verified"],
     });
 
     assert.deepEqual(result, {

package/src/repositories/email-domain/delete-email-domains-by-verification-types.ts

@@ -1,6 +1,10 @@
 //
 
-import type { DatabaseContext, EmailDomain } from "#src/types";
+import type {
+  DatabaseContext,
+  EmailDomain,
+  EmailDomainVerificationType,
+} from "#src/types";
 
 //
 
@@ -13,15 +17,11 @@ export function deleteEmailDomainsByVerificationTypesFactory({
     domain_verification_types,
   }: {
     organization_id: EmailDomain["organization_id"];
-    domain_verification_types: EmailDomain["verification_type"][];
+    domain_verification_types: EmailDomainVerificationType[];
     domain: EmailDomain["domain"];
   }) {
     const SQL_VERIFICATION_TYPES = domain_verification_types
-      .map((type) =>
-        type === null
-          ? "verification_type IS NULL"
-          : `verification_type = '${type}'`,
-      )
+      .map((type) => `verification_type = '${type}'`)
       .join(" OR ");
 
     return pg.query(

package/src/repositories/email-domain/find-email-domains-by-organization-id.test.ts

@@ -25,9 +25,9 @@ describe("findEmailDomainsByOrganizationIdFactory", () => {
 
     await pg.sql`
       INSERT INTO email_domains
-        (id, domain, organization_id, created_at, updated_at)
+        (id, domain, organization_id, created_at, updated_at, verification_type)
       VALUES
-        (1, 'darkangels.world', 1, '4444-04-04', '4444-04-04')
+        (1, 'darkangels.world', 1, '4444-04-04', '4444-04-04', 'not_verified_yet')
       ;
     `;
 
@@ -41,7 +41,7 @@ describe("findEmailDomainsByOrganizationIdFactory", () => {
         id: 1,
         organization_id: 1,
         updated_at: new Date("4444-04-04"),
-        verification_type: null,
+        verification_type: "not_verified_yet",
         verified_at: null,
       },
     ]);

package/src/repositories/organization/index.ts

@@ -2,7 +2,6 @@
 
 export * from "./find-by-id.js";
 export * from "./find-by-user-id.js";
-export * from "./get-by-id.js";
 export * from "./get-users-by-organization.js";
 export * from "./link-user-to-organization.js";
 export * from "./upsert.js";

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/email-domain.ts

@@ -1,48 +1,65 @@
-//
-
 import { z } from "zod";
 
-//
-
-export const EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES = z.enum([
+export const EmailDomainApprovedVerificationTypes = [
   "official_contact",
   "trackdechets_postal_mail",
   "verified",
-]);
+  "external", // domain used by external employees (eg. ext.numerique.gouv.fr)
+] as const;
 
 export type EmailDomainApprovedVerificationType = z.output<
-  typeof EMAIL_DOMAIN_APPROVED_VERIFICATION_TYPES
+  typeof EmailDomainApprovedVerificationTypes
 >;
 
-//
+// domain is not verified, but users are still permitted to use it
+export const EmailDomainPendingVerificationTypes = [
+  "not_verified_yet",
+] as const;
 
-export const EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES = z.enum([
+export type EmailDomainPendingVerificationType = z.output<
+  typeof EmailDomainPendingVerificationTypes
+>;
+
+export const EmailDomainRejectedVerificationTypes = [
   "blacklisted", // unused
-  "external", // domain used by external employees (eg. ext.numerique.gouv.fr)
   "refused",
-]);
+] as const;
 
 export type EmailDomainRejectedVerificationType = z.output<
-  typeof EMAIL_DOMAIN_REJECTED_VERIFICATION_TYPES
+  typeof EmailDomainRejectedVerificationTypes
 >;
 
-//
+export const EmailDomainNoPendingVerificationTypes = z.enum([
+  ...EmailDomainApprovedVerificationTypes,
+  ...EmailDomainRejectedVerificationTypes,
+]);
+
+export type EmailDomainNoPendingVerificationType = z.output<
+  typeof EmailDomainNoPendingVerificationTypes
+>;
 
-export type EmailDomainVerificationType =
-  | EmailDomainApprovedVerificationType
-  | EmailDomainRejectedVerificationType
-  | null; // domain is not verified, but users are still permitted to use it
+export const EmailDomainVerificationTypes = z.enum([
+  ...EmailDomainApprovedVerificationTypes,
+  ...EmailDomainPendingVerificationTypes,
+  ...EmailDomainRejectedVerificationTypes,
+]);
 
-export interface EmailDomain {
-  id: number;
-  organization_id: number;
-  domain: string;
-  verification_type: EmailDomainVerificationType;
+export type EmailDomainVerificationType = z.output<
+  typeof EmailDomainVerificationTypes
+>;
+
+export const EmailDomainSchema = z.object({
+  id: z.number(),
+  organization_id: z.number(),
+  domain: z.string(),
+  verification_type: EmailDomainVerificationTypes,
   // Unused.
-  can_be_suggested: boolean;
+  can_be_suggested: z.boolean(),
   // Can be updated when verification_type changes.
   // In practice, entries are deleted and recreated rather than updated directly
-  verified_at: Date | null;
-  created_at: Date;
-  updated_at: Date;
-}
+  verified_at: z.date().nullable(),
+  created_at: z.date(),
+  updated_at: z.date(),
+});
+
+export type EmailDomain = z.output<typeof EmailDomainSchema>;

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

@@ -37,6 +37,8 @@ export const UnverifiedLinkTypes = [
 
 export const LinkTypes = z.enum([...VerifiedLinkTypes, ...UnverifiedLinkTypes]);
 
+export type LinkType = z.output<typeof LinkTypes>;
+
 export const BaseUserOrganizationLinkSchema = z.object({
   is_external: z.boolean(),
   verification_type: LinkTypes,
@@ -73,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<