ar-saas 0.4.2 → 0.5.0

package/templates/backend/src/modules/invoices/invoices.controller.ts

@@ -0,0 +1,91 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import { CurrentUser } from '../../common/decorators/current-user.decorator';
+import type { TokenPayload } from '../../common/decorators/current-user.decorator';
+import { WorkspaceId } from '../../common/decorators/workspace-id.decorator';
+import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
+import { CreateInvoiceDto } from './dto/create-invoice.dto';
+import { QueryInvoiceDto } from './dto/query-invoice.dto';
+import { UpdateInvoiceDto } from './dto/update-invoice.dto';
+import { InvoicesService } from './invoices.service';
+
+@ApiTags('Invoices')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('invoices')
+export class InvoicesController {
+  constructor(private readonly invoicesService: InvoicesService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Listar facturas del workspace' })
+  @ApiResponse({ status: 200, description: 'Lista paginada de facturas' })
+  findAll(
+    @WorkspaceId() workspaceId: string,
+    @Query() query: QueryInvoiceDto,
+  ) {
+    return this.invoicesService.findAll(workspaceId, query);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Obtener una factura por ID' })
+  @ApiResponse({ status: 200, description: 'Factura encontrada' })
+  @ApiResponse({ status: 404, description: 'Factura no encontrada' })
+  findOne(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.invoicesService.findOne(workspaceId, id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Crear una nueva factura' })
+  @ApiResponse({ status: 201, description: 'Factura creada' })
+  create(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Body() dto: CreateInvoiceDto,
+  ) {
+    return this.invoicesService.create(workspaceId, user.userId, dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Actualizar una factura' })
+  @ApiResponse({ status: 200, description: 'Factura actualizada' })
+  @ApiResponse({ status: 404, description: 'Factura no encontrada' })
+  update(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+    @Body() dto: UpdateInvoiceDto,
+  ) {
+    return this.invoicesService.update(workspaceId, id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Eliminar una factura (soft delete)' })
+  @ApiResponse({ status: 204, description: 'Factura eliminada' })
+  @ApiResponse({ status: 404, description: 'Factura no encontrada' })
+  remove(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.invoicesService.remove(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/invoices/invoices.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ClientsModule } from '../clients/clients.module';
+import { Invoice, InvoiceSchema } from './schemas/invoice.schema';
+import { InvoicesController } from './invoices.controller';
+import { InvoicesRepository } from './invoices.repository';
+import { InvoicesService } from './invoices.service';
+
+@Module({
+  imports: [
+    ClientsModule,
+    MongooseModule.forFeature([{ name: Invoice.name, schema: InvoiceSchema }]),
+  ],
+  controllers: [InvoicesController],
+  providers: [InvoicesService, InvoicesRepository],
+  exports: [InvoicesService],
+})
+export class InvoicesModule {}

package/templates/backend/src/modules/invoices/invoices.repository.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BaseRepository } from '../../common/base/base.repository';
+import { Invoice, InvoiceDocument } from './schemas/invoice.schema';
+
+@Injectable()
+export class InvoicesRepository extends BaseRepository<InvoiceDocument> {
+  constructor(
+    @InjectModel(Invoice.name) private readonly invoiceModel: Model<InvoiceDocument>,
+  ) {
+    super(invoiceModel);
+  }
+}

package/templates/backend/src/modules/invoices/invoices.service.ts

@@ -0,0 +1,104 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { ClientsService } from '../clients/clients.service';
+import { CreateInvoiceDto } from './dto/create-invoice.dto';
+import { QueryInvoiceDto } from './dto/query-invoice.dto';
+import { UpdateInvoiceDto } from './dto/update-invoice.dto';
+import { InvoiceItem } from './schemas/invoice.schema';
+import { InvoicesRepository } from './invoices.repository';
+
+@Injectable()
+export class InvoicesService {
+  constructor(
+    private readonly invoicesRepository: InvoicesRepository,
+    private readonly clientsService: ClientsService,
+  ) {}
+
+  findAll(workspaceId: string, query: QueryInvoiceDto) {
+    const { page, limit, search, status, type, clientId } = query;
+    const filter: Record<string, unknown> = {};
+
+    if (status) filter.status = status;
+    if (type) filter.type = type;
+    if (clientId) filter.clientId = clientId;
+    if (search) {
+      filter.$or = [
+        { number: { $regex: search, $options: 'i' } },
+        { notes: { $regex: search, $options: 'i' } },
+      ];
+    }
+
+    return this.invoicesRepository.paginate(workspaceId, {
+      page,
+      limit,
+      filter,
+      sort: { createdAt: -1 },
+    });
+  }
+
+  async findOne(workspaceId: string, id: string) {
+    const invoice = await this.invoicesRepository.findById(workspaceId, id);
+    if (!invoice) throw new NotFoundException('Factura no encontrada');
+    return invoice;
+  }
+
+  async create(workspaceId: string, userId: string, dto: CreateInvoiceDto) {
+    if (dto.clientId) {
+      await this.clientsService.findOne(workspaceId, dto.clientId);
+    }
+
+    const items = dto.items ?? [];
+    const totals = items.length > 0
+      ? this.computeTotals(items, dto.taxRate ?? 0)
+      : { subtotal: dto.total ?? 0, taxAmount: 0, total: dto.total ?? 0 };
+
+    return this.invoicesRepository.create({
+      ...dto,
+      ...totals,
+      issueDate: dto.issueDate ? new Date(dto.issueDate) : new Date(),
+      dueDate: dto.dueDate ? new Date(dto.dueDate) : undefined,
+      workspaceId: workspaceId as unknown as import('mongoose').Types.ObjectId,
+      createdBy: userId as unknown as import('mongoose').Types.ObjectId,
+      deletedAt: null,
+    } as never);
+  }
+
+  async update(workspaceId: string, id: string, dto: UpdateInvoiceDto) {
+    const current = await this.findOne(workspaceId, id);
+    const clientId = dto.clientId ?? (current as unknown as { clientId: string }).clientId;
+
+    if (clientId) {
+      await this.clientsService.findOne(workspaceId, clientId);
+    }
+
+    const items = dto.items ?? (current as unknown as { items: InvoiceItem[] }).items ?? [];
+    const taxRate = dto.taxRate ?? (current as unknown as { taxRate: number }).taxRate ?? 0;
+    const extra: Record<string, unknown> = {};
+
+    if (items.length > 0) {
+      Object.assign(extra, this.computeTotals(items, taxRate));
+    } else if (dto.total !== undefined) {
+      extra.total = dto.total;
+      extra.subtotal = dto.total;
+      extra.taxAmount = 0;
+    }
+
+    const invoice = await this.invoicesRepository.update(workspaceId, id, { ...dto, ...extra } as never);
+    if (!invoice) throw new NotFoundException('Factura no encontrada');
+    return invoice;
+  }
+
+  async remove(workspaceId: string, id: string) {
+    await this.findOne(workspaceId, id);
+    await this.invoicesRepository.softDelete(workspaceId, id);
+  }
+
+  private computeTotals(
+    items: { amount: number }[],
+    taxRate: number,
+  ): { subtotal: number; taxAmount: number; total: number } {
+    const subtotal = items.reduce((sum, item) => sum + item.amount, 0);
+    const taxAmount = Math.round(subtotal * (taxRate / 100) * 100) / 100;
+    const total = subtotal + taxAmount;
+    return { subtotal, taxAmount, total };
+  }
+}

package/templates/backend/src/modules/invoices/schemas/invoice.schema.ts

@@ -0,0 +1,75 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type InvoiceDocument = HydratedDocument<Invoice>;
+
+export interface InvoiceItem {
+  description: string;
+  quantity: number;
+  unitPrice: number;
+  amount: number;
+}
+
+@Schema({ collection: 'invoices', timestamps: true })
+export class Invoice extends BaseSchema {
+  @Prop({ type: String, enum: ['income', 'expense'], default: 'income' })
+  type!: 'income' | 'expense';
+
+  @Prop({ trim: true })
+  number!: string;
+
+  @Prop()
+  clientId!: string;
+
+  @Prop({
+    type: String,
+    enum: ['draft', 'pending', 'paid', 'overdue', 'cancelled'],
+    default: 'draft',
+  })
+  status!: 'draft' | 'pending' | 'paid' | 'overdue' | 'cancelled';
+
+  @Prop({ type: Date, required: true, default: Date.now })
+  issueDate!: Date;
+
+  @Prop({ type: Date })
+  dueDate!: Date;
+
+  @Prop({
+    type: [
+      {
+        description: { type: String, required: true },
+        quantity: { type: Number, required: true, default: 1 },
+        unitPrice: { type: Number, required: true },
+        amount: { type: Number, required: true },
+      },
+    ],
+    default: [],
+  })
+  items!: InvoiceItem[];
+
+  @Prop({ default: 0 })
+  subtotal!: number;
+
+  @Prop({ default: 0 })
+  taxRate!: number;
+
+  @Prop({ default: 0 })
+  taxAmount!: number;
+
+  @Prop({ default: 0 })
+  total!: number;
+
+  @Prop({ default: 'USD', trim: true, uppercase: true })
+  currency!: string;
+
+  @Prop({ trim: true })
+  notes!: string;
+}
+
+export const InvoiceSchema = SchemaFactory.createForClass(Invoice);
+
+InvoiceSchema.index({ workspaceId: 1, status: 1 });
+InvoiceSchema.index({ workspaceId: 1, type: 1 });
+InvoiceSchema.index({ workspaceId: 1, clientId: 1 });
+InvoiceSchema.index({ workspaceId: 1, createdAt: -1 });

package/templates/backend/src/modules/notifications/dto/create-notification.dto.ts

@@ -0,0 +1,45 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsBoolean, IsEnum, IsOptional, IsString, MaxLength } from 'class-validator';
+
+export class CreateNotificationDto {
+  @ApiProperty({ description: 'ID del usuario destinatario' })
+  @IsString({ message: 'El userId debe ser un texto' })
+  userId!: string;
+
+  @ApiProperty({ example: 'Nueva factura recibida', maxLength: 120 })
+  @IsString({ message: 'El título debe ser un texto' })
+  @MaxLength(120, { message: 'El título no puede superar los 120 caracteres' })
+  title!: string;
+
+  @ApiProperty({ example: 'Se recibió una factura por $1200', maxLength: 500 })
+  @IsString({ message: 'El mensaje debe ser un texto' })
+  @MaxLength(500, { message: 'El mensaje no puede superar los 500 caracteres' })
+  message!: string;
+
+  @ApiPropertyOptional({ enum: ['info', 'warning', 'success', 'error'], default: 'info' })
+  @IsOptional()
+  @IsEnum(['info', 'warning', 'success', 'error'], {
+    message: 'El tipo debe ser "info", "warning", "success" o "error"',
+  })
+  type?: 'info' | 'warning' | 'success' | 'error';
+
+  @ApiPropertyOptional({ example: '/invoices/123' })
+  @IsOptional()
+  @IsString({ message: 'El link debe ser un texto' })
+  link?: string;
+
+  @ApiPropertyOptional({ example: '507f1f77bcf86cd799439011' })
+  @IsOptional()
+  @IsString({ message: 'El refId debe ser un texto' })
+  refId?: string;
+
+  @ApiPropertyOptional({ example: 'invoice' })
+  @IsOptional()
+  @IsString({ message: 'El refType debe ser un texto' })
+  refType?: string;
+
+  @ApiPropertyOptional({ default: false })
+  @IsOptional()
+  @IsBoolean({ message: 'isRead debe ser un booleano' })
+  isRead?: boolean;
+}

package/templates/backend/src/modules/notifications/dto/query-notification.dto.ts

@@ -0,0 +1,30 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Transform, Type } from 'class-transformer';
+import { IsBoolean, IsInt, IsOptional, Max, Min } from 'class-validator';
+
+export class QueryNotificationDto {
+  @ApiPropertyOptional({ description: 'Filtrar por estado de lectura' })
+  @IsOptional()
+  @Transform(({ value }) => {
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    return value;
+  })
+  @IsBoolean({ message: 'isRead debe ser un booleano' })
+  isRead?: boolean;
+
+  @ApiPropertyOptional({ default: 1, minimum: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: 'La página debe ser un número entero' })
+  @Min(1, { message: 'La página mínima es 1' })
+  page?: number = 1;
+
+  @ApiPropertyOptional({ default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: 'El límite debe ser un número entero' })
+  @Min(1, { message: 'El límite mínimo es 1' })
+  @Max(100, { message: 'El límite máximo es 100' })
+  limit?: number = 20;
+}

package/templates/backend/src/modules/notifications/dto/update-notification.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreateNotificationDto } from './create-notification.dto';
+
+export class UpdateNotificationDto extends PartialType(CreateNotificationDto) {}

package/templates/backend/src/modules/notifications/notifications.controller.ts

@@ -0,0 +1,119 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import { CurrentUser } from '../../common/decorators/current-user.decorator';
+import type { TokenPayload } from '../../common/decorators/current-user.decorator';
+import { WorkspaceId } from '../../common/decorators/workspace-id.decorator';
+import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
+import { CreateNotificationDto } from './dto/create-notification.dto';
+import { QueryNotificationDto } from './dto/query-notification.dto';
+import { NotificationsService } from './notifications.service';
+
+@ApiTags('Notifications')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('notifications')
+export class NotificationsController {
+  constructor(private readonly notificationsService: NotificationsService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Listar notificaciones del usuario' })
+  @ApiResponse({ status: 200, description: 'Lista paginada de notificaciones' })
+  findAll(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Query() query: QueryNotificationDto,
+  ) {
+    return this.notificationsService.findAll(workspaceId, user.userId, query);
+  }
+
+  @Get('unread-count')
+  @ApiOperation({ summary: 'Obtener cantidad de notificaciones no leídas' })
+  @ApiResponse({ status: 200, description: '{ count: number }' })
+  getUnreadCount(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+  ) {
+    return this.notificationsService.getUnreadCount(workspaceId, user.userId);
+  }
+
+  @Post('mark-all-read')
+  @ApiOperation({ summary: 'Marcar todas las notificaciones como leídas' })
+  @ApiResponse({ status: 200, description: 'Todas marcadas como leídas' })
+  markAllAsRead(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+  ) {
+    return this.notificationsService.markAllAsRead(workspaceId, user.userId);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Obtener una notificación por ID' })
+  @ApiResponse({ status: 200, description: 'Notificación encontrada' })
+  @ApiResponse({ status: 404, description: 'Notificación no encontrada' })
+  findOne(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.notificationsService.findOne(workspaceId, id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Crear una notificación' })
+  @ApiResponse({ status: 201, description: 'Notificación creada' })
+  create(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Body() dto: CreateNotificationDto,
+  ) {
+    return this.notificationsService.create(workspaceId, user.userId, dto);
+  }
+
+  @Patch(':id/read')
+  @ApiOperation({ summary: 'Marcar notificación como leída' })
+  @ApiResponse({ status: 200, description: 'Notificación marcada como leída' })
+  markAsRead(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.notificationsService.markAsRead(workspaceId, id);
+  }
+
+  @Patch(':id/unread')
+  @ApiOperation({ summary: 'Marcar notificación como no leída' })
+  @ApiResponse({ status: 200, description: 'Notificación marcada como no leída' })
+  markAsUnread(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.notificationsService.markAsUnread(workspaceId, id);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Eliminar una notificación (soft delete)' })
+  @ApiResponse({ status: 204, description: 'Notificación eliminada' })
+  @ApiResponse({ status: 404, description: 'Notificación no encontrada' })
+  remove(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.notificationsService.remove(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/notifications/notifications.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Notification, NotificationSchema } from './schemas/notification.schema';
+import { NotificationsController } from './notifications.controller';
+import { NotificationsRepository } from './notifications.repository';
+import { NotificationsService } from './notifications.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: Notification.name, schema: NotificationSchema }]),
+  ],
+  controllers: [NotificationsController],
+  providers: [NotificationsService, NotificationsRepository],
+  exports: [NotificationsService],
+})
+export class NotificationsModule {}

package/templates/backend/src/modules/notifications/notifications.repository.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BaseRepository } from '../../common/base/base.repository';
+import { Notification, NotificationDocument } from './schemas/notification.schema';
+
+@Injectable()
+export class NotificationsRepository extends BaseRepository<NotificationDocument> {
+  constructor(
+    @InjectModel(Notification.name)
+    private readonly notificationModel: Model<NotificationDocument>,
+  ) {
+    super(notificationModel);
+  }
+
+  async markAllAsRead(workspaceId: string, userId: string): Promise<void> {
+    await this.notificationModel.updateMany(
+      { workspaceId, userId, isRead: false, deletedAt: null },
+      { $set: { isRead: true } },
+    );
+  }
+
+  async getUnreadCount(workspaceId: string, userId: string): Promise<number> {
+    return this.notificationModel.countDocuments({
+      workspaceId,
+      userId,
+      isRead: false,
+      deletedAt: null,
+    });
+  }
+}

package/templates/backend/src/modules/notifications/notifications.service.ts

@@ -0,0 +1,64 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateNotificationDto } from './dto/create-notification.dto';
+import { QueryNotificationDto } from './dto/query-notification.dto';
+import { NotificationsRepository } from './notifications.repository';
+
+@Injectable()
+export class NotificationsService {
+  constructor(private readonly notificationsRepository: NotificationsRepository) {}
+
+  findAll(workspaceId: string, userId: string, query: QueryNotificationDto) {
+    const { page, limit, isRead } = query;
+    const filter: Record<string, unknown> = { userId };
+    if (isRead !== undefined) filter.isRead = isRead;
+
+    return this.notificationsRepository.paginate(workspaceId, {
+      page,
+      limit,
+      filter,
+      sort: { createdAt: -1 },
+    });
+  }
+
+  async findOne(workspaceId: string, id: string) {
+    const notification = await this.notificationsRepository.findById(workspaceId, id);
+    if (!notification) throw new NotFoundException('Notificación no encontrada');
+    return notification;
+  }
+
+  create(workspaceId: string, userId: string, dto: CreateNotificationDto) {
+    return this.notificationsRepository.create({
+      ...dto,
+      workspaceId: workspaceId as unknown as import('mongoose').Types.ObjectId,
+      createdBy: userId as unknown as import('mongoose').Types.ObjectId,
+      deletedAt: null,
+    } as never);
+  }
+
+  async markAsRead(workspaceId: string, id: string) {
+    const notification = await this.notificationsRepository.findById(workspaceId, id);
+    if (!notification) throw new NotFoundException('Notificación no encontrada');
+    return this.notificationsRepository.update(workspaceId, id, { isRead: true } as never);
+  }
+
+  async markAsUnread(workspaceId: string, id: string) {
+    const notification = await this.notificationsRepository.findById(workspaceId, id);
+    if (!notification) throw new NotFoundException('Notificación no encontrada');
+    return this.notificationsRepository.update(workspaceId, id, { isRead: false } as never);
+  }
+
+  async markAllAsRead(workspaceId: string, userId: string) {
+    await this.notificationsRepository.markAllAsRead(workspaceId, userId);
+    return { message: 'Todas las notificaciones marcadas como leídas' };
+  }
+
+  async getUnreadCount(workspaceId: string, userId: string) {
+    const count = await this.notificationsRepository.getUnreadCount(workspaceId, userId);
+    return { count };
+  }
+
+  async remove(workspaceId: string, id: string) {
+    await this.findOne(workspaceId, id);
+    await this.notificationsRepository.softDelete(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/notifications/schemas/notification.schema.ts

@@ -0,0 +1,38 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type NotificationDocument = HydratedDocument<Notification>;
+
+@Schema({ collection: 'notifications', timestamps: true })
+export class Notification extends BaseSchema {
+  @Prop({ required: true })
+  userId!: string;
+
+  @Prop({ required: true, trim: true, maxlength: 120 })
+  title!: string;
+
+  @Prop({ required: true, trim: true, maxlength: 500 })
+  message!: string;
+
+  @Prop({ type: String, enum: ['info', 'warning', 'success', 'error'], default: 'info' })
+  type!: 'info' | 'warning' | 'success' | 'error';
+
+  @Prop({ trim: true })
+  link!: string;
+
+  @Prop({ default: false })
+  isRead!: boolean;
+
+  @Prop({ trim: true })
+  refId!: string;
+
+  @Prop({ trim: true })
+  refType!: string;
+}
+
+export const NotificationSchema = SchemaFactory.createForClass(Notification);
+
+NotificationSchema.index({ workspaceId: 1, userId: 1 });
+NotificationSchema.index({ workspaceId: 1, userId: 1, isRead: 1 });
+NotificationSchema.index({ workspaceId: 1, createdAt: -1 });