refactor: timeline repo queries (#19871)

Co-authored-by: shenlong-tanwen <139912620+shalong-tanwen@users.noreply.github.com>

mobile/lib/domain/services/timeline.service.dart

@@ -18,6 +18,11 @@ typedef TimelineAssetSource = Future<List<BaseAsset>> Function(
 
 typedef TimelineBucketSource = Stream<List<Bucket>> Function();
 
+typedef TimelineQuery = ({
+  TimelineAssetSource assetSource,
+  TimelineBucketSource bucketSource,
+});
+
 class TimelineFactory {
   final DriftTimelineRepository _timelineRepository;
   final SettingsService _settingsService;
@@ -31,78 +36,32 @@ class TimelineFactory {
   GroupAssetsBy get groupBy =>
       GroupAssetsBy.values[_settingsService.get(Setting.groupAssetsBy)];
 
-  TimelineService main(List<String> timelineUsers) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getMainBucketAssets(timelineUsers, offset: offset, count: count),
-        bucketSource: () => _timelineRepository.watchMainBucket(
-          timelineUsers,
-          groupBy: groupBy,
-        ),
-      );
+  TimelineService main(List<String> timelineUsers) =>
+      TimelineService(_timelineRepository.main(timelineUsers, groupBy));
 
-  TimelineService localAlbum({required String albumId}) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getLocalAlbumBucketAssets(albumId, offset: offset, count: count),
-        bucketSource: () => _timelineRepository.watchLocalAlbumBucket(
-          albumId,
-          groupBy: groupBy,
-        ),
-      );
+  TimelineService localAlbum({required String albumId}) =>
+      TimelineService(_timelineRepository.localAlbum(albumId, groupBy));
 
-  TimelineService remoteAlbum({required String albumId}) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getRemoteAlbumBucketAssets(albumId, offset: offset, count: count),
-        bucketSource: () => _timelineRepository.watchRemoteAlbumBucket(
-          albumId,
-          groupBy: groupBy,
-        ),
-      );
+  TimelineService remoteAlbum({required String albumId}) =>
+      TimelineService(_timelineRepository.remoteAlbum(albumId, groupBy));
 
-  TimelineService remoteAssets(String ownerId) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getRemoteBucketAssets(ownerId, offset: offset, count: count),
-        bucketSource: () => _timelineRepository.watchRemoteBucket(
-          ownerId,
-          groupBy: GroupAssetsBy.month,
-        ),
-      );
+  TimelineService remoteAssets(String userId) =>
+      TimelineService(_timelineRepository.remote(userId, groupBy));
 
-  TimelineService favorite(String userId) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getFavoriteBucketAssets(userId, offset: offset, count: count),
-        bucketSource: () =>
-            _timelineRepository.watchFavoriteBucket(userId, groupBy: groupBy),
-      );
+  TimelineService favorite(String userId) =>
+      TimelineService(_timelineRepository.favorite(userId, groupBy));
 
-  TimelineService trash(String userId) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getTrashBucketAssets(userId, offset: offset, count: count),
-        bucketSource: () =>
-            _timelineRepository.watchTrashBucket(userId, groupBy: groupBy),
-      );
+  TimelineService trash(String userId) =>
+      TimelineService(_timelineRepository.trash(userId, groupBy));
 
-  TimelineService archive(String userId) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getArchiveBucketAssets(userId, offset: offset, count: count),
-        bucketSource: () =>
-            _timelineRepository.watchArchiveBucket(userId, groupBy: groupBy),
-      );
+  TimelineService archive(String userId) =>
+      TimelineService(_timelineRepository.archived(userId, groupBy));
 
-  TimelineService lockedFolder(String userId) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getLockedFolderBucketAssets(userId, offset: offset, count: count),
-        bucketSource: () => _timelineRepository.watchLockedFolderBucket(
-          userId,
-          groupBy: groupBy,
-        ),
-      );
+  TimelineService lockedFolder(String userId) =>
+      TimelineService(_timelineRepository.locked(userId, groupBy));
 
-  TimelineService video(String userId) => TimelineService(
-        assetSource: (offset, count) => _timelineRepository
-            .getVideoBucketAssets(userId, offset: offset, count: count),
-        bucketSource: () =>
-            _timelineRepository.watchVideoBucket(userId, groupBy: groupBy),
-      );
+  TimelineService video(String userId) =>
+      TimelineService(_timelineRepository.video(userId, groupBy));
 }
 
 class TimelineService {
@@ -116,7 +75,13 @@ class TimelineService {
   int _totalAssets = 0;
   int get totalAssets => _totalAssets;
 
-  TimelineService({
+  TimelineService(TimelineQuery query)
+      : this._(
+          assetSource: query.assetSource,
+          bucketSource: query.bucketSource,
+        );
+
+  TimelineService._({
     required TimelineAssetSource assetSource,
     required TimelineBucketSource bucketSource,
   })  : _assetSource = assetSource,

mobile/lib/infrastructure/repositories/timeline.repository.dart

@@ -5,8 +5,10 @@ import 'package:easy_localization/easy_localization.dart';
 import 'package:immich_mobile/constants/constants.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/domain/models/timeline.model.dart';
+import 'package:immich_mobile/domain/services/timeline.service.dart';
 import 'package:immich_mobile/infrastructure/entities/local_asset.entity.dart';
 import 'package:immich_mobile/infrastructure/entities/remote_asset.entity.dart';
+import 'package:immich_mobile/infrastructure/entities/remote_asset.entity.drift.dart';
 import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
 import 'package:stream_transform/stream_transform.dart';
 
@@ -30,19 +32,19 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
         .map((users) => users..add(userId));
   }
 
-  List<Bucket> _generateBuckets(int count) {
-    final numBuckets = (count / kTimelineNoneSegmentSize).floor();
-    final buckets = List.generate(
-      numBuckets,
-      (_) => const Bucket(assetCount: kTimelineNoneSegmentSize),
+  TimelineQuery main(List<String> userIds, GroupAssetsBy groupBy) => (
+        bucketSource: () => _watchMainBucket(
+              userIds,
+              groupBy: groupBy,
+            ),
+        assetSource: (offset, count) => _getMainBucketAssets(
+              userIds,
+              offset: offset,
+              count: count,
+            ),
       );
-    if (count % kTimelineNoneSegmentSize != 0) {
-      buckets.add(Bucket(assetCount: count % kTimelineNoneSegmentSize));
-    }
-    return buckets;
-  }
 
-  Stream<List<Bucket>> watchMainBucket(
+  Stream<List<Bucket>> _watchMainBucket(
     List<String> userIds, {
     GroupAssetsBy groupBy = GroupAssetsBy.day,
   }) {
@@ -62,7 +64,7 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
         .throttle(const Duration(seconds: 3), trailing: true);
   }
 
-  Future<List<BaseAsset>> getMainBucketAssets(
+  Future<List<BaseAsset>> _getMainBucketAssets(
     List<String> userIds, {
     required int offset,
     required int count,
@@ -70,8 +72,7 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     return _db.mergedAssetDrift
         .mergedAsset(userIds, limit: Limit(count, offset))
         .map(
-      (row) {
-        return row.remoteId != null && row.ownerId != null
+          (row) => row.remoteId != null && row.ownerId != null
               ? RemoteAsset(
                   id: row.remoteId!,
                   localId: row.localId,
@@ -100,12 +101,24 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
                   isFavorite: row.isFavorite,
                   durationInSeconds: row.durationInSeconds,
                   orientation: row.orientation,
-              );
-      },
-    ).get();
+                ),
+        )
+        .get();
   }
 
-  Stream<List<Bucket>> watchLocalAlbumBucket(
+  TimelineQuery localAlbum(String albumId, GroupAssetsBy groupBy) => (
+        bucketSource: () => _watchLocalAlbumBucket(
+              albumId,
+              groupBy: groupBy,
+            ),
+        assetSource: (offset, count) => _getLocalAlbumBucketAssets(
+              albumId,
+              offset: offset,
+              count: count,
+            ),
+      );
+
+  Stream<List<Bucket>> _watchLocalAlbumBucket(
     String albumId, {
     GroupAssetsBy groupBy = GroupAssetsBy.day,
   }) {
@@ -119,15 +132,14 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     final assetCountExp = _db.localAssetEntity.id.count();
     final dateExp = _db.localAssetEntity.createdAt.dateFmt(groupBy);
 
-    final query = _db.localAssetEntity.selectOnly()
-      ..addColumns([assetCountExp, dateExp])
-      ..join([
+    final query = _db.localAssetEntity.selectOnly().join([
       innerJoin(
         _db.localAlbumAssetEntity,
         _db.localAlbumAssetEntity.assetId.equalsExp(_db.localAssetEntity.id),
         useColumns: false,
       ),
     ])
+      ..addColumns([assetCountExp, dateExp])
       ..where(_db.localAlbumAssetEntity.albumId.equals(albumId))
       ..groupBy([dateExp])
       ..orderBy([OrderingTerm.desc(dateExp)]);
@@ -139,7 +151,7 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     }).watch();
   }
 
-  Future<List<BaseAsset>> getLocalAlbumBucketAssets(
+  Future<List<BaseAsset>> _getLocalAlbumBucketAssets(
     String albumId, {
     required int offset,
     required int count,
@@ -156,12 +168,25 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
       ..where(_db.localAlbumAssetEntity.albumId.equals(albumId))
       ..orderBy([OrderingTerm.desc(_db.localAssetEntity.createdAt)])
       ..limit(count, offset: offset);
+
     return query
         .map((row) => row.readTable(_db.localAssetEntity).toDto())
         .get();
   }
 
-  Stream<List<Bucket>> watchRemoteAlbumBucket(
+  TimelineQuery remoteAlbum(String albumId, GroupAssetsBy groupBy) => (
+        bucketSource: () => _watchRemoteAlbumBucket(
+              albumId,
+              groupBy: groupBy,
+            ),
+        assetSource: (offset, count) => _getRemoteAlbumBucketAssets(
+              albumId,
+              offset: offset,
+              count: count,
+            ),
+      );
+
+  Stream<List<Bucket>> _watchRemoteAlbumBucket(
     String albumId, {
     GroupAssetsBy groupBy = GroupAssetsBy.day,
   }) {
@@ -199,7 +224,7 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     }).watch();
   }
 
-  Future<List<BaseAsset>> getRemoteAlbumBucketAssets(
+  Future<List<BaseAsset>> _getRemoteAlbumBucketAssets(
     String albumId, {
     required int offset,
     required int count,
@@ -225,232 +250,76 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
         .get();
   }
 
-  Stream<List<Bucket>> watchRemoteBucket(
-    String ownerId, {
-    GroupAssetsBy groupBy = GroupAssetsBy.day,
-  }) {
-    if (groupBy == GroupAssetsBy.none) {
-      return _db.remoteAssetEntity
-          .count(
-            where: (row) =>
+  TimelineQuery remote(String ownerId, GroupAssetsBy groupBy) =>
+      _remoteQueryBuilder(
+        filter: (row) =>
             row.deletedAt.isNull() &
             row.visibility.equalsValue(AssetVisibility.timeline) &
             row.ownerId.equals(ownerId),
-          )
-          .map(_generateBuckets)
-          .watchSingle();
-    }
+        groupBy: groupBy,
+      );
 
-    final assetCountExp = _db.remoteAssetEntity.id.count();
-    final dateExp = _db.remoteAssetEntity.createdAt.dateFmt(groupBy);
-
-    final query = _db.remoteAssetEntity.selectOnly()
-      ..addColumns([assetCountExp, dateExp])
-      ..where(
-        _db.remoteAssetEntity.deletedAt.isNull() &
-            _db.remoteAssetEntity.visibility
-                .equalsValue(AssetVisibility.timeline) &
-            _db.remoteAssetEntity.ownerId.equals(ownerId),
-      )
-      ..groupBy([dateExp])
-      ..orderBy([OrderingTerm.desc(dateExp)]);
-
-    return query.map((row) {
-      final timeline = row.read(dateExp)!.dateFmt(groupBy);
-      final assetCount = row.read(assetCountExp)!;
-      return TimeBucket(date: timeline, assetCount: assetCount);
-    }).watch();
-  }
-
-  Future<List<BaseAsset>> getRemoteBucketAssets(
-    String ownerId, {
-    required int offset,
-    required int count,
-  }) {
-    final query = _db.remoteAssetEntity.select()
-      ..where(
-        (row) =>
-            row.deletedAt.isNull() &
-            row.visibility.equalsValue(AssetVisibility.timeline) &
-            row.ownerId.equals(ownerId),
-      )
-      ..orderBy([(row) => OrderingTerm.desc(row.createdAt)])
-      ..limit(count, offset: offset);
-
-    return query.map((row) => row.toDto()).get();
-  }
-
-  Stream<List<Bucket>> watchFavoriteBucket(
-    String userId, {
-    GroupAssetsBy groupBy = GroupAssetsBy.day,
-  }) {
-    if (groupBy == GroupAssetsBy.none) {
-      return _db.remoteAssetEntity
-          .count(
-            where: (row) =>
+  TimelineQuery favorite(String userId, GroupAssetsBy groupBy) =>
+      _remoteQueryBuilder(
+        filter: (row) =>
             row.deletedAt.isNull() &
             row.isFavorite.equals(true) &
             row.ownerId.equals(userId),
-          )
-          .map(_generateBuckets)
-          .watchSingle();
-    }
+        groupBy: groupBy,
+      );
 
-    final assetCountExp = _db.remoteAssetEntity.id.count();
-    final dateExp = _db.remoteAssetEntity.createdAt.dateFmt(groupBy);
+  TimelineQuery trash(String userId, GroupAssetsBy groupBy) =>
+      _remoteQueryBuilder(
+        filter: (row) => row.deletedAt.isNotNull() & row.ownerId.equals(userId),
+        groupBy: groupBy,
+      );
 
-    final query = _db.remoteAssetEntity.selectOnly()
-      ..addColumns([assetCountExp, dateExp])
-      ..where(
-        _db.remoteAssetEntity.deletedAt.isNull() &
-            _db.remoteAssetEntity.ownerId.equals(userId) &
-            _db.remoteAssetEntity.isFavorite.equals(true),
-      )
-      ..groupBy([dateExp])
-      ..orderBy([OrderingTerm.desc(dateExp)]);
-
-    return query.map((row) {
-      final timeline = row.read(dateExp)!.dateFmt(groupBy);
-      final assetCount = row.read(assetCountExp)!;
-      return TimeBucket(date: timeline, assetCount: assetCount);
-    }).watch();
-  }
-
-  Future<List<BaseAsset>> getFavoriteBucketAssets(
-    String userId, {
-    required int offset,
-    required int count,
-  }) {
-    final query = _db.remoteAssetEntity.select()
-      ..where(
-        (row) =>
-            row.deletedAt.isNull() &
-            row.isFavorite.equals(true) &
-            row.ownerId.equals(userId),
-      )
-      ..orderBy([(row) => OrderingTerm.desc(row.createdAt)])
-      ..limit(count, offset: offset);
-
-    return query.map((row) => row.toDto()).get();
-  }
-
-  Stream<List<Bucket>> watchTrashBucket(
-    String userId, {
-    GroupAssetsBy groupBy = GroupAssetsBy.day,
-  }) {
-    if (groupBy == GroupAssetsBy.none) {
-      return _db.remoteAssetEntity
-          .count(
-            where: (row) =>
-                row.deletedAt.isNotNull() & row.ownerId.equals(userId),
-          )
-          .map(_generateBuckets)
-          .watchSingle();
-    }
-
-    final assetCountExp = _db.remoteAssetEntity.id.count();
-    final dateExp = _db.remoteAssetEntity.createdAt.dateFmt(groupBy);
-
-    final query = _db.remoteAssetEntity.selectOnly()
-      ..addColumns([assetCountExp, dateExp])
-      ..where(
-        _db.remoteAssetEntity.ownerId.equals(userId) &
-            _db.remoteAssetEntity.deletedAt.isNotNull(),
-      )
-      ..groupBy([dateExp])
-      ..orderBy([OrderingTerm.desc(dateExp)]);
-
-    return query.map((row) {
-      final timeline = row.read(dateExp)!.dateFmt(groupBy);
-      final assetCount = row.read(assetCountExp)!;
-      return TimeBucket(date: timeline, assetCount: assetCount);
-    }).watch();
-  }
-
-  Future<List<BaseAsset>> getTrashBucketAssets(
-    String userId, {
-    required int offset,
-    required int count,
-  }) {
-    final query = _db.remoteAssetEntity.select()
-      ..where(
-        (row) => row.deletedAt.isNotNull() & row.ownerId.equals(userId),
-      )
-      ..orderBy([(row) => OrderingTerm.desc(row.createdAt)])
-      ..limit(count, offset: offset);
-
-    return query.map((row) => row.toDto()).get();
-  }
-
-  Stream<List<Bucket>> watchArchiveBucket(
-    String userId, {
-    GroupAssetsBy groupBy = GroupAssetsBy.day,
-  }) {
-    if (groupBy == GroupAssetsBy.none) {
-      return _db.remoteAssetEntity
-          .count(
-            where: (row) =>
-                row.deletedAt.isNull() &
-                row.visibility.equalsValue(AssetVisibility.archive) &
-                row.ownerId.equals(userId),
-          )
-          .map(_generateBuckets)
-          .watchSingle();
-    }
-
-    final assetCountExp = _db.remoteAssetEntity.id.count();
-    final dateExp = _db.remoteAssetEntity.createdAt.dateFmt(groupBy);
-
-    final query = _db.remoteAssetEntity.selectOnly()
-      ..addColumns([assetCountExp, dateExp])
-      ..where(
-        _db.remoteAssetEntity.deletedAt.isNull() &
-            _db.remoteAssetEntity.ownerId.equals(userId) &
-            _db.remoteAssetEntity.visibility
-                .equalsValue(AssetVisibility.archive),
-      )
-      ..groupBy([dateExp])
-      ..orderBy([OrderingTerm.desc(dateExp)]);
-
-    return query.map((row) {
-      final timeline = row.read(dateExp)!.dateFmt(groupBy);
-      final assetCount = row.read(assetCountExp)!;
-      return TimeBucket(date: timeline, assetCount: assetCount);
-    }).watch();
-  }
-
-  Future<List<BaseAsset>> getArchiveBucketAssets(
-    String userId, {
-    required int offset,
-    required int count,
-  }) {
-    final query = _db.remoteAssetEntity.select()
-      ..where(
-        (row) =>
+  TimelineQuery archived(String userId, GroupAssetsBy groupBy) =>
+      _remoteQueryBuilder(
+        filter: (row) =>
             row.deletedAt.isNull() &
             row.ownerId.equals(userId) &
             row.visibility.equalsValue(AssetVisibility.archive),
-      )
-      ..orderBy([(row) => OrderingTerm.desc(row.createdAt)])
-      ..limit(count, offset: offset);
+        groupBy: groupBy,
+      );
 
-    return query.map((row) => row.toDto()).get();
-  }
-
-  Stream<List<Bucket>> watchLockedFolderBucket(
-    String userId, {
-    GroupAssetsBy groupBy = GroupAssetsBy.day,
-  }) {
-    if (groupBy == GroupAssetsBy.none) {
-      return _db.remoteAssetEntity
-          .count(
-            where: (row) =>
+  TimelineQuery locked(String userId, GroupAssetsBy groupBy) =>
+      _remoteQueryBuilder(
+        filter: (row) =>
             row.deletedAt.isNull() &
             row.visibility.equalsValue(AssetVisibility.locked) &
             row.ownerId.equals(userId),
-          )
-          .map(_generateBuckets)
-          .watchSingle();
+        groupBy: groupBy,
+      );
+
+  TimelineQuery video(String userId, GroupAssetsBy groupBy) =>
+      _remoteQueryBuilder(
+        filter: (row) =>
+            row.deletedAt.isNull() &
+            row.type.equalsValue(AssetType.video) &
+            row.visibility.equalsValue(AssetVisibility.timeline) &
+            row.ownerId.equals(userId),
+        groupBy: groupBy,
+      );
+
+  TimelineQuery _remoteQueryBuilder({
+    required Expression<bool> Function($RemoteAssetEntityTable row) filter,
+    GroupAssetsBy groupBy = GroupAssetsBy.day,
+  }) {
+    return (
+      bucketSource: () => _watchRemoteBucket(filter: filter, groupBy: groupBy),
+      assetSource: (offset, count) =>
+          _getRemoteAssets(filter: filter, offset: offset, count: count),
+    );
+  }
+
+  Stream<List<Bucket>> _watchRemoteBucket({
+    required Expression<bool> Function($RemoteAssetEntityTable row) filter,
+    GroupAssetsBy groupBy = GroupAssetsBy.day,
+  }) {
+    if (groupBy == GroupAssetsBy.none) {
+      final query = _db.remoteAssetEntity.count(where: filter);
+      return query.map(_generateBuckets).watchSingle();
     }
 
     final assetCountExp = _db.remoteAssetEntity.id.count();
@@ -458,12 +327,7 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
 
     final query = _db.remoteAssetEntity.selectOnly()
       ..addColumns([assetCountExp, dateExp])
-      ..where(
-        _db.remoteAssetEntity.deletedAt.isNull() &
-            _db.remoteAssetEntity.ownerId.equals(userId) &
-            _db.remoteAssetEntity.visibility
-                .equalsValue(AssetVisibility.locked),
-      )
+      ..where(filter(_db.remoteAssetEntity))
       ..groupBy([dateExp])
       ..orderBy([OrderingTerm.desc(dateExp)]);
 
@@ -474,81 +338,29 @@ class DriftTimelineRepository extends DriftDatabaseRepository {
     }).watch();
   }
 
-  Future<List<BaseAsset>> getLockedFolderBucketAssets(
-    String userId, {
+  Future<List<BaseAsset>> _getRemoteAssets({
+    required Expression<bool> Function($RemoteAssetEntityTable row) filter,
     required int offset,
     required int count,
   }) {
     final query = _db.remoteAssetEntity.select()
-      ..where(
-        (row) =>
-            row.deletedAt.isNull() &
-            row.visibility.equalsValue(AssetVisibility.locked) &
-            row.ownerId.equals(userId),
-      )
+      ..where(filter)
       ..orderBy([(row) => OrderingTerm.desc(row.createdAt)])
       ..limit(count, offset: offset);
 
     return query.map((row) => row.toDto()).get();
   }
+}
 
-  Stream<List<Bucket>> watchVideoBucket(
-    String userId, {
-    GroupAssetsBy groupBy = GroupAssetsBy.day,
-  }) {
-    if (groupBy == GroupAssetsBy.none) {
-      return _db.remoteAssetEntity
-          .count(
-            where: (row) =>
-                row.deletedAt.isNull() &
-                row.type.equalsValue(AssetType.video) &
-                row.visibility.equalsValue(AssetVisibility.timeline) &
-                row.ownerId.equals(userId),
-          )
-          .map(_generateBuckets)
-          .watchSingle();
-    }
-
-    final assetCountExp = _db.remoteAssetEntity.id.count();
-    final dateExp = _db.remoteAssetEntity.createdAt.dateFmt(groupBy);
-
-    final query = _db.remoteAssetEntity.selectOnly()
-      ..addColumns([assetCountExp, dateExp])
-      ..where(
-        _db.remoteAssetEntity.deletedAt.isNull() &
-            _db.remoteAssetEntity.ownerId.equals(userId) &
-            _db.remoteAssetEntity.type.equalsValue(AssetType.video) &
-            _db.remoteAssetEntity.visibility
-                .equalsValue(AssetVisibility.timeline),
-      )
-      ..groupBy([dateExp])
-      ..orderBy([OrderingTerm.desc(dateExp)]);
-
-    return query.map((row) {
-      final timeline = row.read(dateExp)!.dateFmt(groupBy);
-      final assetCount = row.read(assetCountExp)!;
-      return TimeBucket(date: timeline, assetCount: assetCount);
-    }).watch();
-  }
-
-  Future<List<BaseAsset>> getVideoBucketAssets(
-    String userId, {
-    required int offset,
-    required int count,
-  }) {
-    final query = _db.remoteAssetEntity.select()
-      ..where(
-        (row) =>
-            row.deletedAt.isNull() &
-            row.type.equalsValue(AssetType.video) &
-            row.visibility.equalsValue(AssetVisibility.timeline) &
-            row.ownerId.equals(userId),
-      )
-      ..orderBy([(row) => OrderingTerm.desc(row.createdAt)])
-      ..limit(count, offset: offset);
-
-    return query.map((row) => row.toDto()).get();
+List<Bucket> _generateBuckets(int count) {
+  final buckets = List.generate(
+    (count / kTimelineNoneSegmentSize).floor(),
+    (_) => const Bucket(assetCount: kTimelineNoneSegmentSize),
+  );
+  if (count % kTimelineNoneSegmentSize != 0) {
+    buckets.add(Bucket(assetCount: count % kTimelineNoneSegmentSize));
   }
+  return buckets;
 }
 
 extension on Expression<DateTime> {