refactor: owned action assets filter

.nvmrc

@@ -1 +1 @@
-24.18.0
+24.15.0

mise.lock

@@ -212,36 +212,36 @@ checksum = "sha256:b6c17e747ae78cdd6de4d7532b3164b277daee97c007d3eaa2b39cca99882
 url = "https://download.java.net/java/GA/jdk21.0.2/f2283984656d49d69e91c558476027ac/13/GPL/openjdk-21.0.2_windows-x64_bin.zip"
 
 [[tools.node]]
-version = "24.18.0"
+version = "24.15.0"
 backend = "core:node"
 
 [tools.node."platforms.linux-arm64"]
-checksum = "sha256:6b4484c2190274175df9aa8f28e2d758a819cb1c1fe6ab481e2f95b463ab8508"
-url = "https://nodejs.org/dist/v24.18.0/node-v24.18.0-linux-arm64.tar.gz"
+checksum = "sha256:73afc234d558c24919875f51c2d1ea002a2ada4ea6f83601a383869fefa64eed"
+url = "https://nodejs.org/dist/v24.15.0/node-v24.15.0-linux-arm64.tar.gz"
 
 [tools.node."platforms.linux-arm64-musl"]
-checksum = "sha256:b1c6c2dc31b46dd8fb2322f4fe75b07e775c5120bc37251deeea28f529d4567b"
-url = "https://unofficial-builds.nodejs.org/download/release/v24.18.0/node-v24.18.0-linux-arm64-musl.tar.gz"
+checksum = "sha256:31e98aa960a067da91edffd5d93bc46657b5d2a8029612c359f5f2ac0060152a"
+url = "https://unofficial-builds.nodejs.org/download/release/v24.15.0/node-v24.15.0-linux-arm64-musl.tar.gz"
 
 [tools.node."platforms.linux-x64"]
-checksum = "sha256:783130984963db7ba9cbd01089eaf2c2efb055c7c1693c943174b967b3050cb8"
-url = "https://nodejs.org/dist/v24.18.0/node-v24.18.0-linux-x64.tar.gz"
+checksum = "sha256:44836872d9aec49f1e6b52a9a922872db9a2b02d235a616a5681b6a85fec8d89"
+url = "https://nodejs.org/dist/v24.15.0/node-v24.15.0-linux-x64.tar.gz"
 
 [tools.node."platforms.linux-x64-musl"]
-checksum = "sha256:ea58409911e141ec6b19d9178efa2d9185a13295005b1cbf5521b3157eed1d95"
-url = "https://unofficial-builds.nodejs.org/download/release/v24.18.0/node-v24.18.0-linux-x64-musl.tar.gz"
+checksum = "sha256:f55af5bd489c5347b113ca6594cae00a54b30ba57ac5875324311bfc6f4762e3"
+url = "https://unofficial-builds.nodejs.org/download/release/v24.15.0/node-v24.15.0-linux-x64-musl.tar.gz"
 
 [tools.node."platforms.macos-arm64"]
-checksum = "sha256:e1a97e14c99c803e96c7339403282ea05a499c32f8d83defe9ef5ec66f979ed1"
-url = "https://nodejs.org/dist/v24.18.0/node-v24.18.0-darwin-arm64.tar.gz"
+checksum = "sha256:372331b969779ab5d15b949884fc6eaf88d5afe87bde8ba881d6400b9100ffc4"
+url = "https://nodejs.org/dist/v24.15.0/node-v24.15.0-darwin-arm64.tar.gz"
 
 [tools.node."platforms.macos-x64"]
-checksum = "sha256:dfd0dbd3e721503434df7b7205e719f61b3a3a31b2bcf9729b8b91fea240f080"
-url = "https://nodejs.org/dist/v24.18.0/node-v24.18.0-darwin-x64.tar.gz"
+checksum = "sha256:ffd5ee293467927f3ee731a553eb88fd1f48cf74eebc2d74a6babe4af228673b"
+url = "https://nodejs.org/dist/v24.15.0/node-v24.15.0-darwin-x64.tar.gz"
 
 [tools.node."platforms.windows-x64"]
-checksum = "sha256:0ae68406b42d7725661da979b1403ec9926da205c6770827f33aac9d8f26e821"
-url = "https://nodejs.org/dist/v24.18.0/node-v24.18.0-win-x64.zip"
+checksum = "sha256:cc5149eabd53779ce1e7bdc5401643622d0c7e6800ade18928a767e940bb0e62"
+url = "https://nodejs.org/dist/v24.15.0/node-v24.15.0-win-x64.zip"
 
 [[tools."npm:oazapfts"]]
 version = "7.5.0"

mise.toml

@@ -15,7 +15,7 @@ config_roots = [
 ]
 
 [tools]
-node = "24.18.0"
+node = "24.15.0"
 pnpm = "11.6.0"
 terragrunt = "1.0.3"
 opentofu = "1.11.6"

mobile/lib/domain/models/asset/remote_asset.model.dart

@@ -52,6 +52,8 @@ class RemoteAsset extends BaseAsset {
 
   bool get isTrashed => deletedAt != null;
 
+  bool get isStacked => stackId != null;
+
   @override
   String toString() {
     return '''Asset {

mobile/lib/presentation/actions/favorite.action.dart

@@ -3,25 +3,29 @@ import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/generated/translations.g.dart';
 import 'package:immich_mobile/presentation/actions/action.dart';
 import 'package:immich_mobile/providers/infrastructure/asset.provider.dart';
+import 'package:immich_mobile/utils/asset_filter.dart';
 import 'package:immich_ui/immich_ui.dart';
 
 class FavoriteAction extends AssetAction<RemoteAsset> {
-  final bool shouldFavorite;
+  final bool favorite;
 
-  FavoriteAction({required super.assets}) : shouldFavorite = assets.any((asset) => !asset.isFavorite);
+  FavoriteAction({required super.assets}) : favorite = assets.any((asset) => !asset.isFavorite);
 
   @override
-  IconData get icon => shouldFavorite ? Icons.favorite_border_rounded : Icons.favorite_rounded;
+  IconData get icon => favorite ? Icons.favorite_border_rounded : Icons.favorite_rounded;
 
   @override
-  String label(ActionScope scope) => shouldFavorite ? scope.context.t.favorite : scope.context.t.unfavorite;
+  String label(ActionScope scope) => favorite ? scope.context.t.favorite : scope.context.t.unfavorite;
 
   @override
-  Iterable<RemoteAsset> filter(ActionScope scope) => assets
-      .where(
-        (asset) => asset is RemoteAsset && asset.ownerId == scope.authUser.id && asset.isFavorite == !shouldFavorite,
-      )
-      .cast<RemoteAsset>();
+  Iterable<RemoteAsset> filter(ActionScope scope) {
+    final owned = AssetFilter(assets).owned(scope.authUser.id);
+    if (favorite) {
+      return owned.notFavorites();
+    } else {
+      return owned.favorites();
+    }
+  }
 
   @override
   bool isVisible(ActionScope scope) => filter(scope).isNotEmpty;
@@ -31,8 +35,8 @@ class FavoriteAction extends AssetAction<RemoteAsset> {
     final ActionScope(:ref) = scope;
     final assets = filter(scope).map((asset) => asset.id).toList(growable: false);
 
-    await ref.read(assetServiceProvider).updateFavorite(assets, shouldFavorite);
-    final message = shouldFavorite
+    await ref.read(assetServiceProvider).updateFavorite(assets, favorite);
+    final message = favorite
         ? StaticTranslations.instance.favorite_action_prompt(count: assets.length)
         : StaticTranslations.instance.unfavorite_action_prompt(count: assets.length);
     snackbar.success(message);

mobile/lib/utils/asset_filter.dart

@@ -0,0 +1,28 @@
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+
+extension type const AssetFilter<T extends BaseAsset>(Iterable<T> assets) implements Iterable<T> {
+  AssetFilter<T> where(bool Function(T asset) test) => AssetFilter(assets.where(test));
+  AssetFilter<T> whereNot(bool Function(T asset) test) => AssetFilter(assets.where((asset) => !test(asset)));
+
+  AssetFilter<T> type(AssetType type) => where((asset) => asset.type == type);
+  AssetFilter<T> favorites() => where(_isFavorite);
+  AssetFilter<T> notFavorites() => whereNot(_isFavorite);
+
+  AssetFilter<RemoteAsset> remote() => AssetFilter(assets.whereType<RemoteAsset>());
+  AssetFilter<RemoteAsset> owned(String ownerId) => remote().where((asset) => asset.ownerId == ownerId);
+  AssetFilter<RemoteAsset> visibility(AssetVisibility visibility) => remote().where(_hasVisibility(visibility));
+  AssetFilter<RemoteAsset> notVisibility(AssetVisibility visibility) => remote().whereNot(_hasVisibility(visibility));
+  AssetFilter<RemoteAsset> archived() => visibility(.archive);
+  AssetFilter<RemoteAsset> notArchived() => notVisibility(.archive);
+  AssetFilter<RemoteAsset> stacked() => remote().where(_isStacked);
+  AssetFilter<RemoteAsset> notStacked() => remote().whereNot(_isStacked);
+
+  AssetFilter<LocalAsset> local() => AssetFilter(assets.whereType<LocalAsset>());
+  AssetFilter<LocalAsset> backedUp() => local().where(_isBackedUp);
+}
+
+bool _isFavorite(BaseAsset asset) => asset.isFavorite;
+bool _isStacked(RemoteAsset asset) => asset.isStacked;
+bool _isBackedUp(LocalAsset asset) => asset.remoteAssetId != null;
+bool Function(RemoteAsset asset) _hasVisibility(AssetVisibility visibility) =>
+    (asset) => asset.visibility == visibility;

mobile/test/unit/factories/remote_asset_factory.dart

@@ -5,7 +5,14 @@ import '../../utils.dart';
 class RemoteAssetFactory {
   const RemoteAssetFactory();
 
-  static RemoteAsset create({String? id, String? name, String? ownerId, bool isFavorite = false}) {
+  static RemoteAsset create({
+    String? id,
+    String? name,
+    String? ownerId,
+    bool isFavorite = false,
+    AssetVisibility visibility = AssetVisibility.timeline,
+    String? stackId,
+  }) {
     id = TestUtils.uuid(id);
 
     return RemoteAsset(
@@ -17,6 +24,8 @@ class RemoteAssetFactory {
       createdAt: TestUtils.yesterday(),
       updatedAt: TestUtils.now(),
       isFavorite: isFavorite,
+      visibility: visibility,
+      stackId: stackId,
       isEdited: false,
     );
   }

mobile/test/unit/utils/asset_filter_test.dart

@@ -0,0 +1,200 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/utils/asset_filter.dart';
+
+import '../factories/local_asset_factory.dart';
+import '../factories/remote_asset_factory.dart';
+
+void main() {
+  group('AssetFilter', () {
+    group('type promotion', () {
+      test('a bare filter retains every BaseAsset', () {
+        final remoteAsset = RemoteAssetFactory.create();
+        final localAsset = LocalAssetFactory.create();
+
+        final AssetFilter<BaseAsset> filter = AssetFilter(<BaseAsset>[remoteAsset, localAsset]);
+
+        expect(filter.toList(), [remoteAsset, localAsset]);
+      });
+
+      test('remote keeps only remote assets', () {
+        final remoteAsset = RemoteAssetFactory.create();
+        final localAsset = LocalAssetFactory.create();
+
+        final AssetFilter<RemoteAsset> remoteOnly = AssetFilter(<BaseAsset>[remoteAsset, localAsset]).remote();
+
+        expect(remoteOnly.toList(), [remoteAsset]);
+      });
+
+      test('local keeps only local assets', () {
+        final remoteAsset = RemoteAssetFactory.create();
+        final localAsset = LocalAssetFactory.create();
+
+        final AssetFilter<LocalAsset> localOnly = AssetFilter(<BaseAsset>[remoteAsset, localAsset]).local();
+
+        expect(localOnly.toList(), [localAsset]);
+      });
+
+      test('owned promotes to RemoteAsset and drops local assets', () {
+        final remoteAsset = RemoteAssetFactory.create();
+        final localAsset = LocalAssetFactory.create();
+
+        final AssetFilter<RemoteAsset> remoteOnly = AssetFilter(<BaseAsset>[
+          remoteAsset,
+          localAsset,
+        ]).owned(remoteAsset.ownerId);
+
+        expect(remoteOnly.toList(), [remoteAsset]);
+      });
+
+      test('backedUp promotes to LocalAsset and drops remote assets', () {
+        final syncedPhoto = LocalAssetFactory.create().copyWith(remoteId: 'remote');
+        final offlinePhoto = LocalAssetFactory.create();
+        final remotePhoto = RemoteAssetFactory.create();
+
+        final AssetFilter<LocalAsset> syncedPhotos = AssetFilter(<BaseAsset>[
+          syncedPhoto,
+          offlinePhoto,
+          remotePhoto,
+        ]).backedUp();
+
+        expect(syncedPhotos.toList(), [syncedPhoto]);
+      });
+    });
+
+    group('named filters', () {
+      test('owned keeps only assets of the given owner', () {
+        final asset1 = RemoteAssetFactory.create();
+        final asset2 = RemoteAssetFactory.create();
+
+        final alexPhotos = AssetFilter([asset1, asset2]).owned(asset1.ownerId);
+
+        expect(alexPhotos.toList(), [asset1]);
+      });
+
+      test('favorites keeps only favorite assets', () {
+        final asset1 = RemoteAssetFactory.create(isFavorite: true);
+        final asset2 = RemoteAssetFactory.create(ownerId: asset1.ownerId);
+
+        final favorites = AssetFilter([asset1, asset2]).favorites();
+
+        expect(favorites.toList(), [asset1]);
+      });
+
+      test('type keeps only assets of the given type', () {
+        final image = RemoteAssetFactory.create();
+        final video = RemoteAssetFactory.create(ownerId: image.ownerId).copyWith(type: .video);
+
+        final videos = AssetFilter([image, video]).type(.video);
+
+        expect(videos.toList(), [video]);
+      });
+
+      test('visibility keeps only assets with the given visibility', () {
+        final locked = RemoteAssetFactory.create(visibility: AssetVisibility.locked);
+        final onTimeline = RemoteAssetFactory.create(ownerId: locked.ownerId);
+
+        final lockedPhotos = AssetFilter([locked, onTimeline]).visibility(.locked);
+
+        expect(lockedPhotos.toList(), [locked]);
+      });
+
+      test('archived keeps only archived assets', () {
+        final archived = RemoteAssetFactory.create(visibility: AssetVisibility.archive);
+        final onTimeline = RemoteAssetFactory.create(ownerId: archived.ownerId);
+
+        final archivedPhotos = AssetFilter([archived, onTimeline]).archived();
+
+        expect(archivedPhotos.toList(), [archived]);
+      });
+
+      test('stacked keeps only assets belonging to a stack', () {
+        final stacked = RemoteAssetFactory.create(stackId: 'stack');
+        final loose = RemoteAssetFactory.create(ownerId: stacked.ownerId);
+
+        final stackedPhotos = AssetFilter([stacked, loose]).stacked();
+
+        expect(stackedPhotos.toList(), [stacked]);
+      });
+    });
+
+    group('inversion', () {
+      test('notArchived keeps every non-archived visibility', () {
+        final archived = RemoteAssetFactory.create(visibility: AssetVisibility.archive);
+        final onTimeline = RemoteAssetFactory.create(ownerId: archived.ownerId, visibility: AssetVisibility.timeline);
+        final hidden = RemoteAssetFactory.create(ownerId: archived.ownerId, visibility: AssetVisibility.hidden);
+        final locked = RemoteAssetFactory.create(ownerId: archived.ownerId, visibility: AssetVisibility.locked);
+
+        final visiblePhotos = AssetFilter([archived, onTimeline, hidden, locked]).notArchived();
+
+        expect(visiblePhotos.toSet(), {onTimeline, hidden, locked});
+      });
+
+      test('notVisibility keeps every asset not at the target visibility', () {
+        final archived = RemoteAssetFactory.create(visibility: AssetVisibility.archive);
+        final onTimeline = RemoteAssetFactory.create(ownerId: archived.ownerId, visibility: AssetVisibility.timeline);
+        final locked = RemoteAssetFactory.create(ownerId: archived.ownerId, visibility: AssetVisibility.locked);
+
+        final toArchive = AssetFilter([archived, onTimeline, locked]).notVisibility(.archive);
+
+        expect(toArchive.toSet(), {onTimeline, locked});
+      });
+
+      test('notStacked keeps only assets without a stack', () {
+        final stacked = RemoteAssetFactory.create(stackId: 'stack');
+        final loose = RemoteAssetFactory.create(ownerId: stacked.ownerId);
+
+        final loosePhotos = AssetFilter([stacked, loose]).notStacked();
+
+        expect(loosePhotos.toList(), [loose]);
+      });
+
+      test('whereNot inverts an arbitrary predicate', () {
+        final favorite = RemoteAssetFactory.create(isFavorite: true);
+        final regular = RemoteAssetFactory.create(ownerId: favorite.ownerId);
+
+        final nonFavorites = AssetFilter([favorite, regular]).whereNot((asset) => asset.isFavorite);
+
+        expect(nonFavorites.toList(), [regular]);
+      });
+
+      test('notFavorites keeps only non-favorite assets', () {
+        final favorite = RemoteAssetFactory.create(isFavorite: true);
+        final regular = RemoteAssetFactory.create(ownerId: favorite.ownerId);
+
+        final nonFavorites = AssetFilter([favorite, regular]).notFavorites();
+
+        expect(nonFavorites.toList(), [regular]);
+      });
+    });
+
+    group('chaining', () {
+      test('combines predicates across owner, visibility and stack', () {
+        final asset = RemoteAssetFactory.create();
+        final wrongOwner = RemoteAssetFactory.create();
+        final archived = RemoteAssetFactory.create(ownerId: asset.ownerId, visibility: AssetVisibility.archive);
+        final stacked = RemoteAssetFactory.create(ownerId: asset.ownerId, stackId: 'stack-1');
+        final localPhoto = LocalAssetFactory.create();
+
+        final result = AssetFilter(<BaseAsset>[
+          asset,
+          wrongOwner,
+          archived,
+          stacked,
+          localPhoto,
+        ]).owned(asset.ownerId).notArchived().notStacked();
+
+        expect(result.toList(), [asset]);
+      });
+
+      test('a base filter after a promotion retains the promoted type', () {
+        final favorite = RemoteAssetFactory.create(isFavorite: true);
+        final regular = RemoteAssetFactory.create(ownerId: favorite.ownerId);
+
+        final AssetFilter<RemoteAsset> result = AssetFilter([favorite, regular]).owned(favorite.ownerId).favorites();
+
+        expect(result.toList(), [favorite]);
+      });
+    });
+  });
+}

server/src/queries/search.repository.sql

@@ -7,17 +7,18 @@ from
   "asset"
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
-  "asset"."fileCreatedAt" >= $1
-  and "asset_exif"."lensModel" = $2
-  and "asset"."ownerId" = any ($3::uuid[])
-  and "asset"."isFavorite" = $4
+  "asset"."visibility" = $1
+  and "asset"."fileCreatedAt" >= $2
+  and "asset_exif"."lensModel" = $3
+  and "asset"."ownerId" = any ($4::uuid[])
+  and "asset"."isFavorite" = $5
   and "asset"."deletedAt" is null
 order by
   "asset"."fileCreatedAt" desc
 limit
-  $5
-offset
   $6
+offset
+  $7
 
 -- SearchRepository.searchStatistics
 select
@@ -26,10 +27,11 @@ from
   "asset"
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
-  "asset"."fileCreatedAt" >= $1
-  and "asset_exif"."lensModel" = $2
-  and "asset"."ownerId" = any ($3::uuid[])
-  and "asset"."isFavorite" = $4
+  "asset"."visibility" = $1
+  and "asset"."fileCreatedAt" >= $2
+  and "asset_exif"."lensModel" = $3
+  and "asset"."ownerId" = any ($4::uuid[])
+  and "asset"."isFavorite" = $5
   and "asset"."deletedAt" is null
 
 -- SearchRepository.searchRandom
@@ -39,15 +41,16 @@ from
   "asset"
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
-  "asset"."fileCreatedAt" >= $1
-  and "asset_exif"."lensModel" = $2
-  and "asset"."ownerId" = any ($3::uuid[])
-  and "asset"."isFavorite" = $4
+  "asset"."visibility" = $1
+  and "asset"."fileCreatedAt" >= $2
+  and "asset_exif"."lensModel" = $3
+  and "asset"."ownerId" = any ($4::uuid[])
+  and "asset"."isFavorite" = $5
   and "asset"."deletedAt" is null
 order by
   random()
 limit
-  $5
+  $6
 
 -- SearchRepository.searchLargeAssets
 select
@@ -57,16 +60,17 @@ from
   "asset"
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
-  "asset"."fileCreatedAt" >= $1
-  and "asset_exif"."lensModel" = $2
-  and "asset"."ownerId" = any ($3::uuid[])
-  and "asset"."isFavorite" = $4
+  "asset"."visibility" = $1
+  and "asset"."fileCreatedAt" >= $2
+  and "asset_exif"."lensModel" = $3
+  and "asset"."ownerId" = any ($4::uuid[])
+  and "asset"."isFavorite" = $5
   and "asset"."deletedAt" is null
-  and "asset_exif"."fileSizeInByte" > $5
+  and "asset_exif"."fileSizeInByte" > $6
 order by
   "asset_exif"."fileSizeInByte" desc
 limit
-  $6
+  $7
 
 -- SearchRepository.searchSmart
 begin
@@ -79,17 +83,18 @@ from
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
   inner join "smart_search" on "asset"."id" = "smart_search"."assetId"
 where
-  "asset"."fileCreatedAt" >= $1
-  and "asset_exif"."lensModel" = $2
-  and "asset"."ownerId" = any ($3::uuid[])
-  and "asset"."isFavorite" = $4
+  "asset"."visibility" = $1
+  and "asset"."fileCreatedAt" >= $2
+  and "asset_exif"."lensModel" = $3
+  and "asset"."ownerId" = any ($4::uuid[])
+  and "asset"."isFavorite" = $5
   and "asset"."deletedAt" is null
 order by
-  smart_search.embedding <=> $5
+  smart_search.embedding <=> $6
 limit
-  $6
-offset
   $7
+offset
+  $8
 commit
 
 -- SearchRepository.getEmbedding

server/src/repositories/search.repository.ts

@@ -117,8 +117,7 @@ type BaseAssetSearchOptions = SearchDateOptions &
   SearchAlbumOptions &
   SearchOcrOptions;
 
-export type AssetSearchOptions = Omit<BaseAssetSearchOptions, 'visibility'> &
-  SearchRelationOptions & { visibility?: AssetVisibility | 'not-locked' };
+export type AssetSearchOptions = BaseAssetSearchOptions & SearchRelationOptions;
 
 export type AssetSearchBuilderOptions = Omit<AssetSearchOptions, 'orderDirection'>;
 
@@ -126,11 +125,11 @@ export type SmartSearchOptions = SearchDateOptions &
   SearchEmbeddingOptions &
   SearchExifOptions &
   SearchOneToOneRelationOptions &
-  Omit<SearchStatusOptions, 'visibility'> &
+  SearchStatusOptions &
   SearchUserIdOptions &
   SearchPeopleOptions &
   SearchTagOptions &
-  SearchOcrOptions & { visibility?: AssetVisibility | 'not-locked' };
+  SearchOcrOptions;
 
 export type OcrSearchOptions = SearchDateOptions & SearchOcrOptions;
 

server/src/services/search.service.spec.ts

@@ -250,7 +250,7 @@ describe(SearchService.name, () => {
       );
       expect(mocks.search.searchSmart).toHaveBeenCalledWith(
         { page: 1, size: 100 },
-        { query: 'test', embedding: '[1, 2, 3]', userIds: [authStub.user1.user.id], visibility: 'not-locked' },
+        { query: 'test', embedding: '[1, 2, 3]', userIds: [authStub.user1.user.id] },
       );
     });
 

server/src/services/search.service.ts

@@ -73,22 +73,14 @@ export class SearchService extends BaseService {
       checksum = Buffer.from(dto.checksum, encoding);
     }
 
-    let userIds: string[] | undefined;
-
-    if (dto.albumIds && dto.albumIds.length > 0) {
-      await this.requireAccess({ auth, ids: dto.albumIds, permission: Permission.AlbumRead });
-    } else {
-      userIds = await this.getUserIdsToSearch(auth, dto.visibility);
-    }
-
     const page = dto.page ?? 1;
     const size = dto.size || 250;
+    const userIds = await this.getUserIdsToSearch(auth, dto.visibility);
     const { hasNextPage, items } = await this.searchRepository.searchMetadata(
       { page, size },
       {
         ...dto,
         checksum,
-        visibility: dto.visibility ?? (auth.session?.hasElevatedPermission ? undefined : 'not-locked'),
         userIds,
         orderDirection: dto.order ?? AssetOrder.Desc,
       },
@@ -99,13 +91,9 @@ export class SearchService extends BaseService {
 
   async searchStatistics(auth: AuthDto, dto: StatisticsSearchDto): Promise<SearchStatisticsResponseDto> {
     const userIds = await this.getUserIdsToSearch(auth);
-    if (dto.visibility === AssetVisibility.Locked) {
-      requireElevatedPermission(auth);
-    }
 
     return await this.searchRepository.searchStatistics({
       ...dto,
-      visibility: dto.visibility ?? (auth.session?.hasElevatedPermission ? undefined : 'not-locked'),
       userIds,
     });
   }
@@ -126,11 +114,7 @@ export class SearchService extends BaseService {
     }
 
     const userIds = await this.getUserIdsToSearch(auth, dto.visibility);
-    const items = await this.searchRepository.searchLargeAssets(dto.size || 250, {
-      ...dto,
-      visibility: dto.visibility ?? (auth.session?.hasElevatedPermission ? undefined : 'not-locked'),
-      userIds,
-    });
+    const items = await this.searchRepository.searchLargeAssets(dto.size || 250, { ...dto, userIds });
     return items.map((item) => mapAsset(item, { auth }));
   }
 
@@ -171,12 +155,7 @@ export class SearchService extends BaseService {
     const size = dto.size || 100;
     const { hasNextPage, items } = await this.searchRepository.searchSmart(
       { page, size },
-      {
-        ...dto,
-        userIds: await userIds,
-        embedding,
-        visibility: dto.visibility ?? (auth.session?.hasElevatedPermission ? undefined : 'not-locked'),
-      },
+      { ...dto, userIds: await userIds, embedding },
     );
 
     return this.mapResponse(items, hasNextPage ? (page + 1).toString() : null, { auth });

server/src/utils/database.ts

@@ -373,15 +373,12 @@ const joinDeduplicationPlugin = new DeduplicateJoinsPlugin();
 
 export function searchAssetBuilder(kysely: Kysely<DB>, options: AssetSearchBuilderOptions) {
   options.withDeleted ||= !!(options.trashedAfter || options.trashedBefore || options.isOffline);
+  const visibility = options.visibility == null ? AssetVisibility.Timeline : options.visibility;
 
   return kysely
     .withPlugin(joinDeduplicationPlugin)
     .selectFrom('asset')
-    .$if(!!options.visibility, (qb) =>
-      options.visibility === 'not-locked'
-        ? qb.where('asset.visibility', '!=', AssetVisibility.Locked)
-        : qb.where('asset.visibility', '=', options.visibility!),
-    )
+    .where('asset.visibility', '=', visibility)
     .$if(!!options.albumIds && options.albumIds.length > 0, (qb) => inAlbums(qb, options.albumIds!))
     .$if(!!options.tagIds && options.tagIds.length > 0, (qb) => hasTags(qb, options.tagIds!))
     .$if(options.tagIds === null, (qb) =>

server/test/medium/specs/services/search.service.spec.ts

@@ -1,6 +1,5 @@
 import { Kysely } from 'kysely';
 import { SearchSuggestionType } from 'src/dtos/search.dto';
-import { AlbumUserRole, AssetVisibility } from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { AssetRepository } from 'src/repositories/asset.repository';
 import { DatabaseRepository } from 'src/repositories/database.repository';
@@ -109,71 +108,6 @@ describe(SearchService.name, () => {
       expect(response.assets.items.length).toBe(1);
       expect(response.assets.items[0].id).toBe(unstackedAsset.id);
     });
-
-    describe('visibility', () => {
-      it('should filter out locked assets in a default session', async () => {
-        const { sut, ctx } = setup();
-        const { user } = await ctx.newUser();
-
-        await ctx.newAsset({ ownerId: user.id, visibility: AssetVisibility.Locked });
-
-        const auth = factory.auth({ user: { id: user.id } });
-
-        const response = await sut.searchMetadata(auth, { withStacked: false });
-
-        expect(response.assets.items.length).toBe(0);
-      });
-
-      it('should return locked assets in an elevated session', async () => {
-        const { sut, ctx } = setup();
-        const { user } = await ctx.newUser();
-
-        await ctx.newAsset({ ownerId: user.id, visibility: AssetVisibility.Locked });
-
-        const auth = factory.auth({ user: { id: user.id }, session: { hasElevatedPermission: true } });
-
-        const response = await sut.searchMetadata(auth, { withStacked: false });
-
-        expect(response.assets.items.length).toBe(1);
-      });
-    });
-  });
-
-  describe('albumIds option', () => {
-    it('should return assets from shared album', async () => {
-      const { sut, ctx } = setup();
-      const { user } = await ctx.newUser();
-      const { user: otherUser } = await ctx.newUser();
-
-      const { asset } = await ctx.newAsset({ ownerId: otherUser.id });
-      const { album } = await ctx.newAlbum({ ownerId: otherUser.id });
-      await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
-      await ctx.newAlbumUser({ albumId: album.id, userId: user.id, role: AlbumUserRole.Editor });
-
-      const auth = factory.auth({ user: { id: user.id } });
-
-      const response = await sut.searchMetadata(auth, { albumIds: [album.id] });
-
-      expect(response.assets.items.length).toBe(1);
-    });
-
-    it('should not return assets for album, a user is not in, when partner sharing is enabled', async () => {
-      const { sut, ctx } = setup();
-      const { user } = await ctx.newUser();
-      const { user: otherUser } = await ctx.newUser();
-
-      await ctx.newPartner({ sharedById: otherUser.id, sharedWithId: user.id });
-
-      const { asset } = await ctx.newAsset({ ownerId: otherUser.id });
-      const { album } = await ctx.newAlbum({ ownerId: otherUser.id });
-      await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
-
-      const auth = factory.auth({ user: { id: user.id } });
-
-      await expect(sut.searchMetadata(auth, { albumIds: [album.id] })).rejects.toThrow(
-        'Not found or no album.read access',
-      );
-    });
   });
 
   describe('getSearchSuggestions', () => {

server/test/small.factory.ts

@@ -27,7 +27,7 @@ const authFactory = ({
   user,
 }: {
   apiKey?: Partial<AuthApiKey>;
-  session?: { id?: string; hasElevatedPermission?: boolean };
+  session?: { id: string };
   user?: Omit<
     Partial<UserAdmin>,
     'createdAt' | 'updatedAt' | 'deletedAt' | 'fileCreatedAt' | 'fileModifiedAt' | 'localDateTime' | 'profileChangedAt'
@@ -46,8 +46,8 @@ const authFactory = ({
 
   if (session) {
     auth.session = {
-      id: session.id ?? newUuid(),
-      hasElevatedPermission: session.hasElevatedPermission ?? false,
+      id: session.id,
+      hasElevatedPermission: false,
     };
   }