@hed-hog/core 0.0.367 → 0.0.370

package/src/user/user.service.ts

@@ -1,6 +1,7 @@
 import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
+import type { Prisma, user_change_log } from '@hed-hog/api-prisma';
 import {
     BadRequestException,
     Inject,
@@ -55,6 +56,18 @@ const USER_SORT_FIELDS = [
 
 const USER_SEARCH_FIELDS = ['name'] as const;
 
+type UserChangeLog = user_change_log;
+type UserChangeLogActor = Prisma.userGetPayload<{
+  select: {
+    id: true;
+    name: true;
+    user_identifier: {
+      select: { value: true };
+      take: 1;
+    };
+  };
+}>;
+
 @Injectable()
 export class UserService {
   constructor(
@@ -213,7 +226,12 @@ export class UserService {
     return { user, challenge };
   }
 
-  async update(locale: string, userId: number, { name }: UpdateDTO) {
+  async update(
+    locale: string,
+    userId: number,
+    { name }: UpdateDTO,
+    actorUserId?: number,
+  ) {
     const user = await this.findUserById(locale, userId);
 
     const result = await this.prismaService.user.update({
@@ -221,6 +239,17 @@ export class UserService {
       data: { name: name ?? user.name },
     });
 
+    if (result.name !== user.name) {
+      await this.recordUserChange({
+        targetUserId: userId,
+        actorUserId,
+        action: 'update',
+        summary: `name: "${user.name ?? ''}" → "${result.name ?? ''}"`,
+        beforeData: { name: user.name },
+        afterData: { name: result.name },
+      });
+    }
+
     await this.integrationApi.publishEvent({
       eventName: 'core.user.updated',
       sourceModule: 'core',
@@ -236,6 +265,7 @@ export class UserService {
     locale: string,
     userId: number,
     { password }: ResetPasswordDTO,
+    actorUserId?: number,
   ) {
     await this.validateUserExists(locale, userId);
 
@@ -266,6 +296,13 @@ export class UserService {
 
     await this.registerUserActivity(userId, 'resetPassword');
 
+    await this.recordUserChange({
+      targetUserId: userId,
+      actorUserId,
+      action: 'reset_password',
+      summary: 'Password reset and flagged for required change on next login',
+    });
+
     return {
       password: nextPassword,
       requiresReset: true,
@@ -305,7 +342,12 @@ export class UserService {
   // Avatar Management
   // ==========================================
 
-  async changeAvatar(locale: string, userId: number, avatar: MulterFile) {
+  async changeAvatar(
+    locale: string,
+    userId: number,
+    avatar: MulterFile,
+    actorUserId?: number,
+  ) {
     const user = await this.validateUserExists(locale, userId);
 
     const newFile = await this.file.upload(USER_AVATAR_UPLOAD_DESTINATION, avatar);
@@ -317,6 +359,15 @@ export class UserService {
       data: { photo_id: newFile.id },
     });
 
+    await this.recordUserChange({
+      targetUserId: userId,
+      actorUserId,
+      action: 'avatar_changed',
+      summary: 'Avatar updated',
+      beforeData: { photo_id: user.photo_id },
+      afterData: { photo_id: newFile.id },
+    });
+
     return {
       id: newFile.id,
       path: newFile.path,
@@ -518,8 +569,13 @@ export class UserService {
     }));
   }
 
-  async assignRoleToUser(locale: string, userId: number, roleId: number) {
-    await Promise.all([
+  async assignRoleToUser(
+    locale: string,
+    userId: number,
+    roleId: number,
+    actorUserId?: number,
+  ) {
+    const [, role] = await Promise.all([
       this.validateUserExists(locale, userId),
       this.validateRoleExists(locale, roleId),
     ]);
@@ -530,16 +586,31 @@ export class UserService {
       return existingRoleUser;
     }
 
-    return this.prismaService.role_user.create({
+    const result = await this.prismaService.role_user.create({
       data: {
         user_id: userId,
         role_id: roleId,
       },
     });
+
+    await this.recordUserChange({
+      targetUserId: userId,
+      actorUserId,
+      action: 'role_assigned',
+      summary: `Role assigned: ${role.slug}`,
+      afterData: { role_id: roleId, slug: role.slug },
+    });
+
+    return result;
   }
 
-  async removeRoleFromUser(locale: string, userId: number, roleId: number) {
-    await Promise.all([
+  async removeRoleFromUser(
+    locale: string,
+    userId: number,
+    roleId: number,
+    actorUserId?: number,
+  ) {
+    const [, role] = await Promise.all([
       this.validateUserExists(locale, userId),
       this.validateRoleExists(locale, roleId),
     ]);
@@ -554,6 +625,14 @@ export class UserService {
       where: { id: roleUser.id },
     });
 
+    await this.recordUserChange({
+      targetUserId: userId,
+      actorUserId,
+      action: 'role_removed',
+      summary: `Role removed: ${role.slug}`,
+      beforeData: { role_id: roleId, slug: role.slug },
+    });
+
     return { count: 1 };
   }
 
@@ -574,6 +653,102 @@ export class UserService {
     });
   }
 
+  // ==========================================
+  // Change Log (administrative audit trail)
+  // ==========================================
+
+  private async recordUserChange(data: {
+    targetUserId: number;
+    actorUserId?: number | null;
+    action: string;
+    summary?: string;
+    beforeData?: unknown;
+    afterData?: unknown;
+  }) {
+    return this.prismaService.user_change_log
+      .create({
+        data: {
+          target_user_id: data.targetUserId,
+          actor_user_id: data.actorUserId ?? null,
+          action: data.action,
+          summary: data.summary ?? null,
+          before_data:
+            data.beforeData === undefined
+              ? null
+              : JSON.stringify(data.beforeData),
+          after_data:
+            data.afterData === undefined
+              ? null
+              : JSON.stringify(data.afterData),
+        },
+      })
+      .catch(() => null);
+  }
+
+  async listUserChangeLogs(locale: string, userId: number, paginationParams) {
+    await this.validateUserExists(locale, userId);
+
+    const paginated = await this.paginationService.paginatePrismaModel(
+      this.prismaService.user_change_log,
+      {
+        page: paginationParams?.page,
+        pageSize: paginationParams?.pageSize,
+        sortField: paginationParams?.sortField || 'created_at',
+        sortOrder: paginationParams?.sortOrder || 'desc',
+        validSortFields: ['id', 'created_at', 'action'],
+        where: { target_user_id: userId },
+      },
+    );
+
+    const logs = (paginated.data || []) as UserChangeLog[];
+    const actorIds = [
+      ...new Set(
+        logs
+          .map((log) => log.actor_user_id)
+          .filter((id): id is number => Boolean(id)),
+      ),
+    ];
+
+    const actors: UserChangeLogActor[] = actorIds.length
+      ? await this.prismaService.user.findMany({
+          where: { id: { in: actorIds } },
+          select: {
+            id: true,
+            name: true,
+            user_identifier: {
+              where: { type: IDENTIFIER_TYPE.EMAIL, enabled: true },
+              select: { value: true },
+              take: 1,
+            },
+          },
+        })
+      : [];
+
+    const actorMap = new Map(actors.map((actor) => [actor.id, actor]));
+
+    return {
+      ...paginated,
+      data: logs.map((log) => {
+        const actor = log.actor_user_id
+          ? actorMap.get(log.actor_user_id)
+          : null;
+
+        return {
+          id: String(log.id),
+          actorUserId: log.actor_user_id ? String(log.actor_user_id) : null,
+          actorName: actor?.name ?? null,
+          actorEmail: actor?.user_identifier?.[0]?.value ?? null,
+          action: log.action,
+          summary: log.summary || '',
+          beforeData: log.before_data || '',
+          afterData: log.after_data || '',
+          ipAddress: log.ip_address || '',
+          createdAt: log.created_at?.toISOString?.() || null,
+        };
+      }),
+    };
+  }
+
   // ==========================================
   // Private Helper Methods
   // ==========================================
@@ -761,4 +936,4 @@ export class UserService {
       },
     });
   }
-}
+}

package/src/webhook-integration/integration-event-catalog.controller.ts

@@ -1,50 +1,50 @@
-import { DeleteDTO, Role } from '@hed-hog/api';
-import { Pagination } from '@hed-hog/api-pagination';
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-} from '@nestjs/common';
-import { IntegrationEventCatalogService } from './integration-event-catalog.service';
-
-@Role()
-@Controller('integration-event-catalog')
-export class IntegrationEventCatalogController {
-  constructor(private readonly service: IntegrationEventCatalogService) {}
-
-  @Get()
-  list(@Pagination() paginationParams) {
-    return this.service.list(paginationParams);
-  }
-
-  @Get('options')
-  options() {
-    return this.service.options();
-  }
-
-  @Get(':id')
-  get(@Param('id', ParseIntPipe) id: number) {
-    return this.service.get(id);
-  }
-
-  @Post()
-  create(@Body() data: any) {
-    return this.service.create(data);
-  }
-
-  @Patch(':id')
-  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
-    return this.service.update(id, data);
-  }
-
-  @Delete()
-  delete(@Body() data: DeleteDTO) {
-    return this.service.delete(data);
-  }
-}
-
+import { DeleteDTO, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { IntegrationEventCatalogService } from './integration-event-catalog.service';
+
+@Role()
+@Controller('integration-event-catalog')
+export class IntegrationEventCatalogController {
+  constructor(private readonly service: IntegrationEventCatalogService) {}
+
+  @Get()
+  list(@Pagination() paginationParams) {
+    return this.service.list(paginationParams);
+  }
+
+  @Get('options')
+  options() {
+    return this.service.options();
+  }
+
+  @Get(':id')
+  get(@Param('id', ParseIntPipe) id: number) {
+    return this.service.get(id);
+  }
+
+  @Post()
+  create(@Body() data: any) {
+    return this.service.create(data);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
+    return this.service.update(id, data);
+  }
+
+  @Delete()
+  delete(@Body() data: DeleteDTO) {
+    return this.service.delete(data);
+  }
+}
+

package/src/webhook-integration/integration-event-catalog.service.ts

@@ -1,117 +1,117 @@
-import { DeleteDTO } from '@hed-hog/api';
-import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
-import { PrismaService } from '@hed-hog/api-prisma';
-import {
-  BadRequestException,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
-
-@Injectable()
-export class IntegrationEventCatalogService {
-  constructor(
-    private readonly prisma: PrismaService,
-    private readonly pagination: PaginationService,
-  ) {}
-
-  private get delegate() {
-    return (this.prisma as any).integration_event_catalog;
-  }
-
-  async list(paginationParams: PaginationDTO) {
-    const fields = ['slug', 'name', 'module', 'description', 'status'];
-    const OR = this.prisma.createInsensitiveSearch(fields, paginationParams);
-
-    return this.pagination.paginate(this.delegate, paginationParams, {
-      where: OR.length > 0 ? { OR } : {},
-      orderBy: [{ module: 'asc' }, { slug: 'asc' }],
-    });
-  }
-
-  async options() {
-    return this.delegate.findMany({
-      where: { status: 'active' },
-      orderBy: [{ module: 'asc' }, { slug: 'asc' }],
-      select: {
-        id: true,
-        slug: true,
-        name: true,
-        module: true,
-        description: true,
-      },
-    });
-  }
-
-  async get(id: number) {
-    const record = await this.delegate.findUnique({ where: { id } });
-    if (!record) {
-      throw new NotFoundException(`Event catalog item with id ${id} not found.`);
-    }
-    return record;
-  }
-
-  async create(data: any) {
-    await this.ensureSlugAvailable(data.slug);
-    return this.delegate.create({
-      data: this.normalize(data),
-    });
-  }
-
-  async update(id: number, data: any) {
-    const existing = await this.get(id);
-    if (data.slug && data.slug !== existing.slug) {
-      await this.ensureSlugAvailable(data.slug);
-    }
-
-    return this.delegate.update({
-      where: { id },
-      data: this.normalize(data, true),
-    });
-  }
-
-  async delete(data: DeleteDTO) {
-    if (!data.ids?.length) {
-      throw new BadRequestException('You must select at least one item to delete.');
-    }
-
-    return this.delegate.deleteMany({
-      where: { id: { in: data.ids } },
-    });
-  }
-
-  private async ensureSlugAvailable(slug: string) {
-    const existing = await this.delegate.findUnique({
-      where: { slug: String(slug || '').trim() },
-      select: { id: true },
-    });
-
-    if (existing) {
-      throw new BadRequestException(`Event "${slug}" already exists.`);
-    }
-  }
-
-  private normalize(data: any, partial = false) {
-    const normalized: Record<string, any> = {};
-    const assign = (key: string, value: any) => {
-      if (!partial || value !== undefined) {
-        normalized[key] = value;
-      }
-    };
-
-    assign('slug', String(data.slug ?? '').trim());
-    assign('name', String(data.name ?? '').trim());
-    assign('module', String(data.module ?? '').trim());
-    assign(
-      'description',
-      data.description === undefined || data.description === null
-        ? partial
-          ? undefined
-          : null
-        : String(data.description).trim() || null,
-    );
-    assign('status', data.status === 'inactive' ? 'inactive' : 'active');
-
-    return normalized;
-  }
-}
-
+import { DeleteDTO } from '@hed-hog/api';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common';
+
+@Injectable()
+export class IntegrationEventCatalogService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly pagination: PaginationService,
+  ) {}
+
+  private get delegate() {
+    return (this.prisma as any).integration_event_catalog;
+  }
+
+  async list(paginationParams: PaginationDTO) {
+    const fields = ['slug', 'name', 'module', 'description', 'status'];
+    const OR = this.prisma.createInsensitiveSearch(fields, paginationParams);
+
+    return this.pagination.paginate(this.delegate, paginationParams, {
+      where: OR.length > 0 ? { OR } : {},
+      orderBy: [{ module: 'asc' }, { slug: 'asc' }],
+    });
+  }
+
+  async options() {
+    return this.delegate.findMany({
+      where: { status: 'active' },
+      orderBy: [{ module: 'asc' }, { slug: 'asc' }],
+      select: {
+        id: true,
+        slug: true,
+        name: true,
+        module: true,
+        description: true,
+      },
+    });
+  }
+
+  async get(id: number) {
+    const record = await this.delegate.findUnique({ where: { id } });
+    if (!record) {
+      throw new NotFoundException(`Event catalog item with id ${id} not found.`);
+    }
+    return record;
+  }
+
+  async create(data: any) {
+    await this.ensureSlugAvailable(data.slug);
+    return this.delegate.create({
+      data: this.normalize(data),
+    });
+  }
+
+  async update(id: number, data: any) {
+    const existing = await this.get(id);
+    if (data.slug && data.slug !== existing.slug) {
+      await this.ensureSlugAvailable(data.slug);
+    }
+
+    return this.delegate.update({
+      where: { id },
+      data: this.normalize(data, true),
+    });
+  }
+
+  async delete(data: DeleteDTO) {
+    if (!data.ids?.length) {
+      throw new BadRequestException('You must select at least one item to delete.');
+    }
+
+    return this.delegate.deleteMany({
+      where: { id: { in: data.ids } },
+    });
+  }
+
+  private async ensureSlugAvailable(slug: string) {
+    const existing = await this.delegate.findUnique({
+      where: { slug: String(slug || '').trim() },
+      select: { id: true },
+    });
+
+    if (existing) {
+      throw new BadRequestException(`Event "${slug}" already exists.`);
+    }
+  }
+
+  private normalize(data: any, partial = false) {
+    const normalized: Record<string, any> = {};
+    const assign = (key: string, value: any) => {
+      if (!partial || value !== undefined) {
+        normalized[key] = value;
+      }
+    };
+
+    assign('slug', String(data.slug ?? '').trim());
+    assign('name', String(data.name ?? '').trim());
+    assign('module', String(data.module ?? '').trim());
+    assign(
+      'description',
+      data.description === undefined || data.description === null
+        ? partial
+          ? undefined
+          : null
+        : String(data.description).trim() || null,
+    );
+    assign('status', data.status === 'inactive' ? 'inactive' : 'active');
+
+    return normalized;
+  }
+}
+