chore: bump dart sdk to 3.8 (#20355)

* chore: bump dart sdk to 3.8

* chore: make build

* make pigeon

* chore: format files

---------

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

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

@@ -16,9 +16,7 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
   final Drift _db;
   const DriftRemoteAlbumRepository(this._db) : super(_db);
 
-  Future<List<RemoteAlbum>> getAll({
-    Set<SortRemoteAlbumsBy> sortBy = const {SortRemoteAlbumsBy.updatedAt},
-  }) {
+  Future<List<RemoteAlbum>> getAll({Set<SortRemoteAlbumsBy> sortBy = const {SortRemoteAlbumsBy.updatedAt}}) {
     final assetCount = _db.remoteAlbumAssetEntity.assetId.count();
 
     final query = _db.remoteAlbumEntity.select().join([
@@ -32,11 +30,7 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
         _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
         useColumns: false,
       ),
-      leftOuterJoin(
-        _db.userEntity,
-        _db.userEntity.id.equalsExp(_db.remoteAlbumEntity.ownerId),
-        useColumns: false,
-      ),
+      leftOuterJoin(_db.userEntity, _db.userEntity.id.equalsExp(_db.remoteAlbumEntity.ownerId), useColumns: false),
     ]);
     query
       ..where(_db.remoteAssetEntity.deletedAt.isNull())
@@ -47,22 +41,19 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
     if (sortBy.isNotEmpty) {
       final orderings = <OrderingTerm>[];
       for (final sort in sortBy) {
-        orderings.add(
-          switch (sort) {
-            SortRemoteAlbumsBy.id => OrderingTerm.asc(_db.remoteAlbumEntity.id),
-            SortRemoteAlbumsBy.updatedAt => OrderingTerm.desc(_db.remoteAlbumEntity.updatedAt),
-          },
-        );
+        orderings.add(switch (sort) {
+          SortRemoteAlbumsBy.id => OrderingTerm.asc(_db.remoteAlbumEntity.id),
+          SortRemoteAlbumsBy.updatedAt => OrderingTerm.desc(_db.remoteAlbumEntity.updatedAt),
+        });
       }
       query.orderBy(orderings);
     }
 
     return query
         .map(
-          (row) => row.readTable(_db.remoteAlbumEntity).toDto(
-                assetCount: row.read(assetCount) ?? 0,
-                ownerName: row.read(_db.userEntity.name)!,
-              ),
+          (row) => row
+              .readTable(_db.remoteAlbumEntity)
+              .toDto(assetCount: row.read(assetCount) ?? 0, ownerName: row.read(_db.userEntity.name)!),
         )
         .get();
   }
@@ -70,42 +61,39 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
   Future<RemoteAlbum?> get(String albumId) {
     final assetCount = _db.remoteAlbumAssetEntity.assetId.count();
 
-    final query = _db.remoteAlbumEntity.select().join([
-      leftOuterJoin(
-        _db.remoteAlbumAssetEntity,
-        _db.remoteAlbumAssetEntity.albumId.equalsExp(_db.remoteAlbumEntity.id),
-        useColumns: false,
-      ),
-      leftOuterJoin(
-        _db.remoteAssetEntity,
-        _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
-        useColumns: false,
-      ),
-      leftOuterJoin(
-        _db.userEntity,
-        _db.userEntity.id.equalsExp(_db.remoteAlbumEntity.ownerId),
-        useColumns: false,
-      ),
-    ])
-      ..where(_db.remoteAlbumEntity.id.equals(albumId) & _db.remoteAssetEntity.deletedAt.isNull())
-      ..addColumns([assetCount])
-      ..addColumns([_db.userEntity.name])
-      ..groupBy([_db.remoteAlbumEntity.id]);
+    final query =
+        _db.remoteAlbumEntity.select().join([
+            leftOuterJoin(
+              _db.remoteAlbumAssetEntity,
+              _db.remoteAlbumAssetEntity.albumId.equalsExp(_db.remoteAlbumEntity.id),
+              useColumns: false,
+            ),
+            leftOuterJoin(
+              _db.remoteAssetEntity,
+              _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
+              useColumns: false,
+            ),
+            leftOuterJoin(
+              _db.userEntity,
+              _db.userEntity.id.equalsExp(_db.remoteAlbumEntity.ownerId),
+              useColumns: false,
+            ),
+          ])
+          ..where(_db.remoteAlbumEntity.id.equals(albumId) & _db.remoteAssetEntity.deletedAt.isNull())
+          ..addColumns([assetCount])
+          ..addColumns([_db.userEntity.name])
+          ..groupBy([_db.remoteAlbumEntity.id]);
 
     return query
         .map(
-          (row) => row.readTable(_db.remoteAlbumEntity).toDto(
-                assetCount: row.read(assetCount) ?? 0,
-                ownerName: row.read(_db.userEntity.name)!,
-              ),
+          (row) => row
+              .readTable(_db.remoteAlbumEntity)
+              .toDto(assetCount: row.read(assetCount) ?? 0, ownerName: row.read(_db.userEntity.name)!),
         )
         .getSingleOrNull();
   }
 
-  Future<void> create(
-    RemoteAlbum album,
-    List<String> assetIds,
-  ) async {
+  Future<void> create(RemoteAlbum album, List<String> assetIds) async {
     await _db.transaction(() async {
       final entity = RemoteAlbumEntityCompanion(
         id: Value(album.id),
@@ -123,17 +111,11 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
 
       if (assetIds.isNotEmpty) {
         final albumAssets = assetIds.map(
-          (assetId) => RemoteAlbumAssetEntityCompanion(
-            albumId: Value(album.id),
-            assetId: Value(assetId),
-          ),
+          (assetId) => RemoteAlbumAssetEntityCompanion(albumId: Value(album.id), assetId: Value(assetId)),
         );
 
         await _db.batch((batch) {
-          batch.insertAll(
-            _db.remoteAlbumAssetEntity,
-            albumAssets,
-          );
+          batch.insertAll(_db.remoteAlbumAssetEntity, albumAssets);
         });
       }
     });
@@ -141,38 +123,30 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
 
   Future<void> update(RemoteAlbum album) async {
     await _db.remoteAlbumEntity.update().replace(
-          RemoteAlbumEntityCompanion(
-            id: Value(album.id),
-            name: Value(album.name),
-            ownerId: Value(album.ownerId),
-            createdAt: Value(album.createdAt),
-            updatedAt: Value(album.updatedAt),
-            description: Value(album.description),
-            thumbnailAssetId: Value(album.thumbnailAssetId),
-            isActivityEnabled: Value(album.isActivityEnabled),
-            order: Value(album.order),
-          ),
-        );
+      RemoteAlbumEntityCompanion(
+        id: Value(album.id),
+        name: Value(album.name),
+        ownerId: Value(album.ownerId),
+        createdAt: Value(album.createdAt),
+        updatedAt: Value(album.updatedAt),
+        description: Value(album.description),
+        thumbnailAssetId: Value(album.thumbnailAssetId),
+        isActivityEnabled: Value(album.isActivityEnabled),
+        order: Value(album.order),
+      ),
+    );
   }
 
   Future<int> removeAssets(String albumId, List<String> assetIds) {
-    return _db.remoteAlbumAssetEntity.deleteWhere(
-      (tbl) => tbl.albumId.equals(albumId) & tbl.assetId.isIn(assetIds),
-    );
+    return _db.remoteAlbumAssetEntity.deleteWhere((tbl) => tbl.albumId.equals(albumId) & tbl.assetId.isIn(assetIds));
   }
 
   FutureOr<(DateTime, DateTime)> getDateRange(String albumId) {
     final query = _db.remoteAlbumAssetEntity.selectOnly()
       ..where(_db.remoteAlbumAssetEntity.albumId.equals(albumId))
-      ..addColumns([
-        _db.remoteAssetEntity.createdAt.min(),
-        _db.remoteAssetEntity.createdAt.max(),
-      ])
+      ..addColumns([_db.remoteAssetEntity.createdAt.min(), _db.remoteAssetEntity.createdAt.max()])
       ..join([
-        innerJoin(
-          _db.remoteAssetEntity,
-          _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
-        ),
+        innerJoin(_db.remoteAssetEntity, _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId)),
       ]);
 
     return query.map((row) {
@@ -183,8 +157,9 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
   }
 
   Future<List<UserDto>> getSharedUsers(String albumId) async {
-    final albumUserRows =
-        await (_db.select(_db.remoteAlbumUserEntity)..where((row) => row.albumId.equals(albumId))).get();
+    final albumUserRows = await (_db.select(
+      _db.remoteAlbumUserEntity,
+    )..where((row) => row.albumId.equals(albumId))).get();
 
     if (albumUserRows.isEmpty) {
       return [];
@@ -214,29 +189,19 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
 
   Future<List<RemoteAsset>> getAssets(String albumId) {
     final query = _db.remoteAlbumAssetEntity.select().join([
-      innerJoin(
-        _db.remoteAssetEntity,
-        _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
-      ),
-    ])
-      ..where(_db.remoteAlbumAssetEntity.albumId.equals(albumId));
+      innerJoin(_db.remoteAssetEntity, _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId)),
+    ])..where(_db.remoteAlbumAssetEntity.albumId.equals(albumId));
 
     return query.map((row) => row.readTable(_db.remoteAssetEntity).toDto()).get();
   }
 
   Future<int> addAssets(String albumId, List<String> assetIds) async {
     final albumAssets = assetIds.map(
-      (assetId) => RemoteAlbumAssetEntityCompanion(
-        albumId: Value(albumId),
-        assetId: Value(assetId),
-      ),
+      (assetId) => RemoteAlbumAssetEntityCompanion(albumId: Value(albumId), assetId: Value(assetId)),
     );
 
     await _db.batch((batch) {
-      batch.insertAll(
-        _db.remoteAlbumAssetEntity,
-        albumAssets,
-      );
+      batch.insertAll(_db.remoteAlbumAssetEntity, albumAssets);
     });
 
     return assetIds.length;
@@ -252,47 +217,41 @@ class DriftRemoteAlbumRepository extends DriftDatabaseRepository {
     );
 
     return _db.batch((batch) {
-      batch.insertAll(
-        _db.remoteAlbumUserEntity,
-        albumUsers,
-      );
+      batch.insertAll(_db.remoteAlbumUserEntity, albumUsers);
     });
   }
 
   Future<void> deleteAlbum(String albumId) async {
     return _db.transaction(() async {
-      await _db.remoteAlbumEntity.deleteWhere(
-        (table) => table.id.equals(albumId),
-      );
+      await _db.remoteAlbumEntity.deleteWhere((table) => table.id.equals(albumId));
     });
   }
 
   Stream<RemoteAlbum?> watchAlbum(String albumId) {
-    final query = _db.remoteAlbumEntity.select().join([
-      leftOuterJoin(
-        _db.remoteAlbumAssetEntity,
-        _db.remoteAlbumAssetEntity.albumId.equalsExp(_db.remoteAlbumEntity.id),
-        useColumns: false,
-      ),
-      leftOuterJoin(
-        _db.remoteAssetEntity,
-        _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
-        useColumns: false,
-      ),
-      leftOuterJoin(
-        _db.userEntity,
-        _db.userEntity.id.equalsExp(_db.remoteAlbumEntity.ownerId),
-        useColumns: false,
-      ),
-    ])
-      ..where(_db.remoteAlbumEntity.id.equals(albumId))
-      ..addColumns([_db.userEntity.name])
-      ..groupBy([_db.remoteAlbumEntity.id]);
+    final query =
+        _db.remoteAlbumEntity.select().join([
+            leftOuterJoin(
+              _db.remoteAlbumAssetEntity,
+              _db.remoteAlbumAssetEntity.albumId.equalsExp(_db.remoteAlbumEntity.id),
+              useColumns: false,
+            ),
+            leftOuterJoin(
+              _db.remoteAssetEntity,
+              _db.remoteAssetEntity.id.equalsExp(_db.remoteAlbumAssetEntity.assetId),
+              useColumns: false,
+            ),
+            leftOuterJoin(
+              _db.userEntity,
+              _db.userEntity.id.equalsExp(_db.remoteAlbumEntity.ownerId),
+              useColumns: false,
+            ),
+          ])
+          ..where(_db.remoteAlbumEntity.id.equals(albumId))
+          ..addColumns([_db.userEntity.name])
+          ..groupBy([_db.remoteAlbumEntity.id]);
 
     return query.map((row) {
-      final album = row.readTable(_db.remoteAlbumEntity).toDto(
-            ownerName: row.read(_db.userEntity.name)!,
-          );
+      final album = row.readTable(_db.remoteAlbumEntity).toDto(ownerName: row.read(_db.userEntity.name)!);
       return album;
     }).watchSingleOrNull();
   }