// ==========================================
// TIME-OFF ENUMS
// ==========================================

enum LeaveType {
  VACATION
  SICK
  PERSONAL
  PARENTAL
  MATERNITY
  PATERNITY
  BEREAVEMENT
  UNPAID
  COMPENSATORY
  OTHER
}

cd packages/database
npx prisma format
# Should complete without errors

cat prisma/schema.prisma | grep -A 15 "enum LeaveType"
# Should show all enum values

# Remove the enum block from schema.prisma

packages/database/prisma/schema.prisma (LeaveType enum)

enum AccrualType {
  ANNUAL
  MONTHLY
  DAILY
  NONE
}

cd packages/database
npx prisma format
cat prisma/schema.prisma | grep -A 6 "enum AccrualType"

# Remove AccrualType enum block

packages/database/prisma/schema.prisma (AccrualType enum)

enum RequestStatus {
  PENDING
  APPROVED
  REJECTED
  CANCELLED
  EXPIRED
}

cd packages/database
npx prisma format
cat prisma/schema.prisma | grep -A 7 "enum RequestStatus"

# Remove RequestStatus enum block

packages/database/prisma/schema.prisma (RequestStatus enum)

enum PolicyStatus {
  ACTIVE
  INACTIVE
  ARCHIVED
}

enum HalfDayPart {
  MORNING
  AFTERNOON
}

cd packages/database
npx prisma format
cat prisma/schema.prisma | grep -E "enum (PolicyStatus|HalfDayPart)" -A 5

# Remove both enum blocks

packages/database/prisma/schema.prisma (PolicyStatus, HalfDayPart enums)

// ==========================================
// TIME-OFF MODELS
// ==========================================

model TimeOffPolicy {
  id              String       @id @default(cuid())
  tenantId        String
  name            String       // e.g., "Annual Vacation"
  code            String?      // e.g., "VACATION", "SICK"
  description     String?
  leaveType       LeaveType
  accrualType     AccrualType  @default(ANNUAL)
  annualAllowance Float        @default(0)    // days per year
  carryOverLimit  Float        @default(0)    // max days to carry over
  carryOverExpiry Int?         // months before carry-over expires
  requiresApproval Boolean     @default(true)
  autoApproveRules Json?       // conditions for automatic approval
  appliesTo       Json         @default("{}")  // employee filters
  status          PolicyStatus @default(ACTIVE)
  createdAt       DateTime     @default(now())
  updatedAt       DateTime     @updatedAt

  // Relations added in Step 79 after all models are defined

  @@unique([tenantId, code])
  @@map("time_off_policies")
}

# Just verify the model was added - NO prisma format yet
cat packages/database/prisma/schema.prisma | grep -A 5 "model TimeOffPolicy"

# Remove TimeOffPolicy model and Tenant relation

packages/database/prisma/schema.prisma (TimeOffPolicy model)

model TimeOffBalance {
  id         String   @id @default(cuid())
  tenantId   String
  employeeId String
  policyId   String
  year       Int      // fiscal year
  entitled   Float    @default(0)    // total allocated days
  used       Float    @default(0)    // approved days taken
  pending    Float    @default(0)    // pending request days
  carryOver  Float    @default(0)    // days from previous year
  adjustment Float    @default(0)    // admin adjustments
  createdAt  DateTime @default(now())
  updatedAt  DateTime @updatedAt

  // Relations added in Step 79 after all models are defined

  @@unique([employeeId, policyId, year])
  @@map("time_off_balances")
}

# Just verify the model was added - NO prisma format yet
cat packages/database/prisma/schema.prisma | grep -A 5 "model TimeOffBalance"

# Remove TimeOffBalance model

packages/database/prisma/schema.prisma (TimeOffBalance model)

model TimeOffRequest {
  id              String        @id @default(cuid())
  tenantId        String
  employeeId      String
  policyId        String
  startDate       DateTime
  endDate         DateTime
  days            Float         // business days calculated
  halfDay         Boolean       @default(false)
  halfDayPart     HalfDayPart?  // MORNING or AFTERNOON
  status          RequestStatus @default(PENDING)
  reason          String?       // optional notes
  approverId      String?       // manager who approved/rejected
  approvedAt      DateTime?
  approverComment String?
  createdAt       DateTime      @default(now())
  updatedAt       DateTime      @updatedAt

  tenant   Tenant        @relation(fields: [tenantId], references: [id], onDelete: Cascade)
  employee Employee      @relation(fields: [employeeId], references: [id], onDelete: Cascade)
  policy   TimeOffPolicy @relation(fields: [policyId], references: [id])

  @@index([tenantId, status])
  @@index([tenantId, employeeId, status])  // For "my requests" queries
  @@map("time_off_requests")
}

// Add these lines inside the TimeOffPolicy model:
  tenant   Tenant             @relation(fields: [tenantId], references: [id], onDelete: Cascade)
  requests TimeOffRequest[]
  balances TimeOffBalance[]

// Add these lines inside the TimeOffBalance model:
  tenant   Tenant        @relation(fields: [tenantId], references: [id], onDelete: Cascade)
  employee Employee      @relation(fields: [employeeId], references: [id], onDelete: Cascade)
  policy   TimeOffPolicy @relation(fields: [policyId], references: [id])

// In the Tenant model, add:
timeOffPolicies  TimeOffPolicy[]
timeOffBalances  TimeOffBalance[]
timeOffRequests  TimeOffRequest[]

// In the Employee model, add:
timeOffBalances TimeOffBalance[]
timeOffRequests TimeOffRequest[]

cd packages/database
npx prisma format
# Should complete without errors - all relations now exist

# Remove all time-off models and their relations from Tenant/Employee

packages/database/prisma/schema.prisma (all time-off models)

cd packages/database

# Push schema changes to database
npx prisma db push

# Verify tables exist
npx prisma studio
# Check for: time_off_policies, time_off_balances, time_off_requests tables

npx prisma db push
# Should complete without errors

# Verify in psql or Prisma Studio:
# - time_off_policies table exists
# - time_off_balances table exists
# - time_off_requests table exists
# - All enums created (LeaveType, AccrualType, RequestStatus, PolicyStatus, HalfDayPart)

# In development: prisma db push --force-reset
# In production: Create down migration

packages/database/prisma/schema.prisma (all time-off models - LOCKED)

mkdir -p apps/api/src/time-off/repositories
mkdir -p apps/api/src/time-off/services
mkdir -p apps/api/src/time-off/controllers
mkdir -p apps/api/src/time-off/dto

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../../prisma/prisma.service';
import { Prisma, PolicyStatus } from '@prisma/client';

@Injectable()
export class TimeOffPolicyRepository {
  constructor(private prisma: PrismaService) {}

  async findAll(tenantId: string, options?: { status?: PolicyStatus }) {
    const where: Prisma.TimeOffPolicyWhereInput = {
      tenantId,
    };

    if (options?.status) {
      where.status = options.status;
    }

    return this.prisma.timeOffPolicy.findMany({
      where,
      orderBy: { name: 'asc' },
    });
  }

  async findById(tenantId: string, id: string) {
    return this.prisma.timeOffPolicy.findFirst({
      where: { id, tenantId },
    });
  }

  async findByCode(tenantId: string, code: string) {
    return this.prisma.timeOffPolicy.findFirst({
      where: { tenantId, code },
    });
  }

  async create(data: Prisma.TimeOffPolicyCreateInput) {
    return this.prisma.timeOffPolicy.create({ data });
  }

  async update(tenantId: string, id: string, data: Prisma.TimeOffPolicyUpdateInput) {
    return this.prisma.timeOffPolicy.updateMany({
      where: { id, tenantId },
      data,
    });
  }

  async delete(tenantId: string, id: string) {
    // Soft delete by setting status to ARCHIVED
    return this.prisma.timeOffPolicy.updateMany({
      where: { id, tenantId },
      data: { status: 'ARCHIVED' },
    });
  }

  async getActivePolicies(tenantId: string) {
    return this.prisma.timeOffPolicy.findMany({
      where: {
        tenantId,
        status: 'ACTIVE',
      },
      orderBy: { name: 'asc' },
    });
  }
}

cd apps/api
npm run build
# Should compile without errors

rm apps/api/src/time-off/repositories/time-off-policy.repository.ts

apps/api/src/time-off/repositories/time-off-policy.repository.ts

import { Injectable, NotFoundException, ConflictException } from '@nestjs/common';
import { TimeOffPolicyRepository } from '../repositories/time-off-policy.repository';
import { CreateTimeOffPolicyDto } from '../dto/create-time-off-policy.dto';
import { UpdateTimeOffPolicyDto } from '../dto/update-time-off-policy.dto';
import { PolicyStatus } from '@prisma/client';

@Injectable()
export class TimeOffPolicyService {
  constructor(private policyRepository: TimeOffPolicyRepository) {}

  async findAll(tenantId: string, status?: PolicyStatus) {
    return this.policyRepository.findAll(tenantId, { status });
  }

  async findById(tenantId: string, id: string) {
    const policy = await this.policyRepository.findById(tenantId, id);
    if (!policy) {
      throw new NotFoundException(`Policy with ID ${id} not found`);
    }
    return policy;
  }

  async getActivePolicies(tenantId: string) {
    return this.policyRepository.getActivePolicies(tenantId);
  }

  async create(tenantId: string, dto: CreateTimeOffPolicyDto) {
    // Check for duplicate code
    if (dto.code) {
      const existing = await this.policyRepository.findByCode(tenantId, dto.code);
      if (existing) {
        throw new ConflictException(`Policy with code ${dto.code} already exists`);
      }
    }

    return this.policyRepository.create({
      tenant: { connect: { id: tenantId } },
      name: dto.name,
      code: dto.code,
      description: dto.description,
      leaveType: dto.leaveType,
      accrualType: dto.accrualType,
      annualAllowance: dto.annualAllowance,
      carryOverLimit: dto.carryOverLimit,
      carryOverExpiry: dto.carryOverExpiry,
      requiresApproval: dto.requiresApproval,
      appliesTo: dto.appliesTo || {},
    });
  }

  async update(tenantId: string, id: string, dto: UpdateTimeOffPolicyDto) {
    await this.findById(tenantId, id); // Verify exists

    // Check code uniqueness if changing
    if (dto.code) {
      const existing = await this.policyRepository.findByCode(tenantId, dto.code);
      if (existing && existing.id !== id) {
        throw new ConflictException(`Policy with code ${dto.code} already exists`);
      }
    }

    await this.policyRepository.update(tenantId, id, dto);
    return this.findById(tenantId, id);
  }

  async archive(tenantId: string, id: string) {
    await this.findById(tenantId, id);
    await this.policyRepository.delete(tenantId, id);
    return { success: true };
  }
}

import { IsString, IsOptional, IsEnum, IsNumber, IsBoolean, Min } from 'class-validator';
import { LeaveType, AccrualType } from '@prisma/client';

export class CreateTimeOffPolicyDto {
  @IsString()
  name: string;

  @IsOptional()
  @IsString()
  code?: string;

  @IsOptional()
  @IsString()
  description?: string;

  @IsEnum(LeaveType)
  leaveType: LeaveType;

  @IsOptional()
  @IsEnum(AccrualType)
  accrualType?: AccrualType;

  @IsOptional()
  @IsNumber()
  @Min(0)
  annualAllowance?: number;

  @IsOptional()
  @IsNumber()
  @Min(0)
  carryOverLimit?: number;

  @IsOptional()
  @IsNumber()
  carryOverExpiry?: number;

  @IsOptional()
  @IsBoolean()
  requiresApproval?: boolean;

  @IsOptional()
  appliesTo?: Record<string, unknown>;
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateTimeOffPolicyDto } from './create-time-off-policy.dto';
import { IsEnum, IsOptional } from 'class-validator';
import { PolicyStatus } from '@prisma/client';

export class UpdateTimeOffPolicyDto extends PartialType(CreateTimeOffPolicyDto) {
  @IsOptional()
  @IsEnum(PolicyStatus)
  status?: PolicyStatus;
}

cd apps/api
npm run build

rm apps/api/src/time-off/services/time-off-policy.service.ts
rm apps/api/src/time-off/dto/create-time-off-policy.dto.ts
rm apps/api/src/time-off/dto/update-time-off-policy.dto.ts

apps/api/src/time-off/services/time-off-policy.service.ts
apps/api/src/time-off/dto/create-time-off-policy.dto.ts
apps/api/src/time-off/dto/update-time-off-policy.dto.ts

import {
  Controller,
  Get,
  Post,
  Put,
  Delete,
  Body,
  Param,
  Query,
  UseGuards,
} from '@nestjs/common';
import { TimeOffPolicyService } from '../services/time-off-policy.service';
import { CreateTimeOffPolicyDto } from '../dto/create-time-off-policy.dto';
import { UpdateTimeOffPolicyDto } from '../dto/update-time-off-policy.dto';
import { TenantGuard } from '../../tenant/tenant.guard';
import { SystemRoleGuard } from '../../auth/system-role.guard';
import { RequireRoles } from '../../auth/require-roles.decorator';
import { TenantId } from '../../tenant/tenant.decorator';
import { PolicyStatus } from '@prisma/client';

@Controller('api/v1/timeoff/policies')
@UseGuards(TenantGuard)
export class TimeOffPolicyController {
  constructor(private policyService: TimeOffPolicyService) {}

  @Get()
  async findAll(
    @TenantId() tenantId: string,
    @Query('status') status?: PolicyStatus,
  ) {
    const policies = await this.policyService.findAll(tenantId, status);
    return { data: policies, error: null };
  }

  @Get('active')
  async getActive(@TenantId() tenantId: string) {
    const policies = await this.policyService.getActivePolicies(tenantId);
    return { data: policies, error: null };
  }

  @Get(':id')
  async findOne(@TenantId() tenantId: string, @Param('id') id: string) {
    const policy = await this.policyService.findById(tenantId, id);
    return { data: policy, error: null };
  }

  @Post()
  @UseGuards(SystemRoleGuard)
  @RequireRoles('SYSTEM_ADMIN', 'HR_ADMIN')
  async create(
    @TenantId() tenantId: string,
    @Body() dto: CreateTimeOffPolicyDto,
  ) {
    const policy = await this.policyService.create(tenantId, dto);
    return { data: policy, error: null };
  }

  @Put(':id')
  @UseGuards(SystemRoleGuard)
  @RequireRoles('SYSTEM_ADMIN', 'HR_ADMIN')
  async update(
    @TenantId() tenantId: string,
    @Param('id') id: string,
    @Body() dto: UpdateTimeOffPolicyDto,
  ) {
    const policy = await this.policyService.update(tenantId, id, dto);
    return { data: policy, error: null };
  }

  @Delete(':id')
  @UseGuards(SystemRoleGuard)
  @RequireRoles('SYSTEM_ADMIN', 'HR_ADMIN')
  async archive(@TenantId() tenantId: string, @Param('id') id: string) {
    await this.policyService.archive(tenantId, id);
    return { data: { success: true }, error: null };
  }
}

cd apps/api
npm run build

rm apps/api/src/time-off/controllers/time-off-policy.controller.ts

apps/api/src/time-off/controllers/time-off-policy.controller.ts

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../../prisma/prisma.service';
import { Prisma } from '@prisma/client';

@Injectable()
export class TimeOffBalanceRepository {
  constructor(private prisma: PrismaService) {}

  async findByEmployeeAndYear(tenantId: string, employeeId: string, year: number) {
    return this.prisma.timeOffBalance.findMany({
      where: { tenantId, employeeId, year },
      include: { policy: true },
    });
  }

  async findByEmployeePolicyYear(tenantId: string, employeeId: string, policyId: string, year: number) {
    return this.prisma.timeOffBalance.findFirst({
      where: {
        tenantId,
        employeeId,
        policyId,
        year,
      },
    });
  }

  async upsert(data: {
    tenantId: string;
    employeeId: string;
    policyId: string;
    year: number;
    entitled?: number;
    used?: number;
    pending?: number;
    carryOver?: number;
    adjustment?: number;
  }) {
    const { tenantId, employeeId, policyId, year, ...updateData } = data;

    return this.prisma.timeOffBalance.upsert({
      where: {
        employeeId_policyId_year: { employeeId, policyId, year },
      },
      create: {
        tenantId,
        employeeId,
        policyId,
        year,
        entitled: updateData.entitled ?? 0,
        used: updateData.used ?? 0,
        pending: updateData.pending ?? 0,
        carryOver: updateData.carryOver ?? 0,
        adjustment: updateData.adjustment ?? 0,
      },
      update: updateData,
    });
  }

  async incrementUsed(employeeId: string, policyId: string, year: number, days: number) {
    return this.prisma.timeOffBalance.update({
      where: {
        employeeId_policyId_year: { employeeId, policyId, year },
      },
      data: {
        used: { increment: days },
        pending: { decrement: days },
      },
    });
  }

  async incrementPending(employeeId: string, policyId: string, year: number, days: number) {
    return this.prisma.timeOffBalance.update({
      where: {
        employeeId_policyId_year: { employeeId, policyId, year },
      },
      data: {
        pending: { increment: days },
      },
    });
  }

  async decrementPending(employeeId: string, policyId: string, year: number, days: number) {
    return this.prisma.timeOffBalance.update({
      where: {
        employeeId_policyId_year: { employeeId, policyId, year },
      },
      data: {
        pending: { decrement: days },
      },
    });
  }
}

import { Injectable, NotFoundException } from '@nestjs/common';
import { TimeOffBalanceRepository } from '../repositories/time-off-balance.repository';
import { TimeOffPolicyRepository } from '../repositories/time-off-policy.repository';

export interface BalanceWithAvailable {
  id: string;
  policyId: string;
  policyName: string;
  policyCode: string | null;
  year: number;
  entitled: number;
  used: number;
  pending: number;
  carryOver: number;
  adjustment: number;
  available: number; // calculated
}

@Injectable()
export class TimeOffBalanceService {
  constructor(
    private balanceRepository: TimeOffBalanceRepository,
    private policyRepository: TimeOffPolicyRepository,
  ) {}

  async getEmployeeBalances(
    tenantId: string,
    employeeId: string,
    year?: number,
  ): Promise<BalanceWithAvailable[]> {
    const targetYear = year || new Date().getFullYear();
    const balances = await this.balanceRepository.findByEmployeeAndYear(
      tenantId,
      employeeId,
      targetYear,
    );

    return balances.map((balance) => ({
      id: balance.id,
      policyId: balance.policyId,
      policyName: balance.policy.name,
      policyCode: balance.policy.code,
      year: balance.year,
      entitled: balance.entitled,
      used: balance.used,
      pending: balance.pending,
      carryOver: balance.carryOver,
      adjustment: balance.adjustment,
      available: this.calculateAvailable(balance),
    }));
  }

  calculateAvailable(balance: {
    entitled: number;
    used: number;
    pending: number;
    carryOver: number;
    adjustment: number;
  }): number {
    // Available = Entitled + CarryOver - Used - Pending + Adjustment
    return (
      balance.entitled +
      balance.carryOver -
      balance.used -
      balance.pending +
      balance.adjustment
    );
  }

  async ensureBalanceExists(
    tenantId: string,
    employeeId: string,
    policyId: string,
    year: number,
  ) {
    const existing = await this.balanceRepository.findByEmployeePolicyYear(
      tenantId,
      employeeId,
      policyId,
      year,
    );

    if (!existing) {
      // Get policy to set initial entitlement
      const policy = await this.policyRepository.findById(tenantId, policyId);
      if (!policy) {
        throw new NotFoundException(`Policy ${policyId} not found`);
      }

      await this.balanceRepository.upsert({
        tenantId,
        employeeId,
        policyId,
        year,
        entitled: policy.annualAllowance,
      });
    }
  }

  async adjustBalance(
    tenantId: string,
    employeeId: string,
    policyId: string,
    year: number,
    adjustment: number,
    reason?: string,
  ) {
    await this.ensureBalanceExists(tenantId, employeeId, policyId, year);

    return this.balanceRepository.upsert({
      tenantId,
      employeeId,
      policyId,
      year,
      adjustment,
    });
  }
}

cd apps/api
npm run build

rm apps/api/src/time-off/repositories/time-off-balance.repository.ts
rm apps/api/src/time-off/services/time-off-balance.service.ts

apps/api/src/time-off/repositories/time-off-balance.repository.ts
apps/api/src/time-off/services/time-off-balance.service.ts

import { Injectable } from '@nestjs/common';
import { PrismaService } from '../../prisma/prisma.service';
import { Prisma, RequestStatus } from '@prisma/client';

@Injectable()
export class TimeOffRequestRepository {
  constructor(private prisma: PrismaService) {}

  // findAll: Uses STRICT CONTAINMENT semantics
  // - Request must START on/after startDate AND END on/before endDate
  // - Use for: "My requests this month" list view
  // - Compare with getCalendarData which uses OVERLAP semantics
  async findAll(
    tenantId: string,
    options?: {
      employeeId?: string;
      status?: RequestStatus;
      startDate?: Date;
      endDate?: Date;
    },
  ) {
    const where: Prisma.TimeOffRequestWhereInput = { tenantId };

    if (options?.employeeId) {
      where.employeeId = options.employeeId;
    }
    if (options?.status) {
      where.status = options.status;
    }
    // Strict containment: request must be entirely within the date range
    if (options?.startDate || options?.endDate) {
      where.startDate = {};
      if (options.startDate) {
        where.startDate.gte = options.startDate;
      }
      if (options.endDate) {
        where.endDate = { lte: options.endDate };
      }
    }

    return this.prisma.timeOffRequest.findMany({
      where,
      include: {
        employee: {
          select: {
            id: true,
            firstName: true,
            lastName: true,
            email: true,
            pictureUrl: true,
          },
        },
        policy: {
          select: {
            id: true,
            name: true,
            code: true,
            leaveType: true,
          },
        },
      },
      orderBy: { createdAt: 'desc' },
    });
  }

  async findById(tenantId: string, id: string) {
    return this.prisma.timeOffRequest.findFirst({
      where: { id, tenantId },
      include: {
        employee: {
          select: {
            id: true,
            firstName: true,
            lastName: true,
            email: true,
            pictureUrl: true,
            orgRelations: {
              select: { primaryManagerId: true },
            },
          },
        },
        policy: true,
      },
    });
  }

  async findPendingForManager(tenantId: string, managerId: string) {
    return this.prisma.timeOffRequest.findMany({
      where: {
        tenantId,
        status: 'PENDING',
        employee: {
          orgRelations: {
            primaryManagerId: managerId,
          },
        },
      },
      include: {
        employee: {
          select: {
            id: true,
            firstName: true,
            lastName: true,
            pictureUrl: true,
          },
        },
        policy: {
          select: {
            id: true,
            name: true,
            code: true,
          },
        },
      },
      orderBy: { createdAt: 'asc' },
    });
  }

  async create(data: Prisma.TimeOffRequestUncheckedCreateInput) {
    return this.prisma.timeOffRequest.create({
      data,
      include: {
        employee: true,
        policy: true,
      },
    });
  }

  async updateStatus(
    tenantId: string,
    id: string,
    status: RequestStatus,
    approverId?: string,
    approverComment?: string,
  ) {
    return this.prisma.timeOffRequest.updateMany({
      where: { id, tenantId },
      data: {
        status,
        approverId,
        approverComment,
        approvedAt: status === 'APPROVED' || status === 'REJECTED' ? new Date() : undefined,
      },
    });
  }

  async checkOverlap(
    employeeId: string,
    startDate: Date,
    endDate: Date,
    excludeRequestId?: string,
  ) {
    const where: Prisma.TimeOffRequestWhereInput = {
      employeeId,
      status: { in: ['PENDING', 'APPROVED'] },
      OR: [
        {
          startDate: { lte: endDate },
          endDate: { gte: startDate },
        },
      ],
    };

    if (excludeRequestId) {
      where.id = { not: excludeRequestId };
    }

    return this.prisma.timeOffRequest.findFirst({ where });
  }

  // getCalendarData: Uses OVERLAP semantics
  // - Returns any request that OVERLAPS with the date range
  // - startDate <= range.endDate AND endDate >= range.startDate
  // - Use for: Team calendar view showing who's off during a period
  // - Compare with findAll which uses STRICT CONTAINMENT semantics
  async getCalendarData(
    tenantId: string,
    startDate: Date,
    endDate: Date,
    options?: {
      departmentId?: string;
      teamId?: string;
    },
  ) {
    // Overlap condition: request touches any part of the date range
    const where: Prisma.TimeOffRequestWhereInput = {
      tenantId,
      status: 'APPROVED',
      startDate: { lte: endDate },   // Request starts before range ends
      endDate: { gte: startDate },   // Request ends after range starts
    };

    if (options?.departmentId) {
      where.employee = {
        orgRelations: {
          departments: {
            some: {
              departmentId: options.departmentId,
              isPrimary: true,
            },
          },
        },
      };
    }

    return this.prisma.timeOffRequest.findMany({
      where,
      include: {
        employee: {
          select: {
            id: true,
            firstName: true,
            lastName: true,
            pictureUrl: true,
          },
        },
        policy: {
          select: {
            name: true,
            code: true,
            leaveType: true,
          },
        },
      },
      orderBy: { startDate: 'asc' },
    });
  }
}

cd apps/api
npm run build

rm apps/api/src/time-off/repositories/time-off-request.repository.ts

apps/api/src/time-off/repositories/time-off-request.repository.ts

import { IsString, IsDateString, IsOptional, IsBoolean, IsEnum } from 'class-validator';
import { HalfDayPart } from '@prisma/client';

export class CreateTimeOffRequestDto {
  @IsString()
  policyId: string;

  @IsDateString()
  startDate: string;

  @IsDateString()
  endDate: string;

  @IsOptional()
  @IsBoolean()
  halfDay?: boolean;

  @IsOptional()
  @IsEnum(HalfDayPart)
  halfDayPart?: HalfDayPart;

  @IsOptional()
  @IsString()
  reason?: string;
}

import { IsString, IsOptional, IsEnum } from 'class-validator';
import { RequestStatus } from '@prisma/client';

export class ApproveRequestDto {
  @IsEnum(RequestStatus)
  status: 'APPROVED' | 'REJECTED';

  @IsOptional()
  @IsString()
  comment?: string;
}

import {
  Injectable,
  NotFoundException,
  BadRequestException,
  ForbiddenException,
} from '@nestjs/common';
import { TimeOffRequestRepository } from '../repositories/time-off-request.repository';
import { TimeOffBalanceRepository } from '../repositories/time-off-balance.repository';
import { TimeOffBalanceService } from './time-off-balance.service';
import { TimeOffPolicyService } from './time-off-policy.service';
import { CreateTimeOffRequestDto } from '../dto/create-time-off-request.dto';
import { ApproveRequestDto } from '../dto/approve-request.dto';
import { PrismaService } from '../../prisma/prisma.service';

@Injectable()
export class TimeOffRequestService {
  constructor(
    private prisma: PrismaService,
    private requestRepository: TimeOffRequestRepository,
    private balanceRepository: TimeOffBalanceRepository,
    private balanceService: TimeOffBalanceService,
  ) {}

  async findAll(
    tenantId: string,
    options?: {
      employeeId?: string;
      status?: 'PENDING' | 'APPROVED' | 'REJECTED' | 'CANCELLED';
    },
  ) {
    return this.requestRepository.findAll(tenantId, options);
  }

  async findById(tenantId: string, id: string) {
    const request = await this.requestRepository.findById(tenantId, id);
    if (!request) {
      throw new NotFoundException(`Request ${id} not found`);
    }
    return request;
  }

  async getPendingForManager(tenantId: string, managerId: string) {
    return this.requestRepository.findPendingForManager(tenantId, managerId);
  }

  async submit(tenantId: string, employeeId: string, dto: CreateTimeOffRequestDto) {
    const startDate = new Date(dto.startDate);
    const endDate = new Date(dto.endDate);
    const year = startDate.getFullYear();

    // Validate dates
    if (endDate < startDate) {
      throw new BadRequestException('End date must be after start date');
    }

    // Calculate business days
    const days = dto.halfDay ? 0.5 : this.calculateBusinessDays(startDate, endDate);

    // Check for overlapping requests
    const overlap = await this.requestRepository.checkOverlap(employeeId, startDate, endDate);
    if (overlap) {
      throw new BadRequestException('You already have a request for these dates');
    }

    // Ensure balance exists and check available
    await this.balanceService.ensureBalanceExists(tenantId, employeeId, dto.policyId, year);
    const balances = await this.balanceService.getEmployeeBalances(tenantId, employeeId, year);
    const balance = balances.find((b) => b.policyId === dto.policyId);

    if (!balance || balance.available < days) {
      throw new BadRequestException(
        `Insufficient balance. Available: ${balance?.available ?? 0} days, Requested: ${days} days`,
      );
    }

    // Create request
    const request = await this.requestRepository.create({
      tenantId,
      employeeId,
      policyId: dto.policyId,
      startDate,
      endDate,
      days,
      halfDay: dto.halfDay || false,
      halfDayPart: dto.halfDayPart,
      reason: dto.reason,
      status: 'PENDING',
    });

    // Update pending balance
    await this.balanceRepository.incrementPending(employeeId, dto.policyId, year, days);

    return request;
  }

  async approve(
    tenantId: string,
    requestId: string,
    approverId: string,
    dto: ApproveRequestDto,
  ) {
    const request = await this.findById(tenantId, requestId);

    // Cannot approve own request
    if (request.employeeId === approverId) {
      throw new ForbiddenException('You cannot approve your own request');
    }

    // Check if approver is the manager
    const managerId = request.employee.orgRelations?.primaryManagerId;
    if (managerId !== approverId) {
      throw new ForbiddenException('You can only approve requests from your direct reports');
    }

    // Rejection requires comment
    if (dto.status === 'REJECTED' && !dto.comment) {
      throw new BadRequestException('Rejection requires a comment');
    }

    const year = request.startDate.getFullYear();

    // Use transaction to ensure atomicity of status + balance updates
    // This prevents partial updates if one operation fails
    await this.prisma.$transaction(async (tx) => {
      // Update request status with precondition check to prevent race conditions
      // Only update if status is still PENDING (handles concurrent approval attempts)
      const result = await tx.timeOffRequest.updateMany({
        where: {
          id: requestId,
          tenantId,
          status: 'PENDING', // Precondition: must still be pending
        },
        data: {
          status: dto.status,
          approverId,
          approverComment: dto.comment,
          approvedAt: new Date(),
        },
      });

      if (result.count === 0) {
        throw new BadRequestException('Request has already been processed');
      }

      // Update balance atomically within same transaction
      if (dto.status === 'APPROVED') {
        // Move from pending to used
        await tx.timeOffBalance.update({
          where: {
            employeeId_policyId_year: {
              employeeId: request.employeeId,
              policyId: request.policyId,
              year,
            },
          },
          data: {
            used: { increment: request.days },
            pending: { decrement: request.days },
          },
        });
      } else if (dto.status === 'REJECTED') {
        // Remove from pending
        await tx.timeOffBalance.update({
          where: {
            employeeId_policyId_year: {
              employeeId: request.employeeId,
              policyId: request.policyId,
              year,
            },
          },
          data: {
            pending: { decrement: request.days },
          },
        });
      }
    });

    return this.findById(tenantId, requestId);
  }

  async cancel(tenantId: string, requestId: string, employeeId: string) {
    const request = await this.findById(tenantId, requestId);

    // Can only cancel own requests
    if (request.employeeId !== employeeId) {
      throw new ForbiddenException('You can only cancel your own requests');
    }

    // Can only cancel pending requests (checked again in transaction for safety)
    if (request.status !== 'PENDING') {
      throw new BadRequestException('Can only cancel pending requests');
    }

    const year = request.startDate.getFullYear();

    // Use transaction to ensure atomicity of status + balance updates
    await this.prisma.$transaction(async (tx) => {
      // Update status with precondition check to prevent race conditions
      const result = await tx.timeOffRequest.updateMany({
        where: {
          id: requestId,
          tenantId,
          status: 'PENDING', // Precondition: must still be pending
        },
        data: {
          status: 'CANCELLED',
        },
      });

      if (result.count === 0) {
        throw new BadRequestException('Request has already been processed');
      }

      // Remove from pending balance atomically
      await tx.timeOffBalance.update({
        where: {
          employeeId_policyId_year: {
            employeeId: request.employeeId,
            policyId: request.policyId,
            year,
          },
        },
        data: {
          pending: { decrement: request.days },
        },
      });
    });

    return { success: true };
  }

  async getCalendar(
    tenantId: string,
    startDate: Date,
    endDate: Date,
    options?: { departmentId?: string; teamId?: string },
  ) {
    return this.requestRepository.getCalendarData(tenantId, startDate, endDate, options);
  }

  private calculateBusinessDays(startDate: Date, endDate: Date): number {
    // Note: For MVP, cross-year requests (Dec 28 - Jan 3) use the start date's year
    // for balance deduction. Future enhancement: split days proportionally between years.
    let count = 0;
    const current = new Date(startDate);

    while (current <= endDate) {
      const dayOfWeek = current.getDay();
      if (dayOfWeek !== 0 && dayOfWeek !== 6) {
        count++;
      }
      current.setDate(current.getDate() + 1);
    }

    return count;
  }
}

cd apps/api
npm run build

rm apps/api/src/time-off/services/time-off-request.service.ts
rm apps/api/src/time-off/dto/create-time-off-request.dto.ts
rm apps/api/src/time-off/dto/approve-request.dto.ts

apps/api/src/time-off/services/time-off-request.service.ts
apps/api/src/time-off/dto/create-time-off-request.dto.ts
apps/api/src/time-off/dto/approve-request.dto.ts

import {
  Controller,
  Get,
  Post,
  Patch,
  Delete,
  Body,
  Param,
  Query,
  UseGuards,
} from '@nestjs/common';
import { TimeOffRequestService } from '../services/time-off-request.service';
import { TimeOffBalanceService } from '../services/time-off-balance.service';
import { CreateTimeOffRequestDto } from '../dto/create-time-off-request.dto';
import { ApproveRequestDto } from '../dto/approve-request.dto';
import { TenantGuard } from '../../tenant/tenant.guard';
import { TenantId } from '../../tenant/tenant.decorator';
import { CurrentUser } from '../../auth/current-user.decorator';

@Controller('api/v1/timeoff')
@UseGuards(TenantGuard)
export class TimeOffRequestController {
  constructor(
    private requestService: TimeOffRequestService,
    private balanceService: TimeOffBalanceService,
  ) {}

  // ==========================================
  // REQUEST ENDPOINTS
  // ==========================================

  @Get('requests')
  async findAll(
    @TenantId() tenantId: string,
    @CurrentUser('employeeId') employeeId: string,
    @Query('status') status?: 'PENDING' | 'APPROVED' | 'REJECTED' | 'CANCELLED',
  ) {
    const requests = await this.requestService.findAll(tenantId, {
      employeeId,
      status,
    });
    return { data: requests, error: null };
  }

  @Get('requests/pending-approvals')
  async getPendingApprovals(
    @TenantId() tenantId: string,
    @CurrentUser('employeeId') managerId: string,
  ) {
    const requests = await this.requestService.getPendingForManager(tenantId, managerId);
    return { data: requests, error: null };
  }

  @Get('requests/:id')
  async findOne(
    @TenantId() tenantId: string,
    @Param('id') id: string,
  ) {
    const request = await this.requestService.findById(tenantId, id);
    return { data: request, error: null };
  }

  @Post('requests')
  async submit(
    @TenantId() tenantId: string,
    @CurrentUser('employeeId') employeeId: string,
    @Body() dto: CreateTimeOffRequestDto,
  ) {
    const request = await this.requestService.submit(tenantId, employeeId, dto);
    return { data: request, error: null };
  }

  @Patch('requests/:id')
  async approve(
    @TenantId() tenantId: string,
    @CurrentUser('employeeId') approverId: string,
    @Param('id') id: string,
    @Body() dto: ApproveRequestDto,
  ) {
    const request = await this.requestService.approve(tenantId, id, approverId, dto);
    return { data: request, error: null };
  }

  @Delete('requests/:id')
  async cancel(
    @TenantId() tenantId: string,
    @CurrentUser('employeeId') employeeId: string,
    @Param('id') id: string,
  ) {
    await this.requestService.cancel(tenantId, id, employeeId);
    return { data: { success: true }, error: null };
  }

  // ==========================================
  // BALANCE ENDPOINTS
  // ==========================================

  @Get('balances')
  async getMyBalances(
    @TenantId() tenantId: string,
    @CurrentUser('employeeId') employeeId: string,
    @Query('year') year?: string,
  ) {
    const balances = await this.balanceService.getEmployeeBalances(
      tenantId,
      employeeId,
      year ? parseInt(year) : undefined,
    );
    return { data: balances, error: null };
  }

  @Get('balances/:employeeId')
  async getEmployeeBalances(
    @TenantId() tenantId: string,
    @Param('employeeId') employeeId: string,
    @Query('year') year?: string,
  ) {
    const balances = await this.balanceService.getEmployeeBalances(
      tenantId,
      employeeId,
      year ? parseInt(year) : undefined,
    );
    return { data: balances, error: null };
  }

  // ==========================================
  // CALENDAR ENDPOINT
  // ==========================================

  @Get('calendar')
  async getCalendar(
    @TenantId() tenantId: string,
    @Query('startDate') startDate: string,
    @Query('endDate') endDate: string,
    @Query('departmentId') departmentId?: string,
    @Query('teamId') teamId?: string,
  ) {
    const data = await this.requestService.getCalendar(
      tenantId,
      new Date(startDate),
      new Date(endDate),
      { departmentId, teamId },
    );
    return { data, error: null };
  }
}

import { Module } from '@nestjs/common';
import { PrismaModule } from '../prisma/prisma.module';
import { TimeOffPolicyRepository } from './repositories/time-off-policy.repository';
import { TimeOffBalanceRepository } from './repositories/time-off-balance.repository';
import { TimeOffRequestRepository } from './repositories/time-off-request.repository';
import { TimeOffPolicyService } from './services/time-off-policy.service';
import { TimeOffBalanceService } from './services/time-off-balance.service';
import { TimeOffRequestService } from './services/time-off-request.service';
import { TimeOffPolicyController } from './controllers/time-off-policy.controller';
import { TimeOffRequestController } from './controllers/time-off-request.controller';

@Module({
  imports: [PrismaModule],
  controllers: [TimeOffPolicyController, TimeOffRequestController],
  providers: [
    TimeOffPolicyRepository,
    TimeOffBalanceRepository,
    TimeOffRequestRepository,
    TimeOffPolicyService,
    TimeOffBalanceService,
    TimeOffRequestService,
  ],
  exports: [TimeOffPolicyService, TimeOffBalanceService, TimeOffRequestService],
})
export class TimeOffModule {}

import { TimeOffModule } from './time-off/time-off.module';

@Module({
  imports: [
    // ... existing modules
    TimeOffModule,
  ],
})
export class AppModule {}

cd apps/api
npm run build

# Test endpoints with curl
curl -X GET http://localhost:3001/api/v1/timeoff/policies/active \
  -H "x-tenant-id: your-tenant-id"
# Should return list of active policies

rm apps/api/src/time-off/controllers/time-off-request.controller.ts
rm apps/api/src/time-off/time-off.module.ts
# Remove TimeOffModule from app.module.ts

apps/api/src/time-off/controllers/time-off-request.controller.ts
apps/api/src/time-off/time-off.module.ts
apps/api/src/app.module.ts (TimeOffModule import)

cd apps/web
npm install react-hook-form @hookform/resolvers date-fns
# Note: zod should already be installed per tech stack (Zod 3.x)

// Add this method to the api object in lib/api.ts:
async patch<T = unknown>(path: string, body: unknown): Promise<{ data: T; error: null }> {
  const tenantId = await getTenantId();
  const res = await fetch(`${API_URL}/api/v1${path}`, {
    method: 'PATCH',
    headers: {
      'Content-Type': 'application/json',
      'x-tenant-id': tenantId,
    },
    body: JSON.stringify(body),
  });
  if (!res.ok) {
    const errorBody = await res.json().catch(() => ({}));
    throw new Error(errorBody.error?.message || `API request failed: ${res.status}`);
  }
  return res.json();
}

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { api } from '@/lib/api';

export interface TimeOffPolicy {
  id: string;
  name: string;
  code: string | null;
  leaveType: string;
  annualAllowance: number;
}

export interface TimeOffBalance {
  id: string;
  policyId: string;
  policyName: string;
  policyCode: string | null;
  year: number;
  entitled: number;
  used: number;
  pending: number;
  carryOver: number;
  adjustment: number;
  available: number;
}

export interface TimeOffRequest {
  id: string;
  policyId: string;
  startDate: string;
  endDate: string;
  days: number;
  halfDay: boolean;
  halfDayPart: 'MORNING' | 'AFTERNOON' | null;
  status: 'PENDING' | 'APPROVED' | 'REJECTED' | 'CANCELLED';
  reason: string | null;
  approverComment: string | null;
  createdAt: string;
  employee: {
    id: string;
    firstName: string;
    lastName: string;
    pictureUrl: string | null;
  };
  policy: {
    id: string;
    name: string;
    code: string | null;
  };
}

export function useActivePolicies() {
  return useQuery({
    queryKey: ['timeoff-policies', 'active'],
    queryFn: async (): Promise<TimeOffPolicy[]> => {
      const response = await api.get<TimeOffPolicy[]>('/timeoff/policies/active');
      return response.data;
    },
  });
}

export function useMyBalances(year?: number) {
  return useQuery({
    queryKey: ['timeoff-balances', 'me', year],
    queryFn: async (): Promise<TimeOffBalance[]> => {
      const params = year ? `?year=${year}` : '';
      const response = await api.get<TimeOffBalance[]>(`/timeoff/balances${params}`);
      return response.data;
    },
  });
}

export function useMyRequests(status?: string) {
  return useQuery({
    queryKey: ['timeoff-requests', 'me', status],
    queryFn: async (): Promise<TimeOffRequest[]> => {
      const params = status ? `?status=${status}` : '';
      const response = await api.get<TimeOffRequest[]>(`/timeoff/requests${params}`);
      return response.data;
    },
  });
}

export function usePendingApprovals() {
  return useQuery({
    queryKey: ['timeoff-requests', 'pending-approvals'],
    queryFn: async (): Promise<TimeOffRequest[]> => {
      const response = await api.get<TimeOffRequest[]>('/timeoff/requests/pending-approvals');
      return response.data;
    },
  });
}

export function useSubmitRequest() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (data: {
      policyId: string;
      startDate: string;
      endDate: string;
      halfDay?: boolean;
      halfDayPart?: 'MORNING' | 'AFTERNOON';
      reason?: string;
    }) => {
      const response = await api.post<TimeOffRequest>('/timeoff/requests', data);
      return response.data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ['timeoff-requests'] });
      queryClient.invalidateQueries({ queryKey: ['timeoff-balances'] });
    },
  });
}

export function useApproveRequest() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({
      requestId,
      status,
      comment,
    }: {
      requestId: string;
      status: 'APPROVED' | 'REJECTED';
      comment?: string;
    }) => {
      const response = await api.patch<TimeOffRequest>(`/timeoff/requests/${requestId}`, {
        status,
        comment,
      });
      return response.data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ['timeoff-requests'] });
      queryClient.invalidateQueries({ queryKey: ['timeoff-balances'] });
    },
  });
}

export function useCancelRequest() {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (requestId: string) => {
      await api.delete(`/timeoff/requests/${requestId}`);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: ['timeoff-requests'] });
      queryClient.invalidateQueries({ queryKey: ['timeoff-balances'] });
    },
  });
}