@trafficgroup/knex-rel 0.1.3 → 0.1.5

package/plan.md

@@ -1,288 +1,831 @@
-# Database Optimization Plan for Camera Bulk Operations
+# Missing DAO Methods Implementation Plan
 
-## Current Schema Analysis
+## Executive Summary
 
-### Existing Tables & Indexes
+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.
 
-**cameras table:**
+---
 
-- Primary key: `id` (auto-increment)
-- Unique index: `uuid`
-- Composite index: `[longitude, latitude]` for geospatial queries
+## Schema Analysis
 
-**video table:**
+### Tables Involved
 
-- Primary key: `id`
-- Foreign key: `cameraId` → `cameras.id` (nullable, with index)
-- Foreign key: `folderId` → `folders.id` (with implicit index)
-- Unique index: `uuid`
-- Composite indexes:
-  - `[annotationSourceId]`
-  - `[folderId, videoType, status]` (template lookup)
+**cameras**
 
-**folders table:**
+```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)
+```
+
+**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)
+```
+
+**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)
+```
+
+---
+
+## Method 1: CameraDAO.getAllWithSearch()
+
+### Call Analysis
+
+**Location**: `api-rel/src/service/camera/camera.service.ts:274`
 
-- Primary key: `id`
-- Foreign key: `cameraId` → `cameras.id` (nullable, with index)
-- Foreign key: `studyId` → `study.id` (with implicit index)
-- Unique index: `uuid`
+**Method Signature**:
 
-### Performance Analysis for Required Operations
+```typescript
+async getAllWithSearch(page: number, limit: number, name?: string): Promise<IDataPaginator<ICamera>>
+```
 
-#### 1. ✅ Bulk update videos when folder cameraId changes
+**Called From**: CameraService.getAllWithSearch()
 
-**Query:** `UPDATE video SET cameraId = ? WHERE folderId = ?`
+- **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
 
-- **Current Performance:** GOOD
-- **Existing Index:** `[folderId]` (implicit from FK constraint)
-- **Status:** No optimization needed
+**Data Flow**:
 
-#### 2. ❌ Search cameras by name with pagination
+```
+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
+```
 
-**Query:** `SELECT * FROM cameras WHERE name ILIKE '%search%' ORDER BY name LIMIT ? OFFSET ?`
+### Implementation Requirements
 
-- **Current Performance:** POOR - Full table scan
-- **Missing Index:** Text search index on `name` column
-- **Impact:** Critical performance issue for camera search
+**SQL Query**:
 
-#### 3. ✅ Find videos by specific camera
+```sql
+-- Count query
+SELECT COUNT(*) as count FROM cameras WHERE name ILIKE '%search%'
+
+-- Data query
+SELECT * FROM cameras
+WHERE name ILIKE '%search%'
+LIMIT ? OFFSET ?
+```
 
-**Query:** `SELECT * FROM video WHERE cameraId = ?`
+**Key Details**:
 
-- **Current Performance:** GOOD
-- **Existing Index:** `[cameraId]` from migration `20250911000000_migration.ts`
-- **Status:** No optimization needed
+- 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
 
-#### 4. ⚠️ Bulk assign camera to multiple videos
+**Performance Considerations**:
 
-**Query:** `UPDATE video SET cameraId = ? WHERE id IN (...)`
+- 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)
 
-- **Current Performance:** ACCEPTABLE but can be optimized
-- **Existing Index:** Primary key on `id`
-- **Optimization Opportunity:** Batch processing with transaction optimization
+---
 
-## Required Database Optimizations
+## Method 2: CameraDAO.getVideosByCamera()
 
-### New Migrations Required
+### Call Analysis
 
-#### Migration: Add camera name search index
+**Location**: `api-rel/src/service/camera/camera.service.ts:308`
 
-**File:** `20250924000000_camera_name_search_index.ts`
-**Purpose:** Optimize camera search by name functionality
+**Method Signature**:
 
 ```typescript
-export async function up(knex: Knex): Promise<void> {
-  await knex.schema.alterTable("cameras", (table) => {
-    // Add index for case-insensitive name searches
-    table.index(knex.raw("LOWER(name)"), "idx_cameras_name_lower");
-  });
-
-  // Add GIN index for full-text search if needed for fuzzy matching
-  await knex.raw(`
-    CREATE INDEX idx_cameras_name_gin
-    ON cameras
-    USING GIN (to_tsvector('english', name))
-  `);
-}
+async getVideosByCamera(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>>
+```
 
-export async function down(knex: Knex): Promise<void> {
-  await knex.raw("DROP INDEX IF EXISTS idx_cameras_name_gin");
-  await knex.schema.alterTable("cameras", (table) => {
-    table.dropIndex(knex.raw("LOWER(name)"), "idx_cameras_name_lower");
-  });
-}
+**Called From**: CameraService.getVideosByCamera()
+
+- **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**:
+
+```
+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
 ```
 
-### DAO Method Optimizations
+**Critical Detail**: Service expects folder data in response (line 312: mapToVideoWithFolderDTO)
 
-#### CameraDAO Enhancements Required
+### Implementation Requirements
 
-**New Methods Needed:**
+**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 ?
+```
+
+**Key Details**:
+
+- 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**:
+
+- 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
+
+---
+
+## Method 3: VideoDAO.bulkUpdateCamera()
+
+### Call Analysis
+
+**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`
+
+**Method Signature**:
 
 ```typescript
-// Optimized paginated search by name
-async searchByName(
-  searchTerm: string,
-  page: number,
-  limit: number
-): Promise<IDataPaginator<ICamera>> {
-  const offset = (page - 1) * limit;
-  const searchPattern = `%${searchTerm.toLowerCase()}%`;
-
-  const query = this._knex("cameras")
-    .whereRaw("LOWER(name) LIKE ?", [searchPattern])
-    .orderBy("name");
-
-  const [countResult] = await query.clone().clearSelect().count("* as count");
-  const totalCount = +countResult.count;
-  const cameras = await query.clone().limit(limit).offset(offset);
-
-  return {
-    success: true,
-    data: cameras,
-    page,
-    limit,
-    count: cameras.length,
-    totalCount,
-    totalPages: Math.ceil(totalCount / limit),
-  };
-}
+async bulkUpdateCamera(videoIds: number[], cameraId: number | null, trx?: Knex.Transaction): Promise<number>
+```
+
+**Call Patterns**:
+
+**Pattern 1 - CameraService.bulkAssignToVideos() (line 364)**:
+
+- 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)
+
+**Pattern 2 - VideoService.bulkUpdateCamera() (line 34)**:
+
+- 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)
+
+**Pattern 3 - FolderService.cascadeUpdateVideosCamera() (line 96)**:
+
+- 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)
+
+### Implementation Requirements
+
+**SQL Query**:
+
+```sql
+UPDATE video
+SET cameraId = ?, updated_at = NOW()
+WHERE id = ANY(?)
+RETURNING id
+```
+
+**Key Details**:
+
+- 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
+
+**Transaction Handling**:
+
+```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;
+```
+
+**Performance Considerations**:
+
+- 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)
+
+**Error Handling**:
+
+- If transaction fails in caller, rollback handles cleanup
+- Return 0 if videoIds is empty array
+- Let Knex errors propagate to service layer
+
+---
+
+## Method 4: VideoDAO.getVideoIdsByFolderId()
+
+### Call Analysis
+
+**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`
+
+**Method Signature**:
+
+```typescript
+async getVideoIdsByFolderId(folderId: number): Promise<number[]>
+```
+
+**Call Patterns**:
+
+**Pattern 1 - FolderService.updateWithCameraCascade() (line 49)**:
+
+- 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
+
+**Pattern 2 - FolderService.cascadeUpdateVideosCamera() (line 89)**:
+
+- 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)
+
+**Pattern 3 - FolderService.getVideoCascadeCount() (line 163)**:
+
+- Context: Count videos that would be affected by cascade
+- Parameters: folder.id
+- Return: videoIds.length for count (line 164)
+- Read-only operation (no updates)
+
+**Pattern 4 - VideoService.getVideoIdsByFolderId() (line 119)**:
+
+- Context: Get all video IDs in folder for cascade operations
+- Parameters: folderId
+- Return: number[] passed back to caller
+- Used for service-level cascade logic
+
+### Implementation Requirements
+
+**SQL Query**:
+
+```sql
+SELECT id FROM video WHERE folderId = ?
+```
+
+**Key Details**:
+
+- 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)
+
+**Performance Considerations**:
+
+- 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
+
+**Return Value**:
+
+```typescript
+const ids = await this._knex("video")
+  .where({ folderId })
+  .select("id")
+  .orderBy("id", "asc");
+return ids.map((row) => row.id);
+```
+
+---
+
+## Method 5: VideoDAO.getVideosByCameraIdWithFolder()
+
+### Call Analysis
+
+**Location**: `api-rel/src/service/video/video.service.ts:77`
+
+**Method Signature**:
+
+```typescript
+async getVideosByCameraIdWithFolder(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>>
+```
+
+**Called From**: VideoService.getVideosByCameraId()
+
+- **Parameters**: cameraId (numeric ID), page, limit
+- **Return Value**: IDataPaginator<IVideo> - directly returned to caller
+- **Purpose**: Get paginated videos for a camera with folder info
+
+**Data Flow**:
+
+```
+API/Service Request → VideoService.getVideosByCameraId(cameraId, page, limit)
+  → VideoDAO.getVideosByCameraIdWithFolder(cameraId, page, limit)
+  → Returns IDataPaginator<IVideo>
+  → Service returns directly (line 77)
+```
+
+**Critical Detail**: Method name explicitly includes "WithFolder" - MUST JOIN folders
+
+### Implementation Requirements
 
-// Get all videos associated with a camera (with pagination)
-async getVideosByCamera(
-  cameraId: number,
-  page: number,
-  limit: number
-): Promise<IDataPaginator<IVideo>> {
-  const offset = (page - 1) * limit;
-
-  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)
-    .orderBy("v.created_at", "desc");
-
-  const [countResult] = await query.clone().clearSelect().count("* as count");
-  const totalCount = +countResult.count;
-  const videos = await query.clone().limit(limit).offset(offset);
-
-  return {
-    success: true,
-    data: videos,
-    page,
-    limit,
-    count: videos.length,
-    totalCount,
-    totalPages: Math.ceil(totalCount / limit),
-  };
+**SQL Query**:
+
+```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 ?
+```
+
+**Key Details**:
+
+- 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>
+
+**Performance Considerations**:
+
+- Same as Method 2 (getVideosByCamera)
+- cameraId indexed
+- Consider composite index on (cameraId, created_at) for sorting
+
+**Pattern Consistency**:
+
+- This method duplicates CameraDAO.getVideosByCamera() logic
+- Both should use IDENTICAL query structure
+- Consider refactoring to shared private method in future
+
+---
+
+## Implementation Order
+
+### Phase 1: Simple Methods (No Dependencies)
+
+1. **CameraDAO.getAllWithSearch()** - Standalone search method
+2. **VideoDAO.getVideoIdsByFolderId()** - Simple ID retrieval
+
+### Phase 2: Complex Query Methods (JOINs)
+
+3. **CameraDAO.getVideosByCamera()** - JOIN with folders
+4. **VideoDAO.getVideosByCameraIdWithFolder()** - Same as #3, different DAO
+
+### Phase 3: Transaction-Aware Methods
+
+5. **VideoDAO.bulkUpdateCamera()** - Transaction support required
+
+---
+
+## Database Indexing Recommendations
+
+### Existing Indexes (Already Present)
+
+- 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)
+
+### Recommended New Indexes
+
+**Optional - cameras.name (for search optimization)**
+
+```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)
+
+**High Priority - video.folderId (for cascade operations)**
+
+```sql
+CREATE INDEX idx_video_folder_id ON video(folderId);
+```
+
+- Benefits: Critical for getVideoIdsByFolderId() performance
+- Usage: Heavy usage in cascade operations
+- Decision: **CHECK IF EXISTS** - likely already present
+
+**Optional - video.(cameraId, created_at) composite**
+
+```sql
+CREATE INDEX idx_video_camera_created ON video(cameraId, created_at DESC);
+```
+
+- Benefits: Optimizes sorted queries in getVideosByCameraIdWithFolder
+- Decision: SKIP for now (single column index sufficient)
+
+---
+
+## Type Safety & Interfaces
+
+All methods already have proper TypeScript interfaces defined:
+
+**ICamera** - knex-rel/src/interfaces/camera/camera.interfaces.ts
+
+- All fields present and correct
+- No modifications needed
+
+**IVideo** - knex-rel/src/interfaces/video/video.interfaces.ts
+
+- Includes optional folder?: IFolder field (line 33)
+- Includes optional cameraId?: number field (line 8)
+- Supports all required fields
+- No modifications needed
+
+**IDataPaginator<T>** - Used consistently across all methods
+
+- success: boolean
+- data: T[]
+- page: number
+- limit: number
+- count: number
+- totalCount: number
+- totalPages: number
+
+---
+
+## Error Handling Patterns
+
+### Pattern 1: Search Methods (getAllWithSearch)
+
+```typescript
+// No try/catch in DAO
+// Let Knex errors propagate to service
+const result = await query...
+return result;
+```
+
+### Pattern 2: Transaction Methods (bulkUpdateCamera)
+
+```typescript
+// 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;
+```
+
+### Pattern 3: Simple Queries (getVideoIdsByFolderId)
+
+```typescript
+// No try/catch needed
+// Direct Knex query with error propagation
+const ids = await this._knex...
+return ids.map(row => row.id);
+```
+
+---
+
+## Code Pattern Examples
+
+### Example 1: getAllWithSearch() Implementation
+
+```typescript
+async getAllWithSearch(page: number, limit: number, name?: string): Promise<IDataPaginator<ICamera>> {
+    const offset = (page - 1) * limit;
+
+    let query = this._knex("cameras");
+
+    // Apply search filter if name provided
+    if (name && name.trim().length > 0) {
+        query = query.where('name', 'ilike', `%${name.trim()}%`);
+    }
+
+    const [countResult] = await query.clone().count("* as count");
+    const totalCount = +countResult.count;
+    const cameras = await query.clone().limit(limit).offset(offset).orderBy('name', 'asc');
+
+    return {
+        success: true,
+        data: cameras,
+        page,
+        limit,
+        count: cameras.length,
+        totalCount,
+        totalPages: Math.ceil(totalCount / limit),
+    };
 }
 ```
 
-#### VideoDAO Enhancements Required
+### Example 2: bulkUpdateCamera() Implementation
+
+```typescript
+async bulkUpdateCamera(videoIds: number[], cameraId: number | null, trx?: Knex.Transaction): Promise<number> {
+    if (!videoIds || videoIds.length === 0) {
+        return 0;
+    }
+
+    const query = trx || this._knex;
+
+    const result = await query('video')
+        .whereIn('id', videoIds)
+        .update({
+            cameraId: cameraId,
+            updated_at: query.fn.now()
+        })
+        .returning('id');
+
+    return result.length;
+}
+```
 
-**New Methods Needed:**
+### Example 3: getVideosByCamera() Implementation
 
 ```typescript
-// Bulk update videos by folder (folder camera cascade)
-async bulkUpdateCameraByFolder(
-  folderId: number,
-  cameraId: number | null
-): Promise<number> {
-  const result = await this._knex("video")
-    .where("folderId", folderId)
-    .update({
-      cameraId: cameraId,
-      updated_at: this._knex.fn.now()
-    });
-  return result;
+async getVideosByCamera(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>> {
+    const offset = (page - 1) * limit;
+
+    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);
+
+    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');
+
+    return {
+        success: true,
+        data: videos,
+        page,
+        limit,
+        count: videos.length,
+        totalCount,
+        totalPages: Math.ceil(totalCount / limit),
+    };
 }
+```
 
-// Bulk assign camera to multiple videos
-async bulkUpdateCamera(
-  videoIds: number[],
-  cameraId: number | null
-): Promise<number> {
-  if (videoIds.length === 0) return 0;
-
-  const result = await this._knex("video")
-    .whereIn("id", videoIds)
-    .update({
-      cameraId: cameraId,
-      updated_at: this._knex.fn.now()
-    });
-  return result;
+### 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);
 }
+```
 
-// Get videos by multiple folder IDs (for folder camera propagation)
-async getVideosByFolderIds(folderIds: number[]): Promise<IVideo[]> {
-  if (folderIds.length === 0) return [];
+### Example 5: getVideosByCameraIdWithFolder() Implementation
 
-  return await this._knex("video")
-    .whereIn("folderId", folderIds)
-    .select("id", "uuid", "name", "folderId", "cameraId");
+```typescript
+async getVideosByCameraIdWithFolder(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>> {
+    const offset = (page - 1) * limit;
+
+    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);
+
+    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');
+
+    return {
+        success: true,
+        data: videos,
+        page,
+        limit,
+        count: videos.length,
+        totalCount,
+        totalPages: Math.ceil(totalCount / limit),
+    };
 }
 ```
 
-## Query Performance Strategies
+---
 
-### 1. Camera Search Optimization
+## Migration Requirements
 
-- **Index Strategy:** Case-insensitive BTREE index on `LOWER(name)`
-- **Query Pattern:** `WHERE LOWER(name) LIKE LOWER(?)`
-- **Full-text Option:** GIN index with `to_tsvector()` for fuzzy search
-- **Expected Performance:** O(log n) lookup instead of O(n) scan
+**No new migrations needed** - All schema changes already exist:
 
-### 2. Bulk Operation Optimization
+- 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
 
-- **Transaction Wrapping:** All bulk operations in single transactions
-- **Batch Size Limits:** Process in chunks of 1000 records max
-- **Index Usage:** Leverage existing primary key and foreign key indexes
+**Optional migration for performance**:
 
-### 3. Folder Camera Cascade Optimization
+- Check if video.folderId index exists (likely already present)
 
-- **Single Query Strategy:** Use `WHERE folderId = ?` leveraging existing index
-- **Atomic Updates:** Single UPDATE statement rather than individual updates
-- **Expected Performance:** O(log n) folder lookup + O(k) video updates
+---
 
-## Implementation Order
+## 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()**
 
-1. **Migration First:** Deploy camera name search index
-2. **DAO Methods:** Add optimized search and bulk operation methods
-3. **Transaction Optimization:** Implement proper transaction handling
-4. **Testing:** Validate performance improvements
+- 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()**
+
+- Test: Folder with videos (return IDs)
+- Test: Folder with no videos (empty array)
+- Test: Non-existent folderId (empty array)
+- Test: Large folder (100+ videos)
+
+**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
+
+---
+
+## Implementation Checklist
+
+### Pre-Implementation
+
+- [ ] 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
+
+### Implementation Phase
+
+- [ ] Implement CameraDAO.getAllWithSearch()
+- [ ] Implement VideoDAO.getVideoIdsByFolderId()
+- [ ] Implement CameraDAO.getVideosByCamera()
+- [ ] Implement VideoDAO.getVideosByCameraIdWithFolder()
+- [ ] Implement VideoDAO.bulkUpdateCamera()
+
+### Testing Phase
+
+- [ ] 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)
+
+### Integration Phase
+
+- [ ] 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
+
+---
 
 ## Risk Assessment
 
-### Migration Safety: LOW RISK
+### Low Risk
 
-- Adding indexes is non-blocking operation
-- No data changes, only performance improvements
-- Easy rollback with down migration
+- getAllWithSearch() - Simple extension of getAll()
+- getVideoIdsByFolderId() - Straightforward SELECT query
 
-### Performance Impact: HIGH BENEFIT
+### Medium Risk
 
-- Camera search: 100x-1000x improvement (O(n) → O(log n))
-- Bulk operations: Proper indexing already exists
-- Folder cascade: Leverages existing folderId index
+- getVideosByCamera() - Requires correct JOIN syntax
+- getVideosByCameraIdWithFolder() - Same as above
 
-### Pattern Compliance: 100% COMPLIANT
+### High Risk
 
-- Follows existing DAO patterns exactly
-- Maintains IBaseDAO interface requirements
-- Uses established naming conventions
-- Preserves UUID external API pattern
+- 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
 
-## Validation Strategy
+### Performance Risks
 
-### Performance Testing Queries
+- 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
 
-```sql
--- Test camera search performance
-EXPLAIN ANALYZE SELECT * FROM cameras
-WHERE LOWER(name) LIKE '%traffic%'
-ORDER BY name LIMIT 20;
+---
 
--- Test video-by-camera lookup
-EXPLAIN ANALYZE SELECT * FROM video
-WHERE cameraId = 1
-ORDER BY created_at DESC LIMIT 20;
+## Summary
 
--- Test folder cascade update
-EXPLAIN ANALYZE UPDATE video
-SET cameraId = 1 WHERE folderId = 5;
-```
+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.
+
+---
+
+## Files to Modify
+
+### 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)`
+
+---
+
+## Pattern Compliance Summary
 
-### Success Metrics
+### Database Patterns ✅
 
-- Camera search < 50ms for 10k+ cameras
-- Video-by-camera < 100ms for 1k+ videos
-- Folder cascade < 200ms for 100+ videos per folder
-- Bulk video update < 500ms for 1000+ videos
+- 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
 
-## Conclusion
+### DAO Patterns ✅
 
-**Current Status:** Schema is well-designed with most needed indexes already present. Only critical gap is camera name search optimization.
+- 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
 
-**Priority:** HIGH for camera name search index, MEDIUM for DAO method enhancements.
+### Query Patterns ✅
 
-**Complexity:** LOW - Single migration required, standard DAO patterns.
+- 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