Add hooks for user & field region/zone updates

Author: CarsonF

src/components/field-region/events/field-region-updated.event.ts

@@ -0,0 +1,10 @@
+import { type UnsecuredDto } from '~/common';
+import { type FieldRegion, type UpdateFieldRegion } from '../dto';
+
+export class FieldRegionUpdatedEvent {
+  constructor(
+    readonly updated: UnsecuredDto<FieldRegion>,
+    readonly previous: UnsecuredDto<FieldRegion>,
+    readonly input: UpdateFieldRegion,
+  ) {}
+}

src/components/field-region/field-region.service.ts

@@ -6,6 +6,7 @@ import {
   type UnsecuredDto,
 } from '~/common';
 import { HandleIdLookup } from '~/core';
+import { IEventBus } from '~/core/events';
 import { Privileges } from '../authorization';
 import {
   type CreateFieldRegion,
@@ -14,12 +15,14 @@ import {
   type FieldRegionListOutput,
   type UpdateFieldRegion,
 } from './dto';
+import { FieldRegionUpdatedEvent } from './events/field-region-updated.event';
 import { FieldRegionRepository } from './field-region.repository';
 
 @Injectable()
 export class FieldRegionService {
   constructor(
     private readonly privileges: Privileges,
+    private readonly events: IEventBus,
     private readonly repo: FieldRegionRepository,
   ) {}
 
@@ -50,7 +53,18 @@ export class FieldRegionService {
     const changes = this.repo.getActualChanges(fieldRegion, input);
     this.privileges.for(FieldRegion, fieldRegion).verifyChanges(changes);
 
+    if (Object.keys(changes).length === 0) {
+      return this.secure(fieldRegion);
+    }
+
     const updated = await this.repo.update({ id: input.id, ...changes });
+
+    const event = new FieldRegionUpdatedEvent(fieldRegion, updated, {
+      id: input.id,
+      ...changes,
+    });
+    await this.events.publish(event);
+
     return this.secure(updated);
   }
 

src/components/field-zone/events/field-zone-updated.event.ts

@@ -0,0 +1,10 @@
+import { type UnsecuredDto } from '~/common';
+import { type FieldZone, type UpdateFieldZone } from '../dto';
+
+export class FieldZoneUpdatedEvent {
+  constructor(
+    readonly updated: UnsecuredDto<FieldZone>,
+    readonly previous: UnsecuredDto<FieldZone>,
+    readonly input: UpdateFieldZone,
+  ) {}
+}

src/components/field-zone/field-zone.service.ts

@@ -6,6 +6,7 @@ import {
   type UnsecuredDto,
 } from '~/common';
 import { HandleIdLookup } from '~/core';
+import { IEventBus } from '~/core/events';
 import { Privileges } from '../authorization';
 import {
   type CreateFieldZone,
@@ -14,12 +15,14 @@ import {
   type FieldZoneListOutput,
   type UpdateFieldZone,
 } from './dto';
+import { FieldZoneUpdatedEvent } from './events/field-zone-updated.event';
 import { FieldZoneRepository } from './field-zone.repository';
 
 @Injectable()
 export class FieldZoneService {
   constructor(
     private readonly privileges: Privileges,
+    private readonly events: IEventBus,
     private readonly repo: FieldZoneRepository,
   ) {}
 
@@ -50,7 +53,18 @@ export class FieldZoneService {
     const changes = this.repo.getActualChanges(fieldZone, input);
     this.privileges.for(FieldZone, fieldZone).verifyChanges(changes);
 
+    if (Object.keys(changes).length === 0) {
+      return this.secure(fieldZone);
+    }
+
     const updated = await this.repo.update({ id: input.id, ...changes });
+
+    const event = new FieldZoneUpdatedEvent(fieldZone, updated, {
+      id: input.id,
+      ...changes,
+    });
+    await this.events.publish(event);
+
     return this.secure(updated);
   }
 

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

@@ -0,0 +1,10 @@
+import { type UnsecuredDto } from '~/common';
+import { type UpdateUser, type User } from '../dto';
+
+export class UserUpdatedEvent {
+  constructor(
+    readonly updated: UnsecuredDto<User>,
+    readonly previous: UnsecuredDto<User>,
+    readonly input: UpdateUser,
+  ) {}
+}

src/components/user/user.service.ts

@@ -11,7 +11,7 @@ import {
 import { HandleIdLookup, ILogger, Logger } from '~/core';
 import { Identity } from '~/core/authentication';
 import { Transactional } from '~/core/database';
-import { property } from '~/core/database/query';
+import { IEventBus } from '~/core/events';
 import { Privileges } from '../authorization';
 import { AssignableRoles } from '../authorization/dto/assignable-roles.dto';
 import { LocationService } from '../location';
@@ -42,6 +42,7 @@ import {
   type EducationListInput,
   type SecuredEducationList,
 } from './education/dto';
+import { UserUpdatedEvent } from './events/user-updated.event';
 import { KnownLanguageRepository } from './known-language.repository';
 import { UnavailabilityService } from './unavailability';
 import {
@@ -62,16 +63,11 @@ export class UserService {
     private readonly locationService: LocationService,
     private readonly knownLanguages: KnownLanguageRepository,
     private readonly identity: Identity,
+    private readonly events: IEventBus,
     private readonly userRepo: UserRepository,
     @Logger('user:service') private readonly logger: ILogger,
   ) {}
 
-  roleProperties = (roles?: Role[]) => {
-    return (roles || []).flatMap((role) =>
-      property('roles', role, 'user', `role${role}`),
-    );
-  };
-
   async create(input: CreatePerson): Promise<ID> {
     if (
       input.roles &&
@@ -117,20 +113,29 @@ export class UserService {
   @Transactional()
   async update(input: UpdateUser): Promise<User> {
     this.logger.debug('mutation update User', { input });
-    const user = await this.readOne(input.id);
+    const user = await this.userRepo.readOne(input.id);
 
     const changes = this.userRepo.getActualChanges(user, input);
 
     this.privileges.for(User, user).verifyChanges(changes);
 
+    if (Object.keys(changes).length === 0) {
+      return this.secure(user);
+    }
+
     if (changes.roles) {
       this.verifyRolesAreAssignable(changes.roles);
     }
 
-    const updated = await this.userRepo.update({
+    input = {
       id: user.id,
       ...changes,
-    });
+    };
+    const updated = await this.userRepo.update(input);
+
+    const event = new UserUpdatedEvent(user, updated, input);
+    await this.events.publish(event);
+
     return this.secure(updated);
   }