@proconnect-gouv/proconnect.identite 1.0.0

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

@@ -0,0 +1,64 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, mock, 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 a user by id", async () => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("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', 'i', 'primarque'),
+        (2, 'perturabo@ironwarriors.world', '4444-04-04', '4444-04-04', 'lion', 'el''jonson', 'iv', 'primarque')
+      ;
+    `;
+
+    const user = await findById(1);
+
+    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 findById(42);
+
+    assert.equal(user, undefined);
+  });
+});

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

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

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

@@ -0,0 +1,63 @@
+//
+
+import { UserNotFoundError } from "#src/errors";
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, mock, 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 () => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("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', 'i', 'primarque'),
+        (2, 'perturabo@ironwarriors.world', '4444-04-04', '4444-04-04', 'lion', 'el''jonson', 'iv', 'primarque')
+      ;
+    `;
+
+    const user = await getById(1);
+
+    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 () => {
+    await assert.rejects(getById(42), new UserNotFoundError("User not found"));
+  });
+});

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

@@ -0,0 +1,21 @@
+//
+
+import { UserNotFoundError } 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 user = await findById(id);
+    if (isEmpty(user)) {
+      throw new UserNotFoundError("User not found");
+    }
+    return user;
+  };
+}
+
+export type GetByIdHandler = ReturnType<typeof getByIdFactory>;

package/src/repositories/user/get-franceconnect-user-info.test.ts

@@ -0,0 +1,58 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, describe, it, mock } from "node:test";
+import { getFranceConnectUserInfoFactory } from "./get-franceconnect-user-info.js";
+
+//
+
+const getFranceConnectUserInfo = getFranceConnectUserInfoFactory({
+  pg: pg as any,
+});
+
+describe("getFranceConnectUserInfo", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+  before(() => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("4444-04-04") });
+  });
+
+  it("should get franceconnect user info", 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')
+      ;
+    `;
+    await pg.sql`
+      INSERT INTO franceconnect_userinfo
+        (user_id, birthdate, birthplace, family_name, gender, given_name, preferred_username, sub, created_at, updated_at)
+        VALUES
+        (1, '8888-08-08', 'Caliban', 'El’Jonson', 'male', 'Li', 'Li', 'abcdefghijklmnopqrstuvwxyz', '4444-04-04', '4444-04-04')
+      ;
+    `;
+
+    const user = await getFranceConnectUserInfo(1);
+    assert.ok(user);
+    assert.deepEqual(user, {
+      birthdate: new Date("8888-08-08"),
+      birthplace: "Caliban",
+      created_at: new Date("4444-04-04"),
+      family_name: "El’Jonson",
+      gender: "male",
+      given_name: "Li",
+      preferred_username: "Li",
+      sub: "abcdefghijklmnopqrstuvwxyz",
+      updated_at: new Date(),
+      user_id: 1,
+    });
+  });
+
+  it("❎ fail to get an unknown user", async () => {
+    const user = await getFranceConnectUserInfo(42);
+
+    assert.equal(user, undefined);
+  });
+});

package/src/repositories/user/get-franceconnect-user-info.ts

@@ -0,0 +1,25 @@
+//
+
+import type { DatabaseContext, FranceConnectUserInfo } from "#src/types";
+import { type QueryResult } from "pg";
+
+//
+
+export function getFranceConnectUserInfoFactory({ pg }: DatabaseContext) {
+  return async function getFranceConnectUserInfo(user_id: number) {
+    const { rows }: QueryResult<FranceConnectUserInfo> = await pg.query(
+      `
+      SELECT *
+      FROM franceconnect_userinfo
+      WHERE user_id = $1
+      `,
+      [user_id],
+    );
+
+    return rows.shift();
+  };
+}
+
+export type GetFranceConnectUserInfoHandler = ReturnType<
+  typeof getFranceConnectUserInfoFactory
+>;

package/src/repositories/user/index.ts

@@ -0,0 +1,10 @@
+//
+
+export * from "./create.js";
+export * from "./find-by-email.js";
+export * from "./find-by-id.js";
+export * from "./get-by-id.js";
+export * from "./get-franceconnect-user-info.js";
+export * from "./update-user-organization-link.js";
+export * from "./update.js";
+export * from "./upsert-franceconnect-userinfo.js";

package/src/repositories/user/update-user-organization-link.test.ts

@@ -0,0 +1,46 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, suite, test } from "node:test";
+import { updateUserOrganizationLinkFactory } from "./update-user-organization-link.js";
+
+//
+
+const updateUserOrganizationLink = updateUserOrganizationLinkFactory({
+  pg: pg as any,
+});
+
+suite("updateUserOrganizationLink", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  test("should update the user organization link", 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')
+      ;
+    `;
+    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 updateUserOrganizationLink(1, 1, {
+      is_external: true,
+    });
+    assert.ok(user.is_external);
+  });
+});

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

@@ -0,0 +1,42 @@
+//
+
+import { hashToPostgresParams } from "#src/services/postgres";
+import type { DatabaseContext, User, UserOrganizationLink } from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function updateUserOrganizationLinkFactory({ pg }: DatabaseContext) {
+  return async function updateUserOrganizationLink(
+    organization_id: number,
+    user_id: number,
+    fieldsToUpdate: Partial<UserOrganizationLink>,
+  ) {
+    const connection = pg;
+
+    const fieldsToUpdateWithTimestamps = {
+      ...fieldsToUpdate,
+      updated_at: new Date(),
+    };
+
+    const { paramsString, valuesString, values } = hashToPostgresParams<User>(
+      fieldsToUpdateWithTimestamps,
+    );
+
+    const { rows }: QueryResult<UserOrganizationLink> = await connection.query(
+      `
+      UPDATE users_organizations SET ${paramsString} = ${valuesString}
+      WHERE organization_id = $${values.length + 1}
+      AND user_id = $${values.length + 2}
+      RETURNING *
+      `,
+      [...values, organization_id, user_id],
+    );
+
+    return rows.shift()!;
+  };
+}
+
+export type UpdateUserOrganizationLinkHandler = ReturnType<
+  typeof updateUserOrganizationLinkFactory
+>;

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

@@ -0,0 +1,26 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, it, suite } from "node:test";
+import { updateUserFactory } from "./update.js";
+
+//
+
+const updateUser = updateUserFactory({ pg: pg as any });
+
+suite("updateUserFactory", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+
+  it("should update the user job", 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');
+    `;
+    const user = await updateUser(1, { job: "Chevalier de l'Ordre" });
+    assert.equal(user.job, "Chevalier de l'Ordre");
+  });
+});

package/src/repositories/user/update.ts

@@ -0,0 +1,34 @@
+//
+
+import { hashToPostgresParams } from "#src/services/postgres";
+import type { DatabaseContext, User } from "#src/types";
+import type { QueryResult } from "pg";
+
+//
+
+export function updateUserFactory({ pg }: DatabaseContext) {
+  return async function updateUser(id: number, fieldsToUpdate: Partial<User>) {
+    const fieldsToUpdateWithTimestamps = {
+      ...fieldsToUpdate,
+      updated_at: new Date(),
+    };
+
+    const { paramsString, valuesString, values } = hashToPostgresParams<User>(
+      fieldsToUpdateWithTimestamps,
+    );
+
+    const { rows }: QueryResult<User> = await pg.query(
+      `
+      UPDATE users
+      SET ${paramsString} = ${valuesString}
+      WHERE id = $${values.length + 1}
+      RETURNING *
+      `,
+      [...values, id],
+    );
+
+    return rows.shift()!;
+  };
+}
+
+export type UpdateUserHandler = ReturnType<typeof updateUserFactory>;

package/src/repositories/user/upsert-franceconnect-userinfo.test.ts

@@ -0,0 +1,100 @@
+//
+
+import { emptyDatabase, migrate, pg } from "#testing";
+import assert from "node:assert/strict";
+import { before, beforeEach, describe, it, mock } from "node:test";
+import { upsertFranceconnectUserinfoFactory } from "./upsert-franceconnect-userinfo.js";
+
+//
+
+const upsertFranceconnectUserinfo = upsertFranceconnectUserinfoFactory({
+  pg: pg as any,
+});
+
+describe("upsertFranceconnectUserinfo", () => {
+  before(migrate);
+  beforeEach(emptyDatabase);
+  before(() => {
+    mock.timers.enable({ apis: ["Date"], now: new Date("4444-04-04") });
+  });
+
+  it("should insert a user franceconnect userinfo", 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')
+      ;
+    `;
+
+    const user = await upsertFranceconnectUserinfo({
+      birthdate: new Date("8888-08-08"),
+      birthplace: "Caliban",
+      created_at: new Date("4444-04-01"),
+      family_name: "El’Jonson",
+      gender: "male",
+      given_name: "Lion",
+      preferred_username: "Li",
+      sub: "abcdefghijklmnopqrstuvwxyz",
+      updated_at: new Date("4444-04-02"),
+      user_id: 1,
+    });
+
+    assert.deepEqual(user, {
+      birthdate: new Date("8888-08-08"),
+      birthplace: "Caliban",
+      created_at: new Date("4444-04-01"),
+      family_name: "El’Jonson",
+      gender: "male",
+      given_name: "Lion",
+      preferred_username: "Li",
+      sub: "abcdefghijklmnopqrstuvwxyz",
+      updated_at: new Date("4444-04-04"),
+      user_id: 1,
+    });
+  });
+
+  it("should update a user Verification link", 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')
+      ;
+    `;
+    await pg.sql`
+      INSERT INTO franceconnect_userinfo
+        (user_id, created_at, updated_at, given_name)
+      VALUES
+        (1, '4444-04-01', '4444-04-02', 'Lion')
+      ;
+    `;
+
+    const user = await upsertFranceconnectUserinfo({
+      user_id: 1,
+      preferred_username: "Li",
+    });
+
+    assert.deepEqual(user, {
+      birthdate: null,
+      birthplace: null,
+      created_at: new Date("4444-04-01"),
+      family_name: null,
+      gender: null,
+      given_name: "Lion",
+      preferred_username: "Li",
+      sub: null,
+      updated_at: new Date("4444-04-04"),
+      user_id: 1,
+    });
+  });
+
+  it("❎ fail to update an unknown user", async () => {
+    await assert.rejects(
+      upsertFranceconnectUserinfo({
+        user_id: 42,
+      }),
+      `error: insert or update on table "franceconnect_userinfo" violates foreign key constraint "franceconnect_userinfo_user_id_fkey"`,
+    );
+  });
+});

package/src/repositories/user/upsert-franceconnect-userinfo.ts

@@ -0,0 +1,41 @@
+//
+
+import { hashToPostgresParams } from "#src/services/postgres";
+import type { DatabaseContext, FranceConnectUserInfo } from "#src/types";
+
+//
+
+export function upsertFranceconnectUserinfoFactory({ pg }: DatabaseContext) {
+  return async function upsertFranceconnectUserinfo(
+    value: Pick<FranceConnectUserInfo, "user_id"> &
+      Partial<FranceConnectUserInfo>,
+  ) {
+    const fieldsWithTimestamps = {
+      ...value,
+      updated_at: new Date(),
+    };
+
+    const { paramsString, valuesString, values } =
+      hashToPostgresParams<FranceConnectUserInfo>(fieldsWithTimestamps);
+
+    const { rows } = await pg.query<FranceConnectUserInfo>(
+      `
+      INSERT INTO franceconnect_userinfo
+        ${paramsString}
+      VALUES
+        ${valuesString}
+      ON CONFLICT (user_id)
+        DO UPDATE
+          SET ${paramsString} = ${valuesString}
+      RETURNING *
+    `,
+      [...values],
+    );
+
+    return rows.shift()!;
+  };
+}
+
+export type UpsetFranceconnectUserinfoHandler = ReturnType<
+  typeof upsertFranceconnectUserinfoFactory
+>;

package/src/services/organization/index.ts

@@ -0,0 +1,4 @@
+//
+
+export * from "./is-domain-allowed-for-organization.js";
+export * from "./is-entreprise-unipersonnelle.js";

package/src/services/organization/is-domain-allowed-for-organization.ts

@@ -0,0 +1,10 @@
+import { DOMAINS_WHITELIST } from "@proconnect-gouv/proconnect.identite/data/organization";
+
+export function isDomainAllowedForOrganization(siret: string, domain: string) {
+  const whitelist = DOMAINS_WHITELIST.get(siret);
+
+  // Allow unknown siret to ignore whitelisting
+  if (!whitelist) return true;
+
+  return whitelist.includes(domain);
+}

package/src/services/organization/is-entreprise-unipersonnelle.test.ts

@@ -0,0 +1,32 @@
+//
+
+import { isEntrepriseUnipersonnelle } from "#src/services/organization";
+import type { Organization } from "#src/types";
+import {
+  association_org_info,
+  entreprise_unipersonnelle_org_info,
+  small_association_org_info,
+} from "#testing/seed/organizations";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+describe("isEntrepriseUnipersonnelle", () => {
+  it("should return false for bad call", () => {
+    assert.equal(isEntrepriseUnipersonnelle({} as Organization), false);
+  });
+
+  it("should return true for unipersonnelle organization", () => {
+    assert.equal(
+      isEntrepriseUnipersonnelle(entreprise_unipersonnelle_org_info),
+      true,
+    );
+  });
+
+  it("should return false for association", () => {
+    assert.equal(isEntrepriseUnipersonnelle(association_org_info), false);
+  });
+
+  it("should return false for small association", () => {
+    assert.equal(isEntrepriseUnipersonnelle(small_association_org_info), false);
+  });
+});

package/src/services/organization/is-entreprise-unipersonnelle.ts

@@ -0,0 +1,31 @@
+//
+
+import type { Organization } from "#src/types";
+
+/**
+ * These fonctions return approximate results. As the data tranche effectifs is
+ * two years old. Consequently, an organization that growths quickly within the
+ * first two years of his existence can be miss-identified as unipersonnelle by
+ * this fonction.
+ */
+export function isEntrepriseUnipersonnelle({
+  cached_libelle_categorie_juridique,
+  cached_tranche_effectifs,
+}: Pick<
+  Organization,
+  "cached_libelle_categorie_juridique" | "cached_tranche_effectifs"
+>): boolean {
+  // check that the organization has the right catégorie juridique
+  const cat_jur_ok = [
+    "Entrepreneur individuel",
+    "Société à responsabilité limitée (sans autre indication)",
+    "SAS, société par actions simplifiée",
+  ].includes(cached_libelle_categorie_juridique || "");
+
+  // check that the organization has the right tranche effectifs
+  const tra_eff_ok = [null, "NN", "00", "01"].includes(
+    cached_tranche_effectifs,
+  );
+
+  return cat_jur_ok && tra_eff_ok;
+}

package/src/services/postgres/hash-to-postgres-params.ts

@@ -0,0 +1,34 @@
+//
+
+import { chain } from "lodash-es";
+
+//
+
+export function hashToPostgresParams<T>(fieldsToUpdate: Partial<T>): {
+  // postgres column-list syntax
+  paramsString: string;
+  // postgres column-list syntax for prepared statement
+  valuesString: string;
+  values: any[];
+} {
+  const paramsString = "(" + Object.keys(fieldsToUpdate).join(", ") + ")";
+  // 'email, encrypted_password'
+
+  const valuesString =
+    "(" +
+    chain(fieldsToUpdate)
+      // { email: 'email@xy.z', encrypted_password: 'hash' }
+      .toPairs()
+      // [[ 'email', 'email@xy.z'], ['encrypted_password', 'hash' ]]
+      .map((_value, index) => `$${index + 1}`)
+      // [ '$1', '$2' ]
+      .join(", ")
+      // '$1, $2'
+      .value() +
+    ")";
+
+  const values = Object.values(fieldsToUpdate);
+  // [ 'email@xy.z', 'hash' ]
+
+  return { paramsString, valuesString, values };
+}