@proconnect-gouv/proconnect.identite 1.7.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @proconnect-gouv/proconnect.identite
 
+## 2.0.0
+
+### Major Changes
+
+- [#1844](https://github.com/proconnect-gouv/proconnect-identite/pull/1844) [`a957ae4`](https://github.com/proconnect-gouv/proconnect-identite/commit/a957ae4c60f0c1567e02102173dae12f84f5be18) Thanks [@douglasduteil](https://github.com/douglasduteil)! - ♻️ Utilisation d'un context global pour utiliser les managers
+
+## 1.7.1
+
+### Patch Changes
+
+- [#1858](https://github.com/proconnect-gouv/proconnect-identite/pull/1858) [`91607a8`](https://github.com/proconnect-gouv/proconnect-identite/commit/91607a8ee6193f1fad76a874a09d043ba179d826) Thanks [@BenoitSerrano](https://github.com/BenoitSerrano)! - Le typage de la fonction isPublicService oblige à passer tous les paramètres de Organization à la fonction, alors que seuls trois d'entre eux nous intéresse
+
 ## 1.7.0
 
 ### Minor Changes

package/dist/connectors/index.d.ts

@@ -0,0 +1,110 @@
+import { type Pool } from "pg";
+export declare function createContext(pg: Pool): {
+    repository: {
+        email_domains: {
+            addDomain: ({ organization_id, domain, verification_type, }: {
+                organization_id: number;
+                domain: string;
+                verification_type: import("../types/email-domain.js").EmailDomainVerificationType;
+            }) => Promise<{
+                id: number;
+                organization_id: number;
+                domain: string;
+                verification_type: "official_contact" | "trackdechets_postal_mail" | "verified" | "external" | "not_verified_yet" | "blacklisted" | "refused";
+                can_be_suggested: boolean;
+                verified_at: Date | null;
+                created_at: Date;
+                updated_at: Date;
+            }>;
+            deleteEmailDomainsByVerificationTypes: ({ organization_id, domain, domain_verification_types, }: {
+                organization_id: import("../types/email-domain.js").EmailDomain["organization_id"];
+                domain_verification_types: import("../types/email-domain.js").EmailDomainVerificationType[];
+                domain: import("../types/email-domain.js").EmailDomain["domain"];
+            }) => Promise<import("pg").QueryResult<any>>;
+            findEmailDomainsByOrganizationId: (organization_id: number) => Promise<{
+                id: number;
+                organization_id: number;
+                domain: string;
+                verification_type: "official_contact" | "trackdechets_postal_mail" | "verified" | "external" | "not_verified_yet" | "blacklisted" | "refused";
+                can_be_suggested: boolean;
+                verified_at: Date | null;
+                created_at: Date;
+                updated_at: Date;
+            }[]>;
+        };
+        organizations: {
+            findById: (id: number) => Promise<import("../types/organization.js").Organization | undefined>;
+            findByUserId: (userId: number) => Promise<(import("../types/organization.js").Organization & {
+                is_external: boolean;
+                verification_type: "domain" | "organization_dirigeant" | "code_sent_to_official_contact_email" | "imported_from_coop_mediation_numerique" | "imported_from_inclusion_connect" | "in_liste_dirigeants_rna" | "in_liste_dirigeants_rne" | "official_contact_email" | "ordre_professionnel_domain" | "proof_received" | "verified_by_coop_mediation_numerique" | "bypassed" | "domain_not_verified_yet" | "no_validation_means_available" | "no_verification_means_for_entreprise_unipersonnelle" | "no_verification_means_for_small_association";
+                verified_at: Date | null;
+                has_been_greeted: boolean;
+                needs_official_contact_email_verification: boolean;
+                official_contact_email_verification_token: string | null;
+                official_contact_email_verification_sent_at: Date | null;
+            })[]>;
+            getUsers: (organization_id: number, additionalWhereClause?: string, additionalParams?: any[]) => Promise<(import("../types/user.js").User & {
+                is_external: boolean;
+                verification_type: "domain" | "organization_dirigeant" | "code_sent_to_official_contact_email" | "imported_from_coop_mediation_numerique" | "imported_from_inclusion_connect" | "in_liste_dirigeants_rna" | "in_liste_dirigeants_rne" | "official_contact_email" | "ordre_professionnel_domain" | "proof_received" | "verified_by_coop_mediation_numerique" | "bypassed" | "domain_not_verified_yet" | "no_validation_means_available" | "no_verification_means_for_entreprise_unipersonnelle" | "no_verification_means_for_small_association";
+                verified_at: Date | null;
+                has_been_greeted: boolean;
+                needs_official_contact_email_verification: boolean;
+                official_contact_email_verification_token: string | null;
+                official_contact_email_verification_sent_at: Date | null;
+            })[]>;
+        };
+        users_organizations: {
+            update: (organization_id: number, user_id: number, fieldsToUpdate: Partial<import("../types/user-organization-link.js").UserOrganizationLink>) => Promise<{
+                is_external: boolean;
+                verification_type: "domain" | "organization_dirigeant" | "code_sent_to_official_contact_email" | "imported_from_coop_mediation_numerique" | "imported_from_inclusion_connect" | "in_liste_dirigeants_rna" | "in_liste_dirigeants_rne" | "official_contact_email" | "ordre_professionnel_domain" | "proof_received" | "verified_by_coop_mediation_numerique" | "bypassed" | "domain_not_verified_yet" | "no_validation_means_available" | "no_verification_means_for_entreprise_unipersonnelle" | "no_verification_means_for_small_association";
+                verified_at: Date | null;
+                has_been_greeted: boolean;
+                needs_official_contact_email_verification: boolean;
+                official_contact_email_verification_token: string | null;
+                official_contact_email_verification_sent_at: Date | null;
+                user_id: number;
+                organization_id: number;
+                created_at: Date;
+                updated_at: Date;
+            }>;
+        };
+        users: {
+            create: ({ email, encrypted_password, }: {
+                email: string;
+                encrypted_password?: string | null;
+            }) => Promise<import("../types/user.js").User>;
+            findByEmail: (email: string) => Promise<import("../types/user.js").User | undefined>;
+            findById: (id: number) => Promise<import("../types/user.js").User | undefined>;
+            getById: (id: number) => Promise<import("../types/user.js").User>;
+            getFranceConnectUserInfo: (user_id: number) => Promise<{
+                birthcountry: string;
+                birthdate: Date;
+                birthplace: string;
+                family_name: string;
+                gender: string;
+                given_name: string;
+                sub: string;
+                created_at: Date;
+                updated_at: Date;
+                user_id: number;
+                preferred_username?: string | undefined;
+            } | undefined>;
+            update: (id: number, fieldsToUpdate: Partial<import("../types/user.js").User>) => Promise<import("../types/user.js").User>;
+            upsetFranceconnectUserinfo: (value: Pick<import("../types/franceconnect.js").FranceConnectUserInfo, "user_id"> & Partial<import("../types/franceconnect.js").FranceConnectUserInfo>) => Promise<{
+                birthcountry: string;
+                birthdate: Date;
+                birthplace: string;
+                family_name: string;
+                gender: string;
+                given_name: string;
+                sub: string;
+                created_at: Date;
+                updated_at: Date;
+                user_id: number;
+                preferred_username?: string | undefined;
+            }>;
+        };
+    };
+};
+export type Context = ReturnType<typeof createContext>;
+//# sourceMappingURL=index.d.ts.map

package/dist/connectors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/connectors/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC;AAkB/B,wBAAgB,aAAa,CAAC,EAAE,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAfgE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4CtG;AACD,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/connectors/index.js

@@ -0,0 +1,45 @@
+//
+import {} from "pg";
+import { addDomainFactory } from "../repositories/email-domain/add-domain.js";
+import { deleteEmailDomainsByVerificationTypesFactory } from "../repositories/email-domain/delete-email-domains-by-verification-types.js";
+import { findEmailDomainsByOrganizationIdFactory } from "../repositories/email-domain/find-email-domains-by-organization-id.js";
+import { findByIdFactory as findOrganizationByIdFactory } from "../repositories/organization/find-by-id.js";
+import { findByUserIdFactory } from "../repositories/organization/find-by-user-id.js";
+import { getUsersByOrganizationFactory } from "../repositories/organization/get-users-by-organization.js";
+import { createUserFactory } from "../repositories/user/create.js";
+import { findByEmailFactory } from "../repositories/user/find-by-email.js";
+import { findByIdFactory as findUserByIdFactory } from "../repositories/user/find-by-id.js";
+import { getByIdFactory } from "../repositories/user/get-by-id.js";
+import { getFranceConnectUserInfoFactory } from "../repositories/user/get-franceconnect-user-info.js";
+import { updateUserOrganizationLinkFactory } from "../repositories/user/update-user-organization-link.js";
+import { updateUserFactory } from "../repositories/user/update.js";
+import { upsertFranceconnectUserinfoFactory } from "../repositories/user/upsert-franceconnect-userinfo.js";
+//
+export function createContext(pg) {
+    return {
+        repository: {
+            email_domains: {
+                addDomain: addDomainFactory({ pg }),
+                deleteEmailDomainsByVerificationTypes: deleteEmailDomainsByVerificationTypesFactory({ pg }),
+                findEmailDomainsByOrganizationId: findEmailDomainsByOrganizationIdFactory({ pg }),
+            },
+            organizations: {
+                findById: findOrganizationByIdFactory({ pg }),
+                findByUserId: findByUserIdFactory({ pg }),
+                getUsers: getUsersByOrganizationFactory({ pg }),
+            },
+            users_organizations: {
+                update: updateUserOrganizationLinkFactory({ pg }),
+            },
+            users: {
+                create: createUserFactory({ pg }),
+                findByEmail: findByEmailFactory({ pg }),
+                findById: findUserByIdFactory({ pg }),
+                getById: getByIdFactory({ pg }),
+                getFranceConnectUserInfo: getFranceConnectUserInfoFactory({ pg }),
+                update: updateUserFactory({ pg }),
+                upsetFranceconnectUserinfo: upsertFranceconnectUserinfoFactory({ pg }),
+            },
+        },
+    };
+}

package/dist/managers/organization/adapters/api_entreprise.d.ts

@@ -20,7 +20,7 @@ export declare function toPartialOrganization(organization_info: OrganizationInf
     cached_siege_social: boolean;
     cached_statut_diffusion: "diffusible" | "partiellement_diffusible" | "non_diffusible";
     cached_tranche_effectifs_unite_legale: string | null;
-    cached_tranche_effectifs: "11" | "12" | "21" | "22" | "31" | "32" | "41" | "42" | "51" | "52" | "53" | "NN" | "00" | "01" | "02" | "03" | null;
+    cached_tranche_effectifs: "NN" | "00" | "01" | "02" | "03" | "11" | "12" | "21" | "22" | "31" | "32" | "41" | "42" | "51" | "52" | "53" | null;
     siret: string;
 };
 //# sourceMappingURL=api_entreprise.d.ts.map

package/dist/managers/organization/mark-domain-as-verified.d.ts

@@ -1,15 +1,6 @@
-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 { Context } from "#src/connectors";
 import { type EmailDomainNoPendingVerificationType } from "#src/types";
-type FactoryDependencies = {
-    addDomain: AddDomainHandler;
-    deleteEmailDomainsByVerificationTypes: DeleteEmailDomainsByVerificationTypesHandler;
-    findOrganizationById: FindByIdHandler;
-    getUsers: GetUsersByOrganizationHandler;
-    updateUserOrganizationLink: UpdateUserOrganizationLinkHandler;
-};
-export declare function markDomainAsVerifiedFactory({ addDomain, deleteEmailDomainsByVerificationTypes, findOrganizationById, getUsers, updateUserOrganizationLink, }: FactoryDependencies): ({ organization_id, domain, domain_verification_type, }: {
+export declare function markDomainAsVerifiedFactory(context: Context): ({ organization_id, domain, domain_verification_type, }: {
     organization_id: number;
     domain: string;
     domain_verification_type: EmailDomainNoPendingVerificationType;
@@ -24,5 +15,4 @@ export declare function markDomainAsVerifiedFactory({ addDomain, deleteEmailDoma
     updated_at: Date;
 }>;
 export type MarkDomainAsVerifiedHandler = ReturnType<typeof markDomainAsVerifiedFactory>;
-export {};
 //# sourceMappingURL=mark-domain-as-verified.d.ts.map

package/dist/managers/organization/mark-domain-as-verified.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mark-domain-as-verified.d.ts","sourceRoot":"","sources":["../../../src/managers/organization/mark-domain-as-verified.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,gBAAgB,EAChB,4CAA4C,EAC7C,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,eAAe,EACf,6BAA6B,EAC9B,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAGL,KAAK,oCAAoC,EAK1C,MAAM,YAAY,CAAC;AAOpB,KAAK,mBAAmB,GAAG;IACzB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,qCAAqC,EAAE,4CAA4C,CAAC;IACpF,oBAAoB,EAAE,eAAe,CAAC;IACtC,QAAQ,EAAE,6BAA6B,CAAC;IACxC,0BAA0B,EAAE,iCAAiC,CAAC;CAC/D,CAAC;AAEF,wBAAgB,2BAA2B,CAAC,EAC1C,SAAS,EACT,qCAAqC,EACrC,oBAAoB,EACpB,QAAQ,EACR,0BAA0B,GAC3B,EAAE,mBAAmB,IAMuB,wDAIxC;IACD,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,wBAAwB,EAAE,oCAAoC,CAAC;CAChE;;;;;;;;;GAgFF;AAED,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAClD,OAAO,2BAA2B,CACnC,CAAC"}
+{"version":3,"file":"mark-domain-as-verified.d.ts","sourceRoot":"","sources":["../../../src/managers/organization/mark-domain-as-verified.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG/C,OAAO,EAGL,KAAK,oCAAoC,EAK1C,MAAM,YAAY,CAAC;AAOpB,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,IAQf,wDAIxC;IACD,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,wBAAwB,EAAE,oCAAoC,CAAC;CAChE;;;;;;;;;GAgFF;AAED,MAAM,MAAM,2BAA2B,GAAG,UAAU,CAClD,OAAO,2BAA2B,CACnC,CAAC"}

package/dist/managers/organization/mark-domain-as-verified.js

@@ -4,13 +4,12 @@ import { assignUserVerificationTypeToDomainFactory } from "#src/managers/user";
 import { EmailDomainApprovedVerificationTypes, EmailDomainPendingVerificationTypes, EmailDomainRejectedVerificationTypes, } from "#src/types";
 import { isEmpty } from "lodash-es";
 import { match } from "ts-pattern";
-export function markDomainAsVerifiedFactory({ addDomain, deleteEmailDomainsByVerificationTypes, findOrganizationById, getUsers, updateUserOrganizationLink, }) {
-    const assignUserVerificationTypeToDomain = assignUserVerificationTypeToDomainFactory({
-        getUsers,
-        updateUserOrganizationLink,
-    });
+//
+export function markDomainAsVerifiedFactory(context) {
+    const assignUserVerificationTypeToDomain = assignUserVerificationTypeToDomainFactory(context);
+    const { repository: { email_domains, organizations }, } = context;
     return async function markDomainAsVerified({ organization_id, domain, domain_verification_type, }) {
-        const organization = await findOrganizationById(organization_id);
+        const organization = await organizations.findById(organization_id);
         if (isEmpty(organization)) {
             throw new NotFoundError();
         }
@@ -31,7 +30,7 @@ export function markDomainAsVerifiedFactory({ addDomain, deleteEmailDomainsByVer
             .exhaustive();
     };
     async function markDomainAsApproved({ organization_id, domain, domain_verification_type, }) {
-        await deleteEmailDomainsByVerificationTypes({
+        await email_domains.deleteEmailDomainsByVerificationTypes({
             organization_id,
             domain,
             domain_verification_types: [
@@ -39,14 +38,14 @@ export function markDomainAsVerifiedFactory({ addDomain, deleteEmailDomainsByVer
                 ...EmailDomainPendingVerificationTypes,
             ],
         });
-        return addDomain({
+        return email_domains.addDomain({
             organization_id,
             domain,
             verification_type: domain_verification_type,
         });
     }
     async function markDomainAsRejected({ organization_id, domain, domain_verification_type, }) {
-        await deleteEmailDomainsByVerificationTypes({
+        await email_domains.deleteEmailDomainsByVerificationTypes({
             organization_id,
             domain,
             domain_verification_types: [
@@ -54,7 +53,7 @@ export function markDomainAsVerifiedFactory({ addDomain, deleteEmailDomainsByVer
                 ...EmailDomainRejectedVerificationTypes,
             ],
         });
-        return addDomain({
+        return email_domains.addDomain({
             organization_id,
             domain,
             verification_type: domain_verification_type,

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

@@ -1,10 +1,3 @@
-import type { GetUsersByOrganizationHandler } from "#src/repositories/organization";
-import type { UpdateUserOrganizationLinkHandler } from "#src/repositories/user";
-type FactoryDependencies = {
-    getUsers: GetUsersByOrganizationHandler;
-    updateUserOrganizationLink: UpdateUserOrganizationLinkHandler;
-};
-export declare function assignUserVerificationTypeToDomainFactory({ getUsers, updateUserOrganizationLink, }: FactoryDependencies): (organization_id: number, domain: string) => Promise<void>;
-export type AssignUserVerificationTypeToDomainFactoryHandler = ReturnType<typeof assignUserVerificationTypeToDomainFactory>;
-export {};
+import type { Context } from "#src/connectors";
+export declare function assignUserVerificationTypeToDomainFactory({ repository: { organizations, users_organizations }, }: Context): (organization_id: number, domain: string) => Promise<void>;
 //# sourceMappingURL=assign-user-verification-type-to-domain.d.ts.map

package/dist/managers/user/assign-user-verification-type-to-domain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assign-user-verification-type-to-domain.d.ts","sourceRoot":"","sources":["../../../src/managers/user/assign-user-verification-type-to-domain.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AACpF,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAOhF,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,6BAA6B,CAAC;IACxC,0BAA0B,EAAE,iCAAiC,CAAC;CAC/D,CAAC;AAEF,wBAAgB,yCAAyC,CAAC,EACxD,QAAQ,EACR,0BAA0B,GAC3B,EAAE,mBAAmB,IAElB,iBAAiB,MAAM,EACvB,QAAQ,MAAM,mBAwBjB;AAED,MAAM,MAAM,gDAAgD,GAAG,UAAU,CACvE,OAAO,yCAAyC,CACjD,CAAC"}
+{"version":3,"file":"assign-user-verification-type-to-domain.d.ts","sourceRoot":"","sources":["../../../src/managers/user/assign-user-verification-type-to-domain.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAO/C,wBAAgB,yCAAyC,CAAC,EACxD,UAAU,EAAE,EAAE,aAAa,EAAE,mBAAmB,EAAE,GACnD,EAAE,OAAO,IAEN,iBAAiB,MAAM,EACvB,QAAQ,MAAM,mBAwBjB"}

package/dist/managers/user/assign-user-verification-type-to-domain.js

@@ -2,16 +2,17 @@
 import { LinkTypes, SuperWeakLinkTypes, UnverifiedLinkTypes } from "#src/types";
 import { getEmailDomain } from "@proconnect-gouv/proconnect.core/services/email";
 import { match } from "ts-pattern";
-export function assignUserVerificationTypeToDomainFactory({ getUsers, updateUserOrganizationLink, }) {
+//
+export function assignUserVerificationTypeToDomainFactory({ repository: { organizations, users_organizations }, }) {
     return async function assignUserVerificationTypeToDomain(organization_id, domain) {
-        const usersInOrganization = await getUsers(organization_id);
+        const usersInOrganization = await organizations.getUsers(organization_id);
         await Promise.all(usersInOrganization.map(({ id, email, verification_type: link_verification_type }) => {
             const userDomain = getEmailDomain(email);
             if (userDomain === domain &&
                 match(link_verification_type)
                     .with(...UnverifiedLinkTypes, ...SuperWeakLinkTypes, () => true)
                     .otherwise(() => false)) {
-                return updateUserOrganizationLink(organization_id, id, {
+                return users_organizations.update(organization_id, id, {
                     verification_type: LinkTypes.enum.domain,
                 });
             }

package/dist/services/organization/is-public-service.d.ts

@@ -1,3 +1,3 @@
 import type { Organization } from "#src/types";
-export declare const isPublicService: ({ cached_categorie_juridique, cached_etat_administratif, siret, }: Organization) => boolean;
+export declare const isPublicService: ({ cached_categorie_juridique, cached_etat_administratif, siret, }: Pick<Organization, "cached_categorie_juridique" | "cached_etat_administratif" | "siret">) => boolean;
 //# sourceMappingURL=is-public-service.d.ts.map

package/dist/services/organization/is-public-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-public-service.d.ts","sourceRoot":"","sources":["../../../src/services/organization/is-public-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ/C,eAAO,MAAM,eAAe,GAAI,mEAI7B,YAAY,KAAG,OAiCjB,CAAC"}
+{"version":3,"file":"is-public-service.d.ts","sourceRoot":"","sources":["../../../src/services/organization/is-public-service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAQ/C,eAAO,MAAM,eAAe,GAAI,mEAI7B,IAAI,CACL,YAAY,EACZ,4BAA4B,GAAG,2BAA2B,GAAG,OAAO,CACrE,KAAG,OAiCH,CAAC"}

package/dist/types/organization-info.d.ts

@@ -21,7 +21,7 @@ export declare const OrganizationInfoSchema: z.ZodObject<{
         partiellement_diffusible: "partiellement_diffusible";
         non_diffusible: "non_diffusible";
     }>;
-    trancheEffectifs: z.ZodNullable<z.ZodCustom<"11" | "12" | "21" | "22" | "31" | "32" | "41" | "42" | "51" | "52" | "53" | "NN" | "00" | "01" | "02" | "03" | null, "11" | "12" | "21" | "22" | "31" | "32" | "41" | "42" | "51" | "52" | "53" | "NN" | "00" | "01" | "02" | "03" | null>>;
+    trancheEffectifs: z.ZodNullable<z.ZodCustom<"NN" | "00" | "01" | "02" | "03" | "11" | "12" | "21" | "22" | "31" | "32" | "41" | "42" | "51" | "52" | "53" | null, "NN" | "00" | "01" | "02" | "03" | "11" | "12" | "21" | "22" | "31" | "32" | "41" | "42" | "51" | "52" | "53" | null>>;
     trancheEffectifsUniteLegale: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type OrganizationInfo = z.output<typeof OrganizationInfoSchema>;

package/dist/types/user-organization-link.js

@@ -52,7 +52,7 @@ export const InsertUserOrganizationLinkSchema = UserOrganizationLinkSchema.pick(
     organization_id: true,
     user_id: true,
     verification_type: true,
-}).merge(UserOrganizationLinkSchema.pick({
+}).extend(UserOrganizationLinkSchema.pick({
     is_external: true,
     needs_official_contact_email_verification: true,
-}).partial());
+}).partial().shape);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proconnect-gouv/proconnect.identite",
-  "version": "1.7.0",
+  "version": "2.0.0",
   "homepage": "https://github.com/proconnect-gouv/proconnect-identite/tree/main/packages/identite#readme",
   "bugs": "https://github.com/proconnect-gouv/proconnect-identite/issues",
   "repository": {

package/src/connectors/index.ts

@@ -0,0 +1,51 @@
+//
+
+import { type Pool } from "pg";
+import { addDomainFactory } from "../repositories/email-domain/add-domain.js";
+import { deleteEmailDomainsByVerificationTypesFactory } from "../repositories/email-domain/delete-email-domains-by-verification-types.js";
+import { findEmailDomainsByOrganizationIdFactory } from "../repositories/email-domain/find-email-domains-by-organization-id.js";
+import { findByIdFactory as findOrganizationByIdFactory } from "../repositories/organization/find-by-id.js";
+import { findByUserIdFactory } from "../repositories/organization/find-by-user-id.js";
+import { getUsersByOrganizationFactory } from "../repositories/organization/get-users-by-organization.js";
+import { createUserFactory } from "../repositories/user/create.js";
+import { findByEmailFactory } from "../repositories/user/find-by-email.js";
+import { findByIdFactory as findUserByIdFactory } from "../repositories/user/find-by-id.js";
+import { getByIdFactory } from "../repositories/user/get-by-id.js";
+import { getFranceConnectUserInfoFactory } from "../repositories/user/get-franceconnect-user-info.js";
+import { updateUserOrganizationLinkFactory } from "../repositories/user/update-user-organization-link.js";
+import { updateUserFactory } from "../repositories/user/update.js";
+import { upsertFranceconnectUserinfoFactory } from "../repositories/user/upsert-franceconnect-userinfo.js";
+
+//
+
+export function createContext(pg: Pool) {
+  return {
+    repository: {
+      email_domains: {
+        addDomain: addDomainFactory({ pg }),
+        deleteEmailDomainsByVerificationTypes:
+          deleteEmailDomainsByVerificationTypesFactory({ pg }),
+        findEmailDomainsByOrganizationId:
+          findEmailDomainsByOrganizationIdFactory({ pg }),
+      },
+      organizations: {
+        findById: findOrganizationByIdFactory({ pg }),
+        findByUserId: findByUserIdFactory({ pg }),
+        getUsers: getUsersByOrganizationFactory({ pg }),
+      },
+      users_organizations: {
+        update: updateUserOrganizationLinkFactory({ pg }),
+      },
+      users: {
+        create: createUserFactory({ pg }),
+        findByEmail: findByEmailFactory({ pg }),
+        findById: findUserByIdFactory({ pg }),
+        getById: getByIdFactory({ pg }),
+        getFranceConnectUserInfo: getFranceConnectUserInfoFactory({ pg }),
+        update: updateUserFactory({ pg }),
+        upsetFranceconnectUserinfo: upsertFranceconnectUserinfoFactory({ pg }),
+      },
+    },
+  };
+}
+export type Context = ReturnType<typeof createContext>;

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(""),
     );