@hed-hog/core 0.0.367 → 0.0.368

package/hedhog/frontend/app/users/user-logs.tsx.ejs

@@ -0,0 +1,190 @@
+'use client';
+
+import { EmptyState } from '@/components/entity-list';
+import { formatDateTime } from '@/lib/format-date';
+import { User } from '@hed-hog/api-types';
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import {
+  Image as ImageIcon,
+  KeyRound,
+  Loader2,
+  Pencil,
+  ScrollText,
+  ShieldMinus,
+  ShieldPlus,
+} from 'lucide-react';
+import { useTranslations } from 'next-intl';
+
+type UserChangeLog = {
+  id: string;
+  actorUserId: string | null;
+  actorName: string | null;
+  actorEmail: string | null;
+  action: string;
+  summary: string;
+  beforeData: string;
+  afterData: string;
+  ipAddress: string;
+  createdAt: string | null;
+};
+
+function getActionIcon(action: string) {
+  switch (action) {
+    case 'update':
+      return Pencil;
+    case 'reset_password':
+      return KeyRound;
+    case 'role_assigned':
+      return ShieldPlus;
+    case 'role_removed':
+      return ShieldMinus;
+    case 'avatar_changed':
+      return ImageIcon;
+    default:
+      return ScrollText;
+  }
+}
+
+function safeParse(raw: string): Record<string, unknown> | null {
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function formatValue(value: unknown) {
+  if (value === null || value === undefined || value === '') return '—';
+  return String(value);
+}
+
+function DiffList({ before, after }: { before: string; after: string }) {
+  const beforeObj = safeParse(before);
+  const afterObj = safeParse(after);
+
+  if (!beforeObj && !afterObj) return null;
+
+  const keys = Array.from(
+    new Set([
+      ...Object.keys(beforeObj ?? {}),
+      ...Object.keys(afterObj ?? {}),
+    ]),
+  );
+
+  if (!keys.length) return null;
+
+  return (
+    <div className="mt-2 space-y-1 rounded-md bg-muted/40 p-2">
+      {keys.map((key) => (
+        <div key={key} className="flex flex-wrap items-center gap-1 text-[11px]">
+          <span className="font-medium text-muted-foreground">{key}:</span>
+          {beforeObj && key in beforeObj && (
+            <span className="rounded bg-rose-50 px-1 py-0.5 text-rose-700 line-through">
+              {formatValue(beforeObj[key])}
+            </span>
+          )}
+          {afterObj && key in afterObj && (
+            <span className="rounded bg-emerald-50 px-1 py-0.5 text-emerald-700">
+              {formatValue(afterObj[key])}
+            </span>
+          )}
+        </div>
+      ))}
+    </div>
+  );
+}
+
+export function UserLogs({ editingUser }: { editingUser: User }) {
+  const { request, currentLocaleCode, getSettingValue } = useApp();
+  const t = useTranslations('core.UserChangeLog');
+  const userId = editingUser?.id;
+
+  const { data: logs = [], isLoading } = useQuery<UserChangeLog[]>({
+    queryKey: ['user-change-logs', userId, currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<{ data: UserChangeLog[] }>({
+        url: `/user/${userId}/log`,
+        method: 'GET',
+      });
+      return response.data?.data || [];
+    },
+    enabled: !!userId,
+  });
+
+  const knownActions = [
+    'update',
+    'reset_password',
+    'role_assigned',
+    'role_removed',
+    'avatar_changed',
+  ];
+  const getActionLabel = (action: string) =>
+    knownActions.includes(action) ? t(action as never) : action;
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center py-8 text-muted-foreground">
+        <Loader2 className="h-5 w-5 animate-spin" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-3">
+      <h4 className="text-sm font-medium">{t('title')}</h4>
+
+      <div className="space-y-2">
+        {logs.length ? (
+          logs.map((log) => {
+            const Icon = getActionIcon(log.action);
+            const actor =
+              log.actorName || log.actorEmail || t('systemActor');
+
+            return (
+              <div key={log.id} className="rounded-lg border p-3">
+                <div className="flex items-start gap-3">
+                  <div className="rounded-md bg-slate-50 p-2">
+                    <Icon className="h-5 w-5 text-muted-foreground" />
+                  </div>
+                  <div className="flex-1">
+                    <div className="flex flex-wrap items-center justify-between gap-2">
+                      <p className="text-sm font-medium">
+                        {getActionLabel(log.action)}
+                      </p>
+                      {log.createdAt && (
+                        <span className="text-[11px] text-muted-foreground">
+                          {formatDateTime(
+                            log.createdAt,
+                            getSettingValue,
+                            currentLocaleCode,
+                          )}
+                        </span>
+                      )}
+                    </div>
+                    <p className="text-xs text-muted-foreground">
+                      {t('byActor')} {actor}
+                    </p>
+                    {log.summary && (
+                      <p className="mt-1 text-xs text-muted-foreground">
+                        {log.summary}
+                      </p>
+                    )}
+                    <DiffList before={log.beforeData} after={log.afterData} />
+                  </div>
+                </div>
+              </div>
+            );
+          })
+        ) : (
+          <EmptyState
+            icon={<ScrollText className="h-6 w-6" />}
+            title={t('emptyTitle')}
+            description={t('emptyDescription')}
+          />
+        )}
+      </div>
+    </div>
+  );
+}

package/hedhog/frontend/app/users/user-sheet.tsx.ejs

@@ -66,6 +66,7 @@ import {
   LucideIcon,
   Mail,
   Monitor,
+  ScrollText,
   RefreshCcw,
   Save,
   Shield,
@@ -84,6 +85,7 @@ import { z } from 'zod';
 import { ActiveSessions } from './active-session';
 import { UserIdentifiersSection } from './identifiers';
 import { PermissionsSection } from './permissions';
+import { UserLogs } from './user-logs';
 
 export type UserSheetProps = {
   open: boolean;
@@ -765,6 +767,10 @@ function UserEditSheet({
                 <Monitor className="h-4 w-4" />
                 <span>{t('tabSessions')}</span>
               </TabsTrigger>
+              <TabsTrigger value="logs">
+                <ScrollText className="h-4 w-4" />
+                <span>{t('tabLogs')}</span>
+              </TabsTrigger>
             </TabsList>
           </div>
 
@@ -1110,7 +1116,10 @@ function UserEditSheet({
                 <FormActions
                   statusContent={editDraftStatusContent}
                   cancelLabel={t('cancel')}
-                  onCancel={() => onOpenChange(false)}
+                  onCancel={() => {
+                    clearEditDraft();
+                    onOpenChange(false);
+                  }}
                   submitLabel={t('saveChanges')}
                   submitType="submit"
                   className="pt-2"
@@ -1478,6 +1487,11 @@ function UserEditSheet({
               refetch={handleRefreshUser}
             />
           </TabsContent>
+
+          {/* Logs Tab */}
+          <TabsContent value="logs" className="space-y-4 mt-4 p-4 pt-0">
+            <UserLogs editingUser={editingUser} />
+          </TabsContent>
         </Tabs>
       </ResizableSheetContent>
     </Sheet>

package/hedhog/frontend/messages/en.json

@@ -244,6 +244,7 @@
     "tabIdentifiers": "Identifiers",
     "tabMfa": "MFA",
     "tabSessions": "Sessions",
+    "tabLogs": "Logs",
     "cardLastLoginDescription": "Last Login",
     "cardLastLoginTitle": "Never",
     "securityTitle": "Security Overview",
@@ -944,6 +945,18 @@
     "revokeAllSuccess": "Sessions revoked successfully!",
     "revokeAllFailure": "Failed to revoke sessions"
   },
+  "UserChangeLog": {
+    "title": "Change History",
+    "byActor": "by",
+    "systemActor": "System",
+    "update": "Profile updated",
+    "reset_password": "Password reset",
+    "role_assigned": "Role assigned",
+    "role_removed": "Role removed",
+    "avatar_changed": "Avatar changed",
+    "emptyTitle": "No changes recorded",
+    "emptyDescription": "Administrative changes made to this user will appear here."
+  },
   "UserActiveSessions": {
     "title": "Active Sessions",
     "revokeAll": "Revoke All",

package/hedhog/frontend/messages/pt.json

@@ -244,6 +244,7 @@
     "tabIdentifiers": "Identificadores",
     "tabMfa": "MFA",
     "tabSessions": "Sessões",
+    "tabLogs": "Logs",
     "cardLastLoginDescription": "Último login",
     "cardLastLoginTitle": "Nunca",
     "securityTitle": "Visão Geral de Segurança",
@@ -944,6 +945,18 @@
     "revokeAllSuccess": "Sessões revogadas com sucesso!",
     "revokeAllFailure": "Falha ao revogar sessões"
   },
+  "UserChangeLog": {
+    "title": "Histórico de Alterações",
+    "byActor": "por",
+    "systemActor": "Sistema",
+    "update": "Perfil atualizado",
+    "reset_password": "Senha redefinida",
+    "role_assigned": "Papel atribuído",
+    "role_removed": "Papel removido",
+    "avatar_changed": "Avatar alterado",
+    "emptyTitle": "Nenhuma alteração registrada",
+    "emptyDescription": "As alterações administrativas feitas neste usuário aparecerão aqui."
+  },
   "UserActiveSessions": {
     "title": "Sessões Ativas",
     "revokeAll": "Revogar Todas",

package/hedhog/table/user_change_log.yaml

@@ -0,0 +1,40 @@
+columns:
+  - type: pk
+  - name: target_user_id
+    type: fk
+    references:
+      table: user
+      column: id
+      onDelete: CASCADE
+      onUpdate: CASCADE
+  - name: actor_user_id
+    type: fk
+    isNullable: true
+    references:
+      table: user
+      column: id
+      onDelete: SET NULL
+      onUpdate: CASCADE
+  - name: action
+    type: varchar
+    length: 80
+  - name: summary
+    type: text
+    isNullable: true
+  - name: before_data
+    type: text
+    isNullable: true
+  - name: after_data
+    type: text
+    isNullable: true
+  - name: ip_address
+    type: varchar
+    length: 64
+    isNullable: true
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [target_user_id]
+  - columns: [actor_user_id]
+  - columns: [action]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/core",
-  "version": "0.0.367",
+  "version": "0.0.368",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -38,12 +38,12 @@
     "speakeasy": "^2.0.0",
     "ua-parser-js": "^2.0.10",
     "uuid": "^11.1.0",
-    "@hed-hog/api-locale": "0.0.14",
     "@hed-hog/api": "0.0.8",
-    "@hed-hog/api-prisma": "0.0.6",
-    "@hed-hog/api-mail": "0.0.9",
+    "@hed-hog/api-locale": "0.0.14",
     "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/api-types": "0.0.1"
+    "@hed-hog/api-mail": "0.0.9",
+    "@hed-hog/api-types": "0.0.1",
+    "@hed-hog/api-prisma": "0.0.6"
   },
   "exports": {
     ".": {

package/src/file/file.service.ts

@@ -490,6 +490,7 @@ export class FileService implements OnModuleInit {
       mimetype?: string;
       size?: number;
       encoding?: string;
+      skipMimeValidation?: boolean;
     },
   ) {
     if (!filePath) {
@@ -511,7 +512,7 @@ export class FileService implements OnModuleInit {
       metadata?.originalname ?? metadata?.filename ?? basename(filePath),
     );
 
-    if (!(await this.acceptMimetypes(mimetype))) {
+    if (!metadata?.skipMimeValidation && !(await this.acceptMimetypes(mimetype))) {
       throw new BadRequestException(`Invalid file type: ${mimetype}`);
     }
 

package/src/notification/events/notification-stale-progress-check.event.ts

@@ -0,0 +1,5 @@
+export const NOTIFICATION_STALE_PROGRESS_CHECK = 'notification.stale-progress-check';
+
+export class NotificationStaleProgressCheckEvent {
+  constructor(public readonly userId: number) {}
+}

package/src/notification/notification.service.ts

@@ -11,12 +11,17 @@ import {
     OnModuleDestroy,
     OnModuleInit,
 } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import type { Request, Response } from 'express';
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
 import { Client, type Notification as PgNotification } from 'pg';
 import { CreateNotificationDto } from './dto/create-notification.dto';
 import { UpdateProgressDto } from './dto/update-progress.dto';
+import {
+    NOTIFICATION_STALE_PROGRESS_CHECK,
+    NotificationStaleProgressCheckEvent,
+} from './events/notification-stale-progress-check.event';
 
 type NotificationStreamEventType =
   | 'ready'
@@ -47,6 +52,7 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
     private readonly prisma: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly pagination: PaginationService,
+    private readonly eventEmitter: EventEmitter2,
   ) {
     this.notificationEvents.setMaxListeners(0);
   }
@@ -106,32 +112,13 @@ export class NotificationService implements OnModuleInit, OnModuleDestroy {
   }
 
   private async cleanupStaleProgressNotifications(userId: number) {
-    const stale = await this.prisma.$queryRaw<{ id: number }[]>`
-      SELECT n.id
-      FROM notification n
-      WHERE n.user_id = ${userId}
-        AND n.progress IS NOT NULL
-        AND n.progress < 100
-        AND n.finished_at IS NULL
-        AND (n.action_data->>'queueJobId') IS NOT NULL
-        AND NOT EXISTS (
-          SELECT 1 FROM queue_job qj
-          WHERE qj.id = (n.action_data->>'queueJobId')::int
-        )
-    `;
-
-    if (!stale.length) return;
-
-    await this.prisma.notification.updateMany({
-      where: { id: { in: stale.map((n) => n.id) } },
-      data: {
-        progress: 100,
-        type: 'error' as any,
-        body: 'O processamento foi interrompido (job não encontrado).',
-        finished_at: new Date(),
-      },
-    });
+    await this.eventEmitter.emitAsync(
+      NOTIFICATION_STALE_PROGRESS_CHECK,
+      new NotificationStaleProgressCheckEvent(userId),
+    );
+  }
 
+  async notifyUpdated(userId: number) {
     await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
   }
 

package/src/task/task.service.ts

@@ -42,6 +42,9 @@ export class TasksService {
     await this.clearOldNotifications();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
+    await this.clearStaleAsyncNotifications();
+    this.logger.verbose('++++++++++++++++++++++++++++++++++');
+
     await this.clearOldAccessLogs();
     this.logger.verbose('++++++++++++++++++++++++++++++++++');
 
@@ -322,4 +325,53 @@ export class TasksService {
       `Old notifications cleaned up in ${Date.now() - startAt}ms`,
     );
   }
+
+  /**
+   * Remove notificações assíncronas que ficaram "travadas" em andamento por tempo demais.
+   *
+   * Uma notificação assíncrona está em andamento quando possui acompanhamento de progresso
+   * (progress IS NOT NULL) que ainda não chegou ao fim (progress < 100) e que nunca foi
+   * finalizada (finished_at IS NULL). Se o job que a alimenta morre ou trava, a notificação
+   * permanece eternamente "rodando".
+   *
+   * Remove registros da tabela notification que:
+   * - Estão em andamento (progress IS NOT NULL AND progress < 100 AND finished_at IS NULL)
+   * - Começaram a rodar há mais horas do que o valor de stale-async-notification-hours,
+   *   medido por COALESCE(started_at, created_at)
+   *
+   * Por quê: notificações assíncronas presas poluem a interface (barra de progresso eterna)
+   * e o banco. A remoção periódica baseada em tempo as descarta de forma previsível.
+   *
+   * Limite: cleanup-batch-limit registros por execução para evitar lock prolongado da tabela.
+   */
+  private async clearStaleAsyncNotifications(): Promise<void> {
+    const settings = await this.settingService.getSettingValues([
+      'cleanup-batch-limit',
+      'stale-async-notification-hours',
+    ]);
+    const batchLimit = Number(settings['cleanup-batch-limit']) || 20000;
+    const staleHours = Number(settings['stale-async-notification-hours']) || 24;
+    this.logger.verbose('Starting cleanup of stale async notifications');
+    const startAt = Date.now();
+
+    await this.prismaService.$executeRaw`
+      WITH del AS (
+        SELECT id
+        FROM notification
+        WHERE progress IS NOT NULL
+          AND progress < 100
+          AND finished_at IS NULL
+          AND COALESCE(started_at, created_at) < (now() - ${Prisma.sql`INTERVAL '${Prisma.raw(String(staleHours))} hours'`})
+        ORDER BY id
+        LIMIT ${batchLimit}
+      )
+      DELETE FROM notification n
+      USING del
+      WHERE n.id = del.id
+    `;
+
+    this.logger.verbose(
+      `Stale async notifications cleaned up in ${Date.now() - startAt}ms`,
+    );
+  }
 }

package/src/user/user.controller.ts

@@ -1,4 +1,4 @@
-import { Public, Role } from '@hed-hog/api';
+import { Public, Role, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
@@ -64,9 +64,10 @@ export class UserController {
   async update(
     @Param('userId', ParseIntPipe) userId: number,
     @Body() data: UpdateDTO,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.update(locale, userId, data);
+    return this.userService.update(locale, userId, data, actor?.id);
   }
 
   @Patch(':userId/reset-password')
@@ -74,8 +75,9 @@ export class UserController {
     @Param('userId', ParseIntPipe) userId: number,
     @Body() data: ResetPasswordDTO,
     @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.resetPassword(locale, userId, data);
+    return this.userService.resetPassword(locale, userId, data, actor?.id);
   }
 
   @UseInterceptors(
@@ -93,8 +95,9 @@ export class UserController {
     @Locale() locale: string,
     @Param('userId', ParseIntPipe) userId: number,
     @UploadedFile() avatar: MulterFile,
+    @User() actor,
   ) {
-    return this.userService.changeAvatar(locale, userId, avatar)
+    return this.userService.changeAvatar(locale, userId, avatar, actor?.id)
   }
 
   @Post(':userId/verify-identifier/:identifierId')
@@ -132,21 +135,32 @@ export class UserController {
     return this.userService.getUserRoutes(locale, userId);
   }
 
+  @Get(':userId/log')
+  async listLogs(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Pagination() paginationParams,
+    @Locale() locale: string,
+  ) {
+    return this.userService.listUserChangeLogs(locale, userId, paginationParams);
+  }
+
   @Post(':userId/role/:roleId')
   async assignRoleToUser(
     @Param('userId', ParseIntPipe) userId: number,
     @Param('roleId', ParseIntPipe) roleId: number,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.assignRoleToUser(locale, userId, roleId);
+    return this.userService.assignRoleToUser(locale, userId, roleId, actor?.id);
   }
 
   @Delete(':userId/role/:roleId')
   async removeRoleFromUser(
     @Param('userId', ParseIntPipe) userId: number,
     @Param('roleId', ParseIntPipe) roleId: number,
-    @Locale() locale: string
+    @Locale() locale: string,
+    @User() actor,
   ) {
-    return this.userService.removeRoleFromUser(locale, userId, roleId);
+    return this.userService.removeRoleFromUser(locale, userId, roleId, actor?.id);
   }
 }