review

back/package.json

@@ -16,7 +16,7 @@
     "trigger-sending-emails-with-assessment-creation-link": "ts-node src/adapters/primary/scripts/triggerSendingEmailsWithAssessmentCreationLink.ts",
     "trigger-refresh-materialized-views": "ts-node src/adapters/primary/scripts/triggerRefreshMaterializedViews.ts",
     "trigger-convention-reminder": "ts-node src/adapters/primary/scripts/triggerConventionReminder.ts",
-    "trigger-resync-old-conventions-to-pe": "ts-node src/adapters/primary/scripts/triggerResyncOldConventionsToPE.ts",
+    "trigger-resync-old-conventions-to-pe": "ts-node src/adapters/primary/scripts/triggerResyncOldConventionsToPe.ts",
     "seed": "NODE_ENV=local ts-node src/adapters/primary/scripts/seed.ts",
     "generate-api-key": "ts-node src/adapters/primary/scripts/generateApiKey.ts",
     "test:unit": "jest --watchAll --testRegex=.unit.test.ts",

back/src/adapters/primary/config/uowConfig.ts

@@ -16,7 +16,7 @@ import { InMemoryAuthenticatedUserRepository } from "../../secondary/InMemoryAut
 import { InMemoryConventionPoleEmploiAdvisorRepository } from "../../secondary/InMemoryConventionPoleEmploiAdvisorRepository";
 import { InMemoryConventionQueries } from "../../secondary/InMemoryConventionQueries";
 import { InMemoryConventionRepository } from "../../secondary/InMemoryConventionRepository";
-import { InMemoryConventionToSyncRepository } from "../../secondary/InMemoryConventionToSyncRepository";
+import { InMemoryConventionsToSyncRepository } from "../../secondary/InMemoryConventionsToSyncRepository";
 import { InMemoryFeatureFlagRepository } from "../../secondary/InMemoryFeatureFlagRepository";
 import { InMemoryFormEstablishmentRepository } from "../../secondary/InMemoryFormEstablishmentRepository";
 import { InMemoryImmersionAssessmentRepository } from "../../secondary/InMemoryImmersionAssessmentRepository";
@@ -32,7 +32,7 @@ import { PgAuthenticatedUserRepository } from "../../secondary/pg/PgAuthenticate
 import { PgConventionPoleEmploiAdvisorRepository } from "../../secondary/pg/PgConventionPoleEmploiAdvisorRepository";
 import { PgConventionQueries } from "../../secondary/pg/PgConventionQueries";
 import { PgConventionRepository } from "../../secondary/pg/PgConventionRepository";
-import { PgConventionToSyncRepository } from "../../secondary/pg/PgConventionToSyncRepository";
+import { PgConventionsToSyncRepository } from "../../secondary/pg/PgConventionsToSyncRepository";
 import { PgDiscussionAggregateRepository } from "../../secondary/pg/PgDiscussionAggregateRepository";
 import { PgErrorRepository } from "../../secondary/pg/PgErrorRepository";
 import { PgEstablishmentAggregateRepository } from "../../secondary/pg/PgEstablishmentAggregateRepository";
@@ -72,7 +72,7 @@ export const createInMemoryUow = () => {
     conventionRepository,
     conventionPoleEmploiAdvisorRepository:
       new InMemoryConventionPoleEmploiAdvisorRepository(),
-    conventionToSyncRepository: new InMemoryConventionToSyncRepository(),
+    conventionsToSyncRepository: new InMemoryConventionsToSyncRepository(),
     discussionAggregateRepository: new InMemoryDiscussionAggregateRepository(),
     establishmentAggregateRepository:
       new InMemoryEstablishmentAggregateRepository(),
@@ -104,7 +104,7 @@ export const createPgUow = (client: PoolClient): UnitOfWork => {
     conventionQueries: new PgConventionQueries(client),
     conventionPoleEmploiAdvisorRepository:
       new PgConventionPoleEmploiAdvisorRepository(client),
-    conventionToSyncRepository: new PgConventionToSyncRepository(client),
+    conventionsToSyncRepository: new PgConventionsToSyncRepository(client),
     discussionAggregateRepository: new PgDiscussionAggregateRepository(client),
     establishmentAggregateRepository: new PgEstablishmentAggregateRepository(
       client,

back/src/adapters/primary/scripts/triggerResyncOldConventionsToPE.ts → back/src/adapters/primary/scripts/triggerResyncOldConventionsToPe.ts

@@ -41,14 +41,14 @@ const executeUsecase = async () => {
       }),
   );
 
-  const resyncOldConventionToPEUsecase = new ResyncOldConventionsToPe(
+  const resyncOldConventionsToPeUsecase = new ResyncOldConventionsToPe(
     uowPerformer,
     httpPoleEmploiGateway,
     timeGateway,
     50,
   );
 
-  return resyncOldConventionToPEUsecase.execute();
+  return resyncOldConventionsToPeUsecase.execute();
 };
 
 /* eslint-disable @typescript-eslint/no-floating-promises */

back/src/adapters/secondary/InMemoryConventionToSyncRepository.ts → back/src/adapters/secondary/InMemoryConventionsToSyncRepository.ts

@@ -1,21 +1,19 @@
 import { ConventionId } from "shared";
 import {
+  ConventionsToSyncRepository,
   ConventionToSync,
-  ConventionToSyncRepository,
-} from "../../domain/convention/ports/ConventionToSyncRepository";
+} from "../../domain/convention/ports/ConventionsToSyncRepository";
 
-export class InMemoryConventionToSyncRepository
-  implements ConventionToSyncRepository
+export class InMemoryConventionsToSyncRepository
+  implements ConventionsToSyncRepository
 {
   public async getById(
     id: ConventionId,
   ): Promise<ConventionToSync | undefined> {
     return this.conventionsToSync.find((convention) => convention.id === id);
   }
 
-  public async getNotProcessedAndErrored(
-    limit: number,
-  ): Promise<ConventionToSync[]> {
+  public async getToProcessOrError(limit: number): Promise<ConventionToSync[]> {
     return this.conventionsToSync
       .filter(({ status }) => status === "ERROR" || status === "TO_PROCESS")
       .slice(0, limit);

back/src/adapters/secondary/pg/PgConventionToSyncRepository.integration.test.ts → back/src/adapters/secondary/pg/PgConventionsToSyncRepository.integration.test.ts

@@ -1,14 +1,14 @@
 import { Pool, PoolClient } from "pg";
 import { expectToEqual } from "shared";
 import { getTestPgPool } from "../../../_testBuilders/getTestPgPool";
-import { ConventionToSync } from "../../../domain/convention/ports/ConventionToSyncRepository";
+import { ConventionToSync } from "../../../domain/convention/ports/ConventionsToSyncRepository";
 import {
-  conventionToSyncTableName,
-  PgConventionToSyncRepository,
-} from "./PgConventionToSyncRepository";
+  conventionsToSyncTableName,
+  PgConventionsToSyncRepository,
+} from "./PgConventionsToSyncRepository";
 
-describe("PgConventionRepository", () => {
-  const conventionToSyncs: ConventionToSync[] = [
+describe("PgConventionsRepository", () => {
+  const conventionsToSync: ConventionToSync[] = [
     {
       id: "aaaaac99-9c0b-1bbb-bb6d-6bb9bd38aaa1",
       status: "TO_PROCESS",
@@ -34,7 +34,7 @@ describe("PgConventionRepository", () => {
 
   let pool: Pool;
   let client: PoolClient;
-  let conventionRepositoryToSyncRepository: PgConventionToSyncRepository;
+  let conventionsToSyncRepository: PgConventionsToSyncRepository;
 
   beforeAll(async () => {
     pool = getTestPgPool();
@@ -48,55 +48,52 @@ describe("PgConventionRepository", () => {
 
   beforeEach(async () => {
     await client.query(`DELETE
-                        FROM ${conventionToSyncTableName}`);
-    conventionRepositoryToSyncRepository = new PgConventionToSyncRepository(
-      client,
-    );
+                        FROM ${conventionsToSyncTableName}`);
+    conventionsToSyncRepository = new PgConventionsToSyncRepository(client);
   });
 
-  it.each(conventionToSyncs)(
+  it.each(conventionsToSync)(
     `save and getById convention with status '$status'`,
     async (conventionToSync) => {
       expectToEqual(
-        await conventionRepositoryToSyncRepository.getById(conventionToSync.id),
+        await conventionsToSyncRepository.getById(conventionToSync.id),
         undefined,
       );
 
-      await conventionRepositoryToSyncRepository.save(conventionToSync);
+      await conventionsToSyncRepository.save(conventionToSync);
 
-      const syncedConvention =
-        await conventionRepositoryToSyncRepository.getById(conventionToSync.id);
+      const syncedConvention = await conventionsToSyncRepository.getById(
+        conventionToSync.id,
+      );
       expectToEqual(syncedConvention, conventionToSync);
     },
   );
 
   describe("getNotProcessedAndErrored", () => {
     beforeEach(() =>
       Promise.all(
-        conventionToSyncs.map((conventionToSync) =>
-          conventionRepositoryToSyncRepository.save(conventionToSync),
+        conventionsToSync.map((conventionToSync) =>
+          conventionsToSyncRepository.save(conventionToSync),
         ),
       ),
     );
 
     it("only TO_PROCESS and ERROR", async () => {
       const conventionsToSyncNotProcessedAndErrored =
-        await conventionRepositoryToSyncRepository.getNotProcessedAndErrored(
-          10000,
-        );
+        await conventionsToSyncRepository.getToProcessOrError(10000);
 
       expectToEqual(conventionsToSyncNotProcessedAndErrored, [
-        conventionToSyncs[0],
-        conventionToSyncs[2],
+        conventionsToSync[0],
+        conventionsToSync[2],
       ]);
     });
 
     it("with limit 1", async () => {
       const conventionsToSyncNotProcessedAndErrored =
-        await conventionRepositoryToSyncRepository.getNotProcessedAndErrored(1);
+        await conventionsToSyncRepository.getToProcessOrError(1);
 
       expectToEqual(conventionsToSyncNotProcessedAndErrored, [
-        conventionToSyncs[0],
+        conventionsToSync[0],
       ]);
     });
   });

back/src/adapters/secondary/pg/PgConventionToSyncRepository.ts → back/src/adapters/secondary/pg/PgConventionsToSyncRepository.ts

@@ -1,22 +1,22 @@
 import { PoolClient } from "pg";
 import { ConventionId } from "shared";
 import {
+  ConventionsToSyncRepository,
   ConventionToSync,
-  ConventionToSyncRepository,
-} from "../../../domain/convention/ports/ConventionToSyncRepository";
+} from "../../../domain/convention/ports/ConventionsToSyncRepository";
 
-export const conventionToSyncTableName = "convention_to_sync_with_pe";
+export const conventionsToSyncTableName = "conventions_to_sync_with_pe";
 
-export class PgConventionToSyncRepository
-  implements ConventionToSyncRepository
+export class PgConventionsToSyncRepository
+  implements ConventionsToSyncRepository
 {
   constructor(private client: PoolClient) {}
 
-  async getNotProcessedAndErrored(limit: number): Promise<ConventionToSync[]> {
+  async getToProcessOrError(limit: number): Promise<ConventionToSync[]> {
     const queryResult = await this.client.query<PgConventionToSync>(
       `
           SELECT id, status, process_date, reason
-          FROM ${conventionToSyncTableName}
+          FROM ${conventionsToSyncTableName}
           WHERE status = 'TO_PROCESS'
              OR status = 'ERROR'
               LIMIT $1
@@ -31,10 +31,10 @@ export class PgConventionToSyncRepository
   async save(conventionToSync: ConventionToSync): Promise<void> {
     await this.client.query(
       `
-          INSERT INTO ${conventionToSyncTableName} (id,
-                                                    status,
-                                                    process_date,
-                                                    reason)
+          INSERT INTO ${conventionsToSyncTableName} (id,
+                                                     status,
+                                                     process_date,
+                                                     reason)
           VALUES ($1, $2, $3, $4)
       `,
       [
@@ -55,7 +55,7 @@ export class PgConventionToSyncRepository
     const queryResult = await this.client.query<PgConventionToSync>(
       `
           SELECT id, status, process_date, reason
-          FROM ${conventionToSyncTableName}
+          FROM ${conventionsToSyncTableName}
           WHERE id = $1
       `,
       [id],

back/src/adapters/secondary/pg/migrations/1687438863530_create-convention-to-sync-repository.ts → back/src/adapters/secondary/pg/migrations/1687438863530_create-conventions-to-sync-repository.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { MigrationBuilder } from "node-pg-migrate";
 
-const tableName = "convention_to_sync_with_pe";
+const tableName = "conventions_to_sync_with_pe";
 
 export async function up(pgm: MigrationBuilder): Promise<void> {
   pgm.createTable(tableName, {

back/src/domain/convention/ports/ConventionToSyncRepository.ts → back/src/domain/convention/ports/ConventionsToSyncRepository.ts

@@ -22,10 +22,10 @@ export type ConventionToSync = {
     }
 );
 
-export interface ConventionToSyncRepository {
+export interface ConventionsToSyncRepository {
   getById(id: ConventionId): Promise<ConventionToSync | undefined>;
 
-  getNotProcessedAndErrored(limit: number): Promise<ConventionToSync[]>;
+  getToProcessOrError(limit: number): Promise<ConventionToSync[]>;
 
   save(filledConvention: ConventionToSync): Promise<void>;
 }

back/src/domain/convention/useCases/ResyncOldConventionsToPe.ts

@@ -5,7 +5,6 @@ import { NotFoundError } from "../../../adapters/primary/helpers/httpErrors";
 import { TimeGateway } from "../../core/ports/TimeGateway";
 import { UnitOfWork, UnitOfWorkPerformer } from "../../core/ports/UnitOfWork";
 import { TransactionalUseCase } from "../../core/UseCase";
-import { ConventionToSync } from "../ports/ConventionToSyncRepository";
 import { PoleEmploiGateway } from "../ports/PoleEmploiGateway";
 import { BroadcastToPoleEmploiOnConventionUpdates } from "./broadcast/BroadcastToPoleEmploiOnConventionUpdates";
 
@@ -35,12 +34,10 @@ export class ResyncOldConventionsToPe extends TransactionalUseCase<
     uow: UnitOfWork,
   ): Promise<ResyncOldConventionToPeReport> {
     const conventionsToSync =
-      await uow.conventionToSyncRepository.getNotProcessedAndErrored(
-        this.limit,
-      );
+      await uow.conventionsToSyncRepository.getToProcessOrError(this.limit);
     await Promise.all(
       conventionsToSync.map((conventionToSync) =>
-        this.handleConventionToSync(uow, conventionToSync),
+        this.handleConventionToSync(uow, conventionToSync.id),
       ),
     );
 
@@ -49,61 +46,62 @@ export class ResyncOldConventionsToPe extends TransactionalUseCase<
 
   private async handleConventionToSync(
     uow: UnitOfWork,
-    payload: ConventionToSync,
+    conventionToSyncId: ConventionId,
   ) {
     try {
-      await this.resync(uow, payload);
+      await this.resync(uow, conventionToSyncId);
       const updatedConventionToSync =
-        await uow.conventionToSyncRepository.getById(payload.id);
+        await uow.conventionsToSyncRepository.getById(conventionToSyncId);
 
       match(updatedConventionToSync)
         .with(undefined, () => {
-          this.report.errors[payload.id] = new Error(
+          this.report.errors[conventionToSyncId] = new Error(
             "Convention not found or no status",
           );
         })
         .with({ status: "SUCCESS" }, () => {
           this.report.success += 1;
         })
-        .with({ status: "TO_PROCESS" }, (conventionToSync) => {
-          this.report.errors[conventionToSync.id] = new Error(
+        .with({ status: "TO_PROCESS" }, (toProcessConventionToSync) => {
+          this.report.errors[toProcessConventionToSync.id] = new Error(
             "Convention still have status TO_PROCESS",
           );
         })
-        .with({ status: "ERROR" }, (conventionToSync) => {
-          this.report.errors[conventionToSync.id] = new Error(
-            conventionToSync.reason,
+        .with({ status: "ERROR" }, (errorConventionToSync) => {
+          this.report.errors[errorConventionToSync.id] = new Error(
+            errorConventionToSync.reason,
           );
         })
-        .with({ status: "SKIP" }, (conventionToSync) => {
-          this.report.skips[conventionToSync.id] = conventionToSync.reason;
+        .with({ status: "SKIP" }, (skipConventionToSync) => {
+          this.report.skips[skipConventionToSync.id] =
+            skipConventionToSync.reason;
         })
         .exhaustive();
     } catch (error) {
       const anError =
         error instanceof Error
           ? error
           : new Error("Not an Error: " + JSON.stringify(error));
-      await uow.conventionToSyncRepository.save({
-        id: payload.id,
+      await uow.conventionsToSyncRepository.save({
+        id: conventionToSyncId,
         status: "ERROR",
         processDate: this.timeGateway.now(),
         reason: anError.message,
       });
-      this.report.errors[payload.id] = anError;
+      this.report.errors[conventionToSyncId] = anError;
     }
   }
 
   private async resync(
     uow: UnitOfWork,
-    conventionToSync: ConventionToSync,
+    conventionToSyncId: ConventionId,
   ): Promise<void> {
     const convention = await uow.conventionRepository.getById(
-      conventionToSync.id,
+      conventionToSyncId,
     );
     if (!convention)
       throw new NotFoundError(
-        `Convention with id ${conventionToSync.id} missing in conventionRepository.`,
+        `Convention with id ${conventionToSyncId} missing in conventionRepository.`,
       );
     await new BroadcastToPoleEmploiOnConventionUpdates(
       this.uowPerform,