fix: album asset sync must sync new assets in a shared album (#20655)

server/test/medium.factory.ts

@@ -5,7 +5,15 @@ import { createHash, randomBytes } from 'node:crypto';
 import { Writable } from 'node:stream';
 import { AssetFace } from 'src/database';
 import { AuthDto, LoginResponseDto } from 'src/dtos/auth.dto';
-import { AlbumUserRole, AssetType, AssetVisibility, MemoryType, SourceType, SyncRequestType } from 'src/enum';
+import {
+  AlbumUserRole,
+  AssetType,
+  AssetVisibility,
+  MemoryType,
+  SourceType,
+  SyncEntityType,
+  SyncRequestType,
+} from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
@@ -251,11 +259,16 @@ export class SyncTestContext extends MediumTestContext<SyncService> {
 
   async syncAckAll(auth: AuthDto, response: Array<{ type: string; ack: string }>) {
     const acks: Record<string, string> = {};
+    const syncAcks: string[] = [];
     for (const { type, ack } of response) {
+      if (type === SyncEntityType.SyncAckV1) {
+        syncAcks.push(ack);
+        continue;
+      }
       acks[type] = ack;
     }
 
-    await this.sut.setAcks(auth, { acks: Object.values(acks) });
+    await this.sut.setAcks(auth, { acks: [...Object.values(acks), ...syncAcks] });
   }
 }
 
@@ -468,8 +481,6 @@ const personInsert = (person: Partial<Insertable<PersonTable>> & { ownerId: stri
     name: person.name || 'Test Name',
     ownerId: person.ownerId || newUuid(),
     thumbnailPath: person.thumbnailPath || '/path/to/thumbnail.jpg',
-    updatedAt: person.updatedAt || newDate(),
-    updateId: person.updateId || newUuid(),
   };
   return {
     ...defaults,

server/test/medium/specs/sync/sync-album-asset-exif.spec.ts

@@ -1,5 +1,6 @@
 import { Kysely } from 'kysely';
 import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
+import { AssetRepository } from 'src/repositories/asset.repository';
 import { DB } from 'src/schema';
 import { SyncTestContext } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
@@ -13,6 +14,18 @@ const setup = async (db?: Kysely<DB>) => {
   return { auth, user, session, ctx };
 };
 
+const updateSyncAck = {
+  ack: expect.stringContaining(SyncEntityType.AlbumAssetExifUpdateV1),
+  data: {},
+  type: SyncEntityType.SyncAckV1,
+};
+
+const backfillSyncAck = {
+  ack: expect.stringContaining(SyncEntityType.AlbumAssetExifBackfillV1),
+  data: {},
+  type: SyncEntityType.SyncAckV1,
+};
+
 beforeAll(async () => {
   defaultDatabase = await getKyselyDB();
 });
@@ -28,8 +41,8 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {
     await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.Editor });
 
     const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
-    expect(response).toHaveLength(1);
     expect(response).toEqual([
+      updateSyncAck,
       {
         ack: expect.any(String),
         data: {
@@ -59,9 +72,10 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {
           state: null,
           timeZone: null,
         },
-        type: SyncEntityType.AlbumAssetExifV1,
+        type: SyncEntityType.AlbumAssetExifCreateV1,
       },
     ]);
+    expect(response).toHaveLength(2);
 
     await ctx.syncAckAll(auth, response);
     await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([]);
@@ -75,7 +89,7 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {
     await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
 
     await expect(ctx.syncStream(auth, [SyncRequestType.AssetExifsV1])).resolves.toHaveLength(1);
-    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toHaveLength(1);
+    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toHaveLength(2);
   });
 
   it('should not sync album asset exif for unrelated user', async () => {
@@ -97,55 +111,46 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {
   it('should backfill album assets exif when a user shares an album with you', async () => {
     const { auth, ctx } = await setup();
     const { user: user2 } = await ctx.newUser();
-    const { asset: asset1Owner } = await ctx.newAsset({ ownerId: auth.user.id });
-    await ctx.newExif({ assetId: asset1Owner.id, make: 'asset1Owner' });
-    await wait(2);
+    const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
+    const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
     const { asset: asset1User2 } = await ctx.newAsset({ ownerId: user2.id });
     await ctx.newExif({ assetId: asset1User2.id, make: 'asset1User2' });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: asset1User2.id });
     await wait(2);
     const { asset: asset2User2 } = await ctx.newAsset({ ownerId: user2.id });
     await ctx.newExif({ assetId: asset2User2.id, make: 'asset2User2' });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: asset2User2.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album1.id, assetId: asset2User2.id });
     await wait(2);
     const { asset: asset3User2 } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: asset3User2.id });
     await ctx.newExif({ assetId: asset3User2.id, make: 'asset3User2' });
-    const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
-    await ctx.newAlbumAsset({ albumId: album1.id, assetId: asset2User2.id });
+    await wait(2);
     await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.Editor });
 
     const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
-    expect(response).toHaveLength(1);
     expect(response).toEqual([
+      updateSyncAck,
       {
         ack: expect.any(String),
         data: expect.objectContaining({
           assetId: asset2User2.id,
         }),
-        type: SyncEntityType.AlbumAssetExifV1,
+        type: SyncEntityType.AlbumAssetExifCreateV1,
       },
     ]);
+    expect(response).toHaveLength(2);
 
     // ack initial album asset exif sync
     await ctx.syncAckAll(auth, response);
 
     // create a second album
-    const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
-    await Promise.all(
-      [asset1User2.id, asset2User2.id, asset3User2.id, asset1Owner.id].map((assetId) =>
-        ctx.newAlbumAsset({ albumId: album2.id, assetId }),
-      ),
-    );
     await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.Editor });
 
     // should backfill the album user
     const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
     expect(newResponse).toEqual([
-      {
-        ack: expect.any(String),
-        data: expect.objectContaining({
-          assetId: asset1Owner.id,
-        }),
-        type: SyncEntityType.AlbumAssetExifBackfillV1,
-      },
       {
         ack: expect.any(String),
         data: expect.objectContaining({
@@ -160,21 +165,194 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {
         }),
         type: SyncEntityType.AlbumAssetExifBackfillV1,
       },
-      {
-        ack: expect.stringContaining(SyncEntityType.AlbumAssetExifBackfillV1),
-        data: {},
-        type: SyncEntityType.SyncAckV1,
-      },
+      backfillSyncAck,
+      updateSyncAck,
       {
         ack: expect.any(String),
         data: expect.objectContaining({
           assetId: asset3User2.id,
         }),
-        type: SyncEntityType.AlbumAssetExifV1,
+        type: SyncEntityType.AlbumAssetExifCreateV1,
       },
     ]);
+    expect(newResponse).toHaveLength(5);
 
     await ctx.syncAckAll(auth, newResponse);
     await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([]);
   });
+
+  it('should sync old asset exif when a user adds them to an album they share you', async () => {
+    const { auth, ctx } = await setup();
+    const { user: user2 } = await ctx.newUser();
+    const { asset: firstAsset } = await ctx.newAsset({ ownerId: user2.id, originalFileName: 'firstAsset' });
+    await ctx.newExif({ assetId: firstAsset.id, make: 'firstAsset' });
+    const { asset: secondAsset } = await ctx.newAsset({ ownerId: user2.id, originalFileName: 'secondAsset' });
+    await ctx.newExif({ assetId: secondAsset.id, make: 'secondAsset' });
+    const { asset: album1Asset } = await ctx.newAsset({ ownerId: user2.id, originalFileName: 'album1Asset' });
+    await ctx.newExif({ assetId: album1Asset.id, make: 'album1Asset' });
+    const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
+    const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: firstAsset.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album1.id, assetId: album1Asset.id });
+    await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const firstAlbumResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(firstAlbumResponse).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: album1Asset.id,
+        }),
+        type: SyncEntityType.AlbumAssetExifCreateV1,
+      },
+    ]);
+    expect(firstAlbumResponse).toHaveLength(2);
+
+    await ctx.syncAckAll(auth, firstAlbumResponse);
+
+    await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(response).toEqual([
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: firstAsset.id,
+        }),
+        type: SyncEntityType.AlbumAssetExifBackfillV1,
+      },
+      backfillSyncAck,
+    ]);
+    expect(response).toHaveLength(2);
+
+    //  ack initial album asset sync
+    await ctx.syncAckAll(auth, response);
+
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: secondAsset.id });
+    await wait(2);
+
+    // should backfill the new asset even though it's older than the first asset
+    const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(newResponse).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: secondAsset.id,
+        }),
+        type: SyncEntityType.AlbumAssetExifCreateV1,
+      },
+    ]);
+    expect(newResponse).toHaveLength(2);
+
+    await ctx.syncAckAll(auth, newResponse);
+    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([]);
+  });
+
+  it('should sync asset exif updates for an album shared with you', async () => {
+    const { auth, ctx } = await setup();
+    const { user: user2 } = await ctx.newUser();
+    const { asset } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newExif({ assetId: asset.id, make: 'asset' });
+    const { album } = await ctx.newAlbum({ ownerId: user2.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+    await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(response).toHaveLength(2);
+    expect(response).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: asset.id,
+        }),
+        type: SyncEntityType.AlbumAssetExifCreateV1,
+      },
+    ]);
+
+    await ctx.syncAckAll(auth, response);
+
+    // update the asset
+    const assetRepository = ctx.get(AssetRepository);
+    await assetRepository.upsertExif({
+      assetId: asset.id,
+      city: 'New City',
+    });
+
+    const updateResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(updateResponse).toHaveLength(1);
+    expect(updateResponse).toEqual([
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: asset.id,
+          city: 'New City',
+        }),
+        type: SyncEntityType.AlbumAssetExifUpdateV1,
+      },
+    ]);
+  });
+
+  it('should sync delayed asset exif creates for an album shared with you', async () => {
+    const { auth, ctx } = await setup();
+    const { user: user2 } = await ctx.newUser();
+    const { asset: assetWithExif } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newExif({ assetId: assetWithExif.id, make: 'assetWithExif' });
+    const { asset: assetDelayedExif } = await ctx.newAsset({ ownerId: user2.id });
+    const { album } = await ctx.newAlbum({ ownerId: user2.id });
+    const { asset: newerAsset } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newExif({ assetId: newerAsset.id, make: 'newerAsset' });
+    await ctx.newAlbumAsset({ albumId: album.id, assetId: assetWithExif.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album.id, assetId: assetDelayedExif.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album.id, assetId: newerAsset.id });
+    await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(response).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: assetWithExif.id,
+        }),
+        type: SyncEntityType.AlbumAssetExifCreateV1,
+      },
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: newerAsset.id,
+        }),
+        type: SyncEntityType.AlbumAssetExifCreateV1,
+      },
+    ]);
+    expect(response).toHaveLength(3);
+
+    await ctx.syncAckAll(auth, response);
+
+    // update the asset
+    const assetRepository = ctx.get(AssetRepository);
+    await assetRepository.upsertExif({
+      assetId: assetDelayedExif.id,
+      city: 'Delayed Exif',
+    });
+
+    const updateResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1]);
+    expect(updateResponse).toEqual([
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          assetId: assetDelayedExif.id,
+          city: 'Delayed Exif',
+        }),
+        type: SyncEntityType.AlbumAssetExifUpdateV1,
+      },
+    ]);
+    expect(updateResponse).toHaveLength(1);
+  });
 });

server/test/medium/specs/sync/sync-album-asset.spec.ts

@@ -1,5 +1,6 @@
 import { Kysely } from 'kysely';
 import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
+import { AssetRepository } from 'src/repositories/asset.repository';
 import { DB } from 'src/schema';
 import { SyncTestContext } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
@@ -13,6 +14,18 @@ const setup = async (db?: Kysely<DB>) => {
   return { auth, user, session, ctx };
 };
 
+const updateSyncAck = {
+  ack: expect.stringContaining(SyncEntityType.AlbumAssetUpdateV1),
+  data: {},
+  type: SyncEntityType.SyncAckV1,
+};
+
+const backfillSyncAck = {
+  ack: expect.stringContaining(SyncEntityType.AlbumAssetBackfillV1),
+  data: {},
+  type: SyncEntityType.SyncAckV1,
+};
+
 beforeAll(async () => {
   defaultDatabase = await getKyselyDB();
 });
@@ -45,8 +58,9 @@ describe(SyncRequestType.AlbumAssetsV1, () => {
     await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.Editor });
 
     const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
-    expect(response).toHaveLength(1);
+    expect(response).toHaveLength(2);
     expect(response).toEqual([
+      updateSyncAck,
       {
         ack: expect.any(String),
         data: {
@@ -67,7 +81,7 @@ describe(SyncRequestType.AlbumAssetsV1, () => {
           stackId: asset.stackId,
           libraryId: asset.libraryId,
         },
-        type: SyncEntityType.AlbumAssetV1,
+        type: SyncEntityType.AlbumAssetCreateV1,
       },
     ]);
 
@@ -82,7 +96,7 @@ describe(SyncRequestType.AlbumAssetsV1, () => {
     await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
 
     await expect(ctx.syncStream(auth, [SyncRequestType.AssetsV1])).resolves.toHaveLength(1);
-    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toHaveLength(1);
+    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toHaveLength(2);
   });
 
   it('should not sync album asset for unrelated user', async () => {
@@ -103,52 +117,42 @@ describe(SyncRequestType.AlbumAssetsV1, () => {
   it('should backfill album assets when a user shares an album with you', async () => {
     const { auth, ctx } = await setup();
     const { user: user2 } = await ctx.newUser();
-    const { asset: asset1Owner } = await ctx.newAsset({ ownerId: auth.user.id });
-    await wait(2);
+    const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
+    const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
     const { asset: asset1User2 } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: asset1User2.id });
     await wait(2);
     const { asset: asset2User2 } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: asset2User2.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album1.id, assetId: asset2User2.id });
     await wait(2);
     const { asset: asset3User2 } = await ctx.newAsset({ ownerId: user2.id });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: asset3User2.id });
     await wait(2);
-    const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
-    await ctx.newAlbumAsset({ albumId: album1.id, assetId: asset2User2.id });
     await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.Editor });
 
     const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
-    expect(response).toHaveLength(1);
+    expect(response).toHaveLength(2);
     expect(response).toEqual([
+      updateSyncAck,
       {
         ack: expect.any(String),
         data: expect.objectContaining({
           id: asset2User2.id,
         }),
-        type: SyncEntityType.AlbumAssetV1,
+        type: SyncEntityType.AlbumAssetCreateV1,
       },
     ]);
 
     // ack initial album asset sync
     await ctx.syncAckAll(auth, response);
 
-    // create a second album
-    const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
-    await Promise.all(
-      [asset1User2.id, asset2User2.id, asset3User2.id, asset1Owner.id].map((assetId) =>
-        ctx.newAlbumAsset({ albumId: album2.id, assetId }),
-      ),
-    );
     await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.Editor });
 
     // should backfill the album user
     const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
     expect(newResponse).toEqual([
-      {
-        ack: expect.any(String),
-        data: expect.objectContaining({
-          id: asset1Owner.id,
-        }),
-        type: SyncEntityType.AlbumAssetBackfillV1,
-      },
       {
         ack: expect.any(String),
         data: expect.objectContaining({
@@ -163,21 +167,129 @@ describe(SyncRequestType.AlbumAssetsV1, () => {
         }),
         type: SyncEntityType.AlbumAssetBackfillV1,
       },
-      {
-        ack: expect.stringContaining(SyncEntityType.AlbumAssetBackfillV1),
-        data: {},
-        type: SyncEntityType.SyncAckV1,
-      },
+      backfillSyncAck,
+      updateSyncAck,
       {
         ack: expect.any(String),
         data: expect.objectContaining({
           id: asset3User2.id,
         }),
-        type: SyncEntityType.AlbumAssetV1,
+        type: SyncEntityType.AlbumAssetCreateV1,
       },
     ]);
 
     await ctx.syncAckAll(auth, newResponse);
     await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toEqual([]);
   });
+
+  it('should sync old assets when a user adds them to an album they share you', async () => {
+    const { auth, ctx } = await setup();
+    const { user: user2 } = await ctx.newUser();
+    const { asset: firstAsset } = await ctx.newAsset({ ownerId: user2.id, originalFileName: 'firstAsset' });
+    const { asset: secondAsset } = await ctx.newAsset({ ownerId: user2.id, originalFileName: 'secondAsset' });
+    const { asset: album1Asset } = await ctx.newAsset({ ownerId: user2.id, originalFileName: 'album1Asset' });
+    const { album: album1 } = await ctx.newAlbum({ ownerId: user2.id });
+    const { album: album2 } = await ctx.newAlbum({ ownerId: user2.id });
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: firstAsset.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album1.id, assetId: album1Asset.id });
+    await ctx.newAlbumUser({ albumId: album1.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const firstAlbumResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+    expect(firstAlbumResponse).toHaveLength(2);
+    expect(firstAlbumResponse).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          id: album1Asset.id,
+        }),
+        type: SyncEntityType.AlbumAssetCreateV1,
+      },
+    ]);
+
+    await ctx.syncAckAll(auth, firstAlbumResponse);
+
+    await ctx.newAlbumUser({ albumId: album2.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+    // expect(response).toHaveLength(2);
+    expect(response).toEqual([
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          id: firstAsset.id,
+        }),
+        type: SyncEntityType.AlbumAssetBackfillV1,
+      },
+      backfillSyncAck,
+    ]);
+
+    //  ack initial album asset sync
+    await ctx.syncAckAll(auth, response);
+
+    await ctx.newAlbumAsset({ albumId: album2.id, assetId: secondAsset.id });
+    await wait(2);
+
+    // should backfill the new asset even though it's older than the first asset
+    const newResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+    expect(newResponse).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          id: secondAsset.id,
+        }),
+        type: SyncEntityType.AlbumAssetCreateV1,
+      },
+    ]);
+
+    await ctx.syncAckAll(auth, newResponse);
+    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1])).resolves.toEqual([]);
+  });
+
+  it('should sync asset updates for an album shared with you', async () => {
+    const { auth, ctx } = await setup();
+    const { user: user2 } = await ctx.newUser();
+    const { asset } = await ctx.newAsset({ ownerId: user2.id, isFavorite: false });
+    const { album } = await ctx.newAlbum({ ownerId: user2.id });
+    await wait(2);
+    await ctx.newAlbumAsset({ albumId: album.id, assetId: asset.id });
+    await ctx.newAlbumUser({ albumId: album.id, userId: auth.user.id, role: AlbumUserRole.Editor });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+    expect(response).toHaveLength(2);
+    expect(response).toEqual([
+      updateSyncAck,
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          id: asset.id,
+        }),
+        type: SyncEntityType.AlbumAssetCreateV1,
+      },
+    ]);
+
+    await ctx.syncAckAll(auth, response);
+
+    // update the asset
+    const assetRepository = ctx.get(AssetRepository);
+    await assetRepository.update({
+      id: asset.id,
+      isFavorite: true,
+    });
+
+    const updateResponse = await ctx.syncStream(auth, [SyncRequestType.AlbumAssetsV1]);
+    expect(updateResponse).toHaveLength(1);
+    expect(updateResponse).toEqual([
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          id: asset.id,
+          isFavorite: true,
+        }),
+        type: SyncEntityType.AlbumAssetUpdateV1,
+      },
+    ]);
+  });
 });

server/test/utils.ts

@@ -446,6 +446,16 @@ export async function* makeStream<T>(items: T[] = []): AsyncIterableIterator<T>
   }
 }
 
-export const wait = (ms: number) => {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+export const wait = (ms: number): Promise<void> => {
+  return new Promise((resolve) => {
+    const target = performance.now() + ms;
+    const checkDone = () => {
+      if (performance.now() >= target) {
+        resolve();
+      } else {
+        setTimeout(checkDone, 1); // Check again after 1ms
+      }
+    };
+    setTimeout(checkDone, ms);
+  });
 };