feat: API and UI to replace asset data without changing record id

.vscode/settings.json

@@ -20,10 +20,7 @@
     "editor.tabSize": 2
   },
   "svelte.enable-ts-plugin": true,
-  "eslint.validate": [
-    "javascript",
-    "svelte"
-  ],
+  "eslint.validate": ["javascript", "svelte"],
   "typescript.preferences.importModuleSpecifier": "non-relative",
   "[dart]": {
     "editor.formatOnSave": true,
@@ -34,9 +31,7 @@
     "editor.wordBasedSuggestions": "off",
     "editor.defaultFormatter": "Dart-Code.dart-code"
   },
-  "cSpell.words": [
-    "immich"
-  ],
+  "cSpell.words": ["immich"],
   "explorer.fileNesting.enabled": true,
   "explorer.fileNesting.patterns": {
     "*.ts": "${capture}.spec.ts,${capture}.mock.ts"

e2e/src/api/specs/activity.e2e-spec.ts

@@ -2,7 +2,7 @@ import {
   ActivityCreateDto,
   AlbumResponseDto,
   AlbumUserRole,
-  AssetFileUploadResponseDto,
+  AssetMediaCreateResponseDto,
   LoginResponseDto,
   ReactionType,
   createActivity as create,
@@ -17,7 +17,8 @@ import { beforeAll, beforeEach, describe, expect, it } from 'vitest';
 describe('/activity', () => {
   let admin: LoginResponseDto;
   let nonOwner: LoginResponseDto;
-  let asset: AssetFileUploadResponseDto;
+
+  let assetId: string;
   let album: AlbumResponseDto;
 
   const createActivity = (dto: ActivityCreateDto, accessToken?: string) =>
@@ -28,12 +29,13 @@ describe('/activity', () => {
 
     admin = await utils.adminSetup();
     nonOwner = await utils.userSetup(admin.accessToken, createUserDto.user1);
-    asset = await utils.createAsset(admin.accessToken);
+    const assetMediaResponse = (await utils.createAsset(admin.accessToken)) as AssetMediaCreateResponseDto;
+    assetId = assetMediaResponse.assetId;
     album = await createAlbum(
       {
         createAlbumDto: {
           albumName: 'Album 1',
-          assetIds: [asset.id],
+          assetIds: [assetId],
           albumUsers: [{ userId: nonOwner.userId, role: AlbumUserRole.Editor }],
         },
       },
@@ -90,7 +92,7 @@ describe('/activity', () => {
         {
           createAlbumDto: {
             albumName: 'Album 2',
-            assetIds: [asset.id],
+            assetIds: [assetId],
           },
         },
         { headers: asBearerAuth(admin.accessToken) },
@@ -173,15 +175,15 @@ describe('/activity', () => {
       const [reaction] = await Promise.all([
         createActivity({
           albumId: album.id,
-          assetId: asset.id,
+          assetId: assetId,
           type: ReactionType.Like,
         }),
         createActivity({ albumId: album.id, type: ReactionType.Like }),
       ]);
 
       const { status, body } = await request(app)
         .get('/activity')
-        .query({ albumId: album.id, assetId: asset.id })
+        .query({ albumId: album.id, assetId: assetId })
         .set('Authorization', `Bearer ${admin.accessToken}`);
       expect(status).toEqual(200);
       expect(body.length).toBe(1);
@@ -263,7 +265,7 @@ describe('/activity', () => {
     it('should not confuse an album like with an asset like', async () => {
       const reaction = await createActivity({
         albumId: album.id,
-        assetId: asset.id,
+        assetId: assetId,
         type: ReactionType.Like,
       });
       const { status, body } = await request(app)
@@ -280,14 +282,14 @@ describe('/activity', () => {
         .set('Authorization', `Bearer ${admin.accessToken}`)
         .send({
           albumId: album.id,
-          assetId: asset.id,
+          assetId: assetId,
           type: 'comment',
           comment: 'This is my first comment',
         });
       expect(status).toEqual(201);
       expect(body).toEqual({
         id: expect.any(String),
-        assetId: asset.id,
+        assetId: assetId,
         createdAt: expect.any(String),
         type: 'comment',
         comment: 'This is my first comment',
@@ -299,11 +301,11 @@ describe('/activity', () => {
       const { status, body } = await request(app)
         .post('/activity')
         .set('Authorization', `Bearer ${admin.accessToken}`)
-        .send({ albumId: album.id, assetId: asset.id, type: 'like' });
+        .send({ albumId: album.id, assetId: assetId, type: 'like' });
       expect(status).toEqual(201);
       expect(body).toEqual({
         id: expect.any(String),
-        assetId: asset.id,
+        assetId: assetId,
         createdAt: expect.any(String),
         type: 'like',
         comment: null,
@@ -314,14 +316,14 @@ describe('/activity', () => {
     it('should return a 200 for a duplicate like on an asset', async () => {
       const reaction = await createActivity({
         albumId: album.id,
-        assetId: asset.id,
+        assetId: assetId,
         type: ReactionType.Like,
       });
 
       const { status, body } = await request(app)
         .post('/activity')
         .set('Authorization', `Bearer ${admin.accessToken}`)
-        .send({ albumId: album.id, assetId: asset.id, type: 'like' });
+        .send({ albumId: album.id, assetId: assetId, type: 'like' });
       expect(status).toEqual(200);
       expect(body).toEqual(reaction);
     });

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

@@ -2,7 +2,7 @@ import {
   addAssetsToAlbum,
   AlbumResponseDto,
   AlbumUserRole,
-  AssetFileUploadResponseDto,
+  AssetMediaCreateResponseDto,
   AssetOrder,
   deleteUser,
   getAlbumInfo,
@@ -26,8 +26,8 @@ const user2NotShared = 'user2NotShared';
 describe('/album', () => {
   let admin: LoginResponseDto;
   let user1: LoginResponseDto;
-  let user1Asset1: AssetFileUploadResponseDto;
-  let user1Asset2: AssetFileUploadResponseDto;
+  let user1Asset1: string;
+  let user1Asset2: string;
   let user1Albums: AlbumResponseDto[];
   let user2: LoginResponseDto;
   let user2Albums: AlbumResponseDto[];
@@ -44,29 +44,30 @@ describe('/album', () => {
       utils.userSetup(admin.accessToken, createUserDto.user3),
     ]);
 
-    [user1Asset1, user1Asset2] = await Promise.all([
+    const responses = await Promise.all([
       utils.createAsset(user1.accessToken, { isFavorite: true }),
       utils.createAsset(user1.accessToken),
     ]);
+    [user1Asset1, user1Asset2] = responses.map((response) => (response as AssetMediaCreateResponseDto).assetId!);
 
     user1Albums = await Promise.all([
       utils.createAlbum(user1.accessToken, {
         albumName: user1SharedEditorUser,
         albumUsers: [{ userId: user2.userId, role: AlbumUserRole.Editor }],
-        assetIds: [user1Asset1.id],
+        assetIds: [user1Asset1],
       }),
       utils.createAlbum(user1.accessToken, {
         albumName: user1SharedLink,
-        assetIds: [user1Asset1.id],
+        assetIds: [user1Asset1],
       }),
       utils.createAlbum(user1.accessToken, {
         albumName: user1NotShared,
-        assetIds: [user1Asset1.id, user1Asset2.id],
+        assetIds: [user1Asset1, user1Asset2],
       }),
       utils.createAlbum(user1.accessToken, {
         albumName: user1SharedViewerUser,
         albumUsers: [{ userId: user2.userId, role: AlbumUserRole.Viewer }],
-        assetIds: [user1Asset1.id],
+        assetIds: [user1Asset1],
       }),
     ]);
 
@@ -88,7 +89,7 @@ describe('/album', () => {
     });
 
     await addAssetsToAlbum(
-      { id: user2Albums[0].id, bulkIdsDto: { ids: [user1Asset1.id] } },
+      { id: user2Albums[0].id, bulkIdsDto: { ids: [user1Asset1] } },
       { headers: asBearerAuth(user1.accessToken) },
     );
 
@@ -258,23 +259,23 @@ describe('/album', () => {
 
     it('should return the album collection filtered by assetId', async () => {
       const { status, body } = await request(app)
-        .get(`/album?assetId=${user1Asset2.id}`)
+        .get(`/album?assetId=${user1Asset2}`)
         .set('Authorization', `Bearer ${user1.accessToken}`);
       expect(status).toBe(200);
       expect(body).toHaveLength(1);
     });
 
     it('should return the album collection filtered by assetId and ignores shared=true', async () => {
       const { status, body } = await request(app)
-        .get(`/album?shared=true&assetId=${user1Asset1.id}`)
+        .get(`/album?shared=true&assetId=${user1Asset1}`)
         .set('Authorization', `Bearer ${user1.accessToken}`);
       expect(status).toBe(200);
       expect(body).toHaveLength(5);
     });
 
     it('should return the album collection filtered by assetId and ignores shared=false', async () => {
       const { status, body } = await request(app)
-        .get(`/album?shared=false&assetId=${user1Asset1.id}`)
+        .get(`/album?shared=false&assetId=${user1Asset1}`)
         .set('Authorization', `Bearer ${user1.accessToken}`);
       expect(status).toBe(200);
       expect(body).toHaveLength(5);
@@ -403,49 +404,49 @@ describe('/album', () => {
     });
 
     it('should be able to add own asset to own album', async () => {
-      const asset = await utils.createAsset(user1.accessToken);
+      const { assetId } = (await utils.createAsset(user1.accessToken)) as AssetMediaCreateResponseDto;
       const { status, body } = await request(app)
         .put(`/album/${user1Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ ids: [asset.id] });
+        .send({ ids: [assetId] });
 
       expect(status).toBe(200);
-      expect(body).toEqual([expect.objectContaining({ id: asset.id, success: true })]);
+      expect(body).toEqual([expect.objectContaining({ id: assetId, success: true })]);
     });
 
     it('should be able to add own asset to shared album', async () => {
-      const asset = await utils.createAsset(user1.accessToken);
+      const { assetId } = (await utils.createAsset(user1.accessToken)) as AssetMediaCreateResponseDto;
       const { status, body } = await request(app)
         .put(`/album/${user2Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ ids: [asset.id] });
+        .send({ ids: [assetId] });
 
       expect(status).toBe(200);
-      expect(body).toEqual([expect.objectContaining({ id: asset.id, success: true })]);
+      expect(body).toEqual([expect.objectContaining({ id: assetId, success: true })]);
     });
 
     it('should not be able to add assets to album as a viewer', async () => {
-      const asset = await utils.createAsset(user2.accessToken);
+      const { assetId } = (await utils.createAsset(user2.accessToken)) as AssetMediaCreateResponseDto;
       const { status, body } = await request(app)
         .put(`/album/${user1Albums[3].id}/assets`)
         .set('Authorization', `Bearer ${user2.accessToken}`)
-        .send({ ids: [asset.id] });
+        .send({ ids: [assetId] });
 
       expect(status).toBe(400);
       expect(body).toEqual(errorDto.badRequest('Not found or no album.addAsset access'));
     });
 
     it('should add duplicate assets only once', async () => {
-      const asset = await utils.createAsset(user1.accessToken);
+      const { assetId } = (await utils.createAsset(user1.accessToken)) as AssetMediaCreateResponseDto;
       const { status, body } = await request(app)
         .put(`/album/${user1Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ ids: [asset.id, asset.id] });
+        .send({ ids: [assetId, assetId] });
 
       expect(status).toBe(200);
       expect(body).toEqual([
-        expect.objectContaining({ id: asset.id, success: true }),
-        expect.objectContaining({ id: asset.id, success: false, error: 'duplicate' }),
+        expect.objectContaining({ id: assetId, success: true }),
+        expect.objectContaining({ id: assetId, success: false, error: 'duplicate' }),
       ]);
     });
   });
@@ -504,7 +505,7 @@ describe('/album', () => {
     it('should require authentication', async () => {
       const { status, body } = await request(app)
         .delete(`/album/${user1Albums[0].id}/assets`)
-        .send({ ids: [user1Asset1.id] });
+        .send({ ids: [user1Asset1] });
 
       expect(status).toBe(401);
       expect(body).toEqual(errorDto.unauthorized);
@@ -514,12 +515,12 @@ describe('/album', () => {
       const { status, body } = await request(app)
         .delete(`/album/${user2Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user2.accessToken}`)
-        .send({ ids: [user1Asset1.id] });
+        .send({ ids: [user1Asset1] });
 
       expect(status).toBe(200);
       expect(body).toEqual([
         expect.objectContaining({
-          id: user1Asset1.id,
+          id: user1Asset1,
           success: false,
           error: 'no_permission',
         }),
@@ -530,12 +531,12 @@ describe('/album', () => {
       const { status, body } = await request(app)
         .delete(`/album/${user1Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user2.accessToken}`)
-        .send({ ids: [user1Asset1.id] });
+        .send({ ids: [user1Asset1] });
 
       expect(status).toBe(200);
       expect(body).toEqual([
         expect.objectContaining({
-          id: user1Asset1.id,
+          id: user1Asset1,
           success: false,
           error: 'no_permission',
         }),
@@ -546,27 +547,27 @@ describe('/album', () => {
       const { status, body } = await request(app)
         .delete(`/album/${user1Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ ids: [user1Asset1.id] });
+        .send({ ids: [user1Asset1] });
 
       expect(status).toBe(200);
-      expect(body).toEqual([expect.objectContaining({ id: user1Asset1.id, success: true })]);
+      expect(body).toEqual([expect.objectContaining({ id: user1Asset1, success: true })]);
     });
 
     it('should be able to remove own asset from shared album', async () => {
       const { status, body } = await request(app)
         .delete(`/album/${user2Albums[0].id}/assets`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ ids: [user1Asset1.id] });
+        .send({ ids: [user1Asset1] });
 
       expect(status).toBe(200);
-      expect(body).toEqual([expect.objectContaining({ id: user1Asset1.id, success: true })]);
+      expect(body).toEqual([expect.objectContaining({ id: user1Asset1, success: true })]);
     });
 
     it('should not be able to remove assets from album as a viewer', async () => {
       const { status, body } = await request(app)
         .delete(`/album/${user1Albums[3].id}/assets`)
         .set('Authorization', `Bearer ${user2.accessToken}`)
-        .send({ ids: [user1Asset1.id] });
+        .send({ ids: [user1Asset1] });
 
       expect(status).toBe(400);
       expect(body).toEqual(errorDto.badRequest('Not found or no album.removeAsset access'));
@@ -576,12 +577,12 @@ describe('/album', () => {
       const { status, body } = await request(app)
         .delete(`/album/${user1Albums[1].id}/assets`)
         .set('Authorization', `Bearer ${user1.accessToken}`)
-        .send({ ids: [user1Asset1.id, user1Asset1.id] });
+        .send({ ids: [user1Asset1, user1Asset1] });
 
       expect(status).toBe(200);
       expect(body).toEqual([
-        expect.objectContaining({ id: user1Asset1.id, success: true }),
-        expect.objectContaining({ id: user1Asset1.id, success: false, error: 'not_found' }),
+        expect.objectContaining({ id: user1Asset1, success: true }),
+        expect.objectContaining({ id: user1Asset1, success: false, error: 'not_found' }),
       ]);
     });
   });