@trafficgroup/knex-rel 0.1.5 → 0.1.7

package/plan.md

@@ -1,831 +0,0 @@
-# Missing DAO Methods Implementation Plan
-
-## Executive Summary
-
-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.
-
----
-
-## Schema Analysis
-
-### Tables Involved
-
-**cameras**
-
-```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`
-
-**Method Signature**:
-
-```typescript
-async getAllWithSearch(page: number, limit: number, name?: string): Promise<IDataPaginator<ICamera>>
-```
-
-**Called From**: CameraService.getAllWithSearch()
-
-- **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**:
-
-```
-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
-```
-
-### Implementation Requirements
-
-**SQL Query**:
-
-```sql
--- Count query
-SELECT COUNT(*) as count FROM cameras WHERE name ILIKE '%search%'
-
--- Data query
-SELECT * FROM cameras
-WHERE name ILIKE '%search%'
-LIMIT ? OFFSET ?
-```
-
-**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
-
-**Performance Considerations**:
-
-- 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)
-
----
-
-## Method 2: CameraDAO.getVideosByCamera()
-
-### Call Analysis
-
-**Location**: `api-rel/src/service/camera/camera.service.ts:308`
-
-**Method Signature**:
-
-```typescript
-async getVideosByCamera(cameraId: number, page: number, limit: number): Promise<IDataPaginator<IVideo>>
-```
-
-**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
-```
-
-**Critical Detail**: Service expects folder data in response (line 312: mapToVideoWithFolderDTO)
-
-### Implementation Requirements
-
-**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
-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
-
-**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),
-    };
-}
-```
-
-### 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;
-}
-```
-
-### Example 3: getVideosByCamera() Implementation
-
-```typescript
-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),
-    };
-}
-```
-
-### 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);
-}
-```
-
-### Example 5: getVideosByCameraIdWithFolder() Implementation
-
-```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),
-    };
-}
-```
-
----
-
-## Migration Requirements
-
-**No new migrations needed** - All schema changes already exist:
-
-- 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
-
-**Optional migration for performance**:
-
-- Check if video.folderId index exists (likely already present)
-
----
-
-## 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()**
-
-- 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
-
-### Low Risk
-
-- getAllWithSearch() - Simple extension of getAll()
-- getVideoIdsByFolderId() - Straightforward SELECT query
-
-### Medium Risk
-
-- getVideosByCamera() - Requires correct JOIN syntax
-- getVideosByCameraIdWithFolder() - Same as above
-
-### High Risk
-
-- 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
-
-### 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
-
----
-
-## Summary
-
-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
-
-### 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 ✅
-
-- 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