fix: Fix folder media in timeline when camera is not timeline supported (#2246)

- Closes: #2205
2025-11-24 14:33:06 -08:00
parent f50bef7446
commit 1f6a4ddce2
20 changed files with 1011 additions and 421 deletions
@@ -1,6 +1,8 @@
+import { add } from 'date-fns';
 import { DataSet } from 'vis-data';
 import { TimelineWindow } from 'vis-timeline';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
 import { CameraManager } from '../../../src/camera-manager/manager';
 import {
  Engine,
@@ -11,13 +13,15 @@ import {
  RecordingSegmentsQuery,
  RecordingSegmentsQueryResults,
 } from '../../../src/camera-manager/types';
+import { FoldersManager } from '../../../src/card-controller/folders/manager';
 import {
  AdvancedCameraCardTimelineItem,
  TimelineDataSource,
 } from '../../../src/components-lib/timeline/source';
-import { TimelineKey } from '../../../src/components-lib/timeline/types';
+import { TimelineKeys } from '../../../src/components-lib/timeline/types';
+import { ConditionStateManagerReadonlyInterface } from '../../../src/conditions/types';
 import { ViewMediaType } from '../../../src/view/item';
-import { EventMediaQuery } from '../../../src/view/query';
+import { FolderViewQuery } from '../../../src/view/query';
 import {
  createCameraManager,
  createFolder,
@@ -26,7 +30,7 @@ import {
  TestViewMedia,
 } from '../../test-utils';

-const CAMERA_ID = 'CAMERA_ID';
+const CAMERA_ID = 'camera-1';
 const TEST_MEDIA_ID = 'TEST_MEDIA_ID';
 const RECORDING_SEGMENT_ID = 'SEGMENT_ID';
 const EXPECTED_RECORDING_ID = `recording-${CAMERA_ID}-${RECORDING_SEGMENT_ID}`;
@@ -34,13 +38,21 @@ const EXPECTED_RECORDING_ID = `recording-${CAMERA_ID}-${RECORDING_SEGMENT_ID}`;
 const start = new Date('2025-09-21T19:31:06Z');
 const end = new Date('2025-09-21T19:31:15Z');

-const testMedia = new TestViewMedia({
+const testCameraMedia = new TestViewMedia({
  cameraID: CAMERA_ID,
  id: TEST_MEDIA_ID,
  startTime: start,
  endTime: end,
 });

+const folder = createFolder({ id: 'folder/folder-1', title: 'Folder Title' });
+const testFolderMedia = new TestViewMedia({
+  folder,
+  id: TEST_MEDIA_ID,
+  startTime: start,
+  endTime: end,
+});
+
 const createTestCameraManager = (): CameraManager => {
  const cameraManager = createCameraManager(
    createStore([
@@ -62,7 +74,7 @@ const createTestCameraManager = (): CameraManager => {
  };

  vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue([eventQuery]);
-  vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue([testMedia]);
+  vi.mocked(cameraManager.executeMediaQueries).mockResolvedValue([testCameraMedia]);

  const recordingSegmentQuery: RecordingSegmentsQuery = {
    type: QueryType.RecordingSegments,
@@ -92,33 +104,83 @@ const createTestCameraManager = (): CameraManager => {
 };

 describe('TimelineDataSource', () => {
-  const folder = createFolder({ id: 'folder/FOLDER_ID', title: 'Folder Title' });
-  const timelineKeys: TimelineKey[] = [
-    { type: 'camera', cameraID: 'CAMERA_ID' },
-    { type: 'folder', folder: folder },
-  ];
+  const cameraTimelineKeys: TimelineKeys = {
+    type: 'camera',
+    cameraIDs: new Set(['camera-1', 'camera-2']),
+  };
+  const folderTimelineKeys: TimelineKeys = {
+    type: 'folder',
+    folder,
+  };

  beforeEach(() => {
    vi.clearAllMocks();
  });

-  describe('should get groups', () => {
-    it('should get mixed groups', () => {
+  describe('should get key type', () => {
+    it('should get camera key type', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.getKeyType()).toBe('camera');
+    });
+
+    it('should get folder key type', () => {
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.getKeyType()).toBe('folder');
+    });
+  });
+
+  describe('should get groups', () => {
+    it('should get camera based groups', () => {
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );

      expect(source.groups.length).toBe(2);
-      expect(source.groups.get('camera/CAMERA_ID')).toEqual({
+      expect(source.groups.get('camera/camera-1')).toEqual({
        content: 'Camera Title',
-        id: 'camera/CAMERA_ID',
+        id: 'camera/camera-1',
      });
-      expect(source.groups.get('folder/FOLDER_ID')).toEqual({
+      expect(source.groups.get('camera/camera-2')).toEqual({
+        content: 'Camera Title',
+        id: 'camera/camera-2',
+      });
+    });
+
+    it('should get folder based groups', () => {
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.groups.length).toBe(1);
+      expect(source.groups.get('folder/folder-1')).toEqual({
        content: 'Folder Title',
-        id: 'folder/FOLDER_ID',
+        id: 'folder/folder-1',
      });
    });

@@ -126,28 +188,58 @@ describe('TimelineDataSource', () => {
      const cameraManager = createTestCameraManager();
      vi.mocked(cameraManager.getCameraMetadata).mockReturnValue(null);

-      const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+      const source = new TimelineDataSource(
+        cameraManager,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );

-      expect(source.groups.get('camera/CAMERA_ID')).toEqual({
-        content: 'CAMERA_ID',
-        id: 'camera/CAMERA_ID',
+      expect(source.groups.get('camera/camera-1')).toEqual({
+        content: 'camera-1',
+        id: 'camera/camera-1',
      });
    });

    it('should use folder id if folder has no title', () => {
-      const folder = createFolder({ id: 'folder/FOLDER_ID' });
-      const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
+      const folder = createFolder({ id: 'folder/folder-1' });
+      const timelineKeys: TimelineKeys = { type: 'folder', folder };

      const source = new TimelineDataSource(
        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
        timelineKeys,
        'all',
        true,
      );

-      expect(source.groups.get('folder/FOLDER_ID')).toEqual({
-        content: 'folder/FOLDER_ID',
-        id: 'folder/FOLDER_ID',
+      expect(source.groups.length).toBe(1);
+      expect(source.groups.get('folder/folder-1')).toEqual({
+        content: 'folder/folder-1',
+        id: 'folder/folder-1',
+      });
+    });
+
+    it('should have no groups if a folder key has no folder', () => {
+      const folder = createFolder({ id: 'folder/folder-1' });
+      const timelineKeys: TimelineKeys = { type: 'folder', folder };
+
+      const source = new TimelineDataSource(
+        createTestCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        timelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.groups.length).toBe(1);
+      expect(source.groups.get('folder/folder-1')).toEqual({
+        content: 'folder/folder-1',
+        id: 'folder/folder-1',
      });
    });
  });
@@ -158,7 +250,7 @@ describe('TimelineDataSource', () => {
      const endTime = new Date('2025-09-21T15:35:28Z');
      const id = 'EVENT_ID';
      const media = new TestViewMedia({
-        cameraID: 'CAMERA_ID',
+        cameraID: 'camera-1',
        id,
        startTime,
        endTime,
@@ -166,7 +258,9 @@ describe('TimelineDataSource', () => {

      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -178,7 +272,7 @@ describe('TimelineDataSource', () => {
        start: startTime.getTime(),
        end: endTime.getTime(),
        media,
-        group: 'camera/CAMERA_ID',
+        group: 'camera/camera-1',
        content: '',
        type: 'range',
      });
@@ -200,7 +294,9 @@ describe('TimelineDataSource', () => {

      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
        'all',
        true,
      );
@@ -221,7 +317,9 @@ describe('TimelineDataSource', () => {
    it('should ignore non-events media', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -238,7 +336,9 @@ describe('TimelineDataSource', () => {
    it('should ignore null results', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -251,7 +351,9 @@ describe('TimelineDataSource', () => {
    it('should ignore media without camera or folder ownership', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -279,83 +381,195 @@ describe('TimelineDataSource', () => {
        vi.restoreAllMocks();
      });

-      it('should refresh events successfully', async () => {
-        const source = new TimelineDataSource(
-          createTestCameraManager(),
-          timelineKeys,
-          'all',
-          false,
-        );
-        const view = createView();
+      describe('should refresh events from camera', () => {
+        it('should refresh events successfully', async () => {
+          const source = new TimelineDataSource(
+            createTestCameraManager(),
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+          const view = createView();

-        await source.refresh(window, view);
+          await source.refresh(window, { view });

-        expect(source.dataset.length).toBe(1);
+          expect(source.dataset.length).toBe(1);

-        expect(source.dataset.get('TEST_MEDIA_ID')).toEqual({
-          id: 'TEST_MEDIA_ID',
-          content: '',
-          start: new Date('2025-09-21T19:31:06Z').getTime(),
-          end: new Date('2025-09-21T19:31:15Z').getTime(),
-          media: testMedia,
-          type: 'range',
-          group: 'camera/CAMERA_ID',
+          expect(source.dataset.get('TEST_MEDIA_ID')).toEqual({
+            id: 'TEST_MEDIA_ID',
+            content: '',
+            start: new Date('2025-09-21T19:31:06Z').getTime(),
+            end: new Date('2025-09-21T19:31:15Z').getTime(),
+            media: testCameraMedia,
+            type: 'range',
+            group: 'camera/camera-1',
+          });
+        });
+
+        it('should refresh events and handle exception', async () => {
+          const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+
+          const cameraManager = createTestCameraManager();
+          vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(
+            new Error('Error fetching events'),
+          );
+
+          const source = new TimelineDataSource(
+            cameraManager,
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+
+          expect(source.dataset.length).toBe(0);
+
+          await source.refresh(window);
+
+          expect(source.dataset.length).toBe(0);
+
+          expect(consoleSpy).toHaveBeenCalledWith('Error fetching events');
+        });
+
+        it('should not refresh events when window is cached', async () => {
+          const cameraManager = createTestCameraManager();
+          const source = new TimelineDataSource(
+            cameraManager,
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+          const view = createView();
+
+          await source.refresh(window, { view });
+          expect(source.dataset.length).toBe(1);
+
+          await source.refresh(window, { view });
+          expect(source.dataset.length).toBe(1);
+          expect(cameraManager.executeMediaQueries).toHaveBeenCalledTimes(1);
+        });
+
+        it('should not refresh events when unable to create event queries', async () => {
+          const cameraManager = createTestCameraManager();
+          vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue(null);
+
+          const source = new TimelineDataSource(
+            cameraManager,
+            mock<FoldersManager>(),
+            mock<ConditionStateManagerReadonlyInterface>(),
+            cameraTimelineKeys,
+            'all',
+            false,
+          );
+
+          await source.refresh(window);
+          expect(source.dataset.length).toBe(0);
        });
      });

-      it('should refresh events and handle exception', async () => {
-        const consoleSpy = vi.spyOn(global.console, 'warn').mockReturnValue(undefined);
+      describe('should refresh events from folder', () => {
+        it('should refresh events successfully', async () => {
+          const foldersManager = mock<FoldersManager>();
+          vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+            folder,
+            path: [{}],
+          });
+          vi.mocked(foldersManager.expandFolder).mockResolvedValue([testFolderMedia]);

-        const cameraManager = createTestCameraManager();
-        vi.mocked(cameraManager.executeMediaQueries).mockRejectedValue(
-          new Error('Error fetching events'),
-        );
+          const source = new TimelineDataSource(
+            mock<CameraManager>(),
+            foldersManager,
+            mock<ConditionStateManagerReadonlyInterface>(),
+            folderTimelineKeys,
+            'all',
+            false,
+          );
+          const view = createView();

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', false);
+          await source.refresh(window, { view });

-        expect(source.dataset.length).toBe(0);
+          expect(source.dataset.length).toBe(1);

-        await source.refresh(window);
+          expect(source.dataset.get('TEST_MEDIA_ID')).toEqual({
+            id: 'TEST_MEDIA_ID',
+            content: '',
+            start: new Date('2025-09-21T19:31:06Z').getTime(),
+            end: new Date('2025-09-21T19:31:15Z').getTime(),
+            media: testFolderMedia,
+            type: 'range',
+            group: 'folder/folder-1',
+            query: expect.any(FolderViewQuery),
+          });
+        });

-        expect(source.dataset.length).toBe(0);
+        describe('should refresh events from folder cached', () => {
+          beforeAll(() => {
+            vi.useFakeTimers();
+          });

-        expect(consoleSpy).toHaveBeenCalledWith('Error fetching events');
-      });
+          afterAll(() => {
+            vi.useRealTimers();
+          });

-      it('should not refresh events when window is cached', async () => {
-        const cameraManager = createTestCameraManager();
-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', false);
-        const view = createView();
+          it('should refresh events only when not cached', async () => {
+            const foldersManager = mock<FoldersManager>();
+            vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+              folder,
+              path: [{}],
+            });
+            vi.mocked(foldersManager.expandFolder).mockResolvedValue([testFolderMedia]);

-        await source.refresh(window, view);
-        expect(source.dataset.length).toBe(1);
+            const source = new TimelineDataSource(
+              mock<CameraManager>(),
+              foldersManager,
+              mock<ConditionStateManagerReadonlyInterface>(),
+              folderTimelineKeys,
+              'all',
+              false,
+            );
+            const view = createView();

-        await source.refresh(window, view);
-        expect(source.dataset.length).toBe(1);
-        expect(cameraManager.executeMediaQueries).toHaveBeenCalledTimes(1);
-      });
+            await source.refresh(window, { view });
+            await source.refresh(window, { view });
+            await source.refresh(window, { view });

-      it('should not refresh events when events in view', async () => {
-        const source = new TimelineDataSource(
-          createTestCameraManager(),
-          timelineKeys,
-          'all',
-          false,
-        );
+            expect(foldersManager.expandFolder).toHaveBeenCalledTimes(1);
+          });

-        await source.refresh(window, createView({ query: new EventMediaQuery() }));
+          it('should refresh events when cached expired', async () => {
+            const start = new Date();
+            vi.setSystemTime(start);
+            const foldersManager = mock<FoldersManager>();
+            vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+              folder,
+              path: [{}],
+            });
+            vi.mocked(foldersManager.expandFolder).mockResolvedValue([testFolderMedia]);

-        expect(source.dataset.length).toBe(0);
-      });
+            const source = new TimelineDataSource(
+              mock<CameraManager>(),
+              foldersManager,
+              mock<ConditionStateManagerReadonlyInterface>(),
+              folderTimelineKeys,
+              'all',
+              false,
+            );
+            const view = createView();

-      it('should not refresh events when unable to create event queries', async () => {
-        const cameraManager = createTestCameraManager();
-        vi.mocked(cameraManager.generateDefaultEventQueries).mockReturnValue(null);
+            await source.refresh(window, { view });

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', false);
+            vi.setSystemTime(add(start, { hours: 1 }));

-        await source.refresh(window);
-        expect(source.dataset.length).toBe(0);
+            await source.refresh(window, { view });
+
+            expect(foldersManager.expandFolder).toHaveBeenCalledTimes(2);
+          });
+        });
      });
    });

@@ -369,7 +583,9 @@ describe('TimelineDataSource', () => {
      it('should refresh recordings successfully', async () => {
        const source = new TimelineDataSource(
          createTestCameraManager(),
-          timelineKeys,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
          'all',
          true,
        );
@@ -382,7 +598,7 @@ describe('TimelineDataSource', () => {
        expect(source.dataset.get(EXPECTED_RECORDING_ID)).toEqual({
          content: '',
          end: 1695307875000,
-          group: 'camera/CAMERA_ID',
+          group: 'camera/camera-1',
          id: EXPECTED_RECORDING_ID,
          start: 1695307866000,
          type: 'background',
@@ -397,7 +613,14 @@ describe('TimelineDataSource', () => {
          new Error('Error fetching recordings'),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        expect(getRecordings(source.dataset).length).toBe(0);

@@ -410,7 +633,14 @@ describe('TimelineDataSource', () => {

      it('should not refresh recordings when window is cached', async () => {
        const cameraManager = createTestCameraManager();
-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);
        expect(getRecordings(source.dataset).length).toBe(1);
@@ -424,7 +654,9 @@ describe('TimelineDataSource', () => {
      it('should not refresh recordings when recordings disabled', async () => {
        const source = new TimelineDataSource(
          createTestCameraManager(),
-          timelineKeys,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
          'all',

          // Disable recordings.
@@ -436,12 +668,31 @@ describe('TimelineDataSource', () => {
        expect(source.dataset.get(EXPECTED_RECORDING_ID)).toBeNull();
      });

-      it('should not refresh recordings without any cameras', async () => {
-        const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
-
+      it('should not refresh recordings with folders', async () => {
        const source = new TimelineDataSource(
          createTestCameraManager(),
-          timelineKeys,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          folderTimelineKeys,
+          'all',
+          true,
+        );
+
+        await source.refresh(window);
+
+        expect(source.dataset.get(EXPECTED_RECORDING_ID)).toBeNull();
+      });
+
+      it('should not refresh recordings without cameras', async () => {
+        const emptycameraTimelineKeys: TimelineKeys = {
+          type: 'camera',
+          cameraIDs: new Set(),
+        };
+        const source = new TimelineDataSource(
+          createTestCameraManager(),
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          emptycameraTimelineKeys,
          'all',
          true,
        );
@@ -457,7 +708,14 @@ describe('TimelineDataSource', () => {
          null,
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);

@@ -499,7 +757,14 @@ describe('TimelineDataSource', () => {
          ]),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);

@@ -507,8 +772,8 @@ describe('TimelineDataSource', () => {
          {
            content: '',
            end: 1695307885000,
-            group: 'camera/CAMERA_ID',
-            id: 'recording-CAMERA_ID-SEGMENT_ID',
+            group: 'camera/camera-1',
+            id: 'recording-camera-1-SEGMENT_ID',
            start: 1695307866000,
            type: 'background',
          },
@@ -547,15 +812,22 @@ describe('TimelineDataSource', () => {
          new Map([[recordingSegmentQuery, recordingSegmentsQueryResults]]),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );
        source.dataset.add({
-          id: 'recording-CAMERA_ID-SEGMENT_ID',
+          id: 'recording-camera-1-SEGMENT_ID',
          start: 1695307866000,

          // No end time.
          end: undefined,

-          group: 'camera/CAMERA_ID',
+          group: 'camera/camera-1',
          content: '',
          type: 'background',
        });
@@ -566,8 +838,8 @@ describe('TimelineDataSource', () => {
          {
            content: '',
            end: 1695307885000,
-            group: 'camera/CAMERA_ID',
-            id: 'recording-CAMERA_ID-SEGMENT_ID',
+            group: 'camera/camera-1',
+            id: 'recording-camera-1-SEGMENT_ID',
            start: 1695307866000,
            type: 'background',
          },
@@ -622,7 +894,14 @@ describe('TimelineDataSource', () => {
          ]),
        );

-        const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+        const source = new TimelineDataSource(
+          cameraManager,
+          mock<FoldersManager>(),
+          mock<ConditionStateManagerReadonlyInterface>(),
+          cameraTimelineKeys,
+          'all',
+          true,
+        );

        await source.refresh(window);

@@ -653,10 +932,11 @@ describe('TimelineDataSource', () => {
    const window: TimelineWindow = { start, end };

    it('should not event queries without cameras', () => {
-      const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
      const source = new TimelineDataSource(
        createCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
        'all',
        true,
      );
@@ -672,11 +952,18 @@ describe('TimelineDataSource', () => {
          },
        ]),
      );
-      const source = new TimelineDataSource(cameraManager, timelineKeys, 'clips', false);
+      const source = new TimelineDataSource(
+        cameraManager,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'clips',
+        false,
+      );
      source.getTimelineEventQueries(window);

      expect(cameraManager.generateDefaultEventQueries).toBeCalledWith(
-        new Set([CAMERA_ID]),
+        new Set(['camera-1', 'camera-2']),
        {
          start,
          end,
@@ -695,14 +982,16 @@ describe('TimelineDataSource', () => {
      );
      const source = new TimelineDataSource(
        cameraManager,
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'snapshots',
        false,
      );
      source.getTimelineEventQueries(window);

      expect(cameraManager.generateDefaultEventQueries).toBeCalledWith(
-        new Set([CAMERA_ID]),
+        new Set(['camera-1', 'camera-2']),
        {
          start,
          end,
@@ -712,14 +1001,51 @@ describe('TimelineDataSource', () => {
    });
  });

+  describe('should get timeline folder queries', () => {
+    it('should not get folder queries without a folder', () => {
+      const source = new TimelineDataSource(
+        createCameraManager(),
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );
+
+      expect(source.getTimelineFolderQuery()).toBeNull();
+    });
+
+    it('should get folder queries', () => {
+      const foldersManager = mock<FoldersManager>();
+      vi.mocked(foldersManager.generateDefaultFolderQuery).mockReturnValue({
+        folder,
+        path: [{}],
+      });
+
+      const source = new TimelineDataSource(
+        mock<CameraManager>(),
+        foldersManager,
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
+        'clips',
+        false,
+      );
+
+      source.getTimelineFolderQuery();
+
+      expect(foldersManager.generateDefaultFolderQuery).toBeCalledWith(folder);
+    });
+  });
+
  describe('should get timeline recording queries', () => {
    const window: TimelineWindow = { start, end };

    it('should not recording queries without cameras', () => {
-      const timelineKeys: TimelineKey[] = [{ type: 'folder', folder: folder }];
      const source = new TimelineDataSource(
        createCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        folderTimelineKeys,
        'all',
        true,
      );
@@ -731,15 +1057,25 @@ describe('TimelineDataSource', () => {
      const cameraManager = createCameraManager(
        createStore([
          {
-            cameraID: CAMERA_ID,
+            cameraID: 'camera-1',
+          },
+          {
+            cameraID: 'camera-2',
          },
        ]),
      );
-      const source = new TimelineDataSource(cameraManager, timelineKeys, 'all', true);
+      const source = new TimelineDataSource(
+        cameraManager,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
+        'all',
+        true,
+      );
      source.getTimelineRecordingQueries(window);

      expect(cameraManager.generateDefaultRecordingQueries).toBeCalledWith(
-        new Set([CAMERA_ID]),
+        new Set(['camera-1', 'camera-2']),
        {
          start,
          end,
@@ -752,7 +1088,9 @@ describe('TimelineDataSource', () => {
    it('should not rewrite when item is not found', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -764,7 +1102,9 @@ describe('TimelineDataSource', () => {
    it('should not rewrite when item is not found', () => {
      const source = new TimelineDataSource(
        createTestCameraManager(),
-        timelineKeys,
+        mock<FoldersManager>(),
+        mock<ConditionStateManagerReadonlyInterface>(),
+        cameraTimelineKeys,
        'all',
        true,
      );
@@ -772,8 +1112,8 @@ describe('TimelineDataSource', () => {
        id: 'id',
        start: start.getTime(),
        end: end.getTime(),
-        media: testMedia,
-        group: 'camera/CAMERA_ID' as const,
+        media: testCameraMedia,
+        group: 'camera/camera-1' as const,
        content: '',
        type: 'range' as const,
      };