refactor(server)*: tsconfigs (#2689)

* refactor(server): tsconfigs

* chore: dummy commit

* fix: start.sh

* chore: restore original entry scripts

server/src/domain/search/dto/index.ts

@@ -0,0 +1 @@
+export * from './search.dto';

server/src/domain/search/dto/search.dto.ts

@@ -0,0 +1,82 @@
+import { AssetType } from '@app/infra/entities';
+import { Transform } from 'class-transformer';
+import { IsArray, IsBoolean, IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import { toBoolean } from '@app/immich/utils/transform.util';
+
+export class SearchDto {
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  q?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  query?: string;
+
+  @IsBoolean()
+  @IsOptional()
+  @Transform(toBoolean)
+  clip?: boolean;
+
+  @IsEnum(AssetType)
+  @IsOptional()
+  type?: AssetType;
+
+  @IsBoolean()
+  @IsOptional()
+  @Transform(toBoolean)
+  isFavorite?: boolean;
+
+  @IsBoolean()
+  @IsOptional()
+  @Transform(toBoolean)
+  isArchived?: boolean;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  'exifInfo.city'?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  'exifInfo.state'?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  'exifInfo.country'?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  'exifInfo.make'?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @IsOptional()
+  'exifInfo.model'?: string;
+
+  @IsString({ each: true })
+  @IsArray()
+  @IsOptional()
+  @Transform(({ value }) => value.split(','))
+  'smartInfo.objects'?: string[];
+
+  @IsString({ each: true })
+  @IsArray()
+  @IsOptional()
+  @Transform(({ value }) => value.split(','))
+  'smartInfo.tags'?: string[];
+
+  @IsBoolean()
+  @IsOptional()
+  @Transform(toBoolean)
+  recent?: boolean;
+
+  @IsBoolean()
+  @IsOptional()
+  @Transform(toBoolean)
+  motion?: boolean;
+}

server/src/domain/search/index.ts

@@ -0,0 +1,4 @@
+export * from './dto';
+export * from './response-dto';
+export * from './search.repository';
+export * from './search.service';

server/src/domain/search/response-dto/index.ts

@@ -0,0 +1,3 @@
+export * from './search-config-response.dto';
+export * from './search-explore.response.dto';
+export * from './search-response.dto';

server/src/domain/search/response-dto/search-config-response.dto.ts

@@ -0,0 +1,3 @@
+export class SearchConfigResponseDto {
+  enabled!: boolean;
+}

server/src/domain/search/response-dto/search-explore.response.dto.ts

@@ -0,0 +1,11 @@
+import { AssetResponseDto } from '../../asset';
+
+class SearchExploreItem {
+  value!: string;
+  data!: AssetResponseDto;
+}
+
+export class SearchExploreResponseDto {
+  fieldName!: string;
+  items!: SearchExploreItem[];
+}

server/src/domain/search/response-dto/search-response.dto.ts

@@ -0,0 +1,37 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { AlbumResponseDto } from '../../album';
+import { AssetResponseDto } from '../../asset';
+
+class SearchFacetCountResponseDto {
+  @ApiProperty({ type: 'integer' })
+  count!: number;
+  value!: string;
+}
+
+class SearchFacetResponseDto {
+  fieldName!: string;
+  counts!: SearchFacetCountResponseDto[];
+}
+
+class SearchAlbumResponseDto {
+  @ApiProperty({ type: 'integer' })
+  total!: number;
+  @ApiProperty({ type: 'integer' })
+  count!: number;
+  items!: AlbumResponseDto[];
+  facets!: SearchFacetResponseDto[];
+}
+
+class SearchAssetResponseDto {
+  @ApiProperty({ type: 'integer' })
+  total!: number;
+  @ApiProperty({ type: 'integer' })
+  count!: number;
+  items!: AssetResponseDto[];
+  facets!: SearchFacetResponseDto[];
+}
+
+export class SearchResponseDto {
+  albums!: SearchAlbumResponseDto;
+  assets!: SearchAssetResponseDto;
+}

server/src/domain/search/search.repository.ts

@@ -0,0 +1,96 @@
+import { AlbumEntity, AssetEntity, AssetFaceEntity, AssetType } from '@app/infra/entities';
+
+export enum SearchCollection {
+  ASSETS = 'assets',
+  ALBUMS = 'albums',
+  FACES = 'faces',
+}
+
+export enum SearchStrategy {
+  CLIP = 'CLIP',
+  TEXT = 'TEXT',
+}
+
+export interface SearchFaceFilter {
+  ownerId: string;
+}
+
+export interface SearchFilter {
+  id?: string;
+  userId: string;
+  type?: AssetType;
+  isFavorite?: boolean;
+  isArchived?: boolean;
+  city?: string;
+  state?: string;
+  country?: string;
+  make?: string;
+  model?: string;
+  objects?: string[];
+  tags?: string[];
+  recent?: boolean;
+  motion?: boolean;
+  debug?: boolean;
+}
+
+export interface SearchResult<T> {
+  /** total matches */
+  total: number;
+  /** collection size */
+  count: number;
+  /** current page */
+  page: number;
+  /** items for page */
+  items: T[];
+  /** score */
+  distances: number[];
+  facets: SearchFacet[];
+}
+
+export interface SearchFacet {
+  fieldName: string;
+  counts: Array<{
+    count: number;
+    value: string;
+  }>;
+}
+
+export interface SearchExploreItem<T> {
+  fieldName: string;
+  items: Array<{
+    value: string;
+    data: T;
+  }>;
+}
+
+export type OwnedFaceEntity = Pick<AssetFaceEntity, 'assetId' | 'personId' | 'embedding'> & {
+  /** computed as assetId|personId */
+  id: string;
+  /** copied from asset.id */
+  ownerId: string;
+};
+
+export type SearchCollectionIndexStatus = Record<SearchCollection, boolean>;
+
+export const ISearchRepository = 'ISearchRepository';
+
+export interface ISearchRepository {
+  setup(): Promise<void>;
+  checkMigrationStatus(): Promise<SearchCollectionIndexStatus>;
+
+  importAlbums(items: AlbumEntity[], done: boolean): Promise<void>;
+  importAssets(items: AssetEntity[], done: boolean): Promise<void>;
+  importFaces(items: OwnedFaceEntity[], done: boolean): Promise<void>;
+
+  deleteAlbums(ids: string[]): Promise<void>;
+  deleteAssets(ids: string[]): Promise<void>;
+  deleteFaces(ids: string[]): Promise<void>;
+  deleteAllFaces(): Promise<number>;
+
+  searchAlbums(query: string, filters: SearchFilter): Promise<SearchResult<AlbumEntity>>;
+  searchAssets(query: string, filters: SearchFilter): Promise<SearchResult<AssetEntity>>;
+  vectorSearch(query: number[], filters: SearchFilter): Promise<SearchResult<AssetEntity>>;
+  searchFaces(query: number[], filters: SearchFaceFilter): Promise<SearchResult<AssetFaceEntity>>;
+
+  explore(userId: string): Promise<SearchExploreItem<AssetEntity>[]>;
+}

server/src/domain/search/search.service.spec.ts

@@ -0,0 +1,392 @@
+import { BadRequestException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { plainToInstance } from 'class-transformer';
+import {
+  albumStub,
+  assetEntityStub,
+  asyncTick,
+  authStub,
+  faceStub,
+  newAlbumRepositoryMock,
+  newAssetRepositoryMock,
+  newFaceRepositoryMock,
+  newJobRepositoryMock,
+  newMachineLearningRepositoryMock,
+  newSearchRepositoryMock,
+  searchStub,
+} from '@test';
+import { IAlbumRepository } from '../album/album.repository';
+import { IAssetRepository } from '../asset/asset.repository';
+import { IFaceRepository } from '../facial-recognition';
+import { JobName } from '../job';
+import { IJobRepository } from '../job/job.repository';
+import { IMachineLearningRepository } from '../smart-info';
+import { SearchDto } from './dto';
+import { ISearchRepository } from './search.repository';
+import { SearchService } from './search.service';
+
+jest.useFakeTimers();
+
+describe(SearchService.name, () => {
+  let sut: SearchService;
+  let albumMock: jest.Mocked<IAlbumRepository>;
+  let assetMock: jest.Mocked<IAssetRepository>;
+  let faceMock: jest.Mocked<IFaceRepository>;
+  let jobMock: jest.Mocked<IJobRepository>;
+  let machineMock: jest.Mocked<IMachineLearningRepository>;
+  let searchMock: jest.Mocked<ISearchRepository>;
+  let configMock: jest.Mocked<ConfigService>;
+
+  const makeSut = (value?: string) => {
+    if (value) {
+      configMock.get.mockReturnValue(value);
+    }
+    return new SearchService(albumMock, assetMock, faceMock, jobMock, machineMock, searchMock, configMock);
+  };
+
+  beforeEach(() => {
+    albumMock = newAlbumRepositoryMock();
+    assetMock = newAssetRepositoryMock();
+    faceMock = newFaceRepositoryMock();
+    jobMock = newJobRepositoryMock();
+    machineMock = newMachineLearningRepositoryMock();
+    searchMock = newSearchRepositoryMock();
+    configMock = { get: jest.fn() } as unknown as jest.Mocked<ConfigService>;
+
+    sut = makeSut();
+  });
+
+  afterEach(() => {
+    sut.teardown();
+  });
+
+  it('should work', () => {
+    expect(sut).toBeDefined();
+  });
+
+  describe('request dto', () => {
+    it('should convert smartInfo.tags to a string list', () => {
+      const instance = plainToInstance(SearchDto, { 'smartInfo.tags': 'a,b,c' });
+      expect(instance['smartInfo.tags']).toEqual(['a', 'b', 'c']);
+    });
+
+    it('should handle empty smartInfo.tags', () => {
+      const instance = plainToInstance(SearchDto, {});
+      expect(instance['smartInfo.tags']).toBeUndefined();
+    });
+
+    it('should convert smartInfo.objects to a string list', () => {
+      const instance = plainToInstance(SearchDto, { 'smartInfo.objects': 'a,b,c' });
+      expect(instance['smartInfo.objects']).toEqual(['a', 'b', 'c']);
+    });
+
+    it('should handle empty smartInfo.objects', () => {
+      const instance = plainToInstance(SearchDto, {});
+      expect(instance['smartInfo.objects']).toBeUndefined();
+    });
+  });
+
+  describe('isEnabled', () => {
+    it('should be enabled by default', () => {
+      expect(sut.isEnabled()).toBe(true);
+    });
+
+    it('should be disabled via an env variable', () => {
+      const sut = makeSut('false');
+
+      expect(sut.isEnabled()).toBe(false);
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return the config', () => {
+      expect(sut.getConfig()).toEqual({ enabled: true });
+    });
+
+    it('should return the config when search is disabled', () => {
+      const sut = makeSut('false');
+
+      expect(sut.getConfig()).toEqual({ enabled: false });
+    });
+  });
+
+  describe(`init`, () => {
+    it('should skip when search is disabled', async () => {
+      const sut = makeSut('false');
+
+      await sut.init();
+
+      expect(searchMock.setup).not.toHaveBeenCalled();
+      expect(searchMock.checkMigrationStatus).not.toHaveBeenCalled();
+      expect(jobMock.queue).not.toHaveBeenCalled();
+
+      sut.teardown();
+    });
+
+    it('should skip schema migration if not needed', async () => {
+      searchMock.checkMigrationStatus.mockResolvedValue({ assets: false, albums: false, faces: false });
+      await sut.init();
+
+      expect(searchMock.setup).toHaveBeenCalled();
+      expect(jobMock.queue).not.toHaveBeenCalled();
+    });
+
+    it('should do schema migration if needed', async () => {
+      searchMock.checkMigrationStatus.mockResolvedValue({ assets: true, albums: true, faces: true });
+      await sut.init();
+
+      expect(searchMock.setup).toHaveBeenCalled();
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.SEARCH_INDEX_ASSETS }],
+        [{ name: JobName.SEARCH_INDEX_ALBUMS }],
+        [{ name: JobName.SEARCH_INDEX_FACES }],
+      ]);
+    });
+  });
+
+  describe('search', () => {
+    it('should throw an error is search is disabled', async () => {
+      const sut = makeSut('false');
+
+      await expect(sut.search(authStub.admin, {})).rejects.toBeInstanceOf(BadRequestException);
+
+      expect(searchMock.searchAlbums).not.toHaveBeenCalled();
+      expect(searchMock.searchAssets).not.toHaveBeenCalled();
+    });
+
+    it('should search assets and albums', async () => {
+      searchMock.searchAssets.mockResolvedValue(searchStub.emptyResults);
+      searchMock.searchAlbums.mockResolvedValue(searchStub.emptyResults);
+      searchMock.vectorSearch.mockResolvedValue(searchStub.emptyResults);
+
+      await expect(sut.search(authStub.admin, {})).resolves.toEqual({
+        albums: {
+          total: 0,
+          count: 0,
+          page: 1,
+          items: [],
+          facets: [],
+          distances: [],
+        },
+        assets: {
+          total: 0,
+          count: 0,
+          page: 1,
+          items: [],
+          facets: [],
+          distances: [],
+        },
+      });
+
+      // expect(searchMock.searchAssets).toHaveBeenCalledWith('*', { userId: authStub.admin.id });
+      expect(searchMock.searchAlbums).toHaveBeenCalledWith('*', { userId: authStub.admin.id });
+    });
+  });
+
+  describe('handleIndexAssets', () => {
+    it('should call done, even when there are no assets', async () => {
+      await sut.handleIndexAssets();
+
+      expect(searchMock.importAssets).toHaveBeenCalledWith([], true);
+    });
+
+    it('should index all the assets', async () => {
+      assetMock.getAll.mockResolvedValue({
+        items: [assetEntityStub.image],
+        hasNextPage: false,
+      });
+
+      await sut.handleIndexAssets();
+
+      expect(searchMock.importAssets.mock.calls).toEqual([
+        [[assetEntityStub.image], false],
+        [[], true],
+      ]);
+    });
+
+    it('should skip if search is disabled', async () => {
+      const sut = makeSut('false');
+
+      await sut.handleIndexAssets();
+
+      expect(searchMock.importAssets).not.toHaveBeenCalled();
+      expect(searchMock.importAlbums).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleIndexAsset', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleIndexAsset({ ids: [assetEntityStub.image.id] });
+    });
+
+    it('should index the asset', () => {
+      sut.handleIndexAsset({ ids: [assetEntityStub.image.id] });
+    });
+  });
+
+  describe('handleIndexAlbums', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleIndexAlbums();
+    });
+
+    it('should index all the albums', async () => {
+      albumMock.getAll.mockResolvedValue([albumStub.empty]);
+
+      await sut.handleIndexAlbums();
+
+      expect(searchMock.importAlbums).toHaveBeenCalledWith([albumStub.empty], true);
+    });
+  });
+
+  describe('handleIndexAlbum', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleIndexAlbum({ ids: [albumStub.empty.id] });
+    });
+
+    it('should index the album', () => {
+      sut.handleIndexAlbum({ ids: [albumStub.empty.id] });
+    });
+  });
+
+  describe('handleRemoveAlbum', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleRemoveAlbum({ ids: ['album1'] });
+    });
+
+    it('should remove the album', () => {
+      sut.handleRemoveAlbum({ ids: ['album1'] });
+    });
+  });
+
+  describe('handleRemoveAsset', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleRemoveAsset({ ids: ['asset1'] });
+    });
+
+    it('should remove the asset', () => {
+      sut.handleRemoveAsset({ ids: ['asset1'] });
+    });
+  });
+
+  describe('handleIndexFaces', () => {
+    it('should call done, even when there are no faces', async () => {
+      faceMock.getAll.mockResolvedValue([]);
+
+      await sut.handleIndexFaces();
+
+      expect(searchMock.importFaces).toHaveBeenCalledWith([], true);
+    });
+
+    it('should index all the faces', async () => {
+      faceMock.getAll.mockResolvedValue([faceStub.face1]);
+
+      await sut.handleIndexFaces();
+
+      expect(searchMock.importFaces.mock.calls).toEqual([
+        [
+          [
+            {
+              id: 'asset-id|person-1',
+              ownerId: 'user-id',
+              assetId: 'asset-id',
+              personId: 'person-1',
+              embedding: [1, 2, 3, 4],
+            },
+          ],
+          false,
+        ],
+        [[], true],
+      ]);
+    });
+
+    it('should skip if search is disabled', async () => {
+      const sut = makeSut('false');
+
+      await sut.handleIndexFaces();
+
+      expect(searchMock.importFaces).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('handleIndexAsset', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleIndexFace({ assetId: 'asset-1', personId: 'person-1' });
+
+      expect(searchMock.importFaces).not.toHaveBeenCalled();
+      expect(faceMock.getByIds).not.toHaveBeenCalled();
+    });
+
+    it('should index the face', () => {
+      faceMock.getByIds.mockResolvedValue([faceStub.face1]);
+
+      sut.handleIndexFace({ assetId: 'asset-1', personId: 'person-1' });
+
+      expect(faceMock.getByIds).toHaveBeenCalledWith([{ assetId: 'asset-1', personId: 'person-1' }]);
+    });
+  });
+
+  describe('handleRemoveFace', () => {
+    it('should skip if search is disabled', () => {
+      const sut = makeSut('false');
+      sut.handleRemoveFace({ assetId: 'asset-1', personId: 'person-1' });
+    });
+
+    it('should remove the face', () => {
+      sut.handleRemoveFace({ assetId: 'asset-1', personId: 'person-1' });
+    });
+  });
+
+  describe('flush', () => {
+    it('should flush queued album updates', async () => {
+      albumMock.getByIds.mockResolvedValue([albumStub.empty]);
+
+      sut.handleIndexAlbum({ ids: ['album1'] });
+
+      jest.runOnlyPendingTimers();
+
+      await asyncTick(4);
+
+      expect(albumMock.getByIds).toHaveBeenCalledWith(['album1']);
+      expect(searchMock.importAlbums).toHaveBeenCalledWith([albumStub.empty], false);
+    });
+
+    it('should flush queued album deletes', async () => {
+      sut.handleRemoveAlbum({ ids: ['album1'] });
+
+      jest.runOnlyPendingTimers();
+
+      await asyncTick(4);
+
+      expect(searchMock.deleteAlbums).toHaveBeenCalledWith(['album1']);
+    });
+
+    it('should flush queued asset updates', async () => {
+      assetMock.getByIds.mockResolvedValue([assetEntityStub.image]);
+
+      sut.handleIndexAsset({ ids: ['asset1'] });
+
+      jest.runOnlyPendingTimers();
+
+      await asyncTick(4);
+
+      expect(assetMock.getByIds).toHaveBeenCalledWith(['asset1']);
+      expect(searchMock.importAssets).toHaveBeenCalledWith([assetEntityStub.image], false);
+    });
+
+    it('should flush queued asset deletes', async () => {
+      sut.handleRemoveAsset({ ids: ['asset1'] });
+
+      jest.runOnlyPendingTimers();
+
+      await asyncTick(4);
+
+      expect(searchMock.deleteAssets).toHaveBeenCalledWith(['asset1']);
+    });
+  });
+});

server/src/domain/search/search.service.ts

@@ -0,0 +1,390 @@
+import { AlbumEntity, AssetEntity, AssetFaceEntity } from '@app/infra/entities';
+import { BadRequestException, Inject, Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { mapAlbum } from '../album';
+import { IAlbumRepository } from '../album/album.repository';
+import { AssetResponseDto, mapAsset } from '../asset';
+import { IAssetRepository } from '../asset/asset.repository';
+import { AuthUserDto } from '../auth';
+import { MACHINE_LEARNING_ENABLED } from '../domain.constant';
+import { usePagination } from '../domain.util';
+import { AssetFaceId, IFaceRepository } from '../facial-recognition';
+import { IAssetFaceJob, IBulkEntityJob, IJobRepository, JobName, JOBS_ASSET_PAGINATION_SIZE } from '../job';
+import { IMachineLearningRepository } from '../smart-info';
+import { SearchDto } from './dto';
+import { SearchConfigResponseDto, SearchResponseDto } from './response-dto';
+import {
+  ISearchRepository,
+  OwnedFaceEntity,
+  SearchCollection,
+  SearchExploreItem,
+  SearchResult,
+  SearchStrategy,
+} from './search.repository';
+
+interface SyncQueue {
+  upsert: Set<string>;
+  delete: Set<string>;
+}
+
+@Injectable()
+export class SearchService {
+  private logger = new Logger(SearchService.name);
+  private enabled: boolean;
+  private timer: NodeJS.Timer | null = null;
+
+  private albumQueue: SyncQueue = {
+    upsert: new Set(),
+    delete: new Set(),
+  };
+
+  private assetQueue: SyncQueue = {
+    upsert: new Set(),
+    delete: new Set(),
+  };
+
+  private faceQueue: SyncQueue = {
+    upsert: new Set(),
+    delete: new Set(),
+  };
+
+  constructor(
+    @Inject(IAlbumRepository) private albumRepository: IAlbumRepository,
+    @Inject(IAssetRepository) private assetRepository: IAssetRepository,
+    @Inject(IFaceRepository) private faceRepository: IFaceRepository,
+    @Inject(IJobRepository) private jobRepository: IJobRepository,
+    @Inject(IMachineLearningRepository) private machineLearning: IMachineLearningRepository,
+    @Inject(ISearchRepository) private searchRepository: ISearchRepository,
+    configService: ConfigService,
+  ) {
+    this.enabled = configService.get('TYPESENSE_ENABLED') !== 'false';
+    if (this.enabled) {
+      this.timer = setInterval(() => this.flush(), 5_000);
+    }
+  }
+
+  teardown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  isEnabled() {
+    return this.enabled;
+  }
+
+  getConfig(): SearchConfigResponseDto {
+    return {
+      enabled: this.enabled,
+    };
+  }
+
+  async init() {
+    if (!this.enabled) {
+      return;
+    }
+
+    this.logger.log('Running bootstrap');
+    await this.searchRepository.setup();
+
+    const migrationStatus = await this.searchRepository.checkMigrationStatus();
+    if (migrationStatus[SearchCollection.ASSETS]) {
+      this.logger.debug('Queueing job to re-index all assets');
+      await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ASSETS });
+    }
+    if (migrationStatus[SearchCollection.ALBUMS]) {
+      this.logger.debug('Queueing job to re-index all albums');
+      await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ALBUMS });
+    }
+    if (migrationStatus[SearchCollection.FACES]) {
+      this.logger.debug('Queueing job to re-index all faces');
+      await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_FACES });
+    }
+  }
+
+  async getExploreData(authUser: AuthUserDto): Promise<SearchExploreItem<AssetResponseDto>[]> {
+    this.assertEnabled();
+    const results = await this.searchRepository.explore(authUser.id);
+    const lookup = await this.getLookupMap(
+      results.reduce(
+        (ids: string[], result: SearchExploreItem<AssetEntity>) => [
+          ...ids,
+          ...result.items.map((item) => item.data.id),
+        ],
+        [],
+      ),
+    );
+
+    return results.map(({ fieldName, items }) => ({
+      fieldName,
+      items: items
+        .map(({ value, data }) => ({ value, data: lookup[data.id] }))
+        .filter(({ data }) => !!data)
+        .map(({ value, data }) => ({ value, data: mapAsset(data) })),
+    }));
+  }
+
+  async search(authUser: AuthUserDto, dto: SearchDto): Promise<SearchResponseDto> {
+    this.assertEnabled();
+
+    const query = dto.q || dto.query || '*';
+    const strategy = dto.clip && MACHINE_LEARNING_ENABLED ? SearchStrategy.CLIP : SearchStrategy.TEXT;
+    const filters = { userId: authUser.id, ...dto };
+
+    let assets: SearchResult<AssetEntity>;
+    switch (strategy) {
+      case SearchStrategy.CLIP:
+        const clip = await this.machineLearning.encodeText(query);
+        assets = await this.searchRepository.vectorSearch(clip, filters);
+        break;
+      case SearchStrategy.TEXT:
+      default:
+        assets = await this.searchRepository.searchAssets(query, filters);
+        break;
+    }
+
+    const albums = await this.searchRepository.searchAlbums(query, filters);
+    const lookup = await this.getLookupMap(assets.items.map((asset) => asset.id));
+
+    return {
+      albums: { ...albums, items: albums.items.map(mapAlbum) },
+      assets: {
+        ...assets,
+        items: assets.items
+          .map((item) => lookup[item.id])
+          .filter((item) => !!item)
+          .map(mapAsset),
+      },
+    };
+  }
+
+  async handleIndexAlbums() {
+    if (!this.enabled) {
+      return false;
+    }
+
+    const albums = this.patchAlbums(await this.albumRepository.getAll());
+    this.logger.log(`Indexing ${albums.length} albums`);
+    await this.searchRepository.importAlbums(albums, true);
+
+    return true;
+  }
+
+  async handleIndexAssets() {
+    if (!this.enabled) {
+      return false;
+    }
+
+    // TODO: do this in batches based on searchIndexVersion
+    const assetPagination = usePagination(JOBS_ASSET_PAGINATION_SIZE, (pagination) =>
+      this.assetRepository.getAll(pagination, { isVisible: true }),
+    );
+
+    for await (const assets of assetPagination) {
+      this.logger.debug(`Indexing ${assets.length} assets`);
+
+      const patchedAssets = this.patchAssets(assets);
+      await this.searchRepository.importAssets(patchedAssets, false);
+    }
+
+    await this.searchRepository.importAssets([], true);
+
+    this.logger.debug('Finished re-indexing all assets');
+
+    return false;
+  }
+
+  async handleIndexFaces() {
+    if (!this.enabled) {
+      return false;
+    }
+
+    // TODO: do this in batches based on searchIndexVersion
+    const faces = this.patchFaces(await this.faceRepository.getAll());
+    this.logger.log(`Indexing ${faces.length} faces`);
+
+    const chunkSize = 1000;
+    for (let i = 0; i < faces.length; i += chunkSize) {
+      await this.searchRepository.importFaces(faces.slice(i, i + chunkSize), false);
+    }
+
+    await this.searchRepository.importFaces([], true);
+
+    this.logger.debug('Finished re-indexing all faces');
+
+    return true;
+  }
+
+  handleIndexAlbum({ ids }: IBulkEntityJob) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    for (const id of ids) {
+      this.albumQueue.upsert.add(id);
+    }
+
+    return true;
+  }
+
+  handleIndexAsset({ ids }: IBulkEntityJob) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    for (const id of ids) {
+      this.assetQueue.upsert.add(id);
+    }
+
+    return true;
+  }
+
+  async handleIndexFace({ assetId, personId }: IAssetFaceJob) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    // immediately push to typesense
+    await this.searchRepository.importFaces(await this.idsToFaces([{ assetId, personId }]), false);
+
+    return true;
+  }
+
+  handleRemoveAlbum({ ids }: IBulkEntityJob) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    for (const id of ids) {
+      this.albumQueue.delete.add(id);
+    }
+
+    return true;
+  }
+
+  handleRemoveAsset({ ids }: IBulkEntityJob) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    for (const id of ids) {
+      this.assetQueue.delete.add(id);
+    }
+
+    return true;
+  }
+
+  handleRemoveFace({ assetId, personId }: IAssetFaceJob) {
+    if (!this.enabled) {
+      return false;
+    }
+
+    this.faceQueue.delete.add(this.asKey({ assetId, personId }));
+
+    return true;
+  }
+
+  private async flush() {
+    if (this.albumQueue.upsert.size > 0) {
+      const ids = [...this.albumQueue.upsert.keys()];
+      const items = await this.idsToAlbums(ids);
+      this.logger.debug(`Flushing ${items.length} album upserts`);
+      await this.searchRepository.importAlbums(items, false);
+      this.albumQueue.upsert.clear();
+    }
+
+    if (this.albumQueue.delete.size > 0) {
+      const ids = [...this.albumQueue.delete.keys()];
+      this.logger.debug(`Flushing ${ids.length} album deletes`);
+      await this.searchRepository.deleteAlbums(ids);
+      this.albumQueue.delete.clear();
+    }
+
+    if (this.assetQueue.upsert.size > 0) {
+      const ids = [...this.assetQueue.upsert.keys()];
+      const items = await this.idsToAssets(ids);
+      this.logger.debug(`Flushing ${items.length} asset upserts`);
+      await this.searchRepository.importAssets(items, false);
+      this.assetQueue.upsert.clear();
+    }
+
+    if (this.assetQueue.delete.size > 0) {
+      const ids = [...this.assetQueue.delete.keys()];
+      this.logger.debug(`Flushing ${ids.length} asset deletes`);
+      await this.searchRepository.deleteAssets(ids);
+      this.assetQueue.delete.clear();
+    }
+
+    if (this.faceQueue.upsert.size > 0) {
+      const ids = [...this.faceQueue.upsert.keys()].map((key) => this.asParts(key));
+      const items = await this.idsToFaces(ids);
+      this.logger.debug(`Flushing ${items.length} face upserts`);
+      await this.searchRepository.importFaces(items, false);
+      this.faceQueue.upsert.clear();
+    }
+
+    if (this.faceQueue.delete.size > 0) {
+      const ids = [...this.faceQueue.delete.keys()];
+      this.logger.debug(`Flushing ${ids.length} face deletes`);
+      await this.searchRepository.deleteFaces(ids);
+      this.faceQueue.delete.clear();
+    }
+  }
+
+  private assertEnabled() {
+    if (!this.enabled) {
+      throw new BadRequestException('Search is disabled');
+    }
+  }
+
+  private async idsToAlbums(ids: string[]): Promise<AlbumEntity[]> {
+    const entities = await this.albumRepository.getByIds(ids);
+    return this.patchAlbums(entities);
+  }
+
+  private async idsToAssets(ids: string[]): Promise<AssetEntity[]> {
+    const entities = await this.assetRepository.getByIds(ids);
+    return this.patchAssets(entities.filter((entity) => entity.isVisible));
+  }
+
+  private async idsToFaces(ids: AssetFaceId[]): Promise<OwnedFaceEntity[]> {
+    return this.patchFaces(await this.faceRepository.getByIds(ids));
+  }
+
+  private patchAssets(assets: AssetEntity[]): AssetEntity[] {
+    return assets;
+  }
+
+  private patchAlbums(albums: AlbumEntity[]): AlbumEntity[] {
+    return albums.map((entity) => ({ ...entity, assets: [] }));
+  }
+
+  private patchFaces(faces: AssetFaceEntity[]): OwnedFaceEntity[] {
+    return faces.map((face) => ({
+      id: this.asKey(face),
+      ownerId: face.asset.ownerId,
+      assetId: face.assetId,
+      personId: face.personId,
+      embedding: face.embedding,
+    }));
+  }
+
+  private asKey(face: AssetFaceId): string {
+    return `${face.assetId}|${face.personId}`;
+  }
+
+  private asParts(key: string): AssetFaceId {
+    const [assetId, personId] = key.split('|');
+    return { assetId, personId };
+  }
+
+  private async getLookupMap(assetIds: string[]) {
+    const assets = await this.assetRepository.getByIds(assetIds);
+    const lookup: Record<string, AssetEntity> = {};
+    for (const asset of assets) {
+      lookup[asset.id] = asset;
+    }
+    return lookup;
+  }
+}