gradient in slideshow

fully rework/condense/simplify AdaptiveImage.svelte

.github/workflows/docker.yml

@@ -131,7 +131,7 @@ jobs:
           - device: rocm
             suffixes: '-rocm'
             platforms: linux/amd64
-            runner-mapping: '{"linux/amd64": "pokedex-large"}'
+            runner-mapping: '{"linux/amd64": "pokedex-giant"}'
     uses: immich-app/devtools/.github/workflows/multi-runner-build.yml@bd49ed7a5a6022149f79b6564df48177476a822b # multi-runner-build-workflow-v2.2.1
     permissions:
       contents: read

.github/workflows/release-pr.yml

@@ -0,0 +1,170 @@
+name: Manage release PR
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
+
+permissions: {}
+
+jobs:
+  bump:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Generate a token
+        id: generate-token
+        uses: actions/create-github-app-token@29824e69f54612133e76f7eaac726eef6c875baf # v2.2.1
+        with:
+          app-id: ${{ secrets.PUSH_O_MATIC_APP_ID }}
+          private-key: ${{ secrets.PUSH_O_MATIC_APP_KEY }}
+
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          persist-credentials: true
+          ref: main
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@eac588ad8def6316056a12d4907a9d4d84ff7a3b # v7.3.0
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@41ff72655975bd51cab0327fa583b6e92b6d3061 # v4.2.0
+
+      - name: Setup Node
+        uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
+        with:
+          node-version-file: './server/.nvmrc'
+          cache: 'pnpm'
+          cache-dependency-path: '**/pnpm-lock.yaml'
+
+      - name: Determine release type
+        id: bump-type
+        uses: ietf-tools/semver-action@c90370b2958652d71c06a3484129a4d423a6d8a8 # v1.11.0
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+
+      - name: Bump versions
+        env:
+          TYPE: ${{ steps.bump-type.outputs.bump }}
+        run: |
+          if [ "$TYPE" == "none" ]; then
+            exit 1 # TODO: Is there a cleaner way to abort the workflow?
+          fi
+          misc/release/pump-version.sh -s $TYPE -m true
+
+      - name: Manage Outline release document
+        id: outline
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        env:
+          OUTLINE_API_KEY: ${{ secrets.OUTLINE_API_KEY }}
+          NEXT_VERSION: ${{ steps.bump-type.outputs.next }}
+        with:
+          github-token: ${{ steps.generate-token.outputs.token }}
+          script: |
+            const fs = require('fs');
+
+            const outlineKey = process.env.OUTLINE_API_KEY;
+            const parentDocumentId = 'da856355-0844-43df-bd71-f8edce5382d9'
+            const collectionId = 'e2910656-714c-4871-8721-447d9353bd73';
+            const baseUrl = 'https://outline.immich.cloud';
+
+            const listResponse = await fetch(`${baseUrl}/api/documents.list`, {
+              method: 'POST',
+              headers: {
+                'Authorization': `Bearer ${outlineKey}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({ parentDocumentId })
+            });
+
+            if (!listResponse.ok) {
+              throw new Error(`Outline list failed: ${listResponse.statusText}`);
+            }
+
+            const listData = await listResponse.json();
+            const allDocuments = listData.data || [];
+
+            const document = allDocuments.find(doc => doc.title === 'next');
+
+            let documentId;
+            let documentUrl;
+            let documentText;
+
+            if (!document) {
+              // Create new document
+              console.log('No existing document found. Creating new one...');
+              const notesTmpl = fs.readFileSync('misc/release/notes.tmpl', 'utf8');
+              const createResponse = await fetch(`${baseUrl}/api/documents.create`, {
+                method: 'POST',
+                headers: {
+                  'Authorization': `Bearer ${outlineKey}`,
+                  'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                  title: 'next',
+                  text: notesTmpl,
+                  collectionId: collectionId,
+                  parentDocumentId: parentDocumentId,
+                  publish: true
+                })
+              });
+
+              if (!createResponse.ok) {
+                throw new Error(`Failed to create document: ${createResponse.statusText}`);
+              }
+
+              const createData = await createResponse.json();
+              documentId = createData.data.id;
+              const urlId = createData.data.urlId;
+              documentUrl = `${baseUrl}/doc/next-${urlId}`;
+              documentText = createData.data.text || '';
+              console.log(`Created new document: ${documentUrl}`);
+            } else {
+              documentId = document.id;
+              const docPath = document.url;
+              documentUrl = `${baseUrl}${docPath}`;
+              documentText = document.text || '';
+              console.log(`Found existing document: ${documentUrl}`);
+            }
+
+            // Generate GitHub release notes
+            console.log('Generating GitHub release notes...');
+            const releaseNotesResponse = await github.rest.repos.generateReleaseNotes({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              tag_name: `${process.env.NEXT_VERSION}`,
+            });
+
+            // Combine the content
+            const changelog = `
+            # ${process.env.NEXT_VERSION}
+
+            ${documentText}
+
+            ${releaseNotesResponse.data.body}
+
+            ---
+
+            `
+
+            const existingChangelog = fs.existsSync('CHANGELOG.md') ? fs.readFileSync('CHANGELOG.md', 'utf8') : '';
+            fs.writeFileSync('CHANGELOG.md', changelog + existingChangelog, 'utf8');
+
+            core.setOutput('document_url', documentUrl);
+
+      - name: Create PR
+        id: create-pr
+        uses: peter-evans/create-pull-request@c0f553fe549906ede9cf27b5156039d195d2ece0 # v8.1.0
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          commit-message: 'chore: release ${{ steps.bump-type.outputs.next }}'
+          title: 'chore: release ${{ steps.bump-type.outputs.next }}'
+          body: 'Release notes: ${{ steps.outline.outputs.document_url }}'
+          labels: 'changelog:skip'
+          branch: 'release/next'
+          draft: true

.github/workflows/release.yml

@@ -0,0 +1,149 @@
+name: release.yml
+on:
+  pull_request:
+    types: [closed]
+    paths:
+      - CHANGELOG.md
+
+jobs:
+  # Maybe double check PR source branch?
+
+  merge_translations:
+    uses: ./.github/workflows/merge-translations.yml
+    permissions:
+      pull-requests: write
+    secrets:
+      PUSH_O_MATIC_APP_ID: ${{ secrets.PUSH_O_MATIC_APP_ID }}
+      PUSH_O_MATIC_APP_KEY: ${{ secrets.PUSH_O_MATIC_APP_KEY }}
+      WEBLATE_TOKEN: ${{ secrets.WEBLATE_TOKEN }}
+
+  build_mobile:
+    uses: ./.github/workflows/build-mobile.yml
+    needs: merge_translations
+    permissions:
+      contents: read
+    secrets:
+      KEY_JKS: ${{ secrets.KEY_JKS }}
+      ALIAS: ${{ secrets.ALIAS }}
+      ANDROID_KEY_PASSWORD: ${{ secrets.ANDROID_KEY_PASSWORD }}
+      ANDROID_STORE_PASSWORD: ${{ secrets.ANDROID_STORE_PASSWORD }}
+      # iOS secrets
+      APP_STORE_CONNECT_API_KEY_ID: ${{ secrets.APP_STORE_CONNECT_API_KEY_ID }}
+      APP_STORE_CONNECT_API_KEY_ISSUER_ID: ${{ secrets.APP_STORE_CONNECT_API_KEY_ISSUER_ID }}
+      APP_STORE_CONNECT_API_KEY: ${{ secrets.APP_STORE_CONNECT_API_KEY }}
+      IOS_CERTIFICATE_P12: ${{ secrets.IOS_CERTIFICATE_P12 }}
+      IOS_CERTIFICATE_PASSWORD: ${{ secrets.IOS_CERTIFICATE_PASSWORD }}
+      IOS_PROVISIONING_PROFILE: ${{ secrets.IOS_PROVISIONING_PROFILE }}
+      IOS_PROVISIONING_PROFILE_SHARE_EXTENSION: ${{ secrets.IOS_PROVISIONING_PROFILE_SHARE_EXTENSION }}misc/release/notes.tmpl
+      IOS_PROVISIONING_PROFILE_WIDGET_EXTENSION: ${{ secrets.IOS_PROVISIONING_PROFILE_WIDGET_EXTENSION }}
+      IOS_DEVELOPMENT_PROVISIONING_PROFILE: ${{ secrets.IOS_DEVELOPMENT_PROVISIONING_PROFILE }}
+      IOS_DEVELOPMENT_PROVISIONING_PROFILE_SHARE_EXTENSION: ${{ secrets.IOS_DEVELOPMENT_PROVISIONING_PROFILE_SHARE_EXTENSION }}
+      IOS_DEVELOPMENT_PROVISIONING_PROFILE_WIDGET_EXTENSION: ${{ secrets.IOS_DEVELOPMENT_PROVISIONING_PROFILE_WIDGET_EXTENSION }}
+      FASTLANE_TEAM_ID: ${{ secrets.FASTLANE_TEAM_ID }}
+    with:
+      ref: main
+      environment: production
+
+  prepare_release:
+    runs-on: ubuntu-latest
+    needs: build_mobile
+    permissions:
+      actions: read # To download the app artifact
+    steps:
+      - name: Generate a token
+        id: generate-token
+        uses: actions/create-github-app-token@29824e69f54612133e76f7eaac726eef6c875baf # v2.2.1
+        with:
+          app-id: ${{ secrets.PUSH_O_MATIC_APP_ID }}
+          private-key: ${{ secrets.PUSH_O_MATIC_APP_KEY }}
+
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+          persist-credentials: false
+          ref: main
+
+      - name: Extract changelog
+        id: changelog
+        run: |
+          CHANGELOG_PATH=$RUNNER_TEMP/changelog.md
+          sed -n '1,/^---$/p' CHANGELOG.md | head -n -1 > $CHANGELOG_PATH
+          echo "path=$CHANGELOG_PATH" >> $GITHUB_OUTPUT
+          VERSION=$(sed -n 's/^# //p' $CHANGELOG_PATH)
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Download APK
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: release-apk-signed
+          github-token: ${{ steps.generate-token.outputs.token }}
+
+      - name: Create draft release
+        uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2.5.0
+        with:
+          tag_name: ${{ steps.version.outputs.result }}
+          token: ${{ steps.generate-token.outputs.token }}
+          body_path: ${{ steps.changelog.outputs.path }}
+          draft: true
+          files: |
+            docker/docker-compose.yml
+            docker/docker-compose.rootless.yml
+            docker/example.env
+            docker/hwaccel.ml.yml
+            docker/hwaccel.transcoding.yml
+            docker/prometheus.yml
+            *.apk
+
+      - name: Rename Outline document
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        continue-on-error: true
+        env:
+          OUTLINE_API_KEY: ${{ secrets.OUTLINE_API_KEY }}
+          VERSION: ${{ steps.changelog.outputs.version }}
+        with:
+          github-token: ${{ steps.generate-token.outputs.token }}
+          script: |
+            const outlineKey = process.env.OUTLINE_API_KEY;
+            const version = process.env.VERSION;
+            const parentDocumentId = 'da856355-0844-43df-bd71-f8edce5382d9';
+            const baseUrl = 'https://outline.immich.cloud';
+
+            const listResponse = await fetch(`${baseUrl}/api/documents.list`, {
+              method: 'POST',
+              headers: {
+                'Authorization': `Bearer ${outlineKey}`,
+                'Content-Type': 'application/json'
+              },
+              body: JSON.stringify({ parentDocumentId })
+            });
+
+            if (!listResponse.ok) {
+              throw new Error(`Outline list failed: ${listResponse.statusText}`);
+            }
+
+            const listData = await listResponse.json();
+            const allDocuments = listData.data || [];
+            const document = allDocuments.find(doc => doc.title === 'next');
+
+            if (document) {
+              console.log(`Found document 'next', renaming to '${version}'...`);
+
+              const updateResponse = await fetch(`${baseUrl}/api/documents.update`, {
+                method: 'POST',
+                headers: {
+                  'Authorization': `Bearer ${outlineKey}`,
+                  'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                  id: document.id,
+                  title: version
+                })
+              });
+
+              if (!updateResponse.ok) {
+                throw new Error(`Failed to rename document: ${updateResponse.statusText}`);
+              }
+            } else {
+              console.log('No document titled "next" found to rename');
+            }

cli/package.json

@@ -20,7 +20,7 @@
     "@types/lodash-es": "^4.17.12",
     "@types/micromatch": "^4.0.9",
     "@types/mock-fs": "^4.13.1",
-    "@types/node": "^24.11.0",
+    "@types/node": "^24.10.14",
     "@vitest/coverage-v8": "^4.0.0",
     "byte-size": "^9.0.0",
     "cli-progress": "^3.12.0",

docker/docker-compose.dev.yml

@@ -155,7 +155,7 @@ services:
 
   redis:
     container_name: immich_redis
-    image: docker.io/valkey/valkey:9@sha256:3eeb09785cd61ec8e3be35f8804c8892080f3ca21934d628abc24ee4ed1698f6
+    image: docker.io/valkey/valkey:9@sha256:2bce660b767cb62c8c0ea020e94a230093be63dbd6af4f21b044960517a5842d
     healthcheck:
       test: redis-cli ping || exit 1
 

docker/docker-compose.prod.yml

@@ -56,7 +56,7 @@ services:
 
   redis:
     container_name: immich_redis
-    image: docker.io/valkey/valkey:9@sha256:3eeb09785cd61ec8e3be35f8804c8892080f3ca21934d628abc24ee4ed1698f6
+    image: docker.io/valkey/valkey:9@sha256:2bce660b767cb62c8c0ea020e94a230093be63dbd6af4f21b044960517a5842d
     healthcheck:
       test: redis-cli ping || exit 1
     restart: always

docker/docker-compose.rootless.yml

@@ -61,7 +61,7 @@ services:
 
   redis:
     container_name: immich_redis
-    image: docker.io/valkey/valkey:9@sha256:3eeb09785cd61ec8e3be35f8804c8892080f3ca21934d628abc24ee4ed1698f6
+    image: docker.io/valkey/valkey:9@sha256:2bce660b767cb62c8c0ea020e94a230093be63dbd6af4f21b044960517a5842d
     user: '1000:1000'
     security_opt:
       - no-new-privileges:true

docker/docker-compose.yml

@@ -49,7 +49,7 @@ services:
 
   redis:
     container_name: immich_redis
-    image: docker.io/valkey/valkey:9@sha256:3eeb09785cd61ec8e3be35f8804c8892080f3ca21934d628abc24ee4ed1698f6
+    image: docker.io/valkey/valkey:9@sha256:2bce660b767cb62c8c0ea020e94a230093be63dbd6af4f21b044960517a5842d
     healthcheck:
       test: redis-cli ping || exit 1
     restart: always

docs/docs/administration/system-settings.md

@@ -230,7 +230,7 @@ The default value is `ultrafast`.
 
 ### Audio codec (`ffmpeg.targetAudioCodec`) {#ffmpeg.targetAudioCodec}
 
-Which audio codec to use when the audio stream is being transcoded. Can be one of `mp3`, `aac`, `opus`.
+Which audio codec to use when the audio stream is being transcoded. Can be one of `mp3`, `aac`, `libopus`.
 
 The default value is `aac`.
 

docs/docs/install/config-file.md

@@ -27,7 +27,7 @@ The default configuration looks like this:
   "ffmpeg": {
     "accel": "disabled",
     "accelDecode": false,
-    "acceptedAudioCodecs": ["aac", "mp3", "opus"],
+    "acceptedAudioCodecs": ["aac", "mp3", "libopus"],
     "acceptedContainers": ["mov", "ogg", "webm"],
     "acceptedVideoCodecs": ["h264"],
     "bframes": -1,

e2e/docker-compose.yml

@@ -44,7 +44,7 @@ services:
 
   redis:
     container_name: immich-e2e-redis
-    image: docker.io/valkey/valkey:9@sha256:3eeb09785cd61ec8e3be35f8804c8892080f3ca21934d628abc24ee4ed1698f6
+    image: docker.io/valkey/valkey:9@sha256:2bce660b767cb62c8c0ea020e94a230093be63dbd6af4f21b044960517a5842d
     healthcheck:
       test: redis-cli ping || exit 1
 

e2e/package.json

@@ -32,7 +32,7 @@
     "@playwright/test": "^1.44.1",
     "@socket.io/component-emitter": "^3.1.2",
     "@types/luxon": "^3.4.2",
-    "@types/node": "^24.11.0",
+    "@types/node": "^24.10.14",
     "@types/pg": "^8.15.1",
     "@types/pngjs": "^6.0.4",
     "@types/supertest": "^6.0.2",

e2e/src/ui/mock-network/timeline-network.ts

@@ -99,13 +99,13 @@ export const setupTimelineMockApiRoutes = async (
   });
 
   await context.route('**/api/assets/*/thumbnail?size=*', async (route, request) => {
-    const pattern = /\/api\/assets\/(?<assetId>[^/]+)\/thumbnail\?size=(?<size>preview|thumbnail)/;
+    const pattern = /\/api\/assets\/(?<assetId>[^/]+)\/thumbnail\?size=(?<size>preview|thumbnail|fullsize)/;
     const match = request.url().match(pattern);
     if (!match?.groups) {
       throw new Error(`Invalid URL for thumbnail endpoint: ${request.url()}`);
     }
 
-    if (match.groups.size === 'preview') {
+    if (match.groups.size === 'preview' || match.groups.size === 'fullsize') {
       if (!route.request().serviceWorker()) {
         return route.continue();
       }

e2e/src/ui/specs/asset-viewer/broken-asset.e2e-spec.ts

@@ -64,9 +64,7 @@ test.describe('broken-asset responsiveness', () => {
 
   test('broken asset in main viewer shows icon and uses text-base', async ({ context, page }) => {
     await context.route(
-      (url) =>
-        url.pathname.includes(`/api/assets/${fixture.primaryAsset.id}/thumbnail`) ||
-        url.pathname.includes(`/api/assets/${fixture.primaryAsset.id}/original`),
+      (url) => url.pathname.includes(`/api/assets/${fixture.primaryAsset.id}/thumbnail`),
       async (route) => {
         return route.fulfill({ status: 404 });
       },

e2e/src/ui/specs/search/search-gallery.e2e-spec.ts

@@ -6,6 +6,7 @@ import {
   generateTimelineData,
   TimelineAssetConfig,
   TimelineData,
+  toAssetResponseDto,
 } from 'src/ui/generators/timeline';
 import { setupBaseMockApiRoutes } from 'src/ui/mock-network/base-network';
 import { setupTimelineMockApiRoutes, TimelineTestContext } from 'src/ui/mock-network/timeline-network';
@@ -53,7 +54,7 @@ test.describe('search gallery-viewer', () => {
             assets: {
               total: searchAssets.length,
               count: searchAssets.length,
-              items: searchAssets,
+              items: searchAssets.map((asset) => toAssetResponseDto(asset)),
               facets: [],
               nextPage: null,
             },

e2e/src/ui/specs/timeline/utils.ts

@@ -163,13 +163,11 @@ export const assetViewerUtils = {
     return page.locator('#immich-asset-viewer');
   },
   async waitForViewerLoad(page: Page, asset: TimelineAssetConfig) {
+    const previewUrl = `/api/assets/${asset.id}/thumbnail?size=preview&c=${asset.thumbhash}&edited=true`;
     await page
-      .locator(
-        `img[draggable="false"][src="/api/assets/${asset.id}/thumbnail?size=preview&c=${asset.thumbhash}&edited=true"]`,
-      )
-      .or(
-        page.locator(`video[poster="/api/assets/${asset.id}/thumbnail?size=preview&c=${asset.thumbhash}&edited=true"]`),
-      )
+      .getByTestId('preview')
+      .and(page.locator(`[src="${previewUrl}"]`))
+      .or(page.locator(`video[poster="${previewUrl}"]`))
       .waitFor();
   },
   async expectActiveAssetToBe(page: Page, assetId: string) {

i18n/en.json

@@ -1007,8 +1007,6 @@
   "editor_edits_applied_success": "Edits applied successfully",
   "editor_flip_horizontal": "Flip horizontal",
   "editor_flip_vertical": "Flip vertical",
-  "editor_handle_corner": "{corner, select, top_left {Top-left} top_right {Top-right} bottom_left {Bottom-left} bottom_right {Bottom-right} other {A}} corner handle",
-  "editor_handle_edge": "{edge, select, top {Top} bottom {Bottom} left {Left} right {Right} other {An}} edge handle",
   "editor_orientation": "Orientation",
   "editor_reset_all_changes": "Reset changes",
   "editor_rotate_left": "Rotate 90° counterclockwise",
@@ -1074,7 +1072,7 @@
     "failed_to_update_notification_status": "Failed to update notification status",
     "incorrect_email_or_password": "Incorrect email or password",
     "library_folder_already_exists": "This import path already exists.",
-    "page_not_found": "Page not found",
+    "page_not_found": "Page not found :/",
     "paths_validation_failed": "{paths, plural, one {# path} other {# paths}} failed validation",
     "profile_picture_transparent_pixels": "Profile pictures cannot have transparent pixels. Please zoom in and/or move the image.",
     "quota_higher_than_disk_size": "You set a quota higher than the disk size",

machine-learning/immich_ml/sessions/ort.py

@@ -64,6 +64,14 @@ class OrtSession:
     def _providers_default(self) -> list[str]:
         available_providers = set(ort.get_available_providers())
         log.debug(f"Available ORT providers: {available_providers}")
+        if (openvino := "OpenVINOExecutionProvider") in available_providers:
+            device_ids: list[str] = ort.capi._pybind_state.get_available_openvino_device_ids()
+            log.debug(f"Available OpenVINO devices: {device_ids}")
+
+            gpu_devices = [device_id for device_id in device_ids if device_id.startswith("GPU")]
+            if not gpu_devices:
+                log.warning("No GPU device found in OpenVINO. Falling back to CPU.")
+                available_providers.remove(openvino)
         return [provider for provider in SUPPORTED_PROVIDERS if provider in available_providers]
 
     @property
@@ -94,19 +102,12 @@ class OrtSession:
                         "migraphx_fp16_enable": "1" if settings.rocm_precision == ModelPrecision.FP16 else "0",
                     }
                 case "OpenVINOExecutionProvider":
-                    device_ids: list[str] = ort.capi._pybind_state.get_available_openvino_device_ids()
-                    # Check for available devices, preferring GPU over CPU
-                    gpu_devices = [d for d in device_ids if d.startswith("GPU")]
-                    if gpu_devices:
-                        device_type = f"GPU.{settings.device_id}"
-                        log.debug(f"OpenVINO: Using GPU device {device_type}")
-                    else:
-                        device_type = "CPU"
-                        log.debug("OpenVINO: No GPU found, using CPU")
+                    openvino_dir = self.model_path.parent / "openvino"
+                    device = f"GPU.{settings.device_id}"
                     options = {
-                        "device_type": device_type,
+                        "device_type": device,
                         "precision": settings.openvino_precision.value,
-                        "cache_dir": (self.model_path.parent / "openvino").as_posix(),
+                        "cache_dir": openvino_dir.as_posix(),
                     }
                 case "CoreMLExecutionProvider":
                     options = {
@@ -138,14 +139,12 @@ class OrtSession:
         sess_options.enable_cpu_mem_arena = settings.model_arena
 
         # avoid thread contention between models
-        # Set inter_op threads
         if settings.model_inter_op_threads > 0:
             sess_options.inter_op_num_threads = settings.model_inter_op_threads
         # these defaults work well for CPU, but bottleneck GPU
         elif settings.model_inter_op_threads == 0 and self.providers == ["CPUExecutionProvider"]:
             sess_options.inter_op_num_threads = 1
 
-        # Set intra_op threads
         if settings.model_intra_op_threads > 0:
             sess_options.intra_op_num_threads = settings.model_intra_op_threads
         elif settings.model_intra_op_threads == 0 and self.providers == ["CPUExecutionProvider"]:

machine-learning/test_main.py

@@ -204,6 +204,13 @@ class TestOrtSession:
 
         assert session.providers == self.OV_EP
 
+    @pytest.mark.ov_device_ids(["CPU"])
+    @pytest.mark.providers(OV_EP)
+    def test_avoids_openvino_if_gpu_not_available(self, providers: list[str], ov_device_ids: list[str]) -> None:
+        session = OrtSession("ViT-B-32__openai")
+
+        assert session.providers == self.CPU_EP
+
     @pytest.mark.providers(CUDA_EP_OUT_OF_ORDER)
     def test_sets_providers_in_correct_order(self, providers: list[str]) -> None:
         session = OrtSession("ViT-B-32__openai")
@@ -249,8 +256,7 @@ class TestOrtSession:
             {"arena_extend_strategy": "kSameAsRequested"},
         ]
 
-    @pytest.mark.ov_device_ids(["GPU.0", "GPU.1", "CPU"])
-    def test_sets_provider_options_for_openvino(self, ov_device_ids: list[str]) -> None:
+    def test_sets_provider_options_for_openvino(self) -> None:
         model_path = "/cache/ViT-B-32__openai/textual/model.onnx"
         os.environ["MACHINE_LEARNING_DEVICE_ID"] = "1"
 
@@ -264,8 +270,7 @@ class TestOrtSession:
             }
         ]
 
-    @pytest.mark.ov_device_ids(["GPU.0", "GPU.1", "CPU"])
-    def test_sets_openvino_to_fp16_if_enabled(self, ov_device_ids: list[str], mocker: MockerFixture) -> None:
+    def test_sets_openvino_to_fp16_if_enabled(self, mocker: MockerFixture) -> None:
         model_path = "/cache/ViT-B-32__openai/textual/model.onnx"
         os.environ["MACHINE_LEARNING_DEVICE_ID"] = "1"
         mocker.patch.object(settings, "openvino_precision", ModelPrecision.FP16)
@@ -280,19 +285,6 @@ class TestOrtSession:
             }
         ]
 
-    @pytest.mark.ov_device_ids(["CPU"])
-    def test_sets_provider_options_for_openvino_cpu(self, ov_device_ids: list[str]) -> None:
-        model_path = "/cache/ViT-B-32__openai/model.onnx"
-        session = OrtSession(model_path, providers=["OpenVINOExecutionProvider"])
-
-        assert session.provider_options == [
-            {
-                "device_type": "CPU",
-                "precision": "FP32",
-                "cache_dir": "/cache/ViT-B-32__openai/openvino",
-            }
-        ]
-
     def test_sets_provider_options_for_cuda(self) -> None:
         os.environ["MACHINE_LEARNING_DEVICE_ID"] = "1"
 
@@ -349,23 +341,6 @@ class TestOrtSession:
         assert session.sess_options.inter_op_num_threads == 1
         assert session.sess_options.intra_op_num_threads == 2
 
-    @pytest.mark.ov_device_ids(["CPU"])
-    def test_sets_default_sess_options_if_openvino_cpu(self, ov_device_ids: list[str]) -> None:
-        model_path = "/cache/ViT-B-32__openai/model.onnx"
-        session = OrtSession(model_path, providers=["OpenVINOExecutionProvider"])
-
-        assert session.sess_options.execution_mode == ort.ExecutionMode.ORT_SEQUENTIAL
-        assert session.sess_options.inter_op_num_threads == 0
-        assert session.sess_options.intra_op_num_threads == 0
-
-    @pytest.mark.ov_device_ids(["GPU.0", "CPU"])
-    def test_sets_default_sess_options_if_openvino_gpu(self, ov_device_ids: list[str]) -> None:
-        model_path = "/cache/ViT-B-32__openai/model.onnx"
-        session = OrtSession(model_path, providers=["OpenVINOExecutionProvider"])
-
-        assert session.sess_options.inter_op_num_threads == 0
-        assert session.sess_options.intra_op_num_threads == 0
-
     def test_sets_default_sess_options_does_not_set_threads_if_non_cpu_and_default_threads(self) -> None:
         session = OrtSession("ViT-B-32__openai", providers=["CUDAExecutionProvider", "CPUExecutionProvider"])
 

mobile/android/app/build.gradle

@@ -3,7 +3,6 @@ plugins {
   id "kotlin-android"
   id "dev.flutter.flutter-gradle-plugin"
   id 'com.google.devtools.ksp'
-  id 'org.jetbrains.kotlin.plugin.serialization'
   id 'org.jetbrains.kotlin.plugin.compose' version '2.0.20' // this version matches your Kotlin version
 
 }

mobile/android/app/src/main/kotlin/app/alextran/immich/core/HttpClientManager.kt

@@ -8,16 +8,11 @@ import app.alextran.immich.BuildConfig
 import app.alextran.immich.NativeBuffer
 import okhttp3.Cache
 import okhttp3.ConnectionPool
-import okhttp3.Cookie
-import okhttp3.CookieJar
-import okhttp3.Credentials
 import okhttp3.Dispatcher
 import okhttp3.Headers
-import okhttp3.HttpUrl
-import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.Credentials
 import okhttp3.OkHttpClient
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
+import org.json.JSONObject
 import java.io.ByteArrayInputStream
 import java.io.File
 import java.net.Socket
@@ -37,19 +32,7 @@ private const val CERT_ALIAS = "client_cert"
 private const val PREFS_NAME = "immich.ssl"
 private const val PREFS_CERT_ALIAS = "immich.client_cert"
 private const val PREFS_HEADERS = "immich.request_headers"
-private const val PREFS_SERVER_URLS = "immich.server_urls"
-private const val PREFS_COOKIES = "immich.cookies"
-private const val COOKIE_EXPIRY_DAYS = 400L
-
-private enum class AuthCookie(val cookieName: String, val httpOnly: Boolean) {
-  ACCESS_TOKEN("immich_access_token", httpOnly = true),
-  IS_AUTHENTICATED("immich_is_authenticated", httpOnly = false),
-  AUTH_TYPE("immich_auth_type", httpOnly = true);
-
-  companion object {
-    val names = entries.map { it.cookieName }.toSet()
-  }
-}
+private const val PREFS_SERVER_URL = "immich.server_url"
 
 /**
  * Manages a shared OkHttpClient with SSL configuration support.
@@ -75,8 +58,6 @@ object HttpClientManager {
   var headers: Headers = Headers.headersOf()
     private set
 
-  private val cookieJar = PersistentCookieJar()
-
   val isMtls: Boolean get() = keyChainAlias != null || keyStore.containsAlias(CERT_ALIAS)
 
   fun initialize(context: Context) {
@@ -88,23 +69,16 @@ object HttpClientManager {
       prefs = appContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
       keyChainAlias = prefs.getString(PREFS_CERT_ALIAS, null)
 
-      cookieJar.init(prefs)
-
       val savedHeaders = prefs.getString(PREFS_HEADERS, null)
       if (savedHeaders != null) {
-        val map = Json.decodeFromString<Map<String, String>>(savedHeaders)
+        val json = JSONObject(savedHeaders)
         val builder = Headers.Builder()
-        for ((key, value) in map) {
-          builder.add(key, value)
+        for (key in json.keys()) {
+          builder.add(key, json.getString(key))
         }
         headers = builder.build()
       }
 
-      val serverUrlsJson = prefs.getString(PREFS_SERVER_URLS, null)
-      if (serverUrlsJson != null) {
-        cookieJar.setServerUrls(Json.decodeFromString<List<String>>(serverUrlsJson))
-      }
-
       val cacheDir = File(File(context.cacheDir, "okhttp"), "api")
       client = build(cacheDir)
       initialized = true
@@ -179,50 +153,25 @@ object HttpClientManager {
     synchronized(this) { clientChangedListeners.add(listener) }
   }
 
-  fun setRequestHeaders(headerMap: Map<String, String>, serverUrls: List<String>, token: String?) {
+  fun setRequestHeaders(headerMap: Map<String, String>, serverUrls: List<String>) {
     synchronized(this) {
       val builder = Headers.Builder()
       headerMap.forEach { (key, value) -> builder[key] = value }
       val newHeaders = builder.build()
-
       val headersChanged = headers != newHeaders
-      val urlsChanged = Json.encodeToString(serverUrls) != prefs.getString(PREFS_SERVER_URLS, null)
-
+      val newUrl = serverUrls.firstOrNull()
+      val urlChanged = newUrl != prefs.getString(PREFS_SERVER_URL, null)
+      if (!headersChanged && !urlChanged) return
       headers = newHeaders
-      cookieJar.setServerUrls(serverUrls)
-
-      if (headersChanged || urlsChanged) {
-        prefs.edit {
-          putString(PREFS_HEADERS, Json.encodeToString(headerMap))
-          putString(PREFS_SERVER_URLS, Json.encodeToString(serverUrls))
+      prefs.edit {
+        if (headersChanged) putString(PREFS_HEADERS, JSONObject(headerMap).toString())
+        if (urlChanged) {
+          if (newUrl != null) putString(PREFS_SERVER_URL, newUrl) else remove(PREFS_SERVER_URL)
         }
       }
-
-      if (token != null) {
-        val url = serverUrls.firstNotNullOfOrNull { it.toHttpUrlOrNull() } ?: return
-        val expiry = System.currentTimeMillis() + COOKIE_EXPIRY_DAYS * 24 * 60 * 60 * 1000
-        val values = mapOf(
-          AuthCookie.ACCESS_TOKEN to token,
-          AuthCookie.IS_AUTHENTICATED to "true",
-          AuthCookie.AUTH_TYPE to "password",
-        )
-        cookieJar.saveFromResponse(url, values.map { (cookie, value) ->
-          Cookie.Builder().name(cookie.cookieName).value(value).domain(url.host).path("/").expiresAt(expiry)
-            .apply {
-              if (url.isHttps) secure()
-              if (cookie.httpOnly) httpOnly()
-            }.build()
-        })
-      }
     }
   }
 
-  fun loadCookieHeader(url: String): String? {
-    val httpUrl = url.toHttpUrlOrNull() ?: return null
-    return cookieJar.loadForRequest(httpUrl).takeIf { it.isNotEmpty() }
-      ?.joinToString("; ") { "${it.name}=${it.value}" }
-  }
-
   private fun build(cacheDir: File): OkHttpClient {
     val connectionPool = ConnectionPool(
       maxIdleConnections = KEEP_ALIVE_CONNECTIONS,
@@ -239,7 +188,6 @@ object HttpClientManager {
     HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.socketFactory)
 
     return OkHttpClient.Builder()
-      .cookieJar(cookieJar)
       .addInterceptor {
         val request = it.request()
         val builder = request.newBuilder()
@@ -301,131 +249,4 @@ object HttpClientManager {
       socket: Socket?
     ): String? = null
   }
-
-  /**
-   * Persistent CookieJar that duplicates auth cookies across equivalent server URLs.
-   * When the server sets cookies for one domain, copies are created for all other known
-   * server domains (for URL switching between local/remote endpoints of the same server).
-   */
-  private class PersistentCookieJar : CookieJar {
-    private val store = mutableListOf<Cookie>()
-    private var serverUrls = listOf<HttpUrl>()
-    private var prefs: SharedPreferences? = null
-
-
-    fun init(prefs: SharedPreferences) {
-      this.prefs = prefs
-      restore()
-    }
-
-    @Synchronized
-    fun setServerUrls(urls: List<String>) {
-      val parsed = urls.mapNotNull { it.toHttpUrlOrNull() }
-      if (parsed.map { it.host } == serverUrls.map { it.host }) return
-      serverUrls = parsed
-      if (syncAuthCookies()) persist()
-    }
-
-    @Synchronized
-    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
-      val changed = cookies.any { new ->
-        store.none { it.name == new.name && it.domain == new.domain && it.path == new.path && it.value == new.value }
-      }
-      store.removeAll { existing ->
-        cookies.any { it.name == existing.name && it.domain == existing.domain && it.path == existing.path }
-      }
-      store.addAll(cookies)
-      val synced = serverUrls.any { it.host == url.host } && syncAuthCookies()
-      if (changed || synced) persist()
-    }
-
-    @Synchronized
-    override fun loadForRequest(url: HttpUrl): List<Cookie> {
-      val now = System.currentTimeMillis()
-      if (store.removeAll { it.expiresAt < now }) {
-        syncAuthCookies()
-        persist()
-      }
-      return store.filter { it.matches(url) }
-    }
-
-    private fun syncAuthCookies(): Boolean {
-      val serverHosts = serverUrls.map { it.host }.toSet()
-      val now = System.currentTimeMillis()
-      val sourceCookies = store
-        .filter { it.name in AuthCookie.names && it.domain in serverHosts && it.expiresAt > now }
-        .associateBy { it.name }
-
-      if (sourceCookies.isEmpty()) {
-        return store.removeAll { it.name in AuthCookie.names && it.domain in serverHosts }
-      }
-
-      var changed = false
-      for (url in serverUrls) {
-        for ((_, source) in sourceCookies) {
-          if (store.any { it.name == source.name && it.domain == url.host && it.value == source.value }) continue
-          store.removeAll { it.name == source.name && it.domain == url.host }
-          store.add(rebuildCookie(source, url))
-          changed = true
-        }
-      }
-      return changed
-    }
-
-    private fun rebuildCookie(source: Cookie, url: HttpUrl): Cookie {
-      return Cookie.Builder()
-        .name(source.name).value(source.value)
-        .domain(url.host).path("/")
-        .expiresAt(source.expiresAt)
-        .apply {
-          if (url.isHttps) secure()
-          if (source.httpOnly) httpOnly()
-        }
-        .build()
-    }
-
-    private fun persist() {
-      val p = prefs ?: return
-      p.edit { putString(PREFS_COOKIES, Json.encodeToString(store.map { SerializedCookie.from(it) })) }
-    }
-
-    private fun restore() {
-      val p = prefs ?: return
-      val jsonStr = p.getString(PREFS_COOKIES, null) ?: return
-      try {
-        store.addAll(Json.decodeFromString<List<SerializedCookie>>(jsonStr).map { it.toCookie() })
-      } catch (_: Exception) {
-        store.clear()
-      }
-    }
-  }
-
-  @Serializable
-  private data class SerializedCookie(
-    val name: String,
-    val value: String,
-    val domain: String,
-    val path: String,
-    val expiresAt: Long,
-    val secure: Boolean,
-    val httpOnly: Boolean,
-    val hostOnly: Boolean,
-  ) {
-    fun toCookie(): Cookie = Cookie.Builder()
-      .name(name).value(value).path(path).expiresAt(expiresAt)
-      .apply {
-        if (hostOnly) hostOnlyDomain(domain) else domain(domain)
-        if (secure) secure()
-        if (httpOnly) httpOnly()
-      }
-      .build()
-
-    companion object {
-      fun from(cookie: Cookie) = SerializedCookie(
-        name = cookie.name, value = cookie.value, domain = cookie.domain,
-        path = cookie.path, expiresAt = cookie.expiresAt, secure = cookie.secure,
-        httpOnly = cookie.httpOnly, hostOnly = cookie.hostOnly,
-      )
-    }
-  }
 }

mobile/android/app/src/main/kotlin/app/alextran/immich/core/Network.g.kt

@@ -184,7 +184,7 @@ interface NetworkApi {
   fun removeCertificate(callback: (Result<Unit>) -> Unit)
   fun hasCertificate(): Boolean
   fun getClientPointer(): Long
-  fun setRequestHeaders(headers: Map<String, String>, serverUrls: List<String>, token: String?)
+  fun setRequestHeaders(headers: Map<String, String>, serverUrls: List<String>)
 
   companion object {
     /** The codec used by NetworkApi. */
@@ -287,9 +287,8 @@ interface NetworkApi {
             val args = message as List<Any?>
             val headersArg = args[0] as Map<String, String>
             val serverUrlsArg = args[1] as List<String>
-            val tokenArg = args[2] as String?
             val wrapped: List<Any?> = try {
-              api.setRequestHeaders(headersArg, serverUrlsArg, tokenArg)
+              api.setRequestHeaders(headersArg, serverUrlsArg)
               listOf(null)
             } catch (exception: Throwable) {
               NetworkPigeonUtils.wrapError(exception)

mobile/android/app/src/main/kotlin/app/alextran/immich/core/NetworkApiPlugin.kt

@@ -39,7 +39,7 @@ class NetworkApiPlugin : FlutterPlugin, ActivityAware {
   }
 }
 
-private class NetworkApiImpl : NetworkApi {
+private class NetworkApiImpl() : NetworkApi {
   var activity: Activity? = null
 
   override fun addCertificate(clientData: ClientCertData, callback: (Result<Unit>) -> Unit) {
@@ -79,7 +79,7 @@ private class NetworkApiImpl : NetworkApi {
     return HttpClientManager.getClientPointer()
   }
 
-  override fun setRequestHeaders(headers: Map<String, String>, serverUrls: List<String>, token: String?) {
-    HttpClientManager.setRequestHeaders(headers, serverUrls, token)
+  override fun setRequestHeaders(headers: Map<String, String>, serverUrls: List<String>) {
+    HttpClientManager.setRequestHeaders(headers, serverUrls)
   }
 }

mobile/android/app/src/main/kotlin/app/alextran/immich/images/RemoteImagesImpl.kt

@@ -192,7 +192,6 @@ private class CronetImageFetcher(context: Context, cacheDir: File) : ImageFetche
     val callback = FetchCallback(onSuccess, onFailure, ::onComplete)
     val requestBuilder = engine.newUrlRequestBuilder(url, callback, executor)
     HttpClientManager.headers.forEach { (key, value) -> requestBuilder.addHeader(key, value) }
-    HttpClientManager.loadCookieHeader(url)?.let { requestBuilder.addHeader("Cookie", it) }
     url.toHttpUrlOrNull()?.let { httpUrl ->
       if (httpUrl.username.isNotEmpty()) {
         requestBuilder.addHeader("Authorization", Credentials.basic(httpUrl.username, httpUrl.password))

mobile/android/app/src/main/kotlin/app/alextran/immich/sync/MessagesImplBase.kt

@@ -16,7 +16,6 @@ import app.alextran.immich.core.ImmichPlugin
 import com.bumptech.glide.Glide
 import com.bumptech.glide.load.ImageHeaderParser
 import com.bumptech.glide.load.ImageHeaderParserUtils
-import com.bumptech.glide.load.resource.bitmap.DefaultImageHeaderParser
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
@@ -82,13 +81,10 @@ open class NativeSyncApiImplBase(context: Context) : ImmichPlugin() {
       }
       if (hasSpecialFormatColumn()) {
         add(SPECIAL_FORMAT_COLUMN)
-      } else {
-        // fallback to mimetype and xmp for playback style detection on older Android versions
-        // both only needed if special format column is not available
-        add(MediaStore.MediaColumns.MIME_TYPE)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-          add(MediaStore.MediaColumns.XMP)
-        }
+      } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        // Fallback: read XMP from MediaStore to detect Motion Photos
+        // only needed if SPECIAL_FORMAT column isn't available
+        add(MediaStore.MediaColumns.XMP)
       }
     }.toTypedArray()
 
@@ -135,7 +131,6 @@ open class NativeSyncApiImplBase(context: Context) : ImmichPlugin() {
         val dateAddedColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATE_ADDED)
         val dateModifiedColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.DATE_MODIFIED)
         val mediaTypeColumn = c.getColumnIndexOrThrow(MediaStore.Files.FileColumns.MEDIA_TYPE)
-        val mimeTypeColumn = c.getColumnIndex(MediaStore.MediaColumns.MIME_TYPE)
         val bucketIdColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.BUCKET_ID)
         val widthColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.WIDTH)
         val heightColumn = c.getColumnIndexOrThrow(MediaStore.MediaColumns.HEIGHT)
@@ -182,20 +177,19 @@ open class NativeSyncApiImplBase(context: Context) : ImmichPlugin() {
           val isFavorite = if (favoriteColumn == -1) false else c.getInt(favoriteColumn) != 0
 
           val playbackStyle = detectPlaybackStyle(
-            numericId, rawMediaType, mimeTypeColumn, specialFormatColumn, xmpColumn, c
+            numericId, rawMediaType, specialFormatColumn, xmpColumn, c
           )
 
-          val isFlipped = orientation == 90 || orientation == 270
           val asset = PlatformAsset(
             id,
             name,
             assetType,
             createdAt,
             modifiedAt,
-            if (isFlipped) height else width,
-            if (isFlipped) width else height,
+            width,
+            height,
             duration,
-            0L,
+            orientation.toLong(),
             isFavorite,
             playbackStyle = playbackStyle,
           )
@@ -206,14 +200,13 @@ open class NativeSyncApiImplBase(context: Context) : ImmichPlugin() {
   }
 
   /**
-   * Detects the playback style for an asset using _special_format (SDK Extension 21+)
-   * or XMP / MIME / RIFF header fallbacks.
+   * Detects the playback style for an asset using _special_format (API 33+)
+   * or XMP / MIME / RIFF header fallbacks (pre-33).
    */
   @SuppressLint("NewApi")
   private fun detectPlaybackStyle(
     assetId: Long,
     rawMediaType: Int,
-    mimeTypeColumn: Int,
     specialFormatColumn: Int,
     xmpColumn: Int,
     cursor: Cursor
@@ -238,56 +231,46 @@ open class NativeSyncApiImplBase(context: Context) : ImmichPlugin() {
       return PlatformAssetPlaybackStyle.UNKNOWN
     }
 
-    val mimeType = if (mimeTypeColumn != -1) cursor.getString(mimeTypeColumn) else null
-
-    // GIFs are always animated and cannot be motion photos; no I/O needed
-    if (mimeType == "image/gif") {
-      return PlatformAssetPlaybackStyle.IMAGE_ANIMATED
-    }
-
+    // Pre-API 33 fallback
     val uri = ContentUris.withAppendedId(
       MediaStore.Files.getContentUri(MediaStore.VOLUME_EXTERNAL),
       assetId
     )
 
-    // Only WebP needs a stream check to distinguish static vs animated;
-    // WebP files are not used as motion photos, so skip XMP detection
-    if (mimeType == "image/webp") {
-      try {
-        val glide = Glide.get(ctx)
-        ctx.contentResolver.openInputStream(uri)?.use { stream ->
-          val type = ImageHeaderParserUtils.getType(
-            listOf(DefaultImageHeaderParser()),
-            stream,
-            glide.arrayPool
-          )
-          // Also check for GIF just in case MIME type is incorrect; Doesn't hurt performance
-          if (type == ImageHeaderParser.ImageType.ANIMATED_WEBP || type == ImageHeaderParser.ImageType.GIF) {
-            return PlatformAssetPlaybackStyle.IMAGE_ANIMATED
-          }
-        }
-      } catch (e: Exception) {
-        Log.w(TAG, "Failed to parse image header for asset $assetId", e)
-      }
-      // if mimeType is webp but not animated, its just an image.
-      return PlatformAssetPlaybackStyle.IMAGE
-    }
-
-
-    // Read XMP from cursor (API 30+)
+    // Read XMP from cursor (API 30+) or ExifInterface stream (pre-30)
     val xmp: String? = if (xmpColumn != -1) {
       cursor.getBlob(xmpColumn)?.toString(Charsets.UTF_8)
     } else {
-      // if xmp column is not available, we are on API 29 or below
-      // theoretically there were motion photos but the Camera:MotionPhoto xmp tag
-      // was only added in Android 11, so we should not have to worry about parsing XMP on older versions
-      null
+      try {
+        ctx.contentResolver.openInputStream(uri)?.use { stream ->
+          ExifInterface(stream).getAttribute(ExifInterface.TAG_XMP)
+        }
+      } catch (e: Exception) {
+        Log.w(TAG, "Failed to read XMP for asset $assetId", e)
+        null
+      }
     }
 
     if (xmp != null && "Camera:MotionPhoto" in xmp) {
       return PlatformAssetPlaybackStyle.LIVE_PHOTO
     }
 
+    try {
+      ctx.contentResolver.openInputStream(uri)?.use { stream ->
+        val glide = Glide.get(ctx)
+        val type = ImageHeaderParserUtils.getType(
+          glide.registry.imageHeaderParsers,
+          stream,
+          glide.arrayPool
+        )
+        if (type == ImageHeaderParser.ImageType.GIF || type == ImageHeaderParser.ImageType.ANIMATED_WEBP) {
+          return PlatformAssetPlaybackStyle.IMAGE_ANIMATED
+        }
+      }
+    } catch (e: Exception) {
+      Log.w(TAG, "Failed to parse image header for asset $assetId", e)
+    }
+
     return PlatformAssetPlaybackStyle.IMAGE
   }
 

mobile/ios/Runner/Core/Network.g.swift

@@ -225,7 +225,7 @@ protocol NetworkApi {
   func removeCertificate(completion: @escaping (Result<Void, Error>) -> Void)
   func hasCertificate() throws -> Bool
   func getClientPointer() throws -> Int64
-  func setRequestHeaders(headers: [String: String], serverUrls: [String], token: String?) throws
+  func setRequestHeaders(headers: [String: String], serverUrls: [String]) throws
 }
 
 /// Generated setup class from Pigeon to handle messages through the `binaryMessenger`.
@@ -315,9 +315,8 @@ class NetworkApiSetup {
         let args = message as! [Any?]
         let headersArg = args[0] as! [String: String]
         let serverUrlsArg = args[1] as! [String]
-        let tokenArg: String? = nilOrValue(args[2])
         do {
-          try api.setRequestHeaders(headers: headersArg, serverUrls: serverUrlsArg, token: tokenArg)
+          try api.setRequestHeaders(headers: headersArg, serverUrls: serverUrlsArg)
           reply(wrapResult(nil))
         } catch {
           reply(wrapError(error))

mobile/ios/Runner/Core/NetworkApiImpl.swift

@@ -58,39 +58,42 @@ class NetworkApiImpl: NetworkApi {
     return Int64(Int(bitPattern: pointer))
   }
   
-  func setRequestHeaders(headers: [String : String], serverUrls: [String], token: String?) throws {
-    URLSessionManager.setServerUrls(serverUrls)
-
-    if let token = token {
-      let expiry = Date().addingTimeInterval(COOKIE_EXPIRY_DAYS * 24 * 60 * 60)
+  func setRequestHeaders(headers: [String : String], serverUrls: [String]) throws {
+    var headers = headers
+    if let token = headers.removeValue(forKey: "x-immich-user-token") {
       for serverUrl in serverUrls {
         guard let url = URL(string: serverUrl), let domain = url.host else { continue }
         let isSecure = serverUrl.hasPrefix("https")
-        let values: [AuthCookie: String] = [
-          .accessToken: token,
-          .isAuthenticated: "true",
-          .authType: "password",
+        let cookies: [(String, String, Bool)] = [
+          ("immich_access_token", token, true),
+          ("immich_is_authenticated", "true", false),
+          ("immich_auth_type", "password", true),
         ]
-        for (cookie, value) in values {
+        let expiry = Date().addingTimeInterval(400 * 24 * 60 * 60)
+        for (name, value, httpOnly) in cookies {
           var properties: [HTTPCookiePropertyKey: Any] = [
-            .name: cookie.name,
+            .name: name,
             .value: value,
             .domain: domain,
             .path: "/",
             .expires: expiry,
           ]
           if isSecure { properties[.secure] = "TRUE" }
-          if cookie.httpOnly { properties[.init("HttpOnly")] = "TRUE" }
-          if let httpCookie = HTTPCookie(properties: properties) {
-            URLSessionManager.cookieStorage.setCookie(httpCookie)
+          if httpOnly { properties[.init("HttpOnly")] = "TRUE" }
+          if let cookie = HTTPCookie(properties: properties) {
+            URLSessionManager.cookieStorage.setCookie(cookie)
           }
         }
       }
     }
 
+    if serverUrls.first != UserDefaults.group.string(forKey: SERVER_URL_KEY) {
+      UserDefaults.group.set(serverUrls.first, forKey: SERVER_URL_KEY)
+    }
+
     if headers != UserDefaults.group.dictionary(forKey: HEADERS_KEY) as? [String: String] {
       UserDefaults.group.set(headers, forKey: HEADERS_KEY)
-      URLSessionManager.shared.recreateSession()
+      URLSessionManager.shared.recreateSession() // Recreate session to apply custom headers without app restart
     }
   }
 }

mobile/ios/Runner/Core/URLSessionManager.swift

@@ -3,30 +3,8 @@ import native_video_player
 
 let CLIENT_CERT_LABEL = "app.alextran.immich.client_identity"
 let HEADERS_KEY = "immich.request_headers"
-let SERVER_URLS_KEY = "immich.server_urls"
+let SERVER_URL_KEY = "immich.server_url"
 let APP_GROUP = "group.app.immich.share"
-let COOKIE_EXPIRY_DAYS: TimeInterval = 400
-
-enum AuthCookie: CaseIterable {
-  case accessToken, isAuthenticated, authType
-
-  var name: String {
-    switch self {
-    case .accessToken: return "immich_access_token"
-    case .isAuthenticated: return "immich_is_authenticated"
-    case .authType: return "immich_auth_type"
-    }
-  }
-
-  var httpOnly: Bool {
-    switch self {
-    case .accessToken, .authType: return true
-    case .isAuthenticated: return false
-    }
-  }
-
-  static let names: Set<String> = Set(allCases.map(\.name))
-}
 
 extension UserDefaults {
   static let group = UserDefaults(suiteName: APP_GROUP)!
@@ -56,94 +34,21 @@ class URLSessionManager: NSObject {
     return "Immich_iOS_\(version)"
   }()
   static let cookieStorage = HTTPCookieStorage.sharedCookieStorage(forGroupContainerIdentifier: APP_GROUP)
-  private static var serverUrls: [String] = []
-  private static var isSyncing = false
-
+  
   var sessionPointer: UnsafeMutableRawPointer {
     Unmanaged.passUnretained(session).toOpaque()
   }
-
+  
   private override init() {
     delegate = URLSessionManagerDelegate()
     session = Self.buildSession(delegate: delegate)
     super.init()
-    Self.serverUrls = UserDefaults.group.stringArray(forKey: SERVER_URLS_KEY) ?? []
-    NotificationCenter.default.addObserver(
-      Self.self,
-      selector: #selector(Self.cookiesDidChange),
-      name: NSNotification.Name.NSHTTPCookieManagerCookiesChanged,
-      object: Self.cookieStorage
-    )
   }
 
   func recreateSession() {
     session = Self.buildSession(delegate: delegate)
   }
 
-  static func setServerUrls(_ urls: [String]) {
-    guard urls != serverUrls else { return }
-    serverUrls = urls
-    UserDefaults.group.set(urls, forKey: SERVER_URLS_KEY)
-    syncAuthCookies()
-  }
-
-  @objc private static func cookiesDidChange(_ notification: Notification) {
-    guard !isSyncing, !serverUrls.isEmpty else { return }
-    syncAuthCookies()
-  }
-
-  private static func syncAuthCookies() {
-    let serverHosts = Set(serverUrls.compactMap { URL(string: $0)?.host })
-    let allCookies = cookieStorage.cookies ?? []
-    let now = Date()
-
-    let serverAuthCookies = allCookies.filter {
-      AuthCookie.names.contains($0.name) && serverHosts.contains($0.domain)
-    }
-
-    var sourceCookies: [String: HTTPCookie] = [:]
-    for cookie in serverAuthCookies {
-      if cookie.expiresDate.map({ $0 > now }) ?? true {
-        sourceCookies[cookie.name] = cookie
-      }
-    }
-
-    isSyncing = true
-    defer { isSyncing = false }
-
-    if sourceCookies.isEmpty {
-      for cookie in serverAuthCookies {
-        cookieStorage.deleteCookie(cookie)
-      }
-      return
-    }
-
-    for serverUrl in serverUrls {
-      guard let url = URL(string: serverUrl), let domain = url.host else { continue }
-      let isSecure = serverUrl.hasPrefix("https")
-
-      for (_, source) in sourceCookies {
-        if allCookies.contains(where: { $0.name == source.name && $0.domain == domain && $0.value == source.value }) {
-          continue
-        }
-
-        var properties: [HTTPCookiePropertyKey: Any] = [
-          .name: source.name,
-          .value: source.value,
-          .domain: domain,
-          .path: "/",
-          .expires: source.expiresDate ?? Date().addingTimeInterval(COOKIE_EXPIRY_DAYS * 24 * 60 * 60),
-        ]
-        if isSecure { properties[.secure] = "TRUE" }
-        if source.isHTTPOnly { properties[.init("HttpOnly")] = "TRUE" }
-
-        if let cookie = HTTPCookie(properties: properties) {
-          cookieStorage.setCookie(cookie)
-        }
-      }
-    }
-  }
-
   private static func buildSession(delegate: URLSessionManagerDelegate) -> URLSession {
     let config = URLSessionConfiguration.default
     config.urlCache = urlCache

mobile/lib/constants/colors.dart

@@ -7,6 +7,6 @@ const String defaultColorPresetName = "indigo";
 
 const Color immichBrandColorLight = Color(0xFF4150AF);
 const Color immichBrandColorDark = Color(0xFFACCBFA);
-const Color whiteOpacity75 = Color.fromRGBO(255, 255, 255, 0.75);
+const Color whiteOpacity75 = Color.fromARGB((0.75 * 255) ~/ 1, 255, 255, 255);
 const Color red400 = Color(0xFFEF5350);
 const Color grey200 = Color(0xFFEEEEEE);

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

@@ -46,7 +46,6 @@ sealed class BaseAsset {
   bool get isVideo => type == AssetType.video;
 
   bool get isMotionPhoto => livePhotoVideoId != null;
-  bool get isAnimatedImage => playbackStyle == AssetPlaybackStyle.imageAnimated;
 
   AssetPlaybackStyle get playbackStyle {
     if (isVideo) return AssetPlaybackStyle.video;

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

@@ -26,8 +26,8 @@ class NetworkRepository {
     }
   }
 
-  static Future<void> setHeaders(Map<String, String> headers, List<String> serverUrls, {String? token}) async {
-    await networkApi.setRequestHeaders(headers, serverUrls, token);
+  static Future<void> setHeaders(Map<String, String> headers, List<String> serverUrls) async {
+    await networkApi.setRequestHeaders(headers, serverUrls);
     if (Platform.isIOS) {
       await init();
     }

mobile/lib/pages/backup/drift_backup.page.dart

@@ -148,12 +148,10 @@ class _DriftBackupPageState extends ConsumerState<DriftBackupPage> {
                         children: [
                           Icon(Icons.warning_rounded, color: context.colorScheme.error, fill: 1),
                           const SizedBox(width: 8),
-                          Flexible(
-                            child: Text(
-                              context.t.backup_error_sync_failed,
-                              style: context.textTheme.bodyMedium?.copyWith(color: context.colorScheme.error),
-                              textAlign: TextAlign.center,
-                            ),
+                          Text(
+                            context.t.backup_error_sync_failed,
+                            style: context.textTheme.bodyMedium?.copyWith(color: context.colorScheme.error),
+                            textAlign: TextAlign.center,
                           ),
                         ],
                       ),
@@ -346,7 +344,6 @@ class _RemainderCard extends ConsumerWidget {
                       remainderCount.toString(),
                       style: context.textTheme.titleLarge?.copyWith(
                         color: context.colorScheme.onSurface.withAlpha(syncStatus.isRemoteSyncing ? 50 : 255),
-                        fontFeatures: [const FontFeature.tabularFigures()],
                       ),
                     ),
                     if (syncStatus.isRemoteSyncing)
@@ -486,7 +483,6 @@ class _PreparingStatusState extends ConsumerState {
                     style: context.textTheme.titleMedium?.copyWith(
                       color: context.colorScheme.primary,
                       fontWeight: FontWeight.w600,
-                      fontFeatures: [const FontFeature.tabularFigures()],
                     ),
                   ),
                 ],
@@ -511,7 +507,6 @@ class _PreparingStatusState extends ConsumerState {
                   style: context.textTheme.titleMedium?.copyWith(
                     color: context.primaryColor,
                     fontWeight: FontWeight.w600,
-                    fontFeatures: [const FontFeature.tabularFigures()],
                   ),
                 ),
               ],

mobile/lib/platform/network_api.g.dart

@@ -281,7 +281,7 @@ class NetworkApi {
     }
   }
 
-  Future<void> setRequestHeaders(Map<String, String> headers, List<String> serverUrls, String? token) async {
+  Future<void> setRequestHeaders(Map<String, String> headers, List<String> serverUrls) async {
     final String pigeonVar_channelName =
         'dev.flutter.pigeon.immich_mobile.NetworkApi.setRequestHeaders$pigeonVar_messageChannelSuffix';
     final BasicMessageChannel<Object?> pigeonVar_channel = BasicMessageChannel<Object?>(
@@ -289,7 +289,7 @@ class NetworkApi {
       pigeonChannelCodec,
       binaryMessenger: pigeonVar_binaryMessenger,
     );
-    final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(<Object?>[headers, serverUrls, token]);
+    final Future<Object?> pigeonVar_sendFuture = pigeonVar_channel.send(<Object?>[headers, serverUrls]);
     final List<Object?>? pigeonVar_replyList = await pigeonVar_sendFuture as List<Object?>?;
     if (pigeonVar_replyList == null) {
       throw _createConnectionError(pigeonVar_channelName);

mobile/lib/presentation/widgets/asset_viewer/asset_page.widget.dart

@@ -19,6 +19,7 @@ import 'package:immich_mobile/presentation/widgets/images/image_provider.dart';
 import 'package:immich_mobile/presentation/widgets/images/thumbnail.widget.dart';
 import 'package:immich_mobile/providers/app_settings.provider.dart';
 import 'package:immich_mobile/providers/asset_viewer/is_motion_video_playing.provider.dart';
+import 'package:immich_mobile/providers/asset_viewer/video_player_provider.dart';
 import 'package:immich_mobile/services/app_settings.service.dart';
 import 'package:immich_mobile/providers/infrastructure/timeline.provider.dart';
 import 'package:immich_mobile/widgets/common/immich_loading_indicator.dart';
@@ -247,6 +248,11 @@ class _AssetPageState extends ConsumerState<AssetPage> {
 
     if (scaleState != PhotoViewScaleState.initial) {
       if (_dragStart == null) _viewer.setControls(false);
+
+      final heroTag = ref.read(assetViewerProvider).currentAsset?.heroTag;
+      if (heroTag != null) {
+        ref.read(videoPlayerProvider(heroTag).notifier).pause();
+      }
       return;
     }
 

mobile/lib/presentation/widgets/asset_viewer/bottom_bar.widget.dart

@@ -61,27 +61,15 @@ class ViewerBottomBar extends ConsumerWidget {
                 ),
               ),
               child: Container(
-                decoration: const BoxDecoration(
-                  gradient: LinearGradient(
-                    begin: Alignment.bottomCenter,
-                    end: Alignment.topCenter,
-                    colors: [Colors.black45, Colors.black12, Colors.transparent],
-                    stops: [0.0, 0.7, 1.0],
-                  ),
-                ),
-                child: SafeArea(
-                  top: false,
-                  child: Padding(
-                    padding: const EdgeInsets.only(top: 16),
-                    child: Column(
-                      mainAxisSize: MainAxisSize.min,
-                      children: [
-                        if (asset.isVideo) VideoControls(videoPlayerName: asset.heroTag),
-                        if (!isReadonlyModeEnabled)
-                          Row(mainAxisAlignment: MainAxisAlignment.spaceEvenly, children: actions),
-                      ],
-                    ),
-                  ),
+                color: Colors.black.withAlpha(125),
+                padding: EdgeInsets.only(bottom: context.padding.bottom, top: 16),
+                child: Column(
+                  mainAxisSize: MainAxisSize.min,
+                  children: [
+                    if (asset.isVideo) VideoControls(videoPlayerName: asset.heroTag),
+                    if (!isReadonlyModeEnabled)
+                      Row(mainAxisAlignment: MainAxisAlignment.spaceEvenly, children: actions),
+                  ],
                 ),
               ),
             ),

mobile/lib/presentation/widgets/asset_viewer/video_viewer.widget.dart

@@ -10,6 +10,7 @@ import 'package:immich_mobile/entities/store.entity.dart';
 import 'package:immich_mobile/extensions/platform_extensions.dart';
 import 'package:immich_mobile/infrastructure/repositories/storage.repository.dart';
 import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
+import 'package:immich_mobile/presentation/widgets/asset_viewer/video_viewer_controls.widget.dart';
 import 'package:immich_mobile/providers/app_settings.provider.dart';
 import 'package:immich_mobile/providers/asset_viewer/is_motion_video_playing.provider.dart';
 import 'package:immich_mobile/providers/asset_viewer/video_player_provider.dart';
@@ -185,7 +186,11 @@ class _NativeVideoViewerState extends ConsumerState<NativeVideoViewer> with Widg
     final source = await _videoSource;
     if (source == null || !mounted) return;
 
-    await _notifier.load(source);
+    unawaited(
+      nc.loadVideoSource(source).catchError((error) {
+        _log.severe('Error loading video source: $error');
+      }),
+    );
     final loopVideo = ref.read(appSettingsServiceProvider).getSetting<bool>(AppSettingsEnum.loopVideo);
     await _notifier.setLoop(!widget.asset.isMotionPhoto && loopVideo);
     await _notifier.setVolume(1);
@@ -208,28 +213,21 @@ class _NativeVideoViewerState extends ConsumerState<NativeVideoViewer> with Widg
 
   @override
   Widget build(BuildContext context) {
-    final isCasting = ref.watch(castProvider.select((c) => c.isCasting));
-    final status = ref.watch(videoPlayerProvider(widget.asset.heroTag).select((v) => v.status));
+    // Prevent the provider from being disposed whilst the widget is alive.
+    ref.listen(videoPlayerProvider(widget.asset.heroTag), (_, __) {});
 
-    return IgnorePointer(
-      child: Stack(
-        children: [
-          Center(child: widget.image),
-          if (!isCasting) ...[
-            Visibility.maintain(
-              visible: _isVideoReady,
-              child: NativeVideoPlayerView(onViewReady: _initController),
-            ),
-            Center(
-              child: AnimatedOpacity(
-                opacity: status == VideoPlaybackStatus.buffering ? 1.0 : 0.0,
-                duration: const Duration(milliseconds: 400),
-                child: const CircularProgressIndicator(),
-              ),
-            ),
-          ],
-        ],
-      ),
+    final isCasting = ref.watch(castProvider.select((c) => c.isCasting));
+
+    return Stack(
+      children: [
+        Center(child: widget.image),
+        if (!isCasting)
+          Visibility.maintain(
+            visible: _isVideoReady,
+            child: NativeVideoPlayerView(onViewReady: _initController),
+          ),
+        if (widget.showControls) Center(child: VideoViewerControls(asset: widget.asset)),
+      ],
     );
   }
 }

mobile/lib/presentation/widgets/asset_viewer/video_viewer_controls.widget.dart

@@ -0,0 +1,114 @@
+import 'package:flutter/material.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/models/cast/cast_manager_state.dart';
+import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
+import 'package:immich_mobile/providers/asset_viewer/video_player_provider.dart';
+import 'package:immich_mobile/providers/cast.provider.dart';
+import 'package:immich_mobile/utils/hooks/timer_hook.dart';
+import 'package:immich_mobile/widgets/asset_viewer/center_play_button.dart';
+import 'package:immich_mobile/widgets/common/delayed_loading_indicator.dart';
+
+class VideoViewerControls extends HookConsumerWidget {
+  final BaseAsset asset;
+  final Duration hideTimerDuration;
+
+  const VideoViewerControls({super.key, required this.asset, this.hideTimerDuration = const Duration(seconds: 5)});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final videoPlayerName = asset.heroTag;
+    final assetIsVideo = asset.isVideo;
+    final showControls = ref.watch(assetViewerProvider.select((s) => s.showingControls && !s.showingDetails));
+    final status = ref.watch(videoPlayerProvider(videoPlayerName).select((value) => value.status));
+
+    final cast = ref.watch(castProvider);
+
+    // A timer to hide the controls
+    final hideTimer = useTimer(hideTimerDuration, () {
+      if (!context.mounted) {
+        return;
+      }
+      final status = ref.read(videoPlayerProvider(videoPlayerName)).status;
+
+      // Do not hide on paused
+      if (status != VideoPlaybackStatus.paused && status != VideoPlaybackStatus.completed && assetIsVideo) {
+        ref.read(assetViewerProvider.notifier).setControls(false);
+      }
+    });
+    final showBuffering = status == VideoPlaybackStatus.buffering && !cast.isCasting;
+
+    /// Shows the controls and starts the timer to hide them
+    void showControlsAndStartHideTimer() {
+      hideTimer.reset();
+      ref.read(assetViewerProvider.notifier).setControls(true);
+    }
+
+    // When playback starts, reset the hide timer
+    ref.listen(videoPlayerProvider(videoPlayerName).select((v) => v.status), (previous, next) {
+      if (next == VideoPlaybackStatus.playing) {
+        hideTimer.reset();
+      }
+    });
+
+    /// Toggles between playing and pausing depending on the state of the video
+    void togglePlay() {
+      showControlsAndStartHideTimer();
+
+      if (cast.isCasting) {
+        switch (cast.castState) {
+          case CastState.playing:
+            ref.read(castProvider.notifier).pause();
+          case CastState.paused:
+            ref.read(castProvider.notifier).play();
+          default:
+        }
+        return;
+      }
+
+      final notifier = ref.read(videoPlayerProvider(videoPlayerName).notifier);
+      switch (status) {
+        case VideoPlaybackStatus.playing:
+          notifier.pause();
+        case VideoPlaybackStatus.completed:
+          notifier.restart();
+        default:
+          notifier.play();
+      }
+    }
+
+    void toggleControlsVisibility() {
+      if (showBuffering) return;
+
+      if (showControls) {
+        ref.read(assetViewerProvider.notifier).setControls(false);
+      } else {
+        showControlsAndStartHideTimer();
+      }
+    }
+
+    return GestureDetector(
+      behavior: HitTestBehavior.translucent,
+      onTap: toggleControlsVisibility,
+      child: IgnorePointer(
+        ignoring: !showControls,
+        child: Stack(
+          children: [
+            if (showBuffering)
+              const Center(child: DelayedLoadingIndicator(fadeInDuration: Duration(milliseconds: 400)))
+            else
+              CenterPlayButton(
+                backgroundColor: Colors.black54,
+                iconColor: Colors.white,
+                isFinished: status == VideoPlaybackStatus.completed,
+                isPlaying:
+                    status == VideoPlaybackStatus.playing || (cast.isCasting && cast.castState == CastState.playing),
+                show: assetIsVideo && showControls,
+                onPressed: togglePlay,
+              ),
+          ],
+        ),
+      ),
+    );
+  }
+}

mobile/lib/presentation/widgets/asset_viewer/viewer_top_app_bar.widget.dart

@@ -75,29 +75,17 @@ class ViewerTopAppBar extends ConsumerWidget implements PreferredSizeWidget {
       child: AnimatedOpacity(
         opacity: opacity,
         duration: Durations.short2,
-        child: DecoratedBox(
-          decoration: BoxDecoration(
-            gradient: showingDetails
-                ? null
-                : const LinearGradient(
-                    begin: Alignment.topCenter,
-                    end: Alignment.bottomCenter,
-                    colors: [Colors.black45, Colors.black12, Colors.transparent],
-                    stops: [0.0, 0.7, 1.0],
-                  ),
-          ),
-          child: AppBar(
-            backgroundColor: Colors.transparent,
-            leading: const _AppBarBackButton(),
-            iconTheme: const IconThemeData(size: 22, color: Colors.white),
-            actionsIconTheme: const IconThemeData(size: 22, color: Colors.white),
-            shape: const Border(),
-            actions: showingDetails || isReadonlyModeEnabled
-                ? null
-                : isInLockedView
-                ? lockedViewActions
-                : actions,
-          ),
+        child: AppBar(
+          backgroundColor: showingDetails ? Colors.transparent : Colors.black.withValues(alpha: 0.5),
+          leading: const _AppBarBackButton(),
+          iconTheme: const IconThemeData(size: 22, color: Colors.white),
+          actionsIconTheme: const IconThemeData(size: 22, color: Colors.white),
+          shape: const Border(),
+          actions: showingDetails || isReadonlyModeEnabled
+              ? null
+              : isInLockedView
+              ? lockedViewActions
+              : actions,
         ),
       ),
     );
@@ -113,14 +101,17 @@ class _AppBarBackButton extends ConsumerWidget {
   @override
   Widget build(BuildContext context, WidgetRef ref) {
     final showingDetails = ref.watch(assetViewerProvider.select((state) => state.showingDetails));
+    final backgroundColor = showingDetails && !context.isDarkTheme ? Colors.white : Colors.black;
+    final foregroundColor = showingDetails && !context.isDarkTheme ? Colors.black : Colors.white;
+
     return Padding(
       padding: const EdgeInsets.only(left: 12.0),
       child: ElevatedButton(
         style: ElevatedButton.styleFrom(
-          backgroundColor: showingDetails ? context.colorScheme.surface : Colors.transparent,
+          backgroundColor: backgroundColor,
           shape: const CircleBorder(),
           iconSize: 22,
-          iconColor: showingDetails ? context.colorScheme.onSurface : Colors.white,
+          iconColor: foregroundColor,
           padding: EdgeInsets.zero,
           elevation: showingDetails ? 4 : 0,
         ),

mobile/lib/presentation/widgets/images/animated_image_stream_completer.dart

@@ -1,96 +0,0 @@
-import 'dart:async';
-import 'dart:ui' as ui;
-
-import 'package:flutter/foundation.dart' show InformationCollector;
-import 'package:flutter/painting.dart';
-
-/// A [MultiFrameImageStreamCompleter] with support for listener tracking
-/// which makes resource cleanup possible when no longer needed.
-/// Codec is disposed through the MultiFrameImageStreamCompleter's internals onDispose method
-class AnimatedImageStreamCompleter extends MultiFrameImageStreamCompleter {
-  void Function()? _onLastListenerRemoved;
-  int _listenerCount = 0;
-  // True once any image or the codec has been provided.
-  // Until then the image cache holds one listener, so "last real listener gone"
-  // is _listenerCount == 1, not 0.
-  bool didProvideImage = false;
-
-  AnimatedImageStreamCompleter._({
-    required super.codec,
-    required super.scale,
-    super.informationCollector,
-    void Function()? onLastListenerRemoved,
-  }) : _onLastListenerRemoved = onLastListenerRemoved;
-
-  factory AnimatedImageStreamCompleter({
-    required Stream<Object> stream,
-    required double scale,
-    ImageInfo? initialImage,
-    InformationCollector? informationCollector,
-    void Function()? onLastListenerRemoved,
-  }) {
-    final codecCompleter = Completer<ui.Codec>();
-    final self = AnimatedImageStreamCompleter._(
-      codec: codecCompleter.future,
-      scale: scale,
-      informationCollector: informationCollector,
-      onLastListenerRemoved: onLastListenerRemoved,
-    );
-
-    if (initialImage != null) {
-      self.didProvideImage = true;
-      self.setImage(initialImage);
-    }
-
-    stream.listen(
-      (item) {
-        if (item is ImageInfo) {
-          self.didProvideImage = true;
-          self.setImage(item);
-        } else if (item is ui.Codec) {
-          if (!codecCompleter.isCompleted) {
-            self.didProvideImage = true;
-            codecCompleter.complete(item);
-          }
-        }
-      },
-      onError: (Object error, StackTrace stack) {
-        if (!codecCompleter.isCompleted) {
-          codecCompleter.completeError(error, stack);
-        }
-      },
-      onDone: () {
-        // also complete if we are done but no error occurred, and we didn't call complete yet
-        // could happen on cancellation
-        if (!codecCompleter.isCompleted) {
-          codecCompleter.completeError(StateError('Stream closed without providing a codec'));
-        }
-      },
-    );
-
-    return self;
-  }
-
-  @override
-  void addListener(ImageStreamListener listener) {
-    super.addListener(listener);
-    _listenerCount++;
-  }
-
-  @override
-  void removeListener(ImageStreamListener listener) {
-    super.removeListener(listener);
-    _listenerCount--;
-
-    final bool onlyCacheListenerLeft = _listenerCount == 1 && !didProvideImage;
-    final bool noListenersAfterCodec = _listenerCount == 0 && didProvideImage;
-
-    if (onlyCacheListenerLeft || noListenersAfterCodec) {
-      final onLastListenerRemoved = _onLastListenerRemoved;
-      if (onLastListenerRemoved != null) {
-        _onLastListenerRemoved = null;
-        onLastListenerRemoved();
-      }
-    }
-  }
-}

mobile/lib/presentation/widgets/images/image_provider.dart

@@ -140,7 +140,7 @@ ImageProvider getFullImageProvider(BaseAsset asset, {Size size = const Size(1080
   final ImageProvider provider;
   if (_shouldUseLocalAsset(asset)) {
     final id = asset is LocalAsset ? asset.id : (asset as RemoteAsset).localId!;
-    provider = LocalFullImageProvider(id: id, size: size, assetType: asset.type, isAnimated: asset.isAnimatedImage);
+    provider = LocalFullImageProvider(id: id, size: size, assetType: asset.type);
   } else {
     final String assetId;
     final String thumbhash;
@@ -153,12 +153,7 @@ ImageProvider getFullImageProvider(BaseAsset asset, {Size size = const Size(1080
     } else {
       throw ArgumentError("Unsupported asset type: ${asset.runtimeType}");
     }
-    provider = RemoteFullImageProvider(
-      assetId: assetId,
-      thumbhash: thumbhash,
-      assetType: asset.type,
-      isAnimated: asset.isAnimatedImage,
-    );
+    provider = RemoteFullImageProvider(assetId: assetId, thumbhash: thumbhash, assetType: asset.type);
   }
 
   return provider;

mobile/lib/presentation/widgets/images/local_image_provider.dart

@@ -1,10 +1,11 @@
+import 'dart:ui';
+
 import 'package:flutter/foundation.dart';
 import 'package:flutter/widgets.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/domain/models/store.model.dart';
 import 'package:immich_mobile/entities/store.entity.dart';
 import 'package:immich_mobile/infrastructure/loaders/image_request.dart';
-import 'package:immich_mobile/presentation/widgets/images/animated_image_stream_completer.dart';
 import 'package:immich_mobile/presentation/widgets/images/image_provider.dart';
 import 'package:immich_mobile/presentation/widgets/images/one_frame_multi_image_stream_completer.dart';
 import 'package:immich_mobile/presentation/widgets/timeline/constants.dart';
@@ -57,9 +58,8 @@ class LocalFullImageProvider extends CancellableImageProvider<LocalFullImageProv
   final String id;
   final Size size;
   final AssetType assetType;
-  final bool isAnimated;
 
-  LocalFullImageProvider({required this.id, required this.assetType, required this.size, required this.isAnimated});
+  LocalFullImageProvider({required this.id, required this.assetType, required this.size});
 
   @override
   Future<LocalFullImageProvider> obtainKey(ImageConfiguration configuration) {
@@ -68,21 +68,6 @@ class LocalFullImageProvider extends CancellableImageProvider<LocalFullImageProv
 
   @override
   ImageStreamCompleter loadImage(LocalFullImageProvider key, ImageDecoderCallback decode) {
-    if (key.isAnimated) {
-      return AnimatedImageStreamCompleter(
-        stream: _animatedCodec(key, decode),
-        scale: 1.0,
-        initialImage: getInitialImage(LocalThumbProvider(id: key.id, assetType: key.assetType)),
-        informationCollector: () => <DiagnosticsNode>[
-          DiagnosticsProperty<ImageProvider>('Image provider', this),
-          DiagnosticsProperty<String>('Id', key.id),
-          DiagnosticsProperty<Size>('Size', key.size),
-          DiagnosticsProperty<bool>('isAnimated', key.isAnimated),
-        ],
-        onLastListenerRemoved: cancel,
-      );
-    }
-
     return OneFramePlaceholderImageStreamCompleter(
       _codec(key, decode),
       initialImage: getInitialImage(LocalThumbProvider(id: key.id, assetType: key.assetType)),
@@ -90,7 +75,6 @@ class LocalFullImageProvider extends CancellableImageProvider<LocalFullImageProv
         DiagnosticsProperty<ImageProvider>('Image provider', this),
         DiagnosticsProperty<String>('Id', key.id),
         DiagnosticsProperty<Size>('Size', key.size),
-        DiagnosticsProperty<bool>('isAnimated', key.isAnimated),
       ],
       onLastListenerRemoved: cancel,
     );
@@ -126,45 +110,15 @@ class LocalFullImageProvider extends CancellableImageProvider<LocalFullImageProv
     yield* loadRequest(request, decode);
   }
 
-  Stream<Object> _animatedCodec(LocalFullImageProvider key, ImageDecoderCallback decode) async* {
-    yield* initialImageStream();
-
-    if (isCancelled) {
-      PaintingBinding.instance.imageCache.evict(this);
-      return;
-    }
-
-    final devicePixelRatio = PlatformDispatcher.instance.views.first.devicePixelRatio;
-    final previewRequest = request = LocalImageRequest(
-      localId: key.id,
-      size: Size(size.width * devicePixelRatio, size.height * devicePixelRatio),
-      assetType: key.assetType,
-    );
-    yield* loadRequest(previewRequest, decode);
-
-    if (isCancelled) {
-      PaintingBinding.instance.imageCache.evict(this);
-      return;
-    }
-
-    // always try original for animated, since previews don't support animation
-    final originalRequest = request = LocalImageRequest(localId: key.id, size: Size.zero, assetType: key.assetType);
-    final codec = await loadCodecRequest(originalRequest);
-    if (codec == null) {
-      throw StateError('Failed to load animated codec for local asset ${key.id}');
-    }
-    yield codec;
-  }
-
   @override
   bool operator ==(Object other) {
     if (identical(this, other)) return true;
     if (other is LocalFullImageProvider) {
-      return id == other.id && size == other.size && isAnimated == other.isAnimated;
+      return id == other.id && size == other.size;
     }
     return false;
   }
 
   @override
-  int get hashCode => id.hashCode ^ size.hashCode ^ isAnimated.hashCode;
+  int get hashCode => id.hashCode ^ size.hashCode;
 }

mobile/lib/presentation/widgets/images/remote_image_provider.dart

@@ -4,7 +4,6 @@ import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
 import 'package:immich_mobile/domain/models/setting.model.dart';
 import 'package:immich_mobile/domain/services/setting.service.dart';
 import 'package:immich_mobile/infrastructure/loaders/image_request.dart';
-import 'package:immich_mobile/presentation/widgets/images/animated_image_stream_completer.dart';
 import 'package:immich_mobile/presentation/widgets/images/image_provider.dart';
 import 'package:immich_mobile/presentation/widgets/images/one_frame_multi_image_stream_completer.dart';
 import 'package:immich_mobile/utils/image_url_builder.dart';
@@ -59,14 +58,8 @@ class RemoteFullImageProvider extends CancellableImageProvider<RemoteFullImagePr
   final String assetId;
   final String thumbhash;
   final AssetType assetType;
-  final bool isAnimated;
 
-  RemoteFullImageProvider({
-    required this.assetId,
-    required this.thumbhash,
-    required this.assetType,
-    required this.isAnimated,
-  });
+  RemoteFullImageProvider({required this.assetId, required this.thumbhash, required this.assetType});
 
   @override
   Future<RemoteFullImageProvider> obtainKey(ImageConfiguration configuration) {
@@ -75,27 +68,12 @@ class RemoteFullImageProvider extends CancellableImageProvider<RemoteFullImagePr
 
   @override
   ImageStreamCompleter loadImage(RemoteFullImageProvider key, ImageDecoderCallback decode) {
-    if (key.isAnimated) {
-      return AnimatedImageStreamCompleter(
-        stream: _animatedCodec(key, decode),
-        scale: 1.0,
-        initialImage: getInitialImage(RemoteImageProvider.thumbnail(assetId: key.assetId, thumbhash: key.thumbhash)),
-        informationCollector: () => <DiagnosticsNode>[
-          DiagnosticsProperty<ImageProvider>('Image provider', this),
-          DiagnosticsProperty<String>('Asset Id', key.assetId),
-          DiagnosticsProperty<bool>('isAnimated', key.isAnimated),
-        ],
-        onLastListenerRemoved: cancel,
-      );
-    }
-
     return OneFramePlaceholderImageStreamCompleter(
       _codec(key, decode),
       initialImage: getInitialImage(RemoteImageProvider.thumbnail(assetId: key.assetId, thumbhash: key.thumbhash)),
       informationCollector: () => <DiagnosticsNode>[
         DiagnosticsProperty<ImageProvider>('Image provider', this),
         DiagnosticsProperty<String>('Asset Id', key.assetId),
-        DiagnosticsProperty<bool>('isAnimated', key.isAnimated),
       ],
       onLastListenerRemoved: cancel,
     );
@@ -128,43 +106,16 @@ class RemoteFullImageProvider extends CancellableImageProvider<RemoteFullImagePr
     yield* loadRequest(originalRequest, decode);
   }
 
-  Stream<Object> _animatedCodec(RemoteFullImageProvider key, ImageDecoderCallback decode) async* {
-    yield* initialImageStream();
-
-    if (isCancelled) {
-      PaintingBinding.instance.imageCache.evict(this);
-      return;
-    }
-
-    final previewRequest = request = RemoteImageRequest(
-      uri: getThumbnailUrlForRemoteId(key.assetId, type: AssetMediaSize.preview, thumbhash: key.thumbhash),
-    );
-    yield* loadRequest(previewRequest, decode, evictOnError: false);
-
-    if (isCancelled) {
-      PaintingBinding.instance.imageCache.evict(this);
-      return;
-    }
-
-    // always try original for animated, since previews don't support animation
-    final originalRequest = request = RemoteImageRequest(uri: getOriginalUrlForRemoteId(key.assetId));
-    final codec = await loadCodecRequest(originalRequest);
-    if (codec == null) {
-      throw StateError('Failed to load animated codec for asset ${key.assetId}');
-    }
-    yield codec;
-  }
-
   @override
   bool operator ==(Object other) {
     if (identical(this, other)) return true;
     if (other is RemoteFullImageProvider) {
-      return assetId == other.assetId && thumbhash == other.thumbhash && isAnimated == other.isAnimated;
+      return assetId == other.assetId && thumbhash == other.thumbhash;
     }
 
     return false;
   }
 
   @override
-  int get hashCode => assetId.hashCode ^ thumbhash.hashCode ^ isAnimated.hashCode;
+  int get hashCode => assetId.hashCode ^ thumbhash.hashCode;
 }

mobile/lib/presentation/widgets/images/thumbnail_tile.widget.dart

@@ -305,8 +305,6 @@ class _AssetTypeIcons extends StatelessWidget {
             padding: EdgeInsets.only(right: 10.0, top: 6.0),
             child: _TileOverlayIcon(Icons.motion_photos_on_rounded),
           ),
-        if (asset.isAnimatedImage)
-          const Padding(padding: EdgeInsets.only(right: 10.0, top: 6.0), child: _TileOverlayIcon(Icons.gif_rounded)),
       ],
     );
   }

mobile/lib/providers/asset_viewer/asset_viewer.provider.dart

@@ -100,11 +100,11 @@ class AssetViewerStateNotifier extends Notifier<AssetViewerState> {
       return;
     }
     state = state.copyWith(showingDetails: showing, showingControls: showing ? true : state.showingControls);
-
-    final heroTag = state.currentAsset?.heroTag;
-    if (heroTag != null) {
-      final notifier = ref.read(videoPlayerProvider(heroTag).notifier);
-      showing ? notifier.hold() : notifier.release();
+    if (showing) {
+      final heroTag = state.currentAsset?.heroTag;
+      if (heroTag != null) {
+        ref.read(videoPlayerProvider(heroTag).notifier).pause();
+      }
     }
   }
 

mobile/lib/providers/asset_viewer/video_player_provider.dart

@@ -44,7 +44,10 @@ class VideoPlayerNotifier extends StateNotifier<VideoPlayerState> {
   NativeVideoPlayerController? _controller;
   Timer? _bufferingTimer;
   Timer? _seekTimer;
-  VideoPlaybackStatus? _holdStatus;
+
+  void attachController(NativeVideoPlayerController controller) {
+    _controller = controller;
+  }
 
   @override
   void dispose() {
@@ -56,19 +59,6 @@ class VideoPlayerNotifier extends StateNotifier<VideoPlayerState> {
     super.dispose();
   }
 
-  void attachController(NativeVideoPlayerController controller) {
-    _controller = controller;
-  }
-
-  Future<void> load(VideoSource source) async {
-    _startBufferingTimer();
-    try {
-      await _controller?.loadVideoSource(source);
-    } catch (e) {
-      _log.severe('Error loading video source: $e');
-    }
-  }
-
   Future<void> pause() async {
     if (_controller == null) return;
 
@@ -104,50 +94,16 @@ class VideoPlayerNotifier extends StateNotifier<VideoPlayerState> {
   }
 
   void seekTo(Duration position) {
-    if (_controller == null || state.position == position) return;
+    if (_controller == null) return;
 
     state = state.copyWith(position: position);
 
-    if (_seekTimer?.isActive ?? false) return;
-
-    _seekTimer = Timer(const Duration(milliseconds: 150), () {
-      _controller?.seekTo(state.position.inMilliseconds);
+    _seekTimer?.cancel();
+    _seekTimer = Timer(const Duration(milliseconds: 100), () {
+      _controller?.seekTo(position.inMilliseconds);
     });
   }
 
-  void toggle() {
-    _holdStatus = null;
-
-    switch (state.status) {
-      case VideoPlaybackStatus.paused:
-        play();
-      case VideoPlaybackStatus.playing || VideoPlaybackStatus.buffering:
-        pause();
-      case VideoPlaybackStatus.completed:
-        restart();
-    }
-  }
-
-  /// Pauses playback and preserves the current status for later restoration.
-  void hold() {
-    if (_holdStatus != null) return;
-
-    _holdStatus = state.status;
-    pause();
-  }
-
-  /// Restores playback to the status before [hold] was called.
-  void release() {
-    final status = _holdStatus;
-    _holdStatus = null;
-
-    switch (status) {
-      case VideoPlaybackStatus.playing || VideoPlaybackStatus.buffering:
-        play();
-      default:
-    }
-  }
-
   Future<void> restart() async {
     seekTo(Duration.zero);
     await play();
@@ -193,12 +149,13 @@ class VideoPlayerNotifier extends StateNotifier<VideoPlayerState> {
     final position = Duration(milliseconds: playbackInfo.position);
     if (state.position == position) return;
 
-    if (state.status == VideoPlaybackStatus.playing) _startBufferingTimer();
+    if (state.status == VideoPlaybackStatus.buffering) {
+      state = state.copyWith(position: position, status: VideoPlaybackStatus.playing);
+    } else {
+      state = state.copyWith(position: position);
+    }
 
-    state = state.copyWith(
-      position: position,
-      status: state.status == VideoPlaybackStatus.buffering ? VideoPlaybackStatus.playing : null,
-    );
+    _startBufferingTimer();
   }
 
   void onNativeStatusChanged() {
@@ -216,7 +173,9 @@ class VideoPlayerNotifier extends StateNotifier<VideoPlayerState> {
         onNativePlaybackEnded();
     }
 
-    if (state.status != newStatus) state = state.copyWith(status: newStatus);
+    if (state.status != newStatus) {
+      state = state.copyWith(status: newStatus);
+    }
   }
 
   void onNativePlaybackEnded() {
@@ -227,7 +186,7 @@ class VideoPlayerNotifier extends StateNotifier<VideoPlayerState> {
   void _startBufferingTimer() {
     _bufferingTimer?.cancel();
     _bufferingTimer = Timer(const Duration(seconds: 3), () {
-      if (mounted && state.status != VideoPlaybackStatus.completed) {
+      if (mounted && state.status == VideoPlaybackStatus.playing) {
         state = state.copyWith(status: VideoPlaybackStatus.buffering);
       }
     });

mobile/lib/providers/auth.provider.dart

@@ -123,7 +123,7 @@ class AuthNotifier extends StateNotifier<AuthState> {
   }
 
   Future<bool> saveAuthInfo({required String accessToken}) async {
-    await Store.put(StoreKey.accessToken, accessToken);
+    await _apiService.setAccessToken(accessToken);
     await _apiService.updateHeaders();
 
     final serverEndpoint = Store.get(StoreKey.serverEndpoint);
@@ -145,6 +145,7 @@ class AuthNotifier extends StateNotifier<AuthState> {
         user = serverUser;
         await Store.put(StoreKey.deviceId, deviceId);
         await Store.put(StoreKey.deviceIdHash, fastHash(deviceId));
+        await Store.put(StoreKey.accessToken, accessToken);
       }
     } on ApiException catch (error, stackTrace) {
       if (error.code == 401) {

mobile/lib/providers/cast.provider.dart

@@ -91,16 +91,6 @@ class CastNotifier extends StateNotifier<CastManagerState> {
     return discovered;
   }
 
-  void toggle() {
-    switch (state.castState) {
-      case CastState.playing:
-        pause();
-      case CastState.paused:
-        play();
-      default:
-    }
-  }
-
   void play() {
     _gCastService.play();
   }

mobile/lib/repositories/auth.repository.dart

@@ -38,6 +38,10 @@ class AuthRepository extends DatabaseRepository {
     });
   }
 
+  String getAccessToken() {
+    return Store.get(StoreKey.accessToken);
+  }
+
   bool getEndpointSwitchingFeature() {
     return Store.tryGet(StoreKey.autoEndpointSwitching) ?? false;
   }

mobile/lib/services/api.service.dart

@@ -11,7 +11,7 @@ import 'package:immich_mobile/utils/url_helper.dart';
 import 'package:logging/logging.dart';
 import 'package:openapi/api.dart';
 
-class ApiService {
+class ApiService implements Authentication {
   late ApiClient _apiClient;
 
   late UsersApi usersApi;
@@ -45,6 +45,7 @@ class ApiService {
       setEndpoint(endpoint);
     }
   }
+  String? _accessToken;
   final _log = Logger("ApiService");
 
   Future<void> updateHeaders() async {
@@ -53,8 +54,11 @@ class ApiService {
   }
 
   setEndpoint(String endpoint) {
-    _apiClient = ApiClient(basePath: endpoint);
+    _apiClient = ApiClient(basePath: endpoint, authentication: this);
     _apiClient.client = NetworkRepository.client;
+    if (_accessToken != null) {
+      setAccessToken(_accessToken!);
+    }
     usersApi = UsersApi(_apiClient);
     authenticationApi = AuthenticationApi(_apiClient);
     oAuthApi = AuthenticationApi(_apiClient);
@@ -153,6 +157,11 @@ class ApiService {
     return "";
   }
 
+  Future<void> setAccessToken(String accessToken) async {
+    _accessToken = accessToken;
+    await Store.put(StoreKey.accessToken, accessToken);
+  }
+
   Future<void> setDeviceInfoHeader() async {
     DeviceInfoPlugin deviceInfoPlugin = DeviceInfoPlugin();
 
@@ -196,12 +205,28 @@ class ApiService {
   }
 
   static Map<String, String> getRequestHeaders() {
+    var accessToken = Store.get(StoreKey.accessToken, "");
     var customHeadersStr = Store.get(StoreKey.customHeaders, "");
-    if (customHeadersStr.isEmpty) {
-      return const {};
+    var header = <String, String>{};
+    if (accessToken.isNotEmpty) {
+      header['x-immich-user-token'] = accessToken;
     }
 
-    return (jsonDecode(customHeadersStr) as Map).cast<String, String>();
+    if (customHeadersStr.isEmpty) {
+      return header;
+    }
+
+    var customHeaders = jsonDecode(customHeadersStr) as Map;
+    customHeaders.forEach((key, value) {
+      header[key] = value;
+    });
+
+    return header;
+  }
+
+  @override
+  Future<void> applyToParams(List<QueryParam> queryParams, Map<String, String> headerParams) {
+    return Future.value();
   }
 
   ApiClient get apiClient => _apiClient;

mobile/lib/services/background.service.dart

@@ -340,6 +340,7 @@ class BackgroundService {
       ],
     );
 
+    await ref.read(apiServiceProvider).setAccessToken(Store.get(StoreKey.accessToken));
     await ref.read(authServiceProvider).setOpenApiServiceEndpoint();
     dPrint(() => "[BG UPLOAD] Using endpoint: ${ref.read(apiServiceProvider).apiClient.basePath}");
 

mobile/lib/services/backup_verification.service.dart

@@ -74,6 +74,7 @@ class BackupVerificationService {
       final lower = compute(_computeSaveToDelete, (
         deleteCandidates: deleteCandidates.slice(0, half),
         originals: originals.slice(0, half),
+        auth: Store.get(StoreKey.accessToken),
         endpoint: Store.get(StoreKey.serverEndpoint),
         rootIsolateToken: isolateToken,
         fileMediaRepository: _fileMediaRepository,
@@ -81,6 +82,7 @@ class BackupVerificationService {
       final upper = compute(_computeSaveToDelete, (
         deleteCandidates: deleteCandidates.slice(half),
         originals: originals.slice(half),
+        auth: Store.get(StoreKey.accessToken),
         endpoint: Store.get(StoreKey.serverEndpoint),
         rootIsolateToken: isolateToken,
         fileMediaRepository: _fileMediaRepository,
@@ -90,6 +92,7 @@ class BackupVerificationService {
       toDelete = await compute(_computeSaveToDelete, (
         deleteCandidates: deleteCandidates,
         originals: originals,
+        auth: Store.get(StoreKey.accessToken),
         endpoint: Store.get(StoreKey.serverEndpoint),
         rootIsolateToken: isolateToken,
         fileMediaRepository: _fileMediaRepository,
@@ -102,6 +105,7 @@ class BackupVerificationService {
     ({
       List<Asset> deleteCandidates,
       List<Asset> originals,
+      String auth,
       String endpoint,
       RootIsolateToken rootIsolateToken,
       FileMediaRepository fileMediaRepository,
@@ -116,6 +120,7 @@ class BackupVerificationService {
     await tuple.fileMediaRepository.enableBackgroundAccess();
     final ApiService apiService = ApiService();
     apiService.setEndpoint(tuple.endpoint);
+    await apiService.setAccessToken(tuple.auth);
     for (int i = 0; i < tuple.deleteCandidates.length; i++) {
       if (await _compareAssets(tuple.deleteCandidates[i], tuple.originals[i], apiService)) {
         result.add(tuple.deleteCandidates[i]);

mobile/lib/theme/theme_data.dart

@@ -62,6 +62,8 @@ ThemeData getThemeData({required ColorScheme colorScheme, required Locale locale
     ),
     chipTheme: const ChipThemeData(side: BorderSide.none),
     sliderTheme: const SliderThemeData(
+      thumbShape: RoundSliderThumbShape(enabledThumbRadius: 7),
+      trackHeight: 2.0,
       // ignore: deprecated_member_use
       year2023: false,
     ),

mobile/lib/utils/migration.dart

@@ -25,10 +25,8 @@ import 'package:immich_mobile/infrastructure/entities/user.entity.dart';
 import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
 import 'package:immich_mobile/infrastructure/repositories/sync_stream.repository.dart';
 import 'package:immich_mobile/platform/native_sync_api.g.dart';
-import 'package:immich_mobile/infrastructure/repositories/network.repository.dart';
 import 'package:immich_mobile/platform/network_api.g.dart';
 import 'package:immich_mobile/providers/infrastructure/platform.provider.dart';
-import 'package:immich_mobile/services/api.service.dart';
 import 'package:immich_mobile/services/app_settings.service.dart';
 import 'package:immich_mobile/utils/datetime_helpers.dart';
 import 'package:immich_mobile/utils/debug_print.dart';
@@ -37,7 +35,7 @@ import 'package:isar/isar.dart';
 // ignore: import_rule_photo_manager
 import 'package:photo_manager/photo_manager.dart';
 
-const int targetVersion = 25;
+const int targetVersion = 23;
 
 Future<void> migrateDatabaseIfNeeded(Isar db, Drift drift) async {
   final hasVersion = Store.tryGet(StoreKey.version) != null;
@@ -107,20 +105,6 @@ Future<void> migrateDatabaseIfNeeded(Isar db, Drift drift) async {
     await _populateLocalAssetPlaybackStyle(drift);
   }
 
-  if (version < 24 && Store.isBetaTimelineEnabled) {
-    await _applyLocalAssetOrientation(drift);
-  }
-
-  if (version < 25) {
-    final accessToken = Store.tryGet(StoreKey.accessToken);
-    if (accessToken != null && accessToken.isNotEmpty) {
-      final serverUrls = ApiService.getServerUrls();
-      if (serverUrls.isNotEmpty) {
-        await NetworkRepository.setHeaders(ApiService.getRequestHeaders(), serverUrls, token: accessToken);
-      }
-    }
-  }
-
   if (version < 22 && !Store.isBetaTimelineEnabled) {
     await Store.put(StoreKey.needBetaMigration, true);
   }
@@ -432,41 +416,26 @@ Future<void> _populateLocalAssetPlaybackStyle(Drift db) async {
       });
     }
 
-    if (Platform.isAndroid) {
-      final trashedAssetMap = await nativeApi.getTrashedAssets();
-      for (final entry in trashedAssetMap.cast<String, List<Object?>>().entries) {
-        final assets = entry.value.cast<PlatformAsset>();
-        await db.batch((batch) {
-          for (final asset in assets) {
-            batch.update(
-              db.trashedLocalAssetEntity,
-              TrashedLocalAssetEntityCompanion(playbackStyle: Value(_toPlaybackStyle(asset.playbackStyle))),
-              where: (t) => t.id.equals(asset.id),
-            );
-          }
-        });
-      }
-      dPrint(() => "[MIGRATION] Successfully populated playbackStyle for local and trashed assets");
-    } else {
-      dPrint(() => "[MIGRATION] Successfully populated playbackStyle for local assets");
+    final trashedAssetMap = await nativeApi.getTrashedAssets();
+    for (final entry in trashedAssetMap.cast<String, List<Object?>>().entries) {
+      final assets = entry.value.cast<PlatformAsset>();
+      await db.batch((batch) {
+        for (final asset in assets) {
+          batch.update(
+            db.trashedLocalAssetEntity,
+            TrashedLocalAssetEntityCompanion(playbackStyle: Value(_toPlaybackStyle(asset.playbackStyle))),
+            where: (t) => t.id.equals(asset.id),
+          );
+        }
+      });
     }
+
+    dPrint(() => "[MIGRATION] Successfully populated playbackStyle for local and trashed assets");
   } catch (error) {
     dPrint(() => "[MIGRATION] Error while populating playbackStyle: $error");
   }
 }
 
-Future<void> _applyLocalAssetOrientation(Drift db) {
-  final query = db.localAssetEntity.update()
-    ..where((filter) => (filter.orientation.equals(90) | (filter.orientation.equals(270))));
-  return query.write(
-    LocalAssetEntityCompanion.custom(
-      width: db.localAssetEntity.height,
-      height: db.localAssetEntity.width,
-      orientation: const Variable(0),
-    ),
-  );
-}
-
 AssetPlaybackStyle _toPlaybackStyle(PlatformAssetPlaybackStyle style) => switch (style) {
   PlatformAssetPlaybackStyle.unknown => AssetPlaybackStyle.unknown,
   PlatformAssetPlaybackStyle.image => AssetPlaybackStyle.image,

mobile/lib/widgets/asset_viewer/animated_play_pause.dart

@@ -1,15 +1,12 @@
-import 'dart:ui';
-
 import 'package:flutter/material.dart';
 
 /// A widget that animates implicitly between a play and a pause icon.
 class AnimatedPlayPause extends StatefulWidget {
-  const AnimatedPlayPause({super.key, required this.playing, this.size, this.color, this.shadows});
+  const AnimatedPlayPause({super.key, required this.playing, this.size, this.color});
 
   final double? size;
   final bool playing;
   final Color? color;
-  final List<Shadow>? shadows;
 
   @override
   State<StatefulWidget> createState() => AnimatedPlayPauseState();
@@ -42,32 +39,12 @@ class AnimatedPlayPauseState extends State<AnimatedPlayPause> with SingleTickerP
 
   @override
   Widget build(BuildContext context) {
-    final icon = AnimatedIcon(
-      color: widget.color,
-      size: widget.size,
-      icon: AnimatedIcons.play_pause,
-      progress: animationController,
-    );
-
     return Center(
-      child: Stack(
-        alignment: Alignment.center,
-        children: [
-          for (final shadow in widget.shadows ?? const <Shadow>[])
-            Transform.translate(
-              offset: shadow.offset,
-              child: ImageFiltered(
-                imageFilter: ImageFilter.blur(sigmaX: shadow.blurRadius / 2, sigmaY: shadow.blurRadius / 2),
-                child: AnimatedIcon(
-                  color: shadow.color,
-                  size: widget.size,
-                  icon: AnimatedIcons.play_pause,
-                  progress: animationController,
-                ),
-              ),
-            ),
-          icon,
-        ],
+      child: AnimatedIcon(
+        color: widget.color,
+        size: widget.size,
+        icon: AnimatedIcons.play_pause,
+        progress: animationController,
       ),
     );
   }

mobile/lib/widgets/asset_viewer/formatted_duration.dart

@@ -0,0 +1,19 @@
+import 'package:flutter/material.dart';
+import 'package:immich_mobile/extensions/duration_extensions.dart';
+
+class FormattedDuration extends StatelessWidget {
+  final Duration data;
+  const FormattedDuration(this.data, {super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return SizedBox(
+      width: data.inHours > 0 ? 70 : 60, // use a fixed width to prevent jitter
+      child: Text(
+        data.format(),
+        style: const TextStyle(fontSize: 14.0, color: Colors.white, fontWeight: FontWeight.w500),
+        textAlign: TextAlign.center,
+      ),
+    );
+  }
+}

mobile/lib/widgets/asset_viewer/video_controls.dart

@@ -1,113 +1,22 @@
-import 'dart:math';
-
 import 'package:flutter/material.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:immich_mobile/constants/colors.dart';
-import 'package:immich_mobile/models/cast/cast_manager_state.dart';
-import 'package:immich_mobile/providers/asset_viewer/asset_viewer.provider.dart';
-import 'package:immich_mobile/providers/asset_viewer/video_player_provider.dart';
-import 'package:immich_mobile/providers/cast.provider.dart';
-import 'package:immich_mobile/utils/hooks/timer_hook.dart';
-import 'package:immich_mobile/extensions/duration_extensions.dart';
-import 'package:immich_mobile/widgets/asset_viewer/animated_play_pause.dart';
+import 'package:immich_mobile/extensions/build_context_extensions.dart';
+import 'package:immich_mobile/widgets/asset_viewer/video_position.dart';
 
-class VideoControls extends HookConsumerWidget {
+/// The video controls for the [videoPlayerProvider]
+class VideoControls extends ConsumerWidget {
   final String videoPlayerName;
 
-  static const List<Shadow> _controlShadows = [Shadow(color: Colors.black87, blurRadius: 6, offset: Offset(0, 1))];
-
   const VideoControls({super.key, required this.videoPlayerName});
 
-  void _toggle(WidgetRef ref, bool isCasting) {
-    if (isCasting) {
-      ref.read(castProvider.notifier).toggle();
-    } else {
-      ref.read(videoPlayerProvider(videoPlayerName).notifier).toggle();
-    }
-  }
-
-  void _onSeek(WidgetRef ref, bool isCasting, double value) {
-    final seekTo = Duration(microseconds: value.toInt());
-
-    if (isCasting) {
-      ref.read(castProvider.notifier).seekTo(seekTo);
-      return;
-    }
-
-    ref.read(videoPlayerProvider(videoPlayerName).notifier).seekTo(seekTo);
-  }
-
   @override
   Widget build(BuildContext context, WidgetRef ref) {
-    final provider = videoPlayerProvider(videoPlayerName);
-    final cast = ref.watch(castProvider);
-    final isCasting = cast.isCasting;
-
-    final (position, duration) = isCasting
-        ? ref.watch(castProvider.select((c) => (c.currentTime, c.duration)))
-        : ref.watch(provider.select((v) => (v.position, v.duration)));
-
-    final videoStatus = ref.watch(provider.select((v) => v.status));
-    final isPlaying = isCasting
-        ? cast.castState == CastState.playing
-        : videoStatus == VideoPlaybackStatus.playing || videoStatus == VideoPlaybackStatus.buffering;
-    final isFinished = !isCasting && videoStatus == VideoPlaybackStatus.completed;
-
-    final hideTimer = useTimer(const Duration(seconds: 5), () {
-      if (!context.mounted) return;
-      if (ref.read(provider).status == VideoPlaybackStatus.playing) {
-        ref.read(assetViewerProvider.notifier).setControls(false);
-      }
-    });
-
-    ref.listen(provider.select((v) => v.status), (_, __) => hideTimer.reset());
-
-    final notifier = ref.read(provider.notifier);
-    final isLoaded = duration != Duration.zero;
-
-    return Padding(
-      padding: const EdgeInsets.all(24),
-      child: Column(
-        spacing: 16,
-        children: [
-          Row(
-            children: [
-              IconButton(
-                iconSize: 32,
-                padding: const EdgeInsets.all(12),
-                constraints: const BoxConstraints(),
-                icon: isFinished
-                    ? const Icon(Icons.replay, color: Colors.white, size: 32, shadows: _controlShadows)
-                    : AnimatedPlayPause(color: Colors.white, size: 32, playing: isPlaying, shadows: _controlShadows),
-                onPressed: () => _toggle(ref, isCasting),
-              ),
-              const Spacer(),
-              Text(
-                "${position.format()} / ${duration.format()}",
-                style: const TextStyle(
-                  color: Colors.white,
-                  fontWeight: FontWeight.w500,
-                  fontFeatures: [FontFeature.tabularFigures()],
-                  shadows: _controlShadows,
-                ),
-              ),
-              const SizedBox(width: 16),
-            ],
-          ),
-          Slider(
-            value: min(position.inMicroseconds.toDouble(), duration.inMicroseconds.toDouble()),
-            min: 0,
-            max: max(duration.inMicroseconds.toDouble(), 1),
-            thumbColor: Colors.white,
-            activeColor: Colors.white,
-            inactiveColor: whiteOpacity75,
-            padding: EdgeInsets.zero,
-            onChangeStart: (_) => notifier.hold(),
-            onChangeEnd: (_) => notifier.release(),
-            onChanged: isLoaded ? (value) => _onSeek(ref, isCasting, value) : null,
-          ),
-        ],
-      ),
-    );
+    final isPortrait = context.orientation == Orientation.portrait;
+    return isPortrait
+        ? VideoPosition(videoPlayerName: videoPlayerName)
+        : Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 60.0),
+            child: VideoPosition(videoPlayerName: videoPlayerName),
+          );
   }
 }

mobile/lib/widgets/asset_viewer/video_position.dart

@@ -0,0 +1,110 @@
+import 'dart:math';
+
+import 'package:flutter/material.dart';
+import 'package:flutter_hooks/flutter_hooks.dart';
+import 'package:hooks_riverpod/hooks_riverpod.dart';
+import 'package:immich_mobile/constants/colors.dart';
+import 'package:immich_mobile/providers/asset_viewer/video_player_provider.dart';
+import 'package:immich_mobile/providers/cast.provider.dart';
+import 'package:immich_mobile/widgets/asset_viewer/formatted_duration.dart';
+
+class VideoPosition extends HookConsumerWidget {
+  final String videoPlayerName;
+
+  const VideoPosition({super.key, required this.videoPlayerName});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final isCasting = ref.watch(castProvider).isCasting;
+
+    final (position, duration) = isCasting
+        ? ref.watch(castProvider.select((c) => (c.currentTime, c.duration)))
+        : ref.watch(videoPlayerProvider(videoPlayerName).select((v) => (v.position, v.duration)));
+
+    final wasPlaying = useRef<bool>(true);
+    return duration == Duration.zero
+        ? const _VideoPositionPlaceholder()
+        : Column(
+            children: [
+              Padding(
+                // align with slider's inherent padding
+                padding: const EdgeInsets.symmetric(horizontal: 12.0),
+                child: Row(
+                  mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                  children: [FormattedDuration(position), FormattedDuration(duration)],
+                ),
+              ),
+              Row(
+                children: [
+                  Expanded(
+                    child: Slider(
+                      value: min(position.inMicroseconds / duration.inMicroseconds * 100, 100),
+                      min: 0,
+                      max: 100,
+                      thumbColor: Colors.white,
+                      activeColor: Colors.white,
+                      inactiveColor: whiteOpacity75,
+                      onChangeStart: (value) {
+                        final status = ref.read(videoPlayerProvider(videoPlayerName)).status;
+                        wasPlaying.value = status != VideoPlaybackStatus.paused;
+                        ref.read(videoPlayerProvider(videoPlayerName).notifier).pause();
+                      },
+                      onChangeEnd: (value) {
+                        if (wasPlaying.value) {
+                          ref.read(videoPlayerProvider(videoPlayerName).notifier).play();
+                        }
+                      },
+                      onChanged: (value) {
+                        final seekToDuration = (duration * (value / 100.0));
+
+                        if (isCasting) {
+                          ref.read(castProvider.notifier).seekTo(seekToDuration);
+                          return;
+                        }
+
+                        ref.read(videoPlayerProvider(videoPlayerName).notifier).seekTo(seekToDuration);
+                      },
+                    ),
+                  ),
+                ],
+              ),
+            ],
+          );
+  }
+}
+
+class _VideoPositionPlaceholder extends StatelessWidget {
+  const _VideoPositionPlaceholder();
+
+  static void _onChangedDummy(_) {}
+
+  @override
+  Widget build(BuildContext context) {
+    return const Column(
+      children: [
+        Padding(
+          padding: EdgeInsets.symmetric(horizontal: 12.0),
+          child: Row(
+            mainAxisAlignment: MainAxisAlignment.spaceBetween,
+            children: [FormattedDuration(Duration.zero), FormattedDuration(Duration.zero)],
+          ),
+        ),
+        Row(
+          children: [
+            Expanded(
+              child: Slider(
+                value: 0.0,
+                min: 0,
+                max: 100,
+                thumbColor: Colors.white,
+                activeColor: Colors.white,
+                inactiveColor: whiteOpacity75,
+                onChanged: _onChangedDummy,
+              ),
+            ),
+          ],
+        ),
+      ],
+    );
+  }
+}

mobile/lib/widgets/common/immich_image.dart

@@ -35,12 +35,7 @@ class ImmichImage extends StatelessWidget {
     }
 
     if (asset == null) {
-      return RemoteFullImageProvider(
-        assetId: assetId!,
-        thumbhash: '',
-        assetType: base_asset.AssetType.video,
-        isAnimated: false,
-      );
+      return RemoteFullImageProvider(assetId: assetId!, thumbhash: '', assetType: base_asset.AssetType.video);
     }
 
     if (useLocal(asset)) {
@@ -48,14 +43,12 @@ class ImmichImage extends StatelessWidget {
         id: asset.localId!,
         assetType: base_asset.AssetType.video,
         size: Size(width, height),
-        isAnimated: false,
       );
     } else {
       return RemoteFullImageProvider(
         assetId: asset.remoteId!,
         thumbhash: asset.thumbhash ?? '',
         assetType: base_asset.AssetType.video,
-        isAnimated: false,
       );
     }
   }

mobile/openapi/lib/model/audio_codec.dart

@@ -26,7 +26,6 @@ class AudioCodec {
   static const mp3 = AudioCodec._(r'mp3');
   static const aac = AudioCodec._(r'aac');
   static const libopus = AudioCodec._(r'libopus');
-  static const opus = AudioCodec._(r'opus');
   static const pcmS16le = AudioCodec._(r'pcm_s16le');
 
   /// List of all possible values in this [enum][AudioCodec].
@@ -34,7 +33,6 @@ class AudioCodec {
     mp3,
     aac,
     libopus,
-    opus,
     pcmS16le,
   ];
 
@@ -77,7 +75,6 @@ class AudioCodecTypeTransformer {
         case r'mp3': return AudioCodec.mp3;
         case r'aac': return AudioCodec.aac;
         case r'libopus': return AudioCodec.libopus;
-        case r'opus': return AudioCodec.opus;
         case r'pcm_s16le': return AudioCodec.pcmS16le;
         default:
           if (!allowNull) {

mobile/pigeon/network_api.dart

@@ -43,5 +43,5 @@ abstract class NetworkApi {
 
   int getClientPointer();
 
-  void setRequestHeaders(Map<String, String> headers, List<String> serverUrls, String? token);
+  void setRequestHeaders(Map<String, String> headers, List<String> serverUrls);
 }

open-api/immich-openapi-specs.json

@@ -17260,7 +17260,6 @@
           "mp3",
           "aac",
           "libopus",
-          "opus",
           "pcm_s16le"
         ],
         "type": "string"

open-api/typescript-sdk/package.json

@@ -19,7 +19,7 @@
     "@oazapfts/runtime": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^24.11.0",
+    "@types/node": "^24.10.14",
     "typescript": "^5.3.3"
   },
   "repository": {

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

@@ -7324,7 +7324,6 @@ export enum AudioCodec {
     Mp3 = "mp3",
     Aac = "aac",
     Libopus = "libopus",
-    Opus = "opus",
     PcmS16Le = "pcm_s16le"
 }
 export enum VideoContainer {

server/package.json

@@ -46,14 +46,14 @@
     "@nestjs/websockets": "^11.0.4",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-async-hooks": "^2.0.0",
-    "@opentelemetry/exporter-prometheus": "^0.213.0",
-    "@opentelemetry/instrumentation-http": "^0.213.0",
-    "@opentelemetry/instrumentation-ioredis": "^0.61.0",
-    "@opentelemetry/instrumentation-nestjs-core": "^0.59.0",
-    "@opentelemetry/instrumentation-pg": "^0.65.0",
+    "@opentelemetry/exporter-prometheus": "^0.212.0",
+    "@opentelemetry/instrumentation-http": "^0.212.0",
+    "@opentelemetry/instrumentation-ioredis": "^0.60.0",
+    "@opentelemetry/instrumentation-nestjs-core": "^0.58.0",
+    "@opentelemetry/instrumentation-pg": "^0.64.0",
     "@opentelemetry/resources": "^2.0.1",
     "@opentelemetry/sdk-metrics": "^2.0.1",
-    "@opentelemetry/sdk-node": "^0.213.0",
+    "@opentelemetry/sdk-node": "^0.212.0",
     "@opentelemetry/semantic-conventions": "^1.34.0",
     "@react-email/components": "^0.5.0",
     "@react-email/render": "^1.1.2",
@@ -66,7 +66,7 @@
     "bullmq": "^5.51.0",
     "chokidar": "^4.0.3",
     "class-transformer": "^0.5.1",
-    "class-validator": "^0.15.0",
+    "class-validator": "^0.14.0",
     "compression": "^1.8.0",
     "cookie": "^1.0.2",
     "cookie-parser": "^1.4.7",
@@ -82,7 +82,7 @@
     "jose": "^5.10.0",
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.2",
-    "kysely": "0.28.11",
+    "kysely": "0.28.2",
     "kysely-postgres-js": "^3.0.0",
     "lodash": "^4.17.21",
     "luxon": "^3.4.2",
@@ -136,7 +136,7 @@
     "@types/luxon": "^3.6.2",
     "@types/mock-fs": "^4.13.1",
     "@types/multer": "^2.0.0",
-    "@types/node": "^24.11.0",
+    "@types/node": "^24.10.14",
     "@types/nodemailer": "^7.0.0",
     "@types/picomatch": "^4.0.0",
     "@types/pngjs": "^6.0.5",

server/src/config.ts

@@ -206,7 +206,7 @@ export const defaults = Object.freeze<SystemConfig>({
     targetVideoCodec: VideoCodec.H264,
     acceptedVideoCodecs: [VideoCodec.H264],
     targetAudioCodec: AudioCodec.Aac,
-    acceptedAudioCodecs: [AudioCodec.Aac, AudioCodec.Mp3, AudioCodec.Opus],
+    acceptedAudioCodecs: [AudioCodec.Aac, AudioCodec.Mp3, AudioCodec.LibOpus],
     acceptedContainers: [VideoContainer.Mov, VideoContainer.Ogg, VideoContainer.Webm],
     targetResolution: '720',
     maxBitrate: '0',

server/src/constants.ts

@@ -2,7 +2,7 @@ import { Duration } from 'luxon';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { SemVer } from 'semver';
-import { ApiTag, AudioCodec, DatabaseExtension, ExifOrientation, VectorIndex } from 'src/enum';
+import { ApiTag, DatabaseExtension, ExifOrientation, VectorIndex } from 'src/enum';
 
 export const ErrorMessages = {
   InconsistentMediaLocation:
@@ -201,11 +201,3 @@ export const endpointTags: Record<ApiTag, string> = {
   [ApiTag.Workflows]:
     'A workflow is a set of actions that run whenever a triggering event occurs. Workflows also can include filters to further limit execution.',
 };
-
-export const AUDIO_ENCODER: Record<AudioCodec, string> = {
-  [AudioCodec.Aac]: 'aac',
-  [AudioCodec.Mp3]: 'mp3',
-  [AudioCodec.Libopus]: 'libopus',
-  [AudioCodec.Opus]: 'libopus',
-  [AudioCodec.PcmS16le]: 'pcm_s16le',
-};

server/src/database.ts

@@ -1,4 +1,4 @@
-import { Selectable, ShallowDehydrateObject } from 'kysely';
+import { Selectable } from 'kysely';
 import { MapAsset } from 'src/dtos/asset-response.dto';
 import {
   AlbumUserRole,
@@ -16,7 +16,6 @@ import {
 } from 'src/enum';
 import { AlbumTable } from 'src/schema/tables/album.table';
 import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
-import { AssetTable } from 'src/schema/tables/asset.table';
 import { PluginActionTable, PluginFilterTable, PluginTable } from 'src/schema/tables/plugin.table';
 import { WorkflowActionTable, WorkflowFilterTable, WorkflowTable } from 'src/schema/tables/workflow.table';
 import { UserMetadataItem } from 'src/types';
@@ -32,7 +31,7 @@ export type AuthUser = {
 };
 
 export type AlbumUser = {
-  user: ShallowDehydrateObject<User>;
+  user: User;
   role: AlbumUserRole;
 };
 
@@ -68,7 +67,7 @@ export type Activity = {
   updatedAt: Date;
   albumId: string;
   userId: string;
-  user: ShallowDehydrateObject<User>;
+  user: User;
   assetId: string | null;
   comment: string | null;
   isLiked: boolean;
@@ -106,7 +105,7 @@ export type Memory = {
   data: object;
   ownerId: string;
   isSaved: boolean;
-  assets: ShallowDehydrateObject<MapAsset>[];
+  assets: MapAsset[];
 };
 
 export type Asset = {
@@ -160,9 +159,9 @@ export type StorageAsset = {
 export type Stack = {
   id: string;
   primaryAssetId: string;
-  owner?: ShallowDehydrateObject<User>;
+  owner?: User;
   ownerId: string;
-  assets: ShallowDehydrateObject<MapAsset>[];
+  assets: MapAsset[];
   assetCount?: number;
 };
 
@@ -178,11 +177,11 @@ export type AuthSharedLink = {
 
 export type SharedLink = {
   id: string;
-  album?: ShallowDehydrateObject<Album> | null;
+  album?: Album | null;
   albumId: string | null;
   allowDownload: boolean;
   allowUpload: boolean;
-  assets: ShallowDehydrateObject<MapAsset>[];
+  assets: MapAsset[];
   createdAt: Date;
   description: string | null;
   expiresAt: Date | null;
@@ -195,8 +194,8 @@ export type SharedLink = {
 };
 
 export type Album = Selectable<AlbumTable> & {
-  owner: ShallowDehydrateObject<User>;
-  assets: ShallowDehydrateObject<Selectable<AssetTable>>[];
+  owner: User;
+  assets: MapAsset[];
 };
 
 export type AuthSession = {
@@ -206,9 +205,9 @@ export type AuthSession = {
 
 export type Partner = {
   sharedById: string;
-  sharedBy: ShallowDehydrateObject<User>;
+  sharedBy: User;
   sharedWithId: string;
-  sharedWith: ShallowDehydrateObject<User>;
+  sharedWith: User;
   createdAt: Date;
   createId: string;
   updatedAt: Date;
@@ -271,7 +270,7 @@ export type AssetFace = {
   imageWidth: number;
   personId: string | null;
   sourceType: SourceType;
-  person?: ShallowDehydrateObject<Person> | null;
+  person?: Person | null;
   updatedAt: Date;
   updateId: string;
   isVisible: boolean;

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

@@ -1,22 +1,18 @@
 import { mapAlbum } from 'src/dtos/album.dto';
 import { AlbumFactory } from 'test/factories/album.factory';
-import { getForAlbum } from 'test/mappers';
 
 describe('mapAlbum', () => {
   it('should set start and end dates', () => {
     const startDate = new Date('2023-02-22T05:06:29.716Z');
     const endDate = new Date('2025-01-01T01:02:03.456Z');
-    const album = AlbumFactory.from()
-      .asset({ localDateTime: endDate }, (builder) => builder.exif())
-      .asset({ localDateTime: startDate }, (builder) => builder.exif())
-      .build();
-    const dto = mapAlbum(getForAlbum(album), false);
-    expect(dto.startDate).toEqual(startDate.toISOString());
-    expect(dto.endDate).toEqual(endDate.toISOString());
+    const album = AlbumFactory.from().asset({ localDateTime: endDate }).asset({ localDateTime: startDate }).build();
+    const dto = mapAlbum(album, false);
+    expect(dto.startDate).toEqual(startDate);
+    expect(dto.endDate).toEqual(endDate);
   });
 
   it('should not set start and end dates for empty assets', () => {
-    const dto = mapAlbum(getForAlbum(AlbumFactory.create()), false);
+    const dto = mapAlbum(AlbumFactory.create(), false);
     expect(dto.startDate).toBeUndefined();
     expect(dto.endDate).toBeUndefined();
   });

server/src/dtos/album.dto.ts

@@ -1,16 +1,13 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
 import { ArrayNotEmpty, IsArray, IsString, ValidateNested } from 'class-validator';
-import { ShallowDehydrateObject } from 'kysely';
 import _ from 'lodash';
 import { AlbumUser, AuthSharedLink, User } from 'src/database';
 import { BulkIdErrorReason } from 'src/dtos/asset-ids.response.dto';
 import { AssetResponseDto, MapAsset, mapAsset } from 'src/dtos/asset-response.dto';
 import { AuthDto } from 'src/dtos/auth.dto';
-import { mapUser, UserResponseDto } from 'src/dtos/user.dto';
+import { UserResponseDto, mapUser } from 'src/dtos/user.dto';
 import { AlbumUserRole, AssetOrder } from 'src/enum';
-import { MaybeDehydrated } from 'src/types';
-import { asDateString } from 'src/utils/date';
 import { Optional, ValidateBoolean, ValidateEnum, ValidateUUID } from 'src/validation';
 
 export class AlbumInfoDto {
@@ -154,10 +151,10 @@ export class AlbumResponseDto {
   albumName!: string;
   @ApiProperty({ description: 'Album description' })
   description!: string;
-  @ApiProperty({ description: 'Creation date', format: 'date-time' })
-  createdAt!: string;
-  @ApiProperty({ description: 'Last update date', format: 'date-time' })
-  updatedAt!: string;
+  @ApiProperty({ description: 'Creation date' })
+  createdAt!: Date;
+  @ApiProperty({ description: 'Last update date' })
+  updatedAt!: Date;
   @ApiProperty({ description: 'Thumbnail asset ID' })
   albumThumbnailAssetId!: string | null;
   @ApiProperty({ description: 'Is shared album' })
@@ -175,12 +172,12 @@ export class AlbumResponseDto {
   owner!: UserResponseDto;
   @ApiProperty({ type: 'integer', description: 'Number of assets' })
   assetCount!: number;
-  @ApiPropertyOptional({ description: 'Last modified asset timestamp', format: 'date-time' })
-  lastModifiedAssetTimestamp?: string;
-  @ApiPropertyOptional({ description: 'Start date (earliest asset)', format: 'date-time' })
-  startDate?: string;
-  @ApiPropertyOptional({ description: 'End date (latest asset)', format: 'date-time' })
-  endDate?: string;
+  @ApiPropertyOptional({ description: 'Last modified asset timestamp' })
+  lastModifiedAssetTimestamp?: Date;
+  @ApiPropertyOptional({ description: 'Start date (earliest asset)' })
+  startDate?: Date;
+  @ApiPropertyOptional({ description: 'End date (latest asset)' })
+  endDate?: Date;
   @ApiProperty({ description: 'Activity feed enabled' })
   isActivityEnabled!: boolean;
   @ValidateEnum({ enum: AssetOrder, name: 'AssetOrder', description: 'Asset sort order', optional: true })
@@ -194,8 +191,8 @@ export class AlbumResponseDto {
 
 export type MapAlbumDto = {
   albumUsers?: AlbumUser[];
-  assets?: ShallowDehydrateObject<MapAsset>[];
-  sharedLinks?: ShallowDehydrateObject<AuthSharedLink>[];
+  assets?: MapAsset[];
+  sharedLinks?: AuthSharedLink[];
   albumName: string;
   description: string;
   albumThumbnailAssetId: string | null;
@@ -203,16 +200,12 @@ export type MapAlbumDto = {
   updatedAt: Date;
   id: string;
   ownerId: string;
-  owner: ShallowDehydrateObject<User>;
+  owner: User;
   isActivityEnabled: boolean;
   order: AssetOrder;
 };
 
-export const mapAlbum = (
-  entity: MaybeDehydrated<MapAlbumDto>,
-  withAssets: boolean,
-  auth?: AuthDto,
-): AlbumResponseDto => {
+export const mapAlbum = (entity: MapAlbumDto, withAssets: boolean, auth?: AuthDto): AlbumResponseDto => {
   const albumUsers: AlbumUserResponseDto[] = [];
 
   if (entity.albumUsers) {
@@ -243,16 +236,16 @@ export const mapAlbum = (
     albumName: entity.albumName,
     description: entity.description,
     albumThumbnailAssetId: entity.albumThumbnailAssetId,
-    createdAt: asDateString(entity.createdAt),
-    updatedAt: asDateString(entity.updatedAt),
+    createdAt: entity.createdAt,
+    updatedAt: entity.updatedAt,
     id: entity.id,
     ownerId: entity.ownerId,
     owner: mapUser(entity.owner),
     albumUsers: albumUsersSorted,
     shared: hasSharedUser || hasSharedLink,
     hasSharedLink,
-    startDate: asDateString(startDate),
-    endDate: asDateString(endDate),
+    startDate,
+    endDate,
     assets: (withAssets ? assets : []).map((asset) => mapAsset(asset, { auth })),
     assetCount: entity.assets?.length || 0,
     isActivityEnabled: entity.isActivityEnabled,
@@ -260,5 +253,5 @@ export const mapAlbum = (
   };
 };
 
-export const mapAlbumWithAssets = (entity: MaybeDehydrated<MapAlbumDto>) => mapAlbum(entity, true);
-export const mapAlbumWithoutAssets = (entity: MaybeDehydrated<MapAlbumDto>) => mapAlbum(entity, false);
+export const mapAlbumWithAssets = (entity: MapAlbumDto) => mapAlbum(entity, true);
+export const mapAlbumWithoutAssets = (entity: MapAlbumDto) => mapAlbum(entity, false);

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

@@ -3,7 +3,6 @@ import { AssetEditAction } from 'src/dtos/editing.dto';
 import { AssetFaceFactory } from 'test/factories/asset-face.factory';
 import { AssetFactory } from 'test/factories/asset.factory';
 import { PersonFactory } from 'test/factories/person.factory';
-import { getForAsset } from 'test/mappers';
 
 describe('mapAsset', () => {
   describe('peopleWithFaces', () => {
@@ -42,7 +41,7 @@ describe('mapAsset', () => {
         })
         .build();
 
-      const result = mapAsset(getForAsset(asset));
+      const result = mapAsset(asset);
 
       expect(result.people).toBeDefined();
       expect(result.people).toHaveLength(1);
@@ -81,7 +80,7 @@ describe('mapAsset', () => {
         .edit({ action: AssetEditAction.Crop, parameters: { x: 50, y: 50, width: 500, height: 400 } })
         .build();
 
-      const result = mapAsset(getForAsset(asset));
+      const result = mapAsset(asset);
 
       expect(result.unassignedFaces).toBeDefined();
       expect(result.unassignedFaces).toHaveLength(1);
@@ -131,7 +130,7 @@ describe('mapAsset', () => {
         .exif({ exifImageWidth: 1000, exifImageHeight: 800 })
         .build();
 
-      const result = mapAsset(getForAsset(asset));
+      const result = mapAsset(asset);
 
       expect(result.people).toBeDefined();
       expect(result.people).toHaveLength(2);
@@ -180,7 +179,7 @@ describe('mapAsset', () => {
         .exif({ exifImageWidth: 1000, exifImageHeight: 800 })
         .build();
 
-      const result = mapAsset(getForAsset(asset));
+      const result = mapAsset(asset);
 
       expect(result.people).toBeDefined();
       expect(result.people).toHaveLength(1);

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

@@ -1,5 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { Selectable, ShallowDehydrateObject } from 'kysely';
+import { Selectable } from 'kysely';
 import { AssetFace, AssetFile, Exif, Stack, Tag, User } from 'src/database';
 import { HistoryBuilder, Property } from 'src/decorators';
 import { AuthDto } from 'src/dtos/auth.dto';
@@ -14,10 +14,9 @@ import {
 import { TagResponseDto, mapTag } from 'src/dtos/tag.dto';
 import { UserResponseDto, mapUser } from 'src/dtos/user.dto';
 import { AssetStatus, AssetType, AssetVisibility } from 'src/enum';
-import { ImageDimensions, MaybeDehydrated } from 'src/types';
+import { ImageDimensions } from 'src/types';
 import { getDimensions } from 'src/utils/asset.util';
 import { hexOrBufferToBase64 } from 'src/utils/bytes';
-import { asDateString } from 'src/utils/date';
 import { mimeTypes } from 'src/utils/mime-types';
 import { ValidateEnum, ValidateUUID } from 'src/validation';
 
@@ -40,7 +39,7 @@ export class SanitizedAssetResponseDto {
       'The local date and time when the photo/video was taken, derived from EXIF metadata. This represents the photographer\'s local time regardless of timezone, stored as a timezone-agnostic timestamp. Used for timeline grouping by "local" days and months.',
     example: '2024-01-15T14:30:00.000Z',
   })
-  localDateTime!: string;
+  localDateTime!: Date;
   @ApiProperty({ description: 'Video duration (for videos)' })
   duration!: string;
   @ApiPropertyOptional({ description: 'Live photo video ID' })
@@ -60,7 +59,7 @@ export class AssetResponseDto extends SanitizedAssetResponseDto {
     description: 'The UTC timestamp when the asset was originally uploaded to Immich.',
     example: '2024-01-15T20:30:00.000Z',
   })
-  createdAt!: string;
+  createdAt!: Date;
   @ApiProperty({ description: 'Device asset ID' })
   deviceAssetId!: string;
   @ApiProperty({ description: 'Device ID' })
@@ -87,7 +86,7 @@ export class AssetResponseDto extends SanitizedAssetResponseDto {
       'The actual UTC timestamp when the file was created/captured, preserving timezone information. This is the authoritative timestamp for chronological sorting within timeline groups. Combined with timezone data, this can be used to determine the exact moment the photo was taken.',
     example: '2024-01-15T19:30:00.000Z',
   })
-  fileCreatedAt!: string;
+  fileCreatedAt!: Date;
   @ApiProperty({
     type: 'string',
     format: 'date-time',
@@ -95,7 +94,7 @@ export class AssetResponseDto extends SanitizedAssetResponseDto {
       'The UTC timestamp when the file was last modified on the filesystem. This reflects the last time the physical file was changed, which may be different from when the photo was originally taken.',
     example: '2024-01-16T10:15:00.000Z',
   })
-  fileModifiedAt!: string;
+  fileModifiedAt!: Date;
   @ApiProperty({
     type: 'string',
     format: 'date-time',
@@ -103,7 +102,7 @@ export class AssetResponseDto extends SanitizedAssetResponseDto {
       'The UTC timestamp when the asset record was last updated in the database. This is automatically maintained by the database and reflects when any field in the asset was last modified.',
     example: '2024-01-16T12:45:30.000Z',
   })
-  updatedAt!: string;
+  updatedAt!: Date;
   @ApiProperty({ description: 'Is favorite' })
   isFavorite!: boolean;
   @ApiProperty({ description: 'Is archived' })
@@ -152,13 +151,13 @@ export type MapAsset = {
   deviceId: string;
   duplicateId: string | null;
   duration: string | null;
-  edits?: ShallowDehydrateObject<AssetEditActionItem>[];
+  edits?: AssetEditActionItem[];
   encodedVideoPath: string | null;
-  exifInfo?: ShallowDehydrateObject<Selectable<Exif>> | null;
-  faces?: ShallowDehydrateObject<AssetFace>[];
+  exifInfo?: Selectable<Exif> | null;
+  faces?: AssetFace[];
   fileCreatedAt: Date;
   fileModifiedAt: Date;
-  files?: ShallowDehydrateObject<AssetFile>[];
+  files?: AssetFile[];
   isExternal: boolean;
   isFavorite: boolean;
   isOffline: boolean;
@@ -168,11 +167,11 @@ export type MapAsset = {
   localDateTime: Date;
   originalFileName: string;
   originalPath: string;
-  owner?: ShallowDehydrateObject<User> | null;
+  owner?: User | null;
   ownerId: string;
-  stack?: (ShallowDehydrateObject<Stack> & { assets: Stack['assets'] }) | null;
+  stack?: Stack | null;
   stackId: string | null;
-  tags?: ShallowDehydrateObject<Tag>[];
+  tags?: Tag[];
   thumbhash: Buffer<ArrayBufferLike> | null;
   type: AssetType;
   width: number | null;
@@ -198,7 +197,7 @@ export type AssetMapOptions = {
 };
 
 const peopleWithFaces = (
-  faces?: MaybeDehydrated<AssetFace>[],
+  faces?: AssetFace[],
   edits?: AssetEditActionItem[],
   assetDimensions?: ImageDimensions,
 ): PersonWithFacesResponseDto[] => {
@@ -214,10 +213,7 @@ const peopleWithFaces = (
     }
 
     if (!peopleFaces.has(face.person.id)) {
-      peopleFaces.set(face.person.id, {
-        ...mapPerson(face.person),
-        faces: [],
-      });
+      peopleFaces.set(face.person.id, { ...mapPerson(face.person), faces: [] });
     }
     const mappedFace = mapFacesWithoutPerson(face, edits, assetDimensions);
     peopleFaces.get(face.person.id)!.faces.push(mappedFace);
@@ -238,7 +234,7 @@ const mapStack = (entity: { stack?: Stack | null }) => {
   };
 };
 
-export function mapAsset(entity: MaybeDehydrated<MapAsset>, options: AssetMapOptions = {}): AssetResponseDto {
+export function mapAsset(entity: MapAsset, options: AssetMapOptions = {}): AssetResponseDto {
   const { stripMetadata = false, withStack = false } = options;
 
   if (stripMetadata) {
@@ -247,7 +243,7 @@ export function mapAsset(entity: MaybeDehydrated<MapAsset>, options: AssetMapOpt
       type: entity.type,
       originalMimeType: mimeTypes.lookup(entity.originalFileName),
       thumbhash: entity.thumbhash ? hexOrBufferToBase64(entity.thumbhash) : null,
-      localDateTime: asDateString(entity.localDateTime),
+      localDateTime: entity.localDateTime,
       duration: entity.duration ?? '0:00:00.00000',
       livePhotoVideoId: entity.livePhotoVideoId,
       hasMetadata: false,
@@ -261,7 +257,7 @@ export function mapAsset(entity: MaybeDehydrated<MapAsset>, options: AssetMapOpt
 
   return {
     id: entity.id,
-    createdAt: asDateString(entity.createdAt),
+    createdAt: entity.createdAt,
     deviceAssetId: entity.deviceAssetId,
     ownerId: entity.ownerId,
     owner: entity.owner ? mapUser(entity.owner) : undefined,
@@ -272,10 +268,10 @@ export function mapAsset(entity: MaybeDehydrated<MapAsset>, options: AssetMapOpt
     originalFileName: entity.originalFileName,
     originalMimeType: mimeTypes.lookup(entity.originalFileName),
     thumbhash: entity.thumbhash ? hexOrBufferToBase64(entity.thumbhash) : null,
-    fileCreatedAt: asDateString(entity.fileCreatedAt),
-    fileModifiedAt: asDateString(entity.fileModifiedAt),
-    localDateTime: asDateString(entity.localDateTime),
-    updatedAt: asDateString(entity.updatedAt),
+    fileCreatedAt: entity.fileCreatedAt,
+    fileModifiedAt: entity.fileModifiedAt,
+    localDateTime: entity.localDateTime,
+    updatedAt: entity.updatedAt,
     isFavorite: options.auth?.user.id === entity.ownerId && entity.isFavorite,
     isArchived: entity.visibility === AssetVisibility.Archive,
     isTrashed: !!entity.deletedAt,
@@ -287,7 +283,7 @@ export function mapAsset(entity: MaybeDehydrated<MapAsset>, options: AssetMapOpt
     people: peopleWithFaces(entity.faces, entity.edits, assetDimensions),
     unassignedFaces: entity.faces
       ?.filter((face) => !face.person)
-      .map((face) => mapFacesWithoutPerson(face, entity.edits, assetDimensions)),
+      .map((a) => mapFacesWithoutPerson(a, entity.edits, assetDimensions)),
     checksum: hexOrBufferToBase64(entity.checksum)!,
     stack: withStack ? mapStack(entity) : undefined,
     isOffline: entity.isOffline,

server/src/dtos/exif.dto.ts

@@ -1,7 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Exif } from 'src/database';
-import { MaybeDehydrated } from 'src/types';
-import { asDateString } from 'src/utils/date';
 
 export class ExifResponseDto {
   @ApiPropertyOptional({ description: 'Camera make' })
@@ -18,9 +16,9 @@ export class ExifResponseDto {
   @ApiPropertyOptional({ description: 'Image orientation' })
   orientation?: string | null = null;
   @ApiPropertyOptional({ description: 'Original date/time', format: 'date-time' })
-  dateTimeOriginal?: string | null = null;
+  dateTimeOriginal?: Date | null = null;
   @ApiPropertyOptional({ description: 'Modification date/time', format: 'date-time' })
-  modifyDate?: string | null = null;
+  modifyDate?: Date | null = null;
   @ApiPropertyOptional({ description: 'Time zone' })
   timeZone?: string | null = null;
   @ApiPropertyOptional({ description: 'Lens model' })
@@ -51,7 +49,7 @@ export class ExifResponseDto {
   rating?: number | null = null;
 }
 
-export function mapExif(entity: MaybeDehydrated<Exif>): ExifResponseDto {
+export function mapExif(entity: Exif): ExifResponseDto {
   return {
     make: entity.make,
     model: entity.model,
@@ -59,8 +57,8 @@ export function mapExif(entity: MaybeDehydrated<Exif>): ExifResponseDto {
     exifImageHeight: entity.exifImageHeight,
     fileSizeInByte: entity.fileSizeInByte ? Number.parseInt(entity.fileSizeInByte.toString()) : null,
     orientation: entity.orientation,
-    dateTimeOriginal: asDateString(entity.dateTimeOriginal),
-    modifyDate: asDateString(entity.modifyDate),
+    dateTimeOriginal: entity.dateTimeOriginal,
+    modifyDate: entity.modifyDate,
     timeZone: entity.timeZone,
     lensModel: entity.lensModel,
     fNumber: entity.fNumber,
@@ -82,7 +80,7 @@ export function mapSanitizedExif(entity: Exif): ExifResponseDto {
   return {
     fileSizeInByte: entity.fileSizeInByte ? Number.parseInt(entity.fileSizeInByte.toString()) : null,
     orientation: entity.orientation,
-    dateTimeOriginal: asDateString(entity.dateTimeOriginal),
+    dateTimeOriginal: entity.dateTimeOriginal,
     timeZone: entity.timeZone,
     projectionType: entity.projectionType,
     exifImageWidth: entity.exifImageWidth,

server/src/dtos/person.dto.ts

@@ -9,8 +9,8 @@ import { AuthDto } from 'src/dtos/auth.dto';
 import { AssetEditActionItem } from 'src/dtos/editing.dto';
 import { SourceType } from 'src/enum';
 import { AssetFaceTable } from 'src/schema/tables/asset-face.table';
-import { ImageDimensions, MaybeDehydrated } from 'src/types';
-import { asBirthDateString, asDateString } from 'src/utils/date';
+import { ImageDimensions } from 'src/types';
+import { asDateString } from 'src/utils/date';
 import { transformFaceBoundingBox } from 'src/utils/transform';
 import {
   IsDateStringFormat,
@@ -33,7 +33,7 @@ export class PersonCreateDto {
   @MaxDateString(() => DateTime.now(), { message: 'Birth date cannot be in the future' })
   @IsDateStringFormat('yyyy-MM-dd')
   @Optional({ nullable: true, emptyToNull: true })
-  birthDate?: string | null;
+  birthDate?: Date | null;
 
   @ValidateBoolean({ optional: true, description: 'Person visibility (hidden)' })
   isHidden?: boolean;
@@ -105,12 +105,8 @@ export class PersonResponseDto {
   thumbnailPath!: string;
   @ApiProperty({ description: 'Is hidden' })
   isHidden!: boolean;
-  @Property({
-    description: 'Last update date',
-    format: 'date-time',
-    history: new HistoryBuilder().added('v1.107.0').stable('v2'),
-  })
-  updatedAt?: string;
+  @Property({ description: 'Last update date', history: new HistoryBuilder().added('v1.107.0').stable('v2') })
+  updatedAt?: Date;
   @Property({ description: 'Is favorite', history: new HistoryBuilder().added('v1.126.0').stable('v2') })
   isFavorite?: boolean;
   @Property({ description: 'Person color (hex)', history: new HistoryBuilder().added('v1.126.0').stable('v2') })
@@ -226,21 +222,21 @@ export class PeopleResponseDto {
   hasNextPage?: boolean;
 }
 
-export function mapPerson(person: MaybeDehydrated<Person>): PersonResponseDto {
+export function mapPerson(person: Person): PersonResponseDto {
   return {
     id: person.id,
     name: person.name,
-    birthDate: asBirthDateString(person.birthDate),
+    birthDate: asDateString(person.birthDate),
     thumbnailPath: person.thumbnailPath,
     isHidden: person.isHidden,
     isFavorite: person.isFavorite,
     color: person.color ?? undefined,
-    updatedAt: asDateString(person.updatedAt),
+    updatedAt: person.updatedAt,
   };
 }
 
 export function mapFacesWithoutPerson(
-  face: MaybeDehydrated<Selectable<AssetFaceTable>>,
+  face: Selectable<AssetFaceTable>,
   edits?: AssetEditActionItem[],
   assetDimensions?: ImageDimensions,
 ): AssetFaceWithoutPersonResponseDto {

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

@@ -1,5 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { Transform, Type } from 'class-transformer';
+import { Type } from 'class-transformer';
 import {
   ArrayMinSize,
   IsInt,
@@ -92,16 +92,6 @@ export class SystemConfigFFmpegDto {
   targetAudioCodec!: AudioCodec;
 
   @ValidateEnum({ enum: AudioCodec, name: 'AudioCodec', each: true, description: 'Accepted audio codecs' })
-  @Transform(({ value }) => {
-    if (Array.isArray(value)) {
-      const libopusIndex = value.indexOf('libopus');
-      if (libopusIndex !== -1) {
-        value[libopusIndex] = 'opus';
-      }
-    }
-
-    return value;
-  })
   acceptedAudioCodecs!: AudioCodec[];
 
   @ValidateEnum({ enum: VideoContainer, name: 'VideoContainer', each: true, description: 'Accepted containers' })

server/src/dtos/tag.dto.ts

@@ -1,8 +1,6 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsHexColor, IsNotEmpty, IsString } from 'class-validator';
 import { Tag } from 'src/database';
-import { MaybeDehydrated } from 'src/types';
-import { asDateString } from 'src/utils/date';
 import { Optional, ValidateHexColor, ValidateUUID } from 'src/validation';
 
 export class TagCreateDto {
@@ -56,22 +54,22 @@ export class TagResponseDto {
   name!: string;
   @ApiProperty({ description: 'Tag value (full path)' })
   value!: string;
-  @ApiProperty({ description: 'Creation date', format: 'date-time' })
-  createdAt!: string;
-  @ApiProperty({ description: 'Last update date', format: 'date-time' })
-  updatedAt!: string;
+  @ApiProperty({ description: 'Creation date' })
+  createdAt!: Date;
+  @ApiProperty({ description: 'Last update date' })
+  updatedAt!: Date;
   @ApiPropertyOptional({ description: 'Tag color (hex)' })
   color?: string;
 }
 
-export function mapTag(entity: MaybeDehydrated<Tag>): TagResponseDto {
+export function mapTag(entity: Tag): TagResponseDto {
   return {
     id: entity.id,
     parentId: entity.parentId ?? undefined,
     name: entity.value.split('/').at(-1) as string,
     value: entity.value,
-    createdAt: asDateString(entity.createdAt),
-    updatedAt: asDateString(entity.updatedAt),
+    createdAt: entity.createdAt,
+    updatedAt: entity.updatedAt,
     color: entity.color ?? undefined,
   };
 }

server/src/dtos/user.dto.ts

@@ -3,8 +3,7 @@ import { Transform } from 'class-transformer';
 import { IsEmail, IsInt, IsNotEmpty, IsString, Min } from 'class-validator';
 import { User, UserAdmin } from 'src/database';
 import { UserAvatarColor, UserMetadataKey, UserStatus } from 'src/enum';
-import { MaybeDehydrated, UserMetadataItem } from 'src/types';
-import { asDateString } from 'src/utils/date';
+import { UserMetadataItem } from 'src/types';
 import { Optional, PinCode, ValidateBoolean, ValidateEnum, ValidateUUID, toEmail, toSanitized } from 'src/validation';
 
 export class UserUpdateMeDto {
@@ -48,8 +47,8 @@ export class UserResponseDto {
   profileImagePath!: string;
   @ValidateEnum({ enum: UserAvatarColor, name: 'UserAvatarColor', description: 'Avatar color' })
   avatarColor!: UserAvatarColor;
-  @ApiProperty({ description: 'Profile change date', format: 'date-time' })
-  profileChangedAt!: string;
+  @ApiProperty({ description: 'Profile change date' })
+  profileChangedAt!: Date;
 }
 
 export class UserLicense {
@@ -69,14 +68,14 @@ const emailToAvatarColor = (email: string): UserAvatarColor => {
   return values[randomIndex];
 };
 
-export const mapUser = (entity: MaybeDehydrated<User | UserAdmin>): UserResponseDto => {
+export const mapUser = (entity: User | UserAdmin): UserResponseDto => {
   return {
     id: entity.id,
     email: entity.email,
     name: entity.name,
     profileImagePath: entity.profileImagePath,
     avatarColor: entity.avatarColor ?? emailToAvatarColor(entity.email),
-    profileChangedAt: asDateString(entity.profileChangedAt),
+    profileChangedAt: entity.profileChangedAt,
   };
 };
 

server/src/enum.ts

@@ -409,9 +409,7 @@ export enum VideoCodec {
 export enum AudioCodec {
   Mp3 = 'mp3',
   Aac = 'aac',
-  /** @deprecated Use `Opus` instead */
-  Libopus = 'libopus',
-  Opus = 'opus',
+  LibOpus = 'libopus',
   PcmS16le = 'pcm_s16le',
 }
 

server/src/middleware/file-upload.interceptor.ts

@@ -10,7 +10,6 @@ import { UploadFieldName } from 'src/dtos/asset-media.dto';
 import { RouteKey } from 'src/enum';
 import { AuthRequest } from 'src/middleware/auth.guard';
 import { LoggingRepository } from 'src/repositories/logging.repository';
-import { StorageRepository } from 'src/repositories/storage.repository';
 import { AssetMediaService } from 'src/services/asset-media.service';
 import { ImmichFile, UploadFile, UploadFiles } from 'src/types';
 import { asUploadRequest, mapToUploadFile } from 'src/utils/asset.util';
@@ -55,7 +54,6 @@ export class FileUploadInterceptor implements NestInterceptor {
   constructor(
     private reflect: Reflector,
     private assetService: AssetMediaService,
-    private storageRepository: StorageRepository,
     private logger: LoggingRepository,
   ) {
     this.logger.setContext(FileUploadInterceptor.name);
@@ -127,18 +125,7 @@ export class FileUploadInterceptor implements NestInterceptor {
     });
 
     if (!this.isAssetUploadFile(file)) {
-      this.defaultStorage._handleFile(request, file, (error, info) => {
-        if (error) {
-          return callback(error);
-        }
-        // Multer does not sync files to disk after writing.
-        //
-        // TODO: use `flush: true` in multer when available: https://github.com/expressjs/multer/issues/1381
-        this.storageRepository
-          .datasync(info!.path!)
-          .then(() => callback(null, info!))
-          .catch((error) => callback(error));
-      });
+      this.defaultStorage._handleFile(request, file, callback);
       return;
     }
 
@@ -149,13 +136,7 @@ export class FileUploadInterceptor implements NestInterceptor {
         hash.destroy();
         callback(error);
       } else {
-        this.storageRepository
-          .datasync(info!.path!)
-          .then(() => callback(null, { ...info, checksum: hash.digest() }))
-          .catch((error) => {
-            hash.destroy();
-            callback(error);
-          });
+        callback(null, { ...info, checksum: hash.digest() });
       }
     });
   }

server/src/queries/asset.repository.sql

@@ -438,7 +438,6 @@ with
           and "stack"."primaryAssetId" != "asset"."id"
       )
     order by
-      (asset."localDateTime" AT TIME ZONE 'UTC')::date desc,
       "asset"."fileCreatedAt" desc
   ),
   "agg" as (

server/src/queries/shared.link.repository.sql

@@ -244,37 +244,3 @@ where
     or "album"."id" is not null
   )
   and "shared_link"."slug" = $2
-
--- SharedLinkRepository.getSharedLinks
-select
-  "shared_link".*,
-  coalesce(
-    json_agg("assets") filter (
-      where
-        "assets"."id" is not null
-    ),
-    '[]'
-  ) as "assets"
-from
-  "shared_link"
-  left join "shared_link_asset" on "shared_link_asset"."sharedLinkId" = "shared_link"."id"
-  left join lateral (
-    select
-      "asset".*
-    from
-      "asset"
-      inner join lateral (
-        select
-          *
-        from
-          "asset_exif"
-        where
-          "asset_exif"."assetId" = "asset"."id"
-      ) as "exifInfo" on true
-    where
-      "asset"."id" = "shared_link_asset"."assetId"
-  ) as "assets" on true
-where
-  "shared_link"."id" = $1
-group by
-  "shared_link"."id"

server/src/repositories/album.repository.ts

@@ -1,22 +1,12 @@
 import { Injectable } from '@nestjs/common';
-import {
-  ExpressionBuilder,
-  Insertable,
-  Kysely,
-  NotNull,
-  Selectable,
-  ShallowDehydrateObject,
-  sql,
-  Updateable,
-} from 'kysely';
+import { ExpressionBuilder, Insertable, Kysely, NotNull, sql, Updateable } from 'kysely';
 import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres';
 import { InjectKysely } from 'nestjs-kysely';
-import { columns } from 'src/database';
+import { columns, Exif } from 'src/database';
 import { Chunked, ChunkedArray, ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
 import { AlbumUserCreateDto } from 'src/dtos/album.dto';
 import { DB } from 'src/schema';
 import { AlbumTable } from 'src/schema/tables/album.table';
-import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
 import { withDefaultVisibility } from 'src/utils/database';
 
 export interface AlbumAssetCount {
@@ -66,9 +56,7 @@ const withAssets = (eb: ExpressionBuilder<DB, 'album'>) => {
         .selectFrom('asset')
         .selectAll('asset')
         .leftJoin('asset_exif', 'asset.id', 'asset_exif.assetId')
-        .select((eb) =>
-          eb.table('asset_exif').$castTo<ShallowDehydrateObject<Selectable<AssetExifTable>>>().as('exifInfo'),
-        )
+        .select((eb) => eb.table('asset_exif').$castTo<Exif>().as('exifInfo'))
         .innerJoin('album_asset', 'album_asset.assetId', 'asset.id')
         .whereRef('album_asset.albumId', '=', 'album.id')
         .where('asset.deletedAt', 'is', null)

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

@@ -9,6 +9,7 @@ import { DB } from 'src/schema';
 import {
   anyUuid,
   asUuid,
+  toJson,
   withDefaultVisibility,
   withEdits,
   withExif,
@@ -295,12 +296,7 @@ export class AssetJobRepository {
             .as('stack_result'),
         (join) => join.onTrue(),
       )
-      .select((eb) =>
-        eb.fn
-          .toJson(eb.table('stack_result'))
-          .$castTo<{ id: string; primaryAssetId: string; assets: { id: string }[] } | null>()
-          .as('stack'),
-      )
+      .select((eb) => toJson(eb, 'stack_result').as('stack'))
       .where('asset.id', '=', id)
       .executeTakeFirst();
   }

server/src/repositories/asset.repository.ts

@@ -6,7 +6,6 @@ import {
   NotNull,
   Selectable,
   SelectQueryBuilder,
-  ShallowDehydrateObject,
   sql,
   Updateable,
   UpdateResult,
@@ -555,11 +554,7 @@ export class AssetRepository {
                   eb
                     .selectFrom('asset as stacked')
                     .selectAll('stack')
-                    .select((eb) =>
-                      eb
-                        .fn<ShallowDehydrateObject<Selectable<AssetTable>>>('array_agg', [eb.table('stacked')])
-                        .as('assets'),
-                    )
+                    .select((eb) => eb.fn('array_agg', [eb.table('stacked')]).as('assets'))
                     .whereRef('stacked.stackId', '=', 'stack.id')
                     .whereRef('stacked.id', '!=', 'stack.primaryAssetId')
                     .where('stacked.deletedAt', 'is', null)
@@ -568,7 +563,7 @@ export class AssetRepository {
                     .as('stacked_assets'),
                 (join) => join.on('stack.id', 'is not', null),
               )
-              .select((eb) => eb.fn.toJson(eb.table('stacked_assets')).as('stack')),
+              .select((eb) => eb.fn.toJson(eb.table('stacked_assets')).$castTo<Stack | null>().as('stack')),
           ),
       )
       .$if(!!files, (qb) => qb.select(withFiles))
@@ -749,7 +744,6 @@ export class AssetRepository {
     params: [DummyValue.TIME_BUCKET, { withStacked: true }, { user: { id: DummyValue.UUID } }],
   })
   getTimeBucket(timeBucket: string, options: TimeBucketOptions, auth: AuthDto) {
-    const order = options.order ?? 'desc';
     const query = this.db
       .with('cte', (qb) =>
         qb
@@ -847,8 +841,7 @@ export class AssetRepository {
           )
           .$if(!!options.isTrashed, (qb) => qb.where('asset.status', '!=', AssetStatus.Deleted))
           .$if(!!options.tagId, (qb) => withTagId(qb, options.tagId!))
-          .orderBy(sql`(asset."localDateTime" AT TIME ZONE 'UTC')::date`, order)
-          .orderBy('asset.fileCreatedAt', order),
+          .orderBy('asset.fileCreatedAt', options.order ?? 'desc'),
       )
       .with('agg', (qb) =>
         qb

server/src/repositories/duplicate.repository.ts

@@ -1,11 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { Kysely, NotNull, Selectable, ShallowDehydrateObject, sql } from 'kysely';
+import { Kysely, NotNull, sql } from 'kysely';
 import { InjectKysely } from 'nestjs-kysely';
 import { Chunked, DummyValue, GenerateSql } from 'src/decorators';
+import { MapAsset } from 'src/dtos/asset-response.dto';
 import { AssetType, VectorIndex } from 'src/enum';
 import { probes } from 'src/repositories/database.repository';
 import { DB } from 'src/schema';
-import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
 import { anyUuid, asUuid, withDefaultVisibility } from 'src/utils/database';
 
 interface DuplicateSearch {
@@ -39,15 +39,15 @@ export class DuplicateRepository {
                 qb
                   .selectFrom('asset_exif')
                   .selectAll('asset')
-                  .select((eb) =>
-                    eb.table('asset_exif').$castTo<ShallowDehydrateObject<Selectable<AssetExifTable>>>().as('exifInfo'),
-                  )
+                  .select((eb) => eb.table('asset_exif').as('exifInfo'))
                   .whereRef('asset_exif.assetId', '=', 'asset.id')
                   .as('asset2'),
               (join) => join.onTrue(),
             )
             .select('asset.duplicateId')
-            .select((eb) => eb.fn.jsonAgg('asset2').orderBy('asset.localDateTime', 'asc').as('assets'))
+            .select((eb) =>
+              eb.fn.jsonAgg('asset2').orderBy('asset.localDateTime', 'asc').$castTo<MapAsset[]>().as('assets'),
+            )
             .where('asset.ownerId', '=', asUuid(userId))
             .where('asset.duplicateId', 'is not', null)
             .$narrowType<{ duplicateId: NotNull }>()

server/src/repositories/media.repository.spec.ts

@@ -6,7 +6,6 @@ import { SourceType } from 'src/enum';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { BoundingBox } from 'src/repositories/machine-learning.repository';
 import { MediaRepository } from 'src/repositories/media.repository';
-import { StorageRepository } from 'src/repositories/storage.repository';
 import { checkFaceVisibility, checkOcrVisibility } from 'src/utils/editor';
 import { automock } from 'test/utils';
 
@@ -66,11 +65,8 @@ describe(MediaRepository.name, () => {
   let sut: MediaRepository;
 
   beforeEach(() => {
-    sut = new MediaRepository(
-      // eslint-disable-next-line no-sparse-arrays
-      automock(LoggingRepository, { args: [, { getEnv: () => ({}) }], strict: false }),
-      automock(StorageRepository, { args: [{ setContext: () => {} }], strict: false }),
-    );
+    // eslint-disable-next-line no-sparse-arrays
+    sut = new MediaRepository(automock(LoggingRepository, { args: [, { getEnv: () => ({}) }], strict: false }));
   });
 
   describe('applyEdits (single actions)', () => {

server/src/repositories/media.repository.ts

@@ -10,7 +10,6 @@ import { Exif } from 'src/database';
 import { AssetEditActionItem } from 'src/dtos/editing.dto';
 import { Colorspace, LogLevel, RawExtractedFormat } from 'src/enum';
 import { LoggingRepository } from 'src/repositories/logging.repository';
-import { StorageRepository } from 'src/repositories/storage.repository';
 import {
   DecodeToBufferOptions,
   GenerateThumbhashOptions,
@@ -46,10 +45,7 @@ export type ExtractResult = {
 
 @Injectable()
 export class MediaRepository {
-  constructor(
-    private logger: LoggingRepository,
-    private storageRepository: StorageRepository,
-  ) {
+  constructor(private logger: LoggingRepository) {
     this.logger.setContext(MediaRepository.name);
   }
 
@@ -120,7 +116,6 @@ export class MediaRepository {
         ignoreMinorErrors: true,
         writeArgs: ['-overwrite_original'],
       });
-      await this.storageRepository.datasync(output);
       return true;
     } catch (error: any) {
       this.logger.warn(`Could not write exif data to image: ${error.message}`);
@@ -138,7 +133,6 @@ export class MediaRepository {
           writeArgs: ['-TagsFromFile', source, `-${tagGroup}:all>${tagGroup}:all`, '-overwrite_original'],
         },
       );
-      await this.storageRepository.datasync(target);
       return true;
     } catch (error: any) {
       this.logger.warn(`Could not copy tag data to image: ${error.message}`);
@@ -186,7 +180,6 @@ export class MediaRepository {
     });
 
     await decoded.toFile(output);
-    await this.storageRepository.datasync(output);
   }
 
   private async getImageDecodingPipeline(input: string | Buffer, options: DecodeToBufferOptions) {
@@ -281,18 +274,14 @@ export class MediaRepository {
     };
   }
 
-  async transcode(input: string, output: string | Writable, options: TranscodeCommand): Promise<void> {
+  transcode(input: string, output: string | Writable, options: TranscodeCommand): Promise<void> {
     if (!options.twoPass) {
-      await new Promise<void>((resolve, reject) => {
+      return new Promise((resolve, reject) => {
         this.configureFfmpegCall(input, output, options)
           .on('error', reject)
           .on('end', () => resolve())
           .run();
       });
-      if (typeof output === 'string') {
-        await this.storageRepository.datasync(output);
-      }
-      return;
     }
 
     if (typeof output !== 'string') {
@@ -301,7 +290,7 @@ export class MediaRepository {
 
     // two-pass allows for precise control of bitrate at the cost of running twice
     // recommended for vp9 for better quality and compression
-    await new Promise<void>((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       // first pass output is not saved as only the .log file is needed
       this.configureFfmpegCall(input, '/dev/null', options)
         .addOptions('-pass', '1')
@@ -321,7 +310,6 @@ export class MediaRepository {
         })
         .run();
     });
-    await this.storageRepository.datasync(output);
   }
 
   async getImageMetadata(input: string | Buffer): Promise<ImageDimensions & { isTransparent: boolean }> {

server/src/repositories/metadata.repository.ts

@@ -2,7 +2,6 @@ import { Injectable } from '@nestjs/common';
 import { BinaryField, DefaultReadTaskOptions, ExifTool, Tags } from 'exiftool-vendored';
 import geotz from 'geo-tz';
 import { LoggingRepository } from 'src/repositories/logging.repository';
-import { StorageRepository } from 'src/repositories/storage.repository';
 import { mimeTypes } from 'src/utils/mime-types';
 
 interface ExifDuration {
@@ -73,8 +72,6 @@ export interface ImmichTags extends Omit<Tags, TagsWithWrongTypes> {
 
   AndroidMake?: string;
   AndroidModel?: string;
-  DeviceManufacturer?: string;
-  DeviceModelName?: string;
 }
 
 @Injectable()
@@ -95,10 +92,7 @@ export class MetadataRepository {
     taskTimeoutMillis: 2 * 60 * 1000,
   });
 
-  constructor(
-    private logger: LoggingRepository,
-    private storageRepository: StorageRepository,
-  ) {
+  constructor(private logger: LoggingRepository) {
     this.logger.setContext(MetadataRepository.name);
   }
 
@@ -125,7 +119,6 @@ export class MetadataRepository {
   async writeTags(path: string, tags: Partial<Tags>): Promise<void> {
     try {
       await this.exiftool.write(path, tags);
-      await this.storageRepository.datasync(path);
     } catch (error) {
       this.logger.warn(`Error writing exif data (${path}): ${error}`);
     }

server/src/repositories/search.repository.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@nestjs/common';
-import { Kysely, OrderByDirection, Selectable, ShallowDehydrateObject, sql } from 'kysely';
+import { Kysely, OrderByDirection, Selectable, sql } from 'kysely';
 import { InjectKysely } from 'nestjs-kysely';
 import { randomUUID } from 'node:crypto';
 import { DummyValue, GenerateSql } from 'src/decorators';
@@ -433,7 +433,7 @@ export class SearchRepository {
       .select((eb) =>
         eb
           .fn('to_jsonb', [eb.table('asset_exif')])
-          .$castTo<ShallowDehydrateObject<Selectable<AssetExifTable>>>()
+          .$castTo<Selectable<AssetExifTable>>()
           .as('exifInfo'),
       )
       .orderBy('asset_exif.city')

server/src/repositories/shared-link.repository.ts

@@ -1,14 +1,13 @@
 import { Injectable } from '@nestjs/common';
-import { Insertable, Kysely, Selectable, ShallowDehydrateObject, sql, Updateable } from 'kysely';
+import { Insertable, Kysely, sql, Updateable } from 'kysely';
 import { jsonArrayFrom, jsonObjectFrom } from 'kysely/helpers/postgres';
 import _ from 'lodash';
 import { InjectKysely } from 'nestjs-kysely';
 import { Album, columns } from 'src/database';
 import { DummyValue, GenerateSql } from 'src/decorators';
+import { MapAsset } from 'src/dtos/asset-response.dto';
 import { SharedLinkType } from 'src/enum';
 import { DB } from 'src/schema';
-import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
-import { AssetTable } from 'src/schema/tables/asset.table';
 import { SharedLinkTable } from 'src/schema/tables/shared-link.table';
 
 export type SharedLinkSearchOptions = {
@@ -107,15 +106,11 @@ export class SharedLinkRepository {
       .select((eb) =>
         eb.fn
           .coalesce(eb.fn.jsonAgg('a').filterWhere('a.id', 'is not', null), sql`'[]'`)
-          .$castTo<
-            (ShallowDehydrateObject<Selectable<AssetTable>> & {
-              exifInfo: ShallowDehydrateObject<Selectable<AssetExifTable>>;
-            })[]
-          >()
+          .$castTo<MapAsset[]>()
           .as('assets'),
       )
       .groupBy(['shared_link.id', sql`"album".*`])
-      .select((eb) => eb.fn.toJson(eb.table('album')).$castTo<ShallowDehydrateObject<Album> | null>().as('album'))
+      .select((eb) => eb.fn.toJson('album').$castTo<Album | null>().as('album'))
       .where('shared_link.id', '=', id)
       .where('shared_link.userId', '=', userId)
       .where((eb) => eb.or([eb('shared_link.type', '=', SharedLinkType.Individual), eb('album.id', 'is not', null)]))
@@ -139,7 +134,9 @@ export class SharedLinkRepository {
             .selectAll('asset')
             .orderBy('asset.fileCreatedAt', 'asc')
             .limit(1),
-        ).as('assets'),
+        )
+          .$castTo<MapAsset[]>()
+          .as('assets'),
       )
       .leftJoinLateral(
         (eb) =>
@@ -178,7 +175,7 @@ export class SharedLinkRepository {
             .as('album'),
         (join) => join.onTrue(),
       )
-      .select((eb) => eb.fn.toJson('album').$castTo<ShallowDehydrateObject<Album> | null>().as('album'))
+      .select((eb) => eb.fn.toJson('album').$castTo<Album | null>().as('album'))
       .where((eb) => eb.or([eb('shared_link.type', '=', SharedLinkType.Individual), eb('album.id', 'is not', null)]))
       .$if(!!albumId, (eb) => eb.where('shared_link.albumId', '=', albumId!))
       .$if(!!id, (eb) => eb.where('shared_link.id', '=', id!))
@@ -249,7 +246,6 @@ export class SharedLinkRepository {
     await this.db.deleteFrom('shared_link').where('shared_link.id', '=', id).execute();
   }
 
-  @GenerateSql({ params: [DummyValue.UUID] })
   private getSharedLinks(id: string) {
     return this.db
       .selectFrom('shared_link')
@@ -273,11 +269,7 @@ export class SharedLinkRepository {
       .select((eb) =>
         eb.fn
           .coalesce(eb.fn.jsonAgg('assets').filterWhere('assets.id', 'is not', null), sql`'[]'`)
-          .$castTo<
-            (ShallowDehydrateObject<Selectable<AssetTable>> & {
-              exifInfo: ShallowDehydrateObject<Selectable<AssetExifTable>>;
-            })[]
-          >()
+          .$castTo<MapAsset[]>()
           .as('assets'),
       )
       .groupBy('shared_link.id')

server/src/repositories/storage.repository.ts

@@ -50,18 +50,8 @@ export class StorageRepository {
     return fs.readdir(folder);
   }
 
-  async copyFile(source: string, target: string) {
-    await fs.copyFile(source, target);
-    await this.datasync(target);
-  }
-
-  async datasync(filepath: string) {
-    const handle = await fs.open(filepath, 'r');
-    try {
-      await handle.datasync();
-    } finally {
-      await handle.close();
-    }
+  copyFile(source: string, target: string) {
+    return fs.copyFile(source, target);
   }
 
   stat(filepath: string) {
@@ -69,19 +59,19 @@ export class StorageRepository {
   }
 
   createFile(filepath: string, buffer: Buffer) {
-    return fs.writeFile(filepath, buffer, { flag: 'wx', flush: true });
+    return fs.writeFile(filepath, buffer, { flag: 'wx' });
   }
 
   createWriteStream(filepath: string): Writable {
-    return createWriteStream(filepath, { flags: 'w', flush: true });
+    return createWriteStream(filepath, { flags: 'w' });
   }
 
   createOrOverwriteFile(filepath: string, buffer: Buffer) {
-    return fs.writeFile(filepath, buffer, { flag: 'w', flush: true });
+    return fs.writeFile(filepath, buffer, { flag: 'w' });
   }
 
   overwriteFile(filepath: string, buffer: Buffer) {
-    return fs.writeFile(filepath, buffer, { flag: 'r+', flush: true });
+    return fs.writeFile(filepath, buffer, { flag: 'r+' });
   }
 
   rename(source: string, target: string) {

server/src/schema/migrations/1772609167000-UpdateOpusCodecName.ts

@@ -1,65 +0,0 @@
-import { Kysely, sql } from 'kysely';
-
-export async function up(db: Kysely<any>): Promise<void> {
-  await sql`
-    UPDATE system_metadata
-    SET value = jsonb_set(
-      value,
-      '{ffmpeg,acceptedAudioCodecs}',
-      (
-        SELECT jsonb_agg(
-          CASE
-            WHEN elem = 'libopus' THEN 'opus'
-            ELSE elem
-          END
-        )
-        FROM jsonb_array_elements_text(value->'ffmpeg'->'acceptedAudioCodecs') elem
-      )
-    )
-    WHERE key = 'system-config'
-    AND value->'ffmpeg'->'acceptedAudioCodecs' ? 'libopus';
-  `.execute(db);
-
-  await sql`
-    UPDATE system_metadata
-    SET value = jsonb_set(
-      value,
-      '{ffmpeg,targetAudioCodec}',
-      '"opus"'::jsonb
-    )
-    WHERE key = 'system-config'
-    AND value->'ffmpeg'->>'targetAudioCodec' = 'libopus';
-  `.execute(db);
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  await sql`
-    UPDATE system_metadata
-    SET value = jsonb_set(
-      value,
-      '{ffmpeg,acceptedAudioCodecs}',
-      (
-        SELECT jsonb_agg(
-          CASE
-            WHEN elem = 'opus' THEN 'libopus'
-            ELSE elem
-          END
-        )
-        FROM jsonb_array_elements_text(value->'ffmpeg'->'acceptedAudioCodecs') elem
-      )
-    )
-    WHERE key = 'system-config'
-    AND value->'ffmpeg'->'acceptedAudioCodecs' ? 'opus';
-  `.execute(db);
-
-  await sql`
-    UPDATE system_metadata
-    SET value = jsonb_set(
-      value,
-      '{ffmpeg,targetAudioCodec}',
-      '"libopus"'::jsonb
-    )
-    WHERE key = 'system-config'
-    AND value->'ffmpeg'->>'targetAudioCodec' = 'opus';
-  `.execute(db);
-}

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

@@ -1,7 +1,6 @@
 import { BadRequestException } from '@nestjs/common';
 import { ReactionType } from 'src/dtos/activity.dto';
 import { ActivityService } from 'src/services/activity.service';
-import { getForActivity } from 'test/mappers';
 import { factory, newUuid, newUuids } from 'test/small.factory';
 import { newTestService, ServiceMocks } from 'test/utils';
 
@@ -79,7 +78,7 @@ describe(ActivityService.name, () => {
       const activity = factory.activity({ albumId, assetId, userId });
 
       mocks.access.activity.checkCreateAccess.mockResolvedValue(new Set([albumId]));
-      mocks.activity.create.mockResolvedValue(getForActivity(activity));
+      mocks.activity.create.mockResolvedValue(activity);
 
       await sut.create(factory.auth({ user: { id: userId } }), {
         albumId,
@@ -102,7 +101,7 @@ describe(ActivityService.name, () => {
       const activity = factory.activity({ albumId, assetId });
 
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([albumId]));
-      mocks.activity.create.mockResolvedValue(getForActivity(activity));
+      mocks.activity.create.mockResolvedValue(activity);
 
       await expect(
         sut.create(factory.auth(), { albumId, assetId, type: ReactionType.COMMENT, comment: 'comment' }),
@@ -114,7 +113,7 @@ describe(ActivityService.name, () => {
       const activity = factory.activity({ userId, albumId, assetId, isLiked: true });
 
       mocks.access.activity.checkCreateAccess.mockResolvedValue(new Set([albumId]));
-      mocks.activity.create.mockResolvedValue(getForActivity(activity));
+      mocks.activity.create.mockResolvedValue(activity);
       mocks.activity.search.mockResolvedValue([]);
 
       await sut.create(factory.auth({ user: { id: userId } }), { albumId, assetId, type: ReactionType.LIKE });
@@ -128,7 +127,7 @@ describe(ActivityService.name, () => {
 
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([albumId]));
       mocks.access.activity.checkCreateAccess.mockResolvedValue(new Set([albumId]));
-      mocks.activity.search.mockResolvedValue([getForActivity(activity)]);
+      mocks.activity.search.mockResolvedValue([activity]);
 
       await sut.create(factory.auth(), { albumId, assetId, type: ReactionType.LIKE });
 

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

@@ -1,4 +1,5 @@
 import { BadRequestException } from '@nestjs/common';
+import _ from 'lodash';
 import { BulkIdErrorReason } from 'src/dtos/asset-ids.response.dto';
 import { AlbumUserRole, AssetOrder, UserMetadataKey } from 'src/enum';
 import { AlbumService } from 'src/services/album.service';
@@ -8,7 +9,6 @@ import { AssetFactory } from 'test/factories/asset.factory';
 import { AuthFactory } from 'test/factories/auth.factory';
 import { UserFactory } from 'test/factories/user.factory';
 import { authStub } from 'test/fixtures/auth.stub';
-import { getForAlbum } from 'test/mappers';
 import { newUuid } from 'test/small.factory';
 import { newTestService, ServiceMocks } from 'test/utils';
 
@@ -45,7 +45,7 @@ describe(AlbumService.name, () => {
     it('gets list of albums for auth user', async () => {
       const album = AlbumFactory.from().albumUser().build();
       const sharedWithUserAlbum = AlbumFactory.from().owner(album.owner).albumUser().build();
-      mocks.album.getOwned.mockResolvedValue([getForAlbum(album), getForAlbum(sharedWithUserAlbum)]);
+      mocks.album.getOwned.mockResolvedValue([album, sharedWithUserAlbum]);
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
           albumId: album.id,
@@ -70,13 +70,8 @@ describe(AlbumService.name, () => {
     });
 
     it('gets list of albums that have a specific asset', async () => {
-      const album = AlbumFactory.from()
-        .owner({ isAdmin: true })
-        .albumUser()
-        .asset({}, (builder) => builder.exif())
-        .asset({}, (builder) => builder.exif())
-        .build();
-      mocks.album.getByAssetId.mockResolvedValue([getForAlbum(album)]);
+      const album = AlbumFactory.from().owner({ isAdmin: true }).albumUser().asset().asset().build();
+      mocks.album.getByAssetId.mockResolvedValue([album]);
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
           albumId: album.id,
@@ -95,7 +90,7 @@ describe(AlbumService.name, () => {
 
     it('gets list of albums that are shared', async () => {
       const album = AlbumFactory.from().albumUser().build();
-      mocks.album.getShared.mockResolvedValue([getForAlbum(album)]);
+      mocks.album.getShared.mockResolvedValue([album]);
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
           albumId: album.id,
@@ -114,7 +109,7 @@ describe(AlbumService.name, () => {
 
     it('gets list of albums that are NOT shared', async () => {
       const album = AlbumFactory.create();
-      mocks.album.getNotShared.mockResolvedValue([getForAlbum(album)]);
+      mocks.album.getNotShared.mockResolvedValue([album]);
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
           albumId: album.id,
@@ -134,7 +129,7 @@ describe(AlbumService.name, () => {
 
   it('counts assets correctly', async () => {
     const album = AlbumFactory.create();
-    mocks.album.getOwned.mockResolvedValue([getForAlbum(album)]);
+    mocks.album.getOwned.mockResolvedValue([album]);
     mocks.album.getMetadataForIds.mockResolvedValue([
       {
         albumId: album.id,
@@ -160,7 +155,7 @@ describe(AlbumService.name, () => {
         .albumUser(albumUser)
         .build();
 
-      mocks.album.create.mockResolvedValue(getForAlbum(album));
+      mocks.album.create.mockResolvedValue(album);
       mocks.user.get.mockResolvedValue(UserFactory.create(album.albumUsers[0].user));
       mocks.user.getMetadata.mockResolvedValue([]);
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([assetId]));
@@ -197,7 +192,7 @@ describe(AlbumService.name, () => {
         .asset({ id: assetId }, (asset) => asset.exif())
         .albumUser(albumUser)
         .build();
-      mocks.album.create.mockResolvedValue(getForAlbum(album));
+      mocks.album.create.mockResolvedValue(album);
       mocks.user.get.mockResolvedValue(album.albumUsers[0].user);
       mocks.user.getMetadata.mockResolvedValue([
         {
@@ -255,7 +250,7 @@ describe(AlbumService.name, () => {
         .albumUser()
         .build();
       mocks.user.get.mockResolvedValue(album.albumUsers[0].user);
-      mocks.album.create.mockResolvedValue(getForAlbum(album));
+      mocks.album.create.mockResolvedValue(album);
       mocks.user.getMetadata.mockResolvedValue([]);
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([assetId]));
 
@@ -321,7 +316,7 @@ describe(AlbumService.name, () => {
     it('should require a valid thumbnail asset id', async () => {
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValue(new Set());
 
       await expect(
@@ -335,8 +330,8 @@ describe(AlbumService.name, () => {
     it('should allow the owner to update the album', 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(album);
+      mocks.album.update.mockResolvedValue(album);
 
       await sut.update(AuthFactory.create(album.owner), album.id, { albumName: 'new album name' });
 
@@ -357,7 +352,7 @@ describe(AlbumService.name, () => {
 
     it('should not let a shared user delete the album', async () => {
       const album = AlbumFactory.create();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set());
 
       await expect(sut.delete(AuthFactory.create(album.owner), album.id)).rejects.toBeInstanceOf(BadRequestException);
@@ -368,7 +363,7 @@ describe(AlbumService.name, () => {
     it('should let the owner delete an album', async () => {
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await sut.delete(AuthFactory.create(album.owner), album.id);
 
@@ -392,7 +387,7 @@ describe(AlbumService.name, () => {
       const userId = newUuid();
       const album = AlbumFactory.from().albumUser({ userId }).build();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       await expect(
         sut.addUsers(AuthFactory.create(album.owner), album.id, { albumUsers: [{ userId }] }),
       ).rejects.toBeInstanceOf(BadRequestException);
@@ -403,7 +398,7 @@ describe(AlbumService.name, () => {
     it('should throw an error if the userId does not exist', async () => {
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.user.get.mockResolvedValue(void 0);
       await expect(
         sut.addUsers(AuthFactory.create(album.owner), album.id, { albumUsers: [{ userId: 'unknown-user' }] }),
@@ -415,7 +410,7 @@ describe(AlbumService.name, () => {
     it('should throw an error if the userId is the ownerId', async () => {
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       await expect(
         sut.addUsers(AuthFactory.create(album.owner), album.id, {
           albumUsers: [{ userId: album.owner.id }],
@@ -429,8 +424,8 @@ describe(AlbumService.name, () => {
       const album = AlbumFactory.create();
       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(album);
+      mocks.album.update.mockResolvedValue(album);
       mocks.user.get.mockResolvedValue(user);
       mocks.albumUser.create.mockResolvedValue(AlbumUserFactory.from().album(album).user(user).build());
 
@@ -461,7 +456,7 @@ describe(AlbumService.name, () => {
       const userId = newUuid();
       const album = AlbumFactory.from().albumUser({ userId }).build();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.albumUser.delete.mockResolvedValue();
 
       await expect(sut.removeUser(AuthFactory.create(album.owner), album.id, userId)).resolves.toBeUndefined();
@@ -475,7 +470,7 @@ describe(AlbumService.name, () => {
       const user1 = UserFactory.create();
       const user2 = UserFactory.create();
       const album = AlbumFactory.from().albumUser({ userId: user1.id }).albumUser({ userId: user2.id }).build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await expect(sut.removeUser(AuthFactory.create(user1), album.id, user2.id)).rejects.toBeInstanceOf(
         BadRequestException,
@@ -488,7 +483,7 @@ describe(AlbumService.name, () => {
     it('should allow a shared user to remove themselves', async () => {
       const user1 = UserFactory.create();
       const album = AlbumFactory.from().albumUser({ userId: user1.id }).build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.albumUser.delete.mockResolvedValue();
 
       await sut.removeUser(AuthFactory.create(user1), album.id, user1.id);
@@ -500,7 +495,7 @@ describe(AlbumService.name, () => {
     it('should allow a shared user to remove themselves using "me"', async () => {
       const user = UserFactory.create();
       const album = AlbumFactory.from().albumUser({ userId: user.id }).build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.albumUser.delete.mockResolvedValue();
 
       await sut.removeUser(AuthFactory.create(user), album.id, 'me');
@@ -511,7 +506,7 @@ describe(AlbumService.name, () => {
 
     it('should not allow the owner to be removed', async () => {
       const album = AlbumFactory.from().albumUser().build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await expect(sut.removeUser(AuthFactory.create(album.owner), album.id, album.owner.id)).rejects.toBeInstanceOf(
         BadRequestException,
@@ -522,7 +517,7 @@ describe(AlbumService.name, () => {
 
     it('should throw an error for a user not in the album', async () => {
       const album = AlbumFactory.from().albumUser().build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await expect(sut.removeUser(AuthFactory.create(album.owner), album.id, 'user-3')).rejects.toBeInstanceOf(
         BadRequestException,
@@ -551,7 +546,7 @@ describe(AlbumService.name, () => {
   describe('getAlbumInfo', () => {
     it('should get a shared album', async () => {
       const album = AlbumFactory.from().albumUser().build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
@@ -571,7 +566,7 @@ describe(AlbumService.name, () => {
 
     it('should get a shared album via a shared link', async () => {
       const album = AlbumFactory.from().albumUser().build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.access.album.checkSharedLinkAccess.mockResolvedValue(new Set([album.id]));
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
@@ -593,7 +588,7 @@ describe(AlbumService.name, () => {
     it('should get a shared album via shared with user', async () => {
       const user = UserFactory.create();
       const album = AlbumFactory.from().albumUser({ userId: user.id }).build();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.access.album.checkSharedAlbumAccess.mockResolvedValue(new Set([album.id]));
       mocks.album.getMetadataForIds.mockResolvedValue([
         {
@@ -635,7 +630,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set());
 
       await expect(
@@ -659,7 +654,7 @@ describe(AlbumService.name, () => {
       const album = AlbumFactory.from({ albumThumbnailAssetId: asset1.id }).build();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset2.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set());
 
       await expect(sut.addAssets(AuthFactory.create(album.owner), album.id, { ids: [asset2.id] })).resolves.toEqual([
@@ -680,7 +675,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkSharedAlbumAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set());
 
       await expect(
@@ -708,7 +703,7 @@ describe(AlbumService.name, () => {
       const album = AlbumFactory.from().albumUser({ userId: user.id, role: AlbumUserRole.Viewer }).build();
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkSharedAlbumAccess.mockResolvedValue(new Set());
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await expect(
         sut.addAssets(AuthFactory.create(user), album.id, { ids: [asset1.id, asset2.id, asset3.id] }),
@@ -723,7 +718,7 @@ describe(AlbumService.name, () => {
       const auth = AuthFactory.from(album.owner).sharedLink({ allowUpload: true, userId: album.ownerId }).build();
       mocks.access.album.checkSharedLinkAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set());
 
       await expect(sut.addAssets(auth, album.id, { ids: [asset1.id, asset2.id, asset3.id] })).resolves.toEqual([
@@ -747,7 +742,7 @@ describe(AlbumService.name, () => {
       const asset = AssetFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkPartnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set());
 
       await expect(sut.addAssets(AuthFactory.create(album.owner), album.id, { ids: [asset.id] })).resolves.toEqual([
@@ -767,7 +762,7 @@ describe(AlbumService.name, () => {
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set([asset.id]));
 
       await expect(sut.addAssets(AuthFactory.create(album.owner), album.id, { ids: [asset.id] })).resolves.toEqual([
@@ -781,7 +776,7 @@ describe(AlbumService.name, () => {
       const asset = AssetFactory.create();
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set());
 
       await expect(sut.addAssets(AuthFactory.create(album.owner), album.id, { ids: [asset.id] })).resolves.toEqual([
@@ -796,7 +791,7 @@ describe(AlbumService.name, () => {
       const user = UserFactory.create();
       const album = AlbumFactory.create();
       const asset = AssetFactory.create({ ownerId: user.id });
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await expect(sut.addAssets(AuthFactory.create(user), album.id, { ids: [asset.id] })).rejects.toBeInstanceOf(
         BadRequestException,
@@ -809,7 +804,7 @@ describe(AlbumService.name, () => {
     it('should not allow unauthorized shared link access to the album', async () => {
       const album = AlbumFactory.create();
       const asset = AssetFactory.create();
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
 
       await expect(
         sut.addAssets(AuthFactory.from().sharedLink({ allowUpload: true }).build(), album.id, { ids: [asset.id] }),
@@ -826,7 +821,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkOwnerAccess.mockResolvedValueOnce(new Set([album1.id, album2.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       await expect(
@@ -864,7 +859,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkOwnerAccess.mockResolvedValueOnce(new Set([album1.id, album2.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       await expect(
@@ -902,7 +897,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkSharedAlbumAccess.mockResolvedValueOnce(new Set([album1.id, album2.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       await expect(
@@ -948,7 +943,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkSharedAlbumAccess.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       await expect(
@@ -970,7 +965,7 @@ describe(AlbumService.name, () => {
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
       mocks.access.album.checkSharedLinkAccess.mockResolvedValueOnce(new Set([album1.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       const auth = AuthFactory.from(album1.owner).sharedLink({ allowUpload: true }).build();
@@ -1009,7 +1004,7 @@ describe(AlbumService.name, () => {
       ];
       mocks.access.album.checkOwnerAccess.mockResolvedValueOnce(new Set([album1.id, album2.id]));
       mocks.access.asset.checkPartnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       await expect(
@@ -1053,7 +1048,7 @@ describe(AlbumService.name, () => {
       mocks.album.getAssetIds
         .mockResolvedValueOnce(new Set([asset1.id, asset2.id, asset3.id]))
         .mockResolvedValueOnce(new Set());
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
 
       await expect(
         sut.addAssetsToAlbums(AuthFactory.create(album1.owner), {
@@ -1083,7 +1078,7 @@ describe(AlbumService.name, () => {
         .mockResolvedValueOnce(new Set([album1.id]))
         .mockResolvedValueOnce(new Set([album2.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
       mocks.album.getAssetIds.mockResolvedValue(new Set([asset1.id, asset2.id, asset3.id]));
 
       await expect(
@@ -1112,7 +1107,7 @@ describe(AlbumService.name, () => {
       mocks.access.album.checkSharedAlbumAccess
         .mockResolvedValueOnce(new Set([album1.id]))
         .mockResolvedValueOnce(new Set([album2.id]));
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(_.cloneDeep(album1)).mockResolvedValueOnce(_.cloneDeep(album2));
       mocks.album.getAssetIds.mockResolvedValueOnce(new Set()).mockResolvedValueOnce(new Set());
 
       await expect(
@@ -1143,7 +1138,7 @@ describe(AlbumService.name, () => {
       const album1 = AlbumFactory.create();
       const album2 = AlbumFactory.create();
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
 
       await expect(
         sut.addAssetsToAlbums(AuthFactory.create(user), {
@@ -1165,7 +1160,7 @@ describe(AlbumService.name, () => {
       const album1 = AlbumFactory.create();
       const album2 = AlbumFactory.create();
       const [asset1, asset2, asset3] = [AssetFactory.create(), AssetFactory.create(), AssetFactory.create()];
-      mocks.album.getById.mockResolvedValueOnce(getForAlbum(album1)).mockResolvedValueOnce(getForAlbum(album2));
+      mocks.album.getById.mockResolvedValueOnce(album1).mockResolvedValueOnce(album2);
 
       await expect(
         sut.addAssetsToAlbums(AuthFactory.from().sharedLink({ allowUpload: true }).build(), {
@@ -1187,7 +1182,7 @@ describe(AlbumService.name, () => {
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValue(new Set([asset.id]));
 
       await expect(sut.removeAssets(AuthFactory.create(album.owner), album.id, { ids: [asset.id] })).resolves.toEqual([
@@ -1201,7 +1196,7 @@ describe(AlbumService.name, () => {
       const asset = AssetFactory.create();
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValue(new Set());
 
       await expect(sut.removeAssets(AuthFactory.create(album.owner), album.id, { ids: [asset.id] })).resolves.toEqual([
@@ -1215,7 +1210,7 @@ describe(AlbumService.name, () => {
       const asset = AssetFactory.create();
       const album = AlbumFactory.create();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValue(new Set([asset.id]));
 
       await expect(sut.removeAssets(AuthFactory.create(album.owner), album.id, { ids: [asset.id] })).resolves.toEqual([
@@ -1229,7 +1224,7 @@ describe(AlbumService.name, () => {
       const album = AlbumFactory.from({ albumThumbnailAssetId: asset1.id }).build();
       mocks.access.album.checkOwnerAccess.mockResolvedValue(new Set([album.id]));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset1.id]));
-      mocks.album.getById.mockResolvedValue(getForAlbum(album));
+      mocks.album.getById.mockResolvedValue(album);
       mocks.album.getAssetIds.mockResolvedValue(new Set([asset1.id, asset2.id]));
 
       await expect(sut.removeAssets(AuthFactory.create(album.owner), album.id, { ids: [asset1.id] })).resolves.toEqual([

server/src/services/album.service.ts

@@ -21,7 +21,6 @@ import { Permission } from 'src/enum';
 import { AlbumAssetCount, AlbumInfoOptions } from 'src/repositories/album.repository';
 import { BaseService } from 'src/services/base.service';
 import { addAssets, removeAssets } from 'src/utils/asset.util';
-import { asDateString } from 'src/utils/date';
 import { getPreferences } from 'src/utils/preferences';
 
 @Injectable()
@@ -65,11 +64,11 @@ export class AlbumService extends BaseService {
     return albums.map((album) => ({
       ...mapAlbumWithoutAssets(album),
       sharedLinks: undefined,
-      startDate: asDateString(albumMetadata[album.id]?.startDate ?? undefined),
-      endDate: asDateString(albumMetadata[album.id]?.endDate ?? undefined),
+      startDate: albumMetadata[album.id]?.startDate ?? undefined,
+      endDate: albumMetadata[album.id]?.endDate ?? undefined,
       assetCount: albumMetadata[album.id]?.assetCount ?? 0,
       // lastModifiedAssetTimestamp is only used in mobile app, please remove if not need
-      lastModifiedAssetTimestamp: asDateString(albumMetadata[album.id]?.lastModifiedAssetTimestamp ?? undefined),
+      lastModifiedAssetTimestamp: albumMetadata[album.id]?.lastModifiedAssetTimestamp ?? undefined,
     }));
   }
 
@@ -86,10 +85,10 @@ export class AlbumService extends BaseService {
 
     return {
       ...mapAlbum(album, withAssets, auth),
-      startDate: asDateString(albumMetadataForIds?.startDate ?? undefined),
-      endDate: asDateString(albumMetadataForIds?.endDate ?? undefined),
+      startDate: albumMetadataForIds?.startDate ?? undefined,
+      endDate: albumMetadataForIds?.endDate ?? undefined,
       assetCount: albumMetadataForIds?.assetCount ?? 0,
-      lastModifiedAssetTimestamp: asDateString(albumMetadataForIds?.lastModifiedAssetTimestamp ?? undefined),
+      lastModifiedAssetTimestamp: albumMetadataForIds?.lastModifiedAssetTimestamp ?? undefined,
       contributorCounts: isShared ? await this.albumRepository.getContributorCounts(album.id) : undefined,
     };
   }

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

@@ -4,12 +4,13 @@ import {
   NotFoundException,
   UnauthorizedException,
 } from '@nestjs/common';
+import { Stats } from 'node:fs';
 import { AssetFile } from 'src/database';
 import { AssetMediaStatus, AssetRejectReason, AssetUploadAction } from 'src/dtos/asset-media-response.dto';
-import { AssetMediaCreateDto, AssetMediaSize, UploadFieldName } from 'src/dtos/asset-media.dto';
+import { AssetMediaCreateDto, AssetMediaReplaceDto, 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, AssetType, AssetVisibility, CacheControl, JobName } from 'src/enum';
+import { AssetFileType, AssetStatus, 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';
@@ -21,7 +22,6 @@ import { AuthFactory } from 'test/factories/auth.factory';
 import { authStub } from 'test/fixtures/auth.stub';
 import { fileStub } from 'test/fixtures/file.stub';
 import { userStub } from 'test/fixtures/user.stub';
-import { getForAsset } from 'test/mappers';
 import { newTestService, ServiceMocks } from 'test/utils';
 
 const file1 = Buffer.from('d2947b871a706081be194569951b7db246907957', 'hex');
@@ -152,6 +152,13 @@ const createDto = Object.freeze({
   duration: '0:00:00.000000',
 }) as AssetMediaCreateDto;
 
+const replaceDto = Object.freeze({
+  deviceAssetId: 'deviceAssetId',
+  deviceId: 'deviceId',
+  fileModifiedAt: new Date('2024-04-15T23:41:36.910Z'),
+  fileCreatedAt: new Date('2024-04-15T23:41:36.910Z'),
+}) as AssetMediaReplaceDto;
+
 const assetEntity = Object.freeze({
   id: 'id_1',
   ownerId: 'user_id_1',
@@ -173,6 +180,25 @@ const assetEntity = Object.freeze({
   livePhotoVideoId: null,
 } as MapAsset);
 
+const existingAsset = Object.freeze({
+  ...assetEntity,
+  duration: null,
+  type: AssetType.Image,
+  checksum: Buffer.from('_getExistingAsset', 'utf8'),
+  libraryId: 'libraryId',
+  originalFileName: 'existing-filename.jpeg',
+}) as MapAsset;
+
+const sidecarAsset = Object.freeze({
+  ...existingAsset,
+  checksum: Buffer.from('_getExistingAssetWithSideCar', 'utf8'),
+}) as MapAsset;
+
+const copiedAsset = Object.freeze({
+  id: 'copied-asset',
+  originalPath: 'copied-path',
+}) as MapAsset;
+
 describe(AssetMediaService.name, () => {
   let sut: AssetMediaService;
   let mocks: ServiceMocks;
@@ -408,7 +434,7 @@ describe(AssetMediaService.name, () => {
         .owner(authStub.user1.user)
         .build();
       const asset = AssetFactory.create({ livePhotoVideoId: motionAsset.id });
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(motionAsset));
+      mocks.asset.getById.mockResolvedValueOnce(motionAsset);
       mocks.asset.create.mockResolvedValueOnce(asset);
 
       await expect(
@@ -425,7 +451,7 @@ describe(AssetMediaService.name, () => {
     it('should hide the linked motion asset', async () => {
       const motionAsset = AssetFactory.from({ type: AssetType.Video }).owner(authStub.user1.user).build();
       const asset = AssetFactory.create();
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(motionAsset));
+      mocks.asset.getById.mockResolvedValueOnce(motionAsset);
       mocks.asset.create.mockResolvedValueOnce(asset);
 
       await expect(
@@ -444,7 +470,7 @@ describe(AssetMediaService.name, () => {
 
     it('should handle a sidecar file', async () => {
       const asset = AssetFactory.from().file({ type: AssetFileType.Sidecar }).build();
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValueOnce(asset);
       mocks.asset.create.mockResolvedValueOnce(asset);
 
       await expect(sut.uploadAsset(authStub.user1, createDto, fileStub.photo, fileStub.photoSidecar)).resolves.toEqual({
@@ -750,6 +776,177 @@ describe(AssetMediaService.name, () => {
     });
   });
 
+  describe('replaceAsset', () => {
+    it('should fail the auth check when update photo does not exist', async () => {
+      await expect(sut.replaceAsset(authStub.user1, 'id', replaceDto, fileStub.photo)).rejects.toThrow(
+        'Not found or no asset.update access',
+      );
+
+      expect(mocks.asset.create).not.toHaveBeenCalled();
+    });
+
+    it('should fail if asset cannot be fetched', async () => {
+      mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([existingAsset.id]));
+      await expect(sut.replaceAsset(authStub.user1, existingAsset.id, replaceDto, fileStub.photo)).rejects.toThrow(
+        'Asset not found',
+      );
+
+      expect(mocks.asset.create).not.toHaveBeenCalled();
+    });
+
+    it('should update a photo with no sidecar to photo with no sidecar', async () => {
+      const updatedFile = fileStub.photo;
+      const updatedAsset = { ...existingAsset, ...updatedFile };
+      mocks.asset.getById.mockResolvedValueOnce(existingAsset);
+      mocks.asset.getById.mockResolvedValueOnce(updatedAsset);
+      mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([existingAsset.id]));
+      // this is the original file size
+      mocks.storage.stat.mockResolvedValue({ size: 0 } as Stats);
+      // this is for the clone call
+      mocks.asset.create.mockResolvedValue(copiedAsset);
+
+      await expect(sut.replaceAsset(authStub.user1, existingAsset.id, replaceDto, updatedFile)).resolves.toEqual({
+        status: AssetMediaStatus.REPLACED,
+        id: 'copied-asset',
+      });
+
+      expect(mocks.asset.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          id: existingAsset.id,
+          originalFileName: 'photo1.jpeg',
+          originalPath: 'fake_path/photo1.jpeg',
+        }),
+      );
+      expect(mocks.asset.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          originalFileName: 'existing-filename.jpeg',
+          originalPath: 'fake_path/asset_1.jpeg',
+        }),
+      );
+      expect(mocks.asset.deleteFile).toHaveBeenCalledWith(
+        expect.objectContaining({
+          assetId: existingAsset.id,
+          type: AssetFileType.Sidecar,
+        }),
+      );
+
+      expect(mocks.asset.updateAll).toHaveBeenCalledWith([copiedAsset.id], {
+        deletedAt: expect.any(Date),
+        status: AssetStatus.Trashed,
+      });
+      expect(mocks.user.updateUsage).toHaveBeenCalledWith(authStub.user1.user.id, updatedFile.size);
+      expect(mocks.storage.utimes).toHaveBeenCalledWith(
+        updatedFile.originalPath,
+        expect.any(Date),
+        new Date(replaceDto.fileModifiedAt),
+      );
+    });
+
+    it('should update a photo with sidecar to photo with sidecar', async () => {
+      const updatedFile = fileStub.photo;
+      const sidecarFile = fileStub.photoSidecar;
+      const updatedAsset = { ...sidecarAsset, ...updatedFile };
+      mocks.asset.getById.mockResolvedValueOnce(existingAsset);
+      mocks.asset.getById.mockResolvedValueOnce(updatedAsset);
+      mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([sidecarAsset.id]));
+      // this is the original file size
+      mocks.storage.stat.mockResolvedValue({ size: 0 } as Stats);
+      // this is for the clone call
+      mocks.asset.create.mockResolvedValue(copiedAsset);
+
+      await expect(
+        sut.replaceAsset(authStub.user1, sidecarAsset.id, replaceDto, updatedFile, sidecarFile),
+      ).resolves.toEqual({
+        status: AssetMediaStatus.REPLACED,
+        id: 'copied-asset',
+      });
+
+      expect(mocks.asset.updateAll).toHaveBeenCalledWith([copiedAsset.id], {
+        deletedAt: expect.any(Date),
+        status: AssetStatus.Trashed,
+      });
+      expect(mocks.asset.upsertFile).toHaveBeenCalledWith(
+        expect.objectContaining({
+          assetId: existingAsset.id,
+          path: sidecarFile.originalPath,
+          type: AssetFileType.Sidecar,
+        }),
+      );
+      expect(mocks.user.updateUsage).toHaveBeenCalledWith(authStub.user1.user.id, updatedFile.size);
+      expect(mocks.storage.utimes).toHaveBeenCalledWith(
+        updatedFile.originalPath,
+        expect.any(Date),
+        new Date(replaceDto.fileModifiedAt),
+      );
+    });
+
+    it('should update a photo with a sidecar to photo with no sidecar', async () => {
+      const updatedFile = fileStub.photo;
+
+      const updatedAsset = { ...sidecarAsset, ...updatedFile };
+      mocks.asset.getById.mockResolvedValueOnce(sidecarAsset);
+      mocks.asset.getById.mockResolvedValueOnce(updatedAsset);
+      mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([sidecarAsset.id]));
+      // this is the original file size
+      mocks.storage.stat.mockResolvedValue({ size: 0 } as Stats);
+      // this is for the copy call
+      mocks.asset.create.mockResolvedValue(copiedAsset);
+
+      await expect(sut.replaceAsset(authStub.user1, existingAsset.id, replaceDto, updatedFile)).resolves.toEqual({
+        status: AssetMediaStatus.REPLACED,
+        id: 'copied-asset',
+      });
+
+      expect(mocks.asset.updateAll).toHaveBeenCalledWith([copiedAsset.id], {
+        deletedAt: expect.any(Date),
+        status: AssetStatus.Trashed,
+      });
+      expect(mocks.asset.deleteFile).toHaveBeenCalledWith(
+        expect.objectContaining({
+          assetId: existingAsset.id,
+          type: AssetFileType.Sidecar,
+        }),
+      );
+      expect(mocks.user.updateUsage).toHaveBeenCalledWith(authStub.user1.user.id, updatedFile.size);
+      expect(mocks.storage.utimes).toHaveBeenCalledWith(
+        updatedFile.originalPath,
+        expect.any(Date),
+        new Date(replaceDto.fileModifiedAt),
+      );
+    });
+
+    it('should handle a photo with sidecar to duplicate photo ', async () => {
+      const updatedFile = fileStub.photo;
+      const error = new Error('unique key violation');
+      (error as any).constraint_name = ASSET_CHECKSUM_CONSTRAINT;
+
+      mocks.asset.update.mockRejectedValue(error);
+      mocks.asset.getById.mockResolvedValueOnce(sidecarAsset);
+      mocks.asset.getUploadAssetIdByChecksum.mockResolvedValue(sidecarAsset.id);
+      mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([sidecarAsset.id]));
+      // this is the original file size
+      mocks.storage.stat.mockResolvedValue({ size: 0 } as Stats);
+      // this is for the clone call
+      mocks.asset.create.mockResolvedValue(copiedAsset);
+
+      await expect(sut.replaceAsset(authStub.user1, sidecarAsset.id, replaceDto, updatedFile)).resolves.toEqual({
+        status: AssetMediaStatus.DUPLICATE,
+        id: sidecarAsset.id,
+      });
+
+      expect(mocks.asset.create).not.toHaveBeenCalled();
+      expect(mocks.asset.updateAll).not.toHaveBeenCalled();
+      expect(mocks.asset.upsertFile).not.toHaveBeenCalled();
+      expect(mocks.asset.deleteFile).not.toHaveBeenCalled();
+
+      expect(mocks.job.queue).toHaveBeenCalledWith({
+        name: JobName.FileDelete,
+        data: { files: [updatedFile.originalPath, undefined] },
+      });
+      expect(mocks.user.updateUsage).not.toHaveBeenCalled();
+    });
+  });
+
   describe('bulkUploadCheck', () => {
     it('should accept hex and base64 checksums', async () => {
       const file1 = Buffer.from('d2947b871a706081be194569951b7db246907957', 'hex');

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

@@ -8,7 +8,6 @@ import { AssetService } from 'src/services/asset.service';
 import { AssetFactory } from 'test/factories/asset.factory';
 import { AuthFactory } from 'test/factories/auth.factory';
 import { authStub } from 'test/fixtures/auth.stub';
-import { getForAsset, getForAssetDeletion, getForPartner } from 'test/mappers';
 import { factory, newUuid } from 'test/small.factory';
 import { makeStream, newTestService, ServiceMocks } from 'test/utils';
 
@@ -72,7 +71,7 @@ describe(AssetService.name, () => {
   describe('getRandom', () => {
     it('should get own random assets', async () => {
       mocks.partner.getAll.mockResolvedValue([]);
-      mocks.asset.getRandom.mockResolvedValue([getForAsset(AssetFactory.create())]);
+      mocks.asset.getRandom.mockResolvedValue([AssetFactory.create()]);
 
       await sut.getRandom(authStub.admin, 1);
 
@@ -83,8 +82,8 @@ describe(AssetService.name, () => {
       const partner = factory.partner({ inTimeline: false });
       const auth = factory.auth({ user: { id: partner.sharedWithId } });
 
-      mocks.asset.getRandom.mockResolvedValue([getForAsset(AssetFactory.create())]);
-      mocks.partner.getAll.mockResolvedValue([getForPartner(partner)]);
+      mocks.asset.getRandom.mockResolvedValue([AssetFactory.create()]);
+      mocks.partner.getAll.mockResolvedValue([partner]);
 
       await sut.getRandom(auth, 1);
 
@@ -95,8 +94,8 @@ describe(AssetService.name, () => {
       const partner = factory.partner({ inTimeline: true });
       const auth = factory.auth({ user: { id: partner.sharedWithId } });
 
-      mocks.asset.getRandom.mockResolvedValue([getForAsset(AssetFactory.create())]);
-      mocks.partner.getAll.mockResolvedValue([getForPartner(partner)]);
+      mocks.asset.getRandom.mockResolvedValue([AssetFactory.create()]);
+      mocks.partner.getAll.mockResolvedValue([partner]);
 
       await sut.getRandom(auth, 1);
 
@@ -108,7 +107,7 @@ describe(AssetService.name, () => {
     it('should allow owner access', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
 
       await sut.get(authStub.admin, asset.id);
 
@@ -122,7 +121,7 @@ describe(AssetService.name, () => {
     it('should allow shared link access', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkSharedLinkAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
 
       await sut.get(authStub.adminSharedLink, asset.id);
 
@@ -135,7 +134,7 @@ describe(AssetService.name, () => {
     it('should strip metadata for shared link if exif is disabled', async () => {
       const asset = AssetFactory.from().exif({ description: 'foo' }).build();
       mocks.access.asset.checkSharedLinkAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
 
       const result = await sut.get(
         { ...authStub.adminSharedLink, sharedLink: { ...authStub.adminSharedLink.sharedLink!, showExif: false } },
@@ -153,7 +152,7 @@ describe(AssetService.name, () => {
     it('should allow partner sharing access', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkPartnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
 
       await sut.get(authStub.admin, asset.id);
 
@@ -163,7 +162,7 @@ describe(AssetService.name, () => {
     it('should allow shared album access', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkAlbumAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
 
       await sut.get(authStub.admin, asset.id);
 
@@ -205,8 +204,8 @@ describe(AssetService.name, () => {
     it('should update the asset', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
-      mocks.asset.update.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
+      mocks.asset.update.mockResolvedValue(asset);
 
       await sut.update(authStub.admin, asset.id, { isFavorite: true });
 
@@ -216,8 +215,8 @@ describe(AssetService.name, () => {
     it('should update the exif description', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
-      mocks.asset.update.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
+      mocks.asset.update.mockResolvedValue(asset);
 
       await sut.update(authStub.admin, asset.id, { description: 'Test description' });
 
@@ -230,8 +229,8 @@ describe(AssetService.name, () => {
     it('should update the exif rating', async () => {
       const asset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(asset));
-      mocks.asset.update.mockResolvedValueOnce(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValueOnce(asset);
+      mocks.asset.update.mockResolvedValueOnce(asset);
 
       await sut.update(authStub.admin, asset.id, { rating: 3 });
 
@@ -275,7 +274,7 @@ describe(AssetService.name, () => {
       const motionAsset = AssetFactory.from().owner(auth.user).build();
       const asset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(asset));
+      mocks.asset.getById.mockResolvedValue(asset);
 
       await expect(
         sut.update(authStub.admin, asset.id, {
@@ -302,7 +301,7 @@ describe(AssetService.name, () => {
       const motionAsset = AssetFactory.create({ type: AssetType.Video });
       const asset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValue(getForAsset(motionAsset));
+      mocks.asset.getById.mockResolvedValue(motionAsset);
 
       await expect(
         sut.update(auth, asset.id, {
@@ -328,9 +327,9 @@ describe(AssetService.name, () => {
       const motionAsset = AssetFactory.create({ type: AssetType.Video, visibility: AssetVisibility.Timeline });
       const stillAsset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([stillAsset.id]));
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(motionAsset));
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(stillAsset));
-      mocks.asset.update.mockResolvedValue(getForAsset(stillAsset));
+      mocks.asset.getById.mockResolvedValueOnce(motionAsset);
+      mocks.asset.getById.mockResolvedValueOnce(stillAsset);
+      mocks.asset.update.mockResolvedValue(stillAsset);
       const auth = AuthFactory.from(motionAsset.owner).build();
 
       await sut.update(auth, stillAsset.id, { livePhotoVideoId: motionAsset.id });
@@ -355,9 +354,9 @@ describe(AssetService.name, () => {
       const asset = AssetFactory.create({ livePhotoVideoId: motionAsset.id });
       const unlinkedAsset = AssetFactory.create();
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set([asset.id]));
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(asset));
-      mocks.asset.getById.mockResolvedValueOnce(getForAsset(motionAsset));
-      mocks.asset.update.mockResolvedValueOnce(getForAsset(unlinkedAsset));
+      mocks.asset.getById.mockResolvedValueOnce(asset);
+      mocks.asset.getById.mockResolvedValueOnce(motionAsset);
+      mocks.asset.update.mockResolvedValueOnce(unlinkedAsset);
 
       await sut.update(auth, asset.id, { livePhotoVideoId: null });
 
@@ -533,7 +532,7 @@ describe(AssetService.name, () => {
     });
 
     it('should immediately queue assets for deletion if trash is disabled', async () => {
-      const asset = AssetFactory.create();
+      const asset = factory.asset({ isOffline: false });
 
       mocks.assetJob.streamForDeletedJob.mockReturnValue(makeStream([asset]));
       mocks.systemMetadata.get.mockResolvedValue({ trash: { enabled: false } });
@@ -547,7 +546,7 @@ describe(AssetService.name, () => {
     });
 
     it('should queue assets for deletion after trash duration', async () => {
-      const asset = AssetFactory.create();
+      const asset = factory.asset({ isOffline: false });
 
       mocks.assetJob.streamForDeletedJob.mockReturnValue(makeStream([asset]));
       mocks.systemMetadata.get.mockResolvedValue({ trash: { enabled: true, days: 7 } });
@@ -570,7 +569,7 @@ describe(AssetService.name, () => {
         .file({ type: AssetFileType.Preview, isEdited: true })
         .file({ type: AssetFileType.Thumbnail, isEdited: true })
         .build();
-      mocks.assetJob.getForAssetDeletion.mockResolvedValue(getForAssetDeletion(asset));
+      mocks.assetJob.getForAssetDeletion.mockResolvedValue(asset);
 
       await sut.handleAssetDeletion({ id: asset.id, deleteOnDisk: true });
 
@@ -584,7 +583,7 @@ describe(AssetService.name, () => {
           },
         ],
       ]);
-      expect(mocks.asset.remove).toHaveBeenCalledWith(getForAssetDeletion(asset));
+      expect(mocks.asset.remove).toHaveBeenCalledWith(asset);
     });
 
     it('should delete the entire stack if deleted asset was the primary asset and the stack would only contain one asset afterwards', async () => {
@@ -592,7 +591,11 @@ describe(AssetService.name, () => {
         .stack({}, (builder) => builder.asset())
         .build();
       mocks.stack.delete.mockResolvedValue();
-      mocks.assetJob.getForAssetDeletion.mockResolvedValue(getForAssetDeletion(asset));
+      mocks.assetJob.getForAssetDeletion.mockResolvedValue({
+        ...asset,
+        // TODO the specific query filters out the primary asset from `stack.assets`. This should be in a mapper eventually
+        stack: { ...asset.stack!, assets: asset.stack!.assets.filter(({ id }) => id !== asset.stack!.primaryAssetId) },
+      });
 
       await sut.handleAssetDeletion({ id: asset.id, deleteOnDisk: true });
 
@@ -602,7 +605,7 @@ describe(AssetService.name, () => {
     it('should delete a live photo', async () => {
       const motionAsset = AssetFactory.from({ type: AssetType.Video, visibility: AssetVisibility.Hidden }).build();
       const asset = AssetFactory.create({ livePhotoVideoId: motionAsset.id });
-      mocks.assetJob.getForAssetDeletion.mockResolvedValue(getForAssetDeletion(asset));
+      mocks.assetJob.getForAssetDeletion.mockResolvedValue(asset);
       mocks.asset.getLivePhotoCount.mockResolvedValue(0);
 
       await sut.handleAssetDeletion({
@@ -619,7 +622,7 @@ describe(AssetService.name, () => {
     it('should not delete a live motion part if it is being used by another asset', async () => {
       const asset = AssetFactory.create({ livePhotoVideoId: newUuid() });
       mocks.asset.getLivePhotoCount.mockResolvedValue(2);
-      mocks.assetJob.getForAssetDeletion.mockResolvedValue(getForAssetDeletion(asset));
+      mocks.assetJob.getForAssetDeletion.mockResolvedValue(asset);
 
       await sut.handleAssetDeletion({ id: asset.id, deleteOnDisk: true });
 
@@ -630,7 +633,7 @@ describe(AssetService.name, () => {
 
     it('should update usage', async () => {
       const asset = AssetFactory.from().exif({ fileSizeInByte: 5000 }).build();
-      mocks.assetJob.getForAssetDeletion.mockResolvedValue(getForAssetDeletion(asset));
+      mocks.assetJob.getForAssetDeletion.mockResolvedValue(asset);
       await sut.handleAssetDeletion({ id: asset.id, deleteOnDisk: true });
       expect(mocks.user.updateUsage).toHaveBeenCalledWith(asset.ownerId, -5000);
     });
@@ -736,7 +739,7 @@ describe(AssetService.name, () => {
 
   describe('upsertMetadata', () => {
     it('should throw a bad request exception if duplicate keys are sent', async () => {
-      const asset = AssetFactory.create();
+      const asset = factory.asset();
       const items = [
         { key: AssetMetadataKey.MobileApp, value: { iCloudId: 'id1' } },
         { key: AssetMetadataKey.MobileApp, value: { iCloudId: 'id1' } },
@@ -754,7 +757,7 @@ describe(AssetService.name, () => {
 
   describe('upsertBulkMetadata', () => {
     it('should throw a bad request exception if duplicate keys are sent', async () => {
-      const asset = AssetFactory.create();
+      const asset = factory.asset();
       const items = [
         { assetId: asset.id, key: AssetMetadataKey.MobileApp, value: { iCloudId: 'id1' } },
         { assetId: asset.id, key: AssetMetadataKey.MobileApp, value: { iCloudId: 'id1' } },

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

@@ -3,7 +3,6 @@ import { DuplicateService } from 'src/services/duplicate.service';
 import { SearchService } from 'src/services/search.service';
 import { AssetFactory } from 'test/factories/asset.factory';
 import { authStub } from 'test/fixtures/auth.stub';
-import { getForDuplicate } from 'test/mappers';
 import { newUuid } from 'test/small.factory';
 import { makeStream, newTestService, ServiceMocks } from 'test/utils';
 import { beforeEach, vitest } from 'vitest';
@@ -40,11 +39,11 @@ describe(SearchService.name, () => {
 
   describe('getDuplicates', () => {
     it('should get duplicates', async () => {
-      const asset = AssetFactory.from().exif().build();
+      const asset = AssetFactory.create();
       mocks.duplicateRepository.getAll.mockResolvedValue([
         {
           duplicateId: 'duplicate-id',
-          assets: [getForDuplicate(asset), getForDuplicate(asset)],
+          assets: [asset, asset],
         },
       ]);
       await expect(sut.getDuplicates(authStub.admin)).resolves.toEqual([

server/src/services/job.service.ts

@@ -186,8 +186,8 @@ export class JobService extends BaseService {
                 exifImageHeight: exif.exifImageHeight,
                 fileSizeInByte: exif.fileSizeInByte,
                 orientation: exif.orientation,
-                dateTimeOriginal: exif.dateTimeOriginal ? new Date(exif.dateTimeOriginal) : null,
-                modifyDate: exif.modifyDate ? new Date(exif.modifyDate) : null,
+                dateTimeOriginal: exif.dateTimeOriginal,
+                modifyDate: exif.modifyDate,
                 timeZone: exif.timeZone,
                 latitude: exif.latitude,
                 longitude: exif.longitude,

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

@@ -3,7 +3,6 @@ import { AlbumFactory } from 'test/factories/album.factory';
 import { AssetFactory } from 'test/factories/asset.factory';
 import { AuthFactory } from 'test/factories/auth.factory';
 import { userStub } from 'test/fixtures/user.stub';
-import { getForAlbum, getForPartner } from 'test/mappers';
 import { factory } from 'test/small.factory';
 import { newTestService, ServiceMocks } from 'test/utils';
 
@@ -53,7 +52,7 @@ describe(MapService.name, () => {
         state: asset.exifInfo.state,
         country: asset.exifInfo.country,
       };
-      mocks.partner.getAll.mockResolvedValue([getForPartner(partner)]);
+      mocks.partner.getAll.mockResolvedValue([partner]);
       mocks.map.getMapMarkers.mockResolvedValue([marker]);
 
       const markers = await sut.getMapMarkers(auth, { withPartners: true });
@@ -82,10 +81,8 @@ describe(MapService.name, () => {
       };
       mocks.partner.getAll.mockResolvedValue([]);
       mocks.map.getMapMarkers.mockResolvedValue([marker]);
-      mocks.album.getOwned.mockResolvedValue([getForAlbum(AlbumFactory.create())]);
-      mocks.album.getShared.mockResolvedValue([
-        getForAlbum(AlbumFactory.from().albumUser({ userId: userStub.user1.id }).build()),
-      ]);
+      mocks.album.getOwned.mockResolvedValue([AlbumFactory.create()]);
+      mocks.album.getShared.mockResolvedValue([AlbumFactory.from().albumUser({ userId: userStub.user1.id }).build()]);
 
       const markers = await sut.getMapMarkers(auth, { withSharedAlbums: true });