Extract stored event ids

Author: Lan2u

src/dependencies.ts

@@ -1,12 +1,19 @@
 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,
@@ -25,15 +32,15 @@ export type Dependencies = {
   >;
   getAllEvents: () => TE.TaskEither<
     FailureWithStatus,
-    ReadonlyArray<DomainEvent>
+    ReadonlyArray<StoredDomainEvent>
   >;
   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;
     }
   >;

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'))
   );

src/init-dependencies/event-store/get-all-events.ts

@@ -10,8 +10,8 @@ import {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';
 
 export const getAllEvents =
@@ -69,8 +69,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>>
       )
     );
 
@@ -106,7 +109,10 @@ 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>>
+      )
     );

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;
     }
   >;

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) =>

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';

tests/init-dependencies/event-store/end-to-end.test.ts

@@ -3,7 +3,12 @@ import {faker} from '@faker-js/faker';
 import * as libsqlClient from '@libsql/client';
 import * as E from 'fp-ts/Either';
 import * as T from 'fp-ts/Task';
-import {DomainEvent, EmailAddress, constructEvent} from '../../../src/types';
+import {
+  DomainEvent,
+  EmailAddress,
+  StoredDomainEvent,
+  constructEvent,
+} from '../../../src/types';
 import {getAllEvents} from '../../../src/init-dependencies/event-store/get-all-events';
 import {pipe} from 'fp-ts/lib/function';
 import {
@@ -29,12 +34,20 @@ const arbitraryMemberNumberLinkedToEmailEvent = () =>
 const testLogger = createLogger({level: 'silent'});
 const dummyRefreshReadModel = () => T.of(undefined);
 
+const expectStoredEvent = (
+  actualEvent: StoredDomainEvent,
+  expectedEvent: DomainEvent
+) => {
+  expect(actualEvent).toMatchObject(expectedEvent);
+  expect(actualEvent.event_id).toEqual(expect.any(String));
+};
+
 describe('event-store end-to-end', () => {
   describe('setup event store', () => {
     const resource = {id: 'singleton', type: 'MemberNumberEmailPairings'};
     const event = arbitraryMemberNumberLinkedToEmailEvent();
     let dbClient: libsqlClient.Client;
-    let getTestEvents: () => Promise<ReadonlyArray<DomainEvent>>;
+    let getTestEvents: () => Promise<ReadonlyArray<StoredDomainEvent>>;
     let resourceEvents: RightOfTaskEither<
       ReturnType<Dependencies['getResourceEvents']>
     >;
@@ -82,7 +95,9 @@ describe('event-store end-to-end', () => {
       });
 
       it('persists the event', async () => {
-        expect(await getTestEvents()).toStrictEqual([event]);
+        const events = await getTestEvents();
+        expect(events).toHaveLength(1);
+        expectStoredEvent(events[0], event);
       });
 
       it('uses the initial version number', () => {
@@ -104,7 +119,10 @@ describe('event-store end-to-end', () => {
       });
 
       it('persists the event', async () => {
-        expect(await getTestEvents()).toStrictEqual([event, event2]);
+        const events = await getTestEvents();
+        expect(events).toHaveLength(2);
+        expectStoredEvent(events[0], event);
+        expectStoredEvent(events[1], event2);
       });
 
       it('increments the version', () => {
@@ -135,7 +153,8 @@ describe('event-store end-to-end', () => {
       it('does not persist the event', async () => {
         const events = await getTestEvents();
         expect(events).toHaveLength(2);
-        expect(events).toStrictEqual([initialEvent, competingEvent]);
+        expectStoredEvent(events[0], initialEvent);
+        expectStoredEvent(events[1], competingEvent);
       });
 
       it.failing('returns on left', () => {
@@ -173,7 +192,8 @@ describe('event-store end-to-end', () => {
 
       it('has independant events', async () => {
         expect(await getTestEvents()).toHaveLength(3);
-        expect(resourceEvents.events).toStrictEqual([event]);
+        expect(resourceEvents.events).toHaveLength(1);
+        expectStoredEvent(resourceEvents.events[0], event);
       });
     });
   });

tests/init-dependencies/event-store/get-all-events.test.ts

@@ -6,6 +6,7 @@ import {randomUUID} from 'crypto';
 import {
   DomainEvent,
   EmailAddress,
+  StoredDomainEvent,
   constructEvent,
 } from '../../../src/types';
 import {commitEvent} from '../../../src/init-dependencies/event-store/commit-event';
@@ -49,11 +50,24 @@ describe('get all events', () => {
   const testLogger = createLogger({level: 'silent'});
   const dummyRefreshReadModel = () => T.of(undefined);
 
+  const expectStoredEvent = (
+    actualEvent: StoredDomainEvent,
+    expectedEvent: DomainEvent
+  ) => {
+    expect(actualEvent).toMatchObject(expectedEvent);
+    expect(actualEvent.event_id).toEqual(expect.any(String));
+  };
+
   let dbClient: libsqlClient.Client;
   let persistEvent: (event: DomainEvent) => Promise<void>;
-  let initalisedGetAllEvents: () => Promise<ReadonlyArray<DomainEvent>>;
-  let initalisedGetAllEventsByType: (type: EventName) => Promise<ReadonlyArray<DomainEvent>>;
-  let initalisedGetAllEventsByTypes: (type1: EventName, type2: EventName) => Promise<ReadonlyArray<DomainEvent>>;
+  let initalisedGetAllEvents: () => Promise<ReadonlyArray<StoredDomainEvent>>;
+  let initalisedGetAllEventsByType: (
+    type: EventName
+  ) => Promise<ReadonlyArray<StoredDomainEvent>>;
+  let initalisedGetAllEventsByTypes: (
+    type1: EventName,
+    type2: EventName
+  ) => Promise<ReadonlyArray<StoredDomainEvent>>;
 
   beforeEach(async () => {
     dbClient = libsqlClient.createClient({url: ':memory:'});
@@ -87,10 +101,10 @@ describe('get all events', () => {
       await persistEvent(memberNumberLinkedToEmail);
       await persistEvent(equipmentTrainingQuizResult);
       await persistEvent(equipmentTrainingSheetRegistered);
-      expect(await initalisedGetAllEvents()).toStrictEqual([
-        memberNumberLinkedToEmail,
-        equipmentTrainingSheetRegistered,
-      ]);
+      const events = await initalisedGetAllEvents();
+      expect(events).toHaveLength(2);
+      expectStoredEvent(events[0], memberNumberLinkedToEmail);
+      expectStoredEvent(events[1], equipmentTrainingSheetRegistered);
     });
   });
 
@@ -102,10 +116,12 @@ describe('get all events', () => {
       await persistEvent(firstMatchingEvent);
       await persistEvent(nonMatchingEvent);
       await persistEvent(secondMatchingEvent);
-      expect(await initalisedGetAllEventsByType('MemberNumberLinkedToEmail')).toStrictEqual([
-        firstMatchingEvent,
-        secondMatchingEvent,
-      ]);
+      const events = await initalisedGetAllEventsByType(
+        'MemberNumberLinkedToEmail'
+      );
+      expect(events).toHaveLength(2);
+      expectStoredEvent(events[0], firstMatchingEvent);
+      expectStoredEvent(events[1], secondMatchingEvent);
     });
 
     it('returns EquipmentTrainingQuizResult events when explicitly requested', async () => {
@@ -114,7 +130,11 @@ describe('get all events', () => {
       const nonMatchingEvent = arbitraryMemberNumberLinkedToEmailEvent();
       await persistEvent(equipmentTrainingQuizResult);
       await persistEvent(nonMatchingEvent);
-      expect(await initalisedGetAllEventsByType('EquipmentTrainingQuizResult')).toStrictEqual([equipmentTrainingQuizResult]);
+      const events = await initalisedGetAllEventsByType(
+        'EquipmentTrainingQuizResult'
+      );
+      expect(events).toHaveLength(1);
+      expectStoredEvent(events[0], equipmentTrainingQuizResult);
     });
   });
 
@@ -128,15 +148,13 @@ describe('get all events', () => {
       await persistEvent(nonMatchingEvent);
       await persistEvent(secondMatchingEvent);
 
-      expect(
-        await initalisedGetAllEventsByTypes(
-          'MemberNumberLinkedToEmail',
-          'EquipmentTrainingSheetRegistered'
-        )
-      ).toStrictEqual([
-        firstMatchingEvent,
-        secondMatchingEvent,
-      ]);
+      const events = await initalisedGetAllEventsByTypes(
+        'MemberNumberLinkedToEmail',
+        'EquipmentTrainingSheetRegistered'
+      );
+      expect(events).toHaveLength(2);
+      expectStoredEvent(events[0], firstMatchingEvent);
+      expectStoredEvent(events[1], secondMatchingEvent);
     });
 
     it('returns EquipmentTrainingQuizResult events when one of the requested types matches', async () => {
@@ -149,15 +167,13 @@ describe('get all events', () => {
       await persistEvent(matchingEvent);
       await persistEvent(nonMatchingEvent);
 
-      expect(
-        await initalisedGetAllEventsByTypes(
-          'EquipmentTrainingQuizResult',
-          'EquipmentTrainingSheetRegistered'
-        )
-      ).toStrictEqual([
-        equipmentTrainingQuizResult,
-        matchingEvent,
-      ]);
+      const events = await initalisedGetAllEventsByTypes(
+        'EquipmentTrainingQuizResult',
+        'EquipmentTrainingSheetRegistered'
+      );
+      expect(events).toHaveLength(2);
+      expectStoredEvent(events[0], equipmentTrainingQuizResult);
+      expectStoredEvent(events[1], matchingEvent);
     });
   });
 });