fix(deps): update mobile

mobile/lib/constants/enums.dart

@@ -9,6 +9,8 @@ enum SortOrder {
 
 enum TextSearchType { context, filename, description, ocr }
 
+enum AssetVisibilityEnum { timeline, hidden, archive, locked }
+
 enum ActionSource { timeline, viewer }
 
 enum ShareAssetType { original, preview }

mobile/lib/constants/locales.dart

@@ -6,7 +6,6 @@ const Map<String, Locale> locales = {
   // Additional locales
   'Arabic (ar)': Locale('ar'),
   'Basque (eu)': Locale('eu'),
-  'Belarusian (be)': Locale('be'),
   'Bosnian (bl)': Locale('bn'),
   'Brazilian Portuguese (pt_BR)': Locale('pt', 'BR'),
   'Bulgarian (bg)': Locale('bg'),

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

@@ -10,7 +10,6 @@ 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/entities/stack.entity.drift.dart';
 import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
-import 'package:immich_mobile/utils/option.dart';
 import 'package:maplibre_gl/maplibre_gl.dart';
 
 class RemoteAssetRepository extends DriftDatabaseRepository {
@@ -293,20 +292,4 @@ class RemoteAssetRepository extends DriftDatabaseRepository {
       ..orderBy([(row) => OrderingTerm.asc(row.sequence)]);
     return query.map((row) => row.toDto()!).get();
   }
-
-  Future<void> update(
-    List<String> remoteIds, {
-    Option<bool> isFavorite = const .none(),
-    Option<AssetVisibility> visibility = const .none(),
-  }) {
-    final companion = RemoteAssetEntityCompanion(
-      visibility: visibility.toDriftValue(),
-      isFavorite: isFavorite.toDriftValue(),
-    );
-    return _db.batch((batch) {
-      for (final remoteId in remoteIds) {
-        batch.update(_db.remoteAssetEntity, companion, where: (e) => e.id.equals(remoteId));
-      }
-    });
-  }
 }

mobile/lib/presentation/widgets/people/person_edit_birthday_modal.widget.dart

@@ -65,7 +65,6 @@ class _DriftPersonNameEditFormState extends ConsumerState<DriftPersonBirthdayEdi
         child: ClipRRect(
           borderRadius: const BorderRadius.all(Radius.circular(16.0)),
           child: ScrollDatePicker(
-            viewType: datePickerColumnOrder(DateFormat.yMd(context.locale.toLanguageTag()).pattern),
             options: DatePickerOptions(
               backgroundColor: context.colorScheme.surfaceContainerHigh,
               itemExtent: 50,
@@ -119,18 +118,3 @@ class _DriftPersonNameEditFormState extends ConsumerState<DriftPersonBirthdayEdi
     );
   }
 }
-
-List<DatePickerViewType>? datePickerColumnOrder(String? pattern) {
-  if (pattern == null) {
-    return null;
-  }
-  final positions = {
-    DatePickerViewType.year: pattern.indexOf('y'),
-    DatePickerViewType.month: pattern.indexOf('M'),
-    DatePickerViewType.day: pattern.indexOf('d'),
-  };
-  if (positions.values.any((position) => position < 0)) {
-    return null;
-  }
-  return positions.keys.toList()..sort((a, b) => positions[a]!.compareTo(positions[b]!));
-}

mobile/lib/providers/infrastructure/toast.provider.dart

@@ -1,4 +0,0 @@
-import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:immich_mobile/repositories/toast.repository.dart';
-
-final toastRepositoryProvider = Provider<ToastRepository>((ref) => const .new());

mobile/lib/repositories/asset_api.repository.dart

@@ -1,14 +1,12 @@
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 import 'package:http/http.dart';
-import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/constants/enums.dart';
 import 'package:immich_mobile/domain/models/asset_edit.model.dart' hide AssetEditAction;
 import 'package:immich_mobile/domain/models/stack.model.dart';
 import 'package:immich_mobile/providers/api.provider.dart';
 import 'package:immich_mobile/repositories/api.repository.dart';
-import 'package:immich_mobile/utils/option.dart';
 import 'package:maplibre_gl/maplibre_gl.dart';
-import 'package:openapi/api.dart' as api show AssetVisibility;
-import 'package:openapi/api.dart' hide AssetVisibility;
+import 'package:openapi/api.dart';
 
 final assetApiRepositoryProvider = Provider(
   (ref) => AssetApiRepository(
@@ -43,7 +41,7 @@ class AssetApiRepository extends ApiRepository {
     return response?.count ?? 0;
   }
 
-  Future<void> updateVisibility(List<String> ids, AssetVisibility visibility) async {
+  Future<void> updateVisibility(List<String> ids, AssetVisibilityEnum visibility) async {
     return _api.updateAssets(AssetBulkUpdateDto(ids: ids, visibility: Optional.present(_mapVisibility(visibility))));
   }
 
@@ -79,11 +77,11 @@ class AssetApiRepository extends ApiRepository {
     return _api.downloadAssetWithHttpInfo(id, edited: edited);
   }
 
-  api.AssetVisibility _mapVisibility(AssetVisibility visibility) => switch (visibility) {
-    AssetVisibility.timeline => api.AssetVisibility.timeline,
-    AssetVisibility.hidden => api.AssetVisibility.hidden,
-    AssetVisibility.locked => api.AssetVisibility.locked,
-    AssetVisibility.archive => api.AssetVisibility.archive,
+  _mapVisibility(AssetVisibilityEnum visibility) => switch (visibility) {
+    AssetVisibilityEnum.timeline => AssetVisibility.timeline,
+    AssetVisibilityEnum.hidden => AssetVisibility.hidden,
+    AssetVisibilityEnum.locked => AssetVisibility.locked,
+    AssetVisibilityEnum.archive => AssetVisibility.archive,
   };
 
   Future<String?> getAssetMIMEType(String assetId) async {
@@ -108,20 +106,6 @@ class AssetApiRepository extends ApiRepository {
   Future<void> removeEdits(String assetId) async {
     return _api.removeAssetEdits(assetId);
   }
-
-  Future<void> update(
-    List<String> remoteIds, {
-    Option<bool> isFavorite = const .none(),
-    Option<AssetVisibility> visibility = const .none(),
-  }) {
-    return _api.updateAssets(
-      AssetBulkUpdateDto(
-        ids: remoteIds,
-        isFavorite: isFavorite.toOptional(),
-        visibility: visibility.map(_mapVisibility).toOptional(),
-      ),
-    );
-  }
 }
 
 extension on StackResponseDto {

mobile/lib/repositories/toast.repository.dart

@@ -1,26 +0,0 @@
-import 'dart:async';
-
-import 'package:immich_ui/immich_ui.dart';
-
-class ToastOption {
-  final Duration? timeout;
-  final FutureOr<void> Function()? onUndo;
-
-  const ToastOption({this.timeout, this.onUndo});
-}
-
-class ToastRepository {
-  const ToastRepository();
-
-  FutureOr<void> success(String message, {ToastOption? toast}) {
-    snackbar.success(message, duration: toast?.timeout);
-  }
-
-  FutureOr<void> info(String message, {ToastOption? toast}) {
-    snackbar.info(message, duration: toast?.timeout);
-  }
-
-  FutureOr<void> error(String message, {ToastOption? toast}) {
-    snackbar.error(message, duration: toast?.timeout);
-  }
-}

mobile/lib/services/action.service.dart

@@ -79,17 +79,17 @@ class ActionService {
   }
 
   Future<void> archive(List<String> remoteIds) async {
-    await _assetApiRepository.updateVisibility(remoteIds, .archive);
+    await _assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.archive);
     await _remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.archive);
   }
 
   Future<void> unArchive(List<String> remoteIds) async {
-    await _assetApiRepository.updateVisibility(remoteIds, .timeline);
+    await _assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.timeline);
     await _remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.timeline);
   }
 
   Future<void> moveToLockFolder(List<String> remoteIds, List<String> localIds) async {
-    await _assetApiRepository.updateVisibility(remoteIds, .locked);
+    await _assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.locked);
     await _remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.locked);
 
     // Ask user if they want to delete local copies
@@ -99,7 +99,7 @@ class ActionService {
   }
 
   Future<void> removeFromLockFolder(List<String> remoteIds) async {
-    await _assetApiRepository.updateVisibility(remoteIds, .timeline);
+    await _assetApiRepository.updateVisibility(remoteIds, AssetVisibilityEnum.timeline);
     await _remoteAssetRepository.updateVisibility(remoteIds, AssetVisibility.timeline);
   }
 

mobile/lib/utils/option.dart

@@ -1,4 +1,3 @@
-import 'package:drift/drift.dart';
 import 'package:openapi/api.dart' show Optional;
 
 sealed class Option<T> {
@@ -22,11 +21,6 @@ sealed class Option<T> {
     None() => null,
   };
 
-  Option<U> map<U>(U Function(T value) f) => switch (this) {
-    Some(:final value) => Some(f(value)),
-    None() => None<U>(),
-  };
-
   U fold<U>(U Function(T value) onSome, U Function() onNone) => switch (this) {
     Some(:final value) => onSome(value),
     None() => onNone(),
@@ -71,10 +65,3 @@ extension OptionToOptional<T> on Option<T> {
     Some(:final value) => Optional.present(value),
   };
 }
-
-extension OptionToDriftValue<T> on Option<T> {
-  Value<T> toDriftValue() => switch (this) {
-    Some(:final value) => Value(value),
-    None() => const Value.absent(),
-  };
-}

mobile/mise.toml

@@ -1,9 +1,9 @@
 [tools]
-"aqua:flutter/flutter" = "3.44.6"
-java = "21.0.2"
+"aqua:flutter/flutter" = "3.44.7"
+java = "21.0.11+10.0.LTS"
 
 [tools."github:CQLabs/homebrew-dcm"]
-version = "1.37.0"
+version = "1.38.2"
 bin = "dcm"
 postinstall = "chmod +x \"$MISE_TOOL_INSTALL_PATH/dcm\" || true"
 

mobile/packages/ui/lib/src/snackbar.dart

@@ -6,23 +6,18 @@ final scaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
 class SnackbarManager {
   const SnackbarManager();
 
-  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? show(
-    String message,
-    SnackbarType type, {
-    Duration? duration,
-  }) {
+  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? show(String message, SnackbarType type) {
     final messenger = scaffoldMessengerKey.currentState;
     final context = scaffoldMessengerKey.currentContext;
     if (messenger == null || context == null) {
       return null;
     }
 
-    duration ??= const .new(seconds: 4);
     messenger.hideCurrentSnackBar();
-    return messenger.showSnackBar(_build(context, message, type, duration));
+    return messenger.showSnackBar(_build(context, message, type));
   }
 
-  SnackBar _build(BuildContext context, String message, SnackbarType type, Duration duration) {
+  SnackBar _build(BuildContext context, String message, SnackbarType type) {
     final theme = Theme.of(context);
     final colors = theme.extension<ImmichColors>() ?? ImmichColors.harmonized(theme.colorScheme);
     final (IconData icon, Color background, Color foreground) = switch (type) {
@@ -34,7 +29,7 @@ class SnackbarManager {
     return SnackBar(
       behavior: .floating,
       backgroundColor: background,
-      duration: duration,
+      duration: const .new(seconds: 4),
       shape: const RoundedRectangleBorder(borderRadius: .all(.circular(ImmichRadius.sm))),
       content: Row(
         children: [
@@ -53,14 +48,11 @@ class SnackbarManager {
     );
   }
 
-  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? info(String message, {Duration? duration}) =>
-      show(message, .info, duration: duration);
+  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? info(String message) => show(message, .info);
 
-  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? success(String message, {Duration? duration}) =>
-      show(message, .success, duration: duration);
+  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? success(String message) => show(message, .success);
 
-  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? error(String message, {Duration? duration}) =>
-      show(message, .error, duration: duration);
+  ScaffoldFeatureController<SnackBar, SnackBarClosedReason>? error(String message) => show(message, .error);
 }
 
 const snackbar = SnackbarManager();

mobile/pubspec.yaml

@@ -58,7 +58,7 @@ dependencies:
   path_provider: ^2.1.5
   path_provider_foundation: ^2.6.0
   permission_handler: ^11.4.0
-  photo_manager: 3.9.0
+  photo_manager: 3.10.0
   pinput: ^5.0.2
   punycode: ^1.0.0
   scroll_date_picker: ^3.8.0
@@ -68,10 +68,10 @@ dependencies:
   sliver_tools: ^0.2.12
   stream_transform: ^2.1.1
   sqlite3: ^3.3.2
-  sqlite_async: 0.14.2
+  sqlite_async: 0.14.3
   sqlite3_connection_pool: ^0.2.6
   thumbhash: 0.1.0+1
-  timezone: ^0.9.4
+  timezone: ^0.11.0
   url_launcher: ^6.3.2
   uuid: ^4.5.3
   wakelock_plus: ^1.3.3

mobile/test/presentation/widgets/people/person_edit_birthday_modal_test.dart

@@ -1,69 +0,0 @@
-import 'package:flutter_test/flutter_test.dart';
-import 'package:immich_mobile/presentation/widgets/people/person_edit_birthday_modal.widget.dart';
-import 'package:intl/date_symbol_data_local.dart';
-import 'package:intl/intl.dart';
-import 'package:scroll_date_picker/scroll_date_picker.dart';
-
-void main() {
-  group('datePickerColumnOrder', () {
-    test('month first (en_US)', () {
-      expect(
-        datePickerColumnOrder('M/d/y'),
-        orderedEquals([DatePickerViewType.month, DatePickerViewType.day, DatePickerViewType.year]),
-      );
-    });
-
-    test('day first (pl)', () {
-      expect(
-        datePickerColumnOrder('dd.MM.y'),
-        orderedEquals([DatePickerViewType.day, DatePickerViewType.month, DatePickerViewType.year]),
-      );
-    });
-
-    test('year first (ko)', () {
-      expect(
-        datePickerColumnOrder('y. M. d.'),
-        orderedEquals([DatePickerViewType.year, DatePickerViewType.month, DatePickerViewType.day]),
-      );
-    });
-
-    test('null pattern falls back to package default', () {
-      expect(datePickerColumnOrder(null), isNull);
-    });
-
-    test('missing field falls back to package default', () {
-      expect(datePickerColumnOrder('M/y'), isNull);
-    });
-  });
-
-  group('datePickerColumnOrder with real locale patterns', () {
-    setUpAll(() async {
-      await initializeDateFormatting();
-    });
-
-    for (final (locales, order, name) in const [
-      (
-        ['en', 'en-US', 'en-PH'],
-        [DatePickerViewType.month, DatePickerViewType.day, DatePickerViewType.year],
-        'month/day/year',
-      ),
-      (
-        ['en-GB', 'fr', 'fr-FR', 'de', 'de-DE', 'pl'],
-        [DatePickerViewType.day, DatePickerViewType.month, DatePickerViewType.year],
-        'day/month/year',
-      ),
-      (
-        ['ja', 'ja-JP', 'zh', 'zh-CN', 'ko', 'ko-KR'],
-        [DatePickerViewType.year, DatePickerViewType.month, DatePickerViewType.day],
-        'year/month/day',
-      ),
-      (['ky'], [DatePickerViewType.year, DatePickerViewType.day, DatePickerViewType.month], 'year/day/month'),
-    ]) {
-      for (final locale in locales) {
-        test('$locale uses $name', () {
-          expect(datePickerColumnOrder(DateFormat.yMd(locale).pattern), orderedEquals(order));
-        });
-      }
-    }
-  });
-}

server/src/controllers/memory.controller.spec.ts

@@ -106,11 +106,7 @@ describe(MemoryController.name, () => {
     it('should require at least one field', async () => {
       const { status, body } = await request(ctx.getHttpServer()).put(`/memories/${factory.uuid()}`).send({});
       expect(status).toBe(400);
-      expect(body).toEqual(
-        errorDto.validationError([
-          { path: [], message: 'At least one of the following fields is required: isSaved, seenAt, memoryAt' },
-        ]),
-      );
+      expect(body).toEqual(errorDto.validationError([{ path: [], message: 'At least one field must be provided' }]));
     });
   });
 

server/src/database.ts

@@ -304,36 +304,6 @@ export const columns = {
     'asset.height',
     'asset.isEdited',
   ],
-  searchAsset: [
-    'asset.id',
-    'asset.updateId',
-    'asset.createdAt',
-    'asset.updatedAt',
-    'asset.deletedAt',
-    'asset.status',
-    'asset.checksum',
-    'asset.checksumAlgorithm',
-    'asset.duplicateId',
-    'asset.duration',
-    'asset.fileCreatedAt',
-    'asset.fileModifiedAt',
-    'asset.isExternal',
-    'asset.isFavorite',
-    'asset.isOffline',
-    'asset.isEdited',
-    'asset.visibility',
-    'asset.libraryId',
-    'asset.livePhotoVideoId',
-    'asset.localDateTime',
-    'asset.originalFileName',
-    'asset.originalPath',
-    'asset.ownerId',
-    'asset.stackId',
-    'asset.thumbhash',
-    'asset.type',
-    'asset.width',
-    'asset.height',
-  ],
   workflowAssetV1: [
     'asset.id',
     'asset.ownerId',

server/src/decorators.ts

@@ -108,11 +108,9 @@ export function ChunkedSet(options?: { paramIndex?: number; chunkSize?: number }
 }
 
 const UUID = '00000000-0000-4000-a000-000000000000';
-const UUID_1 = '00000000-0000-4000-a000-000000000001';
 
 export const DummyValue = {
   UUID,
-  UUID_1,
   UUID_SET: new Set([UUID]),
   PAGINATION: { take: 10, skip: 0 },
   EMAIL: 'user@immich.app',

server/src/dtos/search.dto.ts

@@ -3,15 +3,8 @@ import { Place } from 'src/database';
 import { HistoryBuilder } from 'src/decorators';
 import { AlbumResponseSchema } from 'src/dtos/album.dto';
 import { AssetResponseSchema } from 'src/dtos/asset-response.dto';
-import {
-  AssetOrder,
-  AssetOrderSchema,
-  AssetTypeSchema,
-  AssetVisibilitySchema,
-  SearchOrderField,
-  SearchOrderFieldSchema,
-} from 'src/enum';
-import { isoDatetimeToDate, nonEmptyPartial, stringToBool } from 'src/validation';
+import { AssetOrder, AssetOrderSchema, AssetTypeSchema, AssetVisibilitySchema } from 'src/enum';
+import { isoDatetimeToDate, stringToBool } from 'src/validation';
 import z from 'zod';
 
 const BaseSearchSchema = z.object({
@@ -149,176 +142,6 @@ const SearchSuggestionRequestSchema = z
   })
   .meta({ id: 'SearchSuggestionRequestDto' });
 
-const IdFilterSchema = nonEmptyPartial({
-  eq: z.uuidv4(),
-  ne: z.uuidv4(),
-}).meta({ id: 'IdFilter' });
-
-const IdFilterNullableSchema = nonEmptyPartial({
-  eq: z.uuidv4().nullable(),
-  ne: z.uuidv4().nullable(),
-}).meta({ id: 'IdFilterNullable' });
-
-const IdsFilterSchema = nonEmptyPartial({
-  any: z.array(z.uuidv4()).min(1),
-  all: z.array(z.uuidv4()).min(1),
-  none: z.array(z.uuidv4()).min(1),
-}).meta({ id: 'IdsFilter' });
-
-const stringListShape = {
-  in: z.array(z.string()).min(1),
-  notIn: z.array(z.string()).min(1),
-};
-
-const StringFilterSchema = nonEmptyPartial({
-  eq: z.string(),
-  ne: z.string(),
-  ...stringListShape,
-}).meta({ id: 'StringFilter' });
-
-const stringNullableShape = {
-  eq: z.string().nullable(),
-  ne: z.string().nullable(),
-  ...stringListShape,
-};
-
-const StringFilterNullableSchema = nonEmptyPartial(stringNullableShape).meta({ id: 'StringFilterNullable' });
-
-const StringPatternFilterSchema = nonEmptyPartial({
-  ...stringNullableShape,
-  like: z.string().min(1),
-  notLike: z.string().min(1),
-  startsWith: z.string().min(1),
-  endsWith: z.string().min(1),
-}).meta({ id: 'StringPatternFilter' });
-
-const numberRangeShape = {
-  lt: z.number(),
-  lte: z.number(),
-  gt: z.number(),
-  gte: z.number(),
-  in: z.array(z.number()).min(1),
-  notIn: z.array(z.number()).min(1),
-};
-
-const NumberFilterSchema = nonEmptyPartial({
-  eq: z.number(),
-  ne: z.number(),
-  ...numberRangeShape,
-}).meta({ id: 'NumberFilter' });
-
-const NumberFilterNullableSchema = nonEmptyPartial({
-  eq: z.number().nullable(),
-  ne: z.number().nullable(),
-  ...numberRangeShape,
-}).meta({ id: 'NumberFilterNullable' });
-
-const dateRangeShape = {
-  gt: isoDatetimeToDate,
-  gte: isoDatetimeToDate,
-  lt: isoDatetimeToDate,
-  lte: isoDatetimeToDate,
-};
-
-const DateFilterSchema = nonEmptyPartial({
-  eq: isoDatetimeToDate,
-  ne: isoDatetimeToDate,
-  ...dateRangeShape,
-}).meta({ id: 'DateFilter' });
-
-const DateFilterNullableSchema = nonEmptyPartial({
-  eq: isoDatetimeToDate.nullable(),
-  ne: isoDatetimeToDate.nullable(),
-  ...dateRangeShape,
-}).meta({ id: 'DateFilterNullable' });
-
-const BoolFilterSchema = z.object({ eq: z.boolean() }).meta({ id: 'BoolFilter' });
-
-const enumFilterSchema = <T extends z.core.util.EnumLike>(values: z.ZodEnum<T>, id: string) =>
-  nonEmptyPartial({
-    eq: values,
-    ne: values,
-    in: z.array(values).min(1),
-    notIn: z.array(values).min(1),
-  }).meta({ id });
-
-const EnumFilterAssetTypeSchema = enumFilterSchema(AssetTypeSchema, 'EnumFilterAssetType');
-const EnumFilterAssetVisibilitySchema = enumFilterSchema(AssetVisibilitySchema, 'EnumFilterAssetVisibility');
-
-const StringSimilarityFilterSchema = z
-  .object({
-    matches: z.string().min(1),
-  })
-  .meta({ id: 'StringSimilarityFilter' });
-
-export const DEFAULT_SEARCH_ORDER = {
-  field: SearchOrderField.FileCreatedAt,
-  direction: AssetOrder.Desc,
-};
-
-export const SearchOrderSchema = z
-  .object({
-    field: SearchOrderFieldSchema.default(DEFAULT_SEARCH_ORDER.field),
-    direction: AssetOrderSchema.default(DEFAULT_SEARCH_ORDER.direction),
-  })
-  .meta({ id: 'SearchOrder' });
-
-const SearchFilterBranchSchema = z
-  .object({
-    id: IdFilterSchema,
-    libraryId: IdFilterNullableSchema,
-    type: EnumFilterAssetTypeSchema,
-    visibility: EnumFilterAssetVisibilitySchema,
-    isFavorite: BoolFilterSchema,
-    isMotion: BoolFilterSchema,
-    isOffline: BoolFilterSchema,
-    isEncoded: BoolFilterSchema,
-    hasAlbums: BoolFilterSchema,
-    hasPeople: BoolFilterSchema,
-    hasTags: BoolFilterSchema,
-    city: StringFilterNullableSchema,
-    state: StringFilterNullableSchema,
-    country: StringFilterNullableSchema,
-    make: StringFilterNullableSchema,
-    model: StringFilterNullableSchema,
-    lensModel: StringFilterNullableSchema,
-    description: StringPatternFilterSchema,
-    originalFileName: StringPatternFilterSchema,
-    originalPath: StringPatternFilterSchema,
-    ocr: StringSimilarityFilterSchema,
-    rating: NumberFilterNullableSchema,
-    fileSizeInBytes: NumberFilterSchema,
-    takenAt: DateFilterSchema,
-    createdAt: DateFilterSchema,
-    updatedAt: DateFilterSchema,
-    trashedAt: DateFilterNullableSchema,
-    personIds: IdsFilterSchema,
-    tagIds: IdsFilterSchema,
-    albumIds: IdsFilterSchema,
-    checksum: StringFilterSchema,
-    encodedVideoPath: StringFilterSchema,
-  })
-  .partial()
-  .meta({ id: 'SearchFilterBranch' });
-
-export const SearchFilterSchema = SearchFilterBranchSchema.extend({
-  or: z.array(SearchFilterBranchSchema).min(1).optional(),
-}).meta({ id: 'SearchFilter' });
-
-export type IdFilter = z.infer<typeof IdFilterSchema>;
-export type IdFilterNullable = z.infer<typeof IdFilterNullableSchema>;
-export type IdsFilter = z.infer<typeof IdsFilterSchema>;
-export type StringFilter = z.infer<typeof StringFilterSchema>;
-export type StringFilterNullable = z.infer<typeof StringFilterNullableSchema>;
-export type StringPatternFilter = z.infer<typeof StringPatternFilterSchema>;
-export type NumberFilter = z.infer<typeof NumberFilterSchema>;
-export type NumberFilterNullable = z.infer<typeof NumberFilterNullableSchema>;
-export type DateFilter = z.infer<typeof DateFilterSchema>;
-export type DateFilterNullable = z.infer<typeof DateFilterNullableSchema>;
-export type SearchOrder = z.infer<typeof SearchOrderSchema>;
-export type SearchFilter = z.infer<typeof SearchFilterSchema>;
-export type SearchFilterBranch = z.infer<typeof SearchFilterBranchSchema>;
-
 export class RandomSearchDto extends createZodDto(RandomSearchSchema) {}
 export class LargeAssetSearchDto extends createZodDto(LargeAssetSearchSchema) {}
 export class MetadataSearchDto extends createZodDto(MetadataSearchSchema) {}

server/src/enum.ts

@@ -1234,12 +1234,3 @@ export enum CalendarHeatmapType {
   Upload = 'Upload',
   Taken = 'Taken',
 }
-
-export enum SearchOrderField {
-  FileCreatedAt = 'fileCreatedAt',
-  LocalDateTime = 'localDateTime',
-  FileSizeInBytes = 'fileSizeInBytes',
-  Rating = 'rating',
-}
-
-export const SearchOrderFieldSchema = z.enum(SearchOrderField).meta({ id: 'SearchOrderField' });

server/src/repositories/search.repository.ts

@@ -1,23 +1,12 @@
 import { Injectable } from '@nestjs/common';
 import { Kysely, OrderByDirection, Selectable, ShallowDehydrateObject, sql } from 'kysely';
 import { InjectKysely } from 'nestjs-kysely';
-import { columns } from 'src/database';
 import { DummyValue, GenerateSql } from 'src/decorators';
-import { MapAsset } from 'src/dtos/asset-response.dto';
-import { SearchFilter, SearchOrder } from 'src/dtos/search.dto';
 import { AssetStatus, AssetType, AssetVisibility, VectorIndex } from 'src/enum';
 import { probes } from 'src/repositories/database.repository';
 import { DB } from 'src/schema';
 import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
-import {
-  anyUuid,
-  searchAssetBuilder,
-  searchAssetBuilderLegacy,
-  searchMetadataV3Examples,
-  searchStatisticsV3Examples,
-  withExifInner,
-  withSearchOrder,
-} from 'src/utils/database';
+import { anyUuid, searchAssetBuilder, withExifInner } from 'src/utils/database';
 import { paginationHelper } from 'src/utils/pagination';
 import z from 'zod';
 
@@ -133,21 +122,6 @@ export type AssetSearchOptions = Omit<BaseAssetSearchOptions, 'visibility'> &
 
 export type AssetSearchBuilderOptions = Omit<AssetSearchOptions, 'orderDirection'>;
 
-export interface AssetSearchBuilderV3Options {
-  filter?: SearchFilter;
-  /** Server-derived ownership scope. Never client-controlled. */
-  userIds?: string[];
-  withExif?: boolean;
-  withFaces?: boolean;
-  withPeople?: boolean;
-  withStacked?: boolean;
-  order?: SearchOrder;
-}
-
-export interface AssetSearchPaginationV3Options {
-  size: number;
-}
-
 export type SmartSearchOptions = SearchDateOptions &
   SearchEmbeddingOptions &
   SearchExifOptions &
@@ -222,10 +196,9 @@ export class SearchRepository {
   })
   async searchMetadata(pagination: SearchPaginationOptions, options: AssetSearchOptions) {
     const orderDirection = (options.orderDirection?.toLowerCase() || 'desc') as OrderByDirection;
-    const items = await searchAssetBuilderLegacy(this.db, options)
-      .select(columns.searchAsset)
+    const items = await searchAssetBuilder(this.db, options)
+      .selectAll('asset')
       .orderBy('asset.fileCreatedAt', orderDirection)
-      .orderBy('asset.id', orderDirection)
       .limit(pagination.size + 1)
       .offset((pagination.page - 1) * pagination.size)
       .execute();
@@ -244,7 +217,7 @@ export class SearchRepository {
     ],
   })
   searchStatistics(options: AssetSearchOptions) {
-    return searchAssetBuilderLegacy(this.db, options)
+    return searchAssetBuilder(this.db, options)
       .select((qb) => qb.fn.countAll<number>().as('total'))
       .executeTakeFirstOrThrow();
   }
@@ -262,8 +235,8 @@ export class SearchRepository {
     ],
   })
   async searchRandom(size: number, options: AssetSearchOptions) {
-    return searchAssetBuilderLegacy(this.db, options)
-      .select(columns.searchAsset)
+    return searchAssetBuilder(this.db, options)
+      .selectAll('asset')
       .orderBy(sql`random()`)
       .limit(size)
       .execute();
@@ -283,8 +256,8 @@ export class SearchRepository {
   })
   searchLargeAssets(size: number, options: LargeAssetSearchOptions) {
     const orderDirection = (options.orderDirection?.toLowerCase() || 'desc') as OrderByDirection;
-    return searchAssetBuilderLegacy(this.db, options)
-      .select(columns.searchAsset)
+    return searchAssetBuilder(this.db, options)
+      .selectAll('asset')
       .$call(withExifInner)
       .where('asset_exif.fileSizeInByte', '>', options.minFileSize || 0)
       .orderBy('asset_exif.fileSizeInByte', orderDirection)
@@ -312,11 +285,10 @@ export class SearchRepository {
 
     return this.db.transaction().execute(async (trx) => {
       await sql`set local vchordrq.probes = ${sql.lit(probes[VectorIndex.Clip])}`.execute(trx);
-      const items = await searchAssetBuilderLegacy(trx, options)
-        .select(columns.searchAsset)
+      const items = await searchAssetBuilder(trx, options)
+        .selectAll('asset')
         .innerJoin('smart_search', 'asset.id', 'smart_search.assetId')
         .orderBy(sql`smart_search.embedding <=> ${options.embedding}`)
-        .orderBy('asset.id', 'asc')
         .limit(pagination.size + 1)
         .offset((pagination.page - 1) * pagination.size)
         .execute();
@@ -445,7 +417,7 @@ export class SearchRepository {
       .selectFrom('asset')
       .innerJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
       .innerJoin('cte', 'asset.id', 'cte.assetId')
-      .select(columns.searchAsset)
+      .selectAll('asset')
       .select((eb) =>
         eb
           .fn('to_jsonb', [eb.table('asset_exif')])
@@ -518,24 +490,6 @@ export class SearchRepository {
     return res.map((row) => row.lensModel!);
   }
 
-  @GenerateSql(...searchMetadataV3Examples)
-  searchMetadataV3(
-    pagination: AssetSearchPaginationV3Options,
-    options: AssetSearchBuilderV3Options,
-  ): Promise<MapAsset[]> {
-    return withSearchOrder(searchAssetBuilder(this.db, options), options.order)
-      .select(columns.searchAsset)
-      .limit(pagination.size)
-      .execute();
-  }
-
-  @GenerateSql(...searchStatisticsV3Examples)
-  searchStatisticsV3(options: AssetSearchBuilderV3Options) {
-    return searchAssetBuilder(this.db, options)
-      .select((qb) => qb.fn.countAll<number>().as('total'))
-      .executeTakeFirstOrThrow();
-  }
-
   private getExifField(field: 'city' | 'state' | 'country' | 'make' | 'model' | 'lensModel', userIds: string[]) {
     return this.db
       .selectFrom('asset_exif')

server/src/utils/database.ts

@@ -7,42 +7,21 @@ import {
   Kysely,
   KyselyConfig,
   NotNull,
-  OperandValueExpression,
-  ReferenceExpression,
   Selectable,
   SelectQueryBuilder,
   ShallowDehydrateObject,
   sql,
-  SqlBool,
 } from 'kysely';
 import { PostgresJSDialect } from 'kysely-postgres-js';
 import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres';
 import { Notice, PostgresError } from 'postgres';
 import { columns, lockableProperties, LockableProperty, Person } from 'src/database';
-import { DummyValue, GenerateSqlQueries } from 'src/decorators';
 import { AssetEditActionItem } from 'src/dtos/editing.dto';
-import {
-  DEFAULT_SEARCH_ORDER,
-  IdsFilter,
-  SearchFilterBranch,
-  SearchOrder,
-  StringFilter,
-  StringPatternFilter,
-} from 'src/dtos/search.dto';
-import {
-  AssetFileType,
-  AssetOrder,
-  AssetOrderBy,
-  AssetVisibility,
-  DatabaseExtension,
-  ExifOrientation,
-  SearchOrderField,
-} from 'src/enum';
-import { AssetSearchBuilderOptions, AssetSearchBuilderV3Options } from 'src/repositories/search.repository';
+import { AssetFileType, AssetOrderBy, AssetVisibility, DatabaseExtension, ExifOrientation } from 'src/enum';
+import { AssetSearchBuilderOptions } from 'src/repositories/search.repository';
 import { DB } from 'src/schema';
 import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
 import { AudioStreamInfo, VectorExtension, VideoFormat, VideoPacketInfo, VideoStreamInfo } from 'src/types';
-import { fromChecksum } from 'src/utils/request';
 
 export const getKyselyConfig = (connection: DatabaseConnectionParams): KyselyConfig => {
   return {
@@ -75,8 +54,6 @@ export const getKyselyConfig = (connection: DatabaseConnectionParams): KyselyCon
   };
 };
 
-const uniqueIds = (ids: string[]) => [...new Set(ids)];
-
 export const asUuid = (id: string | Expression<string>) => sql<string>`${id}::uuid`;
 
 export const anyUuid = (ids: string[]) => sql<string>`any(${`{${ids}}`}::uuid[])`;
@@ -108,15 +85,16 @@ export function withDefaultVisibility<O>(qb: SelectQueryBuilder<DB, 'asset', O>)
   return qb.where('asset.visibility', 'in', [sql.lit(AssetVisibility.Archive), sql.lit(AssetVisibility.Timeline)]);
 }
 
-const selectExifInfo = (eb: AssetExpressionBuilder) =>
-  eb.fn
-    .toJson(eb.table('asset_exif'))
-    .$castTo<ShallowDehydrateObject<Selectable<AssetExifTable>> | null>()
-    .as('exifInfo');
-
 // TODO come up with a better query that only selects the fields we need
 export function withExif<O>(qb: SelectQueryBuilder<DB, 'asset', O>) {
-  return qb.leftJoin('asset_exif', 'asset.id', 'asset_exif.assetId').select(selectExifInfo);
+  return qb
+    .leftJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
+    .select((eb) =>
+      eb.fn
+        .toJson(eb.table('asset_exif'))
+        .$castTo<ShallowDehydrateObject<Selectable<AssetExifTable>> | null>()
+        .as('exifInfo'),
+    );
 }
 
 export function withExifInner<O>(qb: SelectQueryBuilder<DB, 'asset', O>) {
@@ -395,7 +373,7 @@ export function withEdits(eb: ExpressionBuilder<DB, 'asset'>): AliasedEditAction
 const joinDeduplicationPlugin = new DeduplicateJoinsPlugin();
 /** TODO: This should only be used for search-related queries, not as a general purpose query builder */
 
-export function searchAssetBuilderLegacy(kysely: Kysely<DB>, options: AssetSearchBuilderOptions) {
+export function searchAssetBuilder(kysely: Kysely<DB>, options: AssetSearchBuilderOptions) {
   options.withDeleted ||= !!(options.trashedAfter || options.trashedBefore || options.isOffline);
 
   return kysely
@@ -515,458 +493,6 @@ export function searchAssetBuilderLegacy(kysely: Kysely<DB>, options: AssetSearc
     .$if(!options.withDeleted, (qb) => qb.where('asset.deletedAt', 'is', null));
 }
 
-type AssetExpressionBuilder = ExpressionBuilder<DB, 'asset' | 'asset_exif'>;
-
-const albumAssets = (eb: AssetExpressionBuilder) =>
-  eb.selectFrom('album_asset').whereRef('album_asset.assetId', '=', 'asset.id');
-
-const visibleFaces = (eb: AssetExpressionBuilder) =>
-  eb
-    .selectFrom('asset_face')
-    .whereRef('asset_face.assetId', '=', 'asset.id')
-    .where('asset_face.deletedAt', 'is', null)
-    .where('asset_face.isVisible', '=', true);
-
-const tagAssets = (eb: AssetExpressionBuilder) =>
-  eb.selectFrom('tag_asset').whereRef('tag_asset.assetId', '=', 'asset.id');
-
-// shared any/all/none mechanics; `matchesAll` only receives deduplicated multi-id lists,
-// so its `count(distinct id) = ids.length` check stays satisfiable
-function idsPredicates(
-  eb: AssetExpressionBuilder,
-  { any, all, none }: IdsFilter = {},
-  ops: {
-    matchesAny: (ids: string[]) => Expression<SqlBool>;
-    matchesAll: (ids: string[]) => Expression<SqlBool>;
-  },
-) {
-  const predicates: Expression<SqlBool>[] = [];
-  if (any) {
-    predicates.push(ops.matchesAny(any));
-  }
-  if (all) {
-    const ids = uniqueIds(all);
-    predicates.push(ids.length === 1 ? ops.matchesAny(ids) : ops.matchesAll(ids));
-  }
-  if (none) {
-    predicates.push(eb.not(ops.matchesAny(none)));
-  }
-  return predicates;
-}
-
-function albumIdsPredicates(eb: AssetExpressionBuilder, filter?: IdsFilter) {
-  const matching = (ids: string[]) => albumAssets(eb).where('album_asset.albumId', '=', anyUuid(ids));
-  return idsPredicates(eb, filter, {
-    matchesAny: (ids) => eb.exists(matching(ids)),
-    matchesAll: (ids) =>
-      eb.exists(
-        matching(ids)
-          .select('album_asset.assetId')
-          .groupBy('album_asset.assetId')
-          .having((eb) => eb.fn.count('album_asset.albumId').distinct(), '=', ids.length),
-      ),
-  });
-}
-
-function personIdsPredicates(eb: AssetExpressionBuilder, filter?: IdsFilter) {
-  const matching = (ids: string[]) => visibleFaces(eb).where('asset_face.personId', '=', anyUuid(ids));
-  return idsPredicates(eb, filter, {
-    matchesAny: (ids) => eb.exists(matching(ids)),
-    matchesAll: (ids) =>
-      eb.exists(
-        matching(ids)
-          .select('asset_face.assetId')
-          .groupBy('asset_face.assetId')
-          .having((eb) => eb.fn.count('asset_face.personId').distinct(), '=', ids.length),
-      ),
-  });
-}
-
-function tagIdsPredicates(eb: AssetExpressionBuilder, filter?: IdsFilter) {
-  const matching = (ids: string[]) =>
-    tagAssets(eb)
-      .innerJoin('tag_closure', 'tag_asset.tagId', 'tag_closure.id_descendant')
-      .where('tag_closure.id_ancestor', '=', anyUuid(ids));
-  return idsPredicates(eb, filter, {
-    matchesAny: (ids) => eb.exists(matching(ids)),
-    matchesAll: (ids) =>
-      eb.exists(
-        matching(ids)
-          .select('tag_asset.assetId')
-          .groupBy('tag_asset.assetId')
-          .having((eb) => eb.fn.count('tag_closure.id_ancestor').distinct(), '=', ids.length),
-      ),
-  });
-}
-
-type ComparisonFilter<T> = {
-  eq?: T | null;
-  ne?: T | null;
-  lt?: T;
-  lte?: T;
-  gt?: T;
-  gte?: T;
-  in?: T[];
-  notIn?: T[];
-};
-
-// one operator dispatch for every filter shape; the DTO schemas constrain which
-// operators (and null literals) each filter can actually carry
-function comparisonPredicates<TB extends keyof DB, RE extends ReferenceExpression<DB, TB>>(
-  eb: ExpressionBuilder<DB, TB>,
-  column: RE,
-  filter: ComparisonFilter<OperandValueExpression<DB, TB, RE>> = {},
-) {
-  const predicates: Expression<SqlBool>[] = [];
-  if (filter.eq !== undefined) {
-    predicates.push(filter.eq === null ? eb(column, 'is', null) : eb(column, '=', filter.eq));
-  }
-  if (filter.ne !== undefined) {
-    predicates.push(filter.ne === null ? eb(column, 'is not', null) : eb(column, '!=', filter.ne));
-  }
-  if (filter.lt !== undefined) {
-    predicates.push(eb(column, '<', filter.lt));
-  }
-  if (filter.lte !== undefined) {
-    predicates.push(eb(column, '<=', filter.lte));
-  }
-  if (filter.gt !== undefined) {
-    predicates.push(eb(column, '>', filter.gt));
-  }
-  if (filter.gte !== undefined) {
-    predicates.push(eb(column, '>=', filter.gte));
-  }
-  if (filter.in !== undefined) {
-    predicates.push(eb(column, 'in', filter.in));
-  }
-  if (filter.notIn !== undefined) {
-    predicates.push(eb(column, 'not in', filter.notIn));
-  }
-  return predicates;
-}
-
-type StringColumn =
-  | 'asset_exif.city'
-  | 'asset_exif.state'
-  | 'asset_exif.country'
-  | 'asset_exif.make'
-  | 'asset_exif.model'
-  | 'asset_exif.lensModel'
-  | 'asset_exif.description'
-  | 'asset.originalFileName'
-  | 'asset.originalPath';
-
-function stringPatternPredicates(eb: AssetExpressionBuilder, column: StringColumn, filter: StringPatternFilter = {}) {
-  const ref = sql.ref(column);
-  const predicates = comparisonPredicates(eb, column, filter);
-  if (filter.like !== undefined) {
-    predicates.push(sql<SqlBool>`f_unaccent(${ref}) ilike ('%' || f_unaccent(${filter.like}) || '%')`);
-  }
-  if (filter.notLike !== undefined) {
-    predicates.push(sql<SqlBool>`f_unaccent(${ref}) not ilike ('%' || f_unaccent(${filter.notLike}) || '%')`);
-  }
-  if (filter.startsWith !== undefined) {
-    predicates.push(sql<SqlBool>`f_unaccent(${ref}) ilike (f_unaccent(${filter.startsWith}) || '%')`);
-  }
-  if (filter.endsWith !== undefined) {
-    predicates.push(sql<SqlBool>`f_unaccent(${ref}) ilike ('%' || f_unaccent(${filter.endsWith}))`);
-  }
-  return predicates;
-}
-
-function checksumPredicates(eb: AssetExpressionBuilder, filter: StringFilter = {}) {
-  return comparisonPredicates(eb, 'asset.checksum', {
-    eq: filter.eq === undefined ? undefined : fromChecksum(filter.eq),
-    ne: filter.ne === undefined ? undefined : fromChecksum(filter.ne),
-    in: filter.in?.map((checksum) => fromChecksum(checksum)),
-    notIn: filter.notIn?.map((checksum) => fromChecksum(checksum)),
-  });
-}
-
-const encodedVideoFiles = (eb: AssetExpressionBuilder) =>
-  eb
-    .selectFrom('asset_file')
-    .whereRef('asset_file.assetId', '=', 'asset.id')
-    .where('asset_file.type', '=', AssetFileType.EncodedVideo);
-
-function existsPredicates(
-  eb: AssetExpressionBuilder,
-  filter: { eq: boolean } | undefined,
-  subquery: () => Expression<unknown>,
-): Expression<SqlBool>[] {
-  if (!filter) {
-    return [];
-  }
-  const exists = eb.exists(subquery());
-  return [filter.eq ? exists : eb.not(exists)];
-}
-
-// predicates are collected as expressions rather than chained `where` calls so the same
-// helpers can build each `or` branch, which must compose into eb.and/eb.or
-function branchPredicates(eb: AssetExpressionBuilder, branch: SearchFilterBranch) {
-  const { encodedVideoPath } = branch;
-  return [
-    ...comparisonPredicates(eb, 'asset.id', branch.id),
-    ...comparisonPredicates(eb, 'asset.libraryId', branch.libraryId),
-    ...comparisonPredicates(eb, 'asset.type', branch.type),
-    ...comparisonPredicates(eb, 'asset.visibility', branch.visibility),
-    ...(branch.isFavorite ? [eb('asset.isFavorite', '=', branch.isFavorite.eq)] : []),
-    ...(branch.isOffline ? [eb('asset.isOffline', '=', branch.isOffline.eq)] : []),
-    ...(branch.isMotion ? [eb('asset.livePhotoVideoId', branch.isMotion.eq ? 'is not' : 'is', null)] : []),
-    ...existsPredicates(eb, branch.isEncoded, () => encodedVideoFiles(eb)),
-    ...existsPredicates(eb, branch.hasAlbums, () => albumAssets(eb)),
-    ...existsPredicates(eb, branch.hasPeople, () => visibleFaces(eb)),
-    ...existsPredicates(eb, branch.hasTags, () => tagAssets(eb)),
-    ...comparisonPredicates(eb, 'asset_exif.city', branch.city),
-    ...comparisonPredicates(eb, 'asset_exif.state', branch.state),
-    ...comparisonPredicates(eb, 'asset_exif.country', branch.country),
-    ...comparisonPredicates(eb, 'asset_exif.make', branch.make),
-    ...comparisonPredicates(eb, 'asset_exif.model', branch.model),
-    ...comparisonPredicates(eb, 'asset_exif.lensModel', branch.lensModel),
-    ...stringPatternPredicates(eb, 'asset_exif.description', branch.description),
-    ...stringPatternPredicates(eb, 'asset.originalFileName', branch.originalFileName),
-    ...stringPatternPredicates(eb, 'asset.originalPath', branch.originalPath),
-    ...(branch.ocr
-      ? [
-          eb.exists(
-            eb
-              .selectFrom('ocr_search')
-              .whereRef('ocr_search.assetId', '=', 'asset.id')
-              .where(
-                sql<SqlBool>`f_unaccent(ocr_search.text) %>> f_unaccent(${tokenizeForSearch(branch.ocr.matches).join(' ')})`,
-              ),
-          ),
-        ]
-      : []),
-    ...comparisonPredicates(eb, 'asset_exif.rating', branch.rating),
-    ...comparisonPredicates(eb, 'asset_exif.fileSizeInByte', branch.fileSizeInBytes),
-    ...comparisonPredicates(eb, 'asset.fileCreatedAt', branch.takenAt),
-    ...comparisonPredicates(eb, 'asset.createdAt', branch.createdAt),
-    ...comparisonPredicates(eb, 'asset.updatedAt', branch.updatedAt),
-    ...comparisonPredicates(eb, 'asset.deletedAt', branch.trashedAt),
-    ...albumIdsPredicates(eb, branch.albumIds),
-    ...personIdsPredicates(eb, branch.personIds),
-    ...tagIdsPredicates(eb, branch.tagIds),
-    ...checksumPredicates(eb, branch.checksum),
-    ...(encodedVideoPath
-      ? [
-          eb.exists(
-            encodedVideoFiles(eb)
-              .where('asset_file.isEdited', '=', false)
-              .where((eb) => eb.and(comparisonPredicates(eb, 'asset_file.path', encodedVideoPath))),
-          ),
-        ]
-      : []),
-  ];
-}
-
-// ordering is deliberately left to the caller so aggregate-only consumers (counts, stats)
-// can compose the same filters without stripping an order by
-export function searchAssetBuilder(kysely: Kysely<DB>, options: AssetSearchBuilderV3Options) {
-  const filter = options.filter ?? {};
-
-  return (
-    kysely
-      .withPlugin(joinDeduplicationPlugin)
-      .selectFrom('asset')
-      // postgres eliminates the left join when no exif column is referenced, so unused joins are free
-      .leftJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
-      .$if(!!options.withExif, (qb) => qb.select(selectExifInfo))
-      .$if(!!options.userIds && options.userIds.length > 0, (qb) =>
-        qb.where('asset.ownerId', '=', anyUuid(options.userIds!)),
-      )
-      .$if(!!(options.withFaces || options.withPeople), (qb) => qb.select(withFacesAndPeople))
-      .$if(options.withStacked === false, (qb) => qb.where('asset.stackId', 'is', null))
-      .where((eb) => {
-        const predicates = branchPredicates(eb, filter);
-        if (filter.or && filter.or.length > 0) {
-          predicates.push(eb.or(filter.or.map((branch) => eb.and(branchPredicates(eb, branch)))));
-        }
-        return predicates.length > 0 ? eb.and(predicates) : eb.lit(true);
-      })
-  );
-}
-
-const searchOrderColumns = {
-  [SearchOrderField.FileCreatedAt]: { column: 'asset.fileCreatedAt', nullable: false },
-  [SearchOrderField.LocalDateTime]: { column: 'asset.localDateTime', nullable: false },
-  [SearchOrderField.FileSizeInBytes]: { column: 'asset_exif.fileSizeInByte', nullable: true },
-  [SearchOrderField.Rating]: { column: 'asset_exif.rating', nullable: true },
-} as const;
-
-export function withSearchOrder(qb: ReturnType<typeof searchAssetBuilder>, order?: SearchOrder) {
-  const { field, direction } = order ?? DEFAULT_SEARCH_ORDER;
-  const { column, nullable } = searchOrderColumns[field];
-  return (
-    qb
-      .orderBy(column, (ob) => {
-        const ordered = direction === AssetOrder.Asc ? ob.asc() : ob.desc();
-        // nulls last: assets without an asset_exif row would otherwise lead descending results
-        return nullable ? ordered.nullsLast() : ordered;
-      })
-      // id tie-break for deterministic pagination
-      .orderBy('asset.id', direction)
-  );
-}
-
-export const searchMetadataV3Examples: GenerateSqlQueries[] = [
-  { name: 'baseline', params: [{ size: 100 }, { userIds: [DummyValue.UUID] }] },
-  { name: 'empty', params: [{ size: 100 }, {}] },
-  {
-    name: 'or-exif-only',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { or: [{ city: { eq: DummyValue.STRING } }] } }],
-  },
-  {
-    name: 'string-eq-null',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { city: { eq: null } } }],
-  },
-  {
-    name: 'string-pattern-like',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { description: { like: DummyValue.STRING } } }],
-  },
-  {
-    name: 'string-pattern-notLike',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { description: { notLike: DummyValue.STRING } } }],
-  },
-  {
-    name: 'string-pattern-startsWith',
-    params: [
-      { size: 100 },
-      { userIds: [DummyValue.UUID], filter: { originalFileName: { startsWith: DummyValue.STRING } } },
-    ],
-  },
-  {
-    name: 'string-similarity-ocr',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { ocr: { matches: DummyValue.STRING } } }],
-  },
-  {
-    name: 'ids-any',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { albumIds: { any: [DummyValue.UUID] } } }],
-  },
-  {
-    name: 'ids-all',
-    params: [
-      { size: 100 },
-      { userIds: [DummyValue.UUID], filter: { personIds: { all: [DummyValue.UUID, DummyValue.UUID_1] } } },
-    ],
-  },
-  {
-    name: 'ids-all-single',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { albumIds: { all: [DummyValue.UUID] } } }],
-  },
-  {
-    name: 'ids-none',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { tagIds: { none: [DummyValue.UUID] } } }],
-  },
-  {
-    name: 'ids-tags-all',
-    params: [
-      { size: 100 },
-      { userIds: [DummyValue.UUID], filter: { tagIds: { all: [DummyValue.UUID, DummyValue.UUID_1] } } },
-    ],
-  },
-  {
-    name: 'has-albums-false',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { hasAlbums: { eq: false } } }],
-  },
-  {
-    name: 'is-encoded',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { isEncoded: { eq: true } } }],
-  },
-  {
-    name: 'number-range',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { fileSizeInBytes: { gte: 100, lte: 1000 } } }],
-  },
-  {
-    name: 'date-eq',
-    params: [{ size: 100 }, { userIds: [DummyValue.UUID], filter: { takenAt: { eq: DummyValue.DATE } } }],
-  },
-  {
-    name: 'date-range',
-    params: [
-      { size: 100 },
-      {
-        userIds: [DummyValue.UUID],
-        filter: { takenAt: { gte: DummyValue.DATE, lt: DummyValue.DATE } },
-      },
-    ],
-  },
-  {
-    name: 'order-fileSize-noExif',
-    params: [
-      { size: 100 },
-      {
-        userIds: [DummyValue.UUID],
-        order: { field: SearchOrderField.FileSizeInBytes, direction: AssetOrder.Desc },
-        withExif: false,
-      },
-    ],
-  },
-  {
-    name: 'order-rating-withExif',
-    params: [
-      { size: 100 },
-      {
-        userIds: [DummyValue.UUID],
-        order: { field: SearchOrderField.Rating, direction: AssetOrder.Asc },
-        withExif: true,
-      },
-    ],
-  },
-  {
-    name: 'or-branches',
-    params: [
-      { size: 100 },
-      {
-        userIds: [DummyValue.UUID],
-        filter: {
-          or: [{ isFavorite: { eq: true } }, { personIds: { any: [DummyValue.UUID] } }],
-        },
-      },
-    ],
-  },
-  {
-    name: 'or-with-top-level',
-    params: [
-      { size: 100 },
-      {
-        userIds: [DummyValue.UUID],
-        filter: {
-          takenAt: { gte: DummyValue.DATE, lt: DummyValue.DATE },
-          or: [{ isFavorite: { eq: true } }, { albumIds: { any: [DummyValue.UUID] } }],
-        },
-      },
-    ],
-  },
-];
-
-export const searchStatisticsV3Examples: GenerateSqlQueries[] = [
-  { name: 'baseline', params: [{ userIds: [DummyValue.UUID] }] },
-  {
-    name: 'with-filter',
-    params: [
-      {
-        userIds: [DummyValue.UUID],
-        filter: {
-          takenAt: { gte: DummyValue.DATE, lt: DummyValue.DATE },
-          fileSizeInBytes: { gte: 100 },
-        },
-      },
-    ],
-  },
-  {
-    name: 'with-or',
-    params: [
-      {
-        userIds: [DummyValue.UUID],
-        filter: {
-          or: [{ isFavorite: { eq: true } }, { hasAlbums: { eq: false } }],
-        },
-      },
-    ],
-  },
-];
-
 export type ReindexVectorIndexOptions = { indexName: string; lists?: number };
 
 type VectorIndexQueryOptions = { table: string; vectorExtension: VectorExtension } & ReindexVectorIndexOptions;

server/src/validation.ts

@@ -42,7 +42,7 @@ export function nonEmptyPartial<T extends z.ZodRawShape>(shape: T) {
     .object(shape)
     .partial()
     .refine((data) => Object.values(data as Record<string, unknown>).some((value) => value !== undefined), {
-      message: `At least one of the following fields is required: ${Object.keys(shape).join(', ')}`,
+      message: 'At least one field must be provided',
     });
 }
 

web/src/lib/components/asset-viewer/actions/NextAssetAction.svelte

@@ -1,10 +1,9 @@
 <script lang="ts">
   import { shortcuts } from '$lib/actions/shortcut';
   import { Icon } from '@immich/ui';
-  import { mdiChevronRight, mdiChevronLeft } from '@mdi/js';
+  import { mdiChevronRight } from '@mdi/js';
   import { t } from 'svelte-i18n';
   import NavigationArea from '../NavigationArea.svelte';
-  import { languageManager } from '$lib/managers/language-manager.svelte';
 
   interface Props {
     onNextAsset: () => void;
@@ -21,5 +20,5 @@
 />
 
 <NavigationArea onClick={onNextAsset} label={$t('view_next_asset')}>
-  <Icon icon={languageManager.rtl ? mdiChevronLeft : mdiChevronRight} size="36" aria-hidden />
+  <Icon icon={mdiChevronRight} size="36" aria-hidden />
 </NavigationArea>

web/src/lib/components/asset-viewer/actions/PreviousAssetAction.svelte

@@ -1,10 +1,9 @@
 <script lang="ts">
   import { shortcuts } from '$lib/actions/shortcut';
   import { Icon } from '@immich/ui';
-  import { mdiChevronLeft, mdiChevronRight } from '@mdi/js';
+  import { mdiChevronLeft } from '@mdi/js';
   import { t } from 'svelte-i18n';
   import NavigationArea from '../NavigationArea.svelte';
-  import { languageManager } from '$lib/managers/language-manager.svelte';
 
   interface Props {
     onPreviousAsset: () => void;
@@ -21,5 +20,5 @@
 />
 
 <NavigationArea onClick={onPreviousAsset} label={$t('view_previous_asset')}>
-  <Icon icon={languageManager.rtl ? mdiChevronRight : mdiChevronLeft} size="36" aria-hidden />
+  <Icon icon={mdiChevronLeft} size="36" aria-hidden />
 </NavigationArea>

web/src/routes/(user)/people/[personId]/[[photos=photos]]/[[assetId=id]]/+page.svelte

@@ -95,8 +95,6 @@
     const getPreviousRoute = $page.url.searchParams.get(QueryParameter.PREVIOUS_ROUTE);
     if (getPreviousRoute && !isExternalUrl(getPreviousRoute)) {
       previousRoute = getPreviousRoute;
-    } else if ($page.params.assetId) {
-      previousRoute = Route.viewPerson(data.person);
     }
     if (action == 'merge') {
       viewMode = PersonPageViewMode.MERGE_PEOPLE;