@hed-hog/core 0.0.387 → 0.0.393

package/src/user/user.service.ts

@@ -6,6 +6,7 @@ import {
     BadRequestException,
     Inject,
     Injectable,
+    Logger,
     NotFoundException,
     forwardRef,
 } from '@nestjs/common';
@@ -20,6 +21,10 @@ import { USER_AVATAR_UPLOAD_DESTINATION } from './constants/user.constants';
 import { CreateWithEmailAndPasswordDTO } from './dto/create-with-email-and-password.dto';
 import { ResetPasswordDTO } from './dto/reset-password.dto';
 import { UpdateDTO } from './dto/update.dto';
+import {
+  PENDING_PASSWORD_RESET_WHERE,
+  hasPendingPasswordReset,
+} from './user-credential.util';
 
 // Constants
 const IDENTIFIER_TYPE = {
@@ -54,8 +59,6 @@ const USER_SORT_FIELDS = [
   'updated_at',
 ] as const;
 
-const USER_SEARCH_FIELDS = ['name'] as const;
-
 type UserChangeLog = user_change_log;
 type UserChangeLogActor = Prisma.userGetPayload<{
   select: {
@@ -70,6 +73,8 @@ type UserChangeLogActor = Prisma.userGetPayload<{
 
 @Injectable()
 export class UserService {
+  private readonly logger = new Logger(UserService.name);
+
   constructor(
     @Inject(forwardRef(() => PrismaService))
     private readonly prismaService: PrismaService,
@@ -154,29 +159,79 @@ export class UserService {
   // CRUD Operations
   // ==========================================
 
-  async list(paginationParams) {
+  async list(paginationParams, filter?: string) {
     const paginate = await this.paginationService.paginatePrismaModel(
       this.prismaService.user,
       {
         ...paginationParams,
         validSortFields: USER_SORT_FIELDS,
-        searchFields: USER_SEARCH_FIELDS,
+        where: this.buildUserListWhere(filter, paginationParams?.search),
         include: this.getUserIncludeClause(),
       }
     );
 
     const stats = await this.getUserStatistics();
 
-    return { paginate, stats };
+    return {
+      paginate: {
+        ...paginate,
+        data: (paginate?.data ?? []).map((user: any) => ({
+          ...user,
+          requires_password_reset: hasPendingPasswordReset(user),
+          last_login_at: user?.user_activity?.[0]?.created_at ?? null,
+        })),
+      },
+      stats,
+    };
   }
 
   async get(locale: string, userId: number) {
-    return this.findUserById(locale, userId);
+    const user = await this.findUserById(locale, userId);
+
+    // Enriquecimento so aqui, e nao em `findUserById`: aquele metodo tambem
+    // serve `GET /auth/verify`, que roda a cada carga de pagina. Quem precisa
+    // dos nomes de operador/ator e a ficha do usuario no admin.
+    const [user_activity, user_session] = await Promise.all([
+      this.attachActivityActors((user as any).user_activity ?? []),
+      this.attachSessionImpersonators((user as any).user_session ?? []),
+    ]);
+
+    return { ...user, user_activity, user_session };
+  }
+
+  /** Ver `attachActivityActors`: mesma razao, aplicada a `user_session`. */
+  private async attachSessionImpersonators(sessions: any[]) {
+    const ids = [
+      ...new Set(
+        sessions
+          .map((session) => session.impersonator_user_id)
+          .filter((id): id is number => typeof id === 'number'),
+      ),
+    ];
+
+    const users = ids.length
+      ? await this.prismaService.user.findMany({
+          where: { id: { in: ids } },
+          select: { id: true, name: true },
+        })
+      : [];
+    const byId = new Map(users.map((user) => [user.id, user]));
+
+    return sessions.map((session: any) => ({
+      ...session,
+      impersonator:
+        typeof session.impersonator_user_id === 'number'
+          ? (byId.get(session.impersonator_user_id) ?? {
+              id: session.impersonator_user_id,
+              name: '',
+            })
+          : null,
+    }));
   }
 
   async createWithEmailAndPassword(
     locale: string,
-    { email, name, password }: CreateWithEmailAndPasswordDTO,
+    { email, name, password, app }: CreateWithEmailAndPasswordDTO,
   ) {
     await this.validateEmailAvailable(locale, email);
 
@@ -185,7 +240,7 @@ export class UserService {
     const user = await this.prismaService.$transaction(async (tx) => {
       const role = await this.getDefaultUserRole(locale, tx);
 
-      const user = await tx.user.create({
+      const created = await tx.user.create({
         data: {
           name,
           user_identifier: {
@@ -209,10 +264,25 @@ export class UserService {
         },
       });
 
-      return user;
+      return created;
+    }).catch((error: any) => {
+      if (error?.code === 'P2002') {
+        throw new BadRequestException(
+          getLocaleText('signup.emailExists', locale, 'Email already in use.')
+        );
+      }
+
+      throw error;
     });
 
-    const challenge = await this.challenge.verifyEmail(locale, user.id, email);
+    try {
+      await this.challenge.sendEmailConfirmationLink(locale, user.id, email, app);
+    } catch (error: any) {
+      this.logger.warn(
+        `Signup confirmation email failed for user ${user.id}: ${error?.message ?? error}`
+      );
+    }
+
     await this.registerUserActivity(user.id, 'register');
 
     await this.integrationApi.publishEvent({
@@ -223,7 +293,10 @@ export class UserService {
       payload: { id: user.id, name: user.name, email },
     }).catch(() => null);
 
-    return { user, challenge };
+    // `hasChallenge` não é decidido aqui: quem chama (AuthService.signupWithEmailAndPassword)
+    // é que sabe se `require-email-verification` está ligada e se o cadastro
+    // deve ou não já sair com uma sessão emitida.
+    return { user };
   }
 
   async update(
@@ -424,8 +497,14 @@ export class UserService {
       include: {
         user_identifier: true,
         user_credential: true,
-        user_activity: true,
+        user_activity: {
+          orderBy: { created_at: 'desc' },
+          take: 20,
+        },
         user_session: true,
+        // Os dispositivos NAO entram aqui: uma conta antiga acumula dezenas
+        // deles, e embutir a lista inteira pesaria em todo GET /user/:id. O
+        // sheet busca em GET /user-device/user/:userId, que e paginado.
         user_account: true,
          role_user: {
            include: {
@@ -640,7 +719,15 @@ export class UserService {
   // Activity Tracking
   // ==========================================
 
-  async registerUserActivity(userId: number | null | undefined, action: string) {
+  /**
+   * `actorUserId` marca quem provocou a atividade quando nao foi o proprio
+   * usuario — hoje, o operador de uma simulacao de acesso.
+   */
+  async registerUserActivity(
+    userId: number | null | undefined,
+    action: string,
+    actorUserId?: number | null,
+  ) {
     if (!userId || !Number.isInteger(userId) || userId <= 0) {
       return null;
     }
@@ -649,6 +736,7 @@ export class UserService {
       data: {
         user_id: userId,
         action,
+        actor_user_id: actorUserId ?? null,
       },
     });
   }
@@ -657,13 +745,18 @@ export class UserService {
   // Change Log (administrative audit trail)
   // ==========================================
 
-  private async recordUserChange(data: {
+  /**
+   * Publico porque a simulacao de acesso (ImpersonationService) tambem precisa
+   * gravar na mesma trilha administrativa, com o operador como ator.
+   */
+  async recordUserChange(data: {
     targetUserId: number;
     actorUserId?: number | null;
     action: string;
     summary?: string;
     beforeData?: unknown;
     afterData?: unknown;
+    ipAddress?: string | null;
   }) {
     return this.prismaService.user_change_log
       .create({
@@ -672,6 +765,7 @@ export class UserService {
           actor_user_id: data.actorUserId ?? null,
           action: data.action,
           summary: data.summary ?? null,
+          ip_address: data.ipAddress ?? null,
           before_data:
             data.beforeData === undefined
               ? null
@@ -749,6 +843,139 @@ export class UserService {
     };
   }
 
+  // ==========================================
+  // Sent Mails (delivery history per user)
+  // ==========================================
+
+  async listUserMails(
+    locale: string,
+    userId: number,
+    params: {
+      page?: number;
+      pageSize?: number;
+      search?: string;
+      sortField?: string;
+      sortOrder?: 'asc' | 'desc';
+      status?: 'all' | 'received' | 'read' | 'error';
+    },
+  ) {
+    await this.validateUserExists(locale, userId);
+
+    const identifiers = await this.prismaService.user_identifier.findMany({
+      where: { user_id: userId, type: IDENTIFIER_TYPE.EMAIL },
+      select: { value: true },
+    });
+
+    const emails = [
+      ...new Set(
+        identifiers
+          .map((identifier) => identifier.value?.trim().toLowerCase())
+          .filter((value): value is string => Boolean(value)),
+      ),
+    ];
+
+    // Tracked deliveries plus a fallback over the raw recipient fields, so
+    // mails sent before the tracking table existed still show up here.
+    const OR: any[] = [{ mail_sent_user: { some: { user_id: userId } } }];
+
+    for (const email of emails) {
+      OR.push({ to: { contains: email, mode: 'insensitive' } });
+      OR.push({ cc: { contains: email, mode: 'insensitive' } });
+      OR.push({ bcc: { contains: email, mode: 'insensitive' } });
+    }
+
+    const AND: any[] = [];
+
+    const status = params?.status;
+    if (status && status !== 'all') {
+      AND.push({ mail_sent_user: { some: { user_id: userId, status } } });
+    }
+
+    const search = params?.search?.trim();
+    if (search) {
+      AND.push({ subject: { contains: search, mode: 'insensitive' } });
+    }
+
+    const paginated = await this.paginationService.paginatePrismaModel(
+      this.prismaService.mail_sent,
+      {
+        page: params?.page,
+        pageSize: params?.pageSize,
+        sortField: params?.sortField || 'created_at',
+        sortOrder: params?.sortOrder || 'desc',
+        validSortFields: ['id', 'created_at', 'subject'],
+        where: {
+          OR,
+          ...(AND.length > 0 ? { AND } : {}),
+        },
+        include: {
+          mail: { select: { id: true, slug: true } },
+          mail_sent_user: {
+            where: { user_id: userId },
+            select: {
+              id: true,
+              recipient_email: true,
+              status: true,
+              read_at: true,
+              error_code: true,
+              error_message: true,
+            },
+          },
+        },
+      },
+    );
+
+    // `total` conta o mesmo universo da lista (rastreados + fallback), para o
+    // KPI não divergir da quantidade de itens exibidos. Os demais contadores só
+    // existem para envios rastreados.
+    const [totalMails, grouped] = await Promise.all([
+      this.prismaService.mail_sent.count({ where: { OR } }),
+      this.prismaService.mail_sent_user.groupBy({
+        by: ['status'],
+        where: { user_id: userId },
+        _count: { _all: true },
+      }),
+    ]);
+
+    const stats = grouped.reduce(
+      (acc, group) => {
+        const count = group._count?._all ?? 0;
+        if (group.status === 'received') acc.received += count;
+        if (group.status === 'read') acc.read += count;
+        if (group.status === 'error') acc.error += count;
+        return acc;
+      },
+      { total: totalMails, received: 0, read: 0, error: 0 },
+    );
+
+    return {
+      ...paginated,
+      stats,
+      data: (paginated.data || []).map((mailSent: any) => {
+        const tracking = mailSent.mail_sent_user?.[0] ?? null;
+
+        return {
+          id: mailSent.id,
+          mailId: mailSent.mail_id,
+          mailSlug: mailSent.mail?.slug ?? null,
+          subject: mailSent.subject,
+          from: mailSent.from,
+          to: mailSent.to,
+          cc: mailSent.cc,
+          bcc: mailSent.bcc,
+          body: mailSent.body,
+          createdAt: mailSent.created_at?.toISOString?.() || null,
+          tracked: Boolean(tracking),
+          recipientEmail: tracking?.recipient_email ?? null,
+          status: tracking?.status ?? null,
+          readAt: tracking?.read_at?.toISOString?.() || null,
+          errorCode: tracking?.error_code ?? null,
+          errorMessage: tracking?.error_message ?? null,
+        };
+      }),
+    };
+  }
+
   async listUserActivities(locale: string, userId: number, paginationParams) {
     await this.validateUserExists(locale, userId);
 
@@ -764,16 +991,57 @@ export class UserService {
       },
     );
 
+    const withActors = await this.attachActivityActors(paginated.data || []);
+
     return {
       ...paginated,
-      data: (paginated.data || []).map((activity: any) => ({
+      data: withActors.map((activity: any) => ({
         id: String(activity.id),
         action: activity.action,
         createdAt: activity.created_at?.toISOString?.() || null,
+        actor: activity.actor,
       })),
     };
   }
 
+  /**
+   * Anexa `actor` as atividades provocadas por outra pessoa (simulacao de
+   * acesso). `actor_user_id` e INT puro, sem FK — uma segunda FK para `user`
+   * renomearia a relacao `user.user_activity` no db pull —, entao o nome vem de
+   * uma consulta separada, como em `listUserChangeLogs`.
+   *
+   * Preserva os campos originais: a ficha do usuario embute `user_activity` cru
+   * e a linha do tempo do admin le `created_at`, nao `createdAt`.
+   */
+  async attachActivityActors(activities: any[]) {
+    const actorIds = [
+      ...new Set(
+        activities
+          .map((activity) => activity.actor_user_id)
+          .filter((id): id is number => typeof id === 'number'),
+      ),
+    ];
+
+    const actors = actorIds.length
+      ? await this.prismaService.user.findMany({
+          where: { id: { in: actorIds } },
+          select: { id: true, name: true },
+        })
+      : [];
+    const actorById = new Map(actors.map((actor) => [actor.id, actor]));
+
+    return activities.map((activity: any) => ({
+      ...activity,
+      actor:
+        typeof activity.actor_user_id === 'number'
+          ? (actorById.get(activity.actor_user_id) ?? {
+              id: activity.actor_user_id,
+              name: '',
+            })
+          : null,
+    }));
+  }
+
   // ==========================================
   // Private Helper Methods
   // ==========================================
@@ -859,10 +1127,74 @@ export class UserService {
     return passwordChars.slice(0, length).join('');
   }
 
+  private buildUserFilterWhere(filter?: string) {
+    switch (filter) {
+      case 'new':
+        return {
+          created_at: {
+            gte: new Date(Date.now() - NEW_USERS_PERIOD_DAYS * DAYS_IN_MS),
+          },
+        };
+      case 'blocked':
+        return { suspended_until: { gt: new Date() } };
+      case 'password-reset':
+        return { user_credential: PENDING_PASSWORD_RESET_WHERE };
+      default:
+        return {};
+    }
+  }
+
+  // O e-mail não é coluna de `user`: mora em `user_identifier`, junto de
+  // username, telefone e cpf. Por isso a busca é montada aqui, e não via
+  // `searchFields` da paginação, que só sabe filtrar colunas escalares.
+  private buildUserSearchWhere(search?: string) {
+    const term = typeof search === 'string' ? search.trim() : '';
+
+    if (!term) {
+      return null;
+    }
+
+    return {
+      OR: [
+        { name: { contains: term, mode: 'insensitive' as const } },
+        {
+          user_identifier: {
+            some: { value: { contains: term, mode: 'insensitive' as const } },
+          },
+        },
+      ],
+    };
+  }
+
+  private buildUserListWhere(filter?: string, search?: string) {
+    const filterWhere = this.buildUserFilterWhere(filter);
+    const searchWhere = this.buildUserSearchWhere(search);
+
+    if (!searchWhere) {
+      return filterWhere;
+    }
+
+    if (!Object.keys(filterWhere).length) {
+      return searchWhere;
+    }
+
+    return { AND: [filterWhere, searchWhere] };
+  }
+
   private getUserIncludeClause() {
     return {
       user_account: true,
-      user_credential: true,
+      user_credential: {
+        select: {
+          id: true,
+          type: true,
+          requires_reset: true,
+          revoked_at: true,
+          expires_at: true,
+          created_at: true,
+          updated_at: true,
+        },
+      },
       user_identifier: {
         where: { enabled: true },
       },
@@ -870,9 +1202,22 @@ export class UserService {
         where: { verified_at: { not: null } },
       },
       user_activity: {
+        where: { action: 'login' },
         orderBy: { created_at: 'desc' },
+        take: 1,
       },
       user_session: {
+        select: {
+          id: true,
+          user_id: true,
+          ip_address: true,
+          user_agent: true,
+          browser_id: true,
+          revoked_at: true,
+          expires_at: true,
+          created_at: true,
+          updated_at: true,
+        },
         where: {
           revoked_at: null,
           expires_at: { gt: new Date() },

package/src/user-device/user-device.controller.ts

@@ -0,0 +1,77 @@
+import { Role, User } from '@hed-hog/api';
+import { Pagination, PaginationDTO } from '@hed-hog/api-pagination';
+import {
+  Controller,
+  Delete,
+  Get,
+  Headers,
+  Param,
+  ParseIntPipe,
+} from '@nestjs/common';
+import { UserDeviceService } from './user-device.service';
+
+@Role()
+@Controller('user-device')
+export class UserDeviceController {
+  constructor(private readonly userDeviceService: UserDeviceService) {}
+
+  /**
+   * Dispositivos do proprio usuario autenticado.
+   *
+   * Os headers da requisicao entram para que o service saiba qual das linhas e
+   * o aparelho que esta perguntando (`current`) — sem eles a tela nao consegue
+   * distinguir "este dispositivo" dos outros, e o unico jeito de fazer isso no
+   * cliente seria expor a device_key.
+   */
+  @Get()
+  async list(
+    @Pagination() paginationParams: PaginationDTO,
+    @User() { id },
+    @Headers('user-agent') userAgent: string,
+    @Headers('x-browser-id') browserId: string,
+  ) {
+    return this.userDeviceService.list(paginationParams, id, {
+      userAgent: userAgent || null,
+      browserId: browserId || null,
+    });
+  }
+
+  /**
+   * Esquece um dispositivo do proprio usuario.
+   *
+   * O id do usuario vem do token, nunca da URL: e o que impede alguem de apagar
+   * o dispositivo de outra pessoa chutando o id.
+   */
+  @Delete(':deviceId')
+  async forget(
+    @User() { id },
+    @Param('deviceId', ParseIntPipe) deviceId: number,
+  ) {
+    return this.userDeviceService.forget(id, deviceId);
+  }
+
+  /**
+   * Dispositivos de outro usuario, para o sheet do admin. Restrita ao papel
+   * admin pela tabela `route` (ver hedhog/data/route.yaml) — o RoleGuard e quem
+   * barra; a rota em si nao checa papel.
+   */
+  @Get('user/:userId')
+  async listForUser(
+    @Pagination() paginationParams: PaginationDTO,
+    @Param('userId', ParseIntPipe) userId: number,
+  ) {
+    return this.userDeviceService.list(paginationParams, userId);
+  }
+
+  /**
+   * Esquece um dispositivo de outro usuario. Mesma restricao de papel da
+   * listagem acima.
+   */
+  @Delete('user/:userId/:deviceId')
+  async forgetForUser(
+    @Param('userId', ParseIntPipe) userId: number,
+    @Param('deviceId', ParseIntPipe) deviceId: number,
+  ) {
+    return this.userDeviceService.forget(userId, deviceId);
+  }
+}

package/src/user-device/user-device.module.ts

@@ -0,0 +1,13 @@
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { UserDeviceController } from './user-device.controller';
+import { UserDeviceService } from './user-device.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule), forwardRef(() => PaginationModule)],
+  controllers: [UserDeviceController],
+  providers: [UserDeviceService],
+  exports: [UserDeviceService],
+})
+export class UserDeviceModule {}