@proconnect-gouv/proconnect.identite 1.0.0

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

@@ -0,0 +1,48 @@
+//
+
+import { hashToPostgresParams } from "#src/services/postgres";
+import type { DatabaseContext, EmailDomain } from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function addDomainFactory({ pg }: DatabaseContext) {
+  return async function addDomain({
+    organization_id,
+    domain,
+    verification_type,
+  }: {
+    organization_id: number;
+    domain: string;
+    verification_type: EmailDomain["verification_type"];
+  }) {
+    const connection = pg;
+
+    const emailDomain = {
+      organization_id,
+      domain,
+      verification_type,
+      can_be_suggested: true,
+      verified_at: new Date(),
+      created_at: new Date(),
+      updated_at: new Date(),
+    };
+
+    const { paramsString, valuesString, values } =
+      hashToPostgresParams<EmailDomain>(emailDomain);
+
+    const { rows }: QueryResult<EmailDomain> = await connection.query(
+      `
+      INSERT INTO email_domains
+        ${paramsString}
+      VALUES
+        ${valuesString}
+      RETURNING *;`,
+      values,
+    );
+
+    return rows.shift()!;
+  };
+}
+
+export type AddDomainHandler = ReturnType<typeof addDomainFactory>;

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

@@ -0,0 +1,49 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, describe, it } from "node:test";
+import { deleteEmailDomainsByVerificationTypesFactory } from "./delete-email-domains-by-verification-types.js";
+
+//
+
+const deleteEmailDomainsByVerificationTypes =
+  deleteEmailDomainsByVerificationTypesFactory({
+    pg: pg as any,
+  });
+
+describe("deleteEmailDomainsByVerificationTypesFactory", function () {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  it("should delete domain verification type NULL and 'verified'", async () => {
+    await pg.sql`
+      INSERT INTO organizations
+        (id, siret, created_at, updated_at)
+      VALUES
+        (1, '66204244933106', '3333-03-03', '3333-04-04')
+      ;
+    `;
+
+    await pg.sql`
+      INSERT INTO email_domains
+        (domain, organization_id, verification_type)
+      VALUES
+        ('darkangels.world', 1, NULL),
+        ('darkangels.world', 1, 'verified')
+      ;
+    `;
+
+    const result = await deleteEmailDomainsByVerificationTypes({
+      domain: "darkangels.world",
+      organization_id: 1,
+      domain_verification_types: [null, "verified"],
+    });
+
+    assert.deepEqual(result, {
+      affectedRows: 2,
+      fields: [],
+      rows: [],
+    });
+  });
+});

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

@@ -0,0 +1,45 @@
+//
+
+import type { DatabaseContext, EmailDomain } from "#src/types";
+
+//
+
+export function deleteEmailDomainsByVerificationTypesFactory({
+  pg,
+}: DatabaseContext) {
+  return async function deleteEmailDomainsByVerificationTypes({
+    organization_id,
+    domain,
+    domain_verification_types,
+  }: {
+    organization_id: EmailDomain["organization_id"];
+    domain_verification_types: EmailDomain["verification_type"][];
+    domain: EmailDomain["domain"];
+  }) {
+    const SQL_VERIFICATION_TYPES = domain_verification_types
+      .map((type) =>
+        type === null
+          ? "verification_type IS NULL"
+          : `verification_type = '${type}'`,
+      )
+      .join(" OR ");
+
+    return pg.query(
+      `
+      DELETE FROM email_domains
+      WHERE
+        ${[
+          "organization_id = $1",
+          "domain = $2",
+          `(${SQL_VERIFICATION_TYPES})`,
+        ].join(" AND ")}
+      ;
+      `,
+      [organization_id, domain],
+    );
+  };
+}
+
+export type DeleteEmailDomainsByVerificationTypesHandler = ReturnType<
+  typeof deleteEmailDomainsByVerificationTypesFactory
+>;

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

@@ -0,0 +1,55 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, describe, it } from "node:test";
+import { findEmailDomainsByOrganizationIdFactory } from "./find-email-domains-by-organization-id.js";
+
+//
+
+const findEmailDomainsByOrganizationId =
+  findEmailDomainsByOrganizationIdFactory({ pg: pg as any });
+
+describe("findEmailDomainsByOrganizationIdFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  it("should find email domains by organization id", async () => {
+    await pg.sql`
+      INSERT INTO organizations
+        (id, siret, created_at, updated_at)
+      VALUES
+        (1, '66204244933106', '4444-04-04', '4444-04-04')
+      ;
+    `;
+
+    await pg.sql`
+      INSERT INTO email_domains
+        (id, domain, organization_id, created_at, updated_at)
+      VALUES
+        (1, 'darkangels.world', 1, '4444-04-04', '4444-04-04')
+      ;
+    `;
+
+    const emailDomains = await findEmailDomainsByOrganizationId(1);
+
+    assert.deepEqual(emailDomains, [
+      {
+        can_be_suggested: true,
+        created_at: new Date("4444-04-04"),
+        domain: "darkangels.world",
+        id: 1,
+        organization_id: 1,
+        updated_at: new Date("4444-04-04"),
+        verification_type: null,
+        verified_at: null,
+      },
+    ]);
+  });
+
+  it("❎ fail to find the organization 42", async () => {
+    const user = await findEmailDomainsByOrganizationId(42);
+
+    assert.deepEqual(user, []);
+  });
+});

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

@@ -0,0 +1,28 @@
+//
+
+import type { DatabaseContext, EmailDomain } from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function findEmailDomainsByOrganizationIdFactory({
+  pg,
+}: DatabaseContext) {
+  return async function findEmailDomainsByOrganizationId(
+    organization_id: number,
+  ) {
+    const { rows }: QueryResult<EmailDomain> = await pg.query(
+      `
+      SELECT *
+      FROM email_domains
+      WHERE organization_id = $1`,
+      [organization_id],
+    );
+
+    return rows;
+  };
+}
+
+export type FindEmailDomainsByOrganizationIdHandler = ReturnType<
+  typeof findEmailDomainsByOrganizationIdFactory
+>;

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

@@ -0,0 +1,13 @@
+export * from "./add-domain.js";
+export * from "./delete-email-domains-by-verification-types.js";
+export * from "./find-email-domains-by-organization-id.js";
+
+import type { AddDomainHandler } from "./add-domain.js";
+import type { DeleteEmailDomainsByVerificationTypesHandler } from "./delete-email-domains-by-verification-types.js";
+import type { FindEmailDomainsByOrganizationIdHandler } from "./find-email-domains-by-organization-id.js";
+
+export type EmailDomainRepository = {
+  addDomain: AddDomainHandler;
+  deleteEmailDomainsByVerificationTypes: DeleteEmailDomainsByVerificationTypesHandler;
+  findEmailDomainsByOrganizationId: FindEmailDomainsByOrganizationIdHandler;
+};

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

@@ -0,0 +1,51 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, suite, test } from "node:test";
+import { findByIdFactory } from "./find-by-id.js";
+
+//
+
+const findById = findByIdFactory({ pg: pg as any });
+
+suite("findByIdFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  test("should find the Necron organization", async () => {
+    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')
+      ;
+    `;
+    const organization = await findById(1);
+
+    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_activite_principale: null,
+      cached_libelle_categorie_juridique: null,
+      cached_libelle_tranche_effectif: null,
+      cached_libelle: "Necron",
+      cached_nom_complet: "Necrontyr",
+      cached_statut_diffusion: null,
+      cached_tranche_effectifs_unite_legale: null,
+      cached_tranche_effectifs: null,
+      created_at: new Date("1967-12-19"),
+      organization_info_fetched_at: null,
+      id: 1,
+      siret: "⚰️",
+      updated_at: new Date("1967-12-19"),
+    });
+  });
+});

package/src/repositories/organization/find-by-id.ts

@@ -0,0 +1,22 @@
+//
+
+import type { DatabaseContext, Organization } from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function findByIdFactory({ pg }: DatabaseContext) {
+  return async function findById(id: number) {
+    const { rows }: QueryResult<Organization> = await pg.query(
+      `
+      SELECT *
+      FROM organizations
+      WHERE id = $1`,
+      [id],
+    );
+
+    return rows.shift();
+  };
+}
+
+export type FindByIdHandler = ReturnType<typeof findByIdFactory>;

package/src/repositories/organization/find-by-user-id.test.ts

@@ -0,0 +1,70 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, suite, test } from "node:test";
+import { findByUserIdFactory } from "./find-by-user-id.js";
+
+//
+
+const findByUserId = findByUserIdFactory({ pg: pg as any });
+
+suite("findByUserIdFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+  beforeEach(seed);
+
+  test("should return empty array when user has no organizations", async () => {
+    const organizations = await findByUserId(42);
+    assert.deepEqual(organizations, []);
+  });
+
+  test("should return single organization when user has one organization", async (t) => {
+    const organizations = await findByUserId(6);
+    t.assert.snapshot(organizations);
+  });
+
+  test("should return multiple organizations when user has multiple organizations", async (t) => {
+    const organizations = await findByUserId(1);
+    t.assert.snapshot(organizations);
+  });
+});
+
+//
+
+async function seed() {
+  await pg.sql`
+    INSERT INTO organizations
+      (id, cached_libelle, cached_nom_complet, siret, created_at, updated_at)
+    VALUES
+      (1, '⚰️', 'Sautekh Dynasty', '40000000000001', '2023-01-15', '2024-02-10'),
+      (2, '💀', 'Nihilakh Dynasty', '40000000000002', '2023-02-20', '2024-03-05'),
+      (3, '🤖', 'Szarekhan Dynasty', '40000000000003', '2023-03-25', '2024-04-12'),
+      (4, '🔥', 'Adeptus Mechanicus', '40000000000004', '2023-04-10', '2024-05-15'),
+      (5, '👨‍🚀', 'Ultramarines Chapter', '40000000000005', '2023-05-05', '2024-06-20'),
+      (6, '👹', 'Death Guard', '40000000000006', '2023-06-15', '2024-07-25')
+    ;
+  `;
+
+  await pg.sql`
+    INSERT INTO users
+      (id, email, created_at, updated_at, given_name, family_name, phone_number, job)
+    VALUES
+      (1, 'imotekh@sautekh.necron', '2023-01-20', '2024-02-15', 'Imotekh', 'The Stormlord', '00000000001', 'Phaeron'),
+      (2, 'trazyn@nihilakh.necron', '2023-02-25', '2024-03-10', 'Trazyn', 'The Infinite', '00000000002', 'Archaeologist'),
+      (6, 'marneus.calgar@ultramar.imperium', '2023-06-20', '2024-07-30', 'Marneus', 'Calgar', '00000000006', 'Chapter Master'),
+      (7, 'mortarion@plague.chaos', '2023-07-25', '2024-08-05', 'Mortarion', 'Primarch', '00000000007', 'Daemon Primarch')
+    ;
+  `;
+
+  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, has_been_greeted)
+    VALUES
+      (1, 1, '2023-01-25', '2024-02-20', false, 'necron', false, 'necron_token_1', '2023-01-26', true),
+      (1, 3, '2023-04-01', '2024-05-05', true, 'alliance', true, 'alliance_token_1', '2023-04-02', false),
+      (2, 2, '2023-03-01', '2024-04-01', false, 'necron', false, 'necron_token_2', '2023-03-02', true),
+      (6, 5, '2023-07-05', '2024-08-15', false, 'imperial', false, 'imperial_token_6', '2023-07-06', true)
+    ;
+  `;
+}

package/src/repositories/organization/find-by-user-id.test.ts.snapshot

@@ -0,0 +1,102 @@
+exports[`findByUserIdFactory > should return multiple organizations when user has multiple organizations 1`] = `
+[
+  {
+    "id": 1,
+    "siret": "40000000000001",
+    "created_at": "2023-01-15T00:00:00.000Z",
+    "updated_at": "2024-02-10T00:00:00.000Z",
+    "cached_libelle": "⚰️",
+    "cached_nom_complet": "Sautekh Dynasty",
+    "cached_enseigne": null,
+    "cached_tranche_effectifs": null,
+    "cached_tranche_effectifs_unite_legale": null,
+    "cached_libelle_tranche_effectif": null,
+    "cached_etat_administratif": null,
+    "cached_est_active": null,
+    "cached_statut_diffusion": null,
+    "cached_est_diffusible": null,
+    "cached_adresse": null,
+    "cached_code_postal": null,
+    "cached_activite_principale": null,
+    "cached_libelle_activite_principale": null,
+    "cached_categorie_juridique": null,
+    "cached_libelle_categorie_juridique": null,
+    "organization_info_fetched_at": null,
+    "cached_code_officiel_geographique": null,
+    "is_external": false,
+    "verification_type": "necron",
+    "verified_at": null,
+    "has_been_greeted": true,
+    "needs_official_contact_email_verification": false,
+    "official_contact_email_verification_token": "necron_token_1",
+    "official_contact_email_verification_sent_at": "2023-01-26T00:00:00.000Z"
+  },
+  {
+    "id": 3,
+    "siret": "40000000000003",
+    "created_at": "2023-03-25T00:00:00.000Z",
+    "updated_at": "2024-04-12T00:00:00.000Z",
+    "cached_libelle": "🤖",
+    "cached_nom_complet": "Szarekhan Dynasty",
+    "cached_enseigne": null,
+    "cached_tranche_effectifs": null,
+    "cached_tranche_effectifs_unite_legale": null,
+    "cached_libelle_tranche_effectif": null,
+    "cached_etat_administratif": null,
+    "cached_est_active": null,
+    "cached_statut_diffusion": null,
+    "cached_est_diffusible": null,
+    "cached_adresse": null,
+    "cached_code_postal": null,
+    "cached_activite_principale": null,
+    "cached_libelle_activite_principale": null,
+    "cached_categorie_juridique": null,
+    "cached_libelle_categorie_juridique": null,
+    "organization_info_fetched_at": null,
+    "cached_code_officiel_geographique": null,
+    "is_external": true,
+    "verification_type": "alliance",
+    "verified_at": null,
+    "has_been_greeted": false,
+    "needs_official_contact_email_verification": true,
+    "official_contact_email_verification_token": "alliance_token_1",
+    "official_contact_email_verification_sent_at": "2023-04-02T00:00:00.000Z"
+  }
+]
+`;
+
+exports[`findByUserIdFactory > should return single organization when user has one organization 1`] = `
+[
+  {
+    "id": 5,
+    "siret": "40000000000005",
+    "created_at": "2023-05-05T00:00:00.000Z",
+    "updated_at": "2024-06-20T00:00:00.000Z",
+    "cached_libelle": "👨‍🚀",
+    "cached_nom_complet": "Ultramarines Chapter",
+    "cached_enseigne": null,
+    "cached_tranche_effectifs": null,
+    "cached_tranche_effectifs_unite_legale": null,
+    "cached_libelle_tranche_effectif": null,
+    "cached_etat_administratif": null,
+    "cached_est_active": null,
+    "cached_statut_diffusion": null,
+    "cached_est_diffusible": null,
+    "cached_adresse": null,
+    "cached_code_postal": null,
+    "cached_activite_principale": null,
+    "cached_libelle_activite_principale": null,
+    "cached_categorie_juridique": null,
+    "cached_libelle_categorie_juridique": null,
+    "organization_info_fetched_at": null,
+    "cached_code_officiel_geographique": null,
+    "is_external": false,
+    "verification_type": "imperial",
+    "verified_at": null,
+    "has_been_greeted": true,
+    "needs_official_contact_email_verification": false,
+    "official_contact_email_verification_token": "imperial_token_6",
+    "official_contact_email_verification_sent_at": "2023-07-06T00:00:00.000Z"
+  }
+]
+`;

package/src/repositories/organization/find-by-user-id.ts

@@ -0,0 +1,38 @@
+//
+
+import type {
+  BaseUserOrganizationLink,
+  DatabaseContext,
+  Organization,
+} from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function findByUserIdFactory({ pg }: DatabaseContext) {
+  return async function findByUserId(userId: number) {
+    const { rows }: QueryResult<Organization & BaseUserOrganizationLink> =
+      await pg.query(
+        `
+        SELECT
+          o.*,
+          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 organizations o
+        INNER JOIN users_organizations uo ON uo.organization_id = o.id
+        WHERE uo.user_id = $1
+        ORDER BY o.created_at
+      `,
+        [userId],
+      );
+
+    return rows;
+  };
+}
+
+export type FindByUserIdHandler = ReturnType<typeof findByUserIdFactory>;

package/src/repositories/organization/get-by-id.test.ts

@@ -0,0 +1,60 @@
+//
+
+import { OrganizationNotFoundError } from "#src/errors";
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, suite, test } from "node:test";
+import { getByIdFactory } from "./get-by-id.js";
+
+//
+
+const getById = getByIdFactory({ pg: pg as any });
+
+suite("getByIdFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  test("should find a user by id", async () => {
+    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')
+      ;
+    `;
+
+    const organization = await getById(1);
+
+    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_activite_principale: null,
+      cached_libelle_categorie_juridique: null,
+      cached_libelle_tranche_effectif: null,
+      cached_libelle: "Necron",
+      cached_nom_complet: "Necrontyr",
+      cached_statut_diffusion: null,
+      cached_tranche_effectifs_unite_legale: null,
+      cached_tranche_effectifs: null,
+      created_at: new Date("1967-12-19"),
+      organization_info_fetched_at: null,
+      id: 1,
+      siret: "⚰️",
+      updated_at: new Date("1967-12-19"),
+    });
+  });
+
+  test("❎ fail to find the God-Emperor of Mankind", async () => {
+    await assert.rejects(
+      getById(42),
+      new OrganizationNotFoundError("Organization not found"),
+    );
+  });
+});

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

@@ -0,0 +1,21 @@
+//
+
+import { OrganizationNotFoundError } from "#src/errors";
+import type { DatabaseContext } from "#src/types";
+import { isEmpty } from "lodash-es";
+import { findByIdFactory } from "./find-by-id.js";
+
+//
+
+export function getByIdFactory({ pg }: DatabaseContext) {
+  const findById = findByIdFactory({ pg });
+  return async function getById(id: number) {
+    const organization = await findById(id);
+    if (isEmpty(organization)) {
+      throw new OrganizationNotFoundError("Organization not found");
+    }
+    return organization;
+  };
+}
+
+export type GetByIdHandler = ReturnType<typeof getByIdFactory>;

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

@@ -0,0 +1,50 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, describe, it } from "node:test";
+import { getUsersByOrganizationFactory } from "./get-users-by-organization.js";
+
+//
+
+const getUsersByOrganization = getUsersByOrganizationFactory({ pg: pg as any });
+
+describe("getUsersByOrganizationFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  it("should find users by organization id", 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')
+      ;
+    `;
+
+    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_available', false, null, null)
+      ;
+    `;
+
+    const user = await getUsersByOrganization(1);
+
+    t.assert.snapshot(user);
+  });
+
+  it("❎ fail to find users for unknown organization id", async () => {
+    const user = await getUsersByOrganization(42);
+    assert.deepEqual(user, []);
+  });
+});