Major Enhancement: NestJS Migration + CASL Authorization + Error Handling

Complete rewrite from Express to NestJS with enterprise-grade features:

## Backend Improvements
- Migrated from Express to NestJS 11.0.1 with TypeScript
- Implemented Prisma ORM 7.3.0 for type-safe database access
- Added CASL authorization system replacing role-based guards
- Created global exception filters with structured logging
- Implemented Auth0 JWT authentication with Passport.js
- Added vehicle management with conflict detection
- Enhanced event scheduling with driver/vehicle assignment
- Comprehensive error handling and logging

## Frontend Improvements
- Upgraded to React 19.2.0 with Vite 7.2.4
- Implemented CASL-based permission system
- Added AbilityContext for declarative permissions
- Created ErrorHandler utility for consistent error messages
- Enhanced API client with request/response logging
- Added War Room (Command Center) dashboard
- Created VIP Schedule view with complete itineraries
- Implemented Vehicle Management UI
- Added mock data generators for testing (288 events across 20 VIPs)

## New Features
- Vehicle fleet management (types, capacity, status tracking)
- Complete 3-day Jamboree schedule generation
- Individual VIP schedule pages with PDF export (planned)
- Real-time War Room dashboard with auto-refresh
- Permission-based navigation filtering
- First user auto-approval as administrator

## Documentation
- Created CASL_AUTHORIZATION.md (comprehensive guide)
- Created ERROR_HANDLING.md (error handling patterns)
- Updated CLAUDE.md with new architecture
- Added migration guides and best practices

## Technical Debt Resolved
- Removed custom authentication in favor of Auth0
- Replaced role checks with CASL abilities
- Standardized error responses across API
- Implemented proper TypeScript typing
- Added comprehensive logging

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

backend/src/vehicles/dto/create-vehicle.dto.ts

@@ -0,0 +1,30 @@
+import { IsString, IsEnum, IsInt, IsOptional, Min } from 'class-validator';
+import { VehicleType, VehicleStatus } from '@prisma/client';
+
+export class CreateVehicleDto {
+  @IsString()
+  name: string;
+
+  @IsEnum(VehicleType)
+  type: VehicleType;
+
+  @IsString()
+  @IsOptional()
+  licensePlate?: string;
+
+  @IsInt()
+  @Min(1)
+  seatCapacity: number;
+
+  @IsEnum(VehicleStatus)
+  @IsOptional()
+  status?: VehicleStatus;
+
+  @IsString()
+  @IsOptional()
+  currentDriverId?: string;
+
+  @IsString()
+  @IsOptional()
+  notes?: string;
+}

backend/src/vehicles/dto/index.ts

@@ -0,0 +1,2 @@
+export * from './create-vehicle.dto';
+export * from './update-vehicle.dto';

backend/src/vehicles/dto/update-vehicle.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateVehicleDto } from './create-vehicle.dto';
+
+export class UpdateVehicleDto extends PartialType(CreateVehicleDto) {}

backend/src/vehicles/vehicles.controller.ts

@@ -0,0 +1,63 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Patch,
+  Delete,
+  Body,
+  Param,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import { VehiclesService } from './vehicles.service';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { RolesGuard } from '../auth/guards/roles.guard';
+import { Roles } from '../auth/decorators/roles.decorator';
+import { Role } from '@prisma/client';
+import { CreateVehicleDto, UpdateVehicleDto } from './dto';
+
+@Controller('vehicles')
+@UseGuards(JwtAuthGuard, RolesGuard)
+export class VehiclesController {
+  constructor(private readonly vehiclesService: VehiclesService) {}
+
+  @Post()
+  @Roles(Role.ADMINISTRATOR, Role.COORDINATOR)
+  create(@Body() createVehicleDto: CreateVehicleDto) {
+    return this.vehiclesService.create(createVehicleDto);
+  }
+
+  @Get()
+  findAll() {
+    return this.vehiclesService.findAll();
+  }
+
+  @Get('available')
+  findAvailable() {
+    return this.vehiclesService.findAvailable();
+  }
+
+  @Get('utilization')
+  @Roles(Role.ADMINISTRATOR, Role.COORDINATOR)
+  getUtilization() {
+    return this.vehiclesService.getUtilization();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string) {
+    return this.vehiclesService.findOne(id);
+  }
+
+  @Patch(':id')
+  @Roles(Role.ADMINISTRATOR, Role.COORDINATOR)
+  update(@Param('id') id: string, @Body() updateVehicleDto: UpdateVehicleDto) {
+    return this.vehiclesService.update(id, updateVehicleDto);
+  }
+
+  @Delete(':id')
+  @Roles(Role.ADMINISTRATOR, Role.COORDINATOR)
+  remove(@Param('id') id: string, @Query('hard') hard?: string) {
+    const isHardDelete = hard === 'true';
+    return this.vehiclesService.remove(id, isHardDelete);
+  }
+}

backend/src/vehicles/vehicles.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { VehiclesService } from './vehicles.service';
+import { VehiclesController } from './vehicles.controller';
+import { PrismaModule } from '../prisma/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  controllers: [VehiclesController],
+  providers: [VehiclesService],
+  exports: [VehiclesService],
+})
+export class VehiclesModule {}

backend/src/vehicles/vehicles.service.ts

@@ -0,0 +1,140 @@
+import { Injectable, NotFoundException, Logger } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { CreateVehicleDto, UpdateVehicleDto } from './dto';
+
+@Injectable()
+export class VehiclesService {
+  private readonly logger = new Logger(VehiclesService.name);
+
+  constructor(private prisma: PrismaService) {}
+
+  async create(createVehicleDto: CreateVehicleDto) {
+    this.logger.log(`Creating vehicle: ${createVehicleDto.name}`);
+
+    return this.prisma.vehicle.create({
+      data: createVehicleDto,
+      include: {
+        currentDriver: true,
+        events: {
+          where: { deletedAt: null },
+          include: { vip: true },
+        },
+      },
+    });
+  }
+
+  async findAll() {
+    return this.prisma.vehicle.findMany({
+      where: { deletedAt: null },
+      include: {
+        currentDriver: true,
+        events: {
+          where: { deletedAt: null },
+          include: { vip: true, driver: true },
+          orderBy: { startTime: 'asc' },
+        },
+      },
+      orderBy: { name: 'asc' },
+    });
+  }
+
+  async findAvailable() {
+    return this.prisma.vehicle.findMany({
+      where: {
+        deletedAt: null,
+        status: 'AVAILABLE',
+      },
+      include: {
+        currentDriver: true,
+      },
+      orderBy: { name: 'asc' },
+    });
+  }
+
+  async findOne(id: string) {
+    const vehicle = await this.prisma.vehicle.findFirst({
+      where: { id, deletedAt: null },
+      include: {
+        currentDriver: true,
+        events: {
+          where: { deletedAt: null },
+          include: { vip: true, driver: true },
+          orderBy: { startTime: 'asc' },
+        },
+      },
+    });
+
+    if (!vehicle) {
+      throw new NotFoundException(`Vehicle with ID ${id} not found`);
+    }
+
+    return vehicle;
+  }
+
+  async update(id: string, updateVehicleDto: UpdateVehicleDto) {
+    const vehicle = await this.findOne(id);
+
+    this.logger.log(`Updating vehicle ${id}: ${vehicle.name}`);
+
+    return this.prisma.vehicle.update({
+      where: { id: vehicle.id },
+      data: updateVehicleDto,
+      include: {
+        currentDriver: true,
+        events: {
+          where: { deletedAt: null },
+          include: { vip: true, driver: true },
+        },
+      },
+    });
+  }
+
+  async remove(id: string, hardDelete = false) {
+    const vehicle = await this.findOne(id);
+
+    if (hardDelete) {
+      this.logger.log(`Hard deleting vehicle: ${vehicle.name}`);
+      return this.prisma.vehicle.delete({
+        where: { id: vehicle.id },
+      });
+    }
+
+    this.logger.log(`Soft deleting vehicle: ${vehicle.name}`);
+    return this.prisma.vehicle.update({
+      where: { id: vehicle.id },
+      data: { deletedAt: new Date() },
+    });
+  }
+
+  /**
+   * Get vehicle utilization statistics
+   */
+  async getUtilization() {
+    const vehicles = await this.findAll();
+
+    const stats = vehicles.map((vehicle) => {
+      const upcomingEvents = vehicle.events.filter(
+        (event) => new Date(event.startTime) > new Date(),
+      );
+
+      return {
+        id: vehicle.id,
+        name: vehicle.name,
+        type: vehicle.type,
+        seatCapacity: vehicle.seatCapacity,
+        status: vehicle.status,
+        upcomingTrips: upcomingEvents.length,
+        currentDriver: vehicle.currentDriver?.name,
+      };
+    });
+
+    return {
+      totalVehicles: vehicles.length,
+      available: vehicles.filter((v) => v.status === 'AVAILABLE').length,
+      inUse: vehicles.filter((v) => v.status === 'IN_USE').length,
+      maintenance: vehicles.filter((v) => v.status === 'MAINTENANCE').length,
+      reserved: vehicles.filter((v) => v.status === 'RESERVED').length,
+      vehicles: stats,
+    };
+  }
+}