@hed-hog/core 0.0.349 → 0.0.351

package/src/notification/dto/create-notification.dto.ts

@@ -0,0 +1,71 @@
+import {
+  IsBoolean,
+  IsDateString,
+  IsEnum,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  Max,
+  Min,
+} from 'class-validator';
+
+export enum NotificationType {
+  Info = 'info',
+  Success = 'success',
+  Warning = 'warning',
+  Error = 'error',
+  Progress = 'progress',
+}
+
+export enum NotificationActionType {
+  Url = 'url',
+  Sheet = 'sheet',
+  Modal = 'modal',
+}
+
+export class CreateNotificationDto {
+  @IsNumber()
+  user_id: number;
+
+  @IsString()
+  title: string;
+
+  @IsOptional()
+  @IsString()
+  body?: string;
+
+  @IsOptional()
+  @IsString()
+  icon?: string;
+
+  @IsOptional()
+  @IsEnum(NotificationType)
+  type?: NotificationType;
+
+  @IsOptional()
+  @IsEnum(NotificationActionType)
+  action_type?: NotificationActionType;
+
+  @IsOptional()
+  @IsObject()
+  action_data?: Record<string, unknown>;
+
+  @IsOptional()
+  @IsString()
+  action_url?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  auto_remove?: boolean;
+
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  @Max(100)
+  progress?: number;
+
+  @IsOptional()
+  @IsDateString()
+  started_at?: string;
+}

package/src/notification/dto/update-progress.dto.ts

@@ -0,0 +1,16 @@
+import { IsBoolean, IsNumber, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class UpdateProgressDto {
+  @IsNumber()
+  @Min(0)
+  @Max(100)
+  progress: number;
+
+  @IsOptional()
+  @IsString()
+  body?: string;
+
+  @IsOptional()
+  @IsBoolean()
+  success?: boolean;
+}

package/src/notification/notification.controller.ts

@@ -0,0 +1,83 @@
+import { Role, User } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Req,
+    Res,
+} from '@nestjs/common';
+import type { Request, Response } from 'express';
+import { CreateNotificationDto } from './dto/create-notification.dto';
+import { UpdateProgressDto } from './dto/update-progress.dto';
+import { NotificationService } from './notification.service';
+
+@Role()
+@Controller('notification')
+export class NotificationController {
+  constructor(private readonly notificationService: NotificationService) {}
+
+  @Get()
+  async list(@User() { id }, @Pagination() paginationParams) {
+    return this.notificationService.list(id, paginationParams);
+  }
+
+  @Get('stream')
+  async stream(
+    @User() { id },
+    @Req() req: Request,
+    @Res() res: Response,
+  ) {
+    return this.notificationService.stream(id, req, res);
+  }
+
+  @Get('unread-count')
+  async unreadCount(@User() { id }) {
+    return this.notificationService.unreadCount(id);
+  }
+
+  @Patch('read-all')
+  async markAllRead(@User() { id }) {
+    return this.notificationService.markAllRead(id);
+  }
+
+  @Patch(':id/read')
+  async markRead(
+    @User() { id: userId },
+    @Param('id', ParseIntPipe) id: number,
+  ) {
+    return this.notificationService.markRead(userId, id);
+  }
+
+  @Patch(':id/progress')
+  async updateProgress(
+    @User() { id: userId },
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateProgressDto,
+  ) {
+    return this.notificationService.updateProgress(userId, id, dto);
+  }
+
+  @Delete()
+  async deleteAll(@User() { id }) {
+    return this.notificationService.deleteAll(id);
+  }
+
+  @Delete(':id')
+  async delete(
+    @User() { id: userId },
+    @Param('id', ParseIntPipe) id: number,
+  ) {
+    return this.notificationService.delete(userId, id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateNotificationDto) {
+    return this.notificationService.create(data);
+  }
+}

package/src/notification/notification.module.ts

@@ -0,0 +1,16 @@
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { NotificationController } from './notification.controller';
+import { NotificationService } from './notification.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+  controllers: [NotificationController],
+  providers: [NotificationService],
+  exports: [NotificationService],
+})
+export class NotificationModule {}

package/src/notification/notification.service.ts

@@ -0,0 +1,324 @@
+import { PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  ForbiddenException,
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
+  OnModuleDestroy,
+  OnModuleInit,
+} from '@nestjs/common';
+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';
+
+type NotificationStreamEventType =
+  | 'ready'
+  | 'notification.created'
+  | 'notification.updated';
+
+type NotificationStreamEvent = {
+  type: NotificationStreamEventType;
+  notificationId?: number;
+  notification?: unknown;
+};
+
+type ClusterNotificationPayload = NotificationStreamEvent & {
+  userId: number;
+  originInstanceId: string;
+};
+
+@Injectable()
+export class NotificationService implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(NotificationService.name);
+  private readonly notificationEvents = new EventEmitter();
+  private readonly instanceId = randomUUID();
+  private readonly channelName = 'notification_events';
+  private pgClient: Client | null = null;
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly pagination: PaginationService,
+  ) {
+    this.notificationEvents.setMaxListeners(0);
+  }
+
+  async onModuleInit() {
+    const databaseUrl = String(process.env.DATABASE_URL || '');
+    if (!databaseUrl.startsWith('postgresql://')) {
+      this.logger.warn(
+        'Cluster notification stream disabled because DATABASE_URL is not PostgreSQL',
+      );
+      return;
+    }
+
+    this.pgClient = new Client({ connectionString: databaseUrl });
+    this.pgClient.on('notification', (message: PgNotification) => {
+      this.handleClusterNotification(message);
+    });
+    this.pgClient.on('error', (error) => {
+      this.logger.error('Cluster notification listener error', error);
+    });
+
+    await this.pgClient.connect();
+    await this.pgClient.query(`LISTEN ${this.channelName}`);
+    this.logger.log(
+      `Cluster notification listener ready on channel ${this.channelName}`,
+    );
+  }
+
+  async onModuleDestroy() {
+    if (!this.pgClient) {
+      return;
+    }
+
+    try {
+      await this.pgClient.query(`UNLISTEN ${this.channelName}`);
+    } catch (error) {
+      this.logger.warn('Failed to unlisten notification channel', error as any);
+    }
+
+    try {
+      await this.pgClient.end();
+    } finally {
+      this.pgClient = null;
+    }
+  }
+
+  async list(userId: number, paginationParams: any) {
+    return this.pagination.paginate(
+      this.prisma.notification,
+      paginationParams,
+      {
+        where: { user_id: userId },
+        orderBy: { created_at: 'desc' },
+      },
+    );
+  }
+
+  async unreadCount(userId: number) {
+    const count = await this.prisma.notification.count({
+      where: { user_id: userId, status: 'unread' },
+    });
+    return { count };
+  }
+
+  async markRead(userId: number, id: number) {
+    const notification = await this.assertOwnership(userId, id);
+    if (notification.auto_remove) {
+      const deleted = await this.prisma.notification.delete({ where: { id } });
+      await this.broadcastNotificationEvent(userId, {
+        type: 'notification.updated',
+        notificationId: id,
+      });
+      return deleted;
+    }
+    const updated = await this.prisma.notification.update({
+      where: { id },
+      data: { status: 'read' },
+    });
+    await this.broadcastNotificationEvent(userId, {
+      type: 'notification.updated',
+      notificationId: id,
+    });
+    return updated;
+  }
+
+  async markAllRead(userId: number) {
+    await this.prisma.notification.deleteMany({
+      where: { user_id: userId, status: 'unread', auto_remove: true },
+    });
+    const updated = await this.prisma.notification.updateMany({
+      where: { user_id: userId, status: 'unread' },
+      data: { status: 'read' },
+    });
+    await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
+    return updated;
+  }
+
+  async delete(userId: number, id: number) {
+    await this.assertOwnership(userId, id);
+    const deleted = await this.prisma.notification.delete({ where: { id } });
+    await this.broadcastNotificationEvent(userId, {
+      type: 'notification.updated',
+      notificationId: id,
+    });
+    return deleted;
+  }
+
+  async deleteAll(userId: number) {
+    const result = await this.prisma.notification.deleteMany({
+      where: { user_id: userId },
+    });
+    await this.broadcastNotificationEvent(userId, { type: 'notification.updated' });
+    return result;
+  }
+
+  async create(data: CreateNotificationDto) {
+    const notification = await this.prisma.notification.create({
+      data: {
+        user_id: data.user_id,
+        title: data.title,
+        body: data.body,
+        icon: data.icon,
+        type: (data.type as any) ?? 'info',
+        action_type: (data.action_type as any) ?? 'url',
+        action_data: data.action_data as any,
+        action_url: data.action_url,
+        auto_remove: data.auto_remove ?? false,
+        progress: data.progress,
+        started_at: data.started_at ? new Date(data.started_at) : undefined,
+      },
+    });
+    await this.broadcastNotificationEvent(data.user_id, {
+      type: 'notification.created',
+      notificationId: notification.id,
+      notification,
+    });
+    return notification;
+  }
+
+  async updateProgress(userId: number, id: number, dto: UpdateProgressDto) {
+    await this.assertOwnership(userId, id);
+    const finished = dto.progress >= 100;
+    const notification = await this.prisma.notification.update({
+      where: { id },
+      data: {
+        progress: dto.progress,
+        body: dto.body,
+        type: finished ? (dto.success === false ? 'error' : 'success') as any : undefined,
+        finished_at: finished ? new Date() : undefined,
+      },
+    });
+    await this.broadcastNotificationEvent(userId, {
+      type: 'notification.updated',
+      notificationId: id,
+      notification,
+    });
+    return notification;
+  }
+
+  stream(userId: number, req: Request, res: Response) {
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+
+    const writeEvent = (event: NotificationStreamEvent) => {
+      if (res.writableEnded) {
+        return;
+      }
+
+      res.write(`event: ${event.type}\n`);
+      res.write(`data: ${JSON.stringify(event)}\n\n`);
+    };
+
+    const eventKey = this.getEventKey(userId);
+    const handler = (event: NotificationStreamEvent) => {
+      writeEvent(event);
+    };
+
+    this.notificationEvents.on(eventKey, handler);
+    writeEvent({ type: 'ready' });
+
+    const heartbeat = setInterval(() => {
+      if (!res.writableEnded) {
+        res.write(': ping\n\n');
+      }
+    }, 25000);
+
+    const cleanup = () => {
+      clearInterval(heartbeat);
+      this.notificationEvents.off(eventKey, handler);
+    };
+
+    req.on('close', cleanup);
+    res.on('close', cleanup);
+  }
+
+  async clearOldNotifications(retentionDays: number, batchLimit: number) {
+    return this.prisma.$executeRawUnsafe(
+      `WITH del AS (
+         SELECT id FROM notification
+         WHERE created_at < NOW() - INTERVAL '${retentionDays} days'
+         ORDER BY id
+         LIMIT ${batchLimit}
+       )
+       DELETE FROM notification n
+       USING del WHERE n.id = del.id`,
+    );
+  }
+
+  private async assertOwnership(userId: number, id: number) {
+    const notification = await this.prisma.notification.findUnique({
+      where: { id },
+      select: { user_id: true, auto_remove: true },
+    });
+    if (!notification) throw new NotFoundException();
+    if (notification.user_id !== userId) throw new ForbiddenException();
+    return notification;
+  }
+
+  private async broadcastNotificationEvent(
+    userId: number,
+    event: NotificationStreamEvent,
+  ) {
+    this.emitLocalNotificationEvent(userId, event);
+
+    const payload: ClusterNotificationPayload = {
+      ...event,
+      userId,
+      originInstanceId: this.instanceId,
+    };
+
+    try {
+      await this.prisma.$executeRaw`
+        SELECT pg_notify(${this.channelName}, ${JSON.stringify(payload)})
+      `;
+    } catch (error) {
+      this.logger.warn('Failed to broadcast notification event', error as any);
+    }
+  }
+
+  private getEventKey(userId: number) {
+    return `notification:${userId}`;
+  }
+
+  private emitLocalNotificationEvent(
+    userId: number,
+    event: NotificationStreamEvent,
+  ) {
+    this.notificationEvents.emit(this.getEventKey(userId), event);
+  }
+
+  private handleClusterNotification(message: PgNotification) {
+    if (message.channel !== this.channelName || !message.payload) {
+      return;
+    }
+
+    let payload: ClusterNotificationPayload;
+    try {
+      payload = JSON.parse(message.payload) as ClusterNotificationPayload;
+    } catch {
+      return;
+    }
+
+    if (!payload || payload.originInstanceId === this.instanceId) {
+      return;
+    }
+
+    this.emitLocalNotificationEvent(payload.userId, {
+      type: payload.type,
+      notificationId: payload.notificationId,
+      notification: payload.notification,
+    });
+  }
+}

package/src/pdf/pdf.service.ts

@@ -182,7 +182,7 @@ export class PdfService {
 
       if (missingRuntime) {
         throw new InternalServerErrorException(
-          'Playwright runtime is not available. Run `npx playwright install chromium` in apps/api.',
+          'Playwright runtime is not available. Run `pnpm --filter api run playwright:install` in the API environment.',
         );
       }
 

package/src/profile/profile.controller.ts

@@ -81,7 +81,7 @@ export class ProfileController {
 
   @Post('mfa/email/verify/confirm')
   sendEmailVerificationMfaConfirm(@User() {id}, @Body() data: EmailVerificationDto, @Locale() locale: string) {
-    console.log('sendEmailVerificationMfaConfirm')
+    
     return this.profileService.confirmEmailVerificationMfa(locale, id, data);
   }
   

package/src/profile/profile.module.ts

@@ -17,5 +17,6 @@ import { ProfileService } from './profile.service';
   ],
   controllers: [ProfileController],
   providers: [ProfileService],
+  exports: [ProfileService],
 })
 export class ProfileModule {}

package/src/setting/dto/update-setting-list.dto.ts

@@ -0,0 +1,32 @@
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsInt,
+  IsOptional,
+  IsString,
+  Length,
+  ValidateNested,
+} from 'class-validator';
+
+export class UpdateSettingListItemDTO {
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  id?: number;
+
+  @IsString()
+  @Length(1, 255)
+  value: string;
+
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  order?: number;
+}
+
+export class UpdateSettingListDTO {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => UpdateSettingListItemDTO)
+  options: UpdateSettingListItemDTO[];
+}

package/src/setting/setting.controller.ts

@@ -27,6 +27,7 @@ import { DeleteDTO } from './dto/delete.dto';
 import { ExportDto } from './dto/export.dto';
 import { SettingUserDTO } from './dto/setting-user.dto';
 import { SettingDTO } from './dto/setting.dto';
+import { UpdateSettingListDTO } from './dto/update-setting-list.dto';
 import { UpdateDTO } from './dto/update.dto';
 import { SettingService } from './setting.service';
 
@@ -124,6 +125,14 @@ export class SettingsController {
     return this.settingService.updateFromSlug(slug, data);
   }
 
+  @Put(':settingId/options')
+  async updateSettingListOptions(
+    @Param('settingId', ParseIntPipe) settingId: number,
+    @Body() data: UpdateSettingListDTO,
+  ) {
+    return this.settingService.updateSettingListOptions(settingId, data);
+  }
+
   @Put()
   async setManySettings(@Body() data: SettingDTO) {
     return this.settingService.setManySettings(data);