@proconnect-gouv/proconnect.identite 1.0.0

package/src/repositories/organization/get-users-by-organization.test.ts.snapshot

@@ -0,0 +1,38 @@
+exports[`getUsersByOrganizationFactory > should find users by organization id 1`] = `
+[
+  {
+    "id": 1,
+    "email": "lion.eljonson@darkangels.world",
+    "encrypted_password": "",
+    "reset_password_token": null,
+    "reset_password_sent_at": null,
+    "sign_in_count": 0,
+    "last_sign_in_at": null,
+    "created_at": "4444-04-04T00:00:00.000Z",
+    "updated_at": "4444-04-04T00:00:00.000Z",
+    "email_verified": false,
+    "verify_email_token": null,
+    "verify_email_sent_at": null,
+    "given_name": "lion",
+    "family_name": "el'jonson",
+    "phone_number": "i",
+    "job": "primarque",
+    "magic_link_token": null,
+    "magic_link_sent_at": null,
+    "email_verified_at": null,
+    "current_challenge": null,
+    "needs_inclusionconnect_welcome_page": false,
+    "needs_inclusionconnect_onboarding_help": false,
+    "encrypted_totp_key": null,
+    "totp_key_verified_at": null,
+    "force_2fa": false,
+    "is_external": false,
+    "verification_type": "no_verification_means_available",
+    "verified_at": null,
+    "has_been_greeted": false,
+    "needs_official_contact_email_verification": false,
+    "official_contact_email_verification_token": null,
+    "official_contact_email_verification_sent_at": null
+  }
+]
+`;

package/src/repositories/organization/get-users-by-organization.ts

@@ -0,0 +1,46 @@
+//
+
+import type {
+  BaseUserOrganizationLink,
+  DatabaseContext,
+  User,
+} from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function getUsersByOrganizationFactory({ pg }: DatabaseContext) {
+  return async function getUsersByOrganization(
+    organization_id: number,
+    additionalWhereClause: string = "",
+    additionalParams: any[] = [],
+  ) {
+    const connection = pg;
+    const baseParams = [organization_id];
+
+    const { rows }: QueryResult<User & BaseUserOrganizationLink> =
+      await connection.query(
+        `
+        SELECT
+          u.*,
+          uo.is_external,
+          uo.verification_type,
+          uo.verified_at,
+          uo.has_been_greeted,
+          uo.needs_official_contact_email_verification,
+          uo.official_contact_email_verification_token,
+          uo.official_contact_email_verification_sent_at
+        FROM users u
+        INNER JOIN users_organizations AS uo ON uo.user_id = u.id
+        WHERE uo.organization_id = $1
+        ${additionalWhereClause}`,
+        [...baseParams, ...additionalParams],
+      );
+
+    return rows;
+  };
+}
+
+export type GetUsersByOrganizationHandler = ReturnType<
+  typeof getUsersByOrganizationFactory
+>;

package/src/repositories/organization/index.ts

@@ -0,0 +1,8 @@
+//
+
+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/repositories/organization/link-user-to-organization.test.ts

@@ -0,0 +1,65 @@
+import { emptyDatabase, migrate, pg } from "#testing";
+import { before, beforeEach, mock, suite, test } from "node:test";
+import { linkUserToOrganizationFactory } from "./link-user-to-organization.js";
+
+//
+
+const linkUserToOrganization = linkUserToOrganizationFactory({ pg: pg as any });
+
+suite("linkUserToOrganizationFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+  before(() => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("4444-04-04") });
+  });
+
+  test("should link user to organization", async (t) => {
+    await pg.sql`
+      INSERT INTO organizations
+        (cached_libelle, cached_nom_complet, id, siret, created_at, updated_at)
+      VALUES
+        ('Necron', 'Necrontyr', 1, '⚰️', '1967-12-19', '1967-12-19')
+      ;
+    `;
+    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', 'i', 'primarque')
+      ;
+    `;
+
+    const userOrganizationLink = await linkUserToOrganization({
+      organization_id: 1,
+      user_id: 1,
+      verification_type: null,
+    });
+
+    t.assert.snapshot(userOrganizationLink);
+  });
+
+  test("should mark a user as organization_dirigeant", async (t) => {
+    await pg.sql`
+      INSERT INTO organizations
+        (cached_libelle, cached_nom_complet, id, siret, created_at, updated_at)
+      VALUES
+        ('Necron', 'Necrontyr', 1, '⚰️', '1967-12-19', '1967-12-19')
+      ;
+    `;
+    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', 'i', 'primarque')
+      ;
+    `;
+
+    const userOrganizationLink = await linkUserToOrganization({
+      organization_id: 1,
+      user_id: 1,
+      verification_type: "organization_dirigeant",
+    });
+
+    t.assert.snapshot(userOrganizationLink);
+  });
+});

package/src/repositories/organization/link-user-to-organization.test.ts.snapshot

@@ -0,0 +1,31 @@
+exports[`linkUserToOrganizationFactory > should link user to organization 1`] = `
+{
+  "user_id": 1,
+  "organization_id": 1,
+  "is_external": false,
+  "created_at": "4444-04-04T00:00:00.000Z",
+  "updated_at": "4444-04-04T00:00:00.000Z",
+  "verification_type": null,
+  "has_been_greeted": false,
+  "needs_official_contact_email_verification": false,
+  "official_contact_email_verification_token": null,
+  "official_contact_email_verification_sent_at": null,
+  "verified_at": null
+}
+`;
+
+exports[`linkUserToOrganizationFactory > should mark a user as organization_dirigeant 1`] = `
+{
+  "user_id": 1,
+  "organization_id": 1,
+  "is_external": false,
+  "created_at": "4444-04-04T00:00:00.000Z",
+  "updated_at": "4444-04-04T00:00:00.000Z",
+  "verification_type": "organization_dirigeant",
+  "has_been_greeted": false,
+  "needs_official_contact_email_verification": false,
+  "official_contact_email_verification_token": null,
+  "official_contact_email_verification_sent_at": null,
+  "verified_at": "4444-04-04T00:00:00.000Z"
+}
+`;

package/src/repositories/organization/link-user-to-organization.ts

@@ -0,0 +1,45 @@
+import { hashToPostgresParams } from "#src/services/postgres";
+import type {
+  DatabaseContext,
+  InsertUserOrganizationLink,
+  UserOrganizationLink,
+} from "#src/types";
+import type { QueryResult } from "pg";
+
+export function linkUserToOrganizationFactory({ pg }: DatabaseContext) {
+  return async function linkUserToOrganization({
+    is_external = false,
+    needs_official_contact_email_verification = false,
+    organization_id,
+    user_id,
+    verification_type,
+  }: InsertUserOrganizationLink) {
+    const { paramsString, valuesString, values } =
+      hashToPostgresParams<UserOrganizationLink>({
+        created_at: new Date(),
+        is_external,
+        needs_official_contact_email_verification,
+        organization_id,
+        updated_at: new Date(),
+        user_id,
+        verification_type,
+        verified_at: verification_type ? new Date() : undefined,
+      });
+
+    const { rows }: QueryResult<UserOrganizationLink> = await pg.query(
+      `
+      INSERT INTO users_organizations
+        ${paramsString}
+      VALUES
+        ${valuesString}
+      RETURNING *;`,
+      values,
+    );
+
+    return rows.shift()!;
+  };
+}
+
+export type LinkUserToOrganizationHandler = ReturnType<
+  typeof linkUserToOrganizationFactory
+>;

package/src/repositories/organization/upsert.ts

@@ -0,0 +1,142 @@
+//
+
+import type {
+  DatabaseContext,
+  Organization,
+  OrganizationInfo,
+} from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function upsertFactory({ pg }: DatabaseContext) {
+  return async function upsert({
+    siret,
+    organizationInfo: {
+      libelle: cached_libelle,
+      nomComplet: cached_nom_complet,
+      enseigne: cached_enseigne,
+      trancheEffectifs: cached_tranche_effectifs,
+      trancheEffectifsUniteLegale: cached_tranche_effectifs_unite_legale,
+      libelleTrancheEffectif: cached_libelle_tranche_effectif,
+      etatAdministratif: cached_etat_administratif,
+      estActive: cached_est_active,
+      statutDiffusion: cached_statut_diffusion,
+      estDiffusible: cached_est_diffusible,
+      adresse: cached_adresse,
+      codePostal: cached_code_postal,
+      codeOfficielGeographique: cached_code_officiel_geographique,
+      activitePrincipale: cached_activite_principale,
+      libelleActivitePrincipale: cached_libelle_activite_principale,
+      categorieJuridique: cached_categorie_juridique,
+      libelleCategorieJuridique: cached_libelle_categorie_juridique,
+    },
+  }: {
+    siret: string;
+    organizationInfo: OrganizationInfo;
+  }) {
+    const { rows }: QueryResult<Organization> = await pg.query(
+      `
+    INSERT INTO organizations
+      (
+        siret,
+        cached_libelle,
+        cached_nom_complet,
+        cached_enseigne,
+        cached_tranche_effectifs,
+        cached_tranche_effectifs_unite_legale,
+        cached_libelle_tranche_effectif,
+        cached_etat_administratif,
+        cached_est_active,
+        cached_statut_diffusion,
+        cached_est_diffusible,
+        cached_adresse,
+        cached_code_postal,
+        cached_code_officiel_geographique,
+        cached_activite_principale,
+        cached_libelle_activite_principale,
+        cached_categorie_juridique,
+        cached_libelle_categorie_juridique,
+        organization_info_fetched_at,
+        updated_at,
+        created_at
+      )
+    VALUES
+      ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)
+    ON CONFLICT (siret)
+    DO UPDATE
+    SET (
+        siret,
+        cached_libelle,
+        cached_nom_complet,
+        cached_enseigne,
+        cached_tranche_effectifs,
+        cached_tranche_effectifs_unite_legale,
+        cached_libelle_tranche_effectif,
+        cached_etat_administratif,
+        cached_est_active,
+        cached_statut_diffusion,
+        cached_est_diffusible,
+        cached_adresse,
+        cached_code_postal,
+        cached_code_officiel_geographique,
+        cached_activite_principale,
+        cached_libelle_activite_principale,
+        cached_categorie_juridique,
+        cached_libelle_categorie_juridique,
+        organization_info_fetched_at,
+        updated_at
+    ) = (
+        EXCLUDED.siret,
+        EXCLUDED.cached_libelle,
+        EXCLUDED.cached_nom_complet,
+        EXCLUDED.cached_enseigne,
+        EXCLUDED.cached_tranche_effectifs,
+        EXCLUDED.cached_tranche_effectifs_unite_legale,
+        EXCLUDED.cached_libelle_tranche_effectif,
+        EXCLUDED.cached_etat_administratif,
+        EXCLUDED.cached_est_active,
+        EXCLUDED.cached_statut_diffusion,
+        EXCLUDED.cached_est_diffusible,
+        EXCLUDED.cached_adresse,
+        EXCLUDED.cached_code_postal,
+        EXCLUDED.cached_code_officiel_geographique,
+        EXCLUDED.cached_activite_principale,
+        EXCLUDED.cached_libelle_activite_principale,
+        EXCLUDED.cached_categorie_juridique,
+        EXCLUDED.cached_libelle_categorie_juridique,
+        EXCLUDED.organization_info_fetched_at,
+        EXCLUDED.updated_at
+    )
+  RETURNING *
+  `,
+      [
+        siret,
+        cached_libelle,
+        cached_nom_complet,
+        cached_enseigne,
+        cached_tranche_effectifs,
+        cached_tranche_effectifs_unite_legale,
+        cached_libelle_tranche_effectif,
+        cached_etat_administratif,
+        cached_est_active,
+        cached_statut_diffusion,
+        cached_est_diffusible,
+        cached_adresse,
+        cached_code_postal,
+        cached_code_officiel_geographique,
+        cached_activite_principale,
+        cached_libelle_activite_principale,
+        cached_categorie_juridique,
+        cached_libelle_categorie_juridique,
+        new Date(),
+        new Date(),
+        new Date(),
+      ],
+    );
+
+    return rows.shift()!;
+  };
+}
+
+export type UpsertHandler = ReturnType<typeof upsertFactory>;

package/src/repositories/organization/upset.test.ts

@@ -0,0 +1,95 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, mock, suite, test } from "node:test";
+import { upsertFactory } from "./upsert.js";
+
+//
+
+const upset = upsertFactory({ pg: pg as any });
+
+suite("upset", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+  before(() => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("4444-04-04") });
+  });
+
+  test("should create the Tau Empire organization", async () => {
+    const organization = await upset({
+      organizationInfo: {
+        libelle: "Tau Empire",
+        nomComplet: "Tau Empire",
+      } as any,
+      siret: "👽️",
+    });
+
+    assert.deepEqual(organization, {
+      cached_activite_principale: null,
+      cached_adresse: null,
+      cached_categorie_juridique: null,
+      cached_code_officiel_geographique: null,
+      cached_code_postal: null,
+      cached_enseigne: null,
+      cached_est_active: null,
+      cached_est_diffusible: null,
+      cached_etat_administratif: null,
+      cached_libelle: "Tau Empire",
+      cached_libelle_activite_principale: null,
+      cached_libelle_categorie_juridique: null,
+      cached_libelle_tranche_effectif: null,
+      cached_nom_complet: "Tau Empire",
+      cached_statut_diffusion: null,
+      cached_tranche_effectifs: null,
+      cached_tranche_effectifs_unite_legale: null,
+      created_at: new Date("4444-04-04"),
+      id: 1,
+      organization_info_fetched_at: new Date("4444-04-04"),
+      siret: "👽️",
+      updated_at: new Date("4444-04-04"),
+    });
+  });
+
+  test("should update the Necron organization", async () => {
+    await pg.sql`
+      INSERT INTO organizations
+        (siret, created_at, updated_at)
+      VALUES
+        ('⚰️', '1967-12-19', '1967-12-19');
+    `;
+
+    const organization = await upset({
+      organizationInfo: {
+        libelle: "Necron",
+        nomComplet: "Necrontyr",
+      } as any,
+      siret: "⚰️",
+    });
+
+    assert.deepEqual(organization, {
+      cached_activite_principale: null,
+      cached_adresse: null,
+      cached_categorie_juridique: null,
+      cached_code_officiel_geographique: null,
+      cached_code_postal: null,
+      cached_enseigne: null,
+      cached_est_active: null,
+      cached_est_diffusible: null,
+      cached_etat_administratif: null,
+      cached_libelle: "Necron",
+      cached_libelle_activite_principale: null,
+      cached_libelle_categorie_juridique: null,
+      cached_libelle_tranche_effectif: null,
+      cached_nom_complet: "Necrontyr",
+      cached_statut_diffusion: null,
+      cached_tranche_effectifs: null,
+      cached_tranche_effectifs_unite_legale: null,
+      created_at: new Date("1967-12-19"),
+      id: 1,
+      organization_info_fetched_at: new Date("4444-04-04"),
+      siret: "⚰️",
+      updated_at: new Date("4444-04-04"),
+    });
+  });
+});

package/src/repositories/user/create.test.ts

@@ -0,0 +1,49 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, mock, suite, test } from "node:test";
+import { createUserFactory } from "./create.js";
+
+//
+
+const createUser = createUserFactory({ pg: pg as any });
+
+suite("createUserFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  test("should create the god-emperor of mankind", async () => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("4444-04-04") });
+
+    const user = await createUser({ email: "god-emperor@mankind" });
+
+    assert.deepEqual(user, {
+      created_at: new Date("4444-04-04"),
+      current_challenge: null,
+      email: "god-emperor@mankind",
+      email_verified: false,
+      email_verified_at: null,
+      encrypted_password: null,
+      encrypted_totp_key: null,
+      family_name: null,
+      force_2fa: false,
+      given_name: null,
+      id: 1,
+      job: null,
+      last_sign_in_at: null,
+      magic_link_sent_at: null,
+      magic_link_token: null,
+      needs_inclusionconnect_onboarding_help: false,
+      needs_inclusionconnect_welcome_page: false,
+      phone_number: null,
+      reset_password_sent_at: null,
+      reset_password_token: null,
+      sign_in_count: 0,
+      totp_key_verified_at: null,
+      updated_at: new Date("4444-04-04"),
+      verify_email_sent_at: null,
+      verify_email_token: null,
+    });
+  });
+});

package/src/repositories/user/create.ts

@@ -0,0 +1,44 @@
+//
+
+import { hashToPostgresParams } from "#src/services/postgres";
+import type { DatabaseContext, User } from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function createUserFactory({ pg }: DatabaseContext) {
+  return async function createUser({
+    email,
+    encrypted_password = null,
+  }: {
+    email: string;
+    encrypted_password?: string | null;
+  }) {
+    const userWithTimestamps = {
+      email,
+      email_verified: false,
+      verify_email_token: null,
+      verify_email_sent_at: null,
+      encrypted_password,
+      magic_link_token: null,
+      magic_link_sent_at: null,
+      reset_password_token: null,
+      reset_password_sent_at: null,
+      sign_in_count: 0,
+      last_sign_in_at: null,
+      created_at: new Date(),
+      updated_at: new Date(),
+    };
+
+    const { paramsString, valuesString, values } =
+      hashToPostgresParams<User>(userWithTimestamps);
+
+    const { rows }: QueryResult<User> = await pg.query(
+      `INSERT INTO users ${paramsString} VALUES ${valuesString} RETURNING *;`,
+      values,
+    );
+    return rows.shift()!;
+  };
+}
+
+export type CreateUserHandler = ReturnType<typeof createUserFactory>;

package/src/repositories/user/find-by-email.test.ts

@@ -0,0 +1,62 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, suite, test } from "node:test";
+import { findByEmailFactory } from "./find-by-email.js";
+
+//
+
+const findByEmail = findByEmailFactory({ pg: pg as any });
+
+suite("findByEmailFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  test("should find a user by email", async () => {
+    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', 'i', 'primarque'),
+        (2, 'perturabo@ironwarriors.world', '4444-04-04', '4444-04-04', 'lion', 'el''jonson', 'iv', 'primarque')
+      ;
+    `;
+
+    const user = await findByEmail("lion.eljonson@darkangels.world");
+
+    assert.deepEqual(user, {
+      created_at: new Date("4444-04-04"),
+      current_challenge: null,
+      email: "lion.eljonson@darkangels.world",
+      email_verified: false,
+      email_verified_at: null,
+      encrypted_password: "",
+      encrypted_totp_key: null,
+      family_name: "el'jonson",
+      force_2fa: false,
+      given_name: "lion",
+      id: 1,
+      job: "primarque",
+      last_sign_in_at: null,
+      magic_link_sent_at: null,
+      magic_link_token: null,
+      needs_inclusionconnect_onboarding_help: false,
+      needs_inclusionconnect_welcome_page: false,
+      phone_number: "i",
+      reset_password_sent_at: null,
+      reset_password_token: null,
+      sign_in_count: 0,
+      totp_key_verified_at: null,
+      updated_at: new Date("4444-04-04"),
+      verify_email_sent_at: null,
+      verify_email_token: null,
+    });
+  });
+
+  test("❎ fail to find the God-Emperor of Mankind", async () => {
+    const user = await findByEmail("the God-Emperor of Mankind");
+
+    assert.deepEqual(user, undefined);
+  });
+});

package/src/repositories/user/find-by-email.ts

@@ -0,0 +1,22 @@
+//
+
+import type { DatabaseContext, User } from "#src/types";
+import { type QueryResult } from "pg";
+
+//
+
+export function findByEmailFactory({ pg }: DatabaseContext) {
+  return async function findByEmail(email: string) {
+    const { rows }: QueryResult<User> = await pg.query(
+      `
+      SELECT *
+      FROM users WHERE email = $1
+      `,
+      [email],
+    );
+
+    return rows.shift();
+  };
+}
+
+export type FindByEmailHandler = ReturnType<typeof findByEmailFactory>;