chore: e2e test

e2e/package.json

@@ -50,7 +50,6 @@
     "prettier-plugin-organize-imports": "^4.0.0",
     "sharp": "^0.34.5",
     "socket.io-client": "^4.7.4",
-    "structured-headers": "^2.0.2",
     "supertest": "^7.0.0",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.28.0",

e2e/src/specs/server/api/album.e2e-spec.ts

@@ -424,6 +424,7 @@ describe('/albums', () => {
         description: '',
         albumThumbnailAssetId: null,
         shared: false,
+        isFavorite: false,
         albumUsers: [],
         hasSharedLink: false,
         assets: [],
@@ -540,6 +541,44 @@ describe('/albums', () => {
     });
   });
 
+  describe('PATCH /albums/:id/user-metadata', () => {
+    it('should toggle favorite status per user on a shared album', async () => {
+      const before = await getAlbumInfo({ id: user1Albums[3].id }, { headers: asBearerAuth(user2.accessToken) });
+      expect(before.isFavorite).toBe(false);
+
+      const favoriteResponse = await request(app)
+        .patch(`/albums/${user1Albums[3].id}/user-metadata`)
+        .set('Authorization', `Bearer ${user2.accessToken}`)
+        .send({ isFavorite: true });
+
+      expect(favoriteResponse.status).toBe(200);
+      expect(favoriteResponse.body).toMatchObject({ id: user1Albums[3].id, isFavorite: true });
+
+      const favoritedForViewer = await getAlbumInfo(
+        { id: user1Albums[3].id },
+        { headers: asBearerAuth(user2.accessToken) },
+      );
+      const unchangedForOwner = await getAlbumInfo(
+        { id: user1Albums[3].id },
+        { headers: asBearerAuth(user1.accessToken) },
+      );
+
+      expect(favoritedForViewer.isFavorite).toBe(true);
+      expect(unchangedForOwner.isFavorite).toBe(false);
+
+      const unfavoriteResponse = await request(app)
+        .patch(`/albums/${user1Albums[3].id}/user-metadata`)
+        .set('Authorization', `Bearer ${user2.accessToken}`)
+        .send({ isFavorite: false });
+
+      expect(unfavoriteResponse.status).toBe(200);
+      expect(unfavoriteResponse.body).toMatchObject({ id: user1Albums[3].id, isFavorite: false });
+
+      const after = await getAlbumInfo({ id: user1Albums[3].id }, { headers: asBearerAuth(user2.accessToken) });
+      expect(after.isFavorite).toBe(false);
+    });
+  });
+
   describe('DELETE /albums/:id/assets', () => {
     it('should require authorization', async () => {
       const { status, body } = await request(app)

e2e/src/ui/generators/timeline/rest-response.ts

@@ -427,6 +427,7 @@ export function getAlbum(
     albumUsers: [], // Empty array for non-shared album
     shared: false,
     hasSharedLink: false,
+    isFavorite: false,
     isActivityEnabled: true,
     assetCount: albumAssets.length,
     assets: albumAssets,

e2e/src/utils.ts

@@ -700,16 +700,6 @@ export const utils = {
       }
     }
   },
-
-  downloadAsset: async (accessToken: string, id: string) => {
-    const downloadedRes = await fetch(`${baseUrl}/api/assets/${id}/original`, {
-      headers: asBearerAuth(accessToken),
-    });
-    if (!downloadedRes.ok) {
-      throw new Error(`Failed to download asset ${id}: ${downloadedRes.status} ${await downloadedRes.text()}`);
-    }
-    return await downloadedRes.blob();
-  },
 };
 
 utils.initSdk();

mobile/openapi/README.md

@@ -95,6 +95,7 @@ Class | Method | HTTP request | Description
 *AlbumsApi* | [**removeUserFromAlbum**](doc//AlbumsApi.md#removeuserfromalbum) | **DELETE** /albums/{id}/user/{userId} | Remove user from album
 *AlbumsApi* | [**updateAlbumInfo**](doc//AlbumsApi.md#updatealbuminfo) | **PATCH** /albums/{id} | Update an album
 *AlbumsApi* | [**updateAlbumUser**](doc//AlbumsApi.md#updatealbumuser) | **PUT** /albums/{id}/user/{userId} | Update user role
+*AlbumsApi* | [**updateAlbumUserMetadata**](doc//AlbumsApi.md#updatealbumusermetadata) | **PATCH** /albums/{id}/user-metadata | Update album user metadata
 *AssetsApi* | [**checkBulkUpload**](doc//AssetsApi.md#checkbulkupload) | **POST** /assets/bulk-upload-check | Check bulk upload
 *AssetsApi* | [**checkExistingAssets**](doc//AssetsApi.md#checkexistingassets) | **POST** /assets/exist | Check existing assets
 *AssetsApi* | [**copyAsset**](doc//AssetsApi.md#copyasset) | **PUT** /assets/copy | Copy asset
@@ -294,11 +295,6 @@ Class | Method | HTTP request | Description
 *TrashApi* | [**emptyTrash**](doc//TrashApi.md#emptytrash) | **POST** /trash/empty | Empty trash
 *TrashApi* | [**restoreAssets**](doc//TrashApi.md#restoreassets) | **POST** /trash/restore/assets | Restore assets
 *TrashApi* | [**restoreTrash**](doc//TrashApi.md#restoretrash) | **POST** /trash/restore | Restore trash
-*UploadApi* | [**cancelUpload**](doc//UploadApi.md#cancelupload) | **DELETE** /upload/{id} | 
-*UploadApi* | [**getUploadOptions**](doc//UploadApi.md#getuploadoptions) | **OPTIONS** /upload | 
-*UploadApi* | [**getUploadStatus**](doc//UploadApi.md#getuploadstatus) | **HEAD** /upload/{id} | 
-*UploadApi* | [**resumeUpload**](doc//UploadApi.md#resumeupload) | **PATCH** /upload/{id} | 
-*UploadApi* | [**startUpload**](doc//UploadApi.md#startupload) | **POST** /upload | 
 *UsersApi* | [**createProfileImage**](doc//UsersApi.md#createprofileimage) | **POST** /users/profile-image | Create user profile image
 *UsersApi* | [**deleteProfileImage**](doc//UsersApi.md#deleteprofileimage) | **DELETE** /users/profile-image | Delete user profile image
 *UsersApi* | [**deleteUserLicense**](doc//UsersApi.md#deleteuserlicense) | **DELETE** /users/me/license | Delete user product key
@@ -581,6 +577,8 @@ Class | Method | HTTP request | Description
  - [SyncAlbumToAssetDeleteV1](doc//SyncAlbumToAssetDeleteV1.md)
  - [SyncAlbumToAssetV1](doc//SyncAlbumToAssetV1.md)
  - [SyncAlbumUserDeleteV1](doc//SyncAlbumUserDeleteV1.md)
+ - [SyncAlbumUserMetadataDeleteV1](doc//SyncAlbumUserMetadataDeleteV1.md)
+ - [SyncAlbumUserMetadataV1](doc//SyncAlbumUserMetadataV1.md)
  - [SyncAlbumUserV1](doc//SyncAlbumUserV1.md)
  - [SyncAlbumV1](doc//SyncAlbumV1.md)
  - [SyncAssetDeleteV1](doc//SyncAssetDeleteV1.md)
@@ -661,10 +659,9 @@ Class | Method | HTTP request | Description
  - [TrashResponseDto](doc//TrashResponseDto.md)
  - [UpdateAlbumDto](doc//UpdateAlbumDto.md)
  - [UpdateAlbumUserDto](doc//UpdateAlbumUserDto.md)
+ - [UpdateAlbumUserMetadataDto](doc//UpdateAlbumUserMetadataDto.md)
  - [UpdateAssetDto](doc//UpdateAssetDto.md)
  - [UpdateLibraryDto](doc//UpdateLibraryDto.md)
- - [UploadBackupConfig](doc//UploadBackupConfig.md)
- - [UploadOkDto](doc//UploadOkDto.md)
  - [UsageByUserDto](doc//UsageByUserDto.md)
  - [UserAdminCreateDto](doc//UserAdminCreateDto.md)
  - [UserAdminDeleteDto](doc//UserAdminDeleteDto.md)

mobile/openapi/lib/api.dart

@@ -63,7 +63,6 @@ part 'api/system_metadata_api.dart';
 part 'api/tags_api.dart';
 part 'api/timeline_api.dart';
 part 'api/trash_api.dart';
-part 'api/upload_api.dart';
 part 'api/users_api.dart';
 part 'api/users_admin_api.dart';
 part 'api/views_api.dart';
@@ -315,6 +314,8 @@ part 'model/sync_album_delete_v1.dart';
 part 'model/sync_album_to_asset_delete_v1.dart';
 part 'model/sync_album_to_asset_v1.dart';
 part 'model/sync_album_user_delete_v1.dart';
+part 'model/sync_album_user_metadata_delete_v1.dart';
+part 'model/sync_album_user_metadata_v1.dart';
 part 'model/sync_album_user_v1.dart';
 part 'model/sync_album_v1.dart';
 part 'model/sync_asset_delete_v1.dart';
@@ -395,10 +396,9 @@ part 'model/transcode_policy.dart';
 part 'model/trash_response_dto.dart';
 part 'model/update_album_dto.dart';
 part 'model/update_album_user_dto.dart';
+part 'model/update_album_user_metadata_dto.dart';
 part 'model/update_asset_dto.dart';
 part 'model/update_library_dto.dart';
-part 'model/upload_backup_config.dart';
-part 'model/upload_ok_dto.dart';
 part 'model/usage_by_user_dto.dart';
 part 'model/user_admin_create_dto.dart';
 part 'model/user_admin_delete_dto.dart';

mobile/openapi/lib/api/albums_api.dart

@@ -771,4 +771,65 @@ class AlbumsApi {
       throw ApiException(response.statusCode, await _decodeBodyBytes(response));
     }
   }
+
+  /// Update album user metadata
+  ///
+  /// Update metadata for the authenticated user on a specific album.
+  ///
+  /// Note: This method returns the HTTP [Response].
+  ///
+  /// Parameters:
+  ///
+  /// * [String] id (required):
+  ///
+  /// * [UpdateAlbumUserMetadataDto] updateAlbumUserMetadataDto (required):
+  Future<Response> updateAlbumUserMetadataWithHttpInfo(String id, UpdateAlbumUserMetadataDto updateAlbumUserMetadataDto,) async {
+    // ignore: prefer_const_declarations
+    final apiPath = r'/albums/{id}/user-metadata'
+      .replaceAll('{id}', id);
+
+    // ignore: prefer_final_locals
+    Object? postBody = updateAlbumUserMetadataDto;
+
+    final queryParams = <QueryParam>[];
+    final headerParams = <String, String>{};
+    final formParams = <String, String>{};
+
+    const contentTypes = <String>['application/json'];
+
+
+    return apiClient.invokeAPI(
+      apiPath,
+      'PATCH',
+      queryParams,
+      postBody,
+      headerParams,
+      formParams,
+      contentTypes.isEmpty ? null : contentTypes.first,
+    );
+  }
+
+  /// Update album user metadata
+  ///
+  /// Update metadata for the authenticated user on a specific album.
+  ///
+  /// Parameters:
+  ///
+  /// * [String] id (required):
+  ///
+  /// * [UpdateAlbumUserMetadataDto] updateAlbumUserMetadataDto (required):
+  Future<AlbumResponseDto?> updateAlbumUserMetadata(String id, UpdateAlbumUserMetadataDto updateAlbumUserMetadataDto,) async {
+    final response = await updateAlbumUserMetadataWithHttpInfo(id, updateAlbumUserMetadataDto,);
+    if (response.statusCode >= HttpStatus.badRequest) {
+      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
+    }
+    // When a remote server returns no body with a status of 204, we shall not decode it.
+    // At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
+    // FormatException when trying to decode an empty string.
+    if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
+      return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'AlbumResponseDto',) as AlbumResponseDto;
+    
+    }
+    return null;
+  }
 }

mobile/openapi/lib/api/upload_api.dart

@@ -1,359 +0,0 @@
-//
-// AUTO-GENERATED FILE, DO NOT MODIFY!
-//
-// @dart=2.18
-
-// ignore_for_file: unused_element, unused_import
-// ignore_for_file: always_put_required_named_parameters_first
-// ignore_for_file: constant_identifier_names
-// ignore_for_file: lines_longer_than_80_chars
-
-part of openapi.api;
-
-
-class UploadApi {
-  UploadApi([ApiClient? apiClient]) : apiClient = apiClient ?? defaultApiClient;
-
-  final ApiClient apiClient;
-
-  /// Performs an HTTP 'DELETE /upload/{id}' operation and returns the [Response].
-  /// Parameters:
-  ///
-  /// * [String] id (required):
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  Future<Response> cancelUploadWithHttpInfo(String id, { String? key, String? slug, }) async {
-    // ignore: prefer_const_declarations
-    final apiPath = r'/upload/{id}'
-      .replaceAll('{id}', id);
-
-    // ignore: prefer_final_locals
-    Object? postBody;
-
-    final queryParams = <QueryParam>[];
-    final headerParams = <String, String>{};
-    final formParams = <String, String>{};
-
-    if (key != null) {
-      queryParams.addAll(_queryParams('', 'key', key));
-    }
-    if (slug != null) {
-      queryParams.addAll(_queryParams('', 'slug', slug));
-    }
-
-    const contentTypes = <String>[];
-
-
-    return apiClient.invokeAPI(
-      apiPath,
-      'DELETE',
-      queryParams,
-      postBody,
-      headerParams,
-      formParams,
-      contentTypes.isEmpty ? null : contentTypes.first,
-    );
-  }
-
-  /// Parameters:
-  ///
-  /// * [String] id (required):
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  Future<void> cancelUpload(String id, { String? key, String? slug, }) async {
-    final response = await cancelUploadWithHttpInfo(id,  key: key, slug: slug, );
-    if (response.statusCode >= HttpStatus.badRequest) {
-      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
-    }
-  }
-
-  /// Performs an HTTP 'OPTIONS /upload' operation and returns the [Response].
-  Future<Response> getUploadOptionsWithHttpInfo() async {
-    // ignore: prefer_const_declarations
-    final apiPath = r'/upload';
-
-    // ignore: prefer_final_locals
-    Object? postBody;
-
-    final queryParams = <QueryParam>[];
-    final headerParams = <String, String>{};
-    final formParams = <String, String>{};
-
-    const contentTypes = <String>[];
-
-
-    return apiClient.invokeAPI(
-      apiPath,
-      'OPTIONS',
-      queryParams,
-      postBody,
-      headerParams,
-      formParams,
-      contentTypes.isEmpty ? null : contentTypes.first,
-    );
-  }
-
-  Future<void> getUploadOptions() async {
-    final response = await getUploadOptionsWithHttpInfo();
-    if (response.statusCode >= HttpStatus.badRequest) {
-      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
-    }
-  }
-
-  /// Performs an HTTP 'HEAD /upload/{id}' operation and returns the [Response].
-  /// Parameters:
-  ///
-  /// * [String] id (required):
-  ///
-  /// * [String] uploadDraftInteropVersion (required):
-  ///   Indicates the version of the RUFH protocol supported by the client.
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  Future<Response> getUploadStatusWithHttpInfo(String id, String uploadDraftInteropVersion, { String? key, String? slug, }) async {
-    // ignore: prefer_const_declarations
-    final apiPath = r'/upload/{id}'
-      .replaceAll('{id}', id);
-
-    // ignore: prefer_final_locals
-    Object? postBody;
-
-    final queryParams = <QueryParam>[];
-    final headerParams = <String, String>{};
-    final formParams = <String, String>{};
-
-    if (key != null) {
-      queryParams.addAll(_queryParams('', 'key', key));
-    }
-    if (slug != null) {
-      queryParams.addAll(_queryParams('', 'slug', slug));
-    }
-
-    headerParams[r'upload-draft-interop-version'] = parameterToString(uploadDraftInteropVersion);
-
-    const contentTypes = <String>[];
-
-
-    return apiClient.invokeAPI(
-      apiPath,
-      'HEAD',
-      queryParams,
-      postBody,
-      headerParams,
-      formParams,
-      contentTypes.isEmpty ? null : contentTypes.first,
-    );
-  }
-
-  /// Parameters:
-  ///
-  /// * [String] id (required):
-  ///
-  /// * [String] uploadDraftInteropVersion (required):
-  ///   Indicates the version of the RUFH protocol supported by the client.
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  Future<void> getUploadStatus(String id, String uploadDraftInteropVersion, { String? key, String? slug, }) async {
-    final response = await getUploadStatusWithHttpInfo(id, uploadDraftInteropVersion,  key: key, slug: slug, );
-    if (response.statusCode >= HttpStatus.badRequest) {
-      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
-    }
-  }
-
-  /// Performs an HTTP 'PATCH /upload/{id}' operation and returns the [Response].
-  /// Parameters:
-  ///
-  /// * [String] contentLength (required):
-  ///   Non-negative size of the request body in bytes.
-  ///
-  /// * [String] id (required):
-  ///
-  /// * [String] uploadComplete (required):
-  ///   Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.
-  ///
-  /// * [String] uploadDraftInteropVersion (required):
-  ///   Indicates the version of the RUFH protocol supported by the client.
-  ///
-  /// * [String] uploadOffset (required):
-  ///   Non-negative byte offset indicating the starting position of the data in the request body within the entire file.
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  Future<Response> resumeUploadWithHttpInfo(String contentLength, String id, String uploadComplete, String uploadDraftInteropVersion, String uploadOffset, { String? key, String? slug, }) async {
-    // ignore: prefer_const_declarations
-    final apiPath = r'/upload/{id}'
-      .replaceAll('{id}', id);
-
-    // ignore: prefer_final_locals
-    Object? postBody;
-
-    final queryParams = <QueryParam>[];
-    final headerParams = <String, String>{};
-    final formParams = <String, String>{};
-
-    if (key != null) {
-      queryParams.addAll(_queryParams('', 'key', key));
-    }
-    if (slug != null) {
-      queryParams.addAll(_queryParams('', 'slug', slug));
-    }
-
-    headerParams[r'content-length'] = parameterToString(contentLength);
-    headerParams[r'upload-complete'] = parameterToString(uploadComplete);
-    headerParams[r'upload-draft-interop-version'] = parameterToString(uploadDraftInteropVersion);
-    headerParams[r'upload-offset'] = parameterToString(uploadOffset);
-
-    const contentTypes = <String>[];
-
-
-    return apiClient.invokeAPI(
-      apiPath,
-      'PATCH',
-      queryParams,
-      postBody,
-      headerParams,
-      formParams,
-      contentTypes.isEmpty ? null : contentTypes.first,
-    );
-  }
-
-  /// Parameters:
-  ///
-  /// * [String] contentLength (required):
-  ///   Non-negative size of the request body in bytes.
-  ///
-  /// * [String] id (required):
-  ///
-  /// * [String] uploadComplete (required):
-  ///   Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.
-  ///
-  /// * [String] uploadDraftInteropVersion (required):
-  ///   Indicates the version of the RUFH protocol supported by the client.
-  ///
-  /// * [String] uploadOffset (required):
-  ///   Non-negative byte offset indicating the starting position of the data in the request body within the entire file.
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  Future<UploadOkDto?> resumeUpload(String contentLength, String id, String uploadComplete, String uploadDraftInteropVersion, String uploadOffset, { String? key, String? slug, }) async {
-    final response = await resumeUploadWithHttpInfo(contentLength, id, uploadComplete, uploadDraftInteropVersion, uploadOffset,  key: key, slug: slug, );
-    if (response.statusCode >= HttpStatus.badRequest) {
-      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
-    }
-    // When a remote server returns no body with a status of 204, we shall not decode it.
-    // At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
-    // FormatException when trying to decode an empty string.
-    if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
-      return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'UploadOkDto',) as UploadOkDto;
-    
-    }
-    return null;
-  }
-
-  /// Performs an HTTP 'POST /upload' operation and returns the [Response].
-  /// Parameters:
-  ///
-  /// * [String] contentLength (required):
-  ///   Non-negative size of the request body in bytes.
-  ///
-  /// * [String] reprDigest (required):
-  ///   RFC 9651 structured dictionary containing an `sha` (bytesequence) checksum used to detect duplicate files and validate data integrity.
-  ///
-  /// * [String] xImmichAssetData (required):
-  ///   RFC 9651 structured dictionary containing asset metadata with the following keys: - device-asset-id (string, required): Unique device asset identifier - device-id (string, required): Device identifier - file-created-at (string/date, required): ISO 8601 date string or Unix timestamp - file-modified-at (string/date, required): ISO 8601 date string or Unix timestamp - filename (string, required): Original filename - is-favorite (boolean, optional): Favorite status - live-photo-video-id (string, optional): Live photo ID for assets from iOS devices - icloud-id (string, optional): iCloud identifier for assets from iOS devices
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  ///
-  /// * [String] uploadComplete:
-  ///   Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.
-  ///
-  /// * [String] uploadDraftInteropVersion:
-  ///   Indicates the version of the RUFH protocol supported by the client.
-  Future<Response> startUploadWithHttpInfo(String contentLength, String reprDigest, String xImmichAssetData, { String? key, String? slug, String? uploadComplete, String? uploadDraftInteropVersion, }) async {
-    // ignore: prefer_const_declarations
-    final apiPath = r'/upload';
-
-    // ignore: prefer_final_locals
-    Object? postBody;
-
-    final queryParams = <QueryParam>[];
-    final headerParams = <String, String>{};
-    final formParams = <String, String>{};
-
-    if (key != null) {
-      queryParams.addAll(_queryParams('', 'key', key));
-    }
-    if (slug != null) {
-      queryParams.addAll(_queryParams('', 'slug', slug));
-    }
-
-    headerParams[r'content-length'] = parameterToString(contentLength);
-    headerParams[r'repr-digest'] = parameterToString(reprDigest);
-    if (uploadComplete != null) {
-      headerParams[r'upload-complete'] = parameterToString(uploadComplete);
-    }
-    if (uploadDraftInteropVersion != null) {
-      headerParams[r'upload-draft-interop-version'] = parameterToString(uploadDraftInteropVersion);
-    }
-    headerParams[r'x-immich-asset-data'] = parameterToString(xImmichAssetData);
-
-    const contentTypes = <String>[];
-
-
-    return apiClient.invokeAPI(
-      apiPath,
-      'POST',
-      queryParams,
-      postBody,
-      headerParams,
-      formParams,
-      contentTypes.isEmpty ? null : contentTypes.first,
-    );
-  }
-
-  /// Parameters:
-  ///
-  /// * [String] contentLength (required):
-  ///   Non-negative size of the request body in bytes.
-  ///
-  /// * [String] reprDigest (required):
-  ///   RFC 9651 structured dictionary containing an `sha` (bytesequence) checksum used to detect duplicate files and validate data integrity.
-  ///
-  /// * [String] xImmichAssetData (required):
-  ///   RFC 9651 structured dictionary containing asset metadata with the following keys: - device-asset-id (string, required): Unique device asset identifier - device-id (string, required): Device identifier - file-created-at (string/date, required): ISO 8601 date string or Unix timestamp - file-modified-at (string/date, required): ISO 8601 date string or Unix timestamp - filename (string, required): Original filename - is-favorite (boolean, optional): Favorite status - live-photo-video-id (string, optional): Live photo ID for assets from iOS devices - icloud-id (string, optional): iCloud identifier for assets from iOS devices
-  ///
-  /// * [String] key:
-  ///
-  /// * [String] slug:
-  ///
-  /// * [String] uploadComplete:
-  ///   Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.
-  ///
-  /// * [String] uploadDraftInteropVersion:
-  ///   Indicates the version of the RUFH protocol supported by the client.
-  Future<UploadOkDto?> startUpload(String contentLength, String reprDigest, String xImmichAssetData, { String? key, String? slug, String? uploadComplete, String? uploadDraftInteropVersion, }) async {
-    final response = await startUploadWithHttpInfo(contentLength, reprDigest, xImmichAssetData,  key: key, slug: slug, uploadComplete: uploadComplete, uploadDraftInteropVersion: uploadDraftInteropVersion, );
-    if (response.statusCode >= HttpStatus.badRequest) {
-      throw ApiException(response.statusCode, await _decodeBodyBytes(response));
-    }
-    // When a remote server returns no body with a status of 204, we shall not decode it.
-    // At the time of writing this, `dart:convert` will throw an "Unexpected end of input"
-    // FormatException when trying to decode an empty string.
-    if (response.body.isNotEmpty && response.statusCode != HttpStatus.noContent) {
-      return await apiClient.deserializeAsync(await _decodeBodyBytes(response), 'UploadOkDto',) as UploadOkDto;
-    
-    }
-    return null;
-  }
-}

mobile/openapi/lib/api_client.dart

@@ -674,6 +674,10 @@ class ApiClient {
           return SyncAlbumToAssetV1.fromJson(value);
         case 'SyncAlbumUserDeleteV1':
           return SyncAlbumUserDeleteV1.fromJson(value);
+        case 'SyncAlbumUserMetadataDeleteV1':
+          return SyncAlbumUserMetadataDeleteV1.fromJson(value);
+        case 'SyncAlbumUserMetadataV1':
+          return SyncAlbumUserMetadataV1.fromJson(value);
         case 'SyncAlbumUserV1':
           return SyncAlbumUserV1.fromJson(value);
         case 'SyncAlbumV1':
@@ -834,14 +838,12 @@ class ApiClient {
           return UpdateAlbumDto.fromJson(value);
         case 'UpdateAlbumUserDto':
           return UpdateAlbumUserDto.fromJson(value);
+        case 'UpdateAlbumUserMetadataDto':
+          return UpdateAlbumUserMetadataDto.fromJson(value);
         case 'UpdateAssetDto':
           return UpdateAssetDto.fromJson(value);
         case 'UpdateLibraryDto':
           return UpdateLibraryDto.fromJson(value);
-        case 'UploadBackupConfig':
-          return UploadBackupConfig.fromJson(value);
-        case 'UploadOkDto':
-          return UploadOkDto.fromJson(value);
         case 'UsageByUserDto':
           return UsageByUserDto.fromJson(value);
         case 'UserAdminCreateDto':

mobile/openapi/lib/model/album_response_dto.dart

@@ -25,6 +25,7 @@ class AlbumResponseDto {
     required this.hasSharedLink,
     required this.id,
     required this.isActivityEnabled,
+    required this.isFavorite,
     this.lastModifiedAssetTimestamp,
     this.order,
     required this.owner,
@@ -73,6 +74,9 @@ class AlbumResponseDto {
   /// Activity feed enabled
   bool isActivityEnabled;
 
+  /// Is favorite
+  bool isFavorite;
+
   /// Last modified asset timestamp
   ///
   /// Please note: This property should have been non-nullable! Since the specification file
@@ -125,6 +129,7 @@ class AlbumResponseDto {
     other.hasSharedLink == hasSharedLink &&
     other.id == id &&
     other.isActivityEnabled == isActivityEnabled &&
+    other.isFavorite == isFavorite &&
     other.lastModifiedAssetTimestamp == lastModifiedAssetTimestamp &&
     other.order == order &&
     other.owner == owner &&
@@ -148,6 +153,7 @@ class AlbumResponseDto {
     (hasSharedLink.hashCode) +
     (id.hashCode) +
     (isActivityEnabled.hashCode) +
+    (isFavorite.hashCode) +
     (lastModifiedAssetTimestamp == null ? 0 : lastModifiedAssetTimestamp!.hashCode) +
     (order == null ? 0 : order!.hashCode) +
     (owner.hashCode) +
@@ -157,7 +163,7 @@ class AlbumResponseDto {
     (updatedAt.hashCode);
 
   @override
-  String toString() => 'AlbumResponseDto[albumName=$albumName, albumThumbnailAssetId=$albumThumbnailAssetId, albumUsers=$albumUsers, assetCount=$assetCount, assets=$assets, contributorCounts=$contributorCounts, createdAt=$createdAt, description=$description, endDate=$endDate, hasSharedLink=$hasSharedLink, id=$id, isActivityEnabled=$isActivityEnabled, lastModifiedAssetTimestamp=$lastModifiedAssetTimestamp, order=$order, owner=$owner, ownerId=$ownerId, shared=$shared, startDate=$startDate, updatedAt=$updatedAt]';
+  String toString() => 'AlbumResponseDto[albumName=$albumName, albumThumbnailAssetId=$albumThumbnailAssetId, albumUsers=$albumUsers, assetCount=$assetCount, assets=$assets, contributorCounts=$contributorCounts, createdAt=$createdAt, description=$description, endDate=$endDate, hasSharedLink=$hasSharedLink, id=$id, isActivityEnabled=$isActivityEnabled, isFavorite=$isFavorite, lastModifiedAssetTimestamp=$lastModifiedAssetTimestamp, order=$order, owner=$owner, ownerId=$ownerId, shared=$shared, startDate=$startDate, updatedAt=$updatedAt]';
 
   Map<String, dynamic> toJson() {
     final json = <String, dynamic>{};
@@ -181,6 +187,7 @@ class AlbumResponseDto {
       json[r'hasSharedLink'] = this.hasSharedLink;
       json[r'id'] = this.id;
       json[r'isActivityEnabled'] = this.isActivityEnabled;
+      json[r'isFavorite'] = this.isFavorite;
     if (this.lastModifiedAssetTimestamp != null) {
       json[r'lastModifiedAssetTimestamp'] = this.lastModifiedAssetTimestamp!.toUtc().toIso8601String();
     } else {
@@ -224,6 +231,7 @@ class AlbumResponseDto {
         hasSharedLink: mapValueOfType<bool>(json, r'hasSharedLink')!,
         id: mapValueOfType<String>(json, r'id')!,
         isActivityEnabled: mapValueOfType<bool>(json, r'isActivityEnabled')!,
+        isFavorite: mapValueOfType<bool>(json, r'isFavorite')!,
         lastModifiedAssetTimestamp: mapDateTime(json, r'lastModifiedAssetTimestamp', r''),
         order: AssetOrder.fromJson(json[r'order']),
         owner: UserResponseDto.fromJson(json[r'owner'])!,
@@ -288,6 +296,7 @@ class AlbumResponseDto {
     'hasSharedLink',
     'id',
     'isActivityEnabled',
+    'isFavorite',
     'owner',
     'ownerId',
     'shared',

mobile/openapi/lib/model/job_name.dart

@@ -38,8 +38,6 @@ class JobName {
   static const assetFileMigration = JobName._(r'AssetFileMigration');
   static const assetGenerateThumbnailsQueueAll = JobName._(r'AssetGenerateThumbnailsQueueAll');
   static const assetGenerateThumbnails = JobName._(r'AssetGenerateThumbnails');
-  static const partialAssetCleanup = JobName._(r'PartialAssetCleanup');
-  static const partialAssetCleanupQueueAll = JobName._(r'PartialAssetCleanupQueueAll');
   static const auditLogCleanup = JobName._(r'AuditLogCleanup');
   static const auditTableCleanup = JobName._(r'AuditTableCleanup');
   static const databaseBackup = JobName._(r'DatabaseBackup');
@@ -99,8 +97,6 @@ class JobName {
     assetFileMigration,
     assetGenerateThumbnailsQueueAll,
     assetGenerateThumbnails,
-    partialAssetCleanup,
-    partialAssetCleanupQueueAll,
     auditLogCleanup,
     auditTableCleanup,
     databaseBackup,
@@ -195,8 +191,6 @@ class JobNameTypeTransformer {
         case r'AssetFileMigration': return JobName.assetFileMigration;
         case r'AssetGenerateThumbnailsQueueAll': return JobName.assetGenerateThumbnailsQueueAll;
         case r'AssetGenerateThumbnails': return JobName.assetGenerateThumbnails;
-        case r'PartialAssetCleanup': return JobName.partialAssetCleanup;
-        case r'PartialAssetCleanupQueueAll': return JobName.partialAssetCleanupQueueAll;
         case r'AuditLogCleanup': return JobName.auditLogCleanup;
         case r'AuditTableCleanup': return JobName.auditTableCleanup;
         case r'DatabaseBackup': return JobName.databaseBackup;

mobile/openapi/lib/model/sync_album_user_metadata_delete_v1.dart

@@ -0,0 +1,109 @@
+//
+// AUTO-GENERATED FILE, DO NOT MODIFY!
+//
+// @dart=2.18
+
+// ignore_for_file: unused_element, unused_import
+// ignore_for_file: always_put_required_named_parameters_first
+// ignore_for_file: constant_identifier_names
+// ignore_for_file: lines_longer_than_80_chars
+
+part of openapi.api;
+
+class SyncAlbumUserMetadataDeleteV1 {
+  /// Returns a new [SyncAlbumUserMetadataDeleteV1] instance.
+  SyncAlbumUserMetadataDeleteV1({
+    required this.albumId,
+    required this.userId,
+  });
+
+  /// Album ID
+  String albumId;
+
+  /// User ID
+  String userId;
+
+  @override
+  bool operator ==(Object other) => identical(this, other) || other is SyncAlbumUserMetadataDeleteV1 &&
+    other.albumId == albumId &&
+    other.userId == userId;
+
+  @override
+  int get hashCode =>
+    // ignore: unnecessary_parenthesis
+    (albumId.hashCode) +
+    (userId.hashCode);
+
+  @override
+  String toString() => 'SyncAlbumUserMetadataDeleteV1[albumId=$albumId, userId=$userId]';
+
+  Map<String, dynamic> toJson() {
+    final json = <String, dynamic>{};
+      json[r'albumId'] = this.albumId;
+      json[r'userId'] = this.userId;
+    return json;
+  }
+
+  /// Returns a new [SyncAlbumUserMetadataDeleteV1] instance and imports its values from
+  /// [value] if it's a [Map], null otherwise.
+  // ignore: prefer_constructors_over_static_methods
+  static SyncAlbumUserMetadataDeleteV1? fromJson(dynamic value) {
+    upgradeDto(value, "SyncAlbumUserMetadataDeleteV1");
+    if (value is Map) {
+      final json = value.cast<String, dynamic>();
+
+      return SyncAlbumUserMetadataDeleteV1(
+        albumId: mapValueOfType<String>(json, r'albumId')!,
+        userId: mapValueOfType<String>(json, r'userId')!,
+      );
+    }
+    return null;
+  }
+
+  static List<SyncAlbumUserMetadataDeleteV1> listFromJson(dynamic json, {bool growable = false,}) {
+    final result = <SyncAlbumUserMetadataDeleteV1>[];
+    if (json is List && json.isNotEmpty) {
+      for (final row in json) {
+        final value = SyncAlbumUserMetadataDeleteV1.fromJson(row);
+        if (value != null) {
+          result.add(value);
+        }
+      }
+    }
+    return result.toList(growable: growable);
+  }
+
+  static Map<String, SyncAlbumUserMetadataDeleteV1> mapFromJson(dynamic json) {
+    final map = <String, SyncAlbumUserMetadataDeleteV1>{};
+    if (json is Map && json.isNotEmpty) {
+      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
+      for (final entry in json.entries) {
+        final value = SyncAlbumUserMetadataDeleteV1.fromJson(entry.value);
+        if (value != null) {
+          map[entry.key] = value;
+        }
+      }
+    }
+    return map;
+  }
+
+  // maps a json object with a list of SyncAlbumUserMetadataDeleteV1-objects as value to a dart map
+  static Map<String, List<SyncAlbumUserMetadataDeleteV1>> mapListFromJson(dynamic json, {bool growable = false,}) {
+    final map = <String, List<SyncAlbumUserMetadataDeleteV1>>{};
+    if (json is Map && json.isNotEmpty) {
+      // ignore: parameter_assignments
+      json = json.cast<String, dynamic>();
+      for (final entry in json.entries) {
+        map[entry.key] = SyncAlbumUserMetadataDeleteV1.listFromJson(entry.value, growable: growable,);
+      }
+    }
+    return map;
+  }
+
+  /// The list of required keys that must be present in a JSON.
+  static const requiredKeys = <String>{
+    'albumId',
+    'userId',
+  };
+}
+

mobile/openapi/lib/model/sync_album_user_metadata_v1.dart

@@ -0,0 +1,118 @@
+//
+// AUTO-GENERATED FILE, DO NOT MODIFY!
+//
+// @dart=2.18
+
+// ignore_for_file: unused_element, unused_import
+// ignore_for_file: always_put_required_named_parameters_first
+// ignore_for_file: constant_identifier_names
+// ignore_for_file: lines_longer_than_80_chars
+
+part of openapi.api;
+
+class SyncAlbumUserMetadataV1 {
+  /// Returns a new [SyncAlbumUserMetadataV1] instance.
+  SyncAlbumUserMetadataV1({
+    required this.albumId,
+    required this.isFavorite,
+    required this.userId,
+  });
+
+  /// Album ID
+  String albumId;
+
+  /// Is favorite
+  bool isFavorite;
+
+  /// User ID
+  String userId;
+
+  @override
+  bool operator ==(Object other) => identical(this, other) || other is SyncAlbumUserMetadataV1 &&
+    other.albumId == albumId &&
+    other.isFavorite == isFavorite &&
+    other.userId == userId;
+
+  @override
+  int get hashCode =>
+    // ignore: unnecessary_parenthesis
+    (albumId.hashCode) +
+    (isFavorite.hashCode) +
+    (userId.hashCode);
+
+  @override
+  String toString() => 'SyncAlbumUserMetadataV1[albumId=$albumId, isFavorite=$isFavorite, userId=$userId]';
+
+  Map<String, dynamic> toJson() {
+    final json = <String, dynamic>{};
+      json[r'albumId'] = this.albumId;
+      json[r'isFavorite'] = this.isFavorite;
+      json[r'userId'] = this.userId;
+    return json;
+  }
+
+  /// Returns a new [SyncAlbumUserMetadataV1] instance and imports its values from
+  /// [value] if it's a [Map], null otherwise.
+  // ignore: prefer_constructors_over_static_methods
+  static SyncAlbumUserMetadataV1? fromJson(dynamic value) {
+    upgradeDto(value, "SyncAlbumUserMetadataV1");
+    if (value is Map) {
+      final json = value.cast<String, dynamic>();
+
+      return SyncAlbumUserMetadataV1(
+        albumId: mapValueOfType<String>(json, r'albumId')!,
+        isFavorite: mapValueOfType<bool>(json, r'isFavorite')!,
+        userId: mapValueOfType<String>(json, r'userId')!,
+      );
+    }
+    return null;
+  }
+
+  static List<SyncAlbumUserMetadataV1> listFromJson(dynamic json, {bool growable = false,}) {
+    final result = <SyncAlbumUserMetadataV1>[];
+    if (json is List && json.isNotEmpty) {
+      for (final row in json) {
+        final value = SyncAlbumUserMetadataV1.fromJson(row);
+        if (value != null) {
+          result.add(value);
+        }
+      }
+    }
+    return result.toList(growable: growable);
+  }
+
+  static Map<String, SyncAlbumUserMetadataV1> mapFromJson(dynamic json) {
+    final map = <String, SyncAlbumUserMetadataV1>{};
+    if (json is Map && json.isNotEmpty) {
+      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
+      for (final entry in json.entries) {
+        final value = SyncAlbumUserMetadataV1.fromJson(entry.value);
+        if (value != null) {
+          map[entry.key] = value;
+        }
+      }
+    }
+    return map;
+  }
+
+  // maps a json object with a list of SyncAlbumUserMetadataV1-objects as value to a dart map
+  static Map<String, List<SyncAlbumUserMetadataV1>> mapListFromJson(dynamic json, {bool growable = false,}) {
+    final map = <String, List<SyncAlbumUserMetadataV1>>{};
+    if (json is Map && json.isNotEmpty) {
+      // ignore: parameter_assignments
+      json = json.cast<String, dynamic>();
+      for (final entry in json.entries) {
+        map[entry.key] = SyncAlbumUserMetadataV1.listFromJson(entry.value, growable: growable,);
+      }
+    }
+    return map;
+  }
+
+  /// The list of required keys that must be present in a JSON.
+  static const requiredKeys = <String>{
+    'albumId',
+    'isFavorite',
+    'userId',
+  };
+}
+

mobile/openapi/lib/model/sync_entity_type.dart

@@ -48,6 +48,8 @@ class SyncEntityType {
   static const albumUserV1 = SyncEntityType._(r'AlbumUserV1');
   static const albumUserBackfillV1 = SyncEntityType._(r'AlbumUserBackfillV1');
   static const albumUserDeleteV1 = SyncEntityType._(r'AlbumUserDeleteV1');
+  static const albumUserMetadataV1 = SyncEntityType._(r'AlbumUserMetadataV1');
+  static const albumUserMetadataDeleteV1 = SyncEntityType._(r'AlbumUserMetadataDeleteV1');
   static const albumAssetCreateV1 = SyncEntityType._(r'AlbumAssetCreateV1');
   static const albumAssetUpdateV1 = SyncEntityType._(r'AlbumAssetUpdateV1');
   static const albumAssetBackfillV1 = SyncEntityType._(r'AlbumAssetBackfillV1');
@@ -101,6 +103,8 @@ class SyncEntityType {
     albumUserV1,
     albumUserBackfillV1,
     albumUserDeleteV1,
+    albumUserMetadataV1,
+    albumUserMetadataDeleteV1,
     albumAssetCreateV1,
     albumAssetUpdateV1,
     albumAssetBackfillV1,
@@ -189,6 +193,8 @@ class SyncEntityTypeTypeTransformer {
         case r'AlbumUserV1': return SyncEntityType.albumUserV1;
         case r'AlbumUserBackfillV1': return SyncEntityType.albumUserBackfillV1;
         case r'AlbumUserDeleteV1': return SyncEntityType.albumUserDeleteV1;
+        case r'AlbumUserMetadataV1': return SyncEntityType.albumUserMetadataV1;
+        case r'AlbumUserMetadataDeleteV1': return SyncEntityType.albumUserMetadataDeleteV1;
         case r'AlbumAssetCreateV1': return SyncEntityType.albumAssetCreateV1;
         case r'AlbumAssetUpdateV1': return SyncEntityType.albumAssetUpdateV1;
         case r'AlbumAssetBackfillV1': return SyncEntityType.albumAssetBackfillV1;

mobile/openapi/lib/model/sync_request_type.dart

@@ -25,6 +25,7 @@ class SyncRequestType {
 
   static const albumsV1 = SyncRequestType._(r'AlbumsV1');
   static const albumUsersV1 = SyncRequestType._(r'AlbumUsersV1');
+  static const albumUserMetadataV1 = SyncRequestType._(r'AlbumUserMetadataV1');
   static const albumToAssetsV1 = SyncRequestType._(r'AlbumToAssetsV1');
   static const albumAssetsV1 = SyncRequestType._(r'AlbumAssetsV1');
   static const albumAssetExifsV1 = SyncRequestType._(r'AlbumAssetExifsV1');
@@ -50,6 +51,7 @@ class SyncRequestType {
   static const values = <SyncRequestType>[
     albumsV1,
     albumUsersV1,
+    albumUserMetadataV1,
     albumToAssetsV1,
     albumAssetsV1,
     albumAssetExifsV1,
@@ -110,6 +112,7 @@ class SyncRequestTypeTypeTransformer {
       switch (data) {
         case r'AlbumsV1': return SyncRequestType.albumsV1;
         case r'AlbumUsersV1': return SyncRequestType.albumUsersV1;
+        case r'AlbumUserMetadataV1': return SyncRequestType.albumUserMetadataV1;
         case r'AlbumToAssetsV1': return SyncRequestType.albumToAssetsV1;
         case r'AlbumAssetsV1': return SyncRequestType.albumAssetsV1;
         case r'AlbumAssetExifsV1': return SyncRequestType.albumAssetExifsV1;

mobile/openapi/lib/model/system_config_backups_dto.dart

@@ -14,31 +14,25 @@ class SystemConfigBackupsDto {
   /// Returns a new [SystemConfigBackupsDto] instance.
   SystemConfigBackupsDto({
     required this.database,
-    required this.upload,
   });
 
   DatabaseBackupConfig database;
 
-  UploadBackupConfig upload;
-
   @override
   bool operator ==(Object other) => identical(this, other) || other is SystemConfigBackupsDto &&
-    other.database == database &&
-    other.upload == upload;
+    other.database == database;
 
   @override
   int get hashCode =>
     // ignore: unnecessary_parenthesis
-    (database.hashCode) +
-    (upload.hashCode);
+    (database.hashCode);
 
   @override
-  String toString() => 'SystemConfigBackupsDto[database=$database, upload=$upload]';
+  String toString() => 'SystemConfigBackupsDto[database=$database]';
 
   Map<String, dynamic> toJson() {
     final json = <String, dynamic>{};
       json[r'database'] = this.database;
-      json[r'upload'] = this.upload;
     return json;
   }
 
@@ -52,7 +46,6 @@ class SystemConfigBackupsDto {
 
       return SystemConfigBackupsDto(
         database: DatabaseBackupConfig.fromJson(json[r'database'])!,
-        upload: UploadBackupConfig.fromJson(json[r'upload'])!,
       );
     }
     return null;
@@ -101,7 +94,6 @@ class SystemConfigBackupsDto {
   /// The list of required keys that must be present in a JSON.
   static const requiredKeys = <String>{
     'database',
-    'upload',
   };
 }
 

mobile/openapi/lib/model/system_config_nightly_tasks_dto.dart

@@ -17,7 +17,6 @@ class SystemConfigNightlyTasksDto {
     required this.databaseCleanup,
     required this.generateMemories,
     required this.missingThumbnails,
-    required this.removeStaleUploads,
     required this.startTime,
     required this.syncQuotaUsage,
   });
@@ -34,8 +33,6 @@ class SystemConfigNightlyTasksDto {
   /// Missing thumbnails
   bool missingThumbnails;
 
-  bool removeStaleUploads;
-
   String startTime;
 
   /// Sync quota usage
@@ -47,7 +44,6 @@ class SystemConfigNightlyTasksDto {
     other.databaseCleanup == databaseCleanup &&
     other.generateMemories == generateMemories &&
     other.missingThumbnails == missingThumbnails &&
-    other.removeStaleUploads == removeStaleUploads &&
     other.startTime == startTime &&
     other.syncQuotaUsage == syncQuotaUsage;
 
@@ -58,12 +54,11 @@ class SystemConfigNightlyTasksDto {
     (databaseCleanup.hashCode) +
     (generateMemories.hashCode) +
     (missingThumbnails.hashCode) +
-    (removeStaleUploads.hashCode) +
     (startTime.hashCode) +
     (syncQuotaUsage.hashCode);
 
   @override
-  String toString() => 'SystemConfigNightlyTasksDto[clusterNewFaces=$clusterNewFaces, databaseCleanup=$databaseCleanup, generateMemories=$generateMemories, missingThumbnails=$missingThumbnails, removeStaleUploads=$removeStaleUploads, startTime=$startTime, syncQuotaUsage=$syncQuotaUsage]';
+  String toString() => 'SystemConfigNightlyTasksDto[clusterNewFaces=$clusterNewFaces, databaseCleanup=$databaseCleanup, generateMemories=$generateMemories, missingThumbnails=$missingThumbnails, startTime=$startTime, syncQuotaUsage=$syncQuotaUsage]';
 
   Map<String, dynamic> toJson() {
     final json = <String, dynamic>{};
@@ -71,7 +66,6 @@ class SystemConfigNightlyTasksDto {
       json[r'databaseCleanup'] = this.databaseCleanup;
       json[r'generateMemories'] = this.generateMemories;
       json[r'missingThumbnails'] = this.missingThumbnails;
-      json[r'removeStaleUploads'] = this.removeStaleUploads;
       json[r'startTime'] = this.startTime;
       json[r'syncQuotaUsage'] = this.syncQuotaUsage;
     return json;
@@ -90,7 +84,6 @@ class SystemConfigNightlyTasksDto {
         databaseCleanup: mapValueOfType<bool>(json, r'databaseCleanup')!,
         generateMemories: mapValueOfType<bool>(json, r'generateMemories')!,
         missingThumbnails: mapValueOfType<bool>(json, r'missingThumbnails')!,
-        removeStaleUploads: mapValueOfType<bool>(json, r'removeStaleUploads')!,
         startTime: mapValueOfType<String>(json, r'startTime')!,
         syncQuotaUsage: mapValueOfType<bool>(json, r'syncQuotaUsage')!,
       );
@@ -144,7 +137,6 @@ class SystemConfigNightlyTasksDto {
     'databaseCleanup',
     'generateMemories',
     'missingThumbnails',
-    'removeStaleUploads',
     'startTime',
     'syncQuotaUsage',
   };

mobile/openapi/lib/model/update_album_user_metadata_dto.dart

@@ -10,53 +10,53 @@
 
 part of openapi.api;
 
-class UploadBackupConfig {
-  /// Returns a new [UploadBackupConfig] instance.
-  UploadBackupConfig({
-    required this.maxAgeHours,
+class UpdateAlbumUserMetadataDto {
+  /// Returns a new [UpdateAlbumUserMetadataDto] instance.
+  UpdateAlbumUserMetadataDto({
+    required this.isFavorite,
   });
 
-  /// Minimum value: 1
-  num maxAgeHours;
+  /// Favorite status
+  bool isFavorite;
 
   @override
-  bool operator ==(Object other) => identical(this, other) || other is UploadBackupConfig &&
-    other.maxAgeHours == maxAgeHours;
+  bool operator ==(Object other) => identical(this, other) || other is UpdateAlbumUserMetadataDto &&
+    other.isFavorite == isFavorite;
 
   @override
   int get hashCode =>
     // ignore: unnecessary_parenthesis
-    (maxAgeHours.hashCode);
+    (isFavorite.hashCode);
 
   @override
-  String toString() => 'UploadBackupConfig[maxAgeHours=$maxAgeHours]';
+  String toString() => 'UpdateAlbumUserMetadataDto[isFavorite=$isFavorite]';
 
   Map<String, dynamic> toJson() {
     final json = <String, dynamic>{};
-      json[r'maxAgeHours'] = this.maxAgeHours;
+      json[r'isFavorite'] = this.isFavorite;
     return json;
   }
 
-  /// Returns a new [UploadBackupConfig] instance and imports its values from
+  /// Returns a new [UpdateAlbumUserMetadataDto] instance and imports its values from
   /// [value] if it's a [Map], null otherwise.
   // ignore: prefer_constructors_over_static_methods
-  static UploadBackupConfig? fromJson(dynamic value) {
-    upgradeDto(value, "UploadBackupConfig");
+  static UpdateAlbumUserMetadataDto? fromJson(dynamic value) {
+    upgradeDto(value, "UpdateAlbumUserMetadataDto");
     if (value is Map) {
       final json = value.cast<String, dynamic>();
 
-      return UploadBackupConfig(
-        maxAgeHours: num.parse('${json[r'maxAgeHours']}'),
+      return UpdateAlbumUserMetadataDto(
+        isFavorite: mapValueOfType<bool>(json, r'isFavorite')!,
       );
     }
     return null;
   }
 
-  static List<UploadBackupConfig> listFromJson(dynamic json, {bool growable = false,}) {
-    final result = <UploadBackupConfig>[];
+  static List<UpdateAlbumUserMetadataDto> listFromJson(dynamic json, {bool growable = false,}) {
+    final result = <UpdateAlbumUserMetadataDto>[];
     if (json is List && json.isNotEmpty) {
       for (final row in json) {
-        final value = UploadBackupConfig.fromJson(row);
+        final value = UpdateAlbumUserMetadataDto.fromJson(row);
         if (value != null) {
           result.add(value);
         }
@@ -65,12 +65,12 @@ class UploadBackupConfig {
     return result.toList(growable: growable);
   }
 
-  static Map<String, UploadBackupConfig> mapFromJson(dynamic json) {
-    final map = <String, UploadBackupConfig>{};
+  static Map<String, UpdateAlbumUserMetadataDto> mapFromJson(dynamic json) {
+    final map = <String, UpdateAlbumUserMetadataDto>{};
     if (json is Map && json.isNotEmpty) {
       json = json.cast<String, dynamic>(); // ignore: parameter_assignments
       for (final entry in json.entries) {
-        final value = UploadBackupConfig.fromJson(entry.value);
+        final value = UpdateAlbumUserMetadataDto.fromJson(entry.value);
         if (value != null) {
           map[entry.key] = value;
         }
@@ -79,14 +79,14 @@ class UploadBackupConfig {
     return map;
   }
 
-  // maps a json object with a list of UploadBackupConfig-objects as value to a dart map
-  static Map<String, List<UploadBackupConfig>> mapListFromJson(dynamic json, {bool growable = false,}) {
-    final map = <String, List<UploadBackupConfig>>{};
+  // maps a json object with a list of UpdateAlbumUserMetadataDto-objects as value to a dart map
+  static Map<String, List<UpdateAlbumUserMetadataDto>> mapListFromJson(dynamic json, {bool growable = false,}) {
+    final map = <String, List<UpdateAlbumUserMetadataDto>>{};
     if (json is Map && json.isNotEmpty) {
       // ignore: parameter_assignments
       json = json.cast<String, dynamic>();
       for (final entry in json.entries) {
-        map[entry.key] = UploadBackupConfig.listFromJson(entry.value, growable: growable,);
+        map[entry.key] = UpdateAlbumUserMetadataDto.listFromJson(entry.value, growable: growable,);
       }
     }
     return map;
@@ -94,7 +94,7 @@ class UploadBackupConfig {
 
   /// The list of required keys that must be present in a JSON.
   static const requiredKeys = <String>{
-    'maxAgeHours',
+    'isFavorite',
   };
 }
 

mobile/openapi/lib/model/upload_ok_dto.dart

@@ -1,99 +0,0 @@
-//
-// AUTO-GENERATED FILE, DO NOT MODIFY!
-//
-// @dart=2.18
-
-// ignore_for_file: unused_element, unused_import
-// ignore_for_file: always_put_required_named_parameters_first
-// ignore_for_file: constant_identifier_names
-// ignore_for_file: lines_longer_than_80_chars
-
-part of openapi.api;
-
-class UploadOkDto {
-  /// Returns a new [UploadOkDto] instance.
-  UploadOkDto({
-    required this.id,
-  });
-
-  String id;
-
-  @override
-  bool operator ==(Object other) => identical(this, other) || other is UploadOkDto &&
-    other.id == id;
-
-  @override
-  int get hashCode =>
-    // ignore: unnecessary_parenthesis
-    (id.hashCode);
-
-  @override
-  String toString() => 'UploadOkDto[id=$id]';
-
-  Map<String, dynamic> toJson() {
-    final json = <String, dynamic>{};
-      json[r'id'] = this.id;
-    return json;
-  }
-
-  /// Returns a new [UploadOkDto] instance and imports its values from
-  /// [value] if it's a [Map], null otherwise.
-  // ignore: prefer_constructors_over_static_methods
-  static UploadOkDto? fromJson(dynamic value) {
-    upgradeDto(value, "UploadOkDto");
-    if (value is Map) {
-      final json = value.cast<String, dynamic>();
-
-      return UploadOkDto(
-        id: mapValueOfType<String>(json, r'id')!,
-      );
-    }
-    return null;
-  }
-
-  static List<UploadOkDto> listFromJson(dynamic json, {bool growable = false,}) {
-    final result = <UploadOkDto>[];
-    if (json is List && json.isNotEmpty) {
-      for (final row in json) {
-        final value = UploadOkDto.fromJson(row);
-        if (value != null) {
-          result.add(value);
-        }
-      }
-    }
-    return result.toList(growable: growable);
-  }
-
-  static Map<String, UploadOkDto> mapFromJson(dynamic json) {
-    final map = <String, UploadOkDto>{};
-    if (json is Map && json.isNotEmpty) {
-      json = json.cast<String, dynamic>(); // ignore: parameter_assignments
-      for (final entry in json.entries) {
-        final value = UploadOkDto.fromJson(entry.value);
-        if (value != null) {
-          map[entry.key] = value;
-        }
-      }
-    }
-    return map;
-  }
-
-  // maps a json object with a list of UploadOkDto-objects as value to a dart map
-  static Map<String, List<UploadOkDto>> mapListFromJson(dynamic json, {bool growable = false,}) {
-    final map = <String, List<UploadOkDto>>{};
-    if (json is Map && json.isNotEmpty) {
-      // ignore: parameter_assignments
-      json = json.cast<String, dynamic>();
-      for (final entry in json.entries) {
-        map[entry.key] = UploadOkDto.listFromJson(entry.value, growable: growable,);
-      }
-    }
-    return map;
-  }
-
-  /// The list of required keys that must be present in a JSON.
-  static const requiredKeys = <String>{
-    'id',
-  };
-}
-

open-api/immich-openapi-specs.json

@@ -2221,6 +2221,72 @@
         "x-immich-state": "Stable"
       }
     },
+    "/albums/{id}/user-metadata": {
+      "patch": {
+        "description": "Update metadata for the authenticated user on a specific album.",
+        "operationId": "updateAlbumUserMetadata",
+        "parameters": [
+          {
+            "name": "id",
+            "required": true,
+            "in": "path",
+            "schema": {
+              "format": "uuid",
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/UpdateAlbumUserMetadataDto"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/AlbumResponseDto"
+                }
+              }
+            },
+            "description": ""
+          }
+        },
+        "security": [
+          {
+            "bearer": []
+          },
+          {
+            "cookie": []
+          },
+          {
+            "api_key": []
+          }
+        ],
+        "summary": "Update album user metadata",
+        "tags": [
+          "Albums"
+        ],
+        "x-immich-history": [
+          {
+            "version": "v2.7.0",
+            "state": "Added"
+          },
+          {
+            "version": "v2.7.0",
+            "state": "Beta"
+          }
+        ],
+        "x-immich-permission": "album.read",
+        "x-immich-state": "Beta"
+      }
+    },
     "/albums/{id}/user/{userId}": {
       "delete": {
         "description": "Remove a user from an album. Use an ID of \"me\" to leave a shared album.",
@@ -14046,320 +14112,6 @@
         "x-immich-state": "Stable"
       }
     },
-    "/upload": {
-      "options": {
-        "operationId": "getUploadOptions",
-        "parameters": [],
-        "responses": {
-          "204": {
-            "description": ""
-          }
-        },
-        "tags": [
-          "Upload"
-        ]
-      },
-      "post": {
-        "operationId": "startUpload",
-        "parameters": [
-          {
-            "name": "content-length",
-            "in": "header",
-            "description": "Non-negative size of the request body in bytes.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "key",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "repr-digest",
-            "in": "header",
-            "description": "RFC 9651 structured dictionary containing an `sha` (bytesequence) checksum used to detect duplicate files and validate data integrity.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "slug",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "upload-complete",
-            "in": "header",
-            "description": "Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.",
-            "required": false,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "upload-draft-interop-version",
-            "in": "header",
-            "description": "Indicates the version of the RUFH protocol supported by the client.",
-            "required": false,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "x-immich-asset-data",
-            "in": "header",
-            "description": "RFC 9651 structured dictionary containing asset metadata with the following keys:\n- device-asset-id (string, required): Unique device asset identifier\n- device-id (string, required): Device identifier\n- file-created-at (string/date, required): ISO 8601 date string or Unix timestamp\n- file-modified-at (string/date, required): ISO 8601 date string or Unix timestamp\n- filename (string, required): Original filename\n- is-favorite (boolean, optional): Favorite status\n- live-photo-video-id (string, optional): Live photo ID for assets from iOS devices\n- icloud-id (string, optional): iCloud identifier for assets from iOS devices",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UploadOkDto"
-                }
-              }
-            },
-            "description": ""
-          },
-          "201": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "bearer": []
-          },
-          {
-            "cookie": []
-          },
-          {
-            "api_key": []
-          }
-        ],
-        "tags": [
-          "Upload"
-        ],
-        "x-immich-permission": "asset.upload"
-      }
-    },
-    "/upload/{id}": {
-      "delete": {
-        "operationId": "cancelUpload",
-        "parameters": [
-          {
-            "name": "id",
-            "required": true,
-            "in": "path",
-            "schema": {
-              "format": "uuid",
-              "type": "string"
-            }
-          },
-          {
-            "name": "key",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "slug",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "bearer": []
-          },
-          {
-            "cookie": []
-          },
-          {
-            "api_key": []
-          }
-        ],
-        "tags": [
-          "Upload"
-        ],
-        "x-immich-permission": "asset.upload"
-      },
-      "head": {
-        "operationId": "getUploadStatus",
-        "parameters": [
-          {
-            "name": "id",
-            "required": true,
-            "in": "path",
-            "schema": {
-              "format": "uuid",
-              "type": "string"
-            }
-          },
-          {
-            "name": "key",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "slug",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "upload-draft-interop-version",
-            "in": "header",
-            "description": "Indicates the version of the RUFH protocol supported by the client.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "bearer": []
-          },
-          {
-            "cookie": []
-          },
-          {
-            "api_key": []
-          }
-        ],
-        "tags": [
-          "Upload"
-        ],
-        "x-immich-permission": "asset.upload"
-      },
-      "patch": {
-        "operationId": "resumeUpload",
-        "parameters": [
-          {
-            "name": "content-length",
-            "in": "header",
-            "description": "Non-negative size of the request body in bytes.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "id",
-            "required": true,
-            "in": "path",
-            "schema": {
-              "format": "uuid",
-              "type": "string"
-            }
-          },
-          {
-            "name": "key",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "slug",
-            "required": false,
-            "in": "query",
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "upload-complete",
-            "in": "header",
-            "description": "Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "upload-draft-interop-version",
-            "in": "header",
-            "description": "Indicates the version of the RUFH protocol supported by the client.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          },
-          {
-            "name": "upload-offset",
-            "in": "header",
-            "description": "Non-negative byte offset indicating the starting position of the data in the request body within the entire file.",
-            "required": true,
-            "schema": {
-              "type": "string"
-            }
-          }
-        ],
-        "responses": {
-          "200": {
-            "content": {
-              "application/json": {
-                "schema": {
-                  "$ref": "#/components/schemas/UploadOkDto"
-                }
-              }
-            },
-            "description": ""
-          }
-        },
-        "security": [
-          {
-            "bearer": []
-          },
-          {
-            "cookie": []
-          },
-          {
-            "api_key": []
-          }
-        ],
-        "tags": [
-          "Upload"
-        ],
-        "x-immich-permission": "asset.upload"
-      }
-    },
     "/users": {
       "get": {
         "description": "Retrieve a list of all users on the server.",
@@ -15984,6 +15736,10 @@
             "description": "Activity feed enabled",
             "type": "boolean"
           },
+          "isFavorite": {
+            "description": "Is favorite",
+            "type": "boolean"
+          },
           "lastModifiedAssetTimestamp": {
             "description": "Last modified asset timestamp",
             "format": "date-time",
@@ -16030,6 +15786,7 @@
           "hasSharedLink",
           "id",
           "isActivityEnabled",
+          "isFavorite",
           "owner",
           "ownerId",
           "shared",
@@ -18586,8 +18343,6 @@
           "AssetFileMigration",
           "AssetGenerateThumbnailsQueueAll",
           "AssetGenerateThumbnails",
-          "PartialAssetCleanup",
-          "PartialAssetCleanupQueueAll",
           "AuditLogCleanup",
           "AuditTableCleanup",
           "DatabaseBackup",
@@ -23061,6 +22816,45 @@
         ],
         "type": "object"
       },
+      "SyncAlbumUserMetadataDeleteV1": {
+        "properties": {
+          "albumId": {
+            "description": "Album ID",
+            "type": "string"
+          },
+          "userId": {
+            "description": "User ID",
+            "type": "string"
+          }
+        },
+        "required": [
+          "albumId",
+          "userId"
+        ],
+        "type": "object"
+      },
+      "SyncAlbumUserMetadataV1": {
+        "properties": {
+          "albumId": {
+            "description": "Album ID",
+            "type": "string"
+          },
+          "isFavorite": {
+            "description": "Is favorite",
+            "type": "boolean"
+          },
+          "userId": {
+            "description": "User ID",
+            "type": "string"
+          }
+        },
+        "required": [
+          "albumId",
+          "isFavorite",
+          "userId"
+        ],
+        "type": "object"
+      },
       "SyncAlbumUserV1": {
         "properties": {
           "albumId": {
@@ -23767,6 +23561,8 @@
           "AlbumUserV1",
           "AlbumUserBackfillV1",
           "AlbumUserDeleteV1",
+          "AlbumUserMetadataV1",
+          "AlbumUserMetadataDeleteV1",
           "AlbumAssetCreateV1",
           "AlbumAssetUpdateV1",
           "AlbumAssetBackfillV1",
@@ -24042,6 +23838,7 @@
         "enum": [
           "AlbumsV1",
           "AlbumUsersV1",
+          "AlbumUserMetadataV1",
           "AlbumToAssetsV1",
           "AlbumAssetsV1",
           "AlbumAssetExifsV1",
@@ -24247,14 +24044,10 @@
         "properties": {
           "database": {
             "$ref": "#/components/schemas/DatabaseBackupConfig"
-          },
-          "upload": {
-            "$ref": "#/components/schemas/UploadBackupConfig"
           }
         },
         "required": [
-          "database",
-          "upload"
+          "database"
         ],
         "type": "object"
       },
@@ -24844,9 +24637,6 @@
             "description": "Missing thumbnails",
             "type": "boolean"
           },
-          "removeStaleUploads": {
-            "type": "boolean"
-          },
           "startTime": {
             "type": "string"
           },
@@ -24860,7 +24650,6 @@
           "databaseCleanup",
           "generateMemories",
           "missingThumbnails",
-          "removeStaleUploads",
           "startTime",
           "syncQuotaUsage"
         ],
@@ -25731,6 +25520,18 @@
         ],
         "type": "object"
       },
+      "UpdateAlbumUserMetadataDto": {
+        "properties": {
+          "isFavorite": {
+            "description": "Favorite status",
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "isFavorite"
+        ],
+        "type": "object"
+      },
       "UpdateAssetDto": {
         "properties": {
           "dateTimeOriginal": {
@@ -25820,29 +25621,6 @@
         },
         "type": "object"
       },
-      "UploadBackupConfig": {
-        "properties": {
-          "maxAgeHours": {
-            "minimum": 1,
-            "type": "number"
-          }
-        },
-        "required": [
-          "maxAgeHours"
-        ],
-        "type": "object"
-      },
-      "UploadOkDto": {
-        "properties": {
-          "id": {
-            "type": "string"
-          }
-        },
-        "required": [
-          "id"
-        ],
-        "type": "object"
-      },
       "UsageByUserDto": {
         "properties": {
           "photos": {

open-api/typescript-sdk/src/fetch-client.ts

@@ -656,6 +656,8 @@ export type AlbumResponseDto = {
     id: string;
     /** Activity feed enabled */
     isActivityEnabled: boolean;
+    /** Is favorite */
+    isFavorite: boolean;
     /** Last modified asset timestamp */
     lastModifiedAssetTimestamp?: string;
     /** Asset sort order */
@@ -731,6 +733,10 @@ export type BulkIdResponseDto = {
     /** Whether operation succeeded */
     success: boolean;
 };
+export type UpdateAlbumUserMetadataDto = {
+    /** Favorite status */
+    isFavorite: boolean;
+};
 export type UpdateAlbumUserDto = {
     /** Album user role */
     role: AlbumUserRole;
@@ -2407,12 +2413,8 @@ export type DatabaseBackupConfig = {
     /** Keep last amount */
     keepLastAmount: number;
 };
-export type UploadBackupConfig = {
-    maxAgeHours: number;
-};
 export type SystemConfigBackupsDto = {
     database: DatabaseBackupConfig;
-    upload: UploadBackupConfig;
 };
 export type SystemConfigFFmpegDto = {
     /** Transcode hardware acceleration */
@@ -2602,7 +2604,6 @@ export type SystemConfigNightlyTasksDto = {
     generateMemories: boolean;
     /** Missing thumbnails */
     missingThumbnails: boolean;
-    removeStaleUploads: boolean;
     startTime: string;
     /** Sync quota usage */
     syncQuotaUsage: boolean;
@@ -2818,9 +2819,6 @@ export type TrashResponseDto = {
     /** Number of items in trash */
     count: number;
 };
-export type UploadOkDto = {
-    id: string;
-};
 export type UserUpdateMeDto = {
     /** Avatar color */
     avatarColor?: (UserAvatarColor) | null;
@@ -2958,6 +2956,20 @@ export type SyncAlbumUserDeleteV1 = {
     /** User ID */
     userId: string;
 };
+export type SyncAlbumUserMetadataDeleteV1 = {
+    /** Album ID */
+    albumId: string;
+    /** User ID */
+    userId: string;
+};
+export type SyncAlbumUserMetadataV1 = {
+    /** Album ID */
+    albumId: string;
+    /** Is favorite */
+    isFavorite: boolean;
+    /** User ID */
+    userId: string;
+};
 export type SyncAlbumUserV1 = {
     /** Album ID */
     albumId: string;
@@ -3832,6 +3844,22 @@ export function addAssetsToAlbum({ id, key, slug, bulkIdsDto }: {
         body: bulkIdsDto
     })));
 }
+/**
+ * Update album user metadata
+ */
+export function updateAlbumUserMetadata({ id, updateAlbumUserMetadataDto }: {
+    id: string;
+    updateAlbumUserMetadataDto: UpdateAlbumUserMetadataDto;
+}, opts?: Oazapfts.RequestOpts) {
+    return oazapfts.ok(oazapfts.fetchJson<{
+        status: 200;
+        data: AlbumResponseDto;
+    }>(`/albums/${encodeURIComponent(id)}/user-metadata`, oazapfts.json({
+        ...opts,
+        method: "PATCH",
+        body: updateAlbumUserMetadataDto
+    })));
+}
 /**
  * Remove user from album
  */
@@ -6573,97 +6601,6 @@ export function restoreAssets({ bulkIdsDto }: {
         body: bulkIdsDto
     })));
 }
-export function getUploadOptions(opts?: Oazapfts.RequestOpts) {
-    return oazapfts.ok(oazapfts.fetchText("/upload", {
-        ...opts,
-        method: "OPTIONS"
-    }));
-}
-export function startUpload({ contentLength, key, reprDigest, slug, uploadComplete, uploadDraftInteropVersion, xImmichAssetData }: {
-    contentLength: string;
-    key?: string;
-    reprDigest: string;
-    slug?: string;
-    uploadComplete?: string;
-    uploadDraftInteropVersion?: string;
-    xImmichAssetData: string;
-}, opts?: Oazapfts.RequestOpts) {
-    return oazapfts.ok(oazapfts.fetchJson<{
-        status: 200;
-        data: UploadOkDto;
-    } | {
-        status: 201;
-    }>(`/upload${QS.query(QS.explode({
-        key,
-        slug
-    }))}`, {
-        ...opts,
-        method: "POST",
-        headers: oazapfts.mergeHeaders(opts?.headers, {
-            "content-length": contentLength,
-            "repr-digest": reprDigest,
-            "upload-complete": uploadComplete,
-            "upload-draft-interop-version": uploadDraftInteropVersion,
-            "x-immich-asset-data": xImmichAssetData
-        })
-    }));
-}
-export function cancelUpload({ id, key, slug }: {
-    id: string;
-    key?: string;
-    slug?: string;
-}, opts?: Oazapfts.RequestOpts) {
-    return oazapfts.ok(oazapfts.fetchText(`/upload/${encodeURIComponent(id)}${QS.query(QS.explode({
-        key,
-        slug
-    }))}`, {
-        ...opts,
-        method: "DELETE"
-    }));
-}
-export function getUploadStatus({ id, key, slug, uploadDraftInteropVersion }: {
-    id: string;
-    key?: string;
-    slug?: string;
-    uploadDraftInteropVersion: string;
-}, opts?: Oazapfts.RequestOpts) {
-    return oazapfts.ok(oazapfts.fetchText(`/upload/${encodeURIComponent(id)}${QS.query(QS.explode({
-        key,
-        slug
-    }))}`, {
-        ...opts,
-        method: "HEAD",
-        headers: oazapfts.mergeHeaders(opts?.headers, {
-            "upload-draft-interop-version": uploadDraftInteropVersion
-        })
-    }));
-}
-export function resumeUpload({ contentLength, id, key, slug, uploadComplete, uploadDraftInteropVersion, uploadOffset }: {
-    contentLength: string;
-    id: string;
-    key?: string;
-    slug?: string;
-    uploadComplete: string;
-    uploadDraftInteropVersion: string;
-    uploadOffset: string;
-}, opts?: Oazapfts.RequestOpts) {
-    return oazapfts.ok(oazapfts.fetchJson<{
-        status: 200;
-        data: UploadOkDto;
-    }>(`/upload/${encodeURIComponent(id)}${QS.query(QS.explode({
-        key,
-        slug
-    }))}`, {
-        ...opts,
-        method: "PATCH",
-        headers: oazapfts.mergeHeaders(opts?.headers, {
-            "content-length": contentLength,
-            "upload-complete": uploadComplete,
-            "upload-draft-interop-version": uploadDraftInteropVersion,
-            "upload-offset": uploadOffset
-        })
-    }));
-}
 /**
  * Get all users
  */
@@ -7303,8 +7240,6 @@ export enum JobName {
     AssetFileMigration = "AssetFileMigration",
     AssetGenerateThumbnailsQueueAll = "AssetGenerateThumbnailsQueueAll",
     AssetGenerateThumbnails = "AssetGenerateThumbnails",
-    PartialAssetCleanup = "PartialAssetCleanup",
-    PartialAssetCleanupQueueAll = "PartialAssetCleanupQueueAll",
     AuditLogCleanup = "AuditLogCleanup",
     AuditTableCleanup = "AuditTableCleanup",
     DatabaseBackup = "DatabaseBackup",
@@ -7390,6 +7325,8 @@ export enum SyncEntityType {
     AlbumUserV1 = "AlbumUserV1",
     AlbumUserBackfillV1 = "AlbumUserBackfillV1",
     AlbumUserDeleteV1 = "AlbumUserDeleteV1",
+    AlbumUserMetadataV1 = "AlbumUserMetadataV1",
+    AlbumUserMetadataDeleteV1 = "AlbumUserMetadataDeleteV1",
     AlbumAssetCreateV1 = "AlbumAssetCreateV1",
     AlbumAssetUpdateV1 = "AlbumAssetUpdateV1",
     AlbumAssetBackfillV1 = "AlbumAssetBackfillV1",
@@ -7419,6 +7356,7 @@ export enum SyncEntityType {
 export enum SyncRequestType {
     AlbumsV1 = "AlbumsV1",
     AlbumUsersV1 = "AlbumUsersV1",
+    AlbumUserMetadataV1 = "AlbumUserMetadataV1",
     AlbumToAssetsV1 = "AlbumToAssetsV1",
     AlbumAssetsV1 = "AlbumAssetsV1",
     AlbumAssetExifsV1 = "AlbumAssetExifsV1",

pnpm-lock.yaml

@@ -67,7 +67,7 @@ importers:
         version: 24.12.0
       '@vitest/coverage-v8':
         specifier: ^4.0.0
-        version: 4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
+        version: 4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
       byte-size:
         specifier: ^9.0.0
         version: 9.0.1
@@ -112,10 +112,10 @@ importers:
         version: 8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
       vitest:
         specifier: ^4.0.0
-        version: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+        version: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
       vitest-fetch-mock:
         specifier: ^0.4.0
-        version: 0.4.5(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
+        version: 0.4.5(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
       yaml:
         specifier: ^2.3.1
         version: 2.8.3
@@ -270,9 +270,6 @@ importers:
       socket.io-client:
         specifier: ^4.7.4
         version: 4.8.3
-      structured-headers:
-        specifier: ^2.0.2
-        version: 2.0.2
       supertest:
         specifier: ^7.0.0
         version: 7.2.2
@@ -571,9 +568,6 @@ importers:
       socket.io:
         specifier: ^4.8.1
         version: 4.8.3
-      structured-headers:
-        specifier: ^2.0.2
-        version: 2.0.2
       tailwindcss-preset-email:
         specifier: ^1.4.0
         version: 1.4.1(tailwindcss@3.4.19(tsx@4.21.0)(yaml@2.8.3))
@@ -682,7 +676,7 @@ importers:
         version: 13.15.10
       '@vitest/coverage-v8':
         specifier: ^3.0.0
-        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+        version: 3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
       eslint:
         specifier: ^10.0.0
         version: 10.1.0(jiti@2.6.1)
@@ -739,7 +733,7 @@ importers:
         version: 6.1.1(typescript@5.9.3)(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
       vitest:
         specifier: ^3.0.0
-        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
 
   web:
     dependencies:
@@ -793,7 +787,7 @@ importers:
         version: 2.6.0
       fabric:
         specifier: ^7.0.0
-        version: 7.2.0(encoding@0.1.13)
+        version: 7.2.0
       geo-coordinates-parser:
         specifier: ^1.7.4
         version: 1.7.4
@@ -899,7 +893,7 @@ importers:
         version: 6.9.1
       '@testing-library/svelte':
         specifier: ^5.2.8
-        version: 5.3.1(svelte@5.54.1)(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
+        version: 5.3.1(svelte@5.54.1)(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
       '@testing-library/user-event':
         specifier: ^14.5.2
         version: 14.6.1(@testing-library/dom@10.4.1)
@@ -923,7 +917,7 @@ importers:
         version: 1.5.6
       '@vitest/coverage-v8':
         specifier: ^4.0.0
-        version: 4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
+        version: 4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))
       dotenv:
         specifier: ^17.0.0
         version: 17.3.1
@@ -986,7 +980,7 @@ importers:
         version: 8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
       vitest:
         specifier: ^4.0.0
-        version: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+        version: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
 
 packages:
 
@@ -11228,10 +11222,6 @@ packages:
     resolution: {integrity: sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==}
     engines: {node: '>=18'}
 
-  structured-headers@2.0.2:
-    resolution: {integrity: sha512-IUul56vVHuMg2UxWhwDj9zVJE6ztYEQQkynr1FQ/NydPhivtk5+Qb2N1RS36owEFk2fNUriTguJ2R7htRObcdA==}
-    engines: {node: '>=18', npm: '>=6'}
-
   style-mod@4.1.3:
     resolution: {integrity: sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==}
 
@@ -15463,6 +15453,22 @@ snapshots:
 
   '@mapbox/mapbox-gl-rtl-text@0.3.0': {}
 
+  '@mapbox/node-pre-gyp@1.0.11':
+    dependencies:
+      detect-libc: 2.1.2
+      https-proxy-agent: 5.0.1
+      make-dir: 3.1.0
+      node-fetch: 2.7.0
+      nopt: 5.0.0
+      npmlog: 5.0.1
+      rimraf: 3.0.2
+      semver: 7.7.4
+      tar: 6.2.1
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    optional: true
+
   '@mapbox/node-pre-gyp@1.0.11(encoding@0.1.13)':
     dependencies:
       detect-libc: 2.1.2
@@ -16824,14 +16830,14 @@ snapshots:
     dependencies:
       svelte: 5.54.1
 
-  '@testing-library/svelte@5.3.1(svelte@5.54.1)(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))':
+  '@testing-library/svelte@5.3.1(svelte@5.54.1)(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))':
     dependencies:
       '@testing-library/dom': 10.4.1
       '@testing-library/svelte-core': 1.0.0(svelte@5.54.1)
       svelte: 5.54.1
     optionalDependencies:
       vite: 8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
-      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
 
   '@testing-library/user-event@14.6.1(@testing-library/dom@10.4.1)':
     dependencies:
@@ -17530,7 +17536,7 @@ snapshots:
 
   '@vercel/oidc@3.0.5': {}
 
-  '@vitest/coverage-v8@3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))':
+  '@vitest/coverage-v8@3.2.4(vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))':
     dependencies:
       '@ampproject/remapping': 2.3.0
       '@bcoe/v8-coverage': 1.0.2
@@ -17545,11 +17551,11 @@ snapshots:
       std-env: 3.10.0
       test-exclude: 7.0.2
       tinyrainbow: 2.0.0
-      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
+      vitest: 3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
     transitivePeerDependencies:
       - supports-color
 
-  '@vitest/coverage-v8@4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))':
+  '@vitest/coverage-v8@4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))':
     dependencies:
       '@bcoe/v8-coverage': 1.0.2
       '@vitest/utils': 4.1.0
@@ -17561,9 +17567,9 @@ snapshots:
       obug: 2.1.1
       std-env: 4.0.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
 
-  '@vitest/coverage-v8@4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))':
+  '@vitest/coverage-v8@4.1.0(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)))':
     dependencies:
       '@bcoe/v8-coverage': 1.0.2
       '@vitest/utils': 4.1.0
@@ -17575,7 +17581,7 @@ snapshots:
       obug: 2.1.1
       std-env: 4.0.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
 
   '@vitest/expect@3.2.4':
     dependencies:
@@ -18342,6 +18348,16 @@ snapshots:
 
   caniuse-lite@1.0.30001776: {}
 
+  canvas@2.11.2:
+    dependencies:
+      '@mapbox/node-pre-gyp': 1.0.11
+      nan: 2.26.2
+      simple-get: 3.1.1
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    optional: true
+
   canvas@2.11.2(encoding@0.1.13):
     dependencies:
       '@mapbox/node-pre-gyp': 1.0.11(encoding@0.1.13)
@@ -19940,10 +19956,10 @@ snapshots:
 
   extend@3.0.2: {}
 
-  fabric@7.2.0(encoding@0.1.13):
+  fabric@7.2.0:
     optionalDependencies:
-      canvas: 2.11.2(encoding@0.1.13)
-      jsdom: 26.1.0(canvas@2.11.2(encoding@0.1.13))
+      canvas: 2.11.2
+      jsdom: 26.1.0(canvas@2.11.2)
     transitivePeerDependencies:
       - bufferutil
       - encoding
@@ -21132,6 +21148,36 @@ snapshots:
       - utf-8-validate
     optional: true
 
+  jsdom@26.1.0(canvas@2.11.2):
+    dependencies:
+      cssstyle: 4.6.0
+      data-urls: 5.0.0
+      decimal.js: 10.6.0
+      html-encoding-sniffer: 4.0.0
+      http-proxy-agent: 7.0.2
+      https-proxy-agent: 7.0.6
+      is-potential-custom-element-name: 1.0.1
+      nwsapi: 2.2.23
+      parse5: 7.3.0
+      rrweb-cssom: 0.8.0
+      saxes: 6.0.0
+      symbol-tree: 3.2.4
+      tough-cookie: 5.1.2
+      w3c-xmlserializer: 5.0.0
+      webidl-conversions: 7.0.0
+      whatwg-encoding: 3.1.1
+      whatwg-mimetype: 4.0.0
+      whatwg-url: 14.2.0
+      ws: 8.20.0
+      xml-name-validator: 5.0.0
+    optionalDependencies:
+      canvas: 2.11.2
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+    optional: true
+
   jsep@1.4.0: {}
 
   jsesc@3.1.0: {}
@@ -22362,6 +22408,11 @@ snapshots:
       emojilib: 2.4.0
       skin-tone: 2.0.0
 
+  node-fetch@2.7.0:
+    dependencies:
+      whatwg-url: 5.0.0
+    optional: true
+
   node-fetch@2.7.0(encoding@0.1.13):
     dependencies:
       whatwg-url: 5.0.0
@@ -24538,8 +24589,6 @@ snapshots:
     dependencies:
       '@tokenizer/token': 0.3.0
 
-  structured-headers@2.0.2: {}
-
   style-mod@4.1.3: {}
 
   style-to-js@1.1.21:
@@ -25498,11 +25547,11 @@ snapshots:
     optionalDependencies:
       vite: 8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
 
-  vitest-fetch-mock@0.4.5(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))):
+  vitest-fetch-mock@0.4.5(vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))):
     dependencies:
-      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+      vitest: 4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
 
-  vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3):
+  vitest@3.2.4(@types/debug@4.1.12)(@types/node@24.12.0)(happy-dom@20.8.4)(jiti@2.6.1)(jsdom@26.1.0(canvas@2.11.2))(lightningcss@1.32.0)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3):
     dependencies:
       '@types/chai': 5.2.3
       '@vitest/expect': 3.2.4
@@ -25531,7 +25580,7 @@ snapshots:
       '@types/debug': 4.1.12
       '@types/node': 24.12.0
       happy-dom: 20.8.4
-      jsdom: 26.1.0(canvas@2.11.2(encoding@0.1.13))
+      jsdom: 26.1.0(canvas@2.11.2)
     transitivePeerDependencies:
       - jiti
       - less
@@ -25576,7 +25625,37 @@ snapshots:
     transitivePeerDependencies:
       - msw
 
-  vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2(encoding@0.1.13)))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)):
+  vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@24.12.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)):
+    dependencies:
+      '@vitest/expect': 4.1.0
+      '@vitest/mocker': 4.1.0(vite@8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
+      '@vitest/pretty-format': 4.1.0
+      '@vitest/runner': 4.1.0
+      '@vitest/snapshot': 4.1.0
+      '@vitest/spy': 4.1.0
+      '@vitest/utils': 4.1.0
+      es-module-lexer: 2.0.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.1
+      pathe: 2.0.3
+      picomatch: 4.0.4
+      std-env: 4.0.0
+      tinybench: 2.9.0
+      tinyexec: 1.0.4
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.1.0
+      vite: 8.0.1(@types/node@24.12.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@opentelemetry/api': 1.9.0
+      '@types/node': 24.12.0
+      happy-dom: 20.8.4
+      jsdom: 26.1.0(canvas@2.11.2)
+    transitivePeerDependencies:
+      - msw
+
+  vitest@4.1.0(@opentelemetry/api@1.9.0)(@types/node@25.5.0)(happy-dom@20.8.4)(jsdom@26.1.0(canvas@2.11.2))(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3)):
     dependencies:
       '@vitest/expect': 4.1.0
       '@vitest/mocker': 4.1.0(vite@8.0.1(@types/node@25.5.0)(esbuild@0.27.4)(jiti@2.6.1)(sass@1.97.1)(terser@5.44.1)(tsx@4.21.0)(yaml@2.8.3))
@@ -25602,7 +25681,7 @@ snapshots:
       '@opentelemetry/api': 1.9.0
       '@types/node': 25.5.0
       happy-dom: 20.8.4
-      jsdom: 26.1.0(canvas@2.11.2(encoding@0.1.13))
+      jsdom: 26.1.0(canvas@2.11.2)
     transitivePeerDependencies:
       - msw
 

server/package.json

@@ -115,7 +115,6 @@
     "sharp": "^0.34.5",
     "sirv": "^3.0.0",
     "socket.io": "^4.8.1",
-    "structured-headers": "^2.0.2",
     "tailwindcss-preset-email": "^1.4.0",
     "thumbhash": "^0.1.1",
     "transformation-matrix": "^3.1.0",

server/src/config.ts

@@ -22,9 +22,6 @@ export type SystemConfig = {
       cronExpression: string;
       keepLastAmount: number;
     };
-    upload: {
-      maxAgeHours: number;
-    };
   };
   ffmpeg: {
     crf: number;
@@ -143,7 +140,6 @@ export type SystemConfig = {
     clusterNewFaces: boolean;
     generateMemories: boolean;
     syncQuotaUsage: boolean;
-    removeStaleUploads: boolean;
   };
   trash: {
     enabled: boolean;
@@ -202,9 +198,6 @@ export const defaults = Object.freeze<SystemConfig>({
       cronExpression: CronExpression.EVERY_DAY_AT_2AM,
       keepLastAmount: 14,
     },
-    upload: {
-      maxAgeHours: 72,
-    },
   },
   ffmpeg: {
     crf: 23,
@@ -353,7 +346,6 @@ export const defaults = Object.freeze<SystemConfig>({
     syncQuotaUsage: true,
     missingThumbnails: true,
     clusterNewFaces: true,
-    removeStaleUploads: true,
   },
   trash: {
     enabled: true,

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

@@ -79,6 +79,21 @@ describe(AlbumController.name, () => {
     });
   });
 
+  describe('PATCH /albums/:id/user-metadata', () => {
+    it('should be an authenticated route', async () => {
+      await request(ctx.getHttpServer()).patch(`/albums/${factory.uuid()}/user-metadata`).send({ isFavorite: true });
+      expect(ctx.authenticate).toHaveBeenCalled();
+    });
+
+    it('should reject an invalid favorite payload', async () => {
+      const { status, body } = await request(ctx.getHttpServer())
+        .patch(`/albums/${factory.uuid()}/user-metadata`)
+        .send({ isFavorite: 'invalid' });
+      expect(status).toEqual(400);
+      expect(body).toEqual(factory.responses.badRequest(['isFavorite must be a boolean value']));
+    });
+  });
+
   describe('DELETE /albums/:id/assets', () => {
     it('should be an authenticated route', async () => {
       await request(ctx.getHttpServer()).delete(`/albums/${factory.uuid()}/assets`);

server/src/controllers/album.controller.ts

@@ -12,6 +12,7 @@ import {
   GetAlbumsDto,
   UpdateAlbumDto,
   UpdateAlbumUserDto,
+  UpdateAlbumUserMetadataDto,
 } from 'src/dtos/album.dto';
 import { BulkIdResponseDto, BulkIdsDto } from 'src/dtos/asset-ids.response.dto';
 import { AuthDto } from 'src/dtos/auth.dto';
@@ -89,6 +90,21 @@ export class AlbumController {
     return this.service.update(auth, id, dto);
   }
 
+  @Patch(':id/user-metadata')
+  @Authenticated({ permission: Permission.AlbumRead })
+  @Endpoint({
+    summary: 'Update album user metadata',
+    description: 'Update metadata for the authenticated user on a specific album.',
+    history: new HistoryBuilder().added('v2.7.0').beta('v2.7.0'),
+  })
+  updateAlbumUserMetadata(
+    @Auth() auth: AuthDto,
+    @Param() { id }: UUIDParamDto,
+    @Body() dto: UpdateAlbumUserMetadataDto,
+  ): Promise<AlbumResponseDto> {
+    return this.service.updateAlbumUserMetadata(auth, id, dto);
+  }
+
   @Delete(':id')
   @Authenticated({ permission: Permission.AlbumDelete })
   @HttpCode(HttpStatus.NO_CONTENT)

server/src/controllers/asset-upload.controller.spec.ts

@@ -1,445 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { AssetUploadController } from 'src/controllers/asset-upload.controller';
-import { AssetUploadService } from 'src/services/asset-upload.service';
-import { serializeDictionary } from 'structured-headers';
-import request from 'supertest';
-import { factory } from 'test/small.factory';
-import { ControllerContext, controllerSetup, mockBaseService } from 'test/utils';
-
-const makeAssetData = (overrides?: Partial<any>): string => {
-  return serializeDictionary({
-    filename: 'test-image.jpg',
-    'device-asset-id': 'test-asset-id',
-    'device-id': 'test-device',
-    'file-created-at': new Date('2025-01-02T00:00:00Z').toISOString(),
-    'file-modified-at': new Date('2025-01-01T00:00:00Z').toISOString(),
-    'is-favorite': false,
-    ...overrides,
-  });
-};
-
-describe(AssetUploadController.name, () => {
-  let ctx: ControllerContext;
-  let buffer: Buffer;
-  let checksum: string;
-  const service = mockBaseService(AssetUploadService);
-
-  beforeAll(async () => {
-    ctx = await controllerSetup(AssetUploadController, [{ provide: AssetUploadService, useValue: service }]);
-    return () => ctx.close();
-  });
-
-  beforeEach(() => {
-    service.resetAllMocks();
-    service.startUpload.mockImplementation((_, __, res, ___) => {
-      res.send();
-      return Promise.resolve();
-    });
-    service.resumeUpload.mockImplementation((_, __, res, ___, ____) => {
-      res.send();
-      return Promise.resolve();
-    });
-    service.cancelUpload.mockImplementation((_, __, res) => {
-      res.send();
-      return Promise.resolve();
-    });
-    service.getUploadStatus.mockImplementation((_, res, __, ___) => {
-      res.send();
-      return Promise.resolve();
-    });
-    ctx.reset();
-
-    buffer = Buffer.from(randomUUID());
-    checksum = `sha=:${createHash('sha1').update(buffer).digest('base64')}:`;
-  });
-
-  describe('POST /upload', () => {
-    it('should be an authenticated route', async () => {
-      await request(ctx.getHttpServer()).post('/upload');
-      expect(ctx.authenticate).toHaveBeenCalled();
-    });
-
-    it('should require at least version 3 of Upload-Draft-Interop-Version header if provided', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Upload-Draft-Interop-Version', '2')
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining(['version must not be less than 3']),
-        }),
-      );
-    });
-
-    it('should require X-Immich-Asset-Data header', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'x-immich-asset-data header is required' }));
-    });
-
-    it('should require Repr-Digest header', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'Missing repr-digest header' }));
-    });
-
-    it('should allow conventional upload without Upload-Complete header', async () => {
-      const { status } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Repr-Digest', checksum)
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(201);
-    });
-
-    it('should require Upload-Length header for incomplete upload', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?0')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'Missing upload-length header' }));
-    });
-
-    it('should infer upload length from content length if complete upload', async () => {
-      const { status } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .send(buffer);
-
-      expect(status).toBe(201);
-    });
-
-    it('should reject invalid Repr-Digest format', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', checksum)
-        .set('Repr-Digest', 'invalid-format')
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'Invalid repr-digest header' }));
-    });
-
-    it('should validate device-asset-id is required in asset data', async () => {
-      const assetData = serializeDictionary({
-        filename: 'test.jpg',
-        'device-id': 'test-device',
-        'file-created-at': new Date().toISOString(),
-        'file-modified-at': new Date().toISOString(),
-      });
-
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', assetData)
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining([expect.stringContaining('deviceAssetId')]),
-        }),
-      );
-    });
-
-    it('should validate device-id is required in asset data', async () => {
-      const assetData = serializeDictionary({
-        filename: 'test.jpg',
-        'device-asset-id': 'test-asset',
-        'file-created-at': new Date().toISOString(),
-        'file-modified-at': new Date().toISOString(),
-      });
-
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', assetData)
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining([expect.stringContaining('deviceId')]),
-        }),
-      );
-    });
-
-    it('should validate filename is required in asset data', async () => {
-      const assetData = serializeDictionary({
-        'device-asset-id': 'test-asset',
-        'device-id': 'test-device',
-        'file-created-at': new Date().toISOString(),
-        'file-modified-at': new Date().toISOString(),
-      });
-
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', assetData)
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining([expect.stringContaining('filename')]),
-        }),
-      );
-    });
-
-    it('should accept Upload-Incomplete header for version 3', async () => {
-      const { body, status } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '3')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Repr-Digest', checksum)
-        .set('Upload-Incomplete', '?0')
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(body).toEqual({});
-      expect(status).not.toBe(400);
-    });
-
-    it('should validate Upload-Complete is a boolean structured field', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', 'true')
-        .set('Upload-Length', '1024')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: 'upload-complete must be a structured boolean value' }));
-    });
-
-    it('should validate Upload-Length is a positive integer', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .post('/upload')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('X-Immich-Asset-Data', makeAssetData())
-        .set('Repr-Digest', checksum)
-        .set('Upload-Complete', '?1')
-        .set('Upload-Length', '-100')
-        .send(buffer);
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining(['uploadLength must not be less than 1']),
-        }),
-      );
-    });
-  });
-
-  describe('PATCH /upload/:id', () => {
-    const uploadId = factory.uuid();
-
-    it('should be an authenticated route', async () => {
-      await request(ctx.getHttpServer()).patch(`/upload/${uploadId}`);
-      expect(ctx.authenticate).toHaveBeenCalled();
-    });
-
-    it('should require Upload-Draft-Interop-Version header', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Offset', '0')
-        .set('Upload-Complete', '?1')
-        .send(Buffer.from('test'));
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining(['version must be an integer number', 'version must not be less than 3']),
-        }),
-      );
-    });
-
-    it('should require Upload-Offset header', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('Upload-Complete', '?1')
-        .send(Buffer.from('test'));
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining([
-            'uploadOffset must be an integer number',
-            'uploadOffset must not be less than 0',
-          ]),
-        }),
-      );
-    });
-
-    it('should require Upload-Complete header', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('Upload-Offset', '0')
-        .set('Content-Type', 'application/partial-upload')
-        .send(Buffer.from('test'));
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: ['uploadComplete must be a boolean value'] }));
-    });
-
-    it('should validate UUID parameter', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .patch('/upload/invalid-uuid')
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('Upload-Offset', '0')
-        .set('Upload-Complete', '?0')
-        .send(Buffer.from('test'));
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: ['id must be a UUID'] }));
-    });
-
-    it('should validate Upload-Offset is a non-negative integer', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Draft-Interop-Version', '8')
-        .set('Upload-Offset', '-50')
-        .set('Upload-Complete', '?0')
-        .send(Buffer.from('test'));
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining(['uploadOffset must not be less than 0']),
-        }),
-      );
-    });
-
-    it('should require Content-Type: application/partial-upload for version >= 6', async () => {
-      const { status, body } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Draft-Interop-Version', '6')
-        .set('Upload-Offset', '0')
-        .set('Upload-Complete', '?0')
-        .set('Content-Type', 'application/octet-stream')
-        .send(Buffer.from('test'));
-
-      expect(status).toBe(400);
-      expect(body).toEqual(
-        expect.objectContaining({
-          message: ['contentType must be equal to application/partial-upload'],
-        }),
-      );
-    });
-
-    it('should allow other Content-Type for version < 6', async () => {
-      const { body } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Draft-Interop-Version', '3')
-        .set('Upload-Offset', '0')
-        .set('Upload-Incomplete', '?1')
-        .set('Content-Type', 'application/octet-stream')
-        .send();
-
-      // Will fail for other reasons, but not content-type validation
-      expect(body).not.toEqual(
-        expect.objectContaining({
-          message: expect.arrayContaining([expect.stringContaining('contentType')]),
-        }),
-      );
-    });
-
-    it('should accept Upload-Incomplete header for version 3', async () => {
-      const { status } = await request(ctx.getHttpServer())
-        .patch(`/upload/${uploadId}`)
-        .set('Upload-Draft-Interop-Version', '3')
-        .set('Upload-Offset', '0')
-        .set('Upload-Incomplete', '?1')
-        .send();
-
-      // Should not fail validation
-      expect(status).not.toBe(400);
-    });
-  });
-
-  describe('DELETE /upload/:id', () => {
-    const uploadId = factory.uuid();
-
-    it('should be an authenticated route', async () => {
-      await request(ctx.getHttpServer()).delete(`/upload/${uploadId}`);
-      expect(ctx.authenticate).toHaveBeenCalled();
-    });
-
-    it('should validate UUID parameter', async () => {
-      const { status, body } = await request(ctx.getHttpServer()).delete('/upload/invalid-uuid');
-
-      expect(status).toBe(400);
-      expect(body).toEqual(expect.objectContaining({ message: ['id must be a UUID'] }));
-    });
-  });
-
-  describe('HEAD /upload/:id', () => {
-    const uploadId = factory.uuid();
-
-    it('should be an authenticated route', async () => {
-      await request(ctx.getHttpServer()).head(`/upload/${uploadId}`);
-      expect(ctx.authenticate).toHaveBeenCalled();
-    });
-
-    it('should require Upload-Draft-Interop-Version header', async () => {
-      const { status } = await request(ctx.getHttpServer()).head(`/upload/${uploadId}`);
-
-      expect(status).toBe(400);
-    });
-
-    it('should validate UUID parameter', async () => {
-      const { status } = await request(ctx.getHttpServer())
-        .head('/upload/invalid-uuid')
-        .set('Upload-Draft-Interop-Version', '8');
-
-      expect(status).toBe(400);
-    });
-  });
-});

server/src/controllers/asset-upload.controller.ts

@@ -1,108 +0,0 @@
-import { Controller, Delete, Head, HttpCode, HttpStatus, Options, Param, Patch, Post, Req, Res } from '@nestjs/common';
-import { ApiHeader, ApiOkResponse, ApiTags } from '@nestjs/swagger';
-import { Request, Response } from 'express';
-import { GetUploadStatusDto, Header, ResumeUploadDto, StartUploadDto, UploadOkDto } from 'src/dtos/asset-upload.dto';
-import { AuthDto } from 'src/dtos/auth.dto';
-import { ImmichHeader, Permission } from 'src/enum';
-import { Auth, Authenticated } from 'src/middleware/auth.guard';
-import { AssetUploadService } from 'src/services/asset-upload.service';
-import { validateSyncOrReject } from 'src/utils/request';
-import { UUIDParamDto } from 'src/validation';
-
-const apiInteropVersion = {
-  name: Header.InteropVersion,
-  description: `Indicates the version of the RUFH protocol supported by the client.`,
-  required: true,
-};
-
-const apiUploadComplete = {
-  name: Header.UploadComplete,
-  description:
-    'Structured boolean indicating whether this request completes the file. Use Upload-Incomplete instead for version <= 3.',
-  required: true,
-};
-
-const apiContentLength = {
-  name: Header.ContentLength,
-  description: 'Non-negative size of the request body in bytes.',
-  required: true,
-};
-
-// This is important to let go of the asset lock for an inactive request
-const SOCKET_TIMEOUT_MS = 30_000;
-
-@ApiTags('Upload')
-@Controller('upload')
-export class AssetUploadController {
-  constructor(private service: AssetUploadService) {}
-
-  @Post()
-  @Authenticated({ sharedLink: true, permission: Permission.AssetUpload })
-  @ApiHeader({
-    name: ImmichHeader.AssetData,
-    description: `RFC 9651 structured dictionary containing asset metadata with the following keys:
-- device-asset-id (string, required): Unique device asset identifier
-- device-id (string, required): Device identifier
-- file-created-at (string/date, required): ISO 8601 date string or Unix timestamp
-- file-modified-at (string/date, required): ISO 8601 date string or Unix timestamp
-- filename (string, required): Original filename
-- is-favorite (boolean, optional): Favorite status
-- live-photo-video-id (string, optional): Live photo ID for assets from iOS devices
-- icloud-id (string, optional): iCloud identifier for assets from iOS devices`,
-    required: true,
-    example:
-      'device-asset-id="abc123", device-id="phone1", filename="photo.jpg", file-created-at="2024-01-01T00:00:00Z", file-modified-at="2024-01-01T00:00:00Z"',
-  })
-  @ApiHeader({
-    name: Header.ReprDigest,
-    description:
-      'RFC 9651 structured dictionary containing an `sha` (bytesequence) checksum used to detect duplicate files and validate data integrity.',
-    required: true,
-  })
-  @ApiHeader({ ...apiInteropVersion, required: false })
-  @ApiHeader({ ...apiUploadComplete, required: false })
-  @ApiHeader(apiContentLength)
-  @ApiOkResponse({ type: UploadOkDto })
-  startUpload(@Auth() auth: AuthDto, @Req() req: Request, @Res() res: Response): Promise<void> {
-    res.setTimeout(SOCKET_TIMEOUT_MS);
-    return this.service.startUpload(auth, req, res, validateSyncOrReject(StartUploadDto, req.headers));
-  }
-
-  @Patch(':id')
-  @Authenticated({ sharedLink: true, permission: Permission.AssetUpload })
-  @ApiHeader({
-    name: Header.UploadOffset,
-    description:
-      'Non-negative byte offset indicating the starting position of the data in the request body within the entire file.',
-    required: true,
-  })
-  @ApiHeader(apiInteropVersion)
-  @ApiHeader(apiUploadComplete)
-  @ApiHeader(apiContentLength)
-  @ApiOkResponse({ type: UploadOkDto })
-  resumeUpload(@Auth() auth: AuthDto, @Req() req: Request, @Res() res: Response, @Param() { id }: UUIDParamDto) {
-    res.setTimeout(SOCKET_TIMEOUT_MS);
-    return this.service.resumeUpload(auth, req, res, id, validateSyncOrReject(ResumeUploadDto, req.headers));
-  }
-
-  @Delete(':id')
-  @Authenticated({ sharedLink: true, permission: Permission.AssetUpload })
-  cancelUpload(@Auth() auth: AuthDto, @Res() res: Response, @Param() { id }: UUIDParamDto) {
-    res.setTimeout(SOCKET_TIMEOUT_MS);
-    return this.service.cancelUpload(auth, id, res);
-  }
-
-  @Head(':id')
-  @Authenticated({ sharedLink: true, permission: Permission.AssetUpload })
-  @ApiHeader(apiInteropVersion)
-  getUploadStatus(@Auth() auth: AuthDto, @Req() req: Request, @Res() res: Response, @Param() { id }: UUIDParamDto) {
-    res.setTimeout(SOCKET_TIMEOUT_MS);
-    return this.service.getUploadStatus(auth, res, id, validateSyncOrReject(GetUploadStatusDto, req.headers));
-  }
-
-  @Options()
-  @HttpCode(HttpStatus.NO_CONTENT)
-  getUploadOptions(@Res() res: Response) {
-    return this.service.getUploadOptions(res);
-  }
-}

server/src/controllers/index.ts

@@ -3,7 +3,6 @@ import { AlbumController } from 'src/controllers/album.controller';
 import { ApiKeyController } from 'src/controllers/api-key.controller';
 import { AppController } from 'src/controllers/app.controller';
 import { AssetMediaController } from 'src/controllers/asset-media.controller';
-import { AssetUploadController } from 'src/controllers/asset-upload.controller';
 import { AssetController } from 'src/controllers/asset.controller';
 import { AuthAdminController } from 'src/controllers/auth-admin.controller';
 import { AuthController } from 'src/controllers/auth.controller';
@@ -46,7 +45,6 @@ export const controllers = [
   AppController,
   AssetController,
   AssetMediaController,
-  AssetUploadController,
   AuthController,
   AuthAdminController,
   DatabaseBackupController,

server/src/database.ts

@@ -403,6 +403,11 @@ export const columns = {
     'asset.isEdited',
   ],
   syncAlbumUser: ['album_user.albumId as albumId', 'album_user.userId as userId', 'album_user.role'],
+  syncAlbumUserMetadata: [
+    'album_user_metadata.albumId as albumId',
+    'album_user_metadata.userId as userId',
+    'album_user_metadata.isFavorite',
+  ],
   syncStack: ['stack.id', 'stack.createdAt', 'stack.updatedAt', 'stack.primaryAssetId', 'stack.ownerId'],
   syncUser: ['id', 'name', 'email', 'avatarColor', 'deletedAt', 'updateId', 'profileImagePath', 'profileChangedAt'],
   stack: ['stack.id', 'stack.primaryAssetId', 'ownerId'],

server/src/dtos/album-response.dto.spec.ts

@@ -20,4 +20,14 @@ describe('mapAlbum', () => {
     expect(dto.startDate).toBeUndefined();
     expect(dto.endDate).toBeUndefined();
   });
+
+  it('should default isFavorite to false', () => {
+    const dto = mapAlbum(getForAlbum(AlbumFactory.create()), false);
+    expect(dto.isFavorite).toBe(false);
+  });
+
+  it('should preserve a provided favorite state', () => {
+    const dto = mapAlbum({ ...getForAlbum(AlbumFactory.create()), isFavorite: true }, false);
+    expect(dto.isFavorite).toBe(true);
+  });
 });

server/src/dtos/album.dto.ts

@@ -102,6 +102,11 @@ export class UpdateAlbumDto {
   order?: AssetOrder;
 }
 
+export class UpdateAlbumUserMetadataDto {
+  @ValidateBoolean({ description: 'Favorite status' })
+  isFavorite!: boolean;
+}
+
 export class GetAlbumsDto {
   @ValidateBoolean({
     optional: true,
@@ -183,6 +188,8 @@ export class AlbumResponseDto {
   endDate?: string;
   @ApiProperty({ description: 'Activity feed enabled' })
   isActivityEnabled!: boolean;
+  @ApiProperty({ description: 'Is favorite' })
+  isFavorite!: boolean;
   @ValidateEnum({ enum: AssetOrder, name: 'AssetOrder', description: 'Asset sort order', optional: true })
   order?: AssetOrder;
 
@@ -205,6 +212,7 @@ export type MapAlbumDto = {
   ownerId: string;
   owner: ShallowDehydrateObject<User>;
   isActivityEnabled: boolean;
+  isFavorite?: boolean;
   order: AssetOrder;
 };
 
@@ -256,6 +264,7 @@ export const mapAlbum = (
     assets: (withAssets ? assets : []).map((asset) => mapAsset(asset, { auth })),
     assetCount: entity.assets?.length || 0,
     isActivityEnabled: entity.isActivityEnabled,
+    isFavorite: auth?.sharedLink ? false : (entity.isFavorite ?? false),
     order: entity.order,
   };
 };

server/src/dtos/asset-upload.dto.ts

@@ -1,196 +0,0 @@
-import { BadRequestException } from '@nestjs/common';
-import { ApiProperty } from '@nestjs/swagger';
-import { Expose, plainToInstance, Transform, Type } from 'class-transformer';
-import { Equals, IsBoolean, IsInt, IsNotEmpty, IsString, Min, ValidateIf, ValidateNested } from 'class-validator';
-import { ImmichHeader } from 'src/enum';
-import { Optional, ValidateBoolean, ValidateDate } from 'src/validation';
-import { parseDictionary } from 'structured-headers';
-
-export enum Header {
-  ContentLength = 'content-length',
-  ContentType = 'content-type',
-  InteropVersion = 'upload-draft-interop-version',
-  ReprDigest = 'repr-digest',
-  UploadComplete = 'upload-complete',
-  UploadIncomplete = 'upload-incomplete',
-  UploadLength = 'upload-length',
-  UploadOffset = 'upload-offset',
-}
-
-export class UploadAssetDataDto {
-  @IsNotEmpty()
-  @IsString()
-  deviceAssetId!: string;
-
-  @IsNotEmpty()
-  @IsString()
-  deviceId!: string;
-
-  @ValidateDate()
-  fileCreatedAt!: Date;
-
-  @ValidateDate()
-  fileModifiedAt!: Date;
-
-  @IsString()
-  @IsNotEmpty()
-  filename!: string;
-
-  @ValidateBoolean({ optional: true })
-  isFavorite?: boolean;
-
-  @Optional()
-  @IsString()
-  @IsNotEmpty()
-  livePhotoVideoId?: string;
-
-  @Optional()
-  @IsString()
-  @IsNotEmpty()
-  iCloudId!: string;
-}
-
-export class BaseUploadHeadersDto {
-  @Expose({ name: Header.ContentLength })
-  @Min(0)
-  @IsInt()
-  @Type(() => Number)
-  contentLength!: number;
-}
-
-export class StartUploadDto extends BaseUploadHeadersDto {
-  @Expose({ name: Header.InteropVersion })
-  @Optional()
-  @Min(3)
-  @IsInt()
-  @Type(() => Number)
-  version?: number;
-
-  @Expose({ name: ImmichHeader.AssetData })
-  @ValidateNested()
-  @Transform(({ value }) => {
-    if (!value) {
-      throw new BadRequestException(`${ImmichHeader.AssetData} header is required`);
-    }
-
-    try {
-      const dict = parseDictionary(value);
-      return plainToInstance(UploadAssetDataDto, {
-        deviceAssetId: dict.get('device-asset-id')?.[0],
-        deviceId: dict.get('device-id')?.[0],
-        filename: dict.get('filename')?.[0],
-        duration: dict.get('duration')?.[0],
-        fileCreatedAt: dict.get('file-created-at')?.[0],
-        fileModifiedAt: dict.get('file-modified-at')?.[0],
-        isFavorite: dict.get('is-favorite')?.[0],
-        livePhotoVideoId: dict.get('live-photo-video-id')?.[0],
-        iCloudId: dict.get('icloud-id')?.[0],
-      });
-    } catch {
-      throw new BadRequestException(`${ImmichHeader.AssetData} must be a valid structured dictionary`);
-    }
-  })
-  assetData!: UploadAssetDataDto;
-
-  @Expose({ name: Header.ReprDigest })
-  @Transform(({ value }) => {
-    if (!value) {
-      throw new BadRequestException(`Missing ${Header.ReprDigest} header`);
-    }
-
-    const checksum = parseDictionary(value).get('sha')?.[0];
-    if (checksum instanceof ArrayBuffer && checksum.byteLength === 20) {
-      return Buffer.from(checksum);
-    }
-    throw new BadRequestException(`Invalid ${Header.ReprDigest} header`);
-  })
-  checksum!: Buffer;
-
-  @Expose()
-  @Min(1)
-  @IsInt()
-  @Transform(({ obj }) => {
-    const uploadLength = obj[Header.UploadLength];
-    if (uploadLength != undefined) {
-      return Number(uploadLength);
-    }
-
-    const contentLength = obj[Header.ContentLength];
-    if (contentLength && isUploadComplete(obj) !== false) {
-      return Number(contentLength);
-    }
-    throw new BadRequestException(`Missing ${Header.UploadLength} header`);
-  })
-  uploadLength!: number;
-
-  @Expose()
-  @Transform(({ obj }) => isUploadComplete(obj))
-  uploadComplete?: boolean;
-}
-
-export class ResumeUploadDto extends BaseUploadHeadersDto {
-  @Expose({ name: Header.InteropVersion })
-  @Min(3)
-  @IsInt()
-  @Type(() => Number)
-  version!: number;
-
-  @Expose({ name: Header.ContentType })
-  @ValidateIf((o) => o.version && o.version >= 6)
-  @Equals('application/partial-upload')
-  contentType!: string;
-
-  @Expose({ name: Header.UploadLength })
-  @Min(1)
-  @IsInt()
-  @Type(() => Number)
-  @Optional()
-  uploadLength?: number;
-
-  @Expose({ name: Header.UploadOffset })
-  @Min(0)
-  @IsInt()
-  @Type(() => Number)
-  uploadOffset!: number;
-
-  @Expose()
-  @IsBoolean()
-  @Transform(({ obj }) => isUploadComplete(obj))
-  uploadComplete!: boolean;
-}
-
-export class GetUploadStatusDto {
-  @Expose({ name: Header.InteropVersion })
-  @Min(3)
-  @IsInt()
-  @Type(() => Number)
-  version!: number;
-}
-
-export class UploadOkDto {
-  @ApiProperty()
-  id!: string;
-}
-
-const STRUCTURED_TRUE = '?1';
-const STRUCTURED_FALSE = '?0';
-
-function isUploadComplete(obj: any) {
-  const uploadComplete = obj[Header.UploadComplete];
-  if (uploadComplete === STRUCTURED_TRUE) {
-    return true;
-  } else if (uploadComplete === STRUCTURED_FALSE) {
-    return false;
-  } else if (uploadComplete !== undefined) {
-    throw new BadRequestException('upload-complete must be a structured boolean value');
-  }
-
-  const uploadIncomplete = obj[Header.UploadIncomplete];
-  if (uploadIncomplete === STRUCTURED_TRUE) {
-    return false;
-  } else if (uploadIncomplete === STRUCTURED_FALSE) {
-    return true;
-  } else if (uploadIncomplete !== undefined) {
-    throw new BadRequestException('upload-incomplete must be a structured boolean value');
-  }
-}

server/src/dtos/sync.dto.ts

@@ -279,6 +279,24 @@ export class SyncAlbumUserV1 {
   role!: AlbumUserRole;
 }
 
+@ExtraModel()
+export class SyncAlbumUserMetadataDeleteV1 {
+  @ApiProperty({ description: 'Album ID' })
+  albumId!: string;
+  @ApiProperty({ description: 'User ID' })
+  userId!: string;
+}
+
+@ExtraModel()
+export class SyncAlbumUserMetadataV1 {
+  @ApiProperty({ description: 'Album ID' })
+  albumId!: string;
+  @ApiProperty({ description: 'User ID' })
+  userId!: string;
+  @ApiProperty({ description: 'Is favorite' })
+  isFavorite!: boolean;
+}
+
 @ExtraModel()
 export class SyncAlbumV1 {
   @ApiProperty({ description: 'Album ID' })
@@ -511,6 +529,8 @@ export type SyncItem = {
   [SyncEntityType.AlbumUserV1]: SyncAlbumUserV1;
   [SyncEntityType.AlbumUserBackfillV1]: SyncAlbumUserV1;
   [SyncEntityType.AlbumUserDeleteV1]: SyncAlbumUserDeleteV1;
+  [SyncEntityType.AlbumUserMetadataV1]: SyncAlbumUserMetadataV1;
+  [SyncEntityType.AlbumUserMetadataDeleteV1]: SyncAlbumUserMetadataDeleteV1;
   [SyncEntityType.AlbumAssetCreateV1]: SyncAssetV1;
   [SyncEntityType.AlbumAssetUpdateV1]: SyncAssetV1;
   [SyncEntityType.AlbumAssetBackfillV1]: SyncAssetV1;

server/src/dtos/system-config.dto.ts

@@ -57,23 +57,11 @@ export class DatabaseBackupConfig {
   keepLastAmount!: number;
 }
 
-export class UploadBackupConfig {
-  @IsInt()
-  @IsPositive()
-  @IsNotEmpty()
-  maxAgeHours!: number;
-}
-
 export class SystemConfigBackupsDto {
   @Type(() => DatabaseBackupConfig)
   @ValidateNested()
   @IsObject()
   database!: DatabaseBackupConfig;
-
-  @Type(() => UploadBackupConfig)
-  @ValidateNested()
-  @IsObject()
-  upload!: UploadBackupConfig;
 }
 
 export class SystemConfigFFmpegDto {
@@ -399,9 +387,6 @@ class SystemConfigNightlyTasksDto {
 
   @ValidateBoolean({ description: 'Sync quota usage' })
   syncQuotaUsage!: boolean;
-
-  @ValidateBoolean()
-  removeStaleUploads!: boolean;
 }
 
 class SystemConfigOAuthDto {

server/src/enum.ts

@@ -21,7 +21,6 @@ export enum ImmichHeader {
   SharedLinkSlug = 'x-immich-share-slug',
   Checksum = 'x-immich-checksum',
   Cid = 'x-immich-cid',
-  AssetData = 'x-immich-asset-data',
 }
 
 export enum ImmichQuery {
@@ -359,7 +358,6 @@ export enum AssetStatus {
   Active = 'active',
   Trashed = 'trashed',
   Deleted = 'deleted',
-  Partial = 'partial',
 }
 
 export enum SourceType {
@@ -556,7 +554,6 @@ export enum BootstrapEventPriority {
   JobService = -190,
   // Initialise config after other bootstrap services, stop other services from using config on bootstrap
   SystemConfig = 100,
-  UploadService = 200,
 }
 
 export enum QueueName {
@@ -605,8 +602,6 @@ export enum JobName {
   AssetFileMigration = 'AssetFileMigration',
   AssetGenerateThumbnailsQueueAll = 'AssetGenerateThumbnailsQueueAll',
   AssetGenerateThumbnails = 'AssetGenerateThumbnails',
-  PartialAssetCleanup = 'PartialAssetCleanup',
-  PartialAssetCleanupQueueAll = 'PartialAssetCleanupQueueAll',
 
   AuditLogCleanup = 'AuditLogCleanup',
   AuditTableCleanup = 'AuditTableCleanup',
@@ -728,6 +723,7 @@ export enum ExitCode {
 export enum SyncRequestType {
   AlbumsV1 = 'AlbumsV1',
   AlbumUsersV1 = 'AlbumUsersV1',
+  AlbumUserMetadataV1 = 'AlbumUserMetadataV1',
   AlbumToAssetsV1 = 'AlbumToAssetsV1',
   AlbumAssetsV1 = 'AlbumAssetsV1',
   AlbumAssetExifsV1 = 'AlbumAssetExifsV1',
@@ -782,6 +778,8 @@ export enum SyncEntityType {
   AlbumUserV1 = 'AlbumUserV1',
   AlbumUserBackfillV1 = 'AlbumUserBackfillV1',
   AlbumUserDeleteV1 = 'AlbumUserDeleteV1',
+  AlbumUserMetadataV1 = 'AlbumUserMetadataV1',
+  AlbumUserMetadataDeleteV1 = 'AlbumUserMetadataDeleteV1',
 
   AlbumAssetCreateV1 = 'AlbumAssetCreateV1',
   AlbumAssetUpdateV1 = 'AlbumAssetUpdateV1',

server/src/queries/album.repository.sql

@@ -21,6 +21,18 @@ select
           "user"."id" = "album"."ownerId"
       ) as obj
   ) as "owner",
+  coalesce(
+    (
+      select
+        "album_user_metadata"."isFavorite"
+      from
+        "album_user_metadata"
+      where
+        "album_user_metadata"."albumId" = "album"."id"
+        and "album_user_metadata"."userId" = $1
+    ),
+    false
+  ) as "isFavorite",
   (
     select
       coalesce(json_agg(agg), '[]')
@@ -88,12 +100,24 @@ select
 from
   "album"
 where
-  "album"."id" = $1
+  "album"."id" = $2
   and "album"."deletedAt" is null
 
 -- AlbumRepository.getByAssetId
 select
   "album".*,
+  coalesce(
+    (
+      select
+        "album_user_metadata"."isFavorite"
+      from
+        "album_user_metadata"
+      where
+        "album_user_metadata"."albumId" = "album"."id"
+        and "album_user_metadata"."userId" = $1
+    ),
+    false
+  ) as "isFavorite",
   (
     select
       to_json(obj)
@@ -148,17 +172,17 @@ from
   inner join "album_asset" on "album_asset"."albumId" = "album"."id"
 where
   (
-    "album"."ownerId" = $1
+    "album"."ownerId" = $2
     or exists (
       select
       from
         "album_user"
       where
         "album_user"."albumId" = "album"."id"
-        and "album_user"."userId" = $2
+        and "album_user"."userId" = $3
     )
   )
-  and "album_asset"."assetId" = $3
+  and "album_asset"."assetId" = $4
   and "album"."deletedAt" is null
 order by
   "album"."createdAt" desc,
@@ -210,6 +234,18 @@ group by
 -- AlbumRepository.getOwned
 select
   "album".*,
+  coalesce(
+    (
+      select
+        "album_user_metadata"."isFavorite"
+      from
+        "album_user_metadata"
+      where
+        "album_user_metadata"."albumId" = "album"."id"
+        and "album_user_metadata"."userId" = $1
+    ),
+    false
+  ) as "isFavorite",
   (
     select
       to_json(obj)
@@ -275,7 +311,7 @@ select
 from
   "album"
 where
-  "album"."ownerId" = $1
+  "album"."ownerId" = $2
   and "album"."deletedAt" is null
 order by
   "album"."createdAt" desc
@@ -283,6 +319,18 @@ order by
 -- AlbumRepository.getShared
 select
   "album".*,
+  coalesce(
+    (
+      select
+        "album_user_metadata"."isFavorite"
+      from
+        "album_user_metadata"
+      where
+        "album_user_metadata"."albumId" = "album"."id"
+        and "album_user_metadata"."userId" = $1
+    ),
+    false
+  ) as "isFavorite",
   (
     select
       coalesce(json_agg(agg), '[]')
@@ -356,8 +404,8 @@ where
       where
         "album_user"."albumId" = "album"."id"
         and (
-          "album"."ownerId" = $1
-          or "album_user"."userId" = $2
+          "album"."ownerId" = $2
+          or "album_user"."userId" = $3
         )
     )
     or exists (
@@ -366,7 +414,7 @@ where
         "shared_link"
       where
         "shared_link"."albumId" = "album"."id"
-        and "shared_link"."userId" = $3
+        and "shared_link"."userId" = $4
     )
   )
   and "album"."deletedAt" is null
@@ -376,6 +424,18 @@ order by
 -- AlbumRepository.getNotShared
 select
   "album".*,
+  coalesce(
+    (
+      select
+        "album_user_metadata"."isFavorite"
+      from
+        "album_user_metadata"
+      where
+        "album_user_metadata"."albumId" = "album"."id"
+        and "album_user_metadata"."userId" = $1
+    ),
+    false
+  ) as "isFavorite",
   (
     select
       to_json(obj)
@@ -397,7 +457,7 @@ select
 from
   "album"
 where
-  "album"."ownerId" = $1
+  "album"."ownerId" = $2
   and "album"."deletedAt" is null
   and not exists (
     select

server/src/queries/album.user.metadata.repository.sql

@@ -0,0 +1,10 @@
+-- NOTE: This file is auto generated by ./sql-generator
+
+-- AlbumUserMetadataRepository.upsert
+insert into
+  "album_user_metadata" ("albumId", "userId", "isFavorite")
+values
+  ($1, $2, $3)
+on conflict ("albumId", "userId") do update
+set
+  "isFavorite" = "excluded"."isFavorite"

server/src/queries/album.user.repository.sql

@@ -1,6 +1,7 @@
 -- NOTE: This file is auto generated by ./sql-generator
 
 -- AlbumUserRepository.create
+begin
 insert into
   "album_user" ("userId", "albumId")
 values
@@ -9,6 +10,7 @@ returning
   "userId",
   "albumId",
   "role"
+rollback
 
 -- AlbumUserRepository.update
 update "album_user"
@@ -19,7 +21,13 @@ where
   and "albumId" = $3
 
 -- AlbumUserRepository.delete
+begin
+delete from "album_user_metadata"
+where
+  "userId" = $1
+  and "albumId" = $2
 delete from "album_user"
 where
   "userId" = $1
   and "albumId" = $2
+commit

server/src/queries/asset.job.repository.sql

@@ -14,7 +14,6 @@ from
   left join "smart_search" on "asset"."id" = "smart_search"."assetId"
 where
   "asset"."id" = $1::uuid
-  and "asset"."status" != 'partial'
 limit
   $2
 
@@ -45,7 +44,6 @@ from
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
   "asset"."id" = $2::uuid
-  and "asset"."status" != 'partial'
 limit
   $3
 
@@ -74,7 +72,6 @@ from
   "asset"
 where
   "asset"."id" = $2::uuid
-  and "asset"."status" != 'partial'
 limit
   $3
 
@@ -86,8 +83,7 @@ from
   "asset"
   inner join "asset_job_status" on "asset_job_status"."assetId" = "asset"."id"
 where
-  "asset"."status" != 'partial'
-  and "asset"."deletedAt" is null
+  "asset"."deletedAt" is null
   and "asset"."visibility" != 'hidden'
   and (
     not exists (
@@ -199,7 +195,6 @@ from
   "asset"
 where
   "asset"."id" = $1
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getForGenerateThumbnailJob
 select
@@ -249,7 +244,6 @@ from
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
   "asset"."id" = $4
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getForMetadataExtraction
 select
@@ -308,17 +302,14 @@ from
   "asset"
 where
   "asset"."id" = $3
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getLockedPropertiesForMetadataExtraction
 select
   "asset_exif"."lockedProperties"
 from
   "asset_exif"
-  inner join "asset" on "asset"."id" = "asset_exif"."assetId"
 where
   "asset_exif"."assetId" = $1
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getAlbumThumbnailFiles
 select
@@ -328,10 +319,8 @@ select
   "asset_file"."isEdited"
 from
   "asset_file"
-  inner join "asset" on "asset"."id" = "asset_file"."assetId"
 where
   "asset_file"."assetId" = $1
-  and "asset"."status" != 'partial'
   and "asset_file"."type" = $2
 
 -- AssetJobRepository.streamForSearchDuplicates
@@ -342,8 +331,7 @@ from
   inner join "smart_search" on "asset"."id" = "smart_search"."assetId"
   inner join "asset_job_status" as "job_status" on "job_status"."assetId" = "asset"."id"
 where
-  "asset"."status" != 'partial'
-  and "asset"."deletedAt" is null
+  "asset"."deletedAt" is null
   and "asset"."visibility" in ('archive', 'timeline')
   and "job_status"."duplicatesDetectedAt" is null
 
@@ -355,7 +343,6 @@ from
   inner join "asset_job_status" as "job_status" on "assetId" = "asset"."id"
 where
   "asset"."visibility" != $1
-  and "asset"."status" != 'partial'
   and "asset"."deletedAt" is null
   and exists (
     select
@@ -398,7 +385,6 @@ from
   "asset"
 where
   "asset"."id" = $2
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getForDetectFacesJob
 select
@@ -440,7 +426,6 @@ from
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
   "asset"."id" = $2
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getForOcr
 select
@@ -458,7 +443,6 @@ from
   "asset"
 where
   "asset"."id" = $2
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getForSyncAssets
 select
@@ -472,7 +456,6 @@ from
   "asset"
 where
   "asset"."id" = any ($1::uuid[])
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.getForAssetDeletion
 select
@@ -531,7 +514,6 @@ from
   ) as "stack_result" on true
 where
   "asset"."id" = $3
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.streamForVideoConversion
 select
@@ -550,7 +532,6 @@ where
       and "asset_file"."type" = 'encoded_video'
   )
   and "asset"."visibility" != 'hidden'
-  and "asset"."status" != 'partial'
   and "asset"."deletedAt" is null
 
 -- AssetJobRepository.getForVideoConversion
@@ -579,7 +560,6 @@ from
 where
   "asset"."id" = $1
   and "asset"."type" = 'VIDEO'
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.streamForMetadataExtraction
 select
@@ -592,7 +572,6 @@ where
     "asset_job_status"."metadataExtractedAt" is null
     or "asset_job_status"."assetId" is null
   )
-  and "asset"."status" != 'partial'
   and "asset"."deletedAt" is null
 
 -- AssetJobRepository.getForStorageTemplateJob
@@ -633,8 +612,7 @@ from
   "asset"
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
-  "asset"."status" != 'partial'
-  and "asset"."deletedAt" is null
+  "asset"."deletedAt" is null
   and "asset"."id" = $2
   and "asset"."visibility" != $3
 
@@ -676,8 +654,7 @@ from
   "asset"
   inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
 where
-  "asset"."status" != 'partial'
-  and "asset"."deletedAt" is null
+  "asset"."deletedAt" is null
   and "asset"."visibility" != $2
 
 -- AssetJobRepository.streamForDeletedJob
@@ -688,7 +665,6 @@ from
   "asset"
 where
   "asset"."deletedAt" <= $1
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.streamForSidecar
 select
@@ -705,7 +681,6 @@ where
       "asset_file"."assetId" = "asset"."id"
       and "asset_file"."type" = $1
   )
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.streamForDetectFacesJob
 select
@@ -715,7 +690,6 @@ from
   inner join "asset_job_status" as "job_status" on "assetId" = "asset"."id"
 where
   "asset"."visibility" != $1
-  and "asset"."status" != 'partial'
   and "asset"."deletedAt" is null
   and exists (
     select
@@ -725,7 +699,6 @@ where
       "assetId" = "asset"."id"
       and "asset_file"."type" = $2
   )
-  and "asset"."status" != 'partial'
 order by
   "asset"."fileCreatedAt" desc
 
@@ -739,7 +712,6 @@ where
   "asset_job_status"."ocrAt" is null
   and "asset"."deletedAt" is null
   and "asset"."visibility" != $1
-  and "asset"."status" != 'partial'
 
 -- AssetJobRepository.streamForMigrationJob
 select
@@ -747,14 +719,4 @@ select
 from
   "asset"
 where
-  "asset"."status" != 'partial'
-  and "asset"."deletedAt" is null
-
--- AssetJobRepository.streamForPartialAssetCleanupJob
-select
-  "id"
-from
-  "asset"
-where
-  "asset"."status" = 'partial'
-  and "asset"."createdAt" < $1
+  "asset"."deletedAt" is null

server/src/queries/asset.repository.sql

@@ -101,87 +101,6 @@ where
   and "key" = $2
 commit
 
--- AssetRepository.getCompletionMetadata
-select
-  "originalPath" as "path",
-  "status",
-  "fileModifiedAt",
-  "createdAt",
-  "checksum",
-  "fileSizeInByte" as "size"
-from
-  "asset"
-  inner join "asset_exif" on "asset"."id" = "asset_exif"."assetId"
-where
-  "id" = $1
-  and "ownerId" = $2
-
--- AssetRepository.setComplete
-with
-  "completed_asset" as (
-    update "asset" as "complete_asset"
-    set
-      "status" = 'active',
-      "visibility" = case
-        when (
-          "complete_asset"."type" = 'VIDEO'
-          and exists (
-            select
-            from
-              "asset"
-            where
-              "complete_asset"."id" = "asset"."livePhotoVideoId"
-          )
-        ) then 'hidden'::asset_visibility_enum
-        else 'timeline'::asset_visibility_enum
-      end
-    where
-      "id" = $1
-      and "status" = 'partial'
-    returning
-      *
-  ),
-  "shared_link" as (
-    insert into
-      "album_asset" ("albumId", "assetId")
-    select
-      $2 as "albumId",
-      "completed_asset"."id"
-    from
-      "completed_asset"
-    on conflict do nothing
-  )
-select
-  *
-from
-  "completed_asset"
-
--- AssetRepository.removeAndDecrementQuota
-with
-  "asset_exif" as (
-    select
-      "fileSizeInByte"
-    from
-      "asset_exif"
-    where
-      "assetId" = $1
-  ),
-  "asset" as (
-    delete from "asset"
-    where
-      "id" = $2
-    returning
-      "ownerId"
-  )
-update "user"
-set
-  "quotaUsageInBytes" = "quotaUsageInBytes" - "fileSizeInByte"
-from
-  "asset_exif",
-  "asset"
-where
-  "user"."id" = "asset"."ownerId"
-
 -- AssetRepository.getByDayOfYear
 with
   "res" as (
@@ -422,9 +341,7 @@ where
 
 -- AssetRepository.getUploadAssetIdByChecksum
 select
-  "id",
-  "status",
-  "createdAt"
+  "id"
 from
   "asset"
 where

server/src/queries/sync.repository.sql

@@ -285,6 +285,35 @@ where
 order by
   "album_asset"."updateId" asc
 
+-- SyncRepository.albumUserMetadata.getDeletes
+select
+  "id",
+  "albumId",
+  "userId"
+from
+  "album_user_metadata_audit" as "album_user_metadata_audit"
+where
+  "album_user_metadata_audit"."id" < $1
+  and "album_user_metadata_audit"."id" > $2
+  and "userId" = $3
+order by
+  "album_user_metadata_audit"."id" asc
+
+-- SyncRepository.albumUserMetadata.getUpserts
+select
+  "album_user_metadata"."albumId" as "albumId",
+  "album_user_metadata"."userId" as "userId",
+  "album_user_metadata"."isFavorite",
+  "album_user_metadata"."updateId"
+from
+  "album_user_metadata" as "album_user_metadata"
+where
+  "album_user_metadata"."updateId" < $1
+  and "album_user_metadata"."updateId" > $2
+  and "userId" = $3
+order by
+  "album_user_metadata"."updateId" asc
+
 -- SyncRepository.albumToAsset.getBackfill
 select
   "album_asset"."assetId" as "assetId",

server/src/repositories/album-user-metadata.repository.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import { Insertable, Kysely } from 'kysely';
+import { InjectKysely } from 'nestjs-kysely';
+import { DummyValue, GenerateSql } from 'src/decorators';
+import { DB } from 'src/schema';
+import { AlbumUserMetadataTable } from 'src/schema/tables/album-user-metadata.table';
+
+export type AlbumUserMetadataId = {
+  albumId: string;
+  userId: string;
+};
+
+@Injectable()
+export class AlbumUserMetadataRepository {
+  constructor(@InjectKysely() private db: Kysely<DB>) {}
+
+  @GenerateSql({ params: [{ albumId: DummyValue.UUID, userId: DummyValue.UUID, isFavorite: true }] })
+  async upsert(dto: Insertable<AlbumUserMetadataTable>) {
+    await this.db
+      .insertInto('album_user_metadata')
+      .values(dto)
+      .onConflict((oc) =>
+        oc.columns(['albumId', 'userId']).doUpdateSet((eb) => ({ isFavorite: eb.ref('excluded.isFavorite') })),
+      )
+      .execute();
+  }
+}

server/src/repositories/album-user.repository.ts

@@ -17,11 +17,21 @@ export class AlbumUserRepository {
 
   @GenerateSql({ params: [{ userId: DummyValue.UUID, albumId: DummyValue.UUID }] })
   create(albumUser: Insertable<AlbumUserTable>) {
-    return this.db
-      .insertInto('album_user')
-      .values(albumUser)
-      .returning(['userId', 'albumId', 'role'])
-      .executeTakeFirstOrThrow();
+    return this.db.transaction().execute(async (tx) => {
+      const result = await tx
+        .insertInto('album_user')
+        .values(albumUser)
+        .returning(['userId', 'albumId', 'role'])
+        .executeTakeFirstOrThrow();
+
+      await tx
+        .insertInto('album_user_metadata')
+        .values({ albumId: albumUser.albumId, userId: albumUser.userId, isFavorite: false })
+        .onConflict((oc) => oc.columns(['albumId', 'userId']).doNothing())
+        .execute();
+
+      return result;
+    });
   }
 
   @GenerateSql({ params: [{ userId: DummyValue.UUID, albumId: DummyValue.UUID }, { role: AlbumUserRole.Viewer }] })
@@ -36,6 +46,9 @@ export class AlbumUserRepository {
 
   @GenerateSql({ params: [{ userId: DummyValue.UUID, albumId: DummyValue.UUID }] })
   async delete({ userId, albumId }: AlbumPermissionId): Promise<void> {
-    await this.db.deleteFrom('album_user').where('userId', '=', userId).where('albumId', '=', albumId).execute();
+    await this.db.transaction().execute(async (tx) => {
+      await tx.deleteFrom('album_user_metadata').where('userId', '=', userId).where('albumId', '=', albumId).execute();
+      await tx.deleteFrom('album_user').where('userId', '=', userId).where('albumId', '=', albumId).execute();
+    });
   }
 }

server/src/repositories/album.repository.ts

@@ -31,6 +31,18 @@ export interface AlbumInfoOptions {
   withAssets: boolean;
 }
 
+const withFavorite = (eb: ExpressionBuilder<DB, 'album'>, userId?: string) => {
+  if (!userId) {
+    return sql<boolean>`false`.as('isFavorite');
+  }
+
+  return sql<boolean>`coalesce(${eb
+    .selectFrom('album_user_metadata')
+    .select('album_user_metadata.isFavorite')
+    .whereRef('album_user_metadata.albumId', '=', 'album.id')
+    .where('album_user_metadata.userId', '=', userId)}, false)`.as('isFavorite');
+};
+
 const withOwner = (eb: ExpressionBuilder<DB, 'album'>) => {
   return jsonObjectFrom(eb.selectFrom('user').select(columns.user).whereRef('user.id', '=', 'album.ownerId'))
     .$notNull()
@@ -84,14 +96,15 @@ const withAssets = (eb: ExpressionBuilder<DB, 'album'>) => {
 export class AlbumRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
-  @GenerateSql({ params: [DummyValue.UUID, { withAssets: true }] })
-  async getById(id: string, options: AlbumInfoOptions) {
+  @GenerateSql({ params: [DummyValue.UUID, { withAssets: true }, DummyValue.UUID] })
+  async getById(id: string, options: AlbumInfoOptions, userId?: string) {
     return this.db
       .selectFrom('album')
       .selectAll('album')
       .where('album.id', '=', id)
       .where('album.deletedAt', 'is', null)
       .select(withOwner)
+      .select((eb) => withFavorite(eb, userId))
       .select(withAlbumUsers)
       .select(withSharedLink)
       .$if(options.withAssets, (eb) => eb.select(withAssets))
@@ -119,6 +132,7 @@ export class AlbumRepository {
       .where('album_asset.assetId', '=', assetId)
       .where('album.deletedAt', 'is', null)
       .orderBy('album.createdAt', 'desc')
+      .select((eb) => withFavorite(eb, ownerId))
       .select(withOwner)
       .select(withAlbumUsers)
       .orderBy('album.createdAt', 'desc')
@@ -194,6 +208,7 @@ export class AlbumRepository {
     return this.db
       .selectFrom('album')
       .selectAll('album')
+      .select((eb) => withFavorite(eb, ownerId))
       .select(withOwner)
       .select(withAlbumUsers)
       .select(withSharedLink)
@@ -211,6 +226,7 @@ export class AlbumRepository {
     return this.db
       .selectFrom('album')
       .selectAll('album')
+      .select((eb) => withFavorite(eb, ownerId))
       .where((eb) =>
         eb.or([
           eb.exists(
@@ -243,6 +259,7 @@ export class AlbumRepository {
     return this.db
       .selectFrom('album')
       .selectAll('album')
+      .select((eb) => withFavorite(eb, ownerId))
       .where('album.ownerId', '=', ownerId)
       .where('album.deletedAt', 'is', null)
       .where((eb) => eb.not(eb.exists(eb.selectFrom('album_user').whereRef('album_user.albumId', '=', 'album.id'))))
@@ -318,6 +335,15 @@ export class AlbumRepository {
         throw new Error('Failed to create album');
       }
 
+      await tx
+        .insertInto('album_user_metadata')
+        .values([
+          { albumId: newAlbum.id, userId: album.ownerId, isFavorite: false },
+          ...albumUsers.map((albumUser) => ({ albumId: newAlbum.id, userId: albumUser.userId, isFavorite: false })),
+        ])
+        .onConflict((oc) => oc.columns(['albumId', 'userId']).doNothing())
+        .execute();
+
       if (assetIds.length > 0) {
         await this.addAssets(tx, newAlbum.id, assetIds);
       }
@@ -335,6 +361,7 @@ export class AlbumRepository {
         .selectFrom('album')
         .selectAll('album')
         .where('id', '=', newAlbum.id)
+        .select((eb) => withFavorite(eb, album.ownerId))
         .select(withOwner)
         .select(withAssets)
         .select(withAlbumUsers)

server/src/repositories/asset-job.repository.ts

@@ -28,7 +28,6 @@ export class AssetJobRepository {
     return this.db
       .selectFrom('asset')
       .where('asset.id', '=', asUuid(id))
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .leftJoin('smart_search', 'asset.id', 'smart_search.assetId')
       .select(['id', 'type', 'ownerId', 'duplicateId', 'stackId', 'visibility', 'smart_search.embedding'])
       .limit(1)
@@ -40,7 +39,6 @@ export class AssetJobRepository {
     return this.db
       .selectFrom('asset')
       .where('asset.id', '=', asUuid(id))
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .select(['id', 'originalPath'])
       .select((eb) => withFiles(eb, AssetFileType.Sidecar))
       .$call(withExifInner)
@@ -53,7 +51,6 @@ export class AssetJobRepository {
     return this.db
       .selectFrom('asset')
       .where('asset.id', '=', asUuid(id))
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .select(['id', 'originalPath'])
       .select((eb) => withFiles(eb, AssetFileType.Sidecar))
       .limit(1)
@@ -65,7 +62,6 @@ export class AssetJobRepository {
     return this.db
       .selectFrom('asset')
       .select(['asset.id', 'asset.isEdited'])
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .where('asset.deletedAt', 'is', null)
       .where('asset.visibility', '!=', sql.lit(AssetVisibility.Hidden))
       .$if(!options.force, (qb) =>
@@ -111,7 +107,6 @@ export class AssetJobRepository {
       .select(['asset.id', 'asset.ownerId'])
       .select(withFiles)
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -140,7 +135,6 @@ export class AssetJobRepository {
       .select(withEdits)
       .$call(withExifInner)
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -152,7 +146,6 @@ export class AssetJobRepository {
       .select(withFaces)
       .select((eb) => withFiles(eb, AssetFileType.Sidecar))
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -160,10 +153,8 @@ export class AssetJobRepository {
   async getLockedPropertiesForMetadataExtraction(assetId: string) {
     return this.db
       .selectFrom('asset_exif')
-      .innerJoin('asset', 'asset.id', 'asset_exif.assetId')
       .select('asset_exif.lockedProperties')
       .where('asset_exif.assetId', '=', assetId)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst()
       .then((row) => row?.lockedProperties ?? []);
   }
@@ -172,10 +163,8 @@ export class AssetJobRepository {
   getAlbumThumbnailFiles(id: string, fileType?: AssetFileType) {
     return this.db
       .selectFrom('asset_file')
-      .innerJoin('asset', 'asset.id', 'asset_file.assetId')
       .select(columns.assetFiles)
       .where('asset_file.assetId', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .$if(!!fileType, (qb) => qb.where('asset_file.type', '=', fileType!))
       .execute();
   }
@@ -184,7 +173,6 @@ export class AssetJobRepository {
     return this.db
       .selectFrom('asset')
       .where('asset.visibility', '!=', AssetVisibility.Hidden)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .where('asset.deletedAt', 'is', null)
       .innerJoin('asset_job_status as job_status', 'assetId', 'asset.id')
       .where((eb) =>
@@ -202,7 +190,6 @@ export class AssetJobRepository {
     return this.db
       .selectFrom('asset')
       .select(['asset.id'])
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .where('asset.deletedAt', 'is', null)
       .innerJoin('smart_search', 'asset.id', 'smart_search.assetId')
       .$call(withDefaultVisibility)
@@ -231,7 +218,6 @@ export class AssetJobRepository {
       .select(['asset.id', 'asset.visibility'])
       .select((eb) => withFiles(eb, AssetFileType.Preview))
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -244,7 +230,6 @@ export class AssetJobRepository {
       .select((eb) => withFaces(eb, true, true))
       .select((eb) => withFiles(eb, AssetFileType.Preview))
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -254,7 +239,6 @@ export class AssetJobRepository {
       .selectFrom('asset')
       .select((eb) => ['asset.visibility', withFilePath(eb, AssetFileType.Preview).as('previewFile')])
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -271,7 +255,6 @@ export class AssetJobRepository {
         'asset.fileModifiedAt',
       ])
       .where('asset.id', '=', anyUuid(ids))
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .execute();
   }
 
@@ -318,7 +301,6 @@ export class AssetJobRepository {
           .as('stack'),
       )
       .where('asset.id', '=', id)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -343,7 +325,6 @@ export class AssetJobRepository {
           )
           .where('asset.visibility', '!=', sql.lit(AssetVisibility.Hidden)),
       )
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .where('asset.deletedAt', 'is', null)
       .stream();
   }
@@ -356,7 +337,6 @@ export class AssetJobRepository {
       .select(withFiles)
       .where('asset.id', '=', id)
       .where('asset.type', '=', sql.lit(AssetType.Video))
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .executeTakeFirst();
   }
 
@@ -372,7 +352,6 @@ export class AssetJobRepository {
             eb.or([eb('asset_job_status.metadataExtractedAt', 'is', null), eb('asset_job_status.assetId', 'is', null)]),
           ),
       )
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .where('asset.deletedAt', 'is', null)
       .stream();
   }
@@ -399,7 +378,6 @@ export class AssetJobRepository {
         'asset_exif.lensModel',
       ])
       .select((eb) => withFiles(eb, AssetFileType.Sidecar))
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .where('asset.deletedAt', 'is', null);
   }
 
@@ -422,7 +400,6 @@ export class AssetJobRepository {
       .selectFrom('asset')
       .select(['id', 'isOffline'])
       .where('asset.deletedAt', '<=', trashedBefore)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .stream();
   }
 
@@ -444,7 +421,6 @@ export class AssetJobRepository {
           ),
         ),
       )
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .stream();
   }
 
@@ -453,7 +429,6 @@ export class AssetJobRepository {
     return this.assetsWithPreviews()
       .$if(force === false, (qb) => qb.where('job_status.facesRecognizedAt', 'is', null))
       .select(['asset.id'])
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .orderBy('asset.fileCreatedAt', 'desc')
       .stream();
   }
@@ -470,37 +445,11 @@ export class AssetJobRepository {
       )
       .where('asset.deletedAt', 'is', null)
       .where('asset.visibility', '!=', AssetVisibility.Hidden)
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
       .stream();
   }
 
   @GenerateSql({ params: [DummyValue.DATE], stream: true })
   streamForMigrationJob() {
-    return this.db
-      .selectFrom('asset')
-      .select(['id'])
-      .where('asset.status', '!=', sql.lit(AssetStatus.Partial))
-      .where('asset.deletedAt', 'is', null)
-      .stream();
-  }
-
-  getForPartialAssetCleanupJob(assetId: string) {
-    return this.db
-      .selectFrom('asset')
-      .innerJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
-      .select(['originalPath as path', 'fileSizeInByte as size', 'checksum', 'fileModifiedAt'])
-      .where('id', '=', assetId)
-      .where('status', '=', sql.lit(AssetStatus.Partial))
-      .executeTakeFirst();
-  }
-
-  @GenerateSql({ params: [DummyValue.DATE], stream: true })
-  streamForPartialAssetCleanupJob(createdBefore: Date) {
-    return this.db
-      .selectFrom('asset')
-      .select(['id'])
-      .where('asset.status', '=', sql.lit(AssetStatus.Partial))
-      .where('asset.createdAt', '<', createdBefore)
-      .stream();
+    return this.db.selectFrom('asset').select(['id']).where('asset.deletedAt', 'is', null).stream();
   }
 }

server/src/repositories/asset.repository.ts

@@ -380,130 +380,6 @@ export class AssetRepository {
     return this.db.insertInto('asset').values(asset).returningAll().executeTakeFirstOrThrow();
   }
 
-  createWithMetadata(
-    asset: Insertable<AssetTable> & { id: string },
-    size: number,
-    metadata?: Omit<Insertable<AssetMetadataTable>, 'assetId'>[],
-  ) {
-    let query = this.db;
-    if (asset.livePhotoVideoId) {
-      (query as any) = query.with('motion_asset', (qb) =>
-        qb
-          .updateTable('asset')
-          .set({ visibility: AssetVisibility.Hidden })
-          .where('id', '=', asset.livePhotoVideoId!)
-          .where('type', '=', sql.lit(AssetType.Video))
-          .where('ownerId', '=', asset.ownerId)
-          .returning('id'),
-      );
-    }
-
-    (query as any) = query
-      .with('asset', (qb) =>
-        qb
-          .insertInto('asset')
-          .values(
-            asset.livePhotoVideoId ? { ...asset, livePhotoVideoId: sql<string>`(select id from motion_asset)` } : asset,
-          )
-          .returning(['id', 'ownerId']),
-      )
-      .with('exif', (qb) =>
-        qb
-          .insertInto('asset_exif')
-          .columns(['assetId', 'fileSizeInByte'])
-          .expression((eb) => eb.selectFrom('asset').select(['asset.id', eb.val(size).as('fileSizeInByte')])),
-      );
-
-    if (metadata && metadata.length > 0) {
-      (query as any) = query.with('metadata', (qb) =>
-        qb.insertInto('asset_metadata').values(metadata.map(({ key, value }) => ({ assetId: asset.id, key, value }))),
-      );
-    }
-
-    return query
-      .updateTable('user')
-      .from('asset')
-      .set({ quotaUsageInBytes: sql`"quotaUsageInBytes" + ${size}` })
-      .whereRef('user.id', '=', 'asset.ownerId')
-      .execute();
-  }
-
-  @GenerateSql({ params: [DummyValue.UUID, DummyValue.UUID] })
-  getCompletionMetadata(assetId: string, ownerId: string) {
-    return this.db
-      .selectFrom('asset')
-      .innerJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
-      .select(['originalPath as path', 'status', 'fileModifiedAt', 'createdAt', 'checksum', 'fileSizeInByte as size'])
-      .where('id', '=', assetId)
-      .where('ownerId', '=', ownerId)
-      .executeTakeFirst();
-  }
-
-  @GenerateSql({ params: [DummyValue.UUID, { albumId: DummyValue.UUID, id: DummyValue.UUID }] })
-  setComplete(assetId: string, sharedLink?: { albumId?: string | null; id: string }) {
-    const completedAsset = this.db
-      .updateTable('asset as complete_asset')
-      .set((eb) => ({
-        status: sql.lit(AssetStatus.Active),
-        visibility: eb
-          .case()
-          .when(
-            eb.and([
-              eb('complete_asset.type', '=', sql.lit(AssetType.Video)),
-              eb.exists(eb.selectFrom('asset').whereRef('complete_asset.id', '=', 'asset.livePhotoVideoId')),
-            ]),
-          )
-          .then(sql<AssetVisibility>`'hidden'::asset_visibility_enum`)
-          .else(sql<AssetVisibility>`'timeline'::asset_visibility_enum`)
-          .end(),
-      }))
-      .where('id', '=', assetId)
-      .where('status', '=', sql.lit(AssetStatus.Partial))
-      .returningAll();
-    if (!sharedLink) {
-      return completedAsset.executeTakeFirst();
-    }
-
-    return this.db
-      .with('completed_asset', () => completedAsset)
-      .with('shared_link', (qb) =>
-        sharedLink?.albumId
-          ? qb
-              .insertInto('album_asset')
-              .columns(['albumId', 'assetId'])
-              .expression((eb) =>
-                eb
-                  .selectFrom('completed_asset')
-                  .select([eb.val(sharedLink.albumId).as('albumId'), 'completed_asset.id']),
-              )
-              .onConflict((oc) => oc.doNothing())
-          : qb
-              .insertInto('shared_link_asset')
-              .columns(['sharedLinkId', 'assetId'])
-              .expression((eb) =>
-                eb
-                  .selectFrom('completed_asset')
-                  .select([eb.val(sharedLink.id).as('sharedLinkId'), 'completed_asset.id']),
-              )
-              .onConflict((oc) => oc.doNothing()),
-      )
-      .selectFrom('completed_asset')
-      .selectAll()
-      .executeTakeFirst();
-  }
-
-  @GenerateSql({ params: [DummyValue.UUID] })
-  async removeAndDecrementQuota(id: string): Promise<void> {
-    await this.db
-      .with('asset_exif', (qb) => qb.selectFrom('asset_exif').where('assetId', '=', id).select('fileSizeInByte'))
-      .with('asset', (qb) => qb.deleteFrom('asset').where('id', '=', id).returning('ownerId'))
-      .updateTable('user')
-      .from(['asset_exif', 'asset'])
-      .set({ quotaUsageInBytes: sql`"quotaUsageInBytes" - "fileSizeInByte"` })
-      .whereRef('user.id', '=', 'asset.ownerId')
-      .execute();
-  }
-
   createAll(assets: Insertable<AssetTable>[]) {
     return this.db.insertInto('asset').values(assets).returningAll().execute();
   }
@@ -760,15 +636,17 @@ export class AssetRepository {
   }
 
   @GenerateSql({ params: [DummyValue.UUID, DummyValue.BUFFER] })
-  getUploadAssetIdByChecksum(ownerId: string, checksum: Buffer) {
-    return this.db
+  async getUploadAssetIdByChecksum(ownerId: string, checksum: Buffer): Promise<string | undefined> {
+    const asset = await this.db
       .selectFrom('asset')
-      .select(['id', 'status', 'createdAt'])
+      .select('id')
       .where('ownerId', '=', asUuid(ownerId))
       .where('checksum', '=', checksum)
       .where('libraryId', 'is', null)
       .limit(1)
       .executeTakeFirst();
+
+    return asset?.id;
   }
 
   findLivePhotoMatch(options: LivePhotoSearchOptions) {

server/src/repositories/database.repository.ts

@@ -467,20 +467,6 @@ export class DatabaseRepository {
     return res as R;
   }
 
-  async withUuidLock<R>(uuid: string, callback: () => Promise<R>): Promise<R> {
-    let res;
-    await this.db.connection().execute(async (connection) => {
-      try {
-        await this.acquireUuidLock(uuid, connection);
-        res = await callback();
-      } finally {
-        await this.releaseUuidLock(uuid, connection);
-      }
-    });
-
-    return res as R;
-  }
-
   tryLock(lock: DatabaseLock): Promise<boolean> {
     return this.db.connection().execute(async (connection) => this.acquireTryLock(lock, connection));
   }
@@ -497,10 +483,6 @@ export class DatabaseRepository {
     await sql`SELECT pg_advisory_lock(${lock})`.execute(connection);
   }
 
-  private async acquireUuidLock(uuid: string, connection: Kysely<DB>): Promise<void> {
-    await sql`SELECT pg_advisory_lock(uuid_hash_extended(${uuid}, 0))`.execute(connection);
-  }
-
   private async acquireTryLock(lock: DatabaseLock, connection: Kysely<DB>): Promise<boolean> {
     const { rows } = await sql<{
       pg_try_advisory_lock: boolean;
@@ -512,10 +494,6 @@ export class DatabaseRepository {
     await sql`SELECT pg_advisory_unlock(${lock})`.execute(connection);
   }
 
-  private async releaseUuidLock(uuid: string, connection: Kysely<DB>): Promise<void> {
-    await sql`SELECT pg_advisory_unlock(uuid_hash_extended(${uuid}, 0))`.execute(connection);
-  }
-
   async revertLastMigration(): Promise<string | undefined> {
     this.logger.debug('Reverting last migration');
 

server/src/repositories/event.repository.ts

@@ -82,9 +82,6 @@ type EventMap = {
   // stack bulk events
   StackDeleteAll: [{ stackIds: string[]; userId: string }];
 
-  // upload events
-  UploadAbort: [{ assetId: string; abortTime: Date }];
-
   // user events
   UserSignup: [{ notify: boolean; id: string; password?: string }];
   UserCreate: [UserEvent];

server/src/repositories/index.ts

@@ -1,5 +1,6 @@
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
+import { AlbumUserMetadataRepository } from 'src/repositories/album-user-metadata.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
 import { ApiKeyRepository } from 'src/repositories/api-key.repository';
@@ -55,6 +56,7 @@ export const repositories = [
   AccessRepository,
   ActivityRepository,
   AlbumRepository,
+  AlbumUserMetadataRepository,
   AlbumUserRepository,
   AuditRepository,
   ApiKeyRepository,

server/src/repositories/storage.repository.ts

@@ -62,12 +62,8 @@ export class StorageRepository {
     return fs.writeFile(filepath, buffer, { flag: 'wx' });
   }
 
-  createWriteStream(filepath: string, { flush }: { flush: boolean } = { flush: true }): Writable {
-    return createWriteStream(filepath, { flags: 'w', flush, highWaterMark: 1024 * 1024 });
-  }
-
-  createOrAppendWriteStream(filepath: string, { flush }: { flush: boolean } = { flush: true }): Writable {
-    return createWriteStream(filepath, { flags: 'a', flush, highWaterMark: 1024 * 1024 });
+  createWriteStream(filepath: string): Writable {
+    return createWriteStream(filepath, { flags: 'w', flush: true });
   }
 
   createOrOverwriteFile(filepath: string, buffer: Buffer) {
@@ -183,13 +179,10 @@ export class StorageRepository {
     }
   }
 
-  mkdir(filepath: string): Promise<string | undefined> {
-    return fs.mkdir(filepath, { recursive: true });
-  }
-
   mkdirSync(filepath: string): void {
-    // does not throw an error if the folder already exists
-    mkdirSync(filepath, { recursive: true });
+    if (!existsSync(filepath)) {
+      mkdirSync(filepath, { recursive: true });
+    }
   }
 
   existsSync(filepath: string) {

server/src/repositories/sync.repository.ts

@@ -49,6 +49,7 @@ export class SyncRepository {
   album: AlbumSync;
   albumAsset: AlbumAssetSync;
   albumAssetExif: AlbumAssetExifSync;
+  albumUserMetadata: AlbumUserMetadataSync;
   albumToAsset: AlbumToAssetSync;
   albumUser: AlbumUserSync;
   asset: AssetSync;
@@ -72,6 +73,7 @@ export class SyncRepository {
     this.album = new AlbumSync(this.db);
     this.albumAsset = new AlbumAssetSync(this.db);
     this.albumAssetExif = new AlbumAssetExifSync(this.db);
+    this.albumUserMetadata = new AlbumUserMetadataSync(this.db);
     this.albumToAsset = new AlbumToAssetSync(this.db);
     this.albumUser = new AlbumUserSync(this.db);
     this.asset = new AssetSync(this.db);
@@ -385,6 +387,29 @@ class AlbumUserSync extends BaseSync {
   }
 }
 
+class AlbumUserMetadataSync extends BaseSync {
+  @GenerateSql({ params: [dummyQueryOptions], stream: true })
+  getDeletes(options: SyncQueryOptions) {
+    return this.auditQuery('album_user_metadata_audit', options)
+      .select(['id', 'albumId', 'userId'])
+      .where('userId', '=', options.userId)
+      .stream();
+  }
+
+  cleanupAuditTable(daysAgo: number) {
+    return this.auditCleanup('album_user_metadata_audit', daysAgo);
+  }
+
+  @GenerateSql({ params: [dummyQueryOptions], stream: true })
+  getUpserts(options: SyncQueryOptions) {
+    return this.upsertQuery('album_user_metadata', options)
+      .select(columns.syncAlbumUserMetadata)
+      .select('album_user_metadata.updateId')
+      .where('userId', '=', options.userId)
+      .stream();
+  }
+}
+
 class AssetSync extends BaseSync {
   @GenerateSql({ params: [dummyQueryOptions], stream: true })
   getDeletes(options: SyncQueryOptions) {

server/src/repositories/websocket.repository.ts

@@ -16,7 +16,7 @@ import { AppRestartEvent, ArgsOf, EventRepository } from 'src/repositories/event
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { handlePromiseError } from 'src/utils/misc';
 
-export const serverEvents = ['ConfigUpdate', 'AppRestart', 'UploadAbort'] as const;
+export const serverEvents = ['ConfigUpdate', 'AppRestart'] as const;
 export type ServerEvents = (typeof serverEvents)[number];
 
 export interface ClientEventMap {

server/src/schema/functions.ts

@@ -165,6 +165,19 @@ export const album_user_delete_audit = registerFunction({
     END`,
 });
 
+export const album_user_metadata_audit = registerFunction({
+  name: 'album_user_metadata_audit',
+  returnType: 'TRIGGER',
+  language: 'PLPGSQL',
+  body: `
+    BEGIN
+      INSERT INTO album_user_metadata_audit ("albumId", "userId")
+      SELECT "albumId", "userId"
+      FROM OLD;
+      RETURN NULL;
+    END`,
+});
+
 export const memory_delete_audit = registerFunction({
   name: 'memory_delete_audit',
   returnType: 'TRIGGER',

server/src/schema/index.ts

@@ -4,6 +4,7 @@ import {
   album_delete_audit,
   album_user_after_insert,
   album_user_delete_audit,
+  album_user_metadata_audit,
   asset_delete_audit,
   asset_face_audit,
   asset_metadata_audit,
@@ -25,6 +26,8 @@ import { AlbumAssetAuditTable } from 'src/schema/tables/album-asset-audit.table'
 import { AlbumAssetTable } from 'src/schema/tables/album-asset.table';
 import { AlbumAuditTable } from 'src/schema/tables/album-audit.table';
 import { AlbumUserAuditTable } from 'src/schema/tables/album-user-audit.table';
+import { AlbumUserMetadataAuditTable } from 'src/schema/tables/album-user-metadata-audit.table';
+import { AlbumUserMetadataTable } from 'src/schema/tables/album-user-metadata.table';
 import { AlbumUserTable } from 'src/schema/tables/album-user.table';
 import { AlbumTable } from 'src/schema/tables/album.table';
 import { ApiKeyTable } from 'src/schema/tables/api-key.table';
@@ -83,6 +86,8 @@ export class ImmichDatabase {
     AlbumAssetTable,
     AlbumAssetAuditTable,
     AlbumAuditTable,
+    AlbumUserMetadataAuditTable,
+    AlbumUserMetadataTable,
     AlbumUserAuditTable,
     AlbumUserTable,
     AlbumTable,
@@ -150,6 +155,7 @@ export class ImmichDatabase {
     asset_delete_audit,
     album_delete_audit,
     album_user_after_insert,
+    album_user_metadata_audit,
     album_user_delete_audit,
     memory_delete_audit,
     memory_asset_delete_audit,
@@ -178,6 +184,8 @@ export interface DB {
   album_audit: AlbumAuditTable;
   album_asset: AlbumAssetTable;
   album_asset_audit: AlbumAssetAuditTable;
+  album_user_metadata: AlbumUserMetadataTable;
+  album_user_metadata_audit: AlbumUserMetadataAuditTable;
   album_user: AlbumUserTable;
   album_user_audit: AlbumUserAuditTable;
 

server/src/schema/migrations/1759089915352-AddPartialAssetStatus.ts

@@ -1,9 +0,0 @@
-import { Kysely, sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`ALTER TYPE "assets_status_enum" ADD VALUE IF NOT EXISTS 'partial'`.execute(db);
-}
-
-export async function down(): Promise<void> {
-  // Cannot remove enum values in PostgreSQL
-}

server/src/schema/migrations/1774800000000-AlbumUserMetadataFavorites.ts

@@ -0,0 +1,66 @@
+import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`CREATE OR REPLACE FUNCTION album_user_metadata_audit()
+  RETURNS TRIGGER
+  LANGUAGE PLPGSQL
+  AS $$
+    BEGIN
+      INSERT INTO album_user_metadata_audit ("albumId", "userId")
+      SELECT "albumId", "userId"
+      FROM OLD;
+      RETURN NULL;
+    END
+  $$;`.execute(db);
+  await sql`CREATE TABLE "album_user_metadata_audit" (
+  "id" uuid NOT NULL DEFAULT immich_uuid_v7(),
+  "albumId" uuid NOT NULL,
+  "userId" uuid NOT NULL,
+  "deletedAt" timestamp with time zone NOT NULL DEFAULT clock_timestamp(),
+  CONSTRAINT "album_user_metadata_audit_pkey" PRIMARY KEY ("id")
+);`.execute(db);
+  await sql`CREATE INDEX "album_user_metadata_audit_albumId_idx" ON "album_user_metadata_audit" ("albumId");`.execute(db);
+  await sql`CREATE INDEX "album_user_metadata_audit_userId_idx" ON "album_user_metadata_audit" ("userId");`.execute(db);
+  await sql`CREATE INDEX "album_user_metadata_audit_deletedAt_idx" ON "album_user_metadata_audit" ("deletedAt");`.execute(db);
+  await sql`CREATE TABLE "album_user_metadata" (
+  "albumId" uuid NOT NULL,
+  "userId" uuid NOT NULL,
+  "isFavorite" boolean NOT NULL DEFAULT false,
+  "updateId" uuid NOT NULL DEFAULT immich_uuid_v7(),
+  "updatedAt" timestamp with time zone NOT NULL DEFAULT now(),
+  CONSTRAINT "album_user_metadata_albumId_fkey" FOREIGN KEY ("albumId") REFERENCES "album" ("id") ON UPDATE CASCADE ON DELETE CASCADE,
+  CONSTRAINT "album_user_metadata_userId_fkey" FOREIGN KEY ("userId") REFERENCES "user" ("id") ON UPDATE CASCADE ON DELETE CASCADE,
+  CONSTRAINT "album_user_metadata_pkey" PRIMARY KEY ("albumId", "userId")
+);`.execute(db);
+  await sql`CREATE INDEX "album_user_metadata_userId_idx" ON "album_user_metadata" ("userId");`.execute(db);
+  await sql`CREATE INDEX "album_user_metadata_updateId_idx" ON "album_user_metadata" ("updateId");`.execute(db);
+  await sql`CREATE INDEX "album_user_metadata_updatedAt_idx" ON "album_user_metadata" ("updatedAt");`.execute(db);
+  await sql`CREATE OR REPLACE TRIGGER "album_user_metadata_audit"
+  AFTER DELETE ON "album_user_metadata"
+  REFERENCING OLD TABLE AS "old"
+  FOR EACH STATEMENT
+  WHEN (pg_trigger_depth() = 0)
+  EXECUTE FUNCTION album_user_metadata_audit();`.execute(db);
+  await sql`CREATE OR REPLACE TRIGGER "album_user_metadata_updated_at"
+  BEFORE UPDATE ON "album_user_metadata"
+  FOR EACH ROW
+  EXECUTE FUNCTION updated_at();`.execute(db);
+  await sql`INSERT INTO "album_user_metadata" ("albumId", "userId", "isFavorite")
+  SELECT "id", "ownerId", false FROM "album"
+  ON CONFLICT ("albumId", "userId") DO NOTHING;`.execute(db);
+  await sql`INSERT INTO "album_user_metadata" ("albumId", "userId", "isFavorite")
+  SELECT "albumId", "userId", false FROM "album_user"
+  ON CONFLICT ("albumId", "userId") DO NOTHING;`.execute(db);
+  await sql`INSERT INTO "migration_overrides" ("name", "value") VALUES ('function_album_user_metadata_audit', '{"type":"function","name":"album_user_metadata_audit","sql":"CREATE OR REPLACE FUNCTION album_user_metadata_audit()\\n  RETURNS TRIGGER\\n  LANGUAGE PLPGSQL\\n  AS $$\\n    BEGIN\\n      INSERT INTO album_user_metadata_audit (\\"albumId\\", \\"userId\\")\\n      SELECT \\"albumId\\", \\"userId\\"\\n      FROM OLD;\\n      RETURN NULL;\\n    END\\n  $$;"}'::jsonb);`.execute(db);
+  await sql`INSERT INTO "migration_overrides" ("name", "value") VALUES ('trigger_album_user_metadata_audit', '{"type":"trigger","name":"album_user_metadata_audit","sql":"CREATE OR REPLACE TRIGGER \\"album_user_metadata_audit\\"\\n  AFTER DELETE ON \\"album_user_metadata\\"\\n  REFERENCING OLD TABLE AS \\"old\\"\\n  FOR EACH STATEMENT\\n  WHEN (pg_trigger_depth() = 0)\\n  EXECUTE FUNCTION album_user_metadata_audit();"}'::jsonb);`.execute(db);
+  await sql`INSERT INTO "migration_overrides" ("name", "value") VALUES ('trigger_album_user_metadata_updated_at', '{"type":"trigger","name":"album_user_metadata_updated_at","sql":"CREATE OR REPLACE TRIGGER \\"album_user_metadata_updated_at\\"\\n  BEFORE UPDATE ON \\"album_user_metadata\\"\\n  FOR EACH ROW\\n  EXECUTE FUNCTION updated_at();"}'::jsonb);`.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await sql`DROP TABLE "album_user_metadata_audit";`.execute(db);
+  await sql`DROP TABLE "album_user_metadata";`.execute(db);
+  await sql`DROP FUNCTION album_user_metadata_audit;`.execute(db);
+  await sql`DELETE FROM "migration_overrides" WHERE "name" = 'function_album_user_metadata_audit';`.execute(db);
+  await sql`DELETE FROM "migration_overrides" WHERE "name" = 'trigger_album_user_metadata_audit';`.execute(db);
+  await sql`DELETE FROM "migration_overrides" WHERE "name" = 'trigger_album_user_metadata_updated_at';`.execute(db);
+}

server/src/schema/tables/album-user-metadata-audit.table.ts

@@ -0,0 +1,17 @@
+import { Column, CreateDateColumn, Generated, Table, Timestamp } from '@immich/sql-tools';
+import { PrimaryGeneratedUuidV7Column } from 'src/decorators';
+
+@Table('album_user_metadata_audit')
+export class AlbumUserMetadataAuditTable {
+  @PrimaryGeneratedUuidV7Column()
+  id!: Generated<string>;
+
+  @Column({ type: 'uuid', index: true })
+  albumId!: string;
+
+  @Column({ type: 'uuid', index: true })
+  userId!: string;
+
+  @CreateDateColumn({ default: () => 'clock_timestamp()', index: true })
+  deletedAt!: Generated<Timestamp>;
+}

server/src/schema/tables/album-user-metadata.table.ts

@@ -0,0 +1,48 @@
+import {
+  AfterDeleteTrigger,
+  Column,
+  ForeignKeyColumn,
+  Generated,
+  Table,
+  Timestamp,
+  UpdateDateColumn,
+} from '@immich/sql-tools';
+import { UpdatedAtTrigger, UpdateIdColumn } from 'src/decorators';
+import { album_user_metadata_audit } from 'src/schema/functions';
+import { AlbumTable } from 'src/schema/tables/album.table';
+import { UserTable } from 'src/schema/tables/user.table';
+
+@UpdatedAtTrigger('album_user_metadata_updated_at')
+@Table('album_user_metadata')
+@AfterDeleteTrigger({
+  scope: 'statement',
+  function: album_user_metadata_audit,
+  referencingOldTableAs: 'old',
+  when: 'pg_trigger_depth() = 0',
+})
+export class AlbumUserMetadataTable {
+  @ForeignKeyColumn(() => AlbumTable, {
+    onUpdate: 'CASCADE',
+    onDelete: 'CASCADE',
+    primary: true,
+    index: false,
+  })
+  albumId!: string;
+
+  @ForeignKeyColumn(() => UserTable, {
+    onUpdate: 'CASCADE',
+    onDelete: 'CASCADE',
+    primary: true,
+    index: true,
+  })
+  userId!: string;
+
+  @Column({ type: 'boolean', default: false })
+  isFavorite!: Generated<boolean>;
+
+  @UpdateIdColumn({ index: true })
+  updateId!: Generated<string>;
+
+  @UpdateDateColumn({ index: true })
+  updatedAt!: Generated<Timestamp>;
+}

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

@@ -112,6 +112,23 @@ describe(AlbumService.name, () => {
       expect(mocks.album.getShared).toHaveBeenCalledTimes(1);
     });
 
+    it('includes favorite status in album lists', async () => {
+      const album = AlbumFactory.create();
+      mocks.album.getOwned.mockResolvedValue([{ ...getForAlbum(album), isFavorite: true }]);
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 0,
+          startDate: null,
+          endDate: null,
+          lastModifiedAssetTimestamp: null,
+        },
+      ]);
+
+      const result = await sut.getAll(AuthFactory.create(album.owner), {});
+      expect(result[0].isFavorite).toBe(true);
+    });
+
     it('gets list of albums that are NOT shared', async () => {
       const album = AlbumFactory.create();
       mocks.album.getNotShared.mockResolvedValue([getForAlbum(album)]);
@@ -337,12 +354,42 @@ describe(AlbumService.name, () => {
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.album.getById.mockResolvedValue(getForAlbum(album));
       mocks.album.update.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 0,
+          startDate: null,
+          endDate: null,
+          lastModifiedAssetTimestamp: null,
+        },
+      ]);
 
       await sut.update(AuthFactory.create(album.owner), album.id, { albumName: 'new album name' });
 
       expect(mocks.album.update).toHaveBeenCalledTimes(1);
       expect(mocks.album.update).toHaveBeenCalledWith(album.id, { id: album.id, albumName: 'new album name' });
     });
+
+    it('should preserve favorite status in the response', async () => {
+      const album = AlbumFactory.create();
+      mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
+      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.update.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue({ ...getForAlbum(album), isFavorite: true });
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 0,
+          startDate: null,
+          endDate: null,
+          lastModifiedAssetTimestamp: null,
+        },
+      ]);
+
+      const result = await sut.update(AuthFactory.create(album.owner), album.id, { albumName: 'new album name' });
+      expect(result.isFavorite).toBe(true);
+    });
   });
 
   describe('delete', () => {
@@ -430,7 +477,16 @@ describe(AlbumService.name, () => {
       const user = UserFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.album.getById.mockResolvedValue(getForAlbum(album));
-      mocks.album.update.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 0,
+          startDate: null,
+          endDate: null,
+          lastModifiedAssetTimestamp: null,
+        },
+      ]);
       mocks.user.get.mockResolvedValue(user);
       mocks.albumUser.create.mockResolvedValue(AlbumUserFactory.from().album(album).user(user).build());
 
@@ -468,7 +524,7 @@ describe(AlbumService.name, () => {
 
       expect(mocks.albumUser.delete).toHaveBeenCalledTimes(1);
       expect(mocks.albumUser.delete).toHaveBeenCalledWith({ albumId: album.id, userId });
-      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: false });
+      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: false }, undefined);
     });
 
     it('should prevent removing a shared user from a not-owned album (shared with auth user)', async () => {
@@ -565,10 +621,28 @@ describe(AlbumService.name, () => {
 
       await sut.get(AuthFactory.create(album.owner), album.id, {});
 
-      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: true });
+      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: true }, album.owner.id);
       expect(mocks.access.album.checkOwnerAccess).toHaveBeenCalledWith(album.owner.id, new Set([album.id]));
     });
 
+    it('should include favorite status for the authenticated user', async () => {
+      const album = AlbumFactory.create();
+      mocks.album.getById.mockResolvedValue({ ...getForAlbum(album), isFavorite: true });
+      mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 1,
+          startDate: new Date('1970-01-01'),
+          endDate: new Date('1970-01-01'),
+          lastModifiedAssetTimestamp: new Date('1970-01-01'),
+        },
+      ]);
+
+      const result = await sut.get(AuthFactory.create(album.owner), album.id, {});
+      expect(result.isFavorite).toBe(true);
+    });
+
     it('should get a shared album via a shared link', async () => {
       const album = AlbumFactory.from().albumUser().build();
       mocks.album.getById.mockResolvedValue(getForAlbum(album));
@@ -586,7 +660,7 @@ describe(AlbumService.name, () => {
       const auth = AuthFactory.from().sharedLink().build();
       await sut.get(auth, album.id, {});
 
-      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: true });
+      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: true }, auth.user.id);
       expect(mocks.access.album.checkSharedLinkAccess).toHaveBeenCalledWith(auth.sharedLink!.id, new Set([album.id]));
     });
 
@@ -607,7 +681,7 @@ describe(AlbumService.name, () => {
 
       await sut.get(AuthFactory.create(user), album.id, {});
 
-      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: true });
+      expect(mocks.album.getById).toHaveBeenCalledWith(album.id, { withAssets: true }, user.id);
       expect(mocks.access.album.checkSharedAlbumAccess).toHaveBeenCalledWith(
         user.id,
         new Set([album.id]),
@@ -615,6 +689,26 @@ describe(AlbumService.name, () => {
       );
     });
 
+    it('should not expose favorite status over shared links', async () => {
+      const album = AlbumFactory.create();
+      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.access.album.checkSharedLinkAccess.mockResolvedValue(new Set([album.id]));
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 1,
+          startDate: new Date('1970-01-01'),
+          endDate: new Date('1970-01-01'),
+          lastModifiedAssetTimestamp: new Date('1970-01-01'),
+        },
+      ]);
+
+      const auth = AuthFactory.from().sharedLink().build();
+      const result = await sut.get(auth, album.id, {});
+
+      expect(result.isFavorite).toBe(false);
+    });
+
     it('should throw an error for no access', async () => {
       const auth = AuthFactory.create();
       await expect(sut.get(auth, 'album-123', {})).rejects.toBeInstanceOf(BadRequestException);
@@ -628,6 +722,53 @@ describe(AlbumService.name, () => {
     });
   });
 
+  describe('updateAlbumUserMetadata', () => {
+    it('should update favorite status for an owned album', async () => {
+      const album = AlbumFactory.create();
+      mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
+      mocks.albumUserMetadata.upsert.mockResolvedValue();
+      mocks.album.getById.mockResolvedValue({ ...getForAlbum(album), isFavorite: true });
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 0,
+          startDate: null,
+          endDate: null,
+          lastModifiedAssetTimestamp: null,
+        },
+      ]);
+
+      const result = await sut.updateAlbumUserMetadata(AuthFactory.create(album.owner), album.id, { isFavorite: true });
+
+      expect(mocks.albumUserMetadata.upsert).toHaveBeenCalledWith({
+        albumId: album.id,
+        userId: album.owner.id,
+        isFavorite: true,
+      });
+      expect(result.isFavorite).toBe(true);
+    });
+
+    it('should allow shared viewers to update favorite status', async () => {
+      const viewer = UserFactory.create();
+      const album = AlbumFactory.from().albumUser({ userId: viewer.id, role: AlbumUserRole.Viewer }).build();
+      mocks.access.album.checkSharedAlbumAccess.mockResolvedValue(new Set([album.id]));
+      mocks.albumUserMetadata.upsert.mockResolvedValue();
+      mocks.album.getById.mockResolvedValue({ ...getForAlbum(album), isFavorite: true });
+      mocks.album.getMetadataForIds.mockResolvedValue([
+        {
+          albumId: album.id,
+          assetCount: 0,
+          startDate: null,
+          endDate: null,
+          lastModifiedAssetTimestamp: null,
+        },
+      ]);
+
+      const result = await sut.updateAlbumUserMetadata(AuthFactory.create(viewer), album.id, { isFavorite: true });
+      expect(result.isFavorite).toBe(true);
+    });
+  });
+
   describe('addAssets', () => {
     it('should allow the owner to add assets', async () => {
       const owner = UserFactory.create({ isAdmin: true });

server/src/services/album.service.ts

@@ -14,6 +14,7 @@ import {
   mapAlbumWithoutAssets,
   UpdateAlbumDto,
   UpdateAlbumUserDto,
+  UpdateAlbumUserMetadataDto,
 } from 'src/dtos/album.dto';
 import { BulkIdErrorReason, BulkIdResponseDto, BulkIdsDto } from 'src/dtos/asset-ids.response.dto';
 import { AuthDto } from 'src/dtos/auth.dto';
@@ -77,7 +78,7 @@ export class AlbumService extends BaseService {
     await this.requireAccess({ auth, permission: Permission.AlbumRead, ids: [id] });
     await this.albumRepository.updateThumbnails();
     const withAssets = dto.withoutAssets === undefined ? true : !dto.withoutAssets;
-    const album = await this.findOrFail(id, { withAssets });
+    const album = await this.findOrFail(id, { withAssets }, auth.user.id);
     const [albumMetadataForIds] = await this.albumRepository.getMetadataForIds([album.id]);
 
     const hasSharedUsers = album.albumUsers && album.albumUsers.length > 0;
@@ -147,7 +148,7 @@ export class AlbumService extends BaseService {
         throw new BadRequestException('Invalid album thumbnail');
       }
     }
-    const updatedAlbum = await this.albumRepository.update(album.id, {
+    await this.albumRepository.update(album.id, {
       id: album.id,
       albumName: dto.albumName,
       description: dto.description,
@@ -156,7 +157,15 @@ export class AlbumService extends BaseService {
       order: dto.order,
     });
 
-    return mapAlbumWithoutAssets({ ...updatedAlbum, assets: album.assets });
+    return this.get(auth, id, { withoutAssets: true });
+  }
+
+  async updateAlbumUserMetadata(auth: AuthDto, id: string, dto: UpdateAlbumUserMetadataDto): Promise<AlbumResponseDto> {
+    await this.requireAccess({ auth, permission: Permission.AlbumRead, ids: [id] });
+
+    await this.albumUserMetadataRepository.upsert({ albumId: id, userId: auth.user.id, isFavorite: dto.isFavorite });
+
+    return this.get(auth, id, { withoutAssets: true });
   }
 
   async delete(auth: AuthDto, id: string): Promise<void> {
@@ -306,7 +315,7 @@ export class AlbumService extends BaseService {
       await this.eventRepository.emit('AlbumInvite', { id, userId });
     }
 
-    return this.findOrFail(id, { withAssets: true }).then(mapAlbumWithoutAssets);
+    return this.get(auth, id, { withoutAssets: true });
   }
 
   async removeUser(auth: AuthDto, id: string, userId: string | 'me'): Promise<void> {
@@ -338,8 +347,8 @@ export class AlbumService extends BaseService {
     await this.albumUserRepository.update({ albumId: id, userId }, { role: dto.role });
   }
 
-  private async findOrFail(id: string, options: AlbumInfoOptions) {
-    const album = await this.albumRepository.getById(id, options);
+  private async findOrFail(id: string, options: AlbumInfoOptions, userId?: string) {
+    const album = await this.albumRepository.getById(id, options, userId);
     if (!album) {
       throw new BadRequestException('Album not found');
     }

server/src/services/asset-media.service.spec.ts

@@ -9,7 +9,7 @@ import { AssetMediaStatus, AssetRejectReason, AssetUploadAction } from 'src/dtos
 import { AssetMediaCreateDto, AssetMediaSize, UploadFieldName } from 'src/dtos/asset-media.dto';
 import { MapAsset } from 'src/dtos/asset-response.dto';
 import { AssetEditAction } from 'src/dtos/editing.dto';
-import { AssetFileType, AssetStatus, AssetType, AssetVisibility, CacheControl, JobName } from 'src/enum';
+import { AssetFileType, AssetType, AssetVisibility, CacheControl, JobName } from 'src/enum';
 import { AuthRequest } from 'src/middleware/auth.guard';
 import { AssetMediaService } from 'src/services/asset-media.service';
 import { UploadBody } from 'src/types';
@@ -191,11 +191,7 @@ describe(AssetMediaService.name, () => {
     });
 
     it('should find an existing asset', async () => {
-      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue({
-        id: 'asset-id',
-        createdAt: new Date(),
-        status: AssetStatus.Active,
-      });
+      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue('asset-id');
       await expect(sut.getUploadAssetIdByChecksum(authStub.admin, file1.toString('hex'))).resolves.toEqual({
         id: 'asset-id',
         status: AssetMediaStatus.DUPLICATE,
@@ -204,11 +200,7 @@ describe(AssetMediaService.name, () => {
     });
 
     it('should find an existing asset by base64', async () => {
-      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue({
-        id: 'asset-id',
-        createdAt: new Date(),
-        status: AssetStatus.Active,
-      });
+      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue('asset-id');
       await expect(sut.getUploadAssetIdByChecksum(authStub.admin, file1.toString('base64'))).resolves.toEqual({
         id: 'asset-id',
         status: AssetMediaStatus.DUPLICATE,
@@ -371,11 +363,7 @@ describe(AssetMediaService.name, () => {
       (error as any).constraint_name = ASSET_CHECKSUM_CONSTRAINT;
 
       mocks.asset.create.mockRejectedValue(error);
-      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue({
-        id: assetEntity.id,
-        createdAt: new Date(),
-        status: AssetStatus.Active,
-      });
+      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue(assetEntity.id);
 
       await expect(sut.uploadAsset(authStub.user1, createDto, file)).resolves.toEqual({
         id: 'id_1',

server/src/services/asset-media.service.ts

@@ -53,12 +53,12 @@ export class AssetMediaService extends BaseService {
       return;
     }
 
-    const asset = await this.assetRepository.getUploadAssetIdByChecksum(auth.user.id, fromChecksum(checksum));
-    if (!asset) {
+    const assetId = await this.assetRepository.getUploadAssetIdByChecksum(auth.user.id, fromChecksum(checksum));
+    if (!assetId) {
       return;
     }
 
-    return { id: asset.id, status: AssetMediaStatus.DUPLICATE };
+    return { id: assetId, status: AssetMediaStatus.DUPLICATE };
   }
 
   canUploadFile({ auth, fieldName, file, body }: UploadRequest): true {
@@ -179,10 +179,6 @@ export class AssetMediaService extends BaseService {
         throw new Error('Asset not found');
       }
 
-      if (asset.status === AssetStatus.Partial) {
-        throw new BadRequestException('Cannot replace a partial asset');
-      }
-
       this.requireQuota(auth, file.size);
 
       await this.replaceFileData(asset.id, dto, file, sidecarFile?.originalPath);
@@ -351,18 +347,18 @@ export class AssetMediaService extends BaseService {
 
     // handle duplicates with a success response
     if (isAssetChecksumConstraint(error)) {
-      const duplicate = await this.assetRepository.getUploadAssetIdByChecksum(auth.user.id, file.checksum);
-      if (!duplicate) {
+      const duplicateId = await this.assetRepository.getUploadAssetIdByChecksum(auth.user.id, file.checksum);
+      if (!duplicateId) {
         this.logger.error(`Error locating duplicate for checksum constraint`);
         throw new InternalServerErrorException();
       }
 
       if (auth.sharedLink) {
-        await this.addToSharedLink(auth.sharedLink, duplicate.id);
+        await this.addToSharedLink(auth.sharedLink, duplicateId);
       }
 
-      this.logger.debug(`Duplicate asset upload rejected: existing asset ${duplicate.id}`);
-      return { status: AssetMediaStatus.DUPLICATE, id: duplicate.id };
+      this.logger.debug(`Duplicate asset upload rejected: existing asset ${duplicateId}`);
+      return { status: AssetMediaStatus.DUPLICATE, id: duplicateId };
     }
 
     this.logger.error(`Error uploading file ${error}`, error?.stack);

server/src/services/asset-upload.service.spec.ts

@@ -1,456 +0,0 @@
-import { BadRequestException, InternalServerErrorException } from '@nestjs/common';
-import { AssetMetadataKey, AssetStatus, AssetType, AssetVisibility, JobName, JobStatus } from 'src/enum';
-import { AssetUploadService } from 'src/services/asset-upload.service';
-import { ASSET_CHECKSUM_CONSTRAINT } from 'src/utils/database';
-import { authStub } from 'test/fixtures/auth.stub';
-import { factory } from 'test/small.factory';
-import { newTestService, ServiceMocks } from 'test/utils';
-
-describe(AssetUploadService.name, () => {
-  let sut: AssetUploadService;
-  let mocks: ServiceMocks;
-
-  beforeEach(() => {
-    ({ sut, mocks } = newTestService(AssetUploadService));
-  });
-
-  describe('onStart', () => {
-    const mockDto = {
-      assetData: {
-        filename: 'test.jpg',
-        deviceAssetId: 'device-asset-1',
-        deviceId: 'device-1',
-        fileCreatedAt: new Date('2025-01-01T00:00:00Z'),
-        fileModifiedAt: new Date('2025-01-01T12:00:00Z'),
-        isFavorite: false,
-        iCloudId: '',
-      },
-      checksum: Buffer.from('checksum'),
-      uploadLength: 1024,
-      uploadComplete: true,
-      contentLength: 1024,
-      isComplete: true,
-      version: 8,
-    };
-
-    it('should create a new asset and return upload metadata', async () => {
-      const assetId = factory.uuid();
-      mocks.crypto.randomUUID.mockReturnValue(assetId);
-
-      const result = await sut.onStart(authStub.user1, mockDto);
-
-      expect(result).toEqual({
-        id: assetId,
-        path: expect.stringContaining(assetId),
-        status: AssetStatus.Partial,
-        isDuplicate: false,
-      });
-
-      expect(mocks.asset.createWithMetadata).toHaveBeenCalledWith(
-        expect.objectContaining({
-          id: assetId,
-          ownerId: authStub.user1.user.id,
-          checksum: mockDto.checksum,
-          deviceAssetId: mockDto.assetData.deviceAssetId,
-          deviceId: mockDto.assetData.deviceId,
-          fileCreatedAt: mockDto.assetData.fileCreatedAt,
-          fileModifiedAt: mockDto.assetData.fileModifiedAt,
-          type: AssetType.Image,
-          isFavorite: false,
-          status: AssetStatus.Partial,
-          visibility: AssetVisibility.Hidden,
-          originalFileName: 'test.jpg',
-        }),
-        1024,
-        undefined,
-      );
-    });
-
-    it('should determine asset type from filename extension', async () => {
-      const videoDto = { ...mockDto, assetData: { ...mockDto.assetData, filename: 'video.mp4' } };
-      mocks.crypto.randomUUID.mockReturnValue(factory.uuid());
-
-      await sut.onStart(authStub.user1, videoDto);
-
-      expect(mocks.asset.createWithMetadata).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: AssetType.Video,
-        }),
-        expect.anything(),
-        undefined,
-      );
-    });
-
-    it('should throw BadRequestException for unsupported file types', async () => {
-      const unsupportedDto = { ...mockDto, assetData: { ...mockDto.assetData, filename: 'document.xyz' } };
-
-      await expect(sut.onStart(authStub.user1, unsupportedDto)).rejects.toThrow(BadRequestException);
-      await expect(sut.onStart(authStub.user1, unsupportedDto)).rejects.toThrow('unsupported file type');
-    });
-
-    it('should validate quota before creating asset', async () => {
-      const authWithQuota = {
-        ...authStub.user1,
-        user: {
-          ...authStub.user1.user,
-          quotaSizeInBytes: 2000,
-          quotaUsageInBytes: 1500,
-        },
-      };
-
-      await expect(sut.onStart(authWithQuota, mockDto)).rejects.toThrow(BadRequestException);
-      await expect(sut.onStart(authWithQuota, mockDto)).rejects.toThrow('Quota has been exceeded');
-    });
-
-    it('should allow upload when quota is null (unlimited)', async () => {
-      const authWithUnlimitedQuota = {
-        ...authStub.user1,
-        user: {
-          ...authStub.user1.user,
-          quotaSizeInBytes: null,
-          quotaUsageInBytes: 1000,
-        },
-      };
-
-      mocks.crypto.randomUUID.mockReturnValue(factory.uuid());
-
-      await expect(sut.onStart(authWithUnlimitedQuota, mockDto)).resolves.toBeDefined();
-    });
-
-    it('should allow upload when within quota', async () => {
-      const authWithQuota = {
-        ...authStub.user1,
-        user: {
-          ...authStub.user1.user,
-          quotaSizeInBytes: 5000,
-          quotaUsageInBytes: 1000,
-        },
-      };
-
-      mocks.crypto.randomUUID.mockReturnValue(factory.uuid());
-
-      const result = await sut.onStart(authWithQuota, mockDto);
-
-      expect(result.isDuplicate).toBe(false);
-    });
-
-    it('should handle duplicate detection via checksum constraint', async () => {
-      const existingAssetId = factory.uuid();
-      const checksumError = new Error('duplicate key value violates unique constraint');
-      (checksumError as any).constraint_name = ASSET_CHECKSUM_CONSTRAINT;
-
-      mocks.asset.createWithMetadata.mockRejectedValue(checksumError);
-      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue({
-        id: existingAssetId,
-        status: AssetStatus.Partial,
-        createdAt: new Date(),
-      });
-
-      const result = await sut.onStart(authStub.user1, mockDto);
-
-      expect(result).toEqual({
-        id: existingAssetId,
-        path: expect.any(String),
-        status: AssetStatus.Partial,
-        isDuplicate: true,
-      });
-
-      expect(mocks.asset.getUploadAssetIdByChecksum).toHaveBeenCalledWith(authStub.user1.user.id, mockDto.checksum);
-    });
-
-    it('should throw InternalServerErrorException if duplicate lookup fails', async () => {
-      const checksumError = new Error('duplicate key value violates unique constraint');
-      (checksumError as any).constraint_name = ASSET_CHECKSUM_CONSTRAINT;
-
-      mocks.asset.createWithMetadata.mockRejectedValue(checksumError);
-      // eslint-disable-next-line unicorn/no-useless-undefined
-      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue(undefined);
-
-      await expect(sut.onStart(authStub.user1, mockDto)).rejects.toThrow(InternalServerErrorException);
-    });
-
-    it('should throw InternalServerErrorException for non-checksum errors', async () => {
-      const genericError = new Error('database connection failed');
-      mocks.asset.createWithMetadata.mockRejectedValue(genericError);
-
-      await expect(sut.onStart(authStub.user1, mockDto)).rejects.toThrow(InternalServerErrorException);
-    });
-
-    it('should include iCloud metadata when provided', async () => {
-      const dtoWithICloud = {
-        ...mockDto,
-        assetData: {
-          ...mockDto.assetData,
-          iCloudId: 'icloud-123',
-        },
-      };
-
-      mocks.crypto.randomUUID.mockReturnValue(factory.uuid());
-
-      await sut.onStart(authStub.user1, dtoWithICloud);
-
-      expect(mocks.asset.createWithMetadata).toHaveBeenCalledWith(expect.anything(), expect.anything(), [
-        { key: AssetMetadataKey.MobileApp, value: { iCloudId: 'icloud-123' } },
-      ]);
-    });
-
-    it('should set isFavorite when true', async () => {
-      const favoriteDto = {
-        ...mockDto,
-        assetData: {
-          ...mockDto.assetData,
-          isFavorite: true,
-        },
-      };
-
-      mocks.crypto.randomUUID.mockReturnValue(factory.uuid());
-
-      await sut.onStart(authStub.user1, favoriteDto);
-
-      expect(mocks.asset.createWithMetadata).toHaveBeenCalledWith(
-        expect.objectContaining({
-          isFavorite: true,
-        }),
-        expect.anything(),
-        undefined,
-      );
-    });
-  });
-
-  describe('onComplete', () => {
-    const assetId = factory.uuid();
-    const path = `/upload/${assetId}/file.jpg`;
-    const fileModifiedAt = new Date('2025-01-01T12:00:00Z');
-
-    it('should mark asset as complete and queue metadata extraction job', async () => {
-      await sut.onComplete({ id: assetId, path, fileModifiedAt });
-
-      expect(mocks.asset.setComplete).toHaveBeenCalledWith(assetId);
-      expect(mocks.job.queue).toHaveBeenCalledWith({
-        name: JobName.AssetExtractMetadata,
-        data: { id: assetId, source: 'upload' },
-      });
-    });
-
-    it('should update file modification time', async () => {
-      await sut.onComplete({ id: assetId, path, fileModifiedAt });
-
-      expect(mocks.storage.utimes).toHaveBeenCalledWith(path, expect.any(Date), fileModifiedAt);
-    });
-
-    it('should handle utimes failure gracefully', async () => {
-      mocks.storage.utimes.mockRejectedValue(new Error('Permission denied'));
-
-      await expect(sut.onComplete({ id: assetId, path, fileModifiedAt })).resolves.toBeUndefined();
-
-      // Should still complete asset and queue job
-      expect(mocks.asset.setComplete).toHaveBeenCalled();
-      expect(mocks.job.queue).toHaveBeenCalled();
-    });
-
-    it('should retry setComplete on transient failures', async () => {
-      mocks.asset.setComplete
-        .mockRejectedValueOnce(new Error('Transient error'))
-        .mockRejectedValueOnce(new Error('Transient error'))
-        .mockResolvedValue();
-
-      await sut.onComplete({ id: assetId, path, fileModifiedAt });
-
-      expect(mocks.asset.setComplete).toHaveBeenCalledTimes(3);
-    });
-
-    it('should retry job queueing on transient failures', async () => {
-      mocks.job.queue.mockRejectedValueOnce(new Error('Transient error')).mockResolvedValue();
-
-      await sut.onComplete({ id: assetId, path, fileModifiedAt });
-
-      expect(mocks.job.queue).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('onCancel', () => {
-    const assetId = factory.uuid();
-    const path = `/upload/${assetId}/file.jpg`;
-
-    it('should delete file and remove asset record', async () => {
-      await sut.onCancel(assetId, path);
-
-      expect(mocks.storage.unlink).toHaveBeenCalledWith(path);
-      expect(mocks.asset.removeAndDecrementQuota).toHaveBeenCalledWith(assetId);
-    });
-
-    it('should retry unlink on transient failures', async () => {
-      mocks.storage.unlink.mockRejectedValueOnce(new Error('Transient error')).mockResolvedValue();
-
-      await sut.onCancel(assetId, path);
-
-      expect(mocks.storage.unlink).toHaveBeenCalledTimes(2);
-    });
-
-    it('should retry removeAndDecrementQuota on transient failures', async () => {
-      mocks.asset.removeAndDecrementQuota.mockRejectedValueOnce(new Error('Transient error')).mockResolvedValue();
-
-      await sut.onCancel(assetId, path);
-
-      expect(mocks.asset.removeAndDecrementQuota).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('removeStaleUploads', () => {
-    it('should queue cleanup jobs for stale partial assets', async () => {
-      const staleAssets = [{ id: factory.uuid() }, { id: factory.uuid() }, { id: factory.uuid() }];
-
-      mocks.assetJob.streamForPartialAssetCleanupJob.mockReturnValue(
-        // eslint-disable-next-line @typescript-eslint/require-await
-        (async function* () {
-          for (const asset of staleAssets) {
-            yield asset;
-          }
-        })(),
-      );
-
-      await sut.removeStaleUploads();
-
-      expect(mocks.assetJob.streamForPartialAssetCleanupJob).toHaveBeenCalledWith(expect.any(Date));
-
-      expect(mocks.job.queueAll).toHaveBeenCalledWith([
-        { name: JobName.PartialAssetCleanup, data: staleAssets[0] },
-        { name: JobName.PartialAssetCleanup, data: staleAssets[1] },
-        { name: JobName.PartialAssetCleanup, data: staleAssets[2] },
-      ]);
-    });
-
-    it('should batch cleanup jobs', async () => {
-      const assets = Array.from({ length: 1500 }, () => ({ id: factory.uuid() }));
-
-      mocks.assetJob.streamForPartialAssetCleanupJob.mockReturnValue(
-        // eslint-disable-next-line @typescript-eslint/require-await
-        (async function* () {
-          for (const asset of assets) {
-            yield asset;
-          }
-        })(),
-      );
-
-      await sut.removeStaleUploads();
-
-      // Should be called twice: once for 1000, once for 500
-      expect(mocks.job.queueAll).toHaveBeenCalledTimes(2);
-    });
-
-    it('should handle empty stream', async () => {
-      mocks.assetJob.streamForPartialAssetCleanupJob.mockReturnValue((async function* () {})());
-
-      await sut.removeStaleUploads();
-
-      expect(mocks.job.queueAll).toHaveBeenCalledWith([]);
-    });
-  });
-
-  describe('removeStaleUpload', () => {
-    const assetId = factory.uuid();
-    const path = `/upload/${assetId}/file.jpg`;
-
-    it('should skip if asset not found', async () => {
-      // eslint-disable-next-line unicorn/no-useless-undefined
-      mocks.assetJob.getForPartialAssetCleanupJob.mockResolvedValue(undefined);
-
-      const result = await sut.removeStaleUpload({ id: assetId });
-
-      expect(result).toBe(JobStatus.Skipped);
-      expect(mocks.storage.stat).not.toHaveBeenCalled();
-    });
-
-    it('should complete asset if file matches expected state', async () => {
-      const checksum = Buffer.from('checksum');
-      const fileModifiedAt = new Date();
-
-      mocks.assetJob.getForPartialAssetCleanupJob.mockResolvedValue({
-        path,
-        checksum,
-        fileModifiedAt,
-        size: 1024,
-      });
-
-      mocks.storage.stat.mockResolvedValue({ size: 1024 } as any);
-      mocks.crypto.hashFile.mockResolvedValue(checksum);
-
-      const result = await sut.removeStaleUpload({ id: assetId });
-
-      expect(result).toBe(JobStatus.Success);
-      expect(mocks.asset.setComplete).toHaveBeenCalledWith(assetId);
-      expect(mocks.storage.unlink).not.toHaveBeenCalled();
-    });
-
-    it('should cancel asset if file size does not match', async () => {
-      mocks.assetJob.getForPartialAssetCleanupJob.mockResolvedValue({
-        path,
-        checksum: Buffer.from('checksum'),
-        fileModifiedAt: new Date(),
-        size: 1024,
-      });
-
-      mocks.storage.stat.mockResolvedValue({ size: 512 } as any);
-
-      const result = await sut.removeStaleUpload({ id: assetId });
-
-      expect(result).toBe(JobStatus.Success);
-      expect(mocks.storage.unlink).toHaveBeenCalledWith(path);
-      expect(mocks.asset.removeAndDecrementQuota).toHaveBeenCalledWith(assetId);
-    });
-
-    it('should cancel asset if checksum does not match', async () => {
-      mocks.assetJob.getForPartialAssetCleanupJob.mockResolvedValue({
-        path,
-        checksum: Buffer.from('expected-checksum'),
-        fileModifiedAt: new Date(),
-        size: 1024,
-      });
-
-      mocks.storage.stat.mockResolvedValue({ size: 1024 } as any);
-      mocks.crypto.hashFile.mockResolvedValue(Buffer.from('actual-checksum'));
-
-      const result = await sut.removeStaleUpload({ id: assetId });
-
-      expect(result).toBe(JobStatus.Success);
-      expect(mocks.storage.unlink).toHaveBeenCalledWith(path);
-      expect(mocks.asset.removeAndDecrementQuota).toHaveBeenCalledWith(assetId);
-    });
-
-    it('should cancel asset if file does not exist', async () => {
-      mocks.assetJob.getForPartialAssetCleanupJob.mockResolvedValue({
-        path,
-        checksum: Buffer.from('checksum'),
-        fileModifiedAt: new Date(),
-        size: 1024,
-      });
-
-      const error = new Error('File not found') as NodeJS.ErrnoException;
-      error.code = 'ENOENT';
-      mocks.storage.stat.mockRejectedValue(error);
-
-      const result = await sut.removeStaleUpload({ id: assetId });
-
-      expect(result).toBe(JobStatus.Success);
-      expect(mocks.asset.removeAndDecrementQuota).toHaveBeenCalledWith(assetId);
-    });
-
-    it('should cancel asset if stat fails with permission error', async () => {
-      mocks.assetJob.getForPartialAssetCleanupJob.mockResolvedValue({
-        path,
-        checksum: Buffer.from('checksum'),
-        fileModifiedAt: new Date(),
-        size: 1024,
-      });
-
-      const error = new Error('Permission denied') as NodeJS.ErrnoException;
-      error.code = 'EACCES';
-      mocks.storage.stat.mockRejectedValue(error);
-
-      const result = await sut.removeStaleUpload({ id: assetId });
-
-      expect(result).toBe(JobStatus.Success);
-      expect(mocks.asset.removeAndDecrementQuota).toHaveBeenCalledWith(assetId);
-    });
-  });
-});

server/src/services/asset-upload.service.ts

@@ -1,466 +0,0 @@
-import { BadRequestException, Injectable, InternalServerErrorException } from '@nestjs/common';
-import { Response } from 'express';
-import { DateTime } from 'luxon';
-import { createHash } from 'node:crypto';
-import { dirname, extname, join } from 'node:path';
-import { Readable, Writable } from 'node:stream';
-import { SystemConfig } from 'src/config';
-import { JOBS_ASSET_PAGINATION_SIZE } from 'src/constants';
-import { StorageCore } from 'src/cores/storage.core';
-import { AuthSharedLink } from 'src/database';
-import { OnEvent, OnJob } from 'src/decorators';
-import { GetUploadStatusDto, ResumeUploadDto, StartUploadDto } from 'src/dtos/asset-upload.dto';
-import { AuthDto } from 'src/dtos/auth.dto';
-import {
-  AssetMetadataKey,
-  AssetStatus,
-  AssetType,
-  AssetVisibility,
-  ChecksumAlgorithm,
-  ImmichWorker,
-  JobName,
-  JobStatus,
-  QueueName,
-  StorageFolder,
-} from 'src/enum';
-import { ArgOf } from 'src/repositories/event.repository';
-import { BaseService } from 'src/services/base.service';
-import { JobItem, JobOf } from 'src/types';
-import { isAssetChecksumConstraint } from 'src/utils/database';
-import { mimeTypes } from 'src/utils/mime-types';
-import { withRetry } from 'src/utils/misc';
-
-export const MAX_RUFH_INTEROP_VERSION = 8;
-type CompletionData = { id: string; path: string; fileModifiedAt: Date; sharedLink?: AuthSharedLink };
-
-@Injectable()
-export class AssetUploadService extends BaseService {
-  // This is used to proactively abort previous requests for the same asset
-  // when a new one arrives. The previous request still holds the asset lock
-  // and will prevent the new request from proceeding until the previous one
-  // times out. As normal client behavior will not have concurrent requests,
-  // we can assume the previous request has already failed on the client end.
-  private activeRequests = new Map<string, { req: Readable; startTime: Date }>();
-
-  @OnEvent({ name: 'UploadAbort', workers: [ImmichWorker.Api], server: true })
-  onUploadAbort({ assetId, abortTime }: ArgOf<'UploadAbort'>) {
-    const entry = this.activeRequests.get(assetId);
-    if (!entry) {
-      return false;
-    }
-    if (abortTime > entry.startTime) {
-      entry.req.destroy();
-      this.activeRequests.delete(assetId);
-    }
-    return true;
-  }
-
-  async startUpload(auth: AuthDto, req: Readable, res: Response, dto: StartUploadDto): Promise<void> {
-    this.logger.verboseFn(() => `Starting upload: ${JSON.stringify(dto)}`);
-    const { uploadComplete, assetData, uploadLength, contentLength, version } = dto;
-    const isComplete = uploadComplete !== false;
-    const isResumable = version && uploadComplete !== undefined;
-    const { backup } = await this.getConfig({ withCache: true });
-
-    const { id, path, status, isDuplicate } = await this.onStart(auth, dto);
-    const location = `/api/upload/${id}`;
-    if (isDuplicate) {
-      if (status !== AssetStatus.Partial) {
-        return this.sendAlreadyCompleted(res);
-      }
-
-      if (isResumable) {
-        this.sendInterimResponse(res, location, version, this.getUploadLimits(backup));
-        // this is a 5xx to indicate the client should do offset retrieval and resume
-        res.status(500).send('Incomplete asset already exists');
-        return;
-      }
-    }
-
-    if (isComplete && uploadLength !== contentLength) {
-      return this.sendInconsistentLength(res);
-    }
-
-    if (isResumable) {
-      this.sendInterimResponse(res, location, version, this.getUploadLimits(backup));
-    }
-
-    this.addRequest(id, req);
-    await this.databaseRepository.withUuidLock(id, async () => {
-      // conventional upload, check status again with lock acquired before overwriting
-      if (isDuplicate) {
-        const existingAsset = await this.assetRepository.getCompletionMetadata(id, auth.user.id);
-        if (existingAsset?.status !== AssetStatus.Partial) {
-          return this.sendAlreadyCompleted(res);
-        }
-      }
-      await this.storageRepository.mkdir(dirname(path));
-
-      let checksumBuffer: Buffer | undefined;
-      const writeStream = isDuplicate
-        ? this.storageRepository.createWriteStream(path, { flush: isComplete })
-        : this.storageRepository.createOrAppendWriteStream(path, { flush: isComplete });
-      this.pipe(req, writeStream, contentLength);
-      if (isComplete) {
-        const hash = createHash('sha1');
-        req.on('data', (data: Buffer) => hash.update(data));
-        writeStream.on('finish', () => (checksumBuffer = hash.digest()));
-      }
-      await new Promise((resolve, reject) => writeStream.on('close', resolve).on('error', reject));
-      if (isResumable) {
-        this.setCompleteHeader(res, version, uploadComplete);
-      }
-      if (!isComplete) {
-        res.status(201).set('Location', location).setHeader('Upload-Limit', this.getUploadLimits(backup)).send();
-        return;
-      }
-      if (dto.checksum.compare(checksumBuffer!) !== 0) {
-        return await this.sendChecksumMismatch(res, id, path);
-      }
-
-      await this.onComplete({ id, path, fileModifiedAt: assetData.fileModifiedAt, sharedLink: auth.sharedLink });
-      res.status(200).send({ id });
-    });
-  }
-
-  resumeUpload(auth: AuthDto, req: Readable, res: Response, id: string, dto: ResumeUploadDto): Promise<void> {
-    this.logger.verboseFn(() => `Resuming upload for ${id}: ${JSON.stringify(dto)}`);
-    const { uploadComplete, uploadLength, uploadOffset, contentLength, version } = dto;
-    this.setCompleteHeader(res, version, false);
-    this.addRequest(id, req);
-    return this.databaseRepository.withUuidLock(id, async () => {
-      const completionData = await this.assetRepository.getCompletionMetadata(id, auth.user.id);
-      if (!completionData) {
-        res.status(404).send('Asset not found');
-        return;
-      }
-      const { fileModifiedAt, path, status, checksum: providedChecksum, size } = completionData;
-
-      if (status !== AssetStatus.Partial) {
-        return this.sendAlreadyCompleted(res);
-      }
-
-      if (uploadLength && size && size !== uploadLength) {
-        return this.sendInconsistentLength(res);
-      }
-
-      const expectedOffset = await this.getCurrentOffset(path);
-      if (expectedOffset !== uploadOffset) {
-        return this.sendOffsetMismatch(res, expectedOffset, uploadOffset);
-      }
-
-      const newLength = uploadOffset + contentLength;
-      if (uploadLength !== undefined && newLength > uploadLength) {
-        res.status(400).send('Upload would exceed declared length');
-        return;
-      }
-
-      if (contentLength === 0 && !uploadComplete) {
-        res.status(204).setHeader('Upload-Offset', expectedOffset.toString()).send();
-        return;
-      }
-
-      const writeStream = this.storageRepository.createOrAppendWriteStream(path, { flush: uploadComplete });
-      this.pipe(req, writeStream, contentLength);
-      await new Promise((resolve, reject) => writeStream.on('close', resolve).on('error', reject));
-      this.setCompleteHeader(res, version, uploadComplete);
-      if (!uploadComplete) {
-        try {
-          const offset = await this.getCurrentOffset(path);
-          res.status(204).setHeader('Upload-Offset', offset.toString()).send();
-        } catch {
-          this.logger.error(`Failed to get current offset for ${path} after write`);
-          res.status(500).send();
-        }
-        return;
-      }
-
-      const checksum = await this.cryptoRepository.hashFile(path);
-      if (providedChecksum.compare(checksum) !== 0) {
-        return await this.sendChecksumMismatch(res, id, path);
-      }
-
-      await this.onComplete({ id, path, fileModifiedAt, sharedLink: auth.sharedLink });
-      res.status(200).send({ id });
-    });
-  }
-
-  cancelUpload(auth: AuthDto, assetId: string, res: Response): Promise<void> {
-    this.abortExistingRequest(assetId);
-    return this.databaseRepository.withUuidLock(assetId, async () => {
-      const asset = await this.assetRepository.getCompletionMetadata(assetId, auth.user.id);
-      if (!asset) {
-        res.status(404).send('Asset not found');
-        return;
-      }
-      if (asset.status !== AssetStatus.Partial) {
-        return this.sendAlreadyCompleted(res);
-      }
-      await this.onCancel(assetId, asset.path);
-      res.status(204).send();
-    });
-  }
-
-  async getUploadStatus(auth: AuthDto, res: Response, id: string, { version }: GetUploadStatusDto): Promise<void> {
-    this.logger.verboseFn(() => `Getting upload status for ${id} with version ${version}`);
-    const { backup } = await this.getConfig({ withCache: true });
-    this.abortExistingRequest(id);
-    return this.databaseRepository.withUuidLock(id, async () => {
-      const asset = await this.assetRepository.getCompletionMetadata(id, auth.user.id);
-      if (!asset) {
-        res.status(404).send('Asset not found');
-        return;
-      }
-
-      const offset = await this.getCurrentOffset(asset.path);
-      this.setCompleteHeader(res, version, asset.status !== AssetStatus.Partial);
-      res.status(204).setHeader('Upload-Offset', offset.toString()).setHeader('Cache-Control', 'no-store');
-      if (asset.size) {
-        res.setHeader('Upload-Length', asset.size.toString());
-      }
-      res.setHeader('Upload-Limit', this.getUploadLimits(backup)).send();
-    });
-  }
-
-  async getUploadOptions(res: Response): Promise<void> {
-    const { backup } = await this.getConfig({ withCache: true });
-    res
-      .status(204)
-      .setHeader('Accept-Patch', 'application/partial-upload')
-      .setHeader('Upload-Limit', this.getUploadLimits(backup))
-      .send();
-  }
-
-  @OnJob({ name: JobName.PartialAssetCleanupQueueAll, queue: QueueName.BackgroundTask })
-  async removeStaleUploads(): Promise<void> {
-    const config = await this.getConfig({ withCache: false });
-    const createdBefore = DateTime.now().minus({ hours: config.backup.upload.maxAgeHours }).toJSDate();
-    let jobs: JobItem[] = [];
-    const assets = this.assetJobRepository.streamForPartialAssetCleanupJob(createdBefore);
-    for await (const asset of assets) {
-      jobs.push({ name: JobName.PartialAssetCleanup, data: asset });
-      if (jobs.length >= JOBS_ASSET_PAGINATION_SIZE) {
-        await this.jobRepository.queueAll(jobs);
-        jobs = [];
-      }
-    }
-    await this.jobRepository.queueAll(jobs);
-  }
-
-  @OnJob({ name: JobName.PartialAssetCleanup, queue: QueueName.BackgroundTask })
-  removeStaleUpload({ id }: JobOf<JobName.PartialAssetCleanup>): Promise<JobStatus> {
-    return this.databaseRepository.withUuidLock(id, async () => {
-      const asset = await this.assetJobRepository.getForPartialAssetCleanupJob(id);
-      if (!asset) {
-        return JobStatus.Skipped;
-      }
-      const { checksum, fileModifiedAt, path, size } = asset;
-      try {
-        const stat = await this.storageRepository.stat(path);
-        if (size === stat.size && checksum === (await this.cryptoRepository.hashFile(path))) {
-          await this.onComplete({ id, path, fileModifiedAt });
-          return JobStatus.Success;
-        }
-      } catch (error: any) {
-        this.logger.debugFn(() => `Failed to check upload file ${path}: ${error.message}`);
-      }
-      await this.onCancel(id, path);
-      return JobStatus.Success;
-    });
-  }
-
-  async onStart(
-    auth: AuthDto,
-    { assetData, checksum, uploadLength }: StartUploadDto,
-  ): Promise<{ id: string; path: string; status: AssetStatus; isDuplicate: boolean }> {
-    const assetId = this.cryptoRepository.randomUUID();
-    const folder = StorageCore.getNestedFolder(StorageFolder.Upload, auth.user.id, assetId);
-    const extension = extname(assetData.filename);
-    const path = join(folder, `${assetId}${extension}`);
-    const type = mimeTypes.assetType(path);
-
-    if (type === AssetType.Other) {
-      throw new BadRequestException(`${assetData.filename} is an unsupported file type`);
-    }
-
-    this.validateQuota(auth, uploadLength);
-
-    try {
-      await this.assetRepository.createWithMetadata(
-        {
-          id: assetId,
-          ownerId: auth.user.id,
-          libraryId: null,
-          checksum,
-          checksumAlgorithm: ChecksumAlgorithm.sha1File,
-          originalPath: path,
-          deviceAssetId: assetData.deviceAssetId,
-          deviceId: assetData.deviceId,
-          fileCreatedAt: assetData.fileCreatedAt,
-          fileModifiedAt: assetData.fileModifiedAt,
-          localDateTime: assetData.fileCreatedAt,
-          type,
-          isFavorite: assetData.isFavorite,
-          livePhotoVideoId: assetData.livePhotoVideoId,
-          visibility: AssetVisibility.Hidden,
-          originalFileName: assetData.filename,
-          status: AssetStatus.Partial,
-        },
-        uploadLength,
-        assetData.iCloudId ? [{ key: AssetMetadataKey.MobileApp, value: { iCloudId: assetData.iCloudId } }] : undefined,
-      );
-    } catch (error: any) {
-      if (!isAssetChecksumConstraint(error)) {
-        this.logger.error(`Error creating upload asset record: ${error.message}`);
-        throw new InternalServerErrorException('Error creating asset');
-      }
-
-      const duplicate = await this.assetRepository.getUploadAssetIdByChecksum(auth.user.id, checksum);
-      if (!duplicate) {
-        throw new InternalServerErrorException('Error locating duplicate for checksum constraint');
-      }
-
-      return { id: duplicate.id, path, status: duplicate.status, isDuplicate: true };
-    }
-
-    return { id: assetId, path, status: AssetStatus.Partial, isDuplicate: false };
-  }
-
-  async onComplete({ id, path, fileModifiedAt, sharedLink }: CompletionData) {
-    this.logger.log('Completing upload for asset', id);
-    const asset = await withRetry(() => this.assetRepository.setComplete(id, sharedLink));
-    if (!asset) {
-      this.logger.error(`Failed to mark asset ${id} as complete: not found or already completed`);
-      return;
-    }
-
-    try {
-      await withRetry(() => this.storageRepository.utimes(path, new Date(), fileModifiedAt));
-      await this.eventRepository.emit('AssetCreate', { asset });
-    } catch (error: any) {
-      this.logger.error(`onComplete error for ${path}: ${error.message}`);
-    }
-    const jobData = { name: JobName.AssetExtractMetadata, data: { id, source: 'upload' } } as const;
-    await withRetry(() => this.jobRepository.queue(jobData));
-  }
-
-  async onCancel(assetId: string, path: string): Promise<void> {
-    this.logger.log('Cancelling upload for asset', assetId);
-    await withRetry(() => this.storageRepository.unlink(path));
-    await withRetry(() => this.assetRepository.removeAndDecrementQuota(assetId));
-  }
-
-  private addRequest(assetId: string, req: Readable) {
-    const addTime = new Date();
-    const activeRequest = { req, startTime: addTime };
-    this.abortExistingRequest(assetId, addTime);
-    this.activeRequests.set(assetId, activeRequest);
-    req.on('close', () => {
-      if (this.activeRequests.get(assetId)?.req === req) {
-        this.activeRequests.delete(assetId);
-      }
-    });
-  }
-
-  private abortExistingRequest(assetId: string, abortTime = new Date()) {
-    const abortEvent = { assetId, abortTime };
-    // only emit if we didn't just abort it ourselves
-    if (!this.onUploadAbort(abortEvent)) {
-      this.websocketRepository.serverSend('UploadAbort', abortEvent);
-    }
-  }
-
-  private pipe(req: Readable, writeStream: Writable, size: number) {
-    let receivedLength = 0;
-    req.on('data', (data: Buffer) => {
-      receivedLength += data.length;
-      if (!writeStream.write(data)) {
-        req.pause();
-        writeStream.once('drain', () => req.resume());
-      }
-    });
-
-    req.on('close', () => {
-      if (receivedLength < size) {
-        writeStream.emit('error', new Error('Request closed before all data received'));
-      }
-      writeStream.end();
-    });
-  }
-
-  private sendInterimResponse({ socket }: Response, location: string, interopVersion: number, limits: string): void {
-    if (socket && !socket.destroyed) {
-      // Express doesn't understand interim responses, so write directly to socket
-      socket.write(
-        'HTTP/1.1 104 Upload Resumption Supported\r\n' +
-          `Location: ${location}\r\n` +
-          `Upload-Limit: ${limits}\r\n` +
-          `Upload-Draft-Interop-Version: ${interopVersion}\r\n\r\n`,
-      );
-    }
-  }
-
-  private sendInconsistentLength(res: Response): void {
-    res.status(400).contentType('application/problem+json').send({
-      type: 'https://iana.org/assignments/http-problem-types#inconsistent-upload-length',
-      title: 'inconsistent length values for upload',
-    });
-  }
-
-  private sendAlreadyCompleted(res: Response): void {
-    res.status(400).contentType('application/problem+json').send({
-      type: 'https://iana.org/assignments/http-problem-types#completed-upload',
-      title: 'upload is already completed',
-    });
-  }
-
-  private sendOffsetMismatch(res: Response, expected: number, actual: number): void {
-    res.status(409).contentType('application/problem+json').setHeader('Upload-Offset', expected.toString()).send({
-      type: 'https://iana.org/assignments/http-problem-types#mismatching-upload-offset',
-      title: 'offset from request does not match offset of resource',
-      'expected-offset': expected,
-      'provided-offset': actual,
-    });
-  }
-
-  private sendChecksumMismatch(res: Response, assetId: string, path: string) {
-    this.logger.warn(`Removing upload asset ${assetId} due to checksum mismatch`);
-    res.status(460).send('File on server does not match provided checksum');
-    return this.onCancel(assetId, path);
-  }
-
-  private validateQuota(auth: AuthDto, size: number): void {
-    const { quotaSizeInBytes: quotaLimit, quotaUsageInBytes: currentUsage } = auth.user;
-    if (quotaLimit === null) {
-      return;
-    }
-
-    if (quotaLimit < currentUsage + size) {
-      throw new BadRequestException('Quota has been exceeded!');
-    }
-  }
-
-  private async getCurrentOffset(path: string): Promise<number> {
-    try {
-      const stat = await this.storageRepository.stat(path);
-      return stat.size;
-    } catch (error: any) {
-      if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') {
-        return 0;
-      }
-      throw error;
-    }
-  }
-
-  private setCompleteHeader(res: Response, interopVersion: number | undefined, isComplete: boolean): void {
-    if (interopVersion === undefined || interopVersion > 3) {
-      res.setHeader('Upload-Complete', isComplete ? '?1' : '?0');
-    } else {
-      res.setHeader('Upload-Incomplete', isComplete ? '?0' : '?1');
-    }
-  }
-
-  private getUploadLimits({ upload }: SystemConfig['backup']) {
-    return `min-size=1, max-age=${upload.maxAgeHours * 3600}`;
-  }
-}

server/src/services/base.service.ts

@@ -7,6 +7,7 @@ import { StorageCore } from 'src/cores/storage.core';
 import { UserAdmin } from 'src/database';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
+import { AlbumUserMetadataRepository } from 'src/repositories/album-user-metadata.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
 import { ApiKeyRepository } from 'src/repositories/api-key.repository';
@@ -66,6 +67,7 @@ export const BASE_SERVICE_DEPENDENCIES = [
   AccessRepository,
   ActivityRepository,
   AlbumRepository,
+  AlbumUserMetadataRepository,
   AlbumUserRepository,
   ApiKeyRepository,
   AppRepository,
@@ -125,6 +127,7 @@ export class BaseService {
     protected accessRepository: AccessRepository,
     protected activityRepository: ActivityRepository,
     protected albumRepository: AlbumRepository,
+    protected albumUserMetadataRepository: AlbumUserMetadataRepository,
     protected albumUserRepository: AlbumUserRepository,
     protected apiKeyRepository: ApiKeyRepository,
     protected appRepository: AppRepository,

server/src/services/index.ts

@@ -3,7 +3,6 @@ import { AlbumService } from 'src/services/album.service';
 import { ApiKeyService } from 'src/services/api-key.service';
 import { ApiService } from 'src/services/api.service';
 import { AssetMediaService } from 'src/services/asset-media.service';
-import { AssetUploadService } from 'src/services/asset-upload.service';
 import { AssetService } from 'src/services/asset.service';
 import { AuditService } from 'src/services/audit.service';
 import { AuthAdminService } from 'src/services/auth-admin.service';
@@ -54,7 +53,6 @@ export const services = [
   AlbumService,
   ApiService,
   AssetMediaService,
-  AssetUploadService,
   AssetService,
   AuditService,
   AuthService,

server/src/services/sync.service.ts

@@ -78,6 +78,7 @@ export const SYNC_TYPES_ORDER = [
   SyncRequestType.AlbumAssetsV1,
   SyncRequestType.AlbumsV1,
   SyncRequestType.AlbumUsersV1,
+  SyncRequestType.AlbumUserMetadataV1,
   SyncRequestType.AlbumToAssetsV1,
   SyncRequestType.AssetExifsV1,
   SyncRequestType.AlbumAssetExifsV1,
@@ -183,6 +184,7 @@ export class SyncService extends BaseService {
         this.syncPartnerAssetExifsV1(options, response, checkpointMap, session.id),
       [SyncRequestType.AlbumsV1]: () => this.syncAlbumsV1(options, response, checkpointMap),
       [SyncRequestType.AlbumUsersV1]: () => this.syncAlbumUsersV1(options, response, checkpointMap, session.id),
+      [SyncRequestType.AlbumUserMetadataV1]: () => this.syncAlbumUserMetadataV1(options, response, checkpointMap),
       [SyncRequestType.AlbumAssetsV1]: () => this.syncAlbumAssetsV1(options, response, checkpointMap, session.id),
       [SyncRequestType.AlbumToAssetsV1]: () => this.syncAlbumToAssetsV1(options, response, checkpointMap, session.id),
       [SyncRequestType.AlbumAssetExifsV1]: () =>
@@ -213,6 +215,7 @@ export class SyncService extends BaseService {
 
     await this.syncRepository.album.cleanupAuditTable(pruneThreshold);
     await this.syncRepository.albumUser.cleanupAuditTable(pruneThreshold);
+    await this.syncRepository.albumUserMetadata.cleanupAuditTable(pruneThreshold);
     await this.syncRepository.albumToAsset.cleanupAuditTable(pruneThreshold);
     await this.syncRepository.asset.cleanupAuditTable(pruneThreshold);
     await this.syncRepository.assetFace.cleanupAuditTable(pruneThreshold);
@@ -489,6 +492,20 @@ export class SyncService extends BaseService {
     }
   }
 
+  private async syncAlbumUserMetadataV1(options: SyncQueryOptions, response: Writable, checkpointMap: CheckpointMap) {
+    const deleteType = SyncEntityType.AlbumUserMetadataDeleteV1;
+    const deletes = this.syncRepository.albumUserMetadata.getDeletes({ ...options, ack: checkpointMap[deleteType] });
+    for await (const { id, ...data } of deletes) {
+      send(response, { type: deleteType, ids: [id], data });
+    }
+
+    const upsertType = SyncEntityType.AlbumUserMetadataV1;
+    const upserts = this.syncRepository.albumUserMetadata.getUpserts({ ...options, ack: checkpointMap[upsertType] });
+    for await (const { updateId, ...data } of upserts) {
+      send(response, { type: upsertType, ids: [updateId], data });
+    }
+  }
+
   private async syncAlbumAssetsV1(
     options: SyncQueryOptions,
     response: Writable,

server/src/services/system-config.service.spec.ts

@@ -49,9 +49,6 @@ const updatedConfig = Object.freeze<SystemConfig>({
       cronExpression: '0 02 * * *',
       keepLastAmount: 14,
     },
-    upload: {
-      maxAgeHours: 72,
-    },
   },
   ffmpeg: {
     crf: 30,
@@ -128,7 +125,6 @@ const updatedConfig = Object.freeze<SystemConfig>({
     missingThumbnails: true,
     generateMemories: true,
     syncQuotaUsage: true,
-    removeStaleUploads: true,
   },
   reverseGeocoding: {
     enabled: true,

server/src/types.ts

@@ -361,8 +361,6 @@ export type JobItem =
   | { name: JobName.PersonCleanup; data?: IBaseJob }
   | { name: JobName.AssetDelete; data: IAssetDeleteJob }
   | { name: JobName.AssetDeleteCheck; data?: IBaseJob }
-  | { name: JobName.PartialAssetCleanup; data: IEntityJob }
-  | { name: JobName.PartialAssetCleanupQueueAll; data?: IBaseJob }
 
   // Library Management
   | { name: JobName.LibrarySyncFiles; data: ILibraryFileJob }

server/src/utils/misc.ts

@@ -14,7 +14,6 @@ import {
 import _ from 'lodash';
 import { writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { setTimeout } from 'node:timers/promises';
 import picomatch from 'picomatch';
 import parse from 'picomatch/lib/parse';
 import { SystemConfig } from 'src/config';
@@ -320,18 +319,3 @@ export const globToSqlPattern = (glob: string) => {
 export function clamp(value: number, min: number, max: number) {
   return Math.max(min, Math.min(max, value));
 }
-
-export async function withRetry<T>(operation: () => Promise<T>, retries: number = 2, delay: number = 100): Promise<T> {
-  let lastError: any;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      return await operation();
-    } catch (error: any) {
-      lastError = error;
-    }
-    if (attempt < retries) {
-      await setTimeout(delay);
-    }
-  }
-  throw lastError;
-}

server/src/utils/request.ts

@@ -1,7 +1,3 @@
-import { BadRequestException } from '@nestjs/common';
-import { plainToInstance } from 'class-transformer';
-import { validateSync } from 'class-validator';
-
 import { IncomingHttpHeaders } from 'node:http';
 import { UAParser } from 'ua-parser-js';
 
@@ -24,29 +20,3 @@ export const getUserAgentDetails = (headers: IncomingHttpHeaders) => {
     appVersion,
   };
 };
-
-export function validateSyncOrReject<T extends object>(cls: new () => T, obj: any): T {
-  const dto = plainToInstance(cls, obj, { excludeExtraneousValues: true });
-  const errors = validateSync(dto);
-  if (errors.length === 0) {
-    return dto;
-  }
-
-  const constraints = [];
-  for (const error of errors) {
-    if (error.constraints) {
-      constraints.push(...Object.values(error.constraints));
-    }
-
-    if (!error.children) {
-      continue;
-    }
-
-    for (const child of error.children) {
-      if (child.constraints) {
-        constraints.push(...Object.values(child.constraints));
-      }
-    }
-  }
-  throw new BadRequestException(constraints);
-}

server/test/mappers.ts

@@ -76,6 +76,7 @@ export const getDehydrated = <T extends Record<string, unknown>>(entity: T) => {
 
 export const getForAlbum = (album: ReturnType<AlbumFactory['build']>) => ({
   ...album,
+  isFavorite: false,
   assets: album.assets.map((asset) =>
     getDehydrated({ ...getForAsset(asset), exifInfo: getDehydrated(asset.exifInfo) }),
   ),

server/test/medium.factory.ts

@@ -20,6 +20,7 @@ import {
 } from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
+import { AlbumUserMetadataRepository } from 'src/repositories/album-user-metadata.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
 import { AssetEditRepository } from 'src/repositories/asset-edit.repository';
@@ -401,6 +402,7 @@ const newRealRepository = <T>(key: ClassConstructor<T>, db: Kysely<DB>): T => {
   switch (key) {
     case AccessRepository:
     case AlbumRepository:
+    case AlbumUserMetadataRepository:
     case AlbumUserRepository:
     case ActivityRepository:
     case AssetRepository:
@@ -465,6 +467,7 @@ const newMockRepository = <T>(key: ClassConstructor<T>) => {
   switch (key) {
     case ActivityRepository:
     case AlbumRepository:
+    case AlbumUserMetadataRepository:
     case AssetRepository:
     case AssetJobRepository:
     case ConfigRepository:

server/test/medium/specs/repositories/album-user-metadata.repository.spec.ts

@@ -0,0 +1,104 @@
+import { Kysely } from 'kysely';
+import { AlbumUserMetadataRepository } from 'src/repositories/album-user-metadata.repository';
+import { AlbumUserRepository } from 'src/repositories/album-user.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { DB } from 'src/schema';
+import { BaseService } from 'src/services/base.service';
+import { newMediumService } from 'test/medium.factory';
+import { getKyselyDB } from 'test/utils';
+
+let defaultDatabase: Kysely<DB>;
+
+const setup = (db?: Kysely<DB>) => {
+  const { ctx } = newMediumService(BaseService, {
+    database: db || defaultDatabase,
+    real: [],
+    mock: [LoggingRepository],
+  });
+
+  return {
+    ctx,
+    sut: ctx.get(AlbumUserMetadataRepository),
+    albumUserRepo: ctx.get(AlbumUserRepository),
+  };
+};
+
+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(AlbumUserMetadataRepository.name, () => {
+  it('should create an owner metadata row when an album is created', async () => {
+    const { ctx } = setup();
+    const { user } = await ctx.newUser();
+    const { album } = await ctx.newAlbum({ ownerId: user.id });
+
+    await expect(
+      ctx.database
+        .selectFrom('album_user_metadata')
+        .select(['albumId', 'userId', 'isFavorite'])
+        .where('albumId', '=', album.id)
+        .where('userId', '=', user.id)
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({
+      albumId: album.id,
+      userId: user.id,
+      isFavorite: false,
+    });
+  });
+
+  it('should create a shared-user metadata row when an album user is added', async () => {
+    const { ctx, albumUserRepo } = setup();
+    const { user: owner } = await ctx.newUser();
+    const { user: sharedUser } = await ctx.newUser();
+    const { album } = await ctx.newAlbum({ ownerId: owner.id });
+
+    await albumUserRepo.create({ albumId: album.id, userId: sharedUser.id });
+
+    await expect(
+      ctx.database
+        .selectFrom('album_user_metadata')
+        .select(['albumId', 'userId', 'isFavorite'])
+        .where('albumId', '=', album.id)
+        .where('userId', '=', sharedUser.id)
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({
+      albumId: album.id,
+      userId: sharedUser.id,
+      isFavorite: false,
+    });
+  });
+
+  it('should delete metadata and write an audit row when album access is removed', async () => {
+    const { ctx, albumUserRepo, sut } = setup();
+    const { user: owner } = await ctx.newUser();
+    const { user: sharedUser } = await ctx.newUser();
+    const { album } = await ctx.newAlbum({ ownerId: owner.id });
+
+    await albumUserRepo.create({ albumId: album.id, userId: sharedUser.id });
+    await sut.upsert({ albumId: album.id, userId: sharedUser.id, isFavorite: true });
+
+    await albumUserRepo.delete({ albumId: album.id, userId: sharedUser.id });
+
+    await expect(
+      ctx.database
+        .selectFrom('album_user_metadata')
+        .select('albumId')
+        .where('albumId', '=', album.id)
+        .where('userId', '=', sharedUser.id)
+        .executeTakeFirst(),
+    ).resolves.toBeUndefined();
+
+    await expect(
+      ctx.database
+        .selectFrom('album_user_metadata_audit')
+        .select(['albumId', 'userId'])
+        .where('albumId', '=', album.id)
+        .where('userId', '=', sharedUser.id)
+        .executeTakeFirstOrThrow(),
+    ).resolves.toEqual({
+      albumId: album.id,
+      userId: sharedUser.id,
+    });
+  });
+});

server/test/medium/specs/sync/sync-album-user-metadata.spec.ts

@@ -0,0 +1,95 @@
+import { Kysely } from 'kysely';
+import { SyncEntityType, SyncRequestType } from 'src/enum';
+import { AlbumUserMetadataRepository } from 'src/repositories/album-user-metadata.repository';
+import { AlbumUserRepository } from 'src/repositories/album-user.repository';
+import { DB } from 'src/schema';
+import { SyncTestContext } from 'test/medium.factory';
+import { getKyselyDB } from 'test/utils';
+
+let defaultDatabase: Kysely<DB>;
+
+const setup = async (db?: Kysely<DB>) => {
+  const ctx = new SyncTestContext(db || defaultDatabase);
+  const { auth, user, session } = await ctx.newSyncAuthUser();
+  return { auth, user, session, ctx };
+};
+
+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(SyncEntityType.AlbumUserMetadataV1, () => {
+  it('should sync owner album metadata rows', async () => {
+    const { auth, ctx } = await setup();
+    const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AlbumUserMetadataV1]);
+    expect(response).toEqual([
+      {
+        ack: expect.any(String),
+        data: {
+          albumId: album.id,
+          userId: auth.user.id,
+          isFavorite: false,
+        },
+        type: SyncEntityType.AlbumUserMetadataV1,
+      },
+      expect.objectContaining({ type: SyncEntityType.SyncCompleteV1 }),
+    ]);
+  });
+
+  it('should sync favorite updates', async () => {
+    const { auth, ctx } = await setup();
+    const repo = ctx.get(AlbumUserMetadataRepository);
+    const { album } = await ctx.newAlbum({ ownerId: auth.user.id });
+
+    const initial = await ctx.syncStream(auth, [SyncRequestType.AlbumUserMetadataV1]);
+    await ctx.syncAckAll(auth, initial);
+    await ctx.assertSyncIsComplete(auth, [SyncRequestType.AlbumUserMetadataV1]);
+
+    await repo.upsert({ albumId: album.id, userId: auth.user.id, isFavorite: true });
+
+    const updated = await ctx.syncStream(auth, [SyncRequestType.AlbumUserMetadataV1]);
+    expect(updated).toEqual([
+      {
+        ack: expect.any(String),
+        data: {
+          albumId: album.id,
+          userId: auth.user.id,
+          isFavorite: true,
+        },
+        type: SyncEntityType.AlbumUserMetadataV1,
+      },
+      expect.objectContaining({ type: SyncEntityType.SyncCompleteV1 }),
+    ]);
+  });
+});
+
+describe(SyncEntityType.AlbumUserMetadataDeleteV1, () => {
+  it('should sync metadata deletes when shared album access is removed', async () => {
+    const { auth, ctx } = await setup();
+    const albumUserRepo = ctx.get(AlbumUserRepository);
+    const { user: owner } = await ctx.newUser();
+    const { album } = await ctx.newAlbum({ ownerId: owner.id });
+    await albumUserRepo.create({ albumId: album.id, userId: auth.user.id });
+
+    const initial = await ctx.syncStream(auth, [SyncRequestType.AlbumUserMetadataV1]);
+    await ctx.syncAckAll(auth, initial);
+    await ctx.assertSyncIsComplete(auth, [SyncRequestType.AlbumUserMetadataV1]);
+
+    await albumUserRepo.delete({ albumId: album.id, userId: auth.user.id });
+
+    const deleted = await ctx.syncStream(auth, [SyncRequestType.AlbumUserMetadataV1]);
+    expect(deleted).toEqual([
+      {
+        ack: expect.any(String),
+        data: {
+          albumId: album.id,
+          userId: auth.user.id,
+        },
+        type: SyncEntityType.AlbumUserMetadataDeleteV1,
+      },
+      expect.objectContaining({ type: SyncEntityType.SyncCompleteV1 }),
+    ]);
+  });
+});

server/test/repositories/asset.repository.mock.ts

@@ -49,10 +49,6 @@ export const newAssetRepositoryMock = (): Mocked<RepositoryInterface<AssetReposi
     upsertMetadata: vitest.fn(),
     upsertBulkMetadata: vitest.fn(),
     deleteMetadataByKey: vitest.fn(),
-    getCompletionMetadata: vitest.fn(),
-    createWithMetadata: vitest.fn(),
-    removeAndDecrementQuota: vitest.fn(),
-    setComplete: vitest.fn(),
     deleteBulkMetadata: vitest.fn(),
     getForOriginal: vitest.fn(),
     getForOriginals: vitest.fn(),

server/test/repositories/storage.repository.mock.ts

@@ -56,7 +56,6 @@ export const newStorageRepositoryMock = (): Mocked<RepositoryInterface<StorageRe
     readTextFile: vitest.fn(),
     createFile: vitest.fn(),
     createWriteStream: vitest.fn(),
-    createOrAppendWriteStream: vitest.fn(),
     createOrOverwriteFile: vitest.fn(),
     existsSync: vitest.fn(),
     overwriteFile: vitest.fn(),
@@ -64,7 +63,6 @@ export const newStorageRepositoryMock = (): Mocked<RepositoryInterface<StorageRe
     unlinkDir: vitest.fn().mockResolvedValue(true),
     removeEmptyDirs: vitest.fn(),
     checkFileExists: vitest.fn(),
-    mkdir: vitest.fn(),
     mkdirSync: vitest.fn(),
     checkDiskUsage: vitest.fn(),
     readdir: vitest.fn(),

server/test/utils.ts

@@ -16,6 +16,7 @@ import { AuthGuard } from 'src/middleware/auth.guard';
 import { FileUploadInterceptor } from 'src/middleware/file-upload.interceptor';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
+import { AlbumUserMetadataRepository } from 'src/repositories/album-user-metadata.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
 import { ApiKeyRepository } from 'src/repositories/api-key.repository';
@@ -211,6 +212,7 @@ export type ServiceOverrides = {
   access: AccessRepository;
   activity: ActivityRepository;
   album: AlbumRepository;
+  albumUserMetadata: AlbumUserMetadataRepository;
   albumUser: AlbumUserRepository;
   apiKey: ApiKeyRepository;
   app: AppRepository;
@@ -282,7 +284,6 @@ export const getMocks = () => {
   const databaseMock = automock(DatabaseRepository, { args: [, loggerMock], strict: false });
 
   databaseMock.withLock.mockImplementation((_type, fn) => fn());
-  databaseMock.withUuidLock.mockImplementation((_type, fn) => fn());
   databaseMock.getPostgresVersion = vitest.fn().mockResolvedValue('14.10 (Debian 14.10-1.pgdg120+1)');
   databaseMock.getPostgresVersionRange = vitest.fn().mockReturnValue('>=14.0.0');
   databaseMock.createExtension = vitest.fn().mockResolvedValue(void 0);
@@ -297,6 +298,7 @@ export const getMocks = () => {
     activity: automock(ActivityRepository),
     audit: automock(AuditRepository),
     album: automock(AlbumRepository, { strict: false }),
+    albumUserMetadata: automock(AlbumUserMetadataRepository),
     albumUser: automock(AlbumUserRepository),
     asset: newAssetRepositoryMock(),
     assetEdit: automock(AssetEditRepository),
@@ -363,6 +365,7 @@ export const newTestService = <T extends BaseService>(
     overrides.access || (mocks.access as IAccessRepository as AccessRepository),
     overrides.activity || (mocks.activity as As<ActivityRepository>),
     overrides.album || (mocks.album as As<AlbumRepository>),
+    overrides.albumUserMetadata || (mocks.albumUserMetadata as As<AlbumUserMetadataRepository>),
     overrides.albumUser || (mocks.albumUser as As<AlbumUserRepository>),
     overrides.apiKey || (mocks.apiKey as As<ApiKeyRepository>),
     overrides.app || (mocks.app as As<AppRepository>),

web/src/test-data/factories/album-factory.ts

@@ -18,5 +18,6 @@ export const albumFactory = Sync.makeFactory<AlbumResponseDto>({
   albumUsers: [],
   hasSharedLink: false,
   isActivityEnabled: true,
+  isFavorite: false,
   order: AssetOrder.Desc,
 });