fix(server): searching with both `personIds` and `withPeople` (#13254)

* use cte

* linting

server/src/repositories/search.repository.ts

@@ -26,7 +26,7 @@ import { asVector, searchAssetBuilder } from 'src/utils/database';
 import { Instrumentation } from 'src/utils/instrumentation';
 import { Paginated, PaginationResult, paginatedBuilder } from 'src/utils/pagination';
 import { isValidInteger } from 'src/validation';
-import { Repository, SelectQueryBuilder } from 'typeorm';
+import { Repository } from 'typeorm';
 
 @Instrumentation()
 @Injectable()
@@ -113,14 +113,6 @@ export class SearchRepository implements ISearchRepository {
     return assets1;
   }
 
-  private createPersonFilter(builder: SelectQueryBuilder<AssetFaceEntity>, personIds: string[]) {
-    return builder
-      .select(`${builder.alias}."assetId"`)
-      .where(`${builder.alias}."personId" IN (:...personIds)`, { personIds })
-      .groupBy(`${builder.alias}."assetId"`)
-      .having(`COUNT(DISTINCT ${builder.alias}."personId") = :personCount`, { personCount: personIds.length });
-  }
-
   @GenerateSql({
     params: [
       { page: 1, size: 100 },
@@ -136,21 +128,12 @@ export class SearchRepository implements ISearchRepository {
   })
   async searchSmart(
     pagination: SearchPaginationOptions,
-    { embedding, userIds, personIds, ...options }: SmartSearchOptions,
+    { embedding, userIds, ...options }: SmartSearchOptions,
   ): Paginated<AssetEntity> {
     let results: PaginationResult<AssetEntity> = { items: [], hasNextPage: false };
 
     await this.assetRepository.manager.transaction(async (manager) => {
       let builder = manager.createQueryBuilder(AssetEntity, 'asset');
-
-      if (personIds?.length) {
-        const assetFaceBuilder = manager.createQueryBuilder(AssetFaceEntity, 'asset_face');
-        const cte = this.createPersonFilter(assetFaceBuilder, personIds);
-        builder
-          .addCommonTableExpression(cte, 'asset_face_ids')
-          .innerJoin('asset_face_ids', 'a', 'a."assetId" = asset.id');
-      }
-
       builder = searchAssetBuilder(builder, options);
       builder
         .innerJoin('asset.smartSearch', 'search')

server/src/utils/database.ts

@@ -1,4 +1,5 @@
 import _ from 'lodash';
+import { AssetFaceEntity } from 'src/entities/asset-face.entity';
 import { AssetEntity } from 'src/entities/asset.entity';
 import { AssetSearchBuilderOptions } from 'src/interfaces/search.interface';
 import { Between, IsNull, LessThanOrEqual, MoreThanOrEqual, Not, SelectQueryBuilder } from 'typeorm';
@@ -91,7 +92,6 @@ export function searchAssetBuilder(
     withPeople,
     withSmartInfo,
     personIds,
-    withExif,
     withStacked,
     trashedAfter,
     trashedBefore,
@@ -128,15 +128,14 @@ export function searchAssetBuilder(
   }
 
   if (personIds && personIds.length > 0) {
-    builder
-      .leftJoin(`${builder.alias}.faces`, 'faces')
-      .andWhere('faces.personId IN (:...personIds)', { personIds })
-      .addGroupBy(`${builder.alias}.id`)
-      .having('COUNT(DISTINCT faces.personId) = :personCount', { personCount: personIds.length });
-
-    if (withExif) {
-      builder.addGroupBy('exifInfo.assetId');
-    }
+    const cte = builder
+      .createQueryBuilder()
+      .select('faces."assetId"')
+      .from(AssetFaceEntity, 'faces')
+      .where('faces."personId" IN (:...personIds)', { personIds })
+      .groupBy(`faces."assetId"`)
+      .having(`COUNT(DISTINCT faces."personId") = :personCount`, { personCount: personIds.length });
+    builder.addCommonTableExpression(cte, 'face_ids').innerJoin('face_ids', 'a', 'a."assetId" = asset.id');
   }
 
   if (withStacked) {