ar-saas 0.4.2 → 0.5.0

package/templates/backend/src/modules/pipeline/dto/create-deal.dto.ts

@@ -0,0 +1,40 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsDateString, IsEnum, IsNumber, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateDealDto {
+  @ApiProperty({ example: 'Proyecto de integración', 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({ description: 'ID del cliente' })
+  @IsOptional()
+  @IsString({ message: 'El clientId debe ser un texto' })
+  clientId?: string;
+
+  @ApiPropertyOptional({ example: 5000, minimum: 0 })
+  @IsOptional()
+  @IsNumber({}, { message: 'El valor debe ser un número' })
+  @Min(0, { message: 'El valor no puede ser negativo' })
+  value?: number;
+
+  @ApiPropertyOptional({ example: 'USD' })
+  @IsOptional()
+  @IsString({ message: 'La moneda debe ser un texto' })
+  currency?: string;
+
+  @ApiPropertyOptional({ enum: ['lead', 'contacted', 'proposal', 'won', 'lost'], default: 'lead' })
+  @IsOptional()
+  @IsEnum(['lead', 'contacted', 'proposal', 'won', 'lost'], { message: 'El stage no es válido' })
+  stage?: 'lead' | 'contacted' | 'proposal' | 'won' | 'lost';
+
+  @ApiPropertyOptional({ example: '2026-03-31' })
+  @IsOptional()
+  @IsDateString({}, { message: 'La fecha de cierre esperada debe ser una fecha válida' })
+  expectedCloseDate?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'Las notas deben ser un texto' })
+  notes?: string;
+}

package/templates/backend/src/modules/pipeline/dto/query-deal.dto.ts

@@ -0,0 +1,35 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class QueryDealDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'La búsqueda debe ser un texto' })
+  search?: string;
+
+  @ApiPropertyOptional({ enum: ['lead', 'contacted', 'proposal', 'won', 'lost'] })
+  @IsOptional()
+  @IsEnum(['lead', 'contacted', 'proposal', 'won', 'lost'], { message: 'El stage no es válido' })
+  stage?: 'lead' | 'contacted' | 'proposal' | 'won' | 'lost';
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'El clientId debe ser un texto' })
+  clientId?: 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: 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/pipeline/dto/update-deal.dto.ts

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

package/templates/backend/src/modules/pipeline/pipeline.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 { CreateDealDto } from './dto/create-deal.dto';
+import { QueryDealDto } from './dto/query-deal.dto';
+import { UpdateDealDto } from './dto/update-deal.dto';
+import { PipelineService } from './pipeline.service';
+
+@ApiTags('Pipeline')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('pipeline')
+export class PipelineController {
+  constructor(private readonly pipelineService: PipelineService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Listar deals del workspace' })
+  @ApiResponse({ status: 200, description: 'Lista paginada de deals' })
+  findAll(
+    @WorkspaceId() workspaceId: string,
+    @Query() query: QueryDealDto,
+  ) {
+    return this.pipelineService.findAll(workspaceId, query);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Obtener un deal por ID' })
+  @ApiResponse({ status: 200, description: 'Deal encontrado' })
+  @ApiResponse({ status: 404, description: 'Deal no encontrado' })
+  findOne(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.pipelineService.findOne(workspaceId, id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Crear un nuevo deal' })
+  @ApiResponse({ status: 201, description: 'Deal creado' })
+  create(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Body() dto: CreateDealDto,
+  ) {
+    return this.pipelineService.create(workspaceId, user.userId, dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Actualizar un deal' })
+  @ApiResponse({ status: 200, description: 'Deal actualizado' })
+  @ApiResponse({ status: 404, description: 'Deal no encontrado' })
+  update(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+    @Body() dto: UpdateDealDto,
+  ) {
+    return this.pipelineService.update(workspaceId, id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Eliminar un deal (soft delete)' })
+  @ApiResponse({ status: 204, description: 'Deal eliminado' })
+  @ApiResponse({ status: 404, description: 'Deal no encontrado' })
+  remove(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.pipelineService.remove(workspaceId, id);
+  }
+}

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

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ClientsModule } from '../clients/clients.module';
+import { Deal, DealSchema } from './schemas/deal.schema';
+import { PipelineController } from './pipeline.controller';
+import { PipelineRepository } from './pipeline.repository';
+import { PipelineService } from './pipeline.service';
+
+@Module({
+  imports: [
+    ClientsModule,
+    MongooseModule.forFeature([{ name: Deal.name, schema: DealSchema }]),
+  ],
+  controllers: [PipelineController],
+  providers: [PipelineService, PipelineRepository],
+  exports: [PipelineService],
+})
+export class PipelineModule {}

package/templates/backend/src/modules/pipeline/pipeline.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 { Deal, DealDocument } from './schemas/deal.schema';
+
+@Injectable()
+export class PipelineRepository extends BaseRepository<DealDocument> {
+  constructor(
+    @InjectModel(Deal.name) private readonly dealModel: Model<DealDocument>,
+  ) {
+    super(dealModel);
+  }
+}

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

@@ -0,0 +1,64 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { ClientsService } from '../clients/clients.service';
+import { CreateDealDto } from './dto/create-deal.dto';
+import { QueryDealDto } from './dto/query-deal.dto';
+import { UpdateDealDto } from './dto/update-deal.dto';
+import { PipelineRepository } from './pipeline.repository';
+
+@Injectable()
+export class PipelineService {
+  constructor(
+    private readonly pipelineRepository: PipelineRepository,
+    private readonly clientsService: ClientsService,
+  ) {}
+
+  findAll(workspaceId: string, query: QueryDealDto) {
+    const { page, limit, search, stage, clientId } = query;
+    const filter: Record<string, unknown> = {};
+
+    if (stage) filter.stage = stage;
+    if (clientId) filter.clientId = clientId;
+    if (search) filter.title = { $regex: search, $options: 'i' };
+
+    return this.pipelineRepository.paginate(workspaceId, {
+      page,
+      limit,
+      filter,
+      sort: { createdAt: -1 },
+    });
+  }
+
+  async findOne(workspaceId: string, id: string) {
+    const deal = await this.pipelineRepository.findById(workspaceId, id);
+    if (!deal) throw new NotFoundException('Deal no encontrado');
+    return deal;
+  }
+
+  async create(workspaceId: string, userId: string, dto: CreateDealDto) {
+    if (dto.clientId) {
+      await this.clientsService.findOne(workspaceId, dto.clientId);
+    }
+    return this.pipelineRepository.create({
+      ...dto,
+      expectedCloseDate: dto.expectedCloseDate ? new Date(dto.expectedCloseDate) : 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: UpdateDealDto) {
+    await this.findOne(workspaceId, id);
+    if (dto.clientId) {
+      await this.clientsService.findOne(workspaceId, dto.clientId);
+    }
+    const deal = await this.pipelineRepository.update(workspaceId, id, dto as never);
+    if (!deal) throw new NotFoundException('Deal no encontrado');
+    return deal;
+  }
+
+  async remove(workspaceId: string, id: string) {
+    await this.findOne(workspaceId, id);
+    await this.pipelineRepository.softDelete(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/pipeline/schemas/deal.schema.ts

@@ -0,0 +1,39 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type DealDocument = HydratedDocument<Deal>;
+
+@Schema({ collection: 'deals', timestamps: true })
+export class Deal extends BaseSchema {
+  @Prop({ required: true, trim: true, maxlength: 200 })
+  title!: string;
+
+  @Prop()
+  clientId!: string;
+
+  @Prop({ default: 0 })
+  value!: number;
+
+  @Prop({ default: 'USD', trim: true, uppercase: true })
+  currency!: string;
+
+  @Prop({
+    type: String,
+    enum: ['lead', 'contacted', 'proposal', 'won', 'lost'],
+    default: 'lead',
+  })
+  stage!: 'lead' | 'contacted' | 'proposal' | 'won' | 'lost';
+
+  @Prop({ type: Date })
+  expectedCloseDate!: Date;
+
+  @Prop({ trim: true })
+  notes!: string;
+}
+
+export const DealSchema = SchemaFactory.createForClass(Deal);
+
+DealSchema.index({ workspaceId: 1, stage: 1 });
+DealSchema.index({ workspaceId: 1, clientId: 1 });
+DealSchema.index({ workspaceId: 1, createdAt: -1 });

package/templates/backend/src/modules/planner/dto/create-planner-block.dto.ts

@@ -0,0 +1,66 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsArray, IsBoolean, IsEnum, IsInt, IsOptional, IsString, Matches, MaxLength, Min } from 'class-validator';
+
+export class CreatePlannerBlockDto {
+  @ApiProperty({ example: '2026-06-15', description: 'Fecha en formato YYYY-MM-DD' })
+  @IsString({ message: 'La fecha debe ser un texto' })
+  @Matches(/^\d{4}-\d{2}-\d{2}$/, { message: 'La fecha debe tener el formato YYYY-MM-DD' })
+  date!: string;
+
+  @ApiProperty({ example: '09:00', description: 'Hora de inicio en formato HH:mm' })
+  @IsString({ message: 'La hora de inicio debe ser un texto' })
+  @Matches(/^\d{2}:\d{2}$/, { message: 'La hora de inicio debe tener el formato HH:mm' })
+  startTime!: string;
+
+  @ApiProperty({ example: '10:30', description: 'Hora de fin en formato HH:mm' })
+  @IsString({ message: 'La hora de fin debe ser un texto' })
+  @Matches(/^\d{2}:\d{2}$/, { message: 'La hora de fin debe tener el formato HH:mm' })
+  endTime!: string;
+
+  @ApiProperty({ example: 'Reunión con cliente', 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;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'La descripción debe ser un texto' })
+  description?: string;
+
+  @ApiPropertyOptional({ example: 'work', default: 'work' })
+  @IsOptional()
+  @IsString({ message: 'La categoría debe ser un texto' })
+  category?: string;
+
+  @ApiPropertyOptional({ enum: ['low', 'medium', 'high'], default: 'medium' })
+  @IsOptional()
+  @IsEnum(['low', 'medium', 'high'], { message: 'La prioridad no es válida' })
+  priority?: 'low' | 'medium' | 'high';
+
+  @ApiPropertyOptional({ enum: ['pending', 'in-progress', 'completed', 'skipped'], default: 'pending' })
+  @IsOptional()
+  @IsEnum(['pending', 'in-progress', 'completed', 'skipped'], { message: 'El estado no es válido' })
+  status?: 'pending' | 'in-progress' | 'completed' | 'skipped';
+
+  @ApiPropertyOptional({ example: '#2563EB' })
+  @IsOptional()
+  @IsString({ message: 'El color debe ser un texto' })
+  color?: string;
+
+  @ApiPropertyOptional({ default: false })
+  @IsOptional()
+  @IsBoolean({ message: 'isFocusBlock debe ser un booleano' })
+  isFocusBlock?: boolean;
+
+  @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: [String] })
+  @IsOptional()
+  @IsArray({ message: 'Los tags deben ser un array' })
+  @IsString({ each: true, message: 'Cada tag debe ser un texto' })
+  tags?: string[];
+}

package/templates/backend/src/modules/planner/dto/query-planner-block.dto.ts

@@ -0,0 +1,48 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, IsString, Matches, Max, Min } from 'class-validator';
+
+export class QueryPlannerBlockDto {
+  @ApiPropertyOptional({ example: '2026-06-15', description: 'Fecha exacta YYYY-MM-DD' })
+  @IsOptional()
+  @IsString({ message: 'La fecha debe ser un texto' })
+  @Matches(/^\d{4}-\d{2}-\d{2}$/, { message: 'La fecha debe tener el formato YYYY-MM-DD' })
+  date?: string;
+
+  @ApiPropertyOptional({ example: '2026-06-01' })
+  @IsOptional()
+  @IsString({ message: 'La fecha desde debe ser un texto' })
+  @Matches(/^\d{4}-\d{2}-\d{2}$/, { message: 'La fecha desde debe tener el formato YYYY-MM-DD' })
+  dateFrom?: string;
+
+  @ApiPropertyOptional({ example: '2026-06-30' })
+  @IsOptional()
+  @IsString({ message: 'La fecha hasta debe ser un texto' })
+  @Matches(/^\d{4}-\d{2}-\d{2}$/, { message: 'La fecha hasta debe tener el formato YYYY-MM-DD' })
+  dateTo?: string;
+
+  @ApiPropertyOptional({ enum: ['pending', 'in-progress', 'completed', 'skipped'] })
+  @IsOptional()
+  @IsEnum(['pending', 'in-progress', 'completed', 'skipped'], { message: 'El estado no es válido' })
+  status?: 'pending' | 'in-progress' | 'completed' | 'skipped';
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'La categoría debe ser un texto' })
+  category?: 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: 50, 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 = 50;
+}

package/templates/backend/src/modules/planner/dto/update-block-status.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnum } from 'class-validator';
+
+export class UpdateBlockStatusDto {
+  @ApiProperty({ enum: ['pending', 'in-progress', 'completed', 'skipped'] })
+  @IsEnum(['pending', 'in-progress', 'completed', 'skipped'], {
+    message: 'El estado debe ser "pending", "in-progress", "completed" o "skipped"',
+  })
+  status!: 'pending' | 'in-progress' | 'completed' | 'skipped';
+}

package/templates/backend/src/modules/planner/dto/update-planner-block.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreatePlannerBlockDto } from './create-planner-block.dto';
+
+export class UpdatePlannerBlockDto extends PartialType(CreatePlannerBlockDto) {}

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

@@ -0,0 +1,124 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiQuery,
+  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 { 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 { PlannerService } from './planner.service';
+
+@ApiTags('Planner Blocks')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('planner-blocks')
+export class PlannerController {
+  constructor(private readonly plannerService: PlannerService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Listar bloques del planner (por fecha, rango, estado)' })
+  @ApiResponse({ status: 200, description: 'Lista de bloques' })
+  findAll(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Query() query: QueryPlannerBlockDto,
+  ) {
+    return this.plannerService.findAll(workspaceId, user.userId, query);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Obtener un bloque por ID' })
+  @ApiResponse({ status: 200, description: 'Bloque encontrado' })
+  @ApiResponse({ status: 404, description: 'Bloque no encontrado' })
+  findOne(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Param('id') id: string,
+  ) {
+    return this.plannerService.findOne(workspaceId, user.userId, id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Crear un nuevo bloque' })
+  @ApiResponse({ status: 201, description: 'Bloque creado' })
+  create(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Body() dto: CreatePlannerBlockDto,
+  ) {
+    return this.plannerService.create(workspaceId, user.userId, dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Actualizar un bloque' })
+  @ApiResponse({ status: 200, description: 'Bloque actualizado' })
+  @ApiResponse({ status: 404, description: 'Bloque no encontrado' })
+  update(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Param('id') id: string,
+    @Body() dto: UpdatePlannerBlockDto,
+  ) {
+    return this.plannerService.update(workspaceId, user.userId, id, dto);
+  }
+
+  @Patch(':id/status')
+  @ApiOperation({ summary: 'Actualizar solo el estado de un bloque' })
+  @ApiResponse({ status: 200, description: 'Estado actualizado' })
+  @ApiResponse({ status: 404, description: 'Bloque no encontrado' })
+  updateStatus(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Param('id') id: string,
+    @Body() dto: UpdateBlockStatusDto,
+  ) {
+    return this.plannerService.updateStatus(workspaceId, user.userId, id, dto);
+  }
+
+  @Post(':id/duplicate')
+  @ApiOperation({ summary: 'Duplicar un bloque (opcionalmente en otra fecha)' })
+  @ApiQuery({ name: 'targetDate', required: false, example: '2026-06-16' })
+  @ApiResponse({ status: 201, description: 'Bloque duplicado' })
+  @ApiResponse({ status: 404, description: 'Bloque no encontrado' })
+  duplicate(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Param('id') id: string,
+    @Query('targetDate') targetDate?: string,
+  ) {
+    return this.plannerService.duplicate(workspaceId, user.userId, id, targetDate);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Eliminar un bloque (soft delete)' })
+  @ApiResponse({ status: 204, description: 'Bloque eliminado' })
+  @ApiResponse({ status: 404, description: 'Bloque no encontrado' })
+  remove(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Param('id') id: string,
+  ) {
+    return this.plannerService.remove(workspaceId, user.userId, id);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { PlannerBlock, PlannerBlockSchema } from './schemas/planner-block.schema';
+import { PlannerController } from './planner.controller';
+import { PlannerRepository } from './planner.repository';
+import { PlannerService } from './planner.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: PlannerBlock.name, schema: PlannerBlockSchema }]),
+  ],
+  controllers: [PlannerController],
+  providers: [PlannerService, PlannerRepository],
+  exports: [PlannerService],
+})
+export class PlannerModule {}

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

@@ -0,0 +1,45 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BaseRepository } from '../../common/base/base.repository';
+import { PlannerBlock, PlannerBlockDocument } from './schemas/planner-block.schema';
+
+@Injectable()
+export class PlannerRepository extends BaseRepository<PlannerBlockDocument> {
+  constructor(
+    @InjectModel(PlannerBlock.name)
+    private readonly plannerBlockModel: Model<PlannerBlockDocument>,
+  ) {
+    super(plannerBlockModel);
+  }
+
+  async findByDate(
+    workspaceId: string,
+    userId: string,
+    date: string,
+  ): Promise<PlannerBlockDocument[]> {
+    return this.plannerBlockModel
+      .find({ workspaceId, userId, date, deletedAt: null })
+      .sort({ order: 1 })
+      .lean()
+      .exec() as unknown as PlannerBlockDocument[];
+  }
+
+  async findByDateRange(
+    workspaceId: string,
+    userId: string,
+    dateFrom: string,
+    dateTo: string,
+  ): Promise<PlannerBlockDocument[]> {
+    return this.plannerBlockModel
+      .find({
+        workspaceId,
+        userId,
+        date: { $gte: dateFrom, $lte: dateTo },
+        deletedAt: null,
+      })
+      .sort({ date: 1, order: 1 })
+      .lean()
+      .exec() as unknown as PlannerBlockDocument[];
+  }
+}