feat: asset face sync (#20048)

* chore: remove thumbnailPath from person sync dto

* feat: asset face sync

server/test/fixtures/face.stub.ts

@@ -23,6 +23,8 @@ export const faceStub = {
     sourceType: SourceType.MachineLearning,
     faceSearch: { faceId: 'assetFaceId1', embedding: '[1, 2, 3, 4]' },
     deletedAt: new Date(),
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   primaryFace1: Object.freeze({
     id: 'assetFaceId2',
@@ -39,6 +41,8 @@ export const faceStub = {
     sourceType: SourceType.MachineLearning,
     faceSearch: { faceId: 'assetFaceId2', embedding: '[1, 2, 3, 4]' },
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   mergeFace1: Object.freeze({
     id: 'assetFaceId3',
@@ -55,6 +59,8 @@ export const faceStub = {
     sourceType: SourceType.MachineLearning,
     faceSearch: { faceId: 'assetFaceId3', embedding: '[1, 2, 3, 4]' },
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   noPerson1: Object.freeze({
     id: 'assetFaceId8',
@@ -71,6 +77,8 @@ export const faceStub = {
     sourceType: SourceType.MachineLearning,
     faceSearch: { faceId: 'assetFaceId8', embedding: '[1, 2, 3, 4]' },
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   noPerson2: Object.freeze({
     id: 'assetFaceId9',
@@ -87,6 +95,8 @@ export const faceStub = {
     sourceType: SourceType.MachineLearning,
     faceSearch: { faceId: 'assetFaceId9', embedding: '[1, 2, 3, 4]' },
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   fromExif1: Object.freeze({
     id: 'assetFaceId9',
@@ -102,6 +112,8 @@ export const faceStub = {
     imageWidth: 400,
     sourceType: SourceType.Exif,
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   fromExif2: Object.freeze({
     id: 'assetFaceId9',
@@ -117,6 +129,8 @@ export const faceStub = {
     imageWidth: 1024,
     sourceType: SourceType.Exif,
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
   withBirthDate: Object.freeze({
     id: 'assetFaceId10',
@@ -132,5 +146,7 @@ export const faceStub = {
     imageWidth: 1024,
     sourceType: SourceType.MachineLearning,
     deletedAt: null,
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
   }),
 };

server/test/medium.factory.ts

@@ -154,6 +154,12 @@ export class MediumTestContext<S extends BaseService = BaseService> {
     return { asset, result };
   }
 
+  async newAssetFace(dto: Partial<Insertable<AssetFace>> & { assetId: string }) {
+    const assetFace = mediumFactory.assetFaceInsert(dto);
+    const result = await this.get(PersonRepository).createAssetFace(assetFace);
+    return { assetFace, result };
+  }
+
   async newMemory(dto: Partial<Insertable<MemoryTable>> = {}) {
     const memory = mediumFactory.memoryInsert(dto);
     const result = await this.get(MemoryRepository).create(memory, new Set<string>());

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

@@ -0,0 +1,92 @@
+import { Kysely } from 'kysely';
+import { SyncEntityType, SyncRequestType } from 'src/enum';
+import { PersonRepository } from 'src/repositories/person.repository';
+import { DB } from 'src/schema';
+import { SyncTestContext } from 'test/medium.factory';
+import { factory } from 'test/small.factory';
+import { getKyselyDB } from 'test/utils';
+
+let defaultDatabase: Kysely<DB>;
+
+const setup = async (db?: Kysely<DB>) => {
+  const ctx = new SyncTestContext(db || defaultDatabase);
+  const { auth, user, session } = await ctx.newSyncAuthUser();
+  return { auth, user, session, ctx };
+};
+
+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(SyncEntityType.AssetFaceV1, () => {
+  it('should detect and sync the first asset face', async () => {
+    const { auth, ctx } = await setup();
+    const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+    const { person } = await ctx.newPerson({ ownerId: auth.user.id });
+    const { assetFace } = await ctx.newAssetFace({ assetId: asset.id, personId: person.id });
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AssetFacesV1]);
+    expect(response).toHaveLength(1);
+    expect(response).toEqual([
+      {
+        ack: expect.any(String),
+        data: expect.objectContaining({
+          id: assetFace.id,
+          assetId: asset.id,
+          personId: person.id,
+          imageWidth: assetFace.imageWidth,
+          imageHeight: assetFace.imageHeight,
+          boundingBoxX1: assetFace.boundingBoxX1,
+          boundingBoxY1: assetFace.boundingBoxY1,
+          boundingBoxX2: assetFace.boundingBoxX2,
+          boundingBoxY2: assetFace.boundingBoxY2,
+          sourceType: assetFace.sourceType,
+        }),
+        type: 'AssetFaceV1',
+      },
+    ]);
+
+    await ctx.syncAckAll(auth, response);
+    await expect(ctx.syncStream(auth, [SyncRequestType.AssetFacesV1])).resolves.toEqual([]);
+  });
+
+  it('should detect and sync a deleted asset face', async () => {
+    const { auth, ctx } = await setup();
+    const personRepo = ctx.get(PersonRepository);
+    const { asset } = await ctx.newAsset({ ownerId: auth.user.id });
+    const { assetFace } = await ctx.newAssetFace({ assetId: asset.id });
+    await personRepo.deleteAssetFace(assetFace.id);
+
+    const response = await ctx.syncStream(auth, [SyncRequestType.AssetFacesV1]);
+    expect(response).toHaveLength(1);
+    expect(response).toEqual([
+      {
+        ack: expect.any(String),
+        data: {
+          assetFaceId: assetFace.id,
+        },
+        type: 'AssetFaceDeleteV1',
+      },
+    ]);
+
+    await ctx.syncAckAll(auth, response);
+    await expect(ctx.syncStream(auth, [SyncRequestType.AssetFacesV1])).resolves.toEqual([]);
+  });
+
+  it('should not sync an asset face or asset face delete for an unrelated user', async () => {
+    const { auth, ctx } = await setup();
+    const personRepo = ctx.get(PersonRepository);
+    const { user: user2 } = await ctx.newUser();
+    const { session } = await ctx.newSession({ userId: user2.id });
+    const { asset } = await ctx.newAsset({ ownerId: user2.id });
+    const { assetFace } = await ctx.newAssetFace({ assetId: asset.id });
+    const auth2 = factory.auth({ session, user: user2 });
+
+    expect(await ctx.syncStream(auth2, [SyncRequestType.AssetFacesV1])).toHaveLength(1);
+    expect(await ctx.syncStream(auth, [SyncRequestType.AssetFacesV1])).toHaveLength(0);
+
+    await personRepo.deleteAssetFace(assetFace.id);
+    expect(await ctx.syncStream(auth2, [SyncRequestType.AssetFacesV1])).toHaveLength(1);
+    expect(await ctx.syncStream(auth, [SyncRequestType.AssetFacesV1])).toHaveLength(0);
+  });
+});

server/test/medium/specs/sync/sync-person.spec.ts

@@ -31,7 +31,6 @@ describe(SyncEntityType.PersonV1, () => {
         data: expect.objectContaining({
           id: person.id,
           name: person.name,
-          thumbnailPath: person.thumbnailPath,
           isHidden: person.isHidden,
           birthDate: person.birthDate,
           faceAssetId: person.faceAssetId,