feat: migrate to vitest

server/.eslintrc.js

@@ -10,7 +10,6 @@ module.exports = {
   root: true,
   env: {
     node: true,
-    jest: true,
   },
   ignorePatterns: ['.eslintrc.js'],
   rules: {

server/package.json

@@ -18,9 +18,8 @@
     "check": "tsc --noEmit",
     "check:code": "npm run format && npm run lint && npm run check",
     "check:all": "npm run check:code && npm run test:cov",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:cov": "jest --coverage",
+    "test": "vitest",
+    "test:cov": "vitest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "e2e:jobs": "jest --config e2e/jobs/jest-e2e.json --runInBand",
     "typeorm": "typeorm",
@@ -90,6 +89,7 @@
     "@nestjs/cli": "^10.1.16",
     "@nestjs/schematics": "^10.0.2",
     "@nestjs/testing": "^10.2.2",
+    "@swc/core": "^1.4.1",
     "@testcontainers/postgresql": "^10.2.1",
     "@types/archiver": "^6.0.0",
     "@types/async-lock": "^1.4.2",
@@ -98,7 +98,6 @@
     "@types/express": "^4.17.17",
     "@types/fluent-ffmpeg": "^2.1.21",
     "@types/imagemin": "^8.0.1",
-    "@types/jest": "29.5.12",
     "@types/jest-when": "^3.5.2",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash": "^4.14.197",
@@ -110,62 +109,24 @@
     "@types/ua-parser-js": "^0.7.36",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
+    "@vitest/coverage-v8": "^1.3.0",
     "dotenv": "^16.3.1",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-unicorn": "^51.0.0",
-    "jest": "^29.6.4",
     "jest-when": "^3.6.0",
     "mock-fs": "^5.2.0",
     "prettier": "^3.0.2",
     "prettier-plugin-organize-imports": "^3.2.3",
-    "rimraf": "^5.0.1",
     "source-map-support": "^0.5.21",
     "sql-formatter": "^15.0.0",
     "supertest": "^6.3.3",
     "testcontainers": "^10.2.1",
-    "ts-jest": "^29.1.1",
-    "ts-loader": "^9.4.4",
-    "ts-node": "^10.9.1",
-    "tsconfig-paths": "^4.2.0",
     "typescript": "^5.3.3",
-    "utimes": "^5.2.1"
-  },
-  "jest": {
-    "clearMocks": true,
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": ".",
-    "testRegex": ".*\\.spec\\.ts$",
-    "transform": {
-      "^.+\\.ts$": "ts-jest"
-    },
-    "collectCoverageFrom": [
-      "<rootDir>/src/**/*.(t|j)s",
-      "!<rootDir>/src/infra/**/*",
-      "!<rootDir>/src/immich/controllers/**/*"
-    ],
-    "coverageDirectory": "./coverage",
-    "coverageThreshold": {
-      "./src/domain/": {
-        "branches": 79,
-        "functions": 80,
-        "lines": 90,
-        "statements": 90
-      }
-    },
-    "testEnvironment": "node",
-    "moduleNameMapper": {
-      "^@test(|/.*)$": "<rootDir>/test/$1",
-      "^@app/immich(|/.*)$": "<rootDir>/src/immich/$1",
-      "^@app/infra(|/.*)$": "<rootDir>/src/infra/$1",
-      "^@app/domain(|/.*)$": "<rootDir>/src/domain/$1"
-    },
-    "globalSetup": "<rootDir>/test/global-setup.js"
+    "unplugin-swc": "^1.4.4",
+    "utimes": "^5.2.1",
+    "vitest": "^1.3.0"
   },
   "volta": {
     "node": "20.11.1"

server/src/domain/activity/activity.spec.ts

@@ -2,6 +2,7 @@ import { BadRequestException } from '@nestjs/common';
 import { authStub, IAccessRepositoryMock, newAccessRepositoryMock } from '@test';
 import { activityStub } from '@test/fixtures/activity.stub';
 import { newActivityRepositoryMock } from '@test/repositories/activity.repository.mock';
+import { Mocked } from 'vitest';
 import { IActivityRepository } from '../repositories';
 import { ReactionType } from './activity.dto';
 import { ActivityService } from './activity.service';
@@ -9,7 +10,7 @@ import { ActivityService } from './activity.service';
 describe(ActivityService.name, () => {
   let sut: ActivityService;
   let accessMock: IAccessRepositoryMock;
-  let activityMock: jest.Mocked<IActivityRepository>;
+  let activityMock: Mocked<IActivityRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();

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

@@ -11,6 +11,7 @@ import {
   userStub,
 } from '@test';
 import _ from 'lodash';
+import { Mocked } from 'vitest';
 import { BulkIdErrorReason } from '../asset';
 import { IAlbumRepository, IAssetRepository, IJobRepository, IUserRepository } from '../repositories';
 import { AlbumService } from './album.service';
@@ -18,10 +19,10 @@ import { AlbumService } from './album.service';
 describe(AlbumService.name, () => {
   let sut: AlbumService;
   let accessMock: IAccessRepositoryMock;
-  let albumMock: jest.Mocked<IAlbumRepository>;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
+  let albumMock: Mocked<IAlbumRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let userMock: Mocked<IUserRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();

server/src/domain/api-key/api-key.service.spec.ts

@@ -1,12 +1,13 @@
 import { BadRequestException } from '@nestjs/common';
 import { authStub, keyStub, newCryptoRepositoryMock, newKeyRepositoryMock } from '@test';
+import { Mocked } from 'vitest';
 import { ICryptoRepository, IKeyRepository } from '../repositories';
 import { APIKeyService } from './api-key.service';
 
 describe(APIKeyService.name, () => {
   let sut: APIKeyService;
-  let keyMock: jest.Mocked<IKeyRepository>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
+  let keyMock: Mocked<IKeyRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
 
   beforeEach(() => {
     cryptoMock = newCryptoRepositoryMock();

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

@@ -17,6 +17,7 @@ import {
   newUserRepositoryMock,
 } from '@test';
 import { when } from 'jest-when';
+import { Mocked } from 'vitest';
 import { JobName } from '../job';
 import {
   AssetStats,
@@ -157,14 +158,14 @@ const uploadTests = [
 describe(AssetService.name, () => {
   let sut: AssetService;
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
-  let communicationMock: jest.Mocked<ICommunicationRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let partnerMock: jest.Mocked<IPartnerRepository>;
-  let assetStackMock: jest.Mocked<IAssetStackRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let communicationMock: Mocked<ICommunicationRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let partnerMock: Mocked<IPartnerRepository>;
+  let assetStackMock: Mocked<IAssetStackRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();
@@ -308,12 +309,12 @@ describe(AssetService.name, () => {
 
   describe('getMemoryLane', () => {
     beforeAll(() => {
-      jest.useFakeTimers();
-      jest.setSystemTime(new Date('2024-01-15'));
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date('2024-01-15'));
     });
 
     afterAll(() => {
-      jest.useRealTimers();
+      vi.useRealTimers();
     });
 
     it('should set the title correctly', async () => {

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

@@ -11,6 +11,7 @@ import {
   newStorageRepositoryMock,
   newUserRepositoryMock,
 } from '@test';
+import { Mocked } from 'vitest';
 import {
   IAssetRepository,
   IAuditRepository,
@@ -25,12 +26,12 @@ import { AuditService } from './audit.service';
 describe(AuditService.name, () => {
   let sut: AuditService;
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let auditMock: jest.Mocked<IAuditRepository>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let auditMock: Mocked<IAuditRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let userMock: Mocked<IUserRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();

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

@@ -21,6 +21,7 @@ import {
 import { IncomingHttpHeaders } from 'node:http';
 import { Issuer, generators } from 'openid-client';
 import { Socket } from 'socket.io';
+import { Mock, Mocked } from 'vitest';
 import {
   ICryptoRepository,
   IKeyRepository,
@@ -62,33 +63,32 @@ const oauthUserWithDefaultQuota = {
 
 describe('AuthService', () => {
   let sut: AuthService;
-  let accessMock: jest.Mocked<IAccessRepositoryMock>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
-  let libraryMock: jest.Mocked<ILibraryRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let userTokenMock: jest.Mocked<IUserTokenRepository>;
-  let shareMock: jest.Mocked<ISharedLinkRepository>;
-  let keyMock: jest.Mocked<IKeyRepository>;
-
-  let callbackMock: jest.Mock;
-  let userinfoMock: jest.Mock;
+  let accessMock: Mocked<IAccessRepositoryMock>;
+  let cryptoMock: Mocked<ICryptoRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let libraryMock: Mocked<ILibraryRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let userTokenMock: Mocked<IUserTokenRepository>;
+  let shareMock: Mocked<ISharedLinkRepository>;
+  let keyMock: Mocked<IKeyRepository>;
+  let callbackMock: Mock;
+  let userinfoMock: Mock;
 
   beforeEach(() => {
-    callbackMock = jest.fn().mockReturnValue({ access_token: 'access-token' });
-    userinfoMock = jest.fn().mockResolvedValue({ sub, email });
+    callbackMock = vi.fn().mockReturnValue({ access_token: 'access-token' });
+    userinfoMock = vi.fn().mockResolvedValue({ sub, email });
 
-    jest.spyOn(generators, 'state').mockReturnValue('state');
-    jest.spyOn(Issuer, 'discover').mockResolvedValue({
+    vi.spyOn(generators, 'state').mockReturnValue('state');
+    vi.spyOn(Issuer, 'discover').mockResolvedValue({
       id_token_signing_alg_values_supported: ['RS256'],
-      Client: jest.fn().mockResolvedValue({
+      Client: vi.fn().mockResolvedValue({
         issuer: {
           metadata: {
             end_session_endpoint: 'http://end-session-endpoint',
           },
         },
-        authorizationUrl: jest.fn().mockReturnValue('http://authorization-url'),
-        callbackParams: jest.fn().mockReturnValue({ state: 'state' }),
+        authorizationUrl: vi.fn().mockReturnValue('http://authorization-url'),
+        callbackParams: vi.fn().mockReturnValue({ state: 'state' }),
         callback: callbackMock,
         userinfo: userinfoMock,
       }),
@@ -106,6 +106,10 @@ describe('AuthService', () => {
     sut = new AuthService(accessMock, cryptoMock, configMock, libraryMock, userMock, userTokenMock, shareMock, keyMock);
   });
 
+  afterEach(() => {
+    vi.resetModules();
+  });
+
   it('should be defined', () => {
     expect(sut).toBeDefined();
   });

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

@@ -8,10 +8,11 @@ import {
 } from '@app/domain';
 import { ImmichLogger } from '@app/infra/logger';
 import { newDatabaseRepositoryMock } from '@test';
+import { MockInstance, Mocked } from 'vitest';
 
 describe(DatabaseService.name, () => {
   let sut: DatabaseService;
-  let databaseMock: jest.Mocked<IDatabaseRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
 
   beforeEach(() => {
     databaseMock = newDatabaseRepositoryMock();
@@ -27,14 +28,14 @@ describe(DatabaseService.name, () => {
     [{ vectorExt: DatabaseExtension.VECTORS, extName: 'pgvecto.rs', minVersion: new Version(0, 1, 1) }],
     [{ vectorExt: DatabaseExtension.VECTOR, extName: 'pgvector', minVersion: new Version(0, 5, 0) }],
   ] as const)('init', ({ vectorExt, extName, minVersion }) => {
-    let fatalLog: jest.SpyInstance;
-    let errorLog: jest.SpyInstance;
-    let warnLog: jest.SpyInstance;
+    let fatalLog: MockInstance<[message: any, ...optionalParams: any[]], void>;
+    let errorLog: MockInstance<[message: any, ...optionalParams: any[]], void>;
+    let warnLog: MockInstance<[message: any, ...optionalParams: any[]], void>;
 
     beforeEach(() => {
-      fatalLog = jest.spyOn(ImmichLogger.prototype, 'fatal');
-      errorLog = jest.spyOn(ImmichLogger.prototype, 'error');
-      warnLog = jest.spyOn(ImmichLogger.prototype, 'warn');
+      fatalLog = vi.spyOn(ImmichLogger.prototype, 'fatal');
+      errorLog = vi.spyOn(ImmichLogger.prototype, 'error');
+      warnLog = vi.spyOn(ImmichLogger.prototype, 'warn');
       databaseMock.getPreferredVectorExtension.mockReturnValue(vectorExt);
       databaseMock.getExtensionVersion.mockResolvedValue(minVersion);
 

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

@@ -9,6 +9,7 @@ import {
 } from '@test';
 import { when } from 'jest-when';
 import { Readable } from 'typeorm/platform/PlatformTools.js';
+import { Mocked } from 'vitest';
 import { CacheControl, ImmichFileResponse } from '../domain.util';
 import { IAssetRepository, IStorageRepository } from '../repositories';
 import { DownloadResponseDto } from './download.dto';
@@ -27,8 +28,8 @@ const downloadResponse: DownloadResponseDto = {
 describe(DownloadService.name, () => {
   let sut: DownloadService;
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let storageMock: Mocked<IStorageRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();
@@ -84,8 +85,8 @@ describe(DownloadService.name, () => {
 
     it('should download an archive', async () => {
       const archiveMock = {
-        addFile: jest.fn(),
-        finalize: jest.fn(),
+        addFile: vi.fn(),
+        finalize: vi.fn(),
         stream: new Readable(),
       };
 
@@ -107,8 +108,8 @@ describe(DownloadService.name, () => {
 
     it('should handle duplicate file names', async () => {
       const archiveMock = {
-        addFile: jest.fn(),
-        finalize: jest.fn(),
+        addFile: vi.fn(),
+        finalize: vi.fn(),
         stream: new Readable(),
       };
 
@@ -130,8 +131,8 @@ describe(DownloadService.name, () => {
 
     it('should be deterministic', async () => {
       const archiveMock = {
-        addFile: jest.fn(),
-        finalize: jest.fn(),
+        addFile: vi.fn(),
+        finalize: vi.fn(),
         stream: new Readable(),
       };
 

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

@@ -8,6 +8,7 @@ import {
   newPersonRepositoryMock,
   newSystemConfigRepositoryMock,
 } from '@test';
+import { Mocked } from 'vitest';
 import {
   IAssetRepository,
   ICommunicationRepository,
@@ -23,7 +24,7 @@ import { JobCommand, JobName, QueueName } from './job.constants';
 import { JobService } from './job.service';
 
 const makeMockHandlers = (status: JobStatus) => {
-  const mock = jest.fn().mockResolvedValue(status);
+  const mock = vi.fn().mockResolvedValue(status);
   return Object.fromEntries(Object.values(JobName).map((jobName) => [jobName, mock])) as unknown as Record<
     JobName,
     JobHandler
@@ -32,11 +33,11 @@ const makeMockHandlers = (status: JobStatus) => {
 
 describe(JobService.name, () => {
   let sut: JobService;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let communicationMock: jest.Mocked<ICommunicationRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let communicationMock: Mocked<ICommunicationRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let personMock: Mocked<IPersonRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();

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

@@ -15,10 +15,11 @@ import {
   newStorageRepositoryMock,
   newSystemConfigRepositoryMock,
   systemConfigStub,
-  userStub,
+  userStub
 } from '@test';
 import { when } from 'jest-when';
 import { Stats } from 'node:fs';
+import { Mocked } from 'vitest';
 import { ILibraryFileJob, ILibraryRefreshJob, JobName } from '../job';
 import {
   IAssetRepository,
@@ -39,13 +40,13 @@ describe(LibraryService.name, () => {
   let sut: LibraryService;
 
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let libraryMock: jest.Mocked<ILibraryRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let databaseMock: jest.Mocked<IDatabaseRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let libraryMock: Mocked<ILibraryRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();
@@ -732,7 +733,7 @@ describe(LibraryService.name, () => {
 
       configMock.load.mockResolvedValue(systemConfigStub.libraryWatchEnabled);
 
-      const mockClose = jest.fn();
+      const mockClose = vi.fn();
       storageMock.watch.mockImplementation(makeMockWatcher({ close: mockClose }));
 
       await sut.init();
@@ -1194,7 +1195,7 @@ describe(LibraryService.name, () => {
       it('should watch and unwatch library', async () => {
         libraryMock.getAll.mockResolvedValue([libraryStub.externalLibraryWithImportPaths1]);
         libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-        const mockClose = jest.fn();
+        const mockClose = vi.fn();
         storageMock.watch.mockImplementation(makeMockWatcher({ close: mockClose }));
 
         await sut.watchAll();
@@ -1347,7 +1348,7 @@ describe(LibraryService.name, () => {
         .calledWith(libraryStub.externalLibraryWithImportPaths2.id)
         .mockResolvedValue(libraryStub.externalLibraryWithImportPaths2);
 
-      const mockClose = jest.fn();
+      const mockClose = vi.fn();
       storageMock.watch.mockImplementation(makeMockWatcher({ close: mockClose }));
 
       await sut.init();

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

@@ -24,6 +24,7 @@ import {
   probeStub,
 } from '@test';
 import { Stats } from 'node:fs';
+import { Mocked } from 'vitest';
 import { JobName } from '../job';
 import {
   IAssetRepository,
@@ -41,14 +42,14 @@ import { MediaService } from './media.service';
 
 describe(MediaService.name, () => {
   let sut: MediaService;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let mediaMock: jest.Mocked<IMediaRepository>;
-  let moveMock: jest.Mocked<IMoveRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let mediaMock: Mocked<IMediaRepository>;
+  let moveMock: Mocked<IMoveRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();

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

@@ -21,6 +21,7 @@ import { when } from 'jest-when';
 import { randomBytes } from 'node:crypto';
 import { Stats } from 'node:fs';
 import { constants } from 'node:fs/promises';
+import { Mocked } from 'vitest';
 import { JobName } from '../job';
 import {
   ClientEvent,
@@ -43,18 +44,18 @@ import {
 import { MetadataService, Orientation } from './metadata.service';
 
 describe(MetadataService.name, () => {
-  let albumMock: jest.Mocked<IAlbumRepository>;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let cryptoRepository: jest.Mocked<ICryptoRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let metadataMock: jest.Mocked<IMetadataRepository>;
-  let moveMock: jest.Mocked<IMoveRepository>;
-  let mediaMock: jest.Mocked<IMediaRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let communicationMock: jest.Mocked<ICommunicationRepository>;
-  let databaseMock: jest.Mocked<IDatabaseRepository>;
+  let albumMock: Mocked<IAlbumRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let cryptoRepository: Mocked<ICryptoRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let metadataMock: Mocked<IMetadataRepository>;
+  let moveMock: Mocked<IMoveRepository>;
+  let mediaMock: Mocked<IMediaRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let communicationMock: Mocked<ICommunicationRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
   let sut: MetadataService;
 
   beforeEach(() => {

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

@@ -1,6 +1,7 @@
 import { UserAvatarColor } from '@app/infra/entities';
 import { BadRequestException } from '@nestjs/common';
 import { authStub, newPartnerRepositoryMock, partnerStub } from '@test';
+import { Mocked } from 'vitest';
 import { IAccessRepository, IPartnerRepository, PartnerDirection } from '../repositories';
 import { PartnerResponseDto } from './partner.dto';
 import { PartnerService } from './partner.service';
@@ -46,8 +47,8 @@ const responseDto = {
 
 describe(PartnerService.name, () => {
   let sut: PartnerService;
-  let partnerMock: jest.Mocked<IPartnerRepository>;
-  let accessMock: jest.Mocked<IAccessRepository>;
+  let partnerMock: Mocked<IPartnerRepository>;
+  let accessMock: Mocked<IAccessRepository>;
 
   beforeEach(() => {
     partnerMock = newPartnerRepositoryMock();

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

@@ -19,6 +19,7 @@ import {
   personStub,
 } from '@test';
 import { IsNull } from 'typeorm';
+import { Mocked } from 'vitest';
 import { BulkIdErrorReason } from '../asset';
 import { CacheControl, ImmichFileResponse } from '../domain.util';
 import { JobName } from '../job';
@@ -69,16 +70,16 @@ const detectFaceMock = {
 
 describe(PersonService.name, () => {
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let machineLearningMock: jest.Mocked<IMachineLearningRepository>;
-  let mediaMock: jest.Mocked<IMediaRepository>;
-  let moveMock: jest.Mocked<IMoveRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let searchMock: jest.Mocked<ISearchRepository>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let machineLearningMock: Mocked<IMachineLearningRepository>;
+  let mediaMock: Mocked<IMediaRepository>;
+  let moveMock: Mocked<IMoveRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let searchMock: Mocked<ISearchRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
   let sut: PersonService;
 
   beforeEach(() => {

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

@@ -11,6 +11,7 @@ import {
   newSystemConfigRepositoryMock,
   personStub,
 } from '@test';
+import { Mocked } from 'vitest';
 import { mapAsset } from '../asset';
 import {
   IAssetRepository,
@@ -24,17 +25,17 @@ import {
 import { SearchDto } from './dto';
 import { SearchService } from './search.service';
 
-jest.useFakeTimers();
+vi.useFakeTimers();
 
 describe(SearchService.name, () => {
   let sut: SearchService;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let machineMock: jest.Mocked<IMachineLearningRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let searchMock: jest.Mocked<ISearchRepository>;
-  let partnerMock: jest.Mocked<IPartnerRepository>;
-  let metadataMock: jest.Mocked<IMetadataRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let machineMock: Mocked<IMachineLearningRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let searchMock: Mocked<ISearchRepository>;
+  let partnerMock: Mocked<IPartnerRepository>;
+  let metadataMock: Mocked<IMetadataRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();

server/src/domain/server-info/server-info.service.spec.ts

@@ -7,6 +7,7 @@ import {
   newSystemMetadataRepositoryMock,
   newUserRepositoryMock,
 } from '@test';
+import { Mocked } from 'vitest';
 import { serverVersion } from '../domain.constant';
 import {
   ICommunicationRepository,
@@ -20,12 +21,12 @@ import { ServerInfoService } from './server-info.service';
 
 describe(ServerInfoService.name, () => {
   let sut: ServerInfoService;
-  let communicationMock: jest.Mocked<ICommunicationRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let serverInfoMock: jest.Mocked<IServerInfoRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
-  let systemMetadataMock: jest.Mocked<ISystemMetadataRepository>;
+  let communicationMock: Mocked<ICommunicationRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let serverInfoMock: Mocked<IServerInfoRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let systemMetadataMock: Mocked<ISystemMetadataRepository>;
 
   beforeEach(() => {
     configMock = newSystemConfigRepositoryMock();

server/src/domain/shared-link/shared-link.service.spec.ts

@@ -12,6 +12,7 @@ import {
   sharedLinkStub,
 } from '@test';
 import _ from 'lodash';
+import { Mocked } from 'vitest';
 import { AssetIdErrorReason } from '../asset';
 import { ICryptoRepository, ISharedLinkRepository } from '../repositories';
 import { SharedLinkService } from './shared-link.service';
@@ -19,8 +20,8 @@ import { SharedLinkService } from './shared-link.service';
 describe(SharedLinkService.name, () => {
   let sut: SharedLinkService;
   let accessMock: IAccessRepositoryMock;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
-  let shareMock: jest.Mocked<ISharedLinkRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
+  let shareMock: Mocked<ISharedLinkRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();

server/src/domain/smart-info/smart-info.service.spec.ts

@@ -8,6 +8,7 @@ import {
   newSearchRepositoryMock,
   newSystemConfigRepositoryMock,
 } from '@test';
+import { Mocked } from 'vitest';
 import { JobName } from '../job';
 import {
   IAssetRepository,
@@ -28,12 +29,12 @@ const asset = {
 
 describe(SmartInfoService.name, () => {
   let sut: SmartInfoService;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let searchMock: jest.Mocked<ISearchRepository>;
-  let machineMock: jest.Mocked<IMachineLearningRepository>;
-  let databaseMock: jest.Mocked<IDatabaseRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let searchMock: Mocked<ISearchRepository>;
+  let machineMock: Mocked<IMachineLearningRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();

server/src/domain/storage-template/storage-template.service.spec.ts

@@ -28,19 +28,20 @@ import {
 } from '@test';
 import { when } from 'jest-when';
 import { Stats } from 'node:fs';
+import { Mocked } from 'vitest';
 import { SystemConfigCore } from '../system-config';
 
 describe(StorageTemplateService.name, () => {
   let sut: StorageTemplateService;
-  let albumMock: jest.Mocked<IAlbumRepository>;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let moveMock: jest.Mocked<IMoveRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
-  let cryptoMock: jest.Mocked<ICryptoRepository>;
-  let databaseMock: jest.Mocked<IDatabaseRepository>;
+  let albumMock: Mocked<IAlbumRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let moveMock: Mocked<IMoveRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let cryptoMock: Mocked<ICryptoRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();

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

@@ -1,10 +1,11 @@
 import { newStorageRepositoryMock } from '@test';
+import { Mocked } from 'vitest';
 import { IStorageRepository } from '../repositories';
 import { StorageService } from './storage.service';
 
 describe(StorageService.name, () => {
   let sut: StorageService;
-  let storageMock: jest.Mocked<IStorageRepository>;
+  let storageMock: Mocked<IStorageRepository>;
 
   beforeEach(() => {
     storageMock = newStorageRepositoryMock();

server/src/domain/system-config/system-config.service.spec.ts

@@ -14,6 +14,7 @@ import {
 import { ImmichLogger } from '@app/infra/logger';
 import { BadRequestException } from '@nestjs/common';
 import { newCommunicationRepositoryMock, newSystemConfigRepositoryMock } from '@test';
+import { Mocked } from 'vitest';
 import { QueueName } from '../job';
 import { ICommunicationRepository, ISearchRepository, ISystemConfigRepository, ServerEvent } from '../repositories';
 import { defaults, SystemConfigValidator } from './system-config.core';
@@ -148,9 +149,9 @@ const updatedConfig = Object.freeze<SystemConfig>({
 
 describe(SystemConfigService.name, () => {
   let sut: SystemConfigService;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let communicationMock: jest.Mocked<ICommunicationRepository>;
-  let smartInfoMock: jest.Mocked<ISearchRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let communicationMock: Mocked<ICommunicationRepository>;
+  let smartInfoMock: Mocked<ISearchRepository>;
 
   beforeEach(() => {
     delete process.env.IMMICH_CONFIG_FILE;
@@ -174,7 +175,7 @@ describe(SystemConfigService.name, () => {
 
   describe('addValidator', () => {
     it('should call the validator on config changes', async () => {
-      const validator: SystemConfigValidator = jest.fn();
+      const validator: SystemConfigValidator = vi.fn();
       sut.addValidator(validator);
       await sut.updateConfig(defaults);
       expect(validator).toHaveBeenCalledWith(defaults, defaults);
@@ -182,16 +183,6 @@ describe(SystemConfigService.name, () => {
   });
 
   describe('getConfig', () => {
-    let warnLog: jest.SpyInstance;
-
-    beforeEach(() => {
-      warnLog = jest.spyOn(ImmichLogger.prototype, 'warn');
-    });
-
-    afterEach(() => {
-      warnLog.mockRestore();
-    });
-
     it('should return the default config', async () => {
       configMock.load.mockResolvedValue([]);
 
@@ -266,6 +257,8 @@ describe(SystemConfigService.name, () => {
       const partialConfig = `
         unknownOption: true
       `;
+
+      const warnLog = vi.spyOn(ImmichLogger.prototype, 'warn');
       configMock.readFile.mockResolvedValue(partialConfig);
 
       await sut.getConfig();
@@ -286,6 +279,8 @@ describe(SystemConfigService.name, () => {
         process.env.IMMICH_CONFIG_FILE = 'immich-config.json';
         configMock.readFile.mockResolvedValue(JSON.stringify(test.config));
 
+        const warnLog = vi.spyOn(ImmichLogger.prototype, 'warn');
+
         if (test.warn) {
           await sut.getConfig();
           expect(warnLog).toHaveBeenCalled();
@@ -342,7 +337,7 @@ describe(SystemConfigService.name, () => {
     });
 
     it('should throw an error if the config is not valid', async () => {
-      const validator = jest.fn().mockRejectedValue('invalid config');
+      const validator = vi.fn().mockRejectedValue('invalid config');
 
       sut.addValidator(validator);
 
@@ -362,7 +357,7 @@ describe(SystemConfigService.name, () => {
 
   describe('refreshConfig', () => {
     it('should notify the subscribers', async () => {
-      const changeMock = jest.fn();
+      const changeMock = vi.fn();
       const subscription = sut.config$.subscribe(changeMock);
 
       await sut.refreshConfig();

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

@@ -2,13 +2,14 @@ import { TagType } from '@app/infra/entities';
 import { BadRequestException } from '@nestjs/common';
 import { assetStub, authStub, newTagRepositoryMock, tagResponseStub, tagStub } from '@test';
 import { when } from 'jest-when';
+import { Mocked } from 'vitest';
 import { AssetIdErrorReason } from '../asset';
 import { ITagRepository } from '../repositories';
 import { TagService } from './tag.service';
 
 describe(TagService.name, () => {
   let sut: TagService;
-  let tagMock: jest.Mocked<ITagRepository>;
+  let tagMock: Mocked<ITagRepository>;
 
   beforeEach(() => {
     tagMock = newTagRepositoryMock();

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

@@ -8,6 +8,7 @@ import {
   newCommunicationRepositoryMock,
   newJobRepositoryMock,
 } from '@test';
+import { Mocked } from 'vitest';
 import { JobName } from '..';
 import { ClientEvent, IAssetRepository, ICommunicationRepository, IJobRepository } from '../repositories';
 import { TrashService } from './trash.service';
@@ -15,9 +16,9 @@ import { TrashService } from './trash.service';
 describe(TrashService.name, () => {
   let sut: TrashService;
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let communicationMock: jest.Mocked<ICommunicationRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let communicationMock: Mocked<ICommunicationRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();

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

@@ -18,6 +18,7 @@ import {
   userStub,
 } from '@test';
 import { when } from 'jest-when';
+import { Mocked } from 'vitest';
 import { CacheControl, ImmichFileResponse } from '../domain.util';
 import { JobName } from '../job';
 import {
@@ -41,14 +42,13 @@ const makeDeletedAt = (daysAgo: number) => {
 
 describe(UserService.name, () => {
   let sut: UserService;
-  let userMock: jest.Mocked<IUserRepository>;
-  let cryptoRepositoryMock: jest.Mocked<ICryptoRepository>;
-
-  let albumMock: jest.Mocked<IAlbumRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let libraryMock: jest.Mocked<ILibraryRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let cryptoRepositoryMock: Mocked<ICryptoRepository>;
+  let albumMock: Mocked<IAlbumRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let libraryMock: Mocked<ILibraryRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
 
   beforeEach(() => {
     albumMock = newAlbumRepositoryMock();
@@ -428,7 +428,7 @@ describe(UserService.name, () => {
   describe('resetAdminPassword', () => {
     it('should only work when there is an admin account', async () => {
       userMock.getAdmin.mockResolvedValue(null);
-      const ask = jest.fn().mockResolvedValue('new-password');
+      const ask = vi.fn().mockResolvedValue('new-password');
 
       await expect(sut.resetAdminPassword(ask)).rejects.toBeInstanceOf(BadRequestException);
 
@@ -437,7 +437,7 @@ describe(UserService.name, () => {
 
     it('should default to a random password', async () => {
       userMock.getAdmin.mockResolvedValue(userStub.admin);
-      const ask = jest.fn().mockImplementation(() => {});
+      const ask = vi.fn().mockImplementation(() => {});
 
       const response = await sut.resetAdminPassword(ask);
 
@@ -451,7 +451,7 @@ describe(UserService.name, () => {
 
     it('should use the supplied password', async () => {
       userMock.getAdmin.mockResolvedValue(userStub.admin);
-      const ask = jest.fn().mockResolvedValue('new-password');
+      const ask = vi.fn().mockResolvedValue('new-password');
 
       const response = await sut.resetAdminPassword(ask);
 

server/src/immich/api-v1/asset/asset.service.spec.ts

@@ -21,6 +21,7 @@ import {
 } from '@test';
 import { when } from 'jest-when';
 import { QueryFailedError } from 'typeorm';
+import { Mocked } from 'vitest';
 import { IAssetRepositoryV1 } from './asset-repository';
 import { AssetService } from './asset.service';
 import { CreateAssetDto } from './dto/create-asset.dto';
@@ -67,23 +68,23 @@ const _getAsset_1 = () => {
 describe('AssetService', () => {
   let sut: AssetService;
   let accessMock: IAccessRepositoryMock;
-  let assetRepositoryMockV1: jest.Mocked<IAssetRepositoryV1>;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let libraryMock: jest.Mocked<ILibraryRepository>;
-  let storageMock: jest.Mocked<IStorageRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
+  let assetRepositoryMockV1: Mocked<IAssetRepositoryV1>;
+  let assetMock: Mocked<IAssetRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let libraryMock: Mocked<ILibraryRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let userMock: Mocked<IUserRepository>;
 
   beforeEach(() => {
     assetRepositoryMockV1 = {
-      get: jest.fn(),
-      getAllByUserId: jest.fn(),
-      getDetectedObjectsByUserId: jest.fn(),
-      getLocationsByUserId: jest.fn(),
-      getSearchPropertiesByUserId: jest.fn(),
-      getAssetsByChecksums: jest.fn(),
-      getExistingAssets: jest.fn(),
-      getByOriginalPath: jest.fn(),
+      get: vi.fn(),
+      getAllByUserId: vi.fn(),
+      getDetectedObjectsByUserId: vi.fn(),
+      getLocationsByUserId: vi.fn(),
+      getSearchPropertiesByUserId: vi.fn(),
+      getAssetsByChecksums: vi.fn(),
+      getExistingAssets: vi.fn(),
+      getByOriginalPath: vi.fn(),
     };
 
     accessMock = newAccessRepositoryMock();

server/test/repositories/access.repository.mock.ts

@@ -1,14 +1,15 @@
 import { AccessCore, IAccessRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
 export interface IAccessRepositoryMock {
-  activity: jest.Mocked<IAccessRepository['activity']>;
-  asset: jest.Mocked<IAccessRepository['asset']>;
-  album: jest.Mocked<IAccessRepository['album']>;
-  authDevice: jest.Mocked<IAccessRepository['authDevice']>;
-  library: jest.Mocked<IAccessRepository['library']>;
-  timeline: jest.Mocked<IAccessRepository['timeline']>;
-  person: jest.Mocked<IAccessRepository['person']>;
-  partner: jest.Mocked<IAccessRepository['partner']>;
+  activity: Mocked<IAccessRepository['activity']>;
+  asset: Mocked<IAccessRepository['asset']>;
+  album: Mocked<IAccessRepository['album']>;
+  authDevice: Mocked<IAccessRepository['authDevice']>;
+  library: Mocked<IAccessRepository['library']>;
+  timeline: Mocked<IAccessRepository['timeline']>;
+  person: Mocked<IAccessRepository['person']>;
+  partner: Mocked<IAccessRepository['partner']>;
 }
 
 export const newAccessRepositoryMock = (reset = true): IAccessRepositoryMock => {
@@ -18,44 +19,44 @@ export const newAccessRepositoryMock = (reset = true): IAccessRepositoryMock =>
 
   return {
     activity: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkAlbumOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkCreateAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkAlbumOwnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkCreateAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     asset: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkAlbumAccess: jest.fn().mockResolvedValue(new Set()),
-      checkPartnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkSharedLinkAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkAlbumAccess: vi.fn().mockResolvedValue(new Set()),
+      checkPartnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkSharedLinkAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     album: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkSharedAlbumAccess: jest.fn().mockResolvedValue(new Set()),
-      checkSharedLinkAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkSharedAlbumAccess: vi.fn().mockResolvedValue(new Set()),
+      checkSharedLinkAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     authDevice: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     library: {
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkPartnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkPartnerAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     timeline: {
-      checkPartnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkPartnerAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     person: {
-      checkFaceOwnerAccess: jest.fn().mockResolvedValue(new Set()),
-      checkOwnerAccess: jest.fn().mockResolvedValue(new Set()),
+      checkFaceOwnerAccess: vi.fn().mockResolvedValue(new Set()),
+      checkOwnerAccess: vi.fn().mockResolvedValue(new Set()),
     },
 
     partner: {
-      checkUpdateAccess: jest.fn().mockResolvedValue(new Set()),
+      checkUpdateAccess: vi.fn().mockResolvedValue(new Set()),
     },
   };
 };

server/test/repositories/activity.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IActivityRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newActivityRepositoryMock = (): jest.Mocked<IActivityRepository> => {
+export const newActivityRepositoryMock = (): Mocked<IActivityRepository> => {
   return {
-    search: jest.fn(),
-    create: jest.fn(),
-    delete: jest.fn(),
-    getStatistics: jest.fn(),
+    search: vi.fn(),
+    create: vi.fn(),
+    delete: vi.fn(),
+    getStatistics: vi.fn(),
   };
 };

server/test/repositories/album.repository.mock.ts

@@ -1,27 +1,28 @@
 import { IAlbumRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newAlbumRepositoryMock = (): jest.Mocked<IAlbumRepository> => {
+export const newAlbumRepositoryMock = (): Mocked<IAlbumRepository> => {
   return {
-    getById: jest.fn(),
-    getByIds: jest.fn(),
-    getByAssetId: jest.fn(),
-    getMetadataForIds: jest.fn(),
-    getInvalidThumbnail: jest.fn(),
-    getOwned: jest.fn(),
-    getShared: jest.fn(),
-    getNotShared: jest.fn(),
-    restoreAll: jest.fn(),
-    softDeleteAll: jest.fn(),
-    deleteAll: jest.fn(),
-    getAll: jest.fn(),
-    addAssets: jest.fn(),
-    removeAsset: jest.fn(),
-    removeAssets: jest.fn(),
-    getAssetIds: jest.fn(),
-    hasAsset: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    updateThumbnails: jest.fn(),
+    getById: vi.fn(),
+    getByIds: vi.fn(),
+    getByAssetId: vi.fn(),
+    getMetadataForIds: vi.fn(),
+    getInvalidThumbnail: vi.fn(),
+    getOwned: vi.fn(),
+    getShared: vi.fn(),
+    getNotShared: vi.fn(),
+    restoreAll: vi.fn(),
+    softDeleteAll: vi.fn(),
+    deleteAll: vi.fn(),
+    getAll: vi.fn(),
+    addAssets: vi.fn(),
+    removeAsset: vi.fn(),
+    removeAssets: vi.fn(),
+    getAssetIds: vi.fn(),
+    hasAsset: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    updateThumbnails: vi.fn(),
   };
 };

server/test/repositories/api-key.repository.mock.ts

@@ -1,12 +1,13 @@
 import { IKeyRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newKeyRepositoryMock = (): jest.Mocked<IKeyRepository> => {
+export const newKeyRepositoryMock = (): Mocked<IKeyRepository> => {
   return {
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getKey: jest.fn(),
-    getById: jest.fn(),
-    getByUserId: jest.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    getKey: vi.fn(),
+    getById: vi.fn(),
+    getByUserId: vi.fn(),
   };
 };

server/test/repositories/asset-stack.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IAssetStackRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newAssetStackRepositoryMock = (): jest.Mocked<IAssetStackRepository> => {
+export const newAssetStackRepositoryMock = (): Mocked<IAssetStackRepository> => {
   return {
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getById: jest.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    getById: vi.fn(),
   };
 };

server/test/repositories/asset.repository.mock.ts

@@ -1,40 +1,41 @@
 import { IAssetRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newAssetRepositoryMock = (): jest.Mocked<IAssetRepository> => {
+export const newAssetRepositoryMock = (): Mocked<IAssetRepository> => {
   return {
-    create: jest.fn(),
-    upsertExif: jest.fn(),
-    upsertJobStatus: jest.fn(),
-    getByDate: jest.fn(),
-    getByDayOfYear: jest.fn(),
-    getByIds: jest.fn().mockResolvedValue([]),
-    getByIdsWithAllRelations: jest.fn().mockResolvedValue([]),
-    getByAlbumId: jest.fn(),
-    getByUserId: jest.fn(),
-    getById: jest.fn(),
-    getWithout: jest.fn(),
-    getByChecksum: jest.fn(),
-    getWith: jest.fn(),
-    getRandom: jest.fn(),
-    getFirstAssetForAlbumId: jest.fn(),
-    getLastUpdatedAssetForAlbumId: jest.fn(),
-    getAll: jest.fn().mockResolvedValue({ items: [], hasNextPage: false }),
-    getAllByDeviceId: jest.fn(),
-    updateAll: jest.fn(),
-    getLibraryAssetPaths: jest.fn(),
-    getByLibraryIdAndOriginalPath: jest.fn(),
-    deleteAll: jest.fn(),
-    save: jest.fn(),
-    remove: jest.fn(),
-    findLivePhotoMatch: jest.fn(),
-    getMapMarkers: jest.fn(),
-    getStatistics: jest.fn(),
-    getTimeBucket: jest.fn(),
-    getTimeBuckets: jest.fn(),
-    restoreAll: jest.fn(),
-    softDeleteAll: jest.fn(),
-    getAssetIdByCity: jest.fn(),
-    getAssetIdByTag: jest.fn(),
-    searchMetadata: jest.fn(),
+    create: vi.fn(),
+    upsertExif: vi.fn(),
+    upsertJobStatus: vi.fn(),
+    getByDate: vi.fn(),
+    getByDayOfYear: vi.fn(),
+    getByIds: vi.fn().mockResolvedValue([]),
+    getByIdsWithAllRelations: vi.fn().mockResolvedValue([]),
+    getByAlbumId: vi.fn(),
+    getByUserId: vi.fn(),
+    getById: vi.fn(),
+    getWithout: vi.fn(),
+    getByChecksum: vi.fn(),
+    getWith: vi.fn(),
+    getRandom: vi.fn(),
+    getFirstAssetForAlbumId: vi.fn(),
+    getLastUpdatedAssetForAlbumId: vi.fn(),
+    getAll: vi.fn().mockResolvedValue({ items: [], hasNextPage: false }),
+    getAllByDeviceId: vi.fn(),
+    updateAll: vi.fn(),
+    getLibraryAssetPaths: vi.fn(),
+    getByLibraryIdAndOriginalPath: vi.fn(),
+    deleteAll: vi.fn(),
+    save: vi.fn(),
+    remove: vi.fn(),
+    findLivePhotoMatch: vi.fn(),
+    getMapMarkers: vi.fn(),
+    getStatistics: vi.fn(),
+    getTimeBucket: vi.fn(),
+    getTimeBuckets: vi.fn(),
+    restoreAll: vi.fn(),
+    softDeleteAll: vi.fn(),
+    getAssetIdByCity: vi.fn(),
+    getAssetIdByTag: vi.fn(),
+    searchMetadata: vi.fn(),
   };
 };

server/test/repositories/audit.repository.mock.ts

@@ -1,8 +1,9 @@
 import { IAuditRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newAuditRepositoryMock = (): jest.Mocked<IAuditRepository> => {
+export const newAuditRepositoryMock = (): Mocked<IAuditRepository> => {
   return {
-    getAfter: jest.fn(),
-    removeBefore: jest.fn(),
+    getAfter: vi.fn(),
+    removeBefore: vi.fn(),
   };
 };

server/test/repositories/communication.repository.mock.ts

@@ -1,10 +1,11 @@
 import { ICommunicationRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newCommunicationRepositoryMock = (): jest.Mocked<ICommunicationRepository> => {
+export const newCommunicationRepositoryMock = (): Mocked<ICommunicationRepository> => {
   return {
-    send: jest.fn(),
-    broadcast: jest.fn(),
-    on: jest.fn(),
-    sendServerEvent: jest.fn(),
+    send: vi.fn(),
+    broadcast: vi.fn(),
+    on: vi.fn() as any,
+    sendServerEvent: vi.fn(),
   };
 };

server/test/repositories/crypto.repository.mock.ts

@@ -1,13 +1,14 @@
 import { ICryptoRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newCryptoRepositoryMock = (): jest.Mocked<ICryptoRepository> => {
+export const newCryptoRepositoryMock = (): Mocked<ICryptoRepository> => {
   return {
-    randomUUID: jest.fn().mockReturnValue('random-uuid'),
-    randomBytes: jest.fn().mockReturnValue(Buffer.from('random-bytes', 'utf8')),
-    compareBcrypt: jest.fn().mockReturnValue(true),
-    hashBcrypt: jest.fn().mockImplementation((input) => Promise.resolve(`${input} (hashed)`)),
-    hashSha256: jest.fn().mockImplementation((input) => `${input} (hashed)`),
-    hashSha1: jest.fn().mockImplementation((input) => Buffer.from(`${input.toString()} (hashed)`)),
-    hashFile: jest.fn().mockImplementation((input) => `${input} (file-hashed)`),
+    randomUUID: vi.fn().mockReturnValue('random-uuid'),
+    randomBytes: vi.fn().mockReturnValue(Buffer.from('random-bytes', 'utf8')),
+    compareBcrypt: vi.fn().mockReturnValue(true),
+    hashBcrypt: vi.fn().mockImplementation((input) => Promise.resolve(`${input} (hashed)`)),
+    hashSha256: vi.fn().mockImplementation((input) => `${input} (hashed)`),
+    hashSha1: vi.fn().mockImplementation((input) => Buffer.from(`${input.toString()} (hashed)`)),
+    hashFile: vi.fn().mockImplementation((input) => `${input} (file-hashed)`),
   };
 };

server/test/repositories/database.repository.mock.ts

@@ -1,20 +1,21 @@
 import { IDatabaseRepository, Version } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newDatabaseRepositoryMock = (): jest.Mocked<IDatabaseRepository> => {
+export const newDatabaseRepositoryMock = (): Mocked<IDatabaseRepository> => {
   return {
-    getExtensionVersion: jest.fn(),
-    getAvailableExtensionVersion: jest.fn(),
-    getPreferredVectorExtension: jest.fn(),
-    getPostgresVersion: jest.fn().mockResolvedValue(new Version(14, 0, 0)),
-    createExtension: jest.fn().mockImplementation(() => Promise.resolve()),
-    updateExtension: jest.fn(),
-    updateVectorExtension: jest.fn(),
-    reindex: jest.fn(),
-    shouldReindex: jest.fn(),
-    runMigrations: jest.fn(),
-    withLock: jest.fn().mockImplementation((_, function_: <R>() => Promise<R>) => function_()),
-    tryLock: jest.fn(),
-    isBusy: jest.fn(),
-    wait: jest.fn(),
+    getExtensionVersion: vi.fn(),
+    getAvailableExtensionVersion: vi.fn(),
+    getPreferredVectorExtension: vi.fn(),
+    getPostgresVersion: vi.fn().mockResolvedValue(new Version(14, 0, 0)),
+    createExtension: vi.fn().mockImplementation(() => Promise.resolve()),
+    updateExtension: vi.fn(),
+    updateVectorExtension: vi.fn(),
+    reindex: vi.fn(),
+    shouldReindex: vi.fn(),
+    runMigrations: vi.fn(),
+    withLock: vi.fn().mockImplementation((_, function_: <R>() => Promise<R>) => function_()),
+    tryLock: vi.fn(),
+    isBusy: vi.fn(),
+    wait: vi.fn(),
   };
 };

server/test/repositories/job.repository.mock.ts

@@ -1,20 +1,21 @@
 import { IJobRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newJobRepositoryMock = (): jest.Mocked<IJobRepository> => {
+export const newJobRepositoryMock = (): Mocked<IJobRepository> => {
   return {
-    addHandler: jest.fn(),
-    addCronJob: jest.fn(),
-    deleteCronJob: jest.fn(),
-    updateCronJob: jest.fn(),
-    setConcurrency: jest.fn(),
-    empty: jest.fn(),
-    pause: jest.fn(),
-    resume: jest.fn(),
-    queue: jest.fn().mockImplementation(() => Promise.resolve()),
-    queueAll: jest.fn().mockImplementation(() => Promise.resolve()),
-    getQueueStatus: jest.fn(),
-    getJobCounts: jest.fn(),
-    clear: jest.fn(),
-    waitForQueueCompletion: jest.fn(),
+    addHandler: vi.fn(),
+    addCronJob: vi.fn(),
+    deleteCronJob: vi.fn(),
+    updateCronJob: vi.fn(),
+    setConcurrency: vi.fn(),
+    empty: vi.fn(),
+    pause: vi.fn(),
+    resume: vi.fn(),
+    queue: vi.fn().mockImplementation(() => Promise.resolve()),
+    queueAll: vi.fn().mockImplementation(() => Promise.resolve()),
+    getQueueStatus: vi.fn(),
+    getJobCounts: vi.fn(),
+    clear: vi.fn(),
+    waitForQueueCompletion: vi.fn(),
   };
 };

server/test/repositories/library.repository.mock.ts

@@ -1,18 +1,19 @@
 import { ILibraryRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newLibraryRepositoryMock = (): jest.Mocked<ILibraryRepository> => {
+export const newLibraryRepositoryMock = (): Mocked<ILibraryRepository> => {
   return {
-    get: jest.fn(),
-    getCountForUser: jest.fn(),
-    create: jest.fn(),
-    delete: jest.fn(),
-    softDelete: jest.fn(),
-    update: jest.fn(),
-    getStatistics: jest.fn(),
-    getDefaultUploadLibrary: jest.fn(),
-    getUploadLibraryCount: jest.fn(),
-    getAssetIds: jest.fn(),
-    getAllDeleted: jest.fn(),
-    getAll: jest.fn(),
+    get: vi.fn(),
+    getCountForUser: vi.fn(),
+    create: vi.fn(),
+    delete: vi.fn(),
+    softDelete: vi.fn(),
+    update: vi.fn(),
+    getStatistics: vi.fn(),
+    getDefaultUploadLibrary: vi.fn(),
+    getUploadLibraryCount: vi.fn(),
+    getAssetIds: vi.fn(),
+    getAllDeleted: vi.fn(),
+    getAll: vi.fn(),
   };
 };

server/test/repositories/machine-learning.repository.mock.ts

@@ -1,9 +1,10 @@
 import { IMachineLearningRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newMachineLearningRepositoryMock = (): jest.Mocked<IMachineLearningRepository> => {
+export const newMachineLearningRepositoryMock = (): Mocked<IMachineLearningRepository> => {
   return {
-    encodeImage: jest.fn(),
-    encodeText: jest.fn(),
-    detectFaces: jest.fn(),
+    encodeImage: vi.fn(),
+    encodeText: vi.fn(),
+    detectFaces: vi.fn(),
   };
 };

server/test/repositories/media.repository.mock.ts

@@ -1,11 +1,12 @@
 import { IMediaRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newMediaRepositoryMock = (): jest.Mocked<IMediaRepository> => {
+export const newMediaRepositoryMock = (): Mocked<IMediaRepository> => {
   return {
-    generateThumbhash: jest.fn(),
-    resize: jest.fn(),
-    crop: jest.fn(),
-    probe: jest.fn(),
-    transcode: jest.fn(),
+    generateThumbhash: vi.fn(),
+    resize: vi.fn(),
+    crop: vi.fn(),
+    probe: vi.fn(),
+    transcode: vi.fn(),
   };
 };

server/test/repositories/metadata.repository.mock.ts

@@ -1,17 +1,18 @@
 import { IMetadataRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newMetadataRepositoryMock = (): jest.Mocked<IMetadataRepository> => {
+export const newMetadataRepositoryMock = (): Mocked<IMetadataRepository> => {
   return {
-    init: jest.fn(),
-    teardown: jest.fn(),
-    reverseGeocode: jest.fn(),
-    readTags: jest.fn(),
-    writeTags: jest.fn(),
-    extractBinaryTag: jest.fn(),
-    getCameraMakes: jest.fn(),
-    getCameraModels: jest.fn(),
-    getCities: jest.fn(),
-    getCountries: jest.fn(),
-    getStates: jest.fn(),
+    init: vi.fn(),
+    teardown: vi.fn(),
+    reverseGeocode: vi.fn(),
+    readTags: vi.fn(),
+    writeTags: vi.fn(),
+    extractBinaryTag: vi.fn(),
+    getCameraMakes: vi.fn(),
+    getCameraModels: vi.fn(),
+    getCities: vi.fn(),
+    getCountries: vi.fn(),
+    getStates: vi.fn(),
   };
 };

server/test/repositories/move.repository.mock.ts

@@ -1,10 +1,11 @@
 import { IMoveRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newMoveRepositoryMock = (): jest.Mocked<IMoveRepository> => {
+export const newMoveRepositoryMock = (): Mocked<IMoveRepository> => {
   return {
-    create: jest.fn(),
-    getByEntity: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
+    create: vi.fn(),
+    getByEntity: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
   };
 };

server/test/repositories/partner.repository.mock.ts

@@ -1,11 +1,12 @@
 import { IPartnerRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newPartnerRepositoryMock = (): jest.Mocked<IPartnerRepository> => {
+export const newPartnerRepositoryMock = (): Mocked<IPartnerRepository> => {
   return {
-    create: jest.fn(),
-    remove: jest.fn(),
-    getAll: jest.fn(),
-    get: jest.fn(),
-    update: jest.fn(),
+    create: vi.fn(),
+    remove: vi.fn(),
+    getAll: vi.fn(),
+    get: vi.fn(),
+    update: vi.fn(),
   };
 };

server/test/repositories/person.repository.mock.ts

@@ -1,32 +1,33 @@
 import { IPersonRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newPersonRepositoryMock = (): jest.Mocked<IPersonRepository> => {
+export const newPersonRepositoryMock = (): Mocked<IPersonRepository> => {
   return {
-    getById: jest.fn(),
-    getAll: jest.fn(),
-    getAllForUser: jest.fn(),
-    getAssets: jest.fn(),
-    getAllWithoutFaces: jest.fn(),
+    getById: vi.fn(),
+    getAll: vi.fn(),
+    getAllForUser: vi.fn(),
+    getAssets: vi.fn(),
+    getAllWithoutFaces: vi.fn(),
 
-    getByName: jest.fn(),
+    getByName: vi.fn(),
 
-    create: jest.fn(),
-    update: jest.fn(),
-    deleteAll: jest.fn(),
-    delete: jest.fn(),
-    deleteAllFaces: jest.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    deleteAll: vi.fn(),
+    delete: vi.fn(),
+    deleteAllFaces: vi.fn(),
 
-    getStatistics: jest.fn(),
-    getAllFaces: jest.fn(),
-    getFacesByIds: jest.fn(),
-    getRandomFace: jest.fn(),
+    getStatistics: vi.fn(),
+    getAllFaces: vi.fn(),
+    getFacesByIds: vi.fn(),
+    getRandomFace: vi.fn(),
 
-    reassignFaces: jest.fn(),
-    createFaces: jest.fn(),
-    getFaces: jest.fn(),
-    reassignFace: jest.fn(),
-    getFaceById: jest.fn(),
-    getFaceByIdWithAssets: jest.fn(),
-    getNumberOfPeople: jest.fn(),
+    reassignFaces: vi.fn(),
+    createFaces: vi.fn(),
+    getFaces: vi.fn(),
+    reassignFace: vi.fn(),
+    getFaceById: vi.fn(),
+    getFaceByIdWithAssets: vi.fn(),
+    getNumberOfPeople: vi.fn(),
   };
 };

server/test/repositories/search.repository.mock.ts

@@ -1,13 +1,14 @@
 import { ISearchRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newSearchRepositoryMock = (): jest.Mocked<ISearchRepository> => {
+export const newSearchRepositoryMock = (): Mocked<ISearchRepository> => {
   return {
-    init: jest.fn(),
-    searchMetadata: jest.fn(),
-    searchSmart: jest.fn(),
-    searchFaces: jest.fn(),
-    upsert: jest.fn(),
-    searchPlaces: jest.fn(),
-    deleteAllSearchEmbeddings: jest.fn(),
+    init: vi.fn(),
+    searchMetadata: vi.fn(),
+    searchSmart: vi.fn(),
+    searchFaces: vi.fn(),
+    upsert: vi.fn(),
+    searchPlaces: vi.fn(),
+    deleteAllSearchEmbeddings: vi.fn(),
   };
 };

server/test/repositories/shared-link.repository.mock.ts

@@ -1,12 +1,13 @@
 import { ISharedLinkRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newSharedLinkRepositoryMock = (): jest.Mocked<ISharedLinkRepository> => {
+export const newSharedLinkRepositoryMock = (): Mocked<ISharedLinkRepository> => {
   return {
-    getAll: jest.fn(),
-    get: jest.fn(),
-    getByKey: jest.fn(),
-    create: jest.fn(),
-    remove: jest.fn(),
-    update: jest.fn(),
+    getAll: vi.fn(),
+    get: vi.fn(),
+    getByKey: vi.fn(),
+    create: vi.fn(),
+    remove: vi.fn(),
+    update: vi.fn(),
   };
 };

server/test/repositories/storage.repository.mock.ts

@@ -1,5 +1,6 @@
 import { IStorageRepository, StorageCore, StorageEventType, WatchEvents } from '@app/domain';
 import { WatchOptions } from 'chokidar';
+import { Mocked } from 'vitest';
 
 interface MockWatcherOptions {
   items?: Array<{ event: 'change' | 'add' | 'unlink' | 'error'; value: string }>;
@@ -37,29 +38,29 @@ export const makeMockWatcher =
     return () => Promise.resolve();
   };
 
-export const newStorageRepositoryMock = (reset = true): jest.Mocked<IStorageRepository> => {
+export const newStorageRepositoryMock = (reset = true): Mocked<IStorageRepository> => {
   if (reset) {
     StorageCore.reset();
   }
 
   return {
-    createZipStream: jest.fn(),
-    createReadStream: jest.fn(),
-    readFile: jest.fn(),
-    writeFile: jest.fn(),
-    unlink: jest.fn(),
-    unlinkDir: jest.fn().mockResolvedValue(true),
-    removeEmptyDirs: jest.fn(),
-    checkFileExists: jest.fn(),
-    mkdirSync: jest.fn(),
-    checkDiskUsage: jest.fn(),
-    readdir: jest.fn(),
-    stat: jest.fn(),
-    crawl: jest.fn(),
-    walk: jest.fn().mockImplementation(async function* () {}),
-    rename: jest.fn(),
-    copyFile: jest.fn(),
-    utimes: jest.fn(),
-    watch: jest.fn().mockImplementation(makeMockWatcher({})),
+    createZipStream: vi.fn(),
+    createReadStream: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    unlink: vi.fn(),
+    unlinkDir: vi.fn().mockResolvedValue(true),
+    removeEmptyDirs: vi.fn(),
+    checkFileExists: vi.fn(),
+    mkdirSync: vi.fn(),
+    checkDiskUsage: vi.fn(),
+    readdir: vi.fn(),
+    stat: vi.fn(),
+    crawl: vi.fn(),
+    walk: vi.fn().mockImplementation(async function* () {}),
+    rename: vi.fn(),
+    copyFile: vi.fn(),
+    utimes: vi.fn(),
+    watch: vi.fn().mockImplementation(makeMockWatcher({})),
   };
 };

server/test/repositories/system-config.repository.mock.ts

@@ -1,15 +1,16 @@
 import { ISystemConfigRepository, SystemConfigCore } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newSystemConfigRepositoryMock = (reset = true): jest.Mocked<ISystemConfigRepository> => {
+export const newSystemConfigRepositoryMock = (reset = true): Mocked<ISystemConfigRepository> => {
   if (reset) {
     SystemConfigCore.reset();
   }
 
   return {
-    fetchStyle: jest.fn(),
-    load: jest.fn().mockResolvedValue([]),
-    readFile: jest.fn(),
-    saveAll: jest.fn().mockResolvedValue([]),
-    deleteKeys: jest.fn(),
+    fetchStyle: vi.fn(),
+    load: vi.fn().mockResolvedValue([]),
+    readFile: vi.fn(),
+    saveAll: vi.fn().mockResolvedValue([]),
+    deleteKeys: vi.fn(),
   };
 };

server/test/repositories/system-info.repository.mock.ts

@@ -1,7 +1,8 @@
 import { IServerInfoRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newServerInfoRepositoryMock = (): jest.Mocked<IServerInfoRepository> => {
+export const newServerInfoRepositoryMock = (): Mocked<IServerInfoRepository> => {
   return {
-    getGitHubRelease: jest.fn(),
+    getGitHubRelease: vi.fn(),
   };
 };

server/test/repositories/system-metadata.repository.mock.ts

@@ -1,8 +1,9 @@
 import { ISystemMetadataRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newSystemMetadataRepositoryMock = (): jest.Mocked<ISystemMetadataRepository> => {
+export const newSystemMetadataRepositoryMock = (): Mocked<ISystemMetadataRepository> => {
   return {
-    get: jest.fn(),
-    set: jest.fn(),
+    get: vi.fn() as any,
+    set: vi.fn(),
   };
 };

server/test/repositories/tag.repository.mock.ts

@@ -1,16 +1,17 @@
 import { ITagRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newTagRepositoryMock = (): jest.Mocked<ITagRepository> => {
+export const newTagRepositoryMock = (): Mocked<ITagRepository> => {
   return {
-    getAll: jest.fn(),
-    getById: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    remove: jest.fn(),
-    hasAsset: jest.fn(),
-    hasName: jest.fn(),
-    getAssets: jest.fn(),
-    addAssets: jest.fn(),
-    removeAssets: jest.fn(),
+    getAll: vi.fn(),
+    getById: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    remove: vi.fn(),
+    hasAsset: vi.fn(),
+    hasName: vi.fn(),
+    getAssets: vi.fn(),
+    addAssets: vi.fn(),
+    removeAssets: vi.fn(),
   };
 };

server/test/repositories/user-token.repository.mock.ts

@@ -1,11 +1,12 @@
 import { IUserTokenRepository } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newUserTokenRepositoryMock = (): jest.Mocked<IUserTokenRepository> => {
+export const newUserTokenRepositoryMock = (): Mocked<IUserTokenRepository> => {
   return {
-    create: jest.fn(),
-    save: jest.fn(),
-    delete: jest.fn(),
-    getByToken: jest.fn(),
-    getAll: jest.fn(),
+    create: vi.fn(),
+    save: vi.fn(),
+    delete: vi.fn(),
+    getByToken: vi.fn(),
+    getAll: vi.fn(),
   };
 };

server/test/repositories/user.repository.mock.ts

@@ -1,24 +1,25 @@
 import { IUserRepository, UserCore } from '@app/domain';
+import { Mocked } from 'vitest';
 
-export const newUserRepositoryMock = (reset = true): jest.Mocked<IUserRepository> => {
+export const newUserRepositoryMock = (reset = true): Mocked<IUserRepository> => {
   if (reset) {
     UserCore.reset();
   }
 
   return {
-    get: jest.fn(),
-    getAdmin: jest.fn(),
-    getByEmail: jest.fn(),
-    getByStorageLabel: jest.fn(),
-    getByOAuthId: jest.fn(),
-    getUserStats: jest.fn(),
-    getList: jest.fn(),
-    create: jest.fn(),
-    update: jest.fn(),
-    delete: jest.fn(),
-    getDeletedUsers: jest.fn(),
-    hasAdmin: jest.fn(),
-    updateUsage: jest.fn(),
-    syncUsage: jest.fn(),
+    get: vi.fn(),
+    getAdmin: vi.fn(),
+    getByEmail: vi.fn(),
+    getByStorageLabel: vi.fn(),
+    getByOAuthId: vi.fn(),
+    getUserStats: vi.fn(),
+    getList: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+    getDeletedUsers: vi.fn(),
+    hasAdmin: vi.fn(),
+    updateUsage: vi.fn(),
+    syncUsage: vi.fn(),
   };
 };

server/tsconfig.build.json

@@ -1,4 +1,4 @@
 {
   "extends": "./tsconfig.json",
-  "exclude": ["dist", "node_modules", "upload", "test", "e2e", "**/*spec.ts"]
+  "exclude": ["dist", "node_modules", "upload", "test", "e2e", "**/*spec.ts", "vitest.config.ts"]
 }

server/tsconfig.json

@@ -25,8 +25,9 @@
       "@app/infra": ["src/infra"],
       "@app/infra/*": ["src/infra/*"],
       "@app/domain": ["src/domain"],
-      "@app/domain/*": ["src/domain/*"],
+      "@app/domain/*": ["src/domain/*"]
     },
+    "types": ["vitest/globals"]
   },
-  "exclude": ["dist", "node_modules", "upload"],
+  "exclude": ["dist", "node_modules", "upload", "vitest.config.ts"]
 }

server/vitest.config.mts

@@ -0,0 +1,32 @@
+import path from 'node:path';
+import 'reflect-metadata';
+import swc from 'unplugin-swc';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    server: {
+      deps: {
+        fallbackCJS: true,
+      },
+    },
+  },
+  plugins: [
+    swc.vite({
+      jsc: {
+        baseUrl: path.resolve('./'),
+        paths: {
+          '@test': ['test'],
+          '@test/*': ['test/*'],
+          '@app/immich': ['src/immich'],
+          '@app/immich/*': ['src/immich/*'],
+          '@app/infra': ['src/infra'],
+          '@app/infra/*': ['src/infra/*'],
+          '@app/domain': ['src/domain'],
+          '@app/domain/*': ['src/domain/*'],
+        },
+      },
+    }),
+  ],
+});