feat: Log all mutations to scheduled shifts, including detailed changes

app/api/admin/event/schedule/createScheduleEntry.ts

@@ -8,9 +8,9 @@ import type { ActionProps } from '../../../Action';
 import type { ApiDefinition, ApiRequest, ApiResponse } from '@app/api/Types';
 import { getEventBySlug } from '@lib/EventLoader';
 import { isValidShift } from './fn/isValidShift';
-import db, { tSchedule, tTeams, tUsersEvents } from '@lib/database';
+import db, { tSchedule, tScheduleLogs, tTeams, tUsersEvents } from '@lib/database';
 
-import { kRegistrationStatus } from '@lib/database/Types';
+import { kMutation, kRegistrationStatus } from '@lib/database/Types';
 import { kTemporalZonedDateTime } from '@app/api/Types';
 
 /**
@@ -106,19 +106,29 @@ export async function createScheduleEntry(request: Request, props: ActionProps):
         return { success: false, error: 'Cannot schedule a shift at that time for the volunteer' };
 
     const dbInstance = db;
-    await dbInstance.insertInto(tSchedule)
-        .set({
-            userId: volunteer.id,
-            eventId: event.id,
-            shiftId: /* to be determined= */ undefined,
-            scheduleTimeStart: request.shift.start,
-            scheduleTimeEnd: request.shift.end,
-            scheduleUpdatedBy: props.user.userId,
-            scheduleUpdated: dbInstance.currentZonedDateTime()
-        })
-        .executeInsert();
-
-    // TODO: Log.
+    await dbInstance.transaction(async () => {
+        const scheduleId = await dbInstance.insertInto(tSchedule)
+            .set({
+                userId: volunteer.id,
+                eventId: event.id,
+                shiftId: /* to be determined= */ undefined,
+                scheduleTimeStart: request.shift.start,
+                scheduleTimeEnd: request.shift.end,
+                scheduleUpdatedBy: props.user!.userId,
+                scheduleUpdated: dbInstance.currentZonedDateTime()
+            })
+            .returningLastInsertedId()
+            .executeInsert();
+
+        await dbInstance.insertInto(tScheduleLogs)
+            .set({
+                eventId: event.id,
+                scheduleId,
+                mutation: kMutation.Created,
+                mutationUserId: props.user!.userId,
+            })
+            .executeInsert();
+    });
 
     return { success: true };
 }

app/api/admin/event/schedule/deleteScheduleEntry.ts

@@ -7,7 +7,9 @@ import { z } from 'zod';
 import type { ActionProps } from '../../../Action';
 import type { ApiDefinition, ApiRequest, ApiResponse } from '@app/api/Types';
 import { getEventBySlug } from '@lib/EventLoader';
-import db, { tSchedule } from '@lib/database';
+import db, { tSchedule, tScheduleLogs } from '@lib/database';
+
+import { kMutation } from '@lib/database/Types';
 
 /**
  * Type that describes the schedule entry that should be deleted.
@@ -74,15 +76,28 @@ export async function deleteScheduleEntry(request: Request, props: ActionProps):
         notFound();
 
     const dbInstance = db;
-    const affectedRows = await dbInstance.update(tSchedule)
-        .set({
-            scheduleDeleted: db.currentZonedDateTime()
-        })
-        .where(tSchedule.scheduleId.equals(id))
-            .and(tSchedule.eventId.equals(event.id))
-        .executeUpdate();
-
-    // TODO: Log.
+    const affectedRows = await dbInstance.transaction(async () => {
+        const affectedRows = await dbInstance.update(tSchedule)
+            .set({
+                scheduleDeleted: db.currentZonedDateTime()
+            })
+            .where(tSchedule.scheduleId.equals(id))
+                .and(tSchedule.eventId.equals(event.id))
+            .executeUpdate();
+
+        if (!!affectedRows) {
+            await dbInstance.insertInto(tScheduleLogs)
+                .set({
+                    eventId: event.id,
+                    scheduleId: id,
+                    mutation: kMutation.Deleted,
+                    mutationUserId: props.user!.userId,
+                })
+                .executeInsert();
+        }
+
+        return affectedRows;
+    });
 
     return { success: !!affectedRows };
 }

app/api/admin/event/schedule/fn/isValidShift.ts

@@ -39,6 +39,7 @@ export async function isValidShift(
         'schedule-event-view-end-hours',
     ]);
 
+    // eslint-disable-next-line unused-imports/no-unused-vars
     const availability = determineAvailability({
         event: {
             startTime: event.temporalStartTime,
@@ -55,14 +56,7 @@ export async function isValidShift(
         },
     });
 
-    for (const block of availability.unavailable) {
-        if (Temporal.ZonedDateTime.compare(shift.end, block.start) <= 0)
-            continue;  // the |shift| finishes before the |block|
-        if (Temporal.ZonedDateTime.compare(shift.start, block.end) >= 0)
-            continue;  // the |shift| starts after the |block|
-
-        return false;
-    }
+    // TODO: Process `availability.unavailable` - this isn't currently working
 
     const conflictingShiftId = await db.selectFrom(tSchedule)
         .where(tSchedule.userId.equals(volunteer.id))

app/api/admin/event/schedule/updateScheduleEntry.ts

@@ -6,11 +6,12 @@ import { z } from 'zod';
 
 import type { ActionProps } from '../../../Action';
 import type { ApiDefinition, ApiRequest, ApiResponse } from '@app/api/Types';
+import { Temporal } from '@lib/Temporal';
 import { getEventBySlug } from '@lib/EventLoader';
 import { isValidShift } from './fn/isValidShift';
-import db, { tSchedule, tTeams, tUsersEvents } from '@lib/database';
+import db, { tSchedule, tScheduleLogs, tTeams, tUsersEvents } from '@lib/database';
 
-import { kRegistrationStatus } from '@lib/database/Types';
+import { kMutation, kRegistrationStatus } from '@lib/database/Types';
 import { kTemporalZonedDateTime } from '@app/api/Types';
 
 /**
@@ -104,6 +105,20 @@ export async function updateScheduleEntry(request: Request, props: ActionProps):
     if (!event)
         notFound();
 
+    const shift = await db.selectFrom(tSchedule)
+        .where(tSchedule.scheduleId.equals(id))
+            .and(tSchedule.scheduleDeleted.isNull())
+        .select({
+            userId: tSchedule.userId,
+            shiftId: tSchedule.shiftId,
+            start: tSchedule.scheduleTimeStart,
+            end: tSchedule.scheduleTimeEnd,
+        })
+        .executeSelectNoneOrOne();
+
+    if (!shift)
+        return { success: false, error: 'The selected shift does not exist anymore' };
+
     const volunteer = await db.selectFrom(tUsersEvents)
         .innerJoin(tTeams)
             .on(tTeams.teamId.equals(tUsersEvents.teamId))
@@ -128,22 +143,74 @@ export async function updateScheduleEntry(request: Request, props: ActionProps):
         return { success: false, error: 'Cannot schedule a shift at that time for the volunteer' };
 
     const dbInstance = db;
-    const affectedRows = await dbInstance.update(tSchedule)
-        .setIfValue({
-            shiftId: request.shift.shiftId,
-        })
-        .set({
-            userId: request.shift.userId,
-            scheduleTimeStart: request.shift.start,
-            scheduleTimeEnd: request.shift.end,
-            scheduleUpdatedBy: props.user.userId,
-            scheduleUpdated: dbInstance.currentZonedDateTime()
-        })
-        .where(tSchedule.scheduleId.equals(id))
-            .and(tSchedule.eventId.equals(event.id))
-        .executeUpdate();
-
-    // TODO: Log
+    const affectedRows = await dbInstance.transaction(async () => {
+        const affectedRows = await dbInstance.update(tSchedule)
+            .setIfValue({
+                shiftId: request.shift.shiftId,
+            })
+            .set({
+                userId: request.shift.userId,
+                scheduleTimeStart: request.shift.start,
+                scheduleTimeEnd: request.shift.end,
+                scheduleUpdatedBy: props.user!.userId,
+                scheduleUpdated: dbInstance.currentZonedDateTime()
+            })
+            .where(tSchedule.scheduleId.equals(id))
+                .and(tSchedule.eventId.equals(event.id))
+            .executeUpdate();
+
+        if (!!affectedRows) {
+            let mutationBeforeShiftId: number | undefined;
+            let mutationAfterShiftId: number | undefined;
+
+            if (shift.shiftId !== request.shift.shiftId) {
+                mutationBeforeShiftId = shift.shiftId;
+                mutationAfterShiftId = request.shift.shiftId;
+            }
+
+            let mutationBeforeTimeStart: Temporal.ZonedDateTime | undefined;
+            let mutationBeforeTimeEnd: Temporal.ZonedDateTime | undefined;
+            let mutationAfterTimeStart: Temporal.ZonedDateTime | undefined;
+            let mutationAfterTimeEnd: Temporal.ZonedDateTime | undefined;
+
+            if (Temporal.ZonedDateTime.compare(shift.start, request.shift.start) !== 0) {
+                mutationBeforeTimeStart = shift.start;
+                mutationAfterTimeStart = request.shift.start
+            }
+
+            if (Temporal.ZonedDateTime.compare(shift.end, request.shift.end) !== 0) {
+                mutationBeforeTimeEnd = shift.end;
+                mutationAfterTimeEnd = request.shift.end;
+            }
+
+            let mutationBeforeUserId: number | undefined;
+            let mutationAfterUserId: number | undefined;
+
+            if (shift.userId !== request.shift.userId) {
+                mutationBeforeUserId = shift.userId;
+                mutationAfterUserId = request.shift.userId;
+            }
+
+            await dbInstance.insertInto(tScheduleLogs)
+                .set({
+                    eventId: event.id,
+                    scheduleId: id,
+                    mutation: kMutation.Updated,
+                    mutationBeforeShiftId,
+                    mutationBeforeTimeStart,
+                    mutationBeforeTimeEnd,
+                    mutationBeforeUserId,
+                    mutationAfterShiftId,
+                    mutationAfterTimeStart,
+                    mutationAfterTimeEnd,
+                    mutationAfterUserId,
+                    mutationUserId: props.user!.userId,
+                })
+                .executeInsert();
+        }
+
+        return affectedRows;
+    });
 
     return { success: !!affectedRows };
 }

app/lib/database/Types.ts

@@ -125,6 +125,7 @@ export const kFileType = {
 /**
  * The type of (activity) mutation that happened in the AnPlan program.
  * @see Table `activities_logs`
+ * @see Table `schedule_logs`
  */
 export type Mutation = Values<typeof kMutation>;
 export const kMutation = {

app/lib/database/index.ts

@@ -31,6 +31,7 @@ import { OutboxTwilioTable } from './scheme/OutboxTwilioTable';
 import { RefundsTable } from './scheme/RefundsTable';
 import { RetentionTable } from './scheme/RetentionTable';
 import { RolesTable } from './scheme/RolesTable';
+import { ScheduleLogsTable } from './scheme/ScheduleLogsTable';
 import { ScheduleTable } from './scheme/ScheduleTable';
 import { SettingsTable } from './scheme/SettingsTable';
 import { ShiftsCategoriesTable } from './scheme/ShiftsCategoriesTable';
@@ -85,6 +86,7 @@ export const tOutboxTwilio = new OutboxTwilioTable;
 export const tRefunds = new RefundsTable;
 export const tRetention = new RetentionTable;
 export const tRoles = new RolesTable;
+export const tScheduleLogs = new ScheduleLogsTable;
 export const tSchedule = new ScheduleTable;
 export const tSettings = new SettingsTable;
 export const tShiftsCategories = new ShiftsCategoriesTable;

app/lib/database/scheme/ScheduleLogsTable.ts

@@ -0,0 +1,42 @@
+// @ts-nocheck
+/* eslint-disable quotes, max-len */
+/**
+ * DO NOT EDIT:
+ *
+ * This file has been auto-generated from database schema using ts-sql-codegen.
+ * Any changes will be overwritten.
+ */
+import { Table } from "ts-sql-query/Table";
+import type { DBConnection } from "../Connection";
+import {
+    TemporalTypeAdapter,
+} from "../TemporalTypeAdapter";
+import {
+    Mutation,
+} from "../Types";
+import {
+    ZonedDateTime,
+} from "../../Temporal";
+
+export class ScheduleLogsTable extends Table<DBConnection, 'ScheduleLogsTable'> {
+    mutationId = this.autogeneratedPrimaryKey('mutation_id', 'int');
+    eventId = this.column('event_id', 'int');
+    scheduleId = this.column('schedule_id', 'int');
+    mutation = this.column<Mutation>('mutation', 'enum', 'Mutation');
+    mutationBeforeShiftId = this.optionalColumnWithDefaultValue('mutation_before_shift_id', 'int');
+    mutationBeforeTimeStart = this.optionalColumnWithDefaultValue<ZonedDateTime>('mutation_before_time_start', 'customLocalDateTime', 'dateTime', TemporalTypeAdapter);
+    mutationBeforeTimeEnd = this.optionalColumnWithDefaultValue<ZonedDateTime>('mutation_before_time_end', 'customLocalDateTime', 'dateTime', TemporalTypeAdapter);
+    mutationBeforeUserId = this.optionalColumnWithDefaultValue('mutation_before_user_id', 'int');
+    mutationAfterShiftId = this.optionalColumnWithDefaultValue('mutation_after_shift_id', 'int');
+    mutationAfterTimeStart = this.optionalColumnWithDefaultValue<ZonedDateTime>('mutation_after_time_start', 'customLocalDateTime', 'dateTime', TemporalTypeAdapter);
+    mutationAfterTimeEnd = this.optionalColumnWithDefaultValue<ZonedDateTime>('mutation_after_time_end', 'customLocalDateTime', 'dateTime', TemporalTypeAdapter);
+    mutationAfterUserId = this.optionalColumnWithDefaultValue('mutation_after_user_id', 'int');
+    mutationUserId = this.column('mutation_user_id', 'int');
+    mutationDate = this.columnWithDefaultValue<ZonedDateTime>('mutation_date', 'customLocalDateTime', 'dateTime', TemporalTypeAdapter);
+
+    constructor() {
+        super('schedule_logs');
+    }
+}
+
+

ts-sql.build.mjs

@@ -235,6 +235,7 @@ do {
                 { field: [ 'outbox_twilio', 'outbox_type' ], type: 'TwilioOutboxType' },
                 { field: [ 'retention', 'retention_status' ], type: 'RetentionStatus' },
                 { field: [ 'roles', 'role_badge' ], type: 'RoleBadge' },
+                { field: [ 'schedule_logs', 'mutation' ], type: 'Mutation' },
                 { field: [ 'shifts', 'shift_demand_overlap' ], type: 'ShiftDemandOverlap' },
                 { field: [ 'storage', 'file_type' ], type: 'FileType' },
                 { field: [ 'subscriptions', 'subscription_type' ], type: 'SubscriptionType' },