Pass domain event id around

Lan2u · Lan2u · commit 39cd97bdc26a · 2026-03-26T21:48:41.000Z
diff --git a/src/commands/exclusion-events/exclude-event-form.ts b/src/commands/exclusion-events/exclude-event-form.ts
@@ -2,7 +2,7 @@ import {flow, pipe} from 'fp-ts/lib/function';
 import * as E from 'fp-ts/Either';
 import {html, safe, toLoggedInContent} from '../../types/html';
 import {Form} from '../../types/form';
-import { DomainEvent } from '../../types';
+import {StoredDomainEvent} from '../../types';
 import { renderEvent } from '../../queries/shared-render/render-domain-event';
 import * as t from 'io-ts';
 import * as tt from 'io-ts-types';
@@ -12,7 +12,7 @@ import { StatusCodes } from 'http-status-codes';
 import * as O from 'fp-ts/Option';
 
 type ViewModel = {
-  event: O.Option<DomainEvent>,
+  event: O.Option<StoredDomainEvent>,
   event_id: tt.UUID,
 };
 
@@ -54,7 +54,12 @@ const constructForm: Form<ViewModel>['constructForm'] = input => ({events}) => p
     )
   ),
   E.map(params => params.event_id),
-  E.map(event_id => ({event_id, event: O.fromNullable(events.findLast((event) => event.event_id === event_id))}))
+  E.map(event_id => ({
+    event_id,
+    event: O.fromNullable(
+      events.findLast(event => event.event_id === event_id)
+    ),
+  }))
 );
 
 export const excludeEventForm: Form<ViewModel> = {
diff --git a/src/commands/exclusion-events/exclude-event.ts b/src/commands/exclusion-events/exclude-event.ts
@@ -1,5 +1,6 @@
 import * as t from 'io-ts';
 import * as tt from 'io-ts-types';
+import * as O from 'fp-ts/Option';
 import {Command} from '../command';
 import {isAdminOrSuperUser} from '../is-admin-or-super-user';
 
@@ -9,9 +10,7 @@ const codec = t.strict({
 
 export type ExcludeEvent = t.TypeOf<typeof codec>;
 
-const process: Command<ExcludeEvent>['process'] = async input => {
-  
-};
+const process: Command<ExcludeEvent>['process'] = () => O.none;
 
 const resource = () => ({
   type: 'ExcludeEvent',
diff --git a/src/dependencies.ts b/src/dependencies.ts
@@ -1,11 +1,18 @@
 import {Logger} from 'pino';
-import {Failure, Email, DomainEvent, ResourceVersion} from './types';
+import {
+  Failure,
+  Email,
+  DomainEvent,
+  ResourceVersion,
+  StoredDomainEvent,
+  StoredEventOfType,
+} from './types';
 import * as TE from 'fp-ts/TaskEither';
 import * as O from 'fp-ts/Option';
 import {FailureWithStatus} from './types/failure-with-status';
 import {StatusCodes} from 'http-status-codes';
 import {Resource} from './types/resource';
-import {EventName, EventOfType} from './types/domain-event';
+import {EventName} from './types/domain-event';
 import {SharedReadModel} from './read-models/shared-state';
 import {
   SheetDataTable,
@@ -30,19 +37,19 @@ export type Dependencies = {
   ) => TE.TaskEither<FailureWithStatus, unknown>;
   getAllEvents: () => TE.TaskEither<
     FailureWithStatus,
-    ReadonlyArray<DomainEvent>
+    ReadonlyArray<StoredDomainEvent>
   >;
   getAllExclusionEvents: () => TE.TaskEither<
     FailureWithStatus,
     ReadonlyArray<ExcludedEvent>
   >;
   getAllEventsByType: <T extends EventName>(
     eventType: T
-  ) => TE.TaskEither<FailureWithStatus, ReadonlyArray<EventOfType<T>>>;
+  ) => TE.TaskEither<FailureWithStatus, ReadonlyArray<StoredEventOfType<T>>>;
   getResourceEvents: (resource: Resource) => TE.TaskEither<
     FailureWithStatus,
     {
-      events: ReadonlyArray<DomainEvent>;
+      events: ReadonlyArray<StoredDomainEvent>;
       version: ResourceVersion;
     }
   >;
diff --git a/src/init-dependencies/event-store/events-from-rows.ts b/src/init-dependencies/event-store/events-from-rows.ts
@@ -3,7 +3,7 @@ import * as E from 'fp-ts/Either';
 import * as tt from 'io-ts-types';
 import {EventsTable} from './events-table';
 import * as t from 'io-ts';
-import {DomainEvent} from '../../types';
+import {StoredDomainEvent} from '../../types';
 import {internalCodecFailure} from '../../types/failure-with-status';
 
 const reshapeRowToEvent = (row: EventsTable['rows'][number]) =>
@@ -12,6 +12,7 @@ const reshapeRowToEvent = (row: EventsTable['rows'][number]) =>
     tt.JsonFromString.decode,
     E.chain(tt.JsonRecord.decode),
     E.map(payload => ({
+      event_id: row.id,
       type: row.event_type,
       ...payload,
     }))
@@ -21,6 +22,6 @@ export const eventsFromRows = (rows: EventsTable['rows']) =>
   pipe(
     rows,
     E.traverseArray(reshapeRowToEvent),
-    E.chain(t.readonlyArray(DomainEvent).decode),
+    E.chain(t.readonlyArray(StoredDomainEvent).decode),
     E.mapLeft(internalCodecFailure('Failed to get events from DB'))
   );
diff --git a/src/init-dependencies/event-store/exclude-event.ts b/src/init-dependencies/event-store/exclude-event.ts
@@ -11,8 +11,8 @@ import {dbExecute} from '../../util';
 
 const insertEventExclusionRow = `
     INSERT INTO events_exclusions
-    (id, event_id, reverted_by_number, revert_reason)
-    VALUES (?, ?, ?, ?);
+    (id, event_id, reverted_by_member_number, revert_reason, reverted_at_timestamp_epoch_ms)
+    VALUES (?, ?, ?, ?, ?);
   `;
 
 // This should only be used where an event needs to be 'deleted'.
@@ -36,6 +36,7 @@ export const excludeEvent =
           event_id,
           reverted_by_number,
           revert_reason,
+          Date.now(),
         ]
       ),
     failureWithStatus(
diff --git a/src/init-dependencies/event-store/exclusion-events-from-rows.ts b/src/init-dependencies/event-store/exclusion-events-from-rows.ts
@@ -2,26 +2,31 @@ import {pipe} from 'fp-ts/lib/function';
 import * as E from 'fp-ts/Either';
 import * as tt from 'io-ts-types';
 import {EventExclusionsTable} from './events-table';
-import * as t from 'io-ts';
 import {DomainEvent} from '../../types';
 import {internalCodecFailure} from '../../types/failure-with-status';
-import { ExcludedEvent } from './excluded-event';
 
-const reshapeRowToEvent = (row: EventExclusionsTable['rows'][number]) =>
+const reshapeRowToExcludedEvent = (
+  row: EventExclusionsTable['rows'][number]
+) =>
   pipe(
     row.payload,
     tt.JsonFromString.decode,
     E.chain(tt.JsonRecord.decode),
     E.map(payload => ({
       type: row.event_type,
       ...payload,
-    }))
-  );
-
-export const exclusionEventsFromRows = (rows: EventExclusionsTable['rows']): ReadonlyArray<ExcludedEvent> =>
-  pipe(
-    rows,
-    E.traverseArray(reshapeRowToEvent),
-    E.chain(t.readonlyArray(DomainEvent).decode),
+    })),
+    E.chain(DomainEvent.decode),
+    E.map(payload => ({
+      id: row.id,
+      event_id: row.event_id,
+      reverted_by_number: row.reverted_by_member_number,
+      revert_reason: row.revert_reason,
+      revert_at: new Date(row.reverted_at_timestamp_epoch_ms),
+      payload,
+    })),
     E.mapLeft(internalCodecFailure('Failed to get events from DB'))
   );
+
+export const exclusionEventsFromRows = (rows: EventExclusionsTable['rows']) =>
+  pipe(rows, E.traverseArray(reshapeRowToExcludedEvent));
diff --git a/src/init-dependencies/event-store/get-all-events.ts b/src/init-dependencies/event-store/get-all-events.ts
@@ -11,8 +11,8 @@ import {EventExclusionsTable, EventsTable} from './events-table';
 import {eventsFromRows} from './events-from-rows';
 import {Client} from '@libsql/client';
 import {StatusCodes} from 'http-status-codes';
-import {DomainEvent} from '../../types';
-import {EventName, EventOfType} from '../../types/domain-event';
+import {StoredDomainEvent, StoredEventOfType} from '../../types';
+import {EventName} from '../../types/domain-event';
 import {dbExecute} from '../../util';
 import { exclusionEventsFromRows } from './exclusion-events-from-rows';
 
@@ -87,8 +87,11 @@ export const getAllEventsByType =
       // This assumes that the DB has only returned events of the correct type.
       // This assumption avoids the need to do extra validation.
       // TODO - Pass codec to validate straight to eventsFromRows and get best of both.
-      TE.map<ReadonlyArray<DomainEvent>, ReadonlyArray<EventOfType<T>>>(
-        es => es as ReadonlyArray<EventOfType<T>>
+      TE.map<
+        ReadonlyArray<StoredDomainEvent>,
+        ReadonlyArray<StoredEventOfType<T>>
+      >(
+        es => es as ReadonlyArray<StoredEventOfType<T>>
       )
     );
 
@@ -130,9 +133,12 @@ export const getAllEventsByTypes =
       // This assumption avoids the need to do extra validation.
       // TODO - Pass codec to validate straight to eventsFromRows and get best of both.
       TE.map<
-        ReadonlyArray<DomainEvent>,
-        ReadonlyArray<EventOfType<T> | EventOfType<R>>
-      >(es => es as ReadonlyArray<EventOfType<T> | EventOfType<R>>)
+        ReadonlyArray<StoredDomainEvent>,
+        ReadonlyArray<StoredEventOfType<T> | StoredEventOfType<R>>
+      >(
+        es =>
+          es as ReadonlyArray<StoredEventOfType<T> | StoredEventOfType<R>>
+      )
     );
 
 export const getAllExclusionEvents = (dbClient: Client): Dependencies['getAllExclusionEvents'] =>
@@ -161,5 +167,5 @@ export const getAllExclusionEvents = (dbClient: Client): Dependencies['getAllExc
         )
       ),
       TE.map(table => table.rows),
-      TE.map(exclusionEventsFromRows)
+      TE.chainEitherK(exclusionEventsFromRows)
     );
diff --git a/src/queries/exclusion-log/render.ts b/src/queries/exclusion-log/render.ts
@@ -24,6 +24,9 @@ const renderEntry = (event: ViewModel['events'][number]) => html`
   <li>
     <b>EXCLUDED by ${renderMemberNumber(event.reverted_by_number)} at ${displayDate(DateTime.fromJSDate(event.revert_at))}
     because '${sanitizeString(event.revert_reason)}'.</b>
+    <br />
+    Event id: ${sanitizeString(event.event_id)}
+    <br />
     ${renderPayload(event.payload)}
   </li>
 `;
diff --git a/src/queries/log/construct-view-model.ts b/src/queries/log/construct-view-model.ts
@@ -1,6 +1,6 @@
 import {Params} from '../query';
 import {pipe} from 'fp-ts/lib/function';
-import {DomainEvent, User} from '../../types';
+import {StoredDomainEvent, User} from '../../types';
 import {Dependencies} from '../../dependencies';
 import * as TE from 'fp-ts/TaskEither';
 import {ViewModel, LogSearch} from './view-model';
@@ -26,7 +26,7 @@ function parseQueryToLogSearch(query: Params): LogSearch {
 }
 
 const applyLogSearch =
-  (search: LogSearch) => (events: ReadonlyArray<DomainEvent>) =>
+  (search: LogSearch) => (events: ReadonlyArray<StoredDomainEvent>) =>
     pipe(events, events => {
       const start = search.offset;
       const end = search.offset + search.limit;
diff --git a/src/queries/log/view-model.ts b/src/queries/log/view-model.ts
@@ -1,4 +1,4 @@
-import {DomainEvent, User} from '../../types';
+import {StoredDomainEvent, User} from '../../types';
 
 export interface LogSearch {
   offset: number;
@@ -9,5 +9,5 @@ export type ViewModel = {
   user: User;
   count: number;
   search: LogSearch;
-  events: ReadonlyArray<DomainEvent>;
+  events: ReadonlyArray<StoredDomainEvent>;
 };
diff --git a/src/queries/logcsv/render.ts b/src/queries/logcsv/render.ts
@@ -4,10 +4,11 @@ import {renderActor} from '../../types/actor';
 
 export const render = (viewModel: ViewModel) => {
   const rows = [];
-  rows.push(['recordedAt', 'type', 'actor', 'payload'].join(','));
+  rows.push(['event_id', 'recordedAt', 'type', 'actor', 'payload'].join(','));
   for (const event of viewModel.events) {
-    const {recordedAt, type, actor, ...payload} = event;
+    const {event_id, recordedAt, type, actor, ...payload} = event;
     const row = [
+      event_id,
       recordedAt.toISOString(),
       type,
       renderActor(actor),
diff --git a/src/queries/logcsv/view-model.ts b/src/queries/logcsv/view-model.ts
@@ -1,5 +1,5 @@
-import {DomainEvent} from '../../types';
+import {StoredDomainEvent} from '../../types';
 
 export type ViewModel = {
-  events: ReadonlyArray<DomainEvent>;
+  events: ReadonlyArray<StoredDomainEvent>;
 };
diff --git a/src/queries/shared-render/render-domain-event.ts b/src/queries/shared-render/render-domain-event.ts
@@ -1,15 +1,15 @@
 import {pipe} from 'fp-ts/lib/function';
 import * as RA from 'fp-ts/ReadonlyArray';
 import {html, safe, joinHtml, sanitizeString} from '../../types/html';
-import {DomainEvent} from '../../types';
+import {StoredDomainEvent} from '../../types';
 import {inspect} from 'node:util';
 import {displayDate} from '../../templates/display-date';
 import {DateTime} from 'luxon';
 import {renderActor} from '../../types/actor';
 
-const renderPayload = (event: DomainEvent) =>
+const renderPayload = (event: StoredDomainEvent) =>
   // eslint-disable-next-line unused-imports/no-unused-vars
-  pipe(event, ({type, actor, recordedAt, ...payload}) =>
+  pipe(event, ({event_id, type, actor, recordedAt, ...payload}) =>
     pipe(
       payload,
       Object.entries,
@@ -19,10 +19,11 @@ const renderPayload = (event: DomainEvent) =>
     )
   );
 
-export const renderEvent = (event: DomainEvent) => html`
+export const renderEvent = (event: StoredDomainEvent) => html`
   <li>
     <b>${sanitizeString(event.type)}</b> by ${renderActor(event.actor)} at
-    ${displayDate(DateTime.fromJSDate(event.recordedAt))}<br />
+    ${displayDate(DateTime.fromJSDate(event.recordedAt))}
+    ${event.event_id ? html`<br />Event id: ${sanitizeString(event.event_id)}` : safe('')}<br />
     ${renderPayload(event)}
   </li>
 `;
diff --git a/src/sync-worker/dependencies.ts b/src/sync-worker/dependencies.ts
@@ -9,7 +9,7 @@ import {
 } from './google/sheet-data-table';
 import {ReadonlyRecord} from 'fp-ts/lib/ReadonlyRecord';
 import {UUID} from 'io-ts-types';
-import {DomainEvent, Email, Failure, ResourceVersion} from '../types';
+import {Email, Failure, ResourceVersion, StoredDomainEvent} from '../types';
 import {SharedReadModel} from '../read-models/shared-state';
 import {Resource} from '../types/resource';
 import {Dependencies} from '../dependencies';
@@ -54,7 +54,7 @@ export interface SyncWorkerDependencies {
   getResourceEvents: (resource: Resource) => TE.TaskEither<
     FailureWithStatus,
     {
-      events: ReadonlyArray<DomainEvent>;
+      events: ReadonlyArray<StoredDomainEvent>;
       version: ResourceVersion;
     }
   >;
diff --git a/src/types/domain-event.ts b/src/types/domain-event.ts
@@ -283,11 +283,22 @@ export const DomainEvent = t.union([
   TrainingStatNotificationSent.codec,
 ]);
 
+export const StoredDomainEvent = t.intersection([
+  DomainEvent,
+  t.strict({
+    event_id: tt.UUID,
+  }),
+]);
+
 export type DomainEvent = t.TypeOf<typeof DomainEvent>;
+export type StoredDomainEvent = t.TypeOf<typeof StoredDomainEvent>;
 
 export type EventName = DomainEvent['type'];
 
 export type EventOfType<T extends EventName> = DomainEvent & {type: T};
+export type StoredEventOfType<T extends EventName> = StoredDomainEvent & {
+  type: T;
+};
 
 export const isEventOfType =
   <T extends EventName>(name: T) =>
diff --git a/src/types/form.ts b/src/types/form.ts
@@ -1,4 +1,4 @@
-import {DomainEvent, User} from '.';
+import {StoredDomainEvent, User} from '.';
 import {FailureWithStatus} from './failure-with-status';
 import * as E from 'fp-ts/Either';
 import {HttpResponse} from './html';
@@ -9,7 +9,7 @@ export type Form<T> = {
   renderForm: (viewModel: T) => Member<HttpResponse, 'LoggedInContent'>;
   constructForm: (input: unknown) => (context: {
     user: User;
-    events: ReadonlyArray<DomainEvent>;
+    events: ReadonlyArray<StoredDomainEvent>;
     readModel: SharedReadModel;
   }) => E.Either<FailureWithStatus, T>;
 };
diff --git a/src/types/index.ts b/src/types/index.ts
@@ -10,9 +10,13 @@ export type {GravatarHash} from './gravatar-hash';
 export {isoGravatarHash} from './gravatar-hash';
 export {
   DomainEvent,
+  StoredDomainEvent,
   isEventOfType,
   constructEvent,
   filterByName,
 } from './domain-event';
-export type {SubsetOfDomainEvent} from './domain-event';
+export type {
+  StoredEventOfType,
+  SubsetOfDomainEvent,
+} from './domain-event';
 export type {ResourceVersion} from './resource-version';
diff --git a/tests/init-dependencies/event-store/end-to-end.test.ts b/tests/init-dependencies/event-store/end-to-end.test.ts
diff --git a/tests/init-dependencies/event-store/get-all-events.test.ts b/tests/init-dependencies/event-store/get-all-events.test.ts
diff --git a/tests/init-dependencies/happy-path-adapters.helper.ts b/tests/init-dependencies/happy-path-adapters.helper.ts
diff --git a/tests/read-models/test-framework.ts b/tests/read-models/test-framework.ts
diff --git a/tests/types/domain-event.test.ts b/tests/types/domain-event.test.ts
