Refactor DateOverrideConflict to be more de-decoupled

Author: CarsonF

src/common/exceptions/date-override-conflict.exception.ts

@@ -0,0 +1,74 @@
+import { isNotFalsy, type NonEmptyArray } from '@seedcompany/common';
+import type { ID } from '../id-field';
+import { CalendarDate } from '../temporal';
+import type { Range } from '../types';
+import { RangeException } from './range.exception';
+
+type Conflict = Readonly<{
+  __typename: string;
+  id: ID;
+  label: string;
+  point: 'start' | 'end';
+  date: CalendarDate;
+}>;
+
+interface IdentifiableResource {
+  __typename: string;
+  id: ID;
+  [key: string]: unknown;
+}
+
+export class DateOverrideConflictException extends RangeException {
+  constructor(
+    readonly object: IdentifiableResource,
+    readonly canonical: Range<CalendarDate | null>,
+    label: [singular: string, plural: string],
+    readonly conflicts: NonEmptyArray<Conflict>,
+  ) {
+    const message = [
+      conflicts.length === 1
+        ? `${label[0]} has a date outside the new range`
+        : `${label[1]} have dates outside the new range`,
+      ...conflicts.map(({ date, point, label }) => {
+        const pointStr = point === 'start' ? 'Start' : 'End';
+        const dateStr = date.toISO();
+        return `  - ${pointStr} date of ${label} is ${dateStr}`;
+      }),
+    ].join('\n');
+    super({ message });
+  }
+
+  static findConflicts(
+    canonical: Range<CalendarDate | null>,
+    items: ReadonlyArray<{
+      __typename: string;
+      id: ID;
+      label: string;
+      start: CalendarDate | null;
+      end: CalendarDate | null;
+    }>,
+  ): NonEmptyArray<Conflict> | undefined {
+    const maybeConflicts = items.flatMap<Conflict | null>(
+      ({ start, end, ...item }) => [
+        canonical.start && start && canonical.start > start
+          ? {
+              ...item,
+              point: 'start' as const,
+              date: start,
+            }
+          : null,
+        canonical.end && end && canonical.end < end
+          ? {
+              ...item,
+              point: 'end' as const,
+              date: end,
+            }
+          : null,
+      ],
+    );
+    return asNonEmpty(maybeConflicts.filter(isNotFalsy));
+  }
+}
+
+const asNonEmpty = <T>(items: readonly T[]) =>
+  items.length === 0 ? undefined : (items as NonEmptyArray<T>);

src/common/exceptions/index.ts

@@ -9,3 +9,4 @@ export * from './unauthorized.exception';
 export * from './service-unavailable.exception';
 export * from './invalid-id-for-type.exception';
 export * from './creation-failed.exception';
+export * from './date-override-conflict.exception';

src/components/engagement/handlers/validate-eng-date-overrides-on-project-change.handler.ts

@@ -1,7 +1,5 @@
-import { isNotFalsy, NonEmptyArray } from '@seedcompany/common';
-import { CalendarDate, ID, RangeException, type UnsecuredDto } from '~/common';
+import { DateOverrideConflictException, EnhancedResource } from '~/common';
 import { EventsHandler, IEventHandler } from '~/core';
-import type { Project } from '../../project/dto';
 import { ProjectUpdatedEvent } from '../../project/events';
 import { EngagementService } from '../engagement.service';
 
@@ -12,84 +10,37 @@ export class ValidateEngDateOverridesOnProjectChangeHandler
   constructor(private readonly engagements: EngagementService) {}
 
   async handle(event: ProjectUpdatedEvent) {
-    const { changes, updated, session } = event;
+    const { updated: project, changes, session } = event;
 
     if (changes.mouStart === undefined && changes.mouEnd === undefined) {
       return;
     }
 
-    const project = {
-      id: updated.id,
-      name: updated.name,
-      mouStart: updated.mouStart,
-      mouEnd: updated.mouEnd,
-    };
     const engagements = await this.engagements.listAllByProjectId(
       project.id,
       session,
     );
-    const errors = engagements
-      .flatMap<
-        EngagementDateOverrideConflictException['engagements'][0] | null
-      >((eng) => {
-        const common = {
-          id: eng.id,
-          label: (eng.label.language ?? eng.label.intern)!,
-        } as const;
-        const { startDateOverride: start, endDateOverride: end } = eng;
-        return [
-          project.mouStart && start && project.mouStart > start
-            ? {
-                ...common,
-                point: 'start' as const,
-                date: start,
-              }
-            : null,
-          project.mouEnd && end && project.mouEnd < end
-            ? {
-                ...common,
-                point: 'end' as const,
-                date: end,
-              }
-            : null,
-        ];
-      })
-      .filter(isNotFalsy);
-    if (errors.length === 0) {
-      return;
-    }
-    throw new EngagementDateOverrideConflictException(project, [
-      errors[0]!,
-      ...errors.slice(1),
-    ]);
-  }
-}
-
-class EngagementDateOverrideConflictException extends RangeException {
-  constructor(
-    readonly project: Pick<
-      UnsecuredDto<Project>,
-      'id' | 'name' | 'mouStart' | 'mouEnd'
-    >,
-    readonly engagements: NonEmptyArray<
-      Readonly<{
-        id: ID<'Engagement'>;
-        label: string;
-        point: 'start' | 'end';
-        date: CalendarDate;
-      }>
-    >,
-  ) {
-    const message = [
-      engagements.length === 1
-        ? 'An engagement has a date outside the new range'
-        : 'Some engagements have dates outside the new range',
-      ...engagements.map((eng) => {
-        const pointStr = eng.point === 'start' ? 'Start' : 'End';
-        const dateStr = eng.date.toISO();
-        return `  - ${pointStr} date of ${eng.label} is ${dateStr}`;
-      }),
-    ].join('\n');
-    super({ message });
+    const canonical = { start: project.mouStart, end: project.mouEnd };
+    const conflicts = DateOverrideConflictException.findConflicts(
+      canonical,
+      engagements.map((eng) => ({
+        __typename: EnhancedResource.resolve(eng.__typename).name,
+        id: eng.id,
+        label: (eng.label.language ?? eng.label.intern)!,
+        start: eng.startDateOverride,
+        end: eng.endDateOverride,
+      })),
+    );
+    if (!conflicts) return;
+    throw new DateOverrideConflictException(
+      {
+        __typename: event.resource.name,
+        id: project.id,
+        name: project.name,
+      },
+      canonical,
+      ['An engagement', 'Some engagements'],
+      conflicts,
+    );
   }
 }

src/components/project/events/project-updated.event.ts

@@ -1,11 +1,15 @@
-import { Session, UnsecuredDto } from '~/common';
-import { Project, UpdateProject } from '../dto';
+import { EnhancedResource, Session, UnsecuredDto } from '~/common';
+import { Project, resolveProjectType, UpdateProject } from '../dto';
 
 export class ProjectUpdatedEvent {
+  readonly resource: EnhancedResource<ReturnType<typeof resolveProjectType>>;
+
   constructor(
     public updated: UnsecuredDto<Project>,
     readonly previous: UnsecuredDto<Project>,
     readonly changes: UpdateProject,
     readonly session: Session,
-  ) {}
+  ) {
+    this.resource = EnhancedResource.of(resolveProjectType(this.updated));
+  }
 }