Wiring up a way to view exclusion log

Author: Lan2u

src/dependencies.ts

@@ -4,14 +4,14 @@ 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 {SharedReadModel} from './read-models/shared-state';
 import {
   SheetDataTable,
   TroubleTicketDataTable,
 } from './sync-worker/google/sheet-data-table';
+import { ExcludedEvent } from './init-dependencies/event-store/excluded-event';
 
 export type Dependencies = {
   commitEvent: (
@@ -32,6 +32,10 @@ export type Dependencies = {
     FailureWithStatus,
     ReadonlyArray<DomainEvent>
   >;
+  getAllExclusionEvents: () => TE.TaskEither<
+    FailureWithStatus,
+    ReadonlyArray<ExcludedEvent>
+  >;
   getAllEventsByType: <T extends EventName>(
     eventType: T
   ) => TE.TaskEither<FailureWithStatus, ReadonlyArray<EventOfType<T>>>;

src/init-dependencies/event-store/ensure-events-table-exists.ts

@@ -33,8 +33,9 @@ export const ensureEventTableExists = (eventDB: Client) =>
           CREATE TABLE IF NOT EXISTS events_exclusions (
             id TEXT PRIMARY KEY,
             event_id TEXT NOT NULL,
-            reverted_by_number number NOT NULL,
-            revert_reason TEXT NOT NULL
+            reverted_by_member_number INTEGER NOT NULL,
+            revert_reason TEXT NOT NULL,
+            reverted_at_timestamp_epoch_ms INTEGER NOT NULL
           );
           CREATE INDEX IF NOT EXISTS events_exclusions_event_id_idx
           ON events_exclusions (event_id);

src/init-dependencies/event-store/events-table.ts

@@ -19,8 +19,11 @@ export const EventExclusionsTable = t.strict({
     t.strict({
       id: t.string,
       event_id: t.string,
-      reverted_by_number: t.Int,
+      reverted_by_member_number: t.Int,
       revert_reason: t.string,
+      reverted_at_timestamp_epoch_ms: t.Int,
+      payload: t.string,
+      event_type: t.string,
     })
   ),
 });

src/init-dependencies/event-store/excluded-event.ts

@@ -0,0 +1,11 @@
+import { Int } from "io-ts";
+import { DomainEvent } from "../../types";
+
+export type ExcludedEvent = {
+    id: string,
+    event_id: string,
+    reverted_by_number: Int,
+    revert_reason: string,
+    revert_at: Date,
+    payload: DomainEvent,
+};

src/init-dependencies/event-store/exclusion-events-from-rows.ts

@@ -0,0 +1,27 @@
+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]) =>
+  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.mapLeft(internalCodecFailure('Failed to get events from DB'))
+  );

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

@@ -6,13 +6,15 @@ import {
 } from '../../types/failure-with-status';
 import * as TE from 'fp-ts/TaskEither';
 import * as E from 'fp-ts/Either';
-import {EventsTable} from './events-table';
+import * as RA from 'fp-ts/ReadonlyArray';
+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 {dbExecute} from '../../util';
+import { exclusionEventsFromRows } from './exclusion-events-from-rows';
 
 export const getAllEvents =
   (dbClient: Client): Dependencies['getAllEvents'] =>
@@ -132,3 +134,32 @@ export const getAllEventsByTypes =
         ReadonlyArray<EventOfType<T> | EventOfType<R>>
       >(es => es as ReadonlyArray<EventOfType<T> | EventOfType<R>>)
     );
+
+export const getAllExclusionEvents = (dbClient: Client): Dependencies['getAllExclusionEvents'] =>
+  () =>
+    pipe(
+      TE.tryCatch(
+        () =>
+          dbExecute(
+            dbClient,
+            `
+            SELECT events_exclusions.*, events.payload, events.event_type
+            FROM events_exclusions
+            INNER JOIN events ON events.id = events_exclusions.event_id
+            `,
+            {}
+          ),
+        failureWithStatus(
+          'Failed to query database',
+          StatusCodes.INTERNAL_SERVER_ERROR
+        )
+      ),
+      TE.chainEitherK(
+        flow(
+          EventExclusionsTable.decode,
+          E.mapLeft(internalCodecFailure('Failed to decode event exclusions DB table'))
+        )
+      ),
+      TE.map(table => table.rows),
+      TE.map(exclusionEventsFromRows)
+    );

src/init-dependencies/init-dependencies.ts

@@ -6,7 +6,7 @@ import * as O from 'fp-ts/Option';
 import createLogger, {LoggerOptions} from 'pino';
 import nodemailer from 'nodemailer';
 import {commitEvent} from './event-store/commit-event';
-import {getAllEvents, getAllEventsByType} from './event-store/get-all-events';
+import {getAllEvents, getAllEventsByType, getAllExclusionEvents} from './event-store/get-all-events';
 import {getResourceEvents} from './event-store/get-resource-events';
 import {Client} from '@libsql/client';
 
@@ -73,6 +73,7 @@ export const initDependencies = (
     commitEvent: commitEvent(eventDB, logger, sharedReadModel.asyncRefresh),
     excludeEvent: excludeEvent(eventDB),
     getAllEvents: getAllEvents(eventDB),
+    getAllExclusionEvents: getAllExclusionEvents(eventDB),
     getAllEventsByType: getAllEventsByType(eventDB),
     getResourceEvents: getResourceEvents(eventDB),
     sharedReadModel,

src/queries/exclusion-log/construct-view-model.ts

@@ -0,0 +1,27 @@
+import {pipe} from 'fp-ts/lib/function';
+import {User} from '../../types';
+import {Dependencies} from '../../dependencies';
+import * as TE from 'fp-ts/TaskEither';
+import {readModels} from '../../read-models';
+import {FailureWithStatus, failureWithStatus} from '../../types/failure-with-status';
+import {StatusCodes} from 'http-status-codes';
+import { ViewModel } from './view-model';
+
+
+export const constructViewModel =
+  (deps: Dependencies) => (user: User) => (): TE.TaskEither<FailureWithStatus, ViewModel> =>
+    pipe(
+      deps.getAllEvents(),
+      TE.filterOrElse(readModels.superUsers.is(user.memberNumber), () =>
+        failureWithStatus(
+          'You do not have the necessary permission to see this page.',
+          StatusCodes.FORBIDDEN
+        )()
+      ),
+      TE.chain(
+        (_events) => deps.getAllExclusionEvents()
+      ),
+      TE.map(
+        events => ({events})
+      )
+    );

src/queries/exclusion-log/index.ts

@@ -0,0 +1,14 @@
+import {pipe} from 'fp-ts/lib/function';
+import * as TE from 'fp-ts/TaskEither';
+import {render} from './render';
+import {constructViewModel} from './construct-view-model';
+import {Query, Params} from '../query';
+import {safe, toLoggedInContent} from '../../types/html';
+import {User} from '../../types';
+
+export const exclusionLog: Query = deps => (user: User) =>
+  pipe(
+    constructViewModel(deps)(user)(),
+    TE.map(render),
+    TE.map(toLoggedInContent(safe('Event Log')))
+  );

src/queries/exclusion-log/render.ts

@@ -0,0 +1,47 @@
+import {pipe} from 'fp-ts/lib/function';
+import * as RA from 'fp-ts/ReadonlyArray';
+import {html, joinHtml, sanitizeString} from '../../types/html';
+import {ViewModel} from './view-model';
+import {DomainEvent} from '../../types';
+import {inspect} from 'node:util';
+import {displayDate} from '../../templates/display-date';
+import {DateTime} from 'luxon';
+import { renderMemberNumber } from '../../templates/member-number';
+
+const renderPayload = (event: DomainEvent) =>
+  // eslint-disable-next-line unused-imports/no-unused-vars
+  pipe(event, ({type, actor, recordedAt, ...payload}) =>
+    pipe(
+      payload,
+      Object.entries,
+      RA.map(([key, value]) => `${key}: ${inspect(value)}`),
+      RA.map(sanitizeString),
+      joinHtml
+    )
+  );
+
+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>
+    ${renderPayload(event.payload)}
+  </li>
+`;
+
+const renderLog = (log: ViewModel['events']) =>
+  pipe(
+    log,
+    RA.map(renderEntry),
+    joinHtml,
+    items => html`
+      <ul>
+        ${items}
+      </ul>
+    `
+  );
+
+export const render = (viewModel: ViewModel) => html`
+  <h1>Event log</h1>
+  <p>There are ${viewModel.events.length} excluded events</p>
+  ${renderLog(viewModel.events)}
+`;