ar-saas 0.4.2 → 0.5.0

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

@@ -0,0 +1,104 @@
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { CreatePlannerBlockDto } from './dto/create-planner-block.dto';
+import { QueryPlannerBlockDto } from './dto/query-planner-block.dto';
+import { UpdateBlockStatusDto } from './dto/update-block-status.dto';
+import { UpdatePlannerBlockDto } from './dto/update-planner-block.dto';
+import { PlannerRepository } from './planner.repository';
+
+@Injectable()
+export class PlannerService {
+  constructor(private readonly plannerRepository: PlannerRepository) {}
+
+  async findAll(workspaceId: string, userId: string, query: QueryPlannerBlockDto) {
+    const { date, dateFrom, dateTo, status, category, page, limit } = query;
+
+    if (date) {
+      const blocks = await this.plannerRepository.findByDate(workspaceId, userId, date);
+      return { data: blocks, total: blocks.length, page: 1, limit: blocks.length };
+    }
+
+    if (dateFrom && dateTo) {
+      const dayDiff = this.daysBetween(dateFrom, dateTo);
+      if (dayDiff > 31) {
+        throw new BadRequestException('El rango de fechas no puede superar los 31 días');
+      }
+      const blocks = await this.plannerRepository.findByDateRange(workspaceId, userId, dateFrom, dateTo);
+      return { data: blocks, total: blocks.length, page: 1, limit: blocks.length };
+    }
+
+    const filter: Record<string, unknown> = { userId };
+    if (status) filter.status = status;
+    if (category) filter.category = category;
+
+    return this.plannerRepository.paginate(workspaceId, {
+      page,
+      limit,
+      filter,
+      sort: { date: 1, order: 1 },
+    });
+  }
+
+  async findOne(workspaceId: string, userId: string, id: string) {
+    const block = await this.plannerRepository.findOne(workspaceId, { _id: this.plannerRepository['toObjectId'](id), userId });
+    if (!block) throw new NotFoundException('Bloque no encontrado');
+    return block;
+  }
+
+  create(workspaceId: string, userId: string, dto: CreatePlannerBlockDto) {
+    return this.plannerRepository.create({
+      ...dto,
+      userId,
+      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, userId: string, id: string, dto: UpdatePlannerBlockDto) {
+    await this.findOne(workspaceId, userId, id);
+    const block = await this.plannerRepository.update(workspaceId, id, dto as never);
+    if (!block) throw new NotFoundException('Bloque no encontrado');
+    return block;
+  }
+
+  async updateStatus(workspaceId: string, userId: string, id: string, dto: UpdateBlockStatusDto) {
+    await this.findOne(workspaceId, userId, id);
+    const block = await this.plannerRepository.update(workspaceId, id, { status: dto.status } as never);
+    if (!block) throw new NotFoundException('Bloque no encontrado');
+    return block;
+  }
+
+  async duplicate(workspaceId: string, userId: string, id: string, targetDate?: string) {
+    const original = await this.findOne(workspaceId, userId, id);
+    const orig = original as unknown as Record<string, unknown>;
+    return this.plannerRepository.create({
+      userId,
+      date: targetDate ?? (orig.date as string),
+      startTime: orig.startTime as string,
+      endTime: orig.endTime as string,
+      title: orig.title as string,
+      description: orig.description as string,
+      category: orig.category as string,
+      priority: orig.priority as 'low' | 'medium' | 'high',
+      color: orig.color as string,
+      isFocusBlock: orig.isFocusBlock as boolean,
+      tags: orig.tags as string[],
+      order: ((orig.order as number) ?? 0) + 1,
+      status: 'pending',
+      workspaceId: workspaceId as unknown as import('mongoose').Types.ObjectId,
+      createdBy: userId as unknown as import('mongoose').Types.ObjectId,
+      deletedAt: null,
+    } as never);
+  }
+
+  async remove(workspaceId: string, userId: string, id: string) {
+    await this.findOne(workspaceId, userId, id);
+    await this.plannerRepository.softDelete(workspaceId, id);
+  }
+
+  private daysBetween(from: string, to: string): number {
+    const a = new Date(from).getTime();
+    const b = new Date(to).getTime();
+    return Math.abs(Math.round((b - a) / (1000 * 60 * 60 * 24)));
+  }
+}

package/templates/backend/src/modules/planner/schemas/planner-block.schema.ts

@@ -0,0 +1,56 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type PlannerBlockDocument = HydratedDocument<PlannerBlock>;
+
+@Schema({ collection: 'planner_blocks', timestamps: true })
+export class PlannerBlock extends BaseSchema {
+  @Prop({ required: true })
+  userId!: string;
+
+  @Prop({ required: true })
+  date!: string;
+
+  @Prop({ required: true })
+  startTime!: string;
+
+  @Prop({ required: true })
+  endTime!: string;
+
+  @Prop({ required: true, trim: true, maxlength: 120 })
+  title!: string;
+
+  @Prop({ trim: true })
+  description!: string;
+
+  @Prop({ default: 'work' })
+  category!: string;
+
+  @Prop({ type: String, enum: ['low', 'medium', 'high'], default: 'medium' })
+  priority!: 'low' | 'medium' | 'high';
+
+  @Prop({
+    type: String,
+    enum: ['pending', 'in-progress', 'completed', 'skipped'],
+    default: 'pending',
+  })
+  status!: 'pending' | 'in-progress' | 'completed' | 'skipped';
+
+  @Prop({ default: '#2563EB' })
+  color!: string;
+
+  @Prop({ default: false })
+  isFocusBlock!: boolean;
+
+  @Prop({ default: 0 })
+  order!: number;
+
+  @Prop({ type: [String], default: [] })
+  tags!: string[];
+}
+
+export const PlannerBlockSchema = SchemaFactory.createForClass(PlannerBlock);
+
+PlannerBlockSchema.index({ workspaceId: 1, userId: 1, date: 1 });
+PlannerBlockSchema.index({ workspaceId: 1, userId: 1, date: 1, status: 1 });

package/templates/backend/src/modules/task-columns/dto/create-task-column.dto.ts

@@ -0,0 +1,20 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsInt, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateTaskColumnDto {
+  @ApiProperty({ example: 'En progreso', maxLength: 100 })
+  @IsString({ message: 'El nombre debe ser un texto' })
+  @MaxLength(100, { message: 'El nombre no puede superar los 100 caracteres' })
+  name!: string;
+
+  @ApiPropertyOptional({ example: '#6B7280' })
+  @IsOptional()
+  @IsString({ message: 'El color debe ser un texto' })
+  color?: string;
+
+  @ApiPropertyOptional({ example: 0, minimum: 0 })
+  @IsOptional()
+  @IsInt({ message: 'El orden debe ser un número entero' })
+  @Min(0, { message: 'El orden no puede ser negativo' })
+  order?: number;
+}

package/templates/backend/src/modules/task-columns/dto/reorder-columns.dto.ts

@@ -0,0 +1,9 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsArray, IsString } from 'class-validator';
+
+export class ReorderColumnsDto {
+  @ApiProperty({ example: ['id1', 'id2', 'id3'], description: 'IDs de columnas en el nuevo orden' })
+  @IsArray({ message: 'Los ids deben ser un array' })
+  @IsString({ each: true, message: 'Cada id debe ser un texto' })
+  ids!: string[];
+}

package/templates/backend/src/modules/task-columns/dto/update-task-column.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreateTaskColumnDto } from './create-task-column.dto';
+
+export class UpdateTaskColumnDto extends PartialType(CreateTaskColumnDto) {}

package/templates/backend/src/modules/task-columns/schemas/task-column.schema.ts

@@ -0,0 +1,21 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type TaskColumnDocument = HydratedDocument<TaskColumn>;
+
+@Schema({ collection: 'task_columns', timestamps: true })
+export class TaskColumn extends BaseSchema {
+  @Prop({ required: true, trim: true, maxlength: 100 })
+  name!: string;
+
+  @Prop({ default: '#6B7280' })
+  color!: string;
+
+  @Prop({ default: 0 })
+  order!: number;
+}
+
+export const TaskColumnSchema = SchemaFactory.createForClass(TaskColumn);
+
+TaskColumnSchema.index({ workspaceId: 1, order: 1 });

package/templates/backend/src/modules/task-columns/task-columns.controller.ts

@@ -0,0 +1,86 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  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 { CreateTaskColumnDto } from './dto/create-task-column.dto';
+import { ReorderColumnsDto } from './dto/reorder-columns.dto';
+import { UpdateTaskColumnDto } from './dto/update-task-column.dto';
+import { TaskColumnsService } from './task-columns.service';
+
+@ApiTags('Task Columns')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('task-columns')
+export class TaskColumnsController {
+  constructor(private readonly taskColumnsService: TaskColumnsService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Listar columnas del workspace' })
+  @ApiResponse({ status: 200, description: 'Lista de columnas ordenadas' })
+  findAll(@WorkspaceId() workspaceId: string) {
+    return this.taskColumnsService.findAll(workspaceId);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Crear una nueva columna' })
+  @ApiResponse({ status: 201, description: 'Columna creada' })
+  create(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Body() dto: CreateTaskColumnDto,
+  ) {
+    return this.taskColumnsService.create(workspaceId, user.userId, dto);
+  }
+
+  @Patch('reorder')
+  @ApiOperation({ summary: 'Reordenar columnas' })
+  @ApiResponse({ status: 200, description: 'Columnas reordenadas' })
+  reorder(
+    @WorkspaceId() workspaceId: string,
+    @Body() dto: ReorderColumnsDto,
+  ) {
+    return this.taskColumnsService.reorder(workspaceId, dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Actualizar una columna' })
+  @ApiResponse({ status: 200, description: 'Columna actualizada' })
+  @ApiResponse({ status: 404, description: 'Columna no encontrada' })
+  update(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+    @Body() dto: UpdateTaskColumnDto,
+  ) {
+    return this.taskColumnsService.update(workspaceId, id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Eliminar una columna (soft delete)' })
+  @ApiResponse({ status: 204, description: 'Columna eliminada' })
+  @ApiResponse({ status: 404, description: 'Columna no encontrada' })
+  remove(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.taskColumnsService.remove(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/task-columns/task-columns.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { TaskColumn, TaskColumnSchema } from './schemas/task-column.schema';
+import { TaskColumnsController } from './task-columns.controller';
+import { TaskColumnsRepository } from './task-columns.repository';
+import { TaskColumnsService } from './task-columns.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: TaskColumn.name, schema: TaskColumnSchema }]),
+  ],
+  controllers: [TaskColumnsController],
+  providers: [TaskColumnsService, TaskColumnsRepository],
+  exports: [TaskColumnsService],
+})
+export class TaskColumnsModule {}

package/templates/backend/src/modules/task-columns/task-columns.repository.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BaseRepository } from '../../common/base/base.repository';
+import { TaskColumn, TaskColumnDocument } from './schemas/task-column.schema';
+
+@Injectable()
+export class TaskColumnsRepository extends BaseRepository<TaskColumnDocument> {
+  constructor(
+    @InjectModel(TaskColumn.name)
+    private readonly taskColumnModel: Model<TaskColumnDocument>,
+  ) {
+    super(taskColumnModel);
+  }
+}

package/templates/backend/src/modules/task-columns/task-columns.service.ts

@@ -0,0 +1,49 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateTaskColumnDto } from './dto/create-task-column.dto';
+import { ReorderColumnsDto } from './dto/reorder-columns.dto';
+import { UpdateTaskColumnDto } from './dto/update-task-column.dto';
+import { TaskColumnsRepository } from './task-columns.repository';
+
+@Injectable()
+export class TaskColumnsService {
+  constructor(private readonly taskColumnsRepository: TaskColumnsRepository) {}
+
+  findAll(workspaceId: string) {
+    return this.taskColumnsRepository.findAll(workspaceId, { sort: { order: 1 } });
+  }
+
+  async findOne(workspaceId: string, id: string) {
+    const column = await this.taskColumnsRepository.findById(workspaceId, id);
+    if (!column) throw new NotFoundException('Columna no encontrada');
+    return column;
+  }
+
+  create(workspaceId: string, userId: string, dto: CreateTaskColumnDto) {
+    return this.taskColumnsRepository.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 update(workspaceId: string, id: string, dto: UpdateTaskColumnDto) {
+    await this.findOne(workspaceId, id);
+    const column = await this.taskColumnsRepository.update(workspaceId, id, dto as never);
+    if (!column) throw new NotFoundException('Columna no encontrada');
+    return column;
+  }
+
+  async reorder(workspaceId: string, dto: ReorderColumnsDto) {
+    const updates = dto.ids.map((id, index) =>
+      this.taskColumnsRepository.update(workspaceId, id, { order: index } as never),
+    );
+    await Promise.all(updates);
+    return this.taskColumnsRepository.findAll(workspaceId, { sort: { order: 1 } });
+  }
+
+  async remove(workspaceId: string, id: string) {
+    await this.findOne(workspaceId, id);
+    await this.taskColumnsRepository.softDelete(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/tasks/dto/checklist-item.dto.ts

@@ -0,0 +1,13 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsBoolean, IsOptional, IsString } from 'class-validator';
+
+export class ChecklistItemDto {
+  @ApiProperty({ example: 'Revisar especificaciones' })
+  @IsString({ message: 'El texto debe ser un texto' })
+  text!: string;
+
+  @ApiPropertyOptional({ default: false })
+  @IsOptional()
+  @IsBoolean({ message: 'completed debe ser un booleano' })
+  completed?: boolean;
+}

package/templates/backend/src/modules/tasks/dto/create-task.dto.ts

@@ -0,0 +1,67 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsDateString,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+import { ChecklistItemDto } from './checklist-item.dto';
+import { LabelDto } from './label.dto';
+
+export class CreateTaskDto {
+  @ApiProperty({ example: 'Implementar login', maxLength: 200 })
+  @IsString({ message: 'El título debe ser un texto' })
+  @MaxLength(200, { message: 'El título no puede superar los 200 caracteres' })
+  title!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'La descripción debe ser un texto' })
+  description?: string;
+
+  @ApiPropertyOptional({ enum: ['todo', 'in-progress', 'done', 'cancelled'], default: 'todo' })
+  @IsOptional()
+  @IsEnum(['todo', 'in-progress', 'done', 'cancelled'], { message: 'El estado no es válido' })
+  status?: 'todo' | 'in-progress' | 'done' | 'cancelled';
+
+  @ApiPropertyOptional({ enum: ['low', 'medium', 'high', 'urgent'], default: 'medium' })
+  @IsOptional()
+  @IsEnum(['low', 'medium', 'high', 'urgent'], { message: 'La prioridad no es válida' })
+  priority?: 'low' | 'medium' | 'high' | 'urgent';
+
+  @ApiPropertyOptional({ example: '2026-03-31' })
+  @IsOptional()
+  @IsDateString({}, { message: 'La fecha de vencimiento debe ser una fecha válida' })
+  dueDate?: string;
+
+  @ApiPropertyOptional({ description: 'ID de la columna (null para sin columna)' })
+  @IsOptional()
+  @IsString({ message: 'El columnId debe ser un texto' })
+  columnId?: string | null;
+
+  @ApiPropertyOptional({ example: 0, minimum: 0 })
+  @IsOptional()
+  @IsInt({ message: 'El orden debe ser un número entero' })
+  @Min(0, { message: 'El orden no puede ser negativo' })
+  order?: number;
+
+  @ApiPropertyOptional({ type: [ChecklistItemDto] })
+  @IsOptional()
+  @IsArray({ message: 'El checklist debe ser un array' })
+  @ValidateNested({ each: true })
+  @Type(() => ChecklistItemDto)
+  checklist?: ChecklistItemDto[];
+
+  @ApiPropertyOptional({ type: [LabelDto] })
+  @IsOptional()
+  @IsArray({ message: 'Las labels deben ser un array' })
+  @ValidateNested({ each: true })
+  @Type(() => LabelDto)
+  labels?: LabelDto[];
+}

package/templates/backend/src/modules/tasks/dto/label.dto.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString } from 'class-validator';
+
+export class LabelDto {
+  @ApiProperty({ example: 'Bug' })
+  @IsString({ message: 'El nombre debe ser un texto' })
+  name!: string;
+
+  @ApiProperty({ example: '#EF4444' })
+  @IsString({ message: 'El color debe ser un texto' })
+  color!: string;
+}

package/templates/backend/src/modules/tasks/dto/move-task.dto.ts

@@ -0,0 +1,15 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsInt, IsOptional, IsString, Min, ValidateIf } from 'class-validator';
+
+export class MoveTaskDto {
+  @ApiProperty({ description: 'ID de la columna destino o null para sin columna', nullable: true })
+  @ValidateIf((o: MoveTaskDto) => o.columnId !== null)
+  @IsString({ message: 'El columnId debe ser un texto' })
+  columnId!: string | null;
+
+  @ApiPropertyOptional({ example: 0, minimum: 0 })
+  @IsOptional()
+  @IsInt({ message: 'El orden debe ser un número entero' })
+  @Min(0, { message: 'El orden no puede ser negativo' })
+  order?: number;
+}

package/templates/backend/src/modules/tasks/dto/query-task.dto.ts

@@ -0,0 +1,40 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class QueryTaskDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'La búsqueda debe ser un texto' })
+  search?: string;
+
+  @ApiPropertyOptional({ enum: ['todo', 'in-progress', 'done', 'cancelled'] })
+  @IsOptional()
+  @IsEnum(['todo', 'in-progress', 'done', 'cancelled'], { message: 'El estado no es válido' })
+  status?: 'todo' | 'in-progress' | 'done' | 'cancelled';
+
+  @ApiPropertyOptional({ enum: ['low', 'medium', 'high', 'urgent'] })
+  @IsOptional()
+  @IsEnum(['low', 'medium', 'high', 'urgent'], { message: 'La prioridad no es válida' })
+  priority?: 'low' | 'medium' | 'high' | 'urgent';
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'El columnId debe ser un texto' })
+  columnId?: string;
+
+  @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: 100, minimum: 1, maximum: 200 })
+  @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(200, { message: 'El límite máximo es 200' })
+  limit?: number = 100;
+}

package/templates/backend/src/modules/tasks/dto/update-task.dto.ts

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

package/templates/backend/src/modules/tasks/schemas/task.schema.ts

@@ -0,0 +1,66 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type TaskDocument = HydratedDocument<Task>;
+
+export interface ChecklistItem {
+  text: string;
+  completed: boolean;
+}
+
+export interface TaskLabel {
+  name: string;
+  color: string;
+}
+
+@Schema({ collection: 'tasks', timestamps: true })
+export class Task extends BaseSchema {
+  @Prop({ required: true, trim: true, maxlength: 200 })
+  title!: string;
+
+  @Prop({ trim: true })
+  description!: string;
+
+  @Prop({
+    type: String,
+    enum: ['todo', 'in-progress', 'done', 'cancelled'],
+    default: 'todo',
+  })
+  status!: 'todo' | 'in-progress' | 'done' | 'cancelled';
+
+  @Prop({
+    type: String,
+    enum: ['low', 'medium', 'high', 'urgent'],
+    default: 'medium',
+  })
+  priority!: 'low' | 'medium' | 'high' | 'urgent';
+
+  @Prop({ type: Date })
+  dueDate!: Date;
+
+  @Prop({ type: String, default: null })
+  columnId!: string | null;
+
+  @Prop({ default: 0 })
+  order!: number;
+
+  @Prop({
+    type: [{ text: { type: String, required: true }, completed: { type: Boolean, default: false } }],
+    default: [],
+  })
+  checklist!: ChecklistItem[];
+
+  @Prop({
+    type: [{ name: { type: String, required: true }, color: { type: String, required: true } }],
+    default: [],
+  })
+  labels!: TaskLabel[];
+}
+
+export const TaskSchema = SchemaFactory.createForClass(Task);
+
+TaskSchema.index({ workspaceId: 1, status: 1 });
+TaskSchema.index({ workspaceId: 1, columnId: 1, order: 1 });
+TaskSchema.index({ workspaceId: 1, priority: 1 });
+TaskSchema.index({ workspaceId: 1, dueDate: 1 });