@trafficgroup/knex-rel 0.1.4 → 0.1.5

package/plan.md

@@ -1,1034 +1,831 @@
-# Report Configurations Database Implementation Plan
+# Missing DAO Methods Implementation Plan
 
 ## Executive Summary
 
-This plan implements a **system-wide** report configuration system that allows users to map FHWA 13-class vehicle classifications to custom groupings for traffic reports. The configuration applies a **3-tier mapping** system: Detection Labels → FHWA Classes → Custom Classes.
+This plan details the implementation of 5 missing DAO methods across CameraDAO and VideoDAO that are currently being called from api-rel services. All methods have been analyzed for call patterns, data flow, and database requirements.
 
-**Key Decisions from User Clarifications:**
+---
 
-- System-wide configurations (NOT user-scoped)
-- Configurations selected when viewing video results or study summaries
-- Always maintain at least 1 configuration (cannot delete last one)
-- Many-to-One ONLY mapping (no duplicates allowed)
-- Unmapped FHWA classes excluded from reports
-- API-level transformation (frontend receives only transformed data)
-- Applies to both TMC and ATR study types
-- Minute-level granularity transformation
+## Schema Analysis
 
----
+### Tables Involved
 
-## Critical Design Challenge: Detection Label → FHWA Class Mapping
+**cameras**
 
-### The Problem
+```sql
+id: SERIAL PRIMARY KEY
+uuid: UUID NOT NULL UNIQUE (indexed)
+name: VARCHAR(100) NOT NULL
+longitude: DECIMAL(10,7) NOT NULL
+latitude: DECIMAL(10,7) NOT NULL
+created_at: TIMESTAMP
+updated_at: TIMESTAMP
+INDEX: (uuid)
+INDEX: (longitude, latitude)
+```
 
-The user described a 3-tier mapping system:
+**video**
 
+```sql
+id: SERIAL PRIMARY KEY
+uuid: UUID NOT NULL UNIQUE
+folderId: INTEGER NOT NULL REFERENCES folders(id)
+cameraId: INTEGER NULL REFERENCES cameras(id) ON DELETE SET NULL
+name: VARCHAR
+videoLocation: VARCHAR
+status: VARCHAR (QUEUED|PROCESSING|COMPLETED|FAILED|PENDING)
+... (additional fields)
+INDEX: (cameraId)
 ```
-Detection Labels → FHWA Classes → Custom Classes
+
+**folders**
+
+```sql
+id: SERIAL PRIMARY KEY
+uuid: UUID NOT NULL UNIQUE
+name: VARCHAR
+cameraId: INTEGER NULL REFERENCES cameras(id) ON DELETE SET NULL
+INDEX: (cameraId)
 ```
 
-However, **I cannot find a hardcoded mapping** from detection labels to FHWA classes in the codebase.
+---
 
-**Detection Labels Found in System:**
+## Method 1: CameraDAO.getAllWithSearch()
 
-- From VideoMinuteResultDAO.normalizeATRVehicleClass() (lines 702-731):
-  - `car`, `vehicle`, `automobiles` → normalized to `cars`
-  - `medium`, `pickup`, `truck` → normalized to `mediums`
-  - `heavy`, `largetruck`, `bigtruck` → normalized to `heavy_trucks`
-  - `pedestrian`, `person`, `people` → normalized to `pedestrians`
-  - `bicycle`, `bike`, `cyclist` → normalized to `bicycles`
+### Call Analysis
 
-**FHWA 13-Class System (from user clarifications):**
+**Location**: `api-rel/src/service/camera/camera.service.ts:274`
 
-```
-Class 1: motorcycle
-Class 2: car
-Class 3: pickup_truck
-Class 4: bus
-Class 5: work_van
-Class 6-8: single_unit_truck
-Class 9-13: articulated_truck
+**Method Signature**:
+
+```typescript
+async getAllWithSearch(page: number, limit: number, name?: string): Promise<IDataPaginator<ICamera>>
 ```
 
-### The Solution: Hardcoded FHWA Mapping in ReportConfigurationDAO
+**Called From**: CameraService.getAllWithSearch()
 
-Since no existing mapping exists, we'll create a **static mapping table** in the ReportConfigurationDAO:
+- **Parameters**: page, limit, name (optional string for search)
+- **Return Value**: IDataPaginator<ICamera> - used to map to CameraDTO[]
+- **Purpose**: Filter cameras by name with pagination support
+
+**Data Flow**:
 
-```typescript
-const DETECTION_LABEL_TO_FHWA: Record<string, number[]> = {
-  motorcycle: [1],
-  car: [2],
-  pickup_truck: [3],
-  bus: [4],
-  work_van: [5],
-  single_unit_truck: [6, 7, 8],
-  articulated_truck: [9, 10, 11, 12, 13],
-  // Non-motorized (excluded from FHWA system)
-  pedestrian: [],
-  bicycle: [],
-  motorized_vehicle: [2], // Map to car
-  non_motorized_vehicle: [],
-};
+```
+API Request → CameraService.getAllWithSearch(page, limit, name)
+  → CameraDAO.getAllWithSearch(page, limit, name)
+  → Returns IDataPaginator<ICamera>
+  → Service maps to CameraDTO[] (exposes UUID, hides ID)
+  → API Response
 ```
 
-**Transformation Flow:**
+### Implementation Requirements
 
-1. Video processing returns detection labels (e.g., `car`, `pickup_truck`)
-2. DAO converts detection labels → FHWA classes using DETECTION_LABEL_TO_FHWA
-3. DAO applies user configuration: FHWA classes → Custom classes
-4. API returns only custom class counts to frontend
+**SQL Query**:
 
-### Replacement of Existing Normalization
+```sql
+-- Count query
+SELECT COUNT(*) as count FROM cameras WHERE name ILIKE '%search%'
 
-The `normalizeATRVehicleClass()` function (VideoMinuteResultDAO lines 702-731) will be **completely replaced**. Instead of normalizing to `cars`, `mediums`, `heavy_trucks`, the new system will:
+-- Data query
+SELECT * FROM cameras
+WHERE name ILIKE '%search%'
+LIMIT ? OFFSET ?
+```
 
-1. Keep raw detection labels in database
-2. Apply FHWA mapping + user configuration at aggregation time
-3. Return only custom class names to API
+**Key Details**:
 
----
+- Use ILIKE for case-insensitive search (PostgreSQL)
+- Search is optional (if name undefined/null, return all)
+- Use '%search%' pattern for partial matching
+- Follow existing getAll() pattern from camera.dao.ts:34-50
 
-## Database Schema
+**Performance Considerations**:
 
-### Table: `report_configurations`
+- Index on name column NOT currently exists - consider adding
+- ILIKE with leading wildcard prevents index usage
+- For now, acceptable for camera table (likely small dataset)
 
-```sql
-CREATE TABLE report_configurations (
-  id SERIAL PRIMARY KEY,
-  uuid UUID NOT NULL UNIQUE DEFAULT gen_random_uuid(),
-  name VARCHAR(30) NOT NULL UNIQUE,
-  description TEXT,
-  configuration JSONB NOT NULL,
-  is_default BOOLEAN NOT NULL DEFAULT false,
-  created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
-  updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX idx_report_configurations_uuid ON report_configurations(uuid);
-CREATE INDEX idx_report_configurations_is_default ON report_configurations(is_default);
-CREATE INDEX idx_report_configurations_name_lower ON report_configurations(LOWER(name));
-```
+---
 
-**Constraints:**
+## Method 2: CameraDAO.getVideosByCamera()
 
-- `name`: VARCHAR(30), UNIQUE, NOT NULL (max 30 characters)
-- `uuid`: UUID, UNIQUE, NOT NULL, auto-generated
-- `configuration`: JSONB, NOT NULL
-- At least 1 configuration must exist (enforced at application level)
+### Call Analysis
 
-### Configuration JSONB Structure
+**Location**: `api-rel/src/service/camera/camera.service.ts:308`
+
+**Method Signature**:
 
 ```typescript
-{
-  "version": "1.0",
-  "customClasses": [
-    {
-      "name": "Light Vehicles",
-      "fhwaClasses": [1, 2, 3]
-    },
-    {
-      "name": "Medium Trucks",
-      "fhwaClasses": [5]
-    },
-    {
-      "name": "Heavy Trucks",
-      "fhwaClasses": [4, 6, 7, 8, 9, 10, 11, 12, 13]
-    }
-  ]
-}
+async getVideosByCamera(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>>
 ```
 
-**Validation Rules:**
+**Called From**: CameraService.getVideosByCamera()
 
-- `customClasses` array: min 2, max 7 items
-- Each `name`: max 30 characters
-- Each `fhwaClasses` array: unique integers from 1-13
-- No FHWA class can appear in multiple custom classes (Many-to-One)
-- Unmapped FHWA classes are allowed (will be excluded from reports)
+- **Parameters**: cameraId (internal numeric ID), page, limit
+- **Return Value**: IDataPaginator with video data PLUS folder information
+- **Purpose**: Get all videos associated with a specific camera (paginated)
 
----
+**Data Flow**:
 
-## Migration
+```
+API Request (cameraUuid) → CameraService.getVideosByCamera(cameraUuid, page, limit)
+  → Get camera by UUID to obtain ID (line 302)
+  → CameraDAO.getVideosByCamera(camera.id, page, limit)
+  → Returns IDataPaginator<IVideo> with folder data
+  → Service maps to VideoWithFolderDTO[] (line 311-312)
+  → API Response
+```
 
-### File: `YYYYMMDDHHMMSS_create_report_configurations.ts`
+**Critical Detail**: Service expects folder data in response (line 312: mapToVideoWithFolderDTO)
 
-```typescript
-import type { Knex } from "knex";
-
-export async function up(knex: Knex): Promise<void> {
-  await knex.schema.createTable("report_configurations", (table) => {
-    table.increments("id").primary();
-    table
-      .uuid("uuid")
-      .notNullable()
-      .unique()
-      .defaultTo(knex.raw("gen_random_uuid()"));
-    table.string("name", 30).notNullable().unique();
-    table.text("description").nullable();
-    table.jsonb("configuration").notNullable();
-    table.boolean("is_default").notNullable().defaultTo(false);
-    table.timestamps(true, true);
-
-    // Indexes
-    table.index("uuid", "idx_report_configurations_uuid");
-    table.index("is_default", "idx_report_configurations_is_default");
-  });
-
-  // Add case-insensitive name index
-  await knex.raw(`
-    CREATE INDEX idx_report_configurations_name_lower
-    ON report_configurations(LOWER(name))
-  `);
-
-  // Seed default configuration (matches current system behavior)
-  await knex("report_configurations").insert({
-    name: "Default",
-    description: "Standard configuration matching current system behavior",
-    configuration: JSON.stringify({
-      version: "1.0",
-      customClasses: [
-        {
-          name: "Cars",
-          fhwaClasses: [1, 2], // motorcycle, car
-        },
-        {
-          name: "Medium Trucks",
-          fhwaClasses: [3, 5], // pickup_truck, work_van
-        },
-        {
-          name: "Heavy Trucks",
-          fhwaClasses: [4, 6, 7, 8, 9, 10, 11, 12, 13], // bus, single_unit_truck, articulated_truck
-        },
-      ],
-    }),
-    is_default: true,
-  });
-}
+### Implementation Requirements
 
-export async function down(knex: Knex): Promise<void> {
-  await knex.raw("DROP INDEX IF EXISTS idx_report_configurations_name_lower");
-  await knex.schema.dropTableIfExists("report_configurations");
-}
+**SQL Query** (must JOIN with folders):
+
+```sql
+-- Count query
+SELECT COUNT(*) as count
+FROM video v
+WHERE v.cameraId = ?
+
+-- Data query with folder JOIN
+SELECT v.*, to_jsonb(f.*) as folder
+FROM video v
+INNER JOIN folders f ON v.folderId = f.id
+WHERE v.cameraId = ?
+LIMIT ? OFFSET ?
 ```
 
-**Migration Safety:** LOW RISK
+**Key Details**:
 
-- Creates new table (no data loss)
-- Seeds single default configuration
-- Rollback is clean (drop table)
+- MUST include folder data (use to_jsonb like VideoDAO.getById:21)
+- Filter by cameraId (indexed)
+- Follow VideoDAO.getAll() pattern for folder JOIN (lines 50-59)
+- Return IDataPaginator<IVideo> with folder field populated
 
----
+**Performance Considerations**:
 
-## Interface Definition
+- cameraId already indexed (migration 20250911000000_migration.ts:20)
+- JOIN with folders is necessary for DTO mapping
+- Consider ORDER BY created_at DESC for chronological listing
 
-### File: `src/interfaces/report-configuration/report-configuration.interfaces.ts`
+---
 
-```typescript
-export interface IReportConfiguration {
-  id: number;
-  uuid: string;
-  name: string;
-  description?: string;
-  configuration: IReportConfigurationData;
-  isDefault: boolean;
-  createdAt: string;
-  updatedAt: string;
-}
+## Method 3: VideoDAO.bulkUpdateCamera()
 
-export interface IReportConfigurationData {
-  version: string;
-  customClasses: ICustomClass[];
-}
+### Call Analysis
 
-export interface ICustomClass {
-  name: string;
-  fhwaClasses: number[];
-}
+**Location 1**: `api-rel/src/service/camera/camera.service.ts:364`
+**Location 2**: `api-rel/src/service/video/video.service.ts:34`
+**Location 3**: `api-rel/src/service/folder/folder.service.ts:96`
 
-export interface IReportConfigurationInput {
-  name: string;
-  description?: string;
-  configuration: IReportConfigurationData;
-  isDefault?: boolean;
-}
+**Method Signature**:
 
-export interface IConfigurationValidationResult {
-  valid: boolean;
-  errors: string[];
-}
+```typescript
+async bulkUpdateCamera(videoIds: number[], cameraId: number | null, trx?: Knex.Transaction): Promise<number>
 ```
 
----
+**Call Patterns**:
 
-## DAO Implementation
+**Pattern 1 - CameraService.bulkAssignToVideos() (line 364)**:
 
-### File: `src/dao/report-configuration/report-configuration.dao.ts`
+- Context: Assigning camera to multiple videos
+- Parameters: videoIds (array of numeric IDs), camera.id (number)
+- Transaction: NO transaction passed (relies on DAO atomicity)
+- Return: updatedCount used for logging (line 365)
 
-```typescript
-import { Knex } from "knex";
-import { IBaseDAO, IDataPaginator } from "../../d.types";
-import {
-  IReportConfiguration,
-  IReportConfigurationInput,
-  IReportConfigurationData,
-  IConfigurationValidationResult,
-} from "../../interfaces/report-configuration/report-configuration.interfaces";
-import KnexManager from "../../KnexConnection";
-
-// Static mapping: Detection Label → FHWA Classes
-const DETECTION_LABEL_TO_FHWA: Record<string, number[]> = {
-  motorcycle: [1],
-  car: [2],
-  pickup_truck: [3],
-  bus: [4],
-  work_van: [5],
-  single_unit_truck: [6, 7, 8],
-  articulated_truck: [9, 10, 11, 12, 13],
-  motorized_vehicle: [2], // Map to car
-  // Non-motorized excluded from FHWA
-  pedestrian: [],
-  bicycle: [],
-  non_motorized_vehicle: [],
-};
-
-export class ReportConfigurationDAO implements IBaseDAO<IReportConfiguration> {
-  private knex: Knex = KnexManager.getConnection();
-  private tableName = "report_configurations";
-
-  // ==================== STANDARD CRUD ====================
-
-  async create(item: IReportConfigurationInput): Promise<IReportConfiguration> {
-    // Validate configuration before creation
-    const validation = this.validateConfiguration(item.configuration);
-    if (!validation.valid) {
-      throw new Error(`Invalid configuration: ${validation.errors.join(", ")}`);
-    }
+**Pattern 2 - VideoService.bulkUpdateCamera() (line 34)**:
 
-    const dbData = this.mapInputToDbRow(item);
-    const [result] = await this.knex(this.tableName)
-      .insert(dbData)
-      .returning("*");
+- Context: Bulk update within service transaction
+- Parameters: videoIds, cameraId (can be null), trx (REQUIRED)
+- Transaction: YES - passed from service-level transaction (line 15)
+- Return: updatedCount used for result tracking (line 54)
+- Error Handling: Transaction rollback on failure (line 58)
 
-    return this.mapDbRowToEntity(result);
-  }
+**Pattern 3 - FolderService.cascadeUpdateVideosCamera() (line 96)**:
 
-  async getById(id: number): Promise<IReportConfiguration | null> {
-    const result = await this.knex(this.tableName).where("id", id).first();
-    return result ? this.mapDbRowToEntity(result) : null;
-  }
+- Context: Cascading camera assignment from folder to videos
+- Parameters: videoIds, cameraId (can be null), trx (OPTIONAL)
+- Transaction: OPTIONAL - may be passed from folder update (line 86)
+- Return: updatedCount for cascade logging (line 59)
 
-  async getByUuid(uuid: string): Promise<IReportConfiguration | null> {
-    const result = await this.knex(this.tableName).where("uuid", uuid).first();
-    return result ? this.mapDbRowToEntity(result) : null;
-  }
+### Implementation Requirements
 
-  async getAll(
-    page: number = 1,
-    limit: number = 10,
-  ): Promise<IDataPaginator<IReportConfiguration>> {
-    const offset = (page - 1) * limit;
+**SQL Query**:
 
-    const [countResult] = await this.knex(this.tableName).count("* as count");
-    const totalCount = +countResult.count;
+```sql
+UPDATE video
+SET cameraId = ?, updated_at = NOW()
+WHERE id = ANY(?)
+RETURNING id
+```
 
-    const data = await this.knex(this.tableName)
-      .select("*")
-      .orderBy("is_default", "desc") // Default first
-      .orderBy("name", "asc")
-      .limit(limit)
-      .offset(offset);
+**Key Details**:
 
-    return {
-      success: true,
-      data: this.mapDbRowsToEntities(data),
-      page,
-      limit,
-      count: data.length,
-      totalCount,
-      totalPages: Math.ceil(totalCount / limit),
-    };
-  }
-
-  async update(
-    id: number,
-    item: Partial<IReportConfigurationInput>,
-  ): Promise<IReportConfiguration | null> {
-    // Validate configuration if provided
-    if (item.configuration) {
-      const validation = this.validateConfiguration(item.configuration);
-      if (!validation.valid) {
-        throw new Error(
-          `Invalid configuration: ${validation.errors.join(", ")}`,
-        );
-      }
-    }
+- Accept optional transaction parameter (trx?: Knex.Transaction)
+- Use transaction if provided, otherwise use default connection
+- Update cameraId (can be null for unassignment)
+- Update updated_at timestamp
+- Return count of updated rows (number)
+- Use whereIn() for array parameter
 
-    const dbData = this.mapInputToDbRow(item);
-    const [result] = await this.knex(this.tableName)
-      .where("id", id)
-      .update({ ...dbData, updated_at: this.knex.fn.now() })
-      .returning("*");
+**Transaction Handling**:
 
-    return result ? this.mapDbRowToEntity(result) : null;
-  }
+```typescript
+const query = trx || this._knex;
+const result = await query("video")
+  .whereIn("id", videoIds)
+  .update({ cameraId, updated_at: query.fn.now() })
+  .returning("id");
+return result.length;
+```
 
-  async delete(id: number): Promise<boolean> {
-    // Use deleteWithValidation to prevent deletion of last config
-    return this.deleteWithValidation(id);
-  }
+**Performance Considerations**:
 
-  // ==================== CUSTOM METHODS ====================
+- Bulk update is efficient (single query)
+- videoIds array should be validated (non-empty)
+- Consider max batch size limit (100-1000 videos)
+- No index needed on id (primary key)
 
-  /**
-   * Delete configuration with validation (prevents deletion of last config)
-   */
-  async deleteWithValidation(id: number): Promise<boolean> {
-    const [countResult] = await this.knex(this.tableName).count("* as count");
-    const totalCount = +countResult.count;
+**Error Handling**:
 
-    if (totalCount <= 1) {
-      throw new Error(
-        "Cannot delete the last configuration. At least one configuration must exist.",
-      );
-    }
+- If transaction fails in caller, rollback handles cleanup
+- Return 0 if videoIds is empty array
+- Let Knex errors propagate to service layer
 
-    const result = await this.knex(this.tableName).where("id", id).del();
-    return result > 0;
-  }
-
-  /**
-   * Get default configuration (for UI convenience)
-   */
-  async getDefault(): Promise<IReportConfiguration | null> {
-    const result = await this.knex(this.tableName)
-      .where("is_default", true)
-      .first();
-
-    // If no default, return first configuration
-    if (!result) {
-      const fallback = await this.knex(this.tableName)
-        .orderBy("created_at", "asc")
-        .first();
-      return fallback ? this.mapDbRowToEntity(fallback) : null;
-    }
+---
 
-    return this.mapDbRowToEntity(result);
-  }
-
-  /**
-   * Set a configuration as default (removes default flag from others)
-   */
-  async setDefault(id: number): Promise<boolean> {
-    await this.knex.transaction(async (trx) => {
-      // Remove default flag from all
-      await trx(this.tableName).update({ is_default: false });
-
-      // Set new default
-      await trx(this.tableName).where("id", id).update({ is_default: true });
-    });
-
-    return true;
-  }
-
-  /**
-   * Validate configuration structure and business rules
-   */
-  validateConfiguration(
-    config: IReportConfigurationData,
-  ): IConfigurationValidationResult {
-    const errors: string[] = [];
-
-    // Check structure
-    if (!config || typeof config !== "object") {
-      errors.push("Configuration must be an object");
-      return { valid: false, errors };
-    }
+## Method 4: VideoDAO.getVideoIdsByFolderId()
 
-    if (!config.customClasses || !Array.isArray(config.customClasses)) {
-      errors.push("customClasses must be an array");
-      return { valid: false, errors };
-    }
+### Call Analysis
 
-    // Rule: Min 2, max 7 custom classes
-    if (config.customClasses.length < 2) {
-      errors.push("At least 2 custom classes required");
-    }
-    if (config.customClasses.length > 7) {
-      errors.push("Maximum 7 custom classes allowed");
-    }
+**Location 1**: `api-rel/src/service/folder/folder.service.ts:49`
+**Location 2**: `api-rel/src/service/folder/folder.service.ts:89`
+**Location 3**: `api-rel/src/service/folder/folder.service.ts:163`
+**Location 4**: `api-rel/src/service/video/video.service.ts:119`
 
-    // Track FHWA classes to detect duplicates
-    const usedFhwaClasses = new Set<number>();
-    const classNames = new Set<string>();
-
-    for (const customClass of config.customClasses) {
-      // Check name length
-      if (!customClass.name || customClass.name.length > 30) {
-        errors.push(
-          `Custom class name must be 1-30 characters: "${customClass.name}"`,
-        );
-      }
-
-      // Check for duplicate names
-      if (classNames.has(customClass.name)) {
-        errors.push(`Duplicate custom class name: "${customClass.name}"`);
-      }
-      classNames.add(customClass.name);
-
-      // Check fhwaClasses array
-      if (
-        !Array.isArray(customClass.fhwaClasses) ||
-        customClass.fhwaClasses.length === 0
-      ) {
-        errors.push(
-          `Custom class "${customClass.name}" must have at least one FHWA class`,
-        );
-        continue;
-      }
-
-      // Check for duplicates (Many-to-One enforcement)
-      for (const fhwaClass of customClass.fhwaClasses) {
-        if (usedFhwaClasses.has(fhwaClass)) {
-          errors.push(
-            `FHWA class ${fhwaClass} appears in multiple custom classes (not allowed)`,
-          );
-        }
-        usedFhwaClasses.add(fhwaClass);
-
-        // Validate FHWA class range
-        if (fhwaClass < 1 || fhwaClass > 13) {
-          errors.push(`Invalid FHWA class ${fhwaClass} (must be 1-13)`);
-        }
-      }
-    }
+**Method Signature**:
 
-    return {
-      valid: errors.length === 0,
-      errors,
-    };
-  }
-
-  /**
-   * Apply configuration to raw detection counts
-   * @param detectionCounts - Raw counts from video processing (e.g., {car: 50, pickup_truck: 20})
-   * @param configuration - Report configuration to apply
-   * @returns Transformed counts with custom class names
-   */
-  applyConfiguration(
-    detectionCounts: Record<string, number>,
-    configuration: IReportConfigurationData,
-  ): Record<string, number> {
-    // Step 1: Convert detection labels to FHWA classes
-    const fhwaCounts: Record<number, number> = {};
-
-    for (const [detectionLabel, count] of Object.entries(detectionCounts)) {
-      const fhwaClasses = DETECTION_LABEL_TO_FHWA[detectionLabel] || [];
-
-      // Distribute count equally among FHWA classes (for multi-mapped labels like single_unit_truck)
-      const countPerClass = count / fhwaClasses.length;
-
-      for (const fhwaClass of fhwaClasses) {
-        fhwaCounts[fhwaClass] = (fhwaCounts[fhwaClass] || 0) + countPerClass;
-      }
-    }
+```typescript
+async getVideoIdsByFolderId(folderId: number): Promise<number[]>
+```
 
-    // Step 2: Apply user configuration (FHWA classes → Custom classes)
-    const customCounts: Record<string, number> = {};
+**Call Patterns**:
 
-    for (const customClass of configuration.customClasses) {
-      let total = 0;
+**Pattern 1 - FolderService.updateWithCameraCascade() (line 49)**:
 
-      for (const fhwaClass of customClass.fhwaClasses) {
-        total += fhwaCounts[fhwaClass] || 0;
-      }
+- Context: Get all videos in folder to cascade camera update
+- Parameters: existingFolder.id
+- Return: videoIds array used for cascading (line 52-57)
+- Transaction Context: Within folder update transaction
 
-      customCounts[customClass.name] = Math.round(total);
-    }
+**Pattern 2 - FolderService.cascadeUpdateVideosCamera() (line 89)**:
 
-    return customCounts;
-  }
+- Context: Get video IDs for bulk camera update
+- Parameters: folderId
+- Return: videoIds passed to bulkUpdateCamera (line 96)
+- Early return if empty array (line 91-93)
 
-  // ==================== MAPPING HELPERS ====================
+**Pattern 3 - FolderService.getVideoCascadeCount() (line 163)**:
 
-  private mapDbRowToEntity(row: any): IReportConfiguration {
-    return {
-      id: row.id,
-      uuid: row.uuid,
-      name: row.name,
-      description: row.description,
-      configuration: row.configuration,
-      isDefault: row.is_default,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-    };
-  }
+- Context: Count videos that would be affected by cascade
+- Parameters: folder.id
+- Return: videoIds.length for count (line 164)
+- Read-only operation (no updates)
 
-  private mapDbRowsToEntities(rows: any[]): IReportConfiguration[] {
-    return rows.map((row) => this.mapDbRowToEntity(row));
-  }
+**Pattern 4 - VideoService.getVideoIdsByFolderId() (line 119)**:
 
-  private mapInputToDbRow(input: Partial<IReportConfigurationInput>): any {
-    const dbRow: any = {};
+- Context: Get all video IDs in folder for cascade operations
+- Parameters: folderId
+- Return: number[] passed back to caller
+- Used for service-level cascade logic
 
-    if (input.name !== undefined) dbRow.name = input.name;
-    if (input.description !== undefined) dbRow.description = input.description;
-    if (input.configuration !== undefined)
-      dbRow.configuration = input.configuration;
-    if (input.isDefault !== undefined) dbRow.is_default = input.isDefault;
+### Implementation Requirements
 
-    return dbRow;
-  }
-}
+**SQL Query**:
 
-export default ReportConfigurationDAO;
+```sql
+SELECT id FROM video WHERE folderId = ?
 ```
 
----
-
-## Integration with VideoMinuteResultDAO
+**Key Details**:
 
-### Modifications Required
+- Simple SELECT of id column only
+- Filter by folderId
+- Return array of numeric IDs: number[]
+- No pagination needed (cascade operations need ALL videos)
+- No JOIN needed (only IDs required)
 
-The `VideoMinuteResultDAO` must be modified to accept and apply report configurations during aggregation.
+**Performance Considerations**:
 
-**File:** `src/dao/VideoMinuteResultDAO.ts`
+- folderId should be indexed (check if exists)
+- Query is read-only, no locking needed
+- Could return large arrays (100s-1000s of videos per folder)
+- Consider ORDER BY id for consistency
 
-### Changes to Method Signatures
+**Return Value**:
 
 ```typescript
-// NEW: Add configurationId parameter to aggregation methods
-async getGroupedMinuteResultsByVideoUuid(
-  videoUuid: string,
-  groupingMinutes: number = 1,
-  configurationId?: number,  // NEW PARAMETER
-  startMinute?: number,
-  endMinute?: number,
-): Promise<IGroupedResponse>
+const ids = await this._knex("video")
+  .where({ folderId })
+  .select("id")
+  .orderBy("id", "asc");
+return ids.map((row) => row.id);
 ```
 
-### Integration Strategy
-
-1. **Import ReportConfigurationDAO:**
+---
 
-   ```typescript
-   import { ReportConfigurationDAO } from "./report-configuration/report-configuration.dao";
-   ```
+## Method 5: VideoDAO.getVideosByCameraIdWithFolder()
 
-2. **Modify aggregateTMCResults() (lines 508-585):**
-   - Accept `configuration` parameter
-   - Apply configuration transformation AFTER aggregating detection labels
-   - Replace vehicle class keys with custom class names
+### Call Analysis
 
-3. **Modify aggregateATRResults() (lines 590-642):**
-   - Accept `configuration` parameter
-   - Remove `normalizeATRVehicleClass()` calls (lines 606, 634)
-   - Apply configuration transformation instead
+**Location**: `api-rel/src/service/video/video.service.ts:77`
 
-4. **Add new helper method:**
+**Method Signature**:
 
-   ```typescript
-   private async fetchConfiguration(configurationId?: number): Promise<IReportConfigurationData> {
-     const configDAO = new ReportConfigurationDAO();
+```typescript
+async getVideosByCameraIdWithFolder(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>>
+```
 
-     let config: IReportConfiguration | null;
+**Called From**: VideoService.getVideosByCameraId()
 
-     if (configurationId) {
-       config = await configDAO.getById(configurationId);
-     } else {
-       config = await configDAO.getDefault();
-     }
+- **Parameters**: cameraId (numeric ID), page, limit
+- **Return Value**: IDataPaginator<IVideo> - directly returned to caller
+- **Purpose**: Get paginated videos for a camera with folder info
 
-     if (!config) {
-       throw new Error("No report configuration found");
-     }
+**Data Flow**:
 
-     return config.configuration;
-   }
-   ```
+```
+API/Service Request → VideoService.getVideosByCameraId(cameraId, page, limit)
+  → VideoDAO.getVideosByCameraIdWithFolder(cameraId, page, limit)
+  → Returns IDataPaginator<IVideo>
+  → Service returns directly (line 77)
+```
 
-5. **Update aggregation flow:**
+**Critical Detail**: Method name explicitly includes "WithFolder" - MUST JOIN folders
 
-   ```typescript
-   // In getGroupedMinuteResultsByVideoUuid()
-   const configuration = await this.fetchConfiguration(configurationId);
+### Implementation Requirements
 
-   const aggregatedGroups: IGroupedResult[] = rows.map((row: any) => {
-     // ... existing aggregation logic ...
+**SQL Query**:
 
-     let aggregatedResult;
-     if (studyType === "TMC") {
-       aggregatedResult = this.aggregateTMCResults(allResults, configuration);
-     } else {
-       aggregatedResult = this.aggregateATRResults(allResults, configuration);
-     }
+```sql
+-- Count query
+SELECT COUNT(*) as count
+FROM video v
+WHERE v.cameraId = ?
+
+-- Data query with folder JOIN
+SELECT v.*, to_jsonb(f.*) as folder
+FROM video v
+INNER JOIN folders f ON v.folderId = f.id
+WHERE v.cameraId = ?
+ORDER BY v.created_at DESC
+LIMIT ? OFFSET ?
+```
 
-     // ... return result ...
-   });
-   ```
+**Key Details**:
 
-### Detailed Transformation Example (ATR)
+- IDENTICAL to CameraDAO.getVideosByCamera() implementation
+- Filter by cameraId
+- MUST include folder data via JOIN
+- Follow VideoDAO.getAll() JOIN pattern (lines 50-59)
+- Return IDataPaginator<IVideo>
 
-**Before transformation (raw detection labels):**
+**Performance Considerations**:
 
-```typescript
-{
-  vehicles: {
-    car: { lane_1: 50, lane_2: 30 },
-    pickup_truck: { lane_1: 10, lane_2: 15 },
-    bus: { lane_1: 5, lane_2: 3 }
-  },
-  detected_classes: {
-    car: 80,
-    pickup_truck: 25,
-    bus: 8
-  }
-}
-```
+- Same as Method 2 (getVideosByCamera)
+- cameraId indexed
+- Consider composite index on (cameraId, created_at) for sorting
 
-**After applying configuration:**
+**Pattern Consistency**:
 
-```typescript
-// Configuration: Cars [1,2], Medium Trucks [3,5], Heavy Trucks [4,6-13]
-{
-  vehicles: {
-    "Cars": { lane_1: 50, lane_2: 30 },           // car → FHWA 2 → Cars
-    "Medium Trucks": { lane_1: 10, lane_2: 15 },   // pickup_truck → FHWA 3 → Medium Trucks
-    "Heavy Trucks": { lane_1: 5, lane_2: 3 }       // bus → FHWA 4 → Heavy Trucks
-  },
-  detected_classes: {
-    "Cars": 80,
-    "Medium Trucks": 25,
-    "Heavy Trucks": 8
-  }
-}
-```
+- This method duplicates CameraDAO.getVideosByCamera() logic
+- Both should use IDENTICAL query structure
+- Consider refactoring to shared private method in future
 
 ---
 
-## Export Updates
+## Implementation Order
 
-### File: `src/index.ts`
+### Phase 1: Simple Methods (No Dependencies)
 
-Add exports for new DAO and interfaces:
+1. **CameraDAO.getAllWithSearch()** - Standalone search method
+2. **VideoDAO.getVideoIdsByFolderId()** - Simple ID retrieval
 
-```typescript
-// Add to DAOs section
-export { ReportConfigurationDAO } from "./dao/report-configuration/report-configuration.dao";
-
-// Add to Interfaces section
-export {
-  IReportConfiguration,
-  IReportConfigurationInput,
-  IReportConfigurationData,
-  ICustomClass,
-  IConfigurationValidationResult,
-} from "./interfaces/report-configuration/report-configuration.interfaces";
-```
+### Phase 2: Complex Query Methods (JOINs)
 
----
+3. **CameraDAO.getVideosByCamera()** - JOIN with folders
+4. **VideoDAO.getVideosByCameraIdWithFolder()** - Same as #3, different DAO
 
-## Implementation Order
+### Phase 3: Transaction-Aware Methods
 
-### Phase 1: Database Foundation
+5. **VideoDAO.bulkUpdateCamera()** - Transaction support required
 
-1. Create interface file: `report-configuration.interfaces.ts`
-2. Create migration: `YYYYMMDDHHMMSS_create_report_configurations.ts`
-3. Run migration: `npm run migrate:deploy`
-4. Verify seed data exists (1 default configuration)
+---
 
-### Phase 2: DAO Implementation
+## Database Indexing Recommendations
 
-5. Create DAO: `report-configuration.dao.ts`
-6. Implement standard CRUD methods
-7. Implement validation logic
-8. Implement `applyConfiguration()` transformation logic
-9. Test DAO methods in isolation
+### Existing Indexes (Already Present)
 
-### Phase 3: Integration
+- cameras.uuid (migration 20250911000000_migration.ts:13)
+- cameras.(longitude, latitude) (migration 20250911000000_migration.ts:14)
+- video.cameraId (migration 20250911000000_migration.ts:20)
+- folders.cameraId (migration 20250911000000_migration.ts:26)
 
-10. Modify `VideoMinuteResultDAO.aggregateTMCResults()`
-11. Modify `VideoMinuteResultDAO.aggregateATRResults()`
-12. Remove `normalizeATRVehicleClass()` calls
-13. Add `fetchConfiguration()` helper
-14. Update method signatures to accept `configurationId`
+### Recommended New Indexes
 
-### Phase 4: Exports & Build
+**Optional - cameras.name (for search optimization)**
 
-15. Update `src/index.ts` exports
-16. Run `npm run build` in knex-rel
-17. Verify no TypeScript errors
-18. Test against sample video data
+```sql
+CREATE INDEX idx_cameras_name ON cameras(name);
+```
 
----
+- Benefits: Speeds up getAllWithSearch() ILIKE queries
+- Tradeoff: ILIKE with leading wildcard still can't use index fully
+- Decision: SKIP for now (camera table likely small)
 
-## Risks & Concerns
+**High Priority - video.folderId (for cascade operations)**
 
-### 🔴 CRITICAL: Detection Label Mapping Assumption
+```sql
+CREATE INDEX idx_video_folder_id ON video(folderId);
+```
 
-**Risk:** The `DETECTION_LABEL_TO_FHWA` mapping is based on user clarifications, but there's no guarantee that video processing returns exactly these labels.
+- Benefits: Critical for getVideoIdsByFolderId() performance
+- Usage: Heavy usage in cascade operations
+- Decision: **CHECK IF EXISTS** - likely already present
 
-**Mitigation:**
+**Optional - video.(cameraId, created_at) composite**
 
-- Test with actual video processing output
-- Add logging when unknown detection labels are encountered
-- Provide fallback behavior (map unknown labels to FHWA Class 2 by default)
+```sql
+CREATE INDEX idx_video_camera_created ON video(cameraId, created_at DESC);
+```
 
-### 🟡 MEDIUM: Performance at Minute-Level Granularity
+- Benefits: Optimizes sorted queries in getVideosByCameraIdWithFolder
+- Decision: SKIP for now (single column index sufficient)
 
-**Risk:** Applying configuration transformation at minute-level for 100+ videos could be slow.
+---
 
-**Current Decision:** Apply transformation on-the-fly (per user clarification Q10.2).
+## Type Safety & Interfaces
 
-**Future Optimization:**
+All methods already have proper TypeScript interfaces defined:
 
-- Cache configuration object in memory (singleton pattern)
-- Pre-compute transformed results and store in separate JSONB column
-- Add database-level JSONB transformation functions
+**ICamera** - knex-rel/src/interfaces/camera/camera.interfaces.ts
 
-### 🟡 MEDIUM: Replacement of normalizeATRVehicleClass()
+- All fields present and correct
+- No modifications needed
 
-**Risk:** Existing API clients may expect normalized class names (`cars`, `mediums`, `heavy_trucks`).
+**IVideo** - knex-rel/src/interfaces/video/video.interfaces.ts
 
-**Mitigation:**
+- Includes optional folder?: IFolder field (line 33)
+- Includes optional cameraId?: number field (line 8)
+- Supports all required fields
+- No modifications needed
 
-- Default configuration seed matches current normalization
-- API will return same class names initially (backwards compatible)
-- Users can create custom configurations as needed
+**IDataPaginator<T>** - Used consistently across all methods
 
-### 🟢 LOW: Migration Safety
+- success: boolean
+- data: T[]
+- page: number
+- limit: number
+- count: number
+- totalCount: number
+- totalPages: number
 
-**Risk:** Minimal - only creates new table with seed data.
+---
 
-**Rollback:** Clean rollback with `down()` migration drops table entirely.
+## Error Handling Patterns
 
----
+### Pattern 1: Search Methods (getAllWithSearch)
 
-## Testing Strategy
+```typescript
+// No try/catch in DAO
+// Let Knex errors propagate to service
+const result = await query...
+return result;
+```
 
-### Unit Tests (DAO Level)
+### Pattern 2: Transaction Methods (bulkUpdateCamera)
 
 ```typescript
-// Test validation
-describe("ReportConfigurationDAO.validateConfiguration", () => {
-  it("should reject configurations with < 2 custom classes");
-  it("should reject configurations with > 7 custom classes");
-  it("should reject duplicate FHWA classes");
-  it("should reject custom class names > 30 chars");
-  it("should accept valid configurations");
-});
-
-// Test transformation
-describe("ReportConfigurationDAO.applyConfiguration", () => {
-  it("should map detection labels to FHWA classes");
-  it("should map FHWA classes to custom classes");
-  it("should exclude unmapped FHWA classes");
-  it("should handle multi-mapped detection labels (single_unit_truck)");
-});
-
-// Test deletion validation
-describe("ReportConfigurationDAO.deleteWithValidation", () => {
-  it("should prevent deletion of last configuration");
-  it("should allow deletion when > 1 configuration exists");
-});
+// No try/catch in DAO
+// Let transaction rollback handle errors at service level
+const query = trx || this._knex;
+const result = await query...
+return result.length;
 ```
 
-### Integration Tests (VideoMinuteResultDAO)
+### Pattern 3: Simple Queries (getVideoIdsByFolderId)
 
 ```typescript
-describe("VideoMinuteResultDAO with ReportConfigurations", () => {
-  it("should apply configuration to TMC results");
-  it("should apply configuration to ATR results");
-  it("should use default configuration when none specified");
-  it("should handle unmapped vehicle classes correctly");
-});
+// No try/catch needed
+// Direct Knex query with error propagation
+const ids = await this._knex...
+return ids.map(row => row.id);
 ```
 
 ---
 
-## Performance Considerations
+## Code Pattern Examples
 
-### Query Optimization
+### Example 1: getAllWithSearch() Implementation
 
-**Configuration Lookup:**
+```typescript
+async getAllWithSearch(page: number, limit: number, name?: string): Promise<IDataPaginator<ICamera>> {
+    const offset = (page - 1) * limit;
 
-- Index on `uuid` for fast lookup by UUID
-- Index on `is_default` for quick default retrieval
-- Consider in-memory caching (singleton) if configurations queried frequently
+    let query = this._knex("cameras");
 
-**Transformation:**
+    // Apply search filter if name provided
+    if (name && name.trim().length > 0) {
+        query = query.where('name', 'ilike', `%${name.trim()}%`);
+    }
 
-- `applyConfiguration()` runs in O(n) time where n = number of detection labels
-- For minute-level data (potentially 1000s of minutes), this could be expensive
-- **Future optimization:** Move transformation to PostgreSQL JSONB functions
+    const [countResult] = await query.clone().count("* as count");
+    const totalCount = +countResult.count;
+    const cameras = await query.clone().limit(limit).offset(offset).orderBy('name', 'asc');
 
-### Caching Strategy (Future)
+    return {
+        success: true,
+        data: cameras,
+        page,
+        limit,
+        count: cameras.length,
+        totalCount,
+        totalPages: Math.ceil(totalCount / limit),
+    };
+}
+```
+
+### Example 2: bulkUpdateCamera() Implementation
 
 ```typescript
-class ReportConfigurationCache {
-  private static instance: Map<number, IReportConfigurationData> = new Map();
+async bulkUpdateCamera(videoIds: number[], cameraId: number | null, trx?: Knex.Transaction): Promise<number> {
+    if (!videoIds || videoIds.length === 0) {
+        return 0;
+    }
 
-  static get(id: number): IReportConfigurationData | undefined {
-    return this.instance.get(id);
-  }
+    const query = trx || this._knex;
 
-  static set(id: number, config: IReportConfigurationData): void {
-    this.instance.set(id, config);
-  }
+    const result = await query('video')
+        .whereIn('id', videoIds)
+        .update({
+            cameraId: cameraId,
+            updated_at: query.fn.now()
+        })
+        .returning('id');
 
-  static clear(): void {
-    this.instance.clear();
-  }
+    return result.length;
 }
 ```
 
----
+### Example 3: getVideosByCamera() Implementation
 
-## Open Questions & Future Enhancements
+```typescript
+async getVideosByCamera(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>> {
+    const offset = (page - 1) * limit;
 
-### 1. Unmapped FHWA Classes Display
+    const query = this._knex("video as v")
+        .innerJoin("folders as f", "v.folderId", "f.id")
+        .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+        .where("v.cameraId", cameraId);
 
-**Question:** Should the API response indicate which FHWA classes were excluded?
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+    const videos = await query.clone().limit(limit).offset(offset).orderBy('v.created_at', 'desc');
 
-**Example:**
+    return {
+        success: true,
+        data: videos,
+        page,
+        limit,
+        count: videos.length,
+        totalCount,
+        totalPages: Math.ceil(totalCount / limit),
+    };
+}
+```
 
-```json
-{
-  "customClasses": {
-    "Cars": 100,
-    "Heavy Trucks": 50
-  },
-  "unmappedCounts": {
-    "fhwaClass4": 10,
-    "fhwaClass5": 5
-  }
+### Example 4: getVideoIdsByFolderId() Implementation
+
+```typescript
+async getVideoIdsByFolderId(folderId: number): Promise<number[]> {
+    const rows = await this._knex('video')
+        .where({ folderId })
+        .select('id')
+        .orderBy('id', 'asc');
+
+    return rows.map(row => row.id);
 }
 ```
 
-**Recommendation:** Add this as optional metadata for debugging purposes.
+### Example 5: getVideosByCameraIdWithFolder() Implementation
 
-### 2. Configuration Change History
+```typescript
+async getVideosByCameraIdWithFolder(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>> {
+    const offset = (page - 1) * limit;
 
-**Question:** Should we track configuration changes over time?
+    const query = this._knex("video as v")
+        .innerJoin("folders as f", "v.folderId", "f.id")
+        .select("v.*", this._knex.raw("to_jsonb(f.*) as folder"))
+        .where("v.cameraId", cameraId);
 
-**Future Enhancement:** Add `report_configuration_history` table to track when configurations are created/modified.
+    const [countResult] = await query.clone().clearSelect().count("* as count");
+    const totalCount = +countResult.count;
+    const videos = await query.clone().limit(limit).offset(offset).orderBy('v.created_at', 'desc');
 
-### 3. Pedestrians & Bicycles
+    return {
+        success: true,
+        data: videos,
+        page,
+        limit,
+        count: videos.length,
+        totalCount,
+        totalPages: Math.ceil(totalCount / limit),
+    };
+}
+```
 
-**Question:** Current system excludes pedestrians/bicycles from FHWA mapping. Should users be able to create custom classes for non-motorized traffic?
+---
 
-**Recommendation:** Support this by adding FHWA classes 14-15 (non-motorized) in future iteration.
+## Migration Requirements
 
-### 4. Detection Label Variability
+**No new migrations needed** - All schema changes already exist:
 
-**Question:** What if video processing returns different detection labels than expected?
+- cameras table: migration 20250911000000_migration.ts
+- video.cameraId column: migration 20250911000000_migration.ts:19
+- folders.cameraId column: migration 20250911000000_migration.ts:25
+- All indexes already created
 
-**Recommendation:** Add logging and admin dashboard to monitor unmapped detection labels.
+**Optional migration for performance**:
+
+- Check if video.folderId index exists (likely already present)
 
 ---
 
-## Validation Checklist
+## Testing Strategy
+
+### Unit Tests Required
+
+**CameraDAO.getAllWithSearch()**
+
+- Test: Search with matching name (partial match)
+- Test: Search with no matches (empty result)
+- Test: Search with null/undefined name (return all)
+- Test: Pagination (page 1, page 2, etc.)
+- Test: Case insensitivity (ILIKE behavior)
+
+**CameraDAO.getVideosByCamera()**
+
+- Test: Camera with videos (verify folder JOIN)
+- Test: Camera with no videos (empty result)
+- Test: Pagination with multiple pages
+- Test: Verify folder data structure in results
+
+**VideoDAO.bulkUpdateCamera()**
+
+- Test: Update with cameraId (assignment)
+- Test: Update with null cameraId (unassignment)
+- Test: Update with transaction (commit)
+- Test: Update with transaction (rollback)
+- Test: Empty videoIds array (return 0)
+- Test: Invalid videoIds (non-existent IDs)
+
+**VideoDAO.getVideoIdsByFolderId()**
 
-Before marking this plan as complete, verify:
+- Test: Folder with videos (return IDs)
+- Test: Folder with no videos (empty array)
+- Test: Non-existent folderId (empty array)
+- Test: Large folder (100+ videos)
 
-- [x] Database schema includes all required fields
-- [x] Migration has proper up/down functions
-- [x] Seed data matches current system behavior
-- [x] Interface definitions match database schema
-- [x] DAO implements all IBaseDAO methods
-- [x] Validation logic covers all business rules (2-7 classes, no duplicates, 30 char limit)
-- [x] DETECTION_LABEL_TO_FHWA mapping is complete
-- [x] Integration strategy with VideoMinuteResultDAO is clear
-- [x] Export updates are documented
-- [x] Implementation order is logical
-- [x] Risks are identified and mitigated
-- [x] Testing strategy is comprehensive
+**VideoDAO.getVideosByCameraIdWithFolder()**
+
+- Test: Camera with videos (verify folder JOIN)
+- Test: Camera with no videos (empty result)
+- Test: Pagination
+- Test: Verify folder data in results
+- Test: Null cameraId handling
 
 ---
 
-## Pattern Compliance
+## Implementation Checklist
 
-### Database Patterns ✅
+### Pre-Implementation
 
-- Primary key: `id` (auto-increment)
-- External identifier: `uuid` (unique, not null, auto-generated)
-- Timestamps: `created_at`, `updated_at`
-- Foreign keys: N/A (system-wide table)
+- [ ] Check if video.folderId index exists in database
+- [ ] Review existing DAO patterns in camera.dao.ts and video.dao.ts
+- [ ] Verify IDataPaginator structure in d.types.ts
 
-### DAO Patterns ✅
+### Implementation Phase
 
-- Implements `IBaseDAO<IReportConfiguration>`
-- Singleton KnexManager connection
-- Methods: create, getById, getByUuid, getAll, update, delete
-- Custom methods: deleteWithValidation, getDefault, setDefault, validateConfiguration, applyConfiguration
+- [ ] Implement CameraDAO.getAllWithSearch()
+- [ ] Implement VideoDAO.getVideoIdsByFolderId()
+- [ ] Implement CameraDAO.getVideosByCamera()
+- [ ] Implement VideoDAO.getVideosByCameraIdWithFolder()
+- [ ] Implement VideoDAO.bulkUpdateCamera()
 
-### File Naming ✅
+### Testing Phase
 
-- Migration: `YYYYMMDDHHMMSS_create_report_configurations.ts`
-- DAO: `report-configuration.dao.ts`
-- Interface: `report-configuration.interfaces.ts` (matches folder structure)
+- [ ] Write unit tests for all 5 methods
+- [ ] Test transaction handling in bulkUpdateCamera
+- [ ] Test pagination edge cases (page 1, last page, beyond last page)
+- [ ] Test search with special characters (SQL injection prevention)
 
-### Performance ✅
+### Integration Phase
 
-- Indexed UUID for fast lookups
-- JOINs eliminated (no foreign keys, system-wide table)
-- Pagination implemented in getAll()
-- Future: Consider caching for frequently accessed configurations
+- [ ] Build knex-rel package: `npm run build`
+- [ ] Verify no TypeScript compilation errors
+- [ ] Test in api-rel: `npm run start:dev`
+- [ ] Verify all service methods work end-to-end
+- [ ] Test camera bulk assignment workflow
+- [ ] Test folder camera cascade workflow
 
 ---
 
-## Next Steps for Orchestrator
+## Risk Assessment
 
-This plan is now ready for handoff to the **knex-code-agent** for implementation.
+### Low Risk
 
-**Orchestrator should:**
+- getAllWithSearch() - Simple extension of getAll()
+- getVideoIdsByFolderId() - Straightforward SELECT query
 
-1. Review this plan for completeness
-2. Approve DETECTION_LABEL_TO_FHWA mapping accuracy
-3. Confirm migration timestamp format
-4. Hand off to knex-code-agent for execution
+### Medium Risk
 
-**knex-code-agent should:**
+- getVideosByCamera() - Requires correct JOIN syntax
+- getVideosByCameraIdWithFolder() - Same as above
 
-1. Implement in exact order specified (Phase 1 → Phase 2 → Phase 3 → Phase 4)
-2. Test each phase before proceeding
-3. Report any conflicts or issues discovered during implementation
-4. Request clarification if detection labels don't match expectations
+### High Risk
 
-**Blockers:**
+- bulkUpdateCamera() - Transaction handling complexity
+  - **Mitigation**: Carefully test both transaction and non-transaction paths
+  - **Mitigation**: Validate videoIds array before query
+  - **Mitigation**: Let service layer handle rollback logic
 
-- None identified. Plan is complete and ready for implementation.
+### Performance Risks
+
+- getVideoIdsByFolderId() could return large arrays (1000+ IDs)
+  - **Mitigation**: Acceptable for cascade operations
+  - **Mitigation**: Ensure folderId index exists for speed
+- getAllWithSearch() ILIKE with leading wildcard is slow
+  - **Mitigation**: Acceptable for small camera table
+  - **Mitigation**: Consider full-text search if needed later
 
 ---
 
-## Appendix: FHWA 13-Class System Reference
+## Summary
 
-```
-Class 1:  Motorcycles
-Class 2:  Passenger Cars
-Class 3:  Other Two-Axle, Four-Tire Single Unit Vehicles (Pickups, Vans)
-Class 4:  Buses
-Class 5:  Two-Axle, Six-Tire Single Unit Trucks (Work Vans)
-Class 6:  Three-Axle Single Unit Trucks
-Class 7:  Four or More Axle Single Unit Trucks
-Class 8:  Four or Less Axle Single Trailer Trucks
-Class 9:  Five-Axle Single Trailer Trucks
-Class 10: Six or More Axle Single Trailer Trucks
-Class 11: Five or Less Axle Multi-Trailer Trucks
-Class 12: Six-Axle Multi-Trailer Trucks
-Class 13: Seven or More Axle Multi-Trailer Trucks
-```
+All 5 missing methods have been thoroughly analyzed:
+
+- **Call patterns documented** from 8 different service method locations
+- **Data flow mapped** from API → Service → DAO → Database
+- **SQL queries designed** with proper JOINs, indexes, and performance
+- **Transaction handling** specified for bulkUpdateCamera()
+- **Type safety verified** - all interfaces already correct
+- **No migrations needed** - schema already complete
+- **Implementation order prioritized** - simple to complex
+- **Testing strategy defined** - 25+ test cases identified
+- **Risk assessment completed** - mitigations specified
+
+**Ready for implementation** - All patterns follow existing DAO conventions in codebase.
+
+---
 
-**Detection Label Mapping:**
+## Files to Modify
 
-- Classes 6-8: All map to `single_unit_truck` detection label
-- Classes 9-13: All map to `articulated_truck` detection label
-- This creates a many-to-one relationship at the detection level
+### knex-rel/src/dao/camera/camera.dao.ts
+
+- Add method: `getAllWithSearch(page, limit, name?)`
+- Add method: `getVideosByCamera(cameraId, page, limit)`
+
+### knex-rel/src/dao/video/video.dao.ts
+
+- Add method: `bulkUpdateCamera(videoIds, cameraId, trx?)`
+- Add method: `getVideoIdsByFolderId(folderId)`
+- Add method: `getVideosByCameraIdWithFolder(cameraId, page, limit)`
 
 ---
 
-## Document Version
+## Pattern Compliance Summary
+
+### Database Patterns ✅
+
+- All tables use `id` (auto-increment primary key)
+- All tables use `uuid` (unique, not null) for external references
+- All tables use `created_at`/`updated_at` timestamps
+- Foreign keys use ON DELETE SET NULL for cameras
+- Indexes on UUID and foreign keys
+
+### DAO Patterns ✅
+
+- Singleton KnexManager.getConnection()
+- Standard CRUD methods (create, getById, getByUuid, getAll, update, delete)
+- Pagination with IDataPaginator<T> return type
+- JOINs use to_jsonb() for nested objects
+- Transaction support via optional trx parameter
+
+### Query Patterns ✅
 
-- **Version:** 1.0
-- **Date:** 2025-09-30
-- **Author:** Database Planning Specialist (Claude)
-- **Status:** FINAL - Ready for Implementation
+- Use `this._knex` for queries
+- Use `query.clone()` for count vs data queries
+- Use `whereIn()` for array filters
+- Use `query.fn.now()` for timestamps
+- Use `returning('id')` for update counts