Merge branch 'main' into feature/readonly-sharing

# Conflicts:
#	mobile/openapi/.openapi-generator/FILES
#	mobile/openapi/README.md
#	mobile/openapi/lib/api.dart
#	mobile/openapi/lib/api_client.dart
#	server/src/services/album.service.spec.ts

server/src/app.module.ts

@@ -5,28 +5,29 @@ import { APP_GUARD, APP_INTERCEPTOR, APP_PIPE } from '@nestjs/core';
 import { EventEmitterModule } from '@nestjs/event-emitter';
 import { ScheduleModule, SchedulerRegistry } from '@nestjs/schedule';
 import { TypeOrmModule } from '@nestjs/typeorm';
+import { ClsModule } from 'nestjs-cls';
 import { OpenTelemetryModule } from 'nestjs-otel';
 import { commands } from 'src/commands';
-import { bullConfig, bullQueues, immichAppConfig } from 'src/config';
+import { bullConfig, bullQueues, clsConfig, immichAppConfig } from 'src/config';
 import { controllers } from 'src/controllers';
 import { databaseConfig } from 'src/database.config';
 import { entities } from 'src/entities';
 import { AuthGuard } from 'src/middleware/auth.guard';
 import { ErrorInterceptor } from 'src/middleware/error.interceptor';
 import { FileUploadInterceptor } from 'src/middleware/file-upload.interceptor';
+import { LoggingInterceptor } from 'src/middleware/logging.interceptor';
 import { repositories } from 'src/repositories';
 import { services } from 'src/services';
 import { ApiService } from 'src/services/api.service';
 import { MicroservicesService } from 'src/services/microservices.service';
 import { otelConfig } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 
-const providers = [ImmichLogger];
-const common = [...services, ...providers, ...repositories];
+const common = [...services, ...repositories];
 
 const middleware = [
   FileUploadInterceptor,
   { provide: APP_PIPE, useValue: new ValidationPipe({ transform: true, whitelist: true }) },
+  { provide: APP_INTERCEPTOR, useClass: LoggingInterceptor },
   { provide: APP_INTERCEPTOR, useClass: ErrorInterceptor },
   { provide: APP_GUARD, useClass: AuthGuard },
 ];
@@ -34,6 +35,7 @@ const middleware = [
 const imports = [
   BullModule.forRoot(bullConfig),
   BullModule.registerQueue(...bullQueues),
+  ClsModule.forRoot(clsConfig),
   ConfigModule.forRoot(immichAppConfig),
   EventEmitterModule.forRoot(),
   OpenTelemetryModule.forRoot(otelConfig),

server/src/commands/reset-admin-password.command.ts

@@ -9,7 +9,7 @@ import { UserService } from 'src/services/user.service';
 export class ResetAdminPasswordCommand extends CommandRunner {
   constructor(
     private userService: UserService,
-    private readonly inquirer: InquirerService,
+    private inquirer: InquirerService,
   ) {
     super();
   }

server/src/config.ts

@@ -1,8 +1,10 @@
 import { RegisterQueueOptions } from '@nestjs/bullmq';
 import { ConfigModuleOptions } from '@nestjs/config';
 import { QueueOptions } from 'bullmq';
+import { Request, Response } from 'express';
 import { RedisOptions } from 'ioredis';
 import Joi from 'joi';
+import { CLS_ID, ClsModuleOptions } from 'nestjs-cls';
 import { LogLevel } from 'src/entities/system-config.entity';
 import { QueueName } from 'src/interfaces/job.interface';
 
@@ -69,3 +71,17 @@ export const bullConfig: QueueOptions = {
 };
 
 export const bullQueues: RegisterQueueOptions[] = Object.values(QueueName).map((name) => ({ name }));
+
+export const clsConfig: ClsModuleOptions = {
+  middleware: {
+    mount: true,
+    generateId: true,
+    setup: (cls, req: Request, res: Response) => {
+      const headerValues = req.headers['x-immich-cid'];
+      const headerValue = Array.isArray(headerValues) ? headerValues[0] : headerValues;
+      const cid = headerValue || cls.get(CLS_ID);
+      cls.set(CLS_ID, cid);
+      res.header('x-immich-cid', cid);
+    },
+  },
+};

server/src/controllers/index.ts

@@ -17,6 +17,7 @@ import { PersonController } from 'src/controllers/person.controller';
 import { SearchController } from 'src/controllers/search.controller';
 import { ServerInfoController } from 'src/controllers/server-info.controller';
 import { SharedLinkController } from 'src/controllers/shared-link.controller';
+import { SyncController } from 'src/controllers/sync.controller';
 import { SystemConfigController } from 'src/controllers/system-config.controller';
 import { TagController } from 'src/controllers/tag.controller';
 import { TimelineController } from 'src/controllers/timeline.controller';
@@ -43,6 +44,7 @@ export const controllers = [
   SearchController,
   ServerInfoController,
   SharedLinkController,
+  SyncController,
   SystemConfigController,
   TagController,
   TimelineController,

server/src/controllers/shared-link.controller.ts

@@ -19,7 +19,7 @@ import { UUIDParamDto } from 'src/validation';
 @Controller('shared-link')
 @Authenticated()
 export class SharedLinkController {
-  constructor(private readonly service: SharedLinkService) {}
+  constructor(private service: SharedLinkService) {}
 
   @Get()
   getAllSharedLinks(@Auth() auth: AuthDto): Promise<SharedLinkResponseDto[]> {

server/src/controllers/sync.controller.ts

@@ -0,0 +1,24 @@
+import { Controller, Get, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { AssetResponseDto } from 'src/dtos/asset-response.dto';
+import { AuthDto } from 'src/dtos/auth.dto';
+import { AssetDeltaSyncDto, AssetDeltaSyncResponseDto, AssetFullSyncDto } from 'src/dtos/sync.dto';
+import { Auth, Authenticated } from 'src/middleware/auth.guard';
+import { SyncService } from 'src/services/sync.service';
+
+@ApiTags('Sync')
+@Controller('sync')
+@Authenticated()
+export class SyncController {
+  constructor(private service: SyncService) {}
+
+  @Get('full-sync')
+  getAllForUserFullSync(@Auth() auth: AuthDto, @Query() dto: AssetFullSyncDto): Promise<AssetResponseDto[]> {
+    return this.service.getAllAssetsForUserFullSync(auth, dto);
+  }
+
+  @Get('delta-sync')
+  getDeltaSync(@Auth() auth: AuthDto, @Query() dto: AssetDeltaSyncDto): Promise<AssetDeltaSyncResponseDto> {
+    return this.service.getChangesForDeltaSync(auth, dto);
+  }
+}

server/src/controllers/system-config.controller.ts

@@ -8,7 +8,7 @@ import { SystemConfigService } from 'src/services/system-config.service';
 @Controller('system-config')
 @Authenticated({ admin: true })
 export class SystemConfigController {
-  constructor(private readonly service: SystemConfigService) {}
+  constructor(private service: SystemConfigService) {}
 
   @Get()
   getConfig(): Promise<SystemConfigDto> {

server/src/cores/storage.core.spec.ts

@@ -1,6 +1,7 @@
 import { StorageCore } from 'src/cores/storage.core';
+import { vitest } from 'vitest';
 
-jest.mock('src/constants', () => ({
+vitest.mock('src/constants', () => ({
   APP_MEDIA_LOCATION: '/photos',
 }));
 

server/src/cores/storage.core.ts

@@ -7,11 +7,11 @@ import { PersonEntity } from 'src/entities/person.entity';
 import { ImageFormat } from 'src/entities/system-config.entity';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 
 export enum StorageFolder {
   ENCODED_VIDEO = 'encoded-video',
@@ -41,35 +41,37 @@ export type GeneratedAssetType = GeneratedImageType | AssetPathType.ENCODED_VIDE
 let instance: StorageCore | null;
 
 export class StorageCore {
-  private logger = new ImmichLogger(StorageCore.name);
   private configCore;
   private constructor(
     private assetRepository: IAssetRepository,
+    private cryptoRepository: ICryptoRepository,
     private moveRepository: IMoveRepository,
     private personRepository: IPersonRepository,
-    private cryptoRepository: ICryptoRepository,
-    private repository: IStorageRepository,
+    private storageRepository: IStorageRepository,
     systemConfigRepository: ISystemConfigRepository,
+    private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(systemConfigRepository);
+    this.configCore = SystemConfigCore.create(systemConfigRepository, this.logger);
   }
 
   static create(
     assetRepository: IAssetRepository,
+    cryptoRepository: ICryptoRepository,
     moveRepository: IMoveRepository,
     personRepository: IPersonRepository,
-    cryptoRepository: ICryptoRepository,
-    configRepository: ISystemConfigRepository,
-    repository: IStorageRepository,
+    storageRepository: IStorageRepository,
+    systemConfigRepository: ISystemConfigRepository,
+    logger: ILoggerRepository,
   ) {
     if (!instance) {
       instance = new StorageCore(
         assetRepository,
+        cryptoRepository,
         moveRepository,
         personRepository,
-        cryptoRepository,
-        repository,
-        configRepository,
+        storageRepository,
+        systemConfigRepository,
+        logger,
       );
     }
 
@@ -170,8 +172,8 @@ export class StorageCore {
     let move = await this.moveRepository.getByEntity(entityId, pathType);
     if (move) {
       this.logger.log(`Attempting to finish incomplete move: ${move.oldPath} => ${move.newPath}`);
-      const oldPathExists = await this.repository.checkFileExists(move.oldPath);
-      const newPathExists = await this.repository.checkFileExists(move.newPath);
+      const oldPathExists = await this.storageRepository.checkFileExists(move.oldPath);
+      const newPathExists = await this.storageRepository.checkFileExists(move.newPath);
       const newPathCheck = newPathExists ? move.newPath : null;
       const actualPath = oldPathExists ? move.oldPath : newPathCheck;
       if (!actualPath) {
@@ -205,7 +207,7 @@ export class StorageCore {
     if (move.oldPath !== newPath) {
       try {
         this.logger.debug(`Attempting to rename file: ${move.oldPath} => ${newPath}`);
-        await this.repository.rename(move.oldPath, newPath);
+        await this.storageRepository.rename(move.oldPath, newPath);
       } catch (error: any) {
         if (error.code !== 'EXDEV') {
           this.logger.warn(
@@ -214,19 +216,19 @@ export class StorageCore {
           return;
         }
         this.logger.debug(`Unable to rename file. Falling back to copy, verify and delete`);
-        await this.repository.copyFile(move.oldPath, newPath);
+        await this.storageRepository.copyFile(move.oldPath, newPath);
 
         if (!(await this.verifyNewPathContentsMatchesExpected(move.oldPath, newPath, assetInfo))) {
           this.logger.warn(`Skipping move due to file size mismatch`);
-          await this.repository.unlink(newPath);
+          await this.storageRepository.unlink(newPath);
           return;
         }
 
-        const { atime, mtime } = await this.repository.stat(move.oldPath);
-        await this.repository.utimes(newPath, atime, mtime);
+        const { atime, mtime } = await this.storageRepository.stat(move.oldPath);
+        await this.storageRepository.utimes(newPath, atime, mtime);
 
         try {
-          await this.repository.unlink(move.oldPath);
+          await this.storageRepository.unlink(move.oldPath);
         } catch (error: any) {
           this.logger.warn(`Unable to delete old file, it will now no longer be tracked by Immich: ${error.message}`);
         }
@@ -242,8 +244,8 @@ export class StorageCore {
     newPath: string,
     assetInfo?: { sizeInBytes: number; checksum: Buffer },
   ) {
-    const oldStat = await this.repository.stat(oldPath);
-    const newStat = await this.repository.stat(newPath);
+    const oldStat = await this.storageRepository.stat(oldPath);
+    const newStat = await this.storageRepository.stat(newPath);
     const oldPathSize = assetInfo ? assetInfo.sizeInBytes : oldStat.size;
     const newPathSize = newStat.size;
     this.logger.debug(`File size check: ${newPathSize} === ${oldPathSize}`);
@@ -269,11 +271,11 @@ export class StorageCore {
   }
 
   ensureFolders(input: string) {
-    this.repository.mkdirSync(dirname(input));
+    this.storageRepository.mkdirSync(dirname(input));
   }
 
   removeEmptyDirs(folder: StorageFolder) {
-    return this.repository.removeEmptyDirs(StorageCore.getBaseFolder(folder));
+    return this.storageRepository.removeEmptyDirs(StorageCore.getBaseFolder(folder));
   }
 
   private savePath(pathType: PathType, id: string, newPath: string) {

server/src/cores/system-config.core.ts

@@ -22,8 +22,8 @@ import {
   VideoCodec,
 } from 'src/entities/system-config.entity';
 import { QueueName } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 
 export type SystemConfigValidator = (config: SystemConfig, newConfig: SystemConfig) => void | Promise<void>;
 
@@ -169,16 +169,18 @@ let instance: SystemConfigCore | null;
 
 @Injectable()
 export class SystemConfigCore {
-  private logger = new ImmichLogger(SystemConfigCore.name);
   private configCache: SystemConfigEntity<SystemConfigValue>[] | null = null;
 
   public config$ = new Subject<SystemConfig>();
 
-  private constructor(private repository: ISystemConfigRepository) {}
+  private constructor(
+    private repository: ISystemConfigRepository,
+    private logger: ILoggerRepository,
+  ) {}
 
-  static create(repository: ISystemConfigRepository) {
+  static create(repository: ISystemConfigRepository, logger: ILoggerRepository) {
     if (!instance) {
-      instance = new SystemConfigCore(repository);
+      instance = new SystemConfigCore(repository, logger);
     }
     return instance;
   }

server/src/dtos/sync.dto.ts

@@ -0,0 +1,38 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsInt, IsPositive } from 'class-validator';
+import { AssetResponseDto } from 'src/dtos/asset-response.dto';
+import { ValidateDate, ValidateUUID } from 'src/validation';
+
+export class AssetFullSyncDto {
+  @ValidateUUID({ optional: true })
+  lastId?: string;
+
+  @ValidateDate({ optional: true })
+  lastCreationDate?: Date;
+
+  @ValidateDate()
+  updatedUntil!: Date;
+
+  @IsInt()
+  @IsPositive()
+  @Type(() => Number)
+  @ApiProperty({ type: 'integer' })
+  limit!: number;
+
+  @ValidateUUID({ optional: true })
+  userId?: string;
+}
+
+export class AssetDeltaSyncDto {
+  @ValidateDate()
+  updatedAfter!: Date;
+  @ValidateUUID({ each: true })
+  userIds!: string[];
+}
+
+export class AssetDeltaSyncResponseDto {
+  needsFullSync!: boolean;
+  upserted!: AssetResponseDto[];
+  deleted!: string[];
+}

server/src/interfaces/asset.interface.ts

@@ -133,6 +133,20 @@ export interface MetadataSearchOptions {
   numResults: number;
 }
 
+export interface AssetFullSyncOptions {
+  ownerId: string;
+  lastCreationDate?: Date;
+  lastId?: string;
+  updatedUntil: Date;
+  limit: number;
+}
+
+export interface AssetDeltaSyncOptions {
+  userIds: string[];
+  updatedAfter: Date;
+  limit: number;
+}
+
 export type AssetPathEntity = Pick<AssetEntity, 'id' | 'originalPath' | 'isOffline'>;
 
 export const IAssetRepository = 'IAssetRepository';
@@ -155,7 +169,7 @@ export interface IAssetRepository {
   getRandom(userId: string, count: number): Promise<AssetEntity[]>;
   getFirstAssetForAlbumId(albumId: string): Promise<AssetEntity | null>;
   getLastUpdatedAssetForAlbumId(albumId: string): Promise<AssetEntity | null>;
-  getLibraryAssetPaths(pagination: PaginationOptions, libraryId: string): Paginated<AssetPathEntity>;
+  getExternalLibraryAssetPaths(pagination: PaginationOptions, libraryId: string): Paginated<AssetPathEntity>;
   getByLibraryIdAndOriginalPath(libraryId: string, originalPath: string): Promise<AssetEntity | null>;
   deleteAll(ownerId: string): Promise<void>;
   getAll(pagination: PaginationOptions, options?: AssetSearchOptions): Paginated<AssetEntity>;
@@ -175,4 +189,6 @@ export interface IAssetRepository {
   getAssetIdByCity(userId: string, options: AssetExploreFieldOptions): Promise<SearchExploreItem<string>>;
   getAssetIdByTag(userId: string, options: AssetExploreFieldOptions): Promise<SearchExploreItem<string>>;
   searchMetadata(query: string, userIds: string[], options: MetadataSearchOptions): Promise<AssetEntity[]>;
+  getAllForUserFullSync(options: AssetFullSyncOptions): Promise<AssetEntity[]>;
+  getChangedDeltaSync(options: AssetDeltaSyncOptions): Promise<AssetEntity[]>;
 }

server/src/interfaces/audit.interface.ts

@@ -1,14 +1,14 @@
-import { AuditEntity, DatabaseAction, EntityType } from 'src/entities/audit.entity';
+import { DatabaseAction, EntityType } from 'src/entities/audit.entity';
 
 export const IAuditRepository = 'IAuditRepository';
 
 export interface AuditSearch {
   action?: DatabaseAction;
   entityType?: EntityType;
-  ownerId?: string;
+  userIds: string[];
 }
 
 export interface IAuditRepository {
-  getAfter(since: Date, options: AuditSearch): Promise<AuditEntity[]>;
+  getAfter(since: Date, options: AuditSearch): Promise<string[]>;
   removeBefore(before: Date): Promise<void>;
 }

server/src/interfaces/logger.interface.ts

@@ -0,0 +1,15 @@
+import { LogLevel } from 'src/entities/system-config.entity';
+
+export const ILoggerRepository = 'ILoggerRepository';
+
+export interface ILoggerRepository {
+  setContext(message: string): void;
+  setLogLevel(level: LogLevel): void;
+
+  verbose(message: any, ...args: any): void;
+  debug(message: any, ...args: any): void;
+  log(message: any, ...args: any): void;
+  warn(message: any, ...args: any): void;
+  error(message: any, ...args: any): void;
+  fatal(message: any, ...args: any): void;
+}

server/src/interfaces/storage.interface.ts

@@ -31,14 +31,6 @@ export interface WatchEvents {
   onError(error: Error): void;
 }
 
-export enum StorageEventType {
-  READY = 'ready',
-  ADD = 'add',
-  CHANGE = 'change',
-  UNLINK = 'unlink',
-  ERROR = 'error',
-}
-
 export interface IStorageRepository {
   createZipStream(): ImmichZipStream;
   createReadStream(filepath: string, mimeType?: string | null): Promise<ImmichReadStream>;

server/src/main.ts

@@ -8,34 +8,38 @@ import sirv from 'sirv';
 import { ApiModule, ImmichAdminModule, MicroservicesModule } from 'src/app.module';
 import { WEB_ROOT, envName, excludePaths, isDev, serverVersion } from 'src/constants';
 import { LogLevel } from 'src/entities/system-config.entity';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { WebSocketAdapter } from 'src/middleware/websocket.adapter';
 import { ApiService } from 'src/services/api.service';
 import { otelSDK } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 import { useSwagger } from 'src/utils/misc';
 
 async function bootstrapMicroservices() {
-  const logger = new ImmichLogger('ImmichMicroservice');
-  const port = Number(process.env.MICROSERVICES_PORT) || 3002;
-
   otelSDK.start();
+
+  const host = String(process.env.HOST || '0.0.0.0');
+  const port = Number(process.env.MICROSERVICES_PORT) || 3002;
   const app = await NestFactory.create(MicroservicesModule, { bufferLogs: true });
-  app.useLogger(app.get(ImmichLogger));
+  const logger = await app.resolve(ILoggerRepository);
+  logger.setContext('ImmichMicroservice');
+  app.useLogger(logger);
   app.useWebSocketAdapter(new WebSocketAdapter(app));
 
-  await app.listen(port);
+  await app.listen(port, host);
 
   logger.log(`Immich Microservices is listening on ${await app.getUrl()} [v${serverVersion}] [${envName}] `);
 }
 
 async function bootstrapApi() {
-  const logger = new ImmichLogger('ImmichServer');
-  const port = Number(process.env.SERVER_PORT) || 3001;
-
   otelSDK.start();
-  const app = await NestFactory.create<NestExpressApplication>(ApiModule, { bufferLogs: true });
 
-  app.useLogger(app.get(ImmichLogger));
+  const host = String(process.env.HOST || '0.0.0.0');
+  const port = Number(process.env.SERVER_PORT) || 3001;
+  const app = await NestFactory.create<NestExpressApplication>(ApiModule, { bufferLogs: true });
+  const logger = await app.resolve(ILoggerRepository);
+
+  logger.setContext('ImmichServer');
+  app.useLogger(logger);
   app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']);
   app.set('etag', 'strong');
   app.use(cookieParser());
@@ -65,7 +69,7 @@ async function bootstrapApi() {
   }
   app.use(app.get(ApiService).ssr(excludePaths));
 
-  const server = await app.listen(port);
+  const server = await app.listen(port, host);
   server.requestTimeout = 30 * 60 * 1000;
 
   logger.log(`Immich Server is listening on ${await app.getUrl()} [v${serverVersion}] [${envName}] `);

server/src/middleware/auth.guard.ts

@@ -1,6 +1,7 @@
 import {
   CanActivate,
   ExecutionContext,
+  Inject,
   Injectable,
   SetMetadata,
   applyDecorators,
@@ -11,8 +12,8 @@ import { ApiBearerAuth, ApiCookieAuth, ApiOkResponse, ApiQuery, ApiSecurity } fr
 import { Request } from 'express';
 import { IMMICH_API_KEY_NAME } from 'src/constants';
 import { AuthDto } from 'src/dtos/auth.dto';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AuthService, LoginDetails } from 'src/services/auth.service';
-import { ImmichLogger } from 'src/utils/logger';
 import { UAParser } from 'ua-parser-js';
 
 export enum Metadata {
@@ -79,12 +80,13 @@ export interface AuthRequest extends Request {
 
 @Injectable()
 export class AuthGuard implements CanActivate {
-  private logger = new ImmichLogger(AuthGuard.name);
-
   constructor(
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
     private reflector: Reflector,
     private authService: AuthService,
-  ) {}
+  ) {
+    this.logger.setContext(AuthGuard.name);
+  }
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
     const targets = [context.getHandler(), context.getClass()];

server/src/middleware/error.interceptor.ts

@@ -2,17 +2,20 @@ import {
   CallHandler,
   ExecutionContext,
   HttpException,
+  Inject,
   Injectable,
   InternalServerErrorException,
   NestInterceptor,
 } from '@nestjs/common';
 import { Observable, catchError, throwError } from 'rxjs';
-import { ImmichLogger } from 'src/utils/logger';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { isConnectionAborted, routeToErrorMessage } from 'src/utils/misc';
 
 @Injectable()
 export class ErrorInterceptor implements NestInterceptor {
-  private logger = new ImmichLogger(ErrorInterceptor.name);
+  constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {
+    this.logger.setContext(ErrorInterceptor.name);
+  }
 
   intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> {
     return next.handle().pipe(

server/src/middleware/file-upload.interceptor.ts

@@ -1,4 +1,4 @@
-import { CallHandler, ExecutionContext, Injectable, NestInterceptor } from '@nestjs/common';
+import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor } from '@nestjs/common';
 import { PATH_METADATA } from '@nestjs/common/constants';
 import { Reflector } from '@nestjs/core';
 import { transformException } from '@nestjs/platform-express/multer/multer/multer.utils';
@@ -7,9 +7,9 @@ import multer, { StorageEngine, diskStorage } from 'multer';
 import { createHash, randomUUID } from 'node:crypto';
 import { Observable } from 'rxjs';
 import { UploadFieldName } from 'src/dtos/asset.dto';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AuthRequest } from 'src/middleware/auth.guard';
 import { AssetService, UploadFile } from 'src/services/asset.service';
-import { ImmichLogger } from 'src/utils/logger';
 
 export enum Route {
   ASSET = 'asset',
@@ -59,8 +59,6 @@ const asRequest = (request: AuthRequest, file: Express.Multer.File) => {
 
 @Injectable()
 export class FileUploadInterceptor implements NestInterceptor {
-  private logger = new ImmichLogger(FileUploadInterceptor.name);
-
   private handlers: {
     userProfile: RequestHandler;
     assetUpload: RequestHandler;
@@ -70,7 +68,10 @@ export class FileUploadInterceptor implements NestInterceptor {
   constructor(
     private reflect: Reflector,
     private assetService: AssetService,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
+    this.logger.setContext(FileUploadInterceptor.name);
+
     this.defaultStorage = diskStorage({
       filename: this.filename.bind(this),
       destination: this.destination.bind(this),

server/src/middleware/logging.interceptor.ts

@@ -0,0 +1,28 @@
+import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor } from '@nestjs/common';
+import { Observable, finalize } from 'rxjs';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
+
+@Injectable()
+export class LoggingInterceptor implements NestInterceptor {
+  constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {
+    this.logger.setContext(LoggingInterceptor.name);
+  }
+
+  intercept(context: ExecutionContext, next: CallHandler<any>): Observable<any> {
+    const handler = context.switchToHttp();
+    const req = handler.getRequest();
+    const res = handler.getResponse();
+
+    const { method, ip, path } = req;
+
+    const start = performance.now();
+    return next.handle().pipe(
+      finalize(() => {
+        const finish = performance.now();
+        const duration = (finish - start).toFixed(2);
+        const { statusCode } = res;
+        this.logger.verbose(`${method} ${path} ${statusCode} ${duration}ms ${ip}`);
+      }),
+    );
+  }
+}

server/src/queries/asset.repository.sql

@@ -253,7 +253,7 @@ DELETE FROM "assets"
 WHERE
   "ownerId" = $1
 
--- AssetRepository.getLibraryAssetPaths
+-- AssetRepository.getExternalLibraryAssetPaths
 SELECT DISTINCT
   "distinctAlias"."AssetEntity_id" AS "ids_AssetEntity_id"
 FROM
@@ -272,6 +272,7 @@ FROM
       (
         (
           ((("AssetEntity__AssetEntity_library"."id" = $1)))
+          AND ("AssetEntity"."isExternal" = $2)
         )
       )
       AND ("AssetEntity"."deletedAt" IS NULL)
@@ -767,3 +768,151 @@ ORDER BY
   "asset"."fileCreatedAt" DESC
 LIMIT
   250
+
+-- AssetRepository.getAllForUserFullSync
+SELECT
+  "asset"."id" AS "asset_id",
+  "asset"."deviceAssetId" AS "asset_deviceAssetId",
+  "asset"."ownerId" AS "asset_ownerId",
+  "asset"."libraryId" AS "asset_libraryId",
+  "asset"."deviceId" AS "asset_deviceId",
+  "asset"."type" AS "asset_type",
+  "asset"."originalPath" AS "asset_originalPath",
+  "asset"."previewPath" AS "asset_previewPath",
+  "asset"."thumbnailPath" AS "asset_thumbnailPath",
+  "asset"."thumbhash" AS "asset_thumbhash",
+  "asset"."encodedVideoPath" AS "asset_encodedVideoPath",
+  "asset"."createdAt" AS "asset_createdAt",
+  "asset"."updatedAt" AS "asset_updatedAt",
+  "asset"."deletedAt" AS "asset_deletedAt",
+  "asset"."fileCreatedAt" AS "asset_fileCreatedAt",
+  "asset"."localDateTime" AS "asset_localDateTime",
+  "asset"."fileModifiedAt" AS "asset_fileModifiedAt",
+  "asset"."isFavorite" AS "asset_isFavorite",
+  "asset"."isArchived" AS "asset_isArchived",
+  "asset"."isExternal" AS "asset_isExternal",
+  "asset"."isReadOnly" AS "asset_isReadOnly",
+  "asset"."isOffline" AS "asset_isOffline",
+  "asset"."checksum" AS "asset_checksum",
+  "asset"."duration" AS "asset_duration",
+  "asset"."isVisible" AS "asset_isVisible",
+  "asset"."livePhotoVideoId" AS "asset_livePhotoVideoId",
+  "asset"."originalFileName" AS "asset_originalFileName",
+  "asset"."sidecarPath" AS "asset_sidecarPath",
+  "asset"."stackId" AS "asset_stackId",
+  "exifInfo"."assetId" AS "exifInfo_assetId",
+  "exifInfo"."description" AS "exifInfo_description",
+  "exifInfo"."exifImageWidth" AS "exifInfo_exifImageWidth",
+  "exifInfo"."exifImageHeight" AS "exifInfo_exifImageHeight",
+  "exifInfo"."fileSizeInByte" AS "exifInfo_fileSizeInByte",
+  "exifInfo"."orientation" AS "exifInfo_orientation",
+  "exifInfo"."dateTimeOriginal" AS "exifInfo_dateTimeOriginal",
+  "exifInfo"."modifyDate" AS "exifInfo_modifyDate",
+  "exifInfo"."timeZone" AS "exifInfo_timeZone",
+  "exifInfo"."latitude" AS "exifInfo_latitude",
+  "exifInfo"."longitude" AS "exifInfo_longitude",
+  "exifInfo"."projectionType" AS "exifInfo_projectionType",
+  "exifInfo"."city" AS "exifInfo_city",
+  "exifInfo"."livePhotoCID" AS "exifInfo_livePhotoCID",
+  "exifInfo"."autoStackId" AS "exifInfo_autoStackId",
+  "exifInfo"."state" AS "exifInfo_state",
+  "exifInfo"."country" AS "exifInfo_country",
+  "exifInfo"."make" AS "exifInfo_make",
+  "exifInfo"."model" AS "exifInfo_model",
+  "exifInfo"."lensModel" AS "exifInfo_lensModel",
+  "exifInfo"."fNumber" AS "exifInfo_fNumber",
+  "exifInfo"."focalLength" AS "exifInfo_focalLength",
+  "exifInfo"."iso" AS "exifInfo_iso",
+  "exifInfo"."exposureTime" AS "exifInfo_exposureTime",
+  "exifInfo"."profileDescription" AS "exifInfo_profileDescription",
+  "exifInfo"."colorspace" AS "exifInfo_colorspace",
+  "exifInfo"."bitsPerSample" AS "exifInfo_bitsPerSample",
+  "exifInfo"."fps" AS "exifInfo_fps",
+  "stack"."id" AS "stack_id",
+  "stack"."primaryAssetId" AS "stack_primaryAssetId"
+FROM
+  "assets" "asset"
+  LEFT JOIN "exif" "exifInfo" ON "exifInfo"."assetId" = "asset"."id"
+  LEFT JOIN "asset_stack" "stack" ON "stack"."id" = "asset"."stackId"
+WHERE
+  "asset"."ownerId" = $1
+  AND ("asset"."fileCreatedAt", "asset"."id") < ($2, $3)
+  AND "asset"."updatedAt" <= $4
+  AND "asset"."isVisible" = true
+ORDER BY
+  "asset"."fileCreatedAt" DESC,
+  "asset"."id" DESC
+LIMIT
+  10
+
+-- AssetRepository.getChangedDeltaSync
+SELECT
+  "AssetEntity"."id" AS "AssetEntity_id",
+  "AssetEntity"."deviceAssetId" AS "AssetEntity_deviceAssetId",
+  "AssetEntity"."ownerId" AS "AssetEntity_ownerId",
+  "AssetEntity"."libraryId" AS "AssetEntity_libraryId",
+  "AssetEntity"."deviceId" AS "AssetEntity_deviceId",
+  "AssetEntity"."type" AS "AssetEntity_type",
+  "AssetEntity"."originalPath" AS "AssetEntity_originalPath",
+  "AssetEntity"."previewPath" AS "AssetEntity_previewPath",
+  "AssetEntity"."thumbnailPath" AS "AssetEntity_thumbnailPath",
+  "AssetEntity"."thumbhash" AS "AssetEntity_thumbhash",
+  "AssetEntity"."encodedVideoPath" AS "AssetEntity_encodedVideoPath",
+  "AssetEntity"."createdAt" AS "AssetEntity_createdAt",
+  "AssetEntity"."updatedAt" AS "AssetEntity_updatedAt",
+  "AssetEntity"."deletedAt" AS "AssetEntity_deletedAt",
+  "AssetEntity"."fileCreatedAt" AS "AssetEntity_fileCreatedAt",
+  "AssetEntity"."localDateTime" AS "AssetEntity_localDateTime",
+  "AssetEntity"."fileModifiedAt" AS "AssetEntity_fileModifiedAt",
+  "AssetEntity"."isFavorite" AS "AssetEntity_isFavorite",
+  "AssetEntity"."isArchived" AS "AssetEntity_isArchived",
+  "AssetEntity"."isExternal" AS "AssetEntity_isExternal",
+  "AssetEntity"."isReadOnly" AS "AssetEntity_isReadOnly",
+  "AssetEntity"."isOffline" AS "AssetEntity_isOffline",
+  "AssetEntity"."checksum" AS "AssetEntity_checksum",
+  "AssetEntity"."duration" AS "AssetEntity_duration",
+  "AssetEntity"."isVisible" AS "AssetEntity_isVisible",
+  "AssetEntity"."livePhotoVideoId" AS "AssetEntity_livePhotoVideoId",
+  "AssetEntity"."originalFileName" AS "AssetEntity_originalFileName",
+  "AssetEntity"."sidecarPath" AS "AssetEntity_sidecarPath",
+  "AssetEntity"."stackId" AS "AssetEntity_stackId",
+  "AssetEntity__AssetEntity_exifInfo"."assetId" AS "AssetEntity__AssetEntity_exifInfo_assetId",
+  "AssetEntity__AssetEntity_exifInfo"."description" AS "AssetEntity__AssetEntity_exifInfo_description",
+  "AssetEntity__AssetEntity_exifInfo"."exifImageWidth" AS "AssetEntity__AssetEntity_exifInfo_exifImageWidth",
+  "AssetEntity__AssetEntity_exifInfo"."exifImageHeight" AS "AssetEntity__AssetEntity_exifInfo_exifImageHeight",
+  "AssetEntity__AssetEntity_exifInfo"."fileSizeInByte" AS "AssetEntity__AssetEntity_exifInfo_fileSizeInByte",
+  "AssetEntity__AssetEntity_exifInfo"."orientation" AS "AssetEntity__AssetEntity_exifInfo_orientation",
+  "AssetEntity__AssetEntity_exifInfo"."dateTimeOriginal" AS "AssetEntity__AssetEntity_exifInfo_dateTimeOriginal",
+  "AssetEntity__AssetEntity_exifInfo"."modifyDate" AS "AssetEntity__AssetEntity_exifInfo_modifyDate",
+  "AssetEntity__AssetEntity_exifInfo"."timeZone" AS "AssetEntity__AssetEntity_exifInfo_timeZone",
+  "AssetEntity__AssetEntity_exifInfo"."latitude" AS "AssetEntity__AssetEntity_exifInfo_latitude",
+  "AssetEntity__AssetEntity_exifInfo"."longitude" AS "AssetEntity__AssetEntity_exifInfo_longitude",
+  "AssetEntity__AssetEntity_exifInfo"."projectionType" AS "AssetEntity__AssetEntity_exifInfo_projectionType",
+  "AssetEntity__AssetEntity_exifInfo"."city" AS "AssetEntity__AssetEntity_exifInfo_city",
+  "AssetEntity__AssetEntity_exifInfo"."livePhotoCID" AS "AssetEntity__AssetEntity_exifInfo_livePhotoCID",
+  "AssetEntity__AssetEntity_exifInfo"."autoStackId" AS "AssetEntity__AssetEntity_exifInfo_autoStackId",
+  "AssetEntity__AssetEntity_exifInfo"."state" AS "AssetEntity__AssetEntity_exifInfo_state",
+  "AssetEntity__AssetEntity_exifInfo"."country" AS "AssetEntity__AssetEntity_exifInfo_country",
+  "AssetEntity__AssetEntity_exifInfo"."make" AS "AssetEntity__AssetEntity_exifInfo_make",
+  "AssetEntity__AssetEntity_exifInfo"."model" AS "AssetEntity__AssetEntity_exifInfo_model",
+  "AssetEntity__AssetEntity_exifInfo"."lensModel" AS "AssetEntity__AssetEntity_exifInfo_lensModel",
+  "AssetEntity__AssetEntity_exifInfo"."fNumber" AS "AssetEntity__AssetEntity_exifInfo_fNumber",
+  "AssetEntity__AssetEntity_exifInfo"."focalLength" AS "AssetEntity__AssetEntity_exifInfo_focalLength",
+  "AssetEntity__AssetEntity_exifInfo"."iso" AS "AssetEntity__AssetEntity_exifInfo_iso",
+  "AssetEntity__AssetEntity_exifInfo"."exposureTime" AS "AssetEntity__AssetEntity_exifInfo_exposureTime",
+  "AssetEntity__AssetEntity_exifInfo"."profileDescription" AS "AssetEntity__AssetEntity_exifInfo_profileDescription",
+  "AssetEntity__AssetEntity_exifInfo"."colorspace" AS "AssetEntity__AssetEntity_exifInfo_colorspace",
+  "AssetEntity__AssetEntity_exifInfo"."bitsPerSample" AS "AssetEntity__AssetEntity_exifInfo_bitsPerSample",
+  "AssetEntity__AssetEntity_exifInfo"."fps" AS "AssetEntity__AssetEntity_exifInfo_fps",
+  "AssetEntity__AssetEntity_stack"."id" AS "AssetEntity__AssetEntity_stack_id",
+  "AssetEntity__AssetEntity_stack"."primaryAssetId" AS "AssetEntity__AssetEntity_stack_primaryAssetId"
+FROM
+  "assets" "AssetEntity"
+  LEFT JOIN "exif" "AssetEntity__AssetEntity_exifInfo" ON "AssetEntity__AssetEntity_exifInfo"."assetId" = "AssetEntity"."id"
+  LEFT JOIN "asset_stack" "AssetEntity__AssetEntity_stack" ON "AssetEntity__AssetEntity_stack"."id" = "AssetEntity"."stackId"
+WHERE
+  (
+    ("AssetEntity"."ownerId" IN ($1))
+    AND ("AssetEntity"."isVisible" = $2)
+    AND ("AssetEntity"."updatedAt" > $3)
+  )

server/src/queries/user.repository.sql

@@ -159,10 +159,12 @@ SET
       COALESCE(SUM(exif."fileSizeInByte"), 0)
     FROM
       "assets" "assets"
+      LEFT JOIN "libraries" "library" ON "library"."id" = "assets"."libraryId"
+      AND ("library"."deletedAt" IS NULL)
       LEFT JOIN "exif" "exif" ON "exif"."assetId" = "assets"."id"
     WHERE
       "assets"."ownerId" = users.id
-      AND NOT "assets"."isExternal"
+      AND "library"."type" = 'UPLOAD'
   ),
   "updatedAt" = CURRENT_TIMESTAMP
 WHERE

server/src/repositories/access.repository.ts

@@ -1,3 +1,4 @@
+import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
 import { ActivityEntity } from 'src/entities/activity.entity';
@@ -26,6 +27,7 @@ type IPersonAccess = IAccessRepository['person'];
 type IPartnerAccess = IAccessRepository['partner'];
 
 @Instrumentation()
+@Injectable()
 class ActivityAccess implements IActivityAccess {
   constructor(
     private activityRepository: Repository<ActivityEntity>,

server/src/repositories/asset.repository.ts

@@ -2,15 +2,18 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import path from 'node:path';
 import { Chunked, ChunkedArray, DummyValue, GenerateSql } from 'src/decorators';
-import { AssetOrder } from 'src/entities/album.entity';
+import { AlbumEntity, AssetOrder } from 'src/entities/album.entity';
 import { AssetJobStatusEntity } from 'src/entities/asset-job-status.entity';
 import { AssetEntity, AssetType } from 'src/entities/asset.entity';
 import { ExifEntity } from 'src/entities/exif.entity';
+import { PartnerEntity } from 'src/entities/partner.entity';
 import { SmartInfoEntity } from 'src/entities/smart-info.entity';
 import {
   AssetBuilderOptions,
   AssetCreate,
+  AssetDeltaSyncOptions,
   AssetExploreFieldOptions,
+  AssetFullSyncOptions,
   AssetPathEntity,
   AssetStats,
   AssetStatsOptions,
@@ -39,6 +42,7 @@ import {
   FindOptionsWhere,
   In,
   IsNull,
+  MoreThan,
   Not,
   Repository,
 } from 'typeorm';
@@ -61,6 +65,8 @@ export class AssetRepository implements IAssetRepository {
     @InjectRepository(ExifEntity) private exifRepository: Repository<ExifEntity>,
     @InjectRepository(AssetJobStatusEntity) private jobStatusRepository: Repository<AssetJobStatusEntity>,
     @InjectRepository(SmartInfoEntity) private smartInfoRepository: Repository<SmartInfoEntity>,
+    @InjectRepository(PartnerEntity) private partnerRepository: Repository<PartnerEntity>,
+    @InjectRepository(AlbumEntity) private albumRepository: Repository<AlbumEntity>,
   ) {}
 
   async upsertExif(exif: Partial<ExifEntity>): Promise<void> {
@@ -160,10 +166,10 @@ export class AssetRepository implements IAssetRepository {
   }
 
   @GenerateSql({ params: [{ take: 1, skip: 0 }, DummyValue.UUID] })
-  getLibraryAssetPaths(pagination: PaginationOptions, libraryId: string): Paginated<AssetPathEntity> {
+  getExternalLibraryAssetPaths(pagination: PaginationOptions, libraryId: string): Paginated<AssetPathEntity> {
     return paginate(this.repository, pagination, {
       select: { id: true, originalPath: true, isOffline: true },
-      where: { library: { id: libraryId } },
+      where: { library: { id: libraryId }, isExternal: true },
     });
   }
 
@@ -781,4 +787,55 @@ export class AssetRepository implements IAssetRepository {
         }) as AssetEntity,
     );
   }
+
+  @GenerateSql({
+    params: [
+      {
+        ownerId: DummyValue.UUID,
+        lastCreationDate: DummyValue.DATE,
+        lastId: DummyValue.STRING,
+        updatedUntil: DummyValue.DATE,
+        limit: 10,
+      },
+    ],
+  })
+  getAllForUserFullSync(options: AssetFullSyncOptions): Promise<AssetEntity[]> {
+    const { ownerId, lastCreationDate, lastId, updatedUntil, limit } = options;
+    let builder = this.repository
+      .createQueryBuilder('asset')
+      .leftJoinAndSelect('asset.exifInfo', 'exifInfo')
+      .leftJoinAndSelect('asset.stack', 'stack')
+      .where('asset.ownerId = :ownerId', { ownerId });
+    if (lastCreationDate !== undefined && lastId !== undefined) {
+      builder = builder.andWhere('(asset.fileCreatedAt, asset.id) < (:lastCreationDate, :lastId)', {
+        lastCreationDate,
+        lastId,
+      });
+    }
+    return builder
+      .andWhere('asset.updatedAt <= :updatedUntil', { updatedUntil })
+      .andWhere('asset.isVisible = true')
+      .orderBy('asset.fileCreatedAt', 'DESC')
+      .addOrderBy('asset.id', 'DESC')
+      .limit(limit)
+      .withDeleted()
+      .getMany();
+  }
+
+  @GenerateSql({ params: [{ userIds: [DummyValue.UUID], updatedAfter: DummyValue.DATE }] })
+  getChangedDeltaSync(options: AssetDeltaSyncOptions): Promise<AssetEntity[]> {
+    return this.repository.find({
+      where: {
+        ownerId: In(options.userIds),
+        isVisible: true,
+        updatedAt: MoreThan(options.updatedAfter),
+      },
+      relations: {
+        exifInfo: true,
+        stack: true,
+      },
+      take: options.limit,
+      withDeleted: true,
+    });
+  }
 }

server/src/repositories/audit.repository.ts

@@ -1,25 +1,28 @@
+import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { AuditEntity } from 'src/entities/audit.entity';
 import { AuditSearch, IAuditRepository } from 'src/interfaces/audit.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { LessThan, MoreThan, Repository } from 'typeorm';
+import { In, LessThan, MoreThan, Repository } from 'typeorm';
 
 @Instrumentation()
+@Injectable()
 export class AuditRepository implements IAuditRepository {
   constructor(@InjectRepository(AuditEntity) private repository: Repository<AuditEntity>) {}
 
-  getAfter(since: Date, options: AuditSearch): Promise<AuditEntity[]> {
+  getAfter(since: Date, options: AuditSearch): Promise<string[]> {
     return this.repository
       .createQueryBuilder('audit')
       .where({
         createdAt: MoreThan(since),
         action: options.action,
         entityType: options.entityType,
-        ownerId: options.ownerId,
+        ownerId: In(options.userIds),
       })
       .distinctOn(['audit.entityId', 'audit.entityType'])
       .orderBy('audit.entityId, audit.entityType, audit.createdAt', 'DESC')
-      .getMany();
+      .select('audit.entityId')
+      .getRawMany();
   }
 
   async removeBefore(before: Date): Promise<void> {

server/src/repositories/database.repository.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { InjectDataSource } from '@nestjs/typeorm';
 import AsyncLock from 'async-lock';
 import { vectorExt } from 'src/database.config';
@@ -11,8 +11,8 @@ import {
   VectorUpdateResult,
   extName,
 } from 'src/interfaces/database.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 import { Version, VersionType } from 'src/utils/version';
 import { isValidInteger } from 'src/validation';
 import { DataSource, EntityManager, QueryRunner } from 'typeorm';
@@ -20,10 +20,14 @@ import { DataSource, EntityManager, QueryRunner } from 'typeorm';
 @Instrumentation()
 @Injectable()
 export class DatabaseRepository implements IDatabaseRepository {
-  private logger = new ImmichLogger(DatabaseRepository.name);
   readonly asyncLock = new AsyncLock();
 
-  constructor(@InjectDataSource() private dataSource: DataSource) {}
+  constructor(
+    @InjectDataSource() private dataSource: DataSource,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(DatabaseRepository.name);
+  }
 
   async getExtensionVersion(extension: DatabaseExtension): Promise<Version | null> {
     const res = await this.dataSource.query(`SELECT extversion FROM pg_extension WHERE extname = $1`, [extension]);

server/src/repositories/event.repository.ts

@@ -1,3 +1,4 @@
+import { Inject, Injectable } from '@nestjs/common';
 import { EventEmitter2 } from '@nestjs/event-emitter';
 import {
   OnGatewayConnection,
@@ -14,9 +15,9 @@ import {
   ServerEvent,
   ServerEventMap,
 } from 'src/interfaces/event.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AuthService } from 'src/services/auth.service';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 
 @Instrumentation()
 @WebSocketGateway({
@@ -24,16 +25,18 @@ import { ImmichLogger } from 'src/utils/logger';
   path: '/api/socket.io',
   transports: ['websocket'],
 })
+@Injectable()
 export class EventRepository implements OnGatewayConnection, OnGatewayDisconnect, OnGatewayInit, IEventRepository {
-  private logger = new ImmichLogger(EventRepository.name);
-
   @WebSocketServer()
   private server?: Server;
 
   constructor(
     private authService: AuthService,
     private eventEmitter: EventEmitter2,
-  ) {}
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(EventRepository.name);
+  }
 
   afterInit(server: Server) {
     this.logger.log('Initialized websocket server');

server/src/repositories/index.ts

@@ -12,6 +12,7 @@ import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { IEventRepository } from 'src/interfaces/event.interface';
 import { IJobRepository } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { IMediaRepository } from 'src/interfaces/media.interface';
 import { IMemoryRepository } from 'src/interfaces/memory.interface';
@@ -43,6 +44,7 @@ import { DatabaseRepository } from 'src/repositories/database.repository';
 import { EventRepository } from 'src/repositories/event.repository';
 import { JobRepository } from 'src/repositories/job.repository';
 import { LibraryRepository } from 'src/repositories/library.repository';
+import { LoggerRepository } from 'src/repositories/logger.repository';
 import { MachineLearningRepository } from 'src/repositories/machine-learning.repository';
 import { MediaRepository } from 'src/repositories/media.repository';
 import { MemoryRepository } from 'src/repositories/memory.repository';
@@ -74,6 +76,7 @@ export const repositories = [
   { provide: IDatabaseRepository, useClass: DatabaseRepository },
   { provide: IEventRepository, useClass: EventRepository },
   { provide: IJobRepository, useClass: JobRepository },
+  { provide: ILoggerRepository, useClass: LoggerRepository },
   { provide: ILibraryRepository, useClass: LibraryRepository },
   { provide: IKeyRepository, useClass: ApiKeyRepository },
   { provide: IMachineLearningRepository, useClass: MachineLearningRepository },

server/src/repositories/job.repository.ts

@@ -1,5 +1,5 @@
 import { getQueueToken } from '@nestjs/bullmq';
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
 import { SchedulerRegistry } from '@nestjs/schedule';
 import { Job, JobsOptions, Processor, Queue, Worker, WorkerOptions } from 'bullmq';
@@ -15,8 +15,8 @@ import {
   QueueName,
   QueueStatus,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 
 export const JOBS_TO_QUEUE: Record<JobName, QueueName> = {
   // misc
@@ -83,12 +83,14 @@ export const JOBS_TO_QUEUE: Record<JobName, QueueName> = {
 @Injectable()
 export class JobRepository implements IJobRepository {
   private workers: Partial<Record<QueueName, Worker>> = {};
-  private logger = new ImmichLogger(JobRepository.name);
 
   constructor(
     private moduleReference: ModuleRef,
     private schedulerReqistry: SchedulerRegistry,
-  ) {}
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(JobRepository.name);
+  }
 
   addHandler(queueName: QueueName, concurrency: number, handler: (item: JobItem) => Promise<void>) {
     const workerHandler: Processor = async (job: Job) => handler(job as JobItem);

server/src/repositories/logger.repository.ts

@@ -0,0 +1,27 @@
+import { Injectable, Scope } from '@nestjs/common';
+import { ClsService } from 'nestjs-cls';
+import { LogLevel } from 'src/entities/system-config.entity';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
+import { ImmichLogger } from 'src/utils/logger';
+
+@Injectable({ scope: Scope.TRANSIENT })
+export class LoggerRepository extends ImmichLogger implements ILoggerRepository {
+  constructor(private cls: ClsService) {
+    super(LoggerRepository.name);
+  }
+
+  protected formatContext(context: string): string {
+    let formattedContext = super.formatContext(context);
+
+    const correlationId = this.cls?.getId();
+    if (correlationId && this.isLevelEnabled(LogLevel.VERBOSE)) {
+      formattedContext += `[${correlationId}] `;
+    }
+
+    return formattedContext;
+  }
+
+  setLogLevel(level: LogLevel): void {
+    ImmichLogger.setLogLevel(level);
+  }
+}

server/src/repositories/media.repository.ts

@@ -1,9 +1,11 @@
+import { Inject, Injectable } from '@nestjs/common';
 import ffmpeg, { FfprobeData } from 'fluent-ffmpeg';
 import fs from 'node:fs/promises';
 import { Writable } from 'node:stream';
 import { promisify } from 'node:util';
 import sharp from 'sharp';
 import { Colorspace } from 'src/entities/system-config.entity';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import {
   CropOptions,
   IMediaRepository,
@@ -12,7 +14,6 @@ import {
   VideoInfo,
 } from 'src/interfaces/media.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 import { handlePromiseError } from 'src/utils/misc';
 
 const probe = promisify<string, FfprobeData>(ffmpeg.ffprobe);
@@ -20,9 +21,11 @@ sharp.concurrency(0);
 sharp.cache({ files: 0 });
 
 @Instrumentation()
+@Injectable()
 export class MediaRepository implements IMediaRepository {
-  private logger = new ImmichLogger(MediaRepository.name);
-
+  constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {
+    this.logger.setContext(MediaRepository.name);
+  }
   crop(input: string | Buffer, options: CropOptions): Promise<Buffer> {
     return sharp(input, { failOn: 'none' })
       .pipelineColorspace('rgb16')

server/src/repositories/metadata.repository.ts

@@ -1,4 +1,4 @@
-import { Inject } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { DefaultReadTaskOptions, Tags, exiftool } from 'exiftool-vendored';
 import geotz from 'geo-tz';
@@ -11,24 +11,26 @@ import { DummyValue, GenerateSql } from 'src/decorators';
 import { ExifEntity } from 'src/entities/exif.entity';
 import { GeodataPlacesEntity } from 'src/entities/geodata-places.entity';
 import { SystemMetadataKey } from 'src/entities/system-metadata.entity';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { GeoPoint, IMetadataRepository, ImmichTags, ReverseGeocodeResult } from 'src/interfaces/metadata.interface';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 import { DataSource, QueryRunner, Repository } from 'typeorm';
 import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity.js';
 
 @Instrumentation()
+@Injectable()
 export class MetadataRepository implements IMetadataRepository {
   constructor(
     @InjectRepository(ExifEntity) private exifRepository: Repository<ExifEntity>,
-    @InjectRepository(GeodataPlacesEntity) private readonly geodataPlacesRepository: Repository<GeodataPlacesEntity>,
+    @InjectRepository(GeodataPlacesEntity) private geodataPlacesRepository: Repository<GeodataPlacesEntity>,
     @Inject(ISystemMetadataRepository)
-    private readonly systemMetadataRepository: ISystemMetadataRepository,
+    private systemMetadataRepository: ISystemMetadataRepository,
     @InjectDataSource() private dataSource: DataSource,
-  ) {}
-
-  private logger = new ImmichLogger(MetadataRepository.name);
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(MetadataRepository.name);
+  }
 
   async init(): Promise<void> {
     this.logger.log('Initializing metadata repository');

server/src/repositories/metric.repository.ts

@@ -6,7 +6,7 @@ import { apiMetrics, hostMetrics, jobMetrics, repoMetrics } from 'src/utils/inst
 
 class MetricGroupRepository implements IMetricGroupRepository {
   private enabled = false;
-  constructor(private readonly metricService: MetricService) {}
+  constructor(private metricService: MetricService) {}
 
   addToCounter(name: string, value: number, options?: MetricOptions): void {
     if (this.enabled) {

server/src/repositories/partner.repository.ts

@@ -8,7 +8,7 @@ import { DeepPartial, Repository } from 'typeorm';
 @Instrumentation()
 @Injectable()
 export class PartnerRepository implements IPartnerRepository {
-  constructor(@InjectRepository(PartnerEntity) private readonly repository: Repository<PartnerEntity>) {}
+  constructor(@InjectRepository(PartnerEntity) private repository: Repository<PartnerEntity>) {}
 
   getAll(userId: string): Promise<PartnerEntity[]> {
     return this.repository.find({ where: [{ sharedWithId: userId }, { sharedById: userId }] });

server/src/repositories/person.repository.ts

@@ -1,3 +1,4 @@
+import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import _ from 'lodash';
 import { ChunkedArray, DummyValue, GenerateSql } from 'src/decorators';
@@ -19,6 +20,7 @@ import { Paginated, PaginationOptions, paginate } from 'src/utils/pagination';
 import { FindManyOptions, FindOptionsRelations, FindOptionsSelect, In, Repository } from 'typeorm';
 
 @Instrumentation()
+@Injectable()
 export class PersonRepository implements IPersonRepository {
   constructor(
     @InjectRepository(AssetEntity) private assetRepository: Repository<AssetEntity>,

server/src/repositories/search.repository.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { vectorExt } from 'src/database.config';
 import { DummyValue, GenerateSql } from 'src/decorators';
@@ -8,6 +8,7 @@ import { GeodataPlacesEntity } from 'src/entities/geodata-places.entity';
 import { SmartInfoEntity } from 'src/entities/smart-info.entity';
 import { SmartSearchEntity } from 'src/entities/smart-search.entity';
 import { DatabaseExtension } from 'src/interfaces/database.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import {
   AssetSearchOptions,
   FaceEmbeddingSearch,
@@ -18,7 +19,6 @@ import {
 } from 'src/interfaces/search.interface';
 import { asVector, searchAssetBuilder } from 'src/utils/database';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 import { getCLIPModelInfo } from 'src/utils/misc';
 import { Paginated, PaginationMode, PaginationResult, paginatedBuilder } from 'src/utils/pagination';
 import { isValidInteger } from 'src/validation';
@@ -27,7 +27,6 @@ import { Repository, SelectQueryBuilder } from 'typeorm';
 @Instrumentation()
 @Injectable()
 export class SearchRepository implements ISearchRepository {
-  private logger = new ImmichLogger(SearchRepository.name);
   private faceColumns: string[];
   private assetsByCityQuery: string;
 
@@ -36,8 +35,10 @@ export class SearchRepository implements ISearchRepository {
     @InjectRepository(AssetEntity) private assetRepository: Repository<AssetEntity>,
     @InjectRepository(AssetFaceEntity) private assetFaceRepository: Repository<AssetFaceEntity>,
     @InjectRepository(SmartSearchEntity) private smartSearchRepository: Repository<SmartSearchEntity>,
-    @InjectRepository(GeodataPlacesEntity) private readonly geodataPlacesRepository: Repository<GeodataPlacesEntity>,
+    @InjectRepository(GeodataPlacesEntity) private geodataPlacesRepository: Repository<GeodataPlacesEntity>,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
+    this.logger.setContext(SearchRepository.name);
     this.faceColumns = this.assetFaceRepository.manager.connection
       .getMetadata(AssetFaceEntity)
       .ownColumns.map((column) => column.propertyName)

server/src/repositories/storage.repository.spec.ts

@@ -1,6 +1,8 @@
 import mockfs from 'mock-fs';
 import { CrawlOptionsDto } from 'src/dtos/library.dto';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { StorageRepository } from 'src/repositories/storage.repository';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 
 interface Test {
   test: string;
@@ -181,9 +183,11 @@ const tests: Test[] = [
 
 describe(StorageRepository.name, () => {
   let sut: StorageRepository;
+  let logger: ILoggerRepository;
 
   beforeEach(() => {
-    sut = new StorageRepository();
+    logger = newLoggerRepositoryMock();
+    sut = new StorageRepository(logger);
   });
 
   afterEach(() => {

server/src/repositories/storage.repository.ts

@@ -1,3 +1,4 @@
+import { Inject, Injectable } from '@nestjs/common';
 import archiver from 'archiver';
 import chokidar, { WatchOptions } from 'chokidar';
 import { glob, globStream } from 'fast-glob';
@@ -5,21 +6,23 @@ import { constants, createReadStream, existsSync, mkdirSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { CrawlOptionsDto } from 'src/dtos/library.dto';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import {
   DiskUsage,
   IStorageRepository,
   ImmichReadStream,
   ImmichZipStream,
-  StorageEventType,
   WatchEvents,
 } from 'src/interfaces/storage.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
-import { ImmichLogger } from 'src/utils/logger';
 import { mimeTypes } from 'src/utils/mime-types';
 
 @Instrumentation()
+@Injectable()
 export class StorageRepository implements IStorageRepository {
-  private logger = new ImmichLogger(StorageRepository.name);
+  constructor(@Inject(ILoggerRepository) private logger: ILoggerRepository) {
+    this.logger.setContext(StorageRepository.name);
+  }
 
   readdir(folder: string): Promise<string[]> {
     return fs.readdir(folder);
@@ -173,11 +176,11 @@ export class StorageRepository implements IStorageRepository {
   watch(paths: string[], options: WatchOptions, events: Partial<WatchEvents>) {
     const watcher = chokidar.watch(paths, options);
 
-    watcher.on(StorageEventType.READY, () => events.onReady?.());
-    watcher.on(StorageEventType.ADD, (path) => events.onAdd?.(path));
-    watcher.on(StorageEventType.CHANGE, (path) => events.onChange?.(path));
-    watcher.on(StorageEventType.UNLINK, (path) => events.onUnlink?.(path));
-    watcher.on(StorageEventType.ERROR, (error) => events.onError?.(error));
+    watcher.on('ready', () => events.onReady?.());
+    watcher.on('add', (path) => events.onAdd?.(path));
+    watcher.on('change', (path) => events.onChange?.(path));
+    watcher.on('unlink', (path) => events.onUnlink?.(path));
+    watcher.on('error', (error) => events.onError?.(error));
 
     return () => watcher.close();
   }

server/src/repositories/system-config.repository.ts

@@ -1,3 +1,4 @@
+import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { readFile } from 'node:fs/promises';
 import { Chunked, DummyValue, GenerateSql } from 'src/decorators';
@@ -7,6 +8,7 @@ import { Instrumentation } from 'src/utils/instrumentation';
 import { In, Repository } from 'typeorm';
 
 @Instrumentation()
+@Injectable()
 export class SystemConfigRepository implements ISystemConfigRepository {
   constructor(
     @InjectRepository(SystemConfigEntity)

server/src/repositories/system-metadata.repository.ts

@@ -1,3 +1,4 @@
+import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { SystemMetadata, SystemMetadataEntity } from 'src/entities/system-metadata.entity';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
@@ -5,6 +6,7 @@ import { Instrumentation } from 'src/utils/instrumentation';
 import { Repository } from 'typeorm';
 
 @Instrumentation()
+@Injectable()
 export class SystemMetadataRepository implements ISystemMetadataRepository {
   constructor(
     @InjectRepository(SystemMetadataEntity)

server/src/repositories/user.repository.ts

@@ -2,6 +2,7 @@ import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { AssetEntity } from 'src/entities/asset.entity';
+import { LibraryType } from 'src/entities/library.entity';
 import { UserEntity } from 'src/entities/user.entity';
 import {
   IUserRepository,
@@ -117,11 +118,14 @@ export class UserRepository implements IUserRepository {
 
   @GenerateSql({ params: [DummyValue.UUID] })
   async syncUsage(id?: string) {
+    // we can't use parameters with getQuery, hence the template string
     const subQuery = this.assetRepository
       .createQueryBuilder('assets')
       .select('COALESCE(SUM(exif."fileSizeInByte"), 0)')
+      .leftJoin('assets.library', 'library')
       .leftJoin('assets.exifInfo', 'exif')
-      .where('assets.ownerId = users.id AND NOT assets.isExternal')
+      .where('assets.ownerId = users.id')
+      .andWhere(`library.type = '${LibraryType.UPLOAD}'`)
       .withDeleted();
 
     const query = this.userRepository

server/src/services/activity.service.spec.ts

@@ -6,11 +6,12 @@ import { activityStub } from 'test/fixtures/activity.stub';
 import { authStub } from 'test/fixtures/auth.stub';
 import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
 import { newActivityRepositoryMock } from 'test/repositories/activity.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(ActivityService.name, () => {
   let sut: ActivityService;
   let accessMock: IAccessRepositoryMock;
-  let activityMock: jest.Mocked<IActivityRepository>;
+  let activityMock: Mocked<IActivityRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();

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

@@ -15,14 +15,15 @@ import { newAlbumUserRepositoryMock } from 'test/repositories/album-user.reposit
 import { newAlbumRepositoryMock } from 'test/repositories/album.repository.mock';
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(AlbumService.name, () => {
   let sut: AlbumService;
   let accessMock: IAccessRepositoryMock;
-  let albumMock: jest.Mocked<IAlbumRepository>;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let userMock: jest.Mocked<IUserRepository>;
-  let albumUserMock: jest.Mocked<IAlbumUserRepository>;
+  let albumMock: Mocked<IAlbumRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let albumUserMock: Mocked<IAlbumUserRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();

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

@@ -6,11 +6,12 @@ import { keyStub } from 'test/fixtures/api-key.stub';
 import { authStub } from 'test/fixtures/auth.stub';
 import { newKeyRepositoryMock } from 'test/repositories/api-key.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
+import { Mocked } from 'vitest';
 
 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/services/api.service.ts

@@ -1,9 +1,10 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable } from '@nestjs/common';
 import { Cron, CronExpression, Interval } from '@nestjs/schedule';
 import { NextFunction, Request, Response } from 'express';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ONE_HOUR, WEB_ROOT } from 'src/constants';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AuthService } from 'src/services/auth.service';
 import { DatabaseService } from 'src/services/database.service';
 import { JobService } from 'src/services/job.service';
@@ -11,7 +12,6 @@ import { ServerInfoService } from 'src/services/server-info.service';
 import { SharedLinkService } from 'src/services/shared-link.service';
 import { StorageService } from 'src/services/storage.service';
 import { SystemConfigService } from 'src/services/system-config.service';
-import { ImmichLogger } from 'src/utils/logger';
 import { OpenGraphTags } from 'src/utils/misc';
 
 const render = (index: string, meta: OpenGraphTags) => {
@@ -36,8 +36,6 @@ const render = (index: string, meta: OpenGraphTags) => {
 
 @Injectable()
 export class ApiService {
-  private logger = new ImmichLogger(ApiService.name);
-
   constructor(
     private authService: AuthService,
     private configService: SystemConfigService,
@@ -46,7 +44,10 @@ export class ApiService {
     private sharedLinkService: SharedLinkService,
     private storageService: StorageService,
     private databaseService: DatabaseService,
-  ) {}
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(ApiService.name);
+  }
 
   @Interval(ONE_HOUR.as('milliseconds'))
   async onVersionCheck() {

server/src/services/asset-v1.service.spec.ts

@@ -1,4 +1,3 @@
-import { when } from 'jest-when';
 import { AssetRejectReason, AssetUploadAction } from 'src/dtos/asset-v1-response.dto';
 import { CreateAssetDto } from 'src/dtos/asset-v1.dto';
 import { ASSET_CHECKSUM_CONSTRAINT, AssetEntity, AssetType } from 'src/entities/asset.entity';
@@ -7,6 +6,7 @@ import { IAssetRepositoryV1 } from 'src/interfaces/asset-v1.interface';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { IJobRepository, JobName } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
 import { AssetServiceV1 } from 'src/services/asset-v1.service';
@@ -17,9 +17,11 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
 import { newLibraryRepositoryMock } from 'test/repositories/library.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
 import { QueryFailedError } from 'typeorm';
+import { Mocked, vitest } from 'vitest';
 
 const _getCreateAssetDto = (): CreateAssetDto => {
   const createAssetDto = new CreateAssetDto();
@@ -62,40 +64,50 @@ const _getAsset_1 = () => {
 describe('AssetService', () => {
   let sut: AssetServiceV1;
   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 loggerMock: Mocked<ILoggerRepository>;
+  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: vitest.fn(),
+      getAllByUserId: vitest.fn(),
+      getDetectedObjectsByUserId: vitest.fn(),
+      getLocationsByUserId: vitest.fn(),
+      getSearchPropertiesByUserId: vitest.fn(),
+      getAssetsByChecksums: vitest.fn(),
+      getExistingAssets: vitest.fn(),
+      getByOriginalPath: vitest.fn(),
     };
 
     accessMock = newAccessRepositoryMock();
     assetMock = newAssetRepositoryMock();
     jobMock = newJobRepositoryMock();
     libraryMock = newLibraryRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
     storageMock = newStorageRepositoryMock();
     userMock = newUserRepositoryMock();
 
-    sut = new AssetServiceV1(accessMock, assetRepositoryMockV1, assetMock, jobMock, libraryMock, storageMock, userMock);
+    sut = new AssetServiceV1(
+      accessMock,
+      assetRepositoryMockV1,
+      assetMock,
+      jobMock,
+      libraryMock,
+      storageMock,
+      userMock,
+      loggerMock,
+    );
 
-    when(assetRepositoryMockV1.get)
-      .calledWith(assetStub.livePhotoStillAsset.id)
-      .mockResolvedValue(assetStub.livePhotoStillAsset);
-    when(assetRepositoryMockV1.get)
-      .calledWith(assetStub.livePhotoMotionAsset.id)
-      .mockResolvedValue(assetStub.livePhotoMotionAsset);
+    assetRepositoryMockV1.get.mockImplementation((assetId) =>
+      Promise.resolve(
+        [assetStub.livePhotoMotionAsset, assetStub.livePhotoMotionAsset].find((asset) => asset.id === assetId) ?? null,
+      ),
+    );
   });
 
   describe('uploadFile', () => {

server/src/services/asset-v1.service.ts

@@ -33,18 +33,17 @@ import { IAssetRepositoryV1 } from 'src/interfaces/asset-v1.interface';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { IJobRepository, JobName } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
 import { UploadFile } from 'src/services/asset.service';
 import { CacheControl, ImmichFileResponse, getLivePhotoMotionFilename } from 'src/utils/file';
-import { ImmichLogger } from 'src/utils/logger';
 import { mimeTypes } from 'src/utils/mime-types';
 import { QueryFailedError } from 'typeorm';
 
 @Injectable()
 /** @deprecated */
 export class AssetServiceV1 {
-  readonly logger = new ImmichLogger(AssetServiceV1.name);
   private access: AccessCore;
 
   constructor(
@@ -55,8 +54,10 @@ export class AssetServiceV1 {
     @Inject(ILibraryRepository) private libraryRepository: ILibraryRepository,
     @Inject(IStorageRepository) private storageRepository: IStorageRepository,
     @Inject(IUserRepository) private userRepository: IUserRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
     this.access = AccessCore.create(accessRepository);
+    this.logger.setContext(AssetServiceV1.name);
   }
 
   public async uploadFile(

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

@@ -1,12 +1,12 @@
 import { BadRequestException, UnauthorizedException } from '@nestjs/common';
-import { when } from 'jest-when';
 import { mapAsset } from 'src/dtos/asset-response.dto';
 import { AssetJobName, AssetStatsResponseDto, UploadFieldName } from 'src/dtos/asset.dto';
 import { AssetEntity, AssetType } from 'src/entities/asset.entity';
 import { IAssetStackRepository } from 'src/interfaces/asset-stack.interface';
 import { AssetStats, IAssetRepository } from 'src/interfaces/asset.interface';
 import { ClientEvent, IEventRepository } from 'src/interfaces/event.interface';
-import { IJobRepository, JobItem, JobName } from 'src/interfaces/job.interface';
+import { IJobRepository, JobName } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IPartnerRepository } from 'src/interfaces/partner.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
@@ -22,10 +22,12 @@ import { newAssetStackRepositoryMock } from 'test/repositories/asset-stack.repos
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newPartnerRepositoryMock } from 'test/repositories/partner.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked, vitest } from 'vitest';
 
 const stats: AssetStats = {
   [AssetType.IMAGE]: 10,
@@ -148,19 +150,26 @@ 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 eventMock: jest.Mocked<IEventRepository>;
-  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 eventMock: Mocked<IEventRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let partnerMock: Mocked<IPartnerRepository>;
+  let assetStackMock: Mocked<IAssetStackRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();
   });
 
+  const mockGetById = (assets: AssetEntity[]) => {
+    assetMock.getById.mockImplementation((assetId) =>
+      Promise.resolve(assets.find((asset) => asset.id === assetId) ?? null),
+    );
+  };
+
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();
     assetMock = newAssetRepositoryMock();
@@ -171,6 +180,7 @@ describe(AssetService.name, () => {
     configMock = newSystemConfigRepositoryMock();
     partnerMock = newPartnerRepositoryMock();
     assetStackMock = newAssetStackRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
     sut = new AssetService(
       accessMock,
@@ -182,14 +192,10 @@ describe(AssetService.name, () => {
       eventMock,
       partnerMock,
       assetStackMock,
+      loggerMock,
     );
 
-    when(assetMock.getById)
-      .calledWith(assetStub.livePhotoStillAsset.id)
-      .mockResolvedValue(assetStub.livePhotoStillAsset as AssetEntity);
-    when(assetMock.getById)
-      .calledWith(assetStub.livePhotoMotionAsset.id)
-      .mockResolvedValue(assetStub.livePhotoMotionAsset as AssetEntity);
+    mockGetById([assetStub.livePhotoStillAsset, assetStub.livePhotoMotionAsset]);
   });
 
   describe('canUpload', () => {
@@ -299,12 +305,12 @@ describe(AssetService.name, () => {
 
   describe('getMemoryLane', () => {
     beforeAll(() => {
-      jest.useFakeTimers();
-      jest.setSystemTime(new Date('2024-01-15'));
+      vitest.useFakeTimers();
+      vitest.setSystemTime(new Date('2024-01-15'));
     });
 
     afterAll(() => {
-      jest.useRealTimers();
+      vitest.useRealTimers();
     });
 
     it('should group the assets correctly', async () => {
@@ -469,9 +475,7 @@ describe(AssetService.name, () => {
 
     it('should update parent asset updatedAt when children are added', async () => {
       accessMock.asset.checkOwnerAccess.mockResolvedValue(new Set(['parent']));
-      when(assetMock.getById)
-        .calledWith('parent', { stack: { assets: true } })
-        .mockResolvedValue(assetStub.image);
+      mockGetById([{ ...assetStub.image, id: 'parent' }]);
       await sut.updateAll(authStub.user1, {
         ids: [],
         stackParentId: 'parent',
@@ -488,9 +492,7 @@ describe(AssetService.name, () => {
           stack: assetStackStub('stack-1', [{ id: 'parent' } as AssetEntity, { id: 'child-1' } as AssetEntity]),
         } as AssetEntity,
       ]);
-      when(assetStackMock.getById)
-        .calledWith('stack-1')
-        .mockResolvedValue(assetStackStub('stack-1', [{ id: 'parent' } as AssetEntity]));
+      assetStackMock.getById.mockResolvedValue(assetStackStub('stack-1', [{ id: 'parent' } as AssetEntity]));
 
       await sut.updateAll(authStub.user1, {
         ids: ['child-1'],
@@ -511,12 +513,10 @@ describe(AssetService.name, () => {
         { id: 'child-1' } as AssetEntity,
         { id: 'child-2' } as AssetEntity,
       ]);
-      when(assetMock.getById)
-        .calledWith('parent', { stack: { assets: true } })
-        .mockResolvedValue({
-          id: 'child-1',
-          stack,
-        } as AssetEntity);
+      assetMock.getById.mockResolvedValue({
+        id: 'child-1',
+        stack,
+      } as AssetEntity);
 
       await sut.updateAll(authStub.user1, {
         stackParentId: 'parent',
@@ -547,9 +547,7 @@ describe(AssetService.name, () => {
     it('merge stacks if new child has children', async () => {
       accessMock.asset.checkOwnerAccess.mockResolvedValueOnce(new Set(['child-1']));
       accessMock.asset.checkOwnerAccess.mockResolvedValueOnce(new Set(['parent']));
-      when(assetMock.getById)
-        .calledWith('parent', { stack: { assets: true } })
-        .mockResolvedValue({ ...assetStub.image, id: 'parent' });
+      assetMock.getById.mockResolvedValue({ ...assetStub.image, id: 'parent' });
       assetMock.getByIds.mockResolvedValue([
         {
           id: 'child-1',
@@ -557,9 +555,7 @@ describe(AssetService.name, () => {
           stack: assetStackStub('stack-1', [{ id: 'child-1' } as AssetEntity, { id: 'child-2' } as AssetEntity]),
         } as AssetEntity,
       ]);
-      when(assetStackMock.getById)
-        .calledWith('stack-1')
-        .mockResolvedValue(assetStackStub('stack-1', [{ id: 'parent' } as AssetEntity]));
+      assetStackMock.getById.mockResolvedValue(assetStackStub('stack-1', [{ id: 'parent' } as AssetEntity]));
 
       await sut.updateAll(authStub.user1, {
         ids: ['child-1'],
@@ -579,9 +575,7 @@ describe(AssetService.name, () => {
     it('should send ws asset update event', async () => {
       accessMock.asset.checkOwnerAccess.mockResolvedValueOnce(new Set(['asset-1']));
       accessMock.asset.checkOwnerAccess.mockResolvedValueOnce(new Set(['parent']));
-      when(assetMock.getById)
-        .calledWith('parent', { stack: { assets: true } })
-        .mockResolvedValue(assetStub.image);
+      assetMock.getById.mockResolvedValue(assetStub.image);
 
       await sut.updateAll(authStub.user1, {
         ids: ['asset-1'],
@@ -626,32 +620,10 @@ describe(AssetService.name, () => {
   });
 
   describe('handleAssetDeletion', () => {
-    beforeEach(() => {
-      when(jobMock.queue)
-        .calledWith(
-          expect.objectContaining({
-            name: JobName.ASSET_DELETION,
-          }),
-        )
-        .mockImplementation(async (item: JobItem) => {
-          const jobData = (item as { data?: any })?.data || {};
-          await sut.handleAssetDeletion(jobData);
-        });
-    });
-
     it('should remove faces', async () => {
       const assetWithFace = { ...assetStub.image, faces: [faceStub.face1, faceStub.mergeFace1] };
 
-      when(assetMock.getById)
-        .calledWith(assetWithFace.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetWithFace);
+      assetMock.getById.mockResolvedValue(assetWithFace);
 
       await sut.handleAssetDeletion({ id: assetWithFace.id });
 
@@ -676,16 +648,7 @@ describe(AssetService.name, () => {
     });
 
     it('should update stack primary asset if deleted asset was primary asset in a stack', async () => {
-      when(assetMock.getById)
-        .calledWith(assetStub.primaryImage.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetStub.primaryImage as AssetEntity);
+      assetMock.getById.mockResolvedValue(assetStub.primaryImage as AssetEntity);
 
       await sut.handleAssetDeletion({ id: assetStub.primaryImage.id });
 
@@ -696,16 +659,7 @@ describe(AssetService.name, () => {
     });
 
     it('should only delete generated files for readonly assets', async () => {
-      when(assetMock.getById)
-        .calledWith(assetStub.readOnly.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetStub.readOnly);
+      assetMock.getById.mockResolvedValue(assetStub.readOnly);
 
       await sut.handleAssetDeletion({ id: assetStub.readOnly.id });
 
@@ -728,7 +682,7 @@ describe(AssetService.name, () => {
     });
 
     it('should not process assets from external library without fromExternal flag', async () => {
-      when(assetMock.getById).calledWith(assetStub.external.id).mockResolvedValue(assetStub.external);
+      assetMock.getById.mockResolvedValue(assetStub.external);
 
       await sut.handleAssetDeletion({ id: assetStub.external.id });
 
@@ -738,16 +692,7 @@ describe(AssetService.name, () => {
     });
 
     it('should process assets from external library with fromExternal flag', async () => {
-      when(assetMock.getById)
-        .calledWith(assetStub.external.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetStub.external);
+      assetMock.getById.mockResolvedValue(assetStub.external);
 
       await sut.handleAssetDeletion({ id: assetStub.external.id, fromExternal: true });
 
@@ -769,39 +714,12 @@ describe(AssetService.name, () => {
     });
 
     it('should delete a live photo', async () => {
-      when(assetMock.getById)
-        .calledWith(assetStub.livePhotoStillAsset.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetStub.livePhotoStillAsset);
-      when(assetMock.getById)
-        .calledWith(assetStub.livePhotoMotionAsset.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetStub.livePhotoMotionAsset);
+      assetMock.getById.mockResolvedValue(assetStub.livePhotoStillAsset);
 
       await sut.handleAssetDeletion({ id: assetStub.livePhotoStillAsset.id });
 
       expect(jobMock.queue.mock.calls).toEqual([
         [{ name: JobName.ASSET_DELETION, data: { id: assetStub.livePhotoMotionAsset.id } }],
-        [
-          {
-            name: JobName.DELETE_FILES,
-            data: {
-              files: [undefined, undefined, undefined, undefined, 'fake_path/asset_1.mp4'],
-            },
-          },
-        ],
         [
           {
             name: JobName.DELETE_FILES,
@@ -814,18 +732,8 @@ describe(AssetService.name, () => {
     });
 
     it('should update usage', async () => {
-      when(assetMock.getById)
-        .calledWith(assetStub.image.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: { assets: true },
-          exifInfo: true,
-        })
-        .mockResolvedValue(assetStub.image);
+      assetMock.getById.mockResolvedValue(assetStub.image);
       await sut.handleAssetDeletion({ id: assetStub.image.id });
-
       expect(userMock.updateUsage).toHaveBeenCalledWith(assetStub.image.ownerId, -5000);
     });
   });
@@ -874,18 +782,7 @@ describe(AssetService.name, () => {
     it('make old parent the child of new parent', async () => {
       accessMock.asset.checkOwnerAccess.mockResolvedValueOnce(new Set([assetStub.image.id]));
       accessMock.asset.checkOwnerAccess.mockResolvedValueOnce(new Set(['new']));
-
-      when(assetMock.getById)
-        .calledWith(assetStub.image.id, {
-          faces: {
-            person: true,
-          },
-          library: true,
-          stack: {
-            assets: true,
-          },
-        })
-        .mockResolvedValue({ ...assetStub.image, stackId: 'stack-1' });
+      assetMock.getById.mockResolvedValue({ ...assetStub.image, stackId: 'stack-1' });
 
       await sut.updateStackParent(authStub.user1, {
         oldParentId: assetStub.image.id,

server/src/services/asset.service.ts

@@ -40,11 +40,11 @@ import {
   JobName,
   JobStatus,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IPartnerRepository } from 'src/interfaces/partner.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
-import { ImmichLogger } from 'src/utils/logger';
 import { mimeTypes } from 'src/utils/mime-types';
 import { usePagination } from 'src/utils/pagination';
 
@@ -63,7 +63,6 @@ export interface UploadFile {
 }
 
 export class AssetService {
-  private logger = new ImmichLogger(AssetService.name);
   private access: AccessCore;
   private configCore: SystemConfigCore;
 
@@ -77,9 +76,11 @@ export class AssetService {
     @Inject(IEventRepository) private eventRepository: IEventRepository,
     @Inject(IPartnerRepository) private partnerRepository: IPartnerRepository,
     @Inject(IAssetStackRepository) private assetStackRepository: IAssetStackRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
+    this.logger.setContext(AssetService.name);
     this.access = AccessCore.create(accessRepository);
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
   }
 
   canUploadFile({ auth, fieldName, file }: UploadRequest): true {
@@ -391,12 +392,17 @@ export class AssetService {
     }
 
     await this.assetRepository.remove(asset);
-    await this.userRepository.updateUsage(asset.ownerId, -(asset.exifInfo?.fileSizeInByte || 0));
+    if (asset.library.type === LibraryType.UPLOAD) {
+      await this.userRepository.updateUsage(asset.ownerId, -(asset.exifInfo?.fileSizeInByte || 0));
+    }
     this.eventRepository.clientSend(ClientEvent.ASSET_DELETE, asset.ownerId, id);
 
     // TODO refactor this to use cascades
     if (asset.livePhotoVideoId) {
-      await this.jobRepository.queue({ name: JobName.ASSET_DELETION, data: { id: asset.livePhotoVideoId } });
+      await this.jobRepository.queue({
+        name: JobName.ASSET_DELETION,
+        data: { id: asset.livePhotoVideoId, fromExternal },
+      });
     }
 
     const files = [asset.thumbnailPath, asset.previewPath, asset.encodedVideoPath];

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

@@ -3,6 +3,7 @@ import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { IAuditRepository } from 'src/interfaces/audit.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
@@ -13,19 +14,22 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newAuditRepositoryMock } from 'test/repositories/audit.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked } from 'vitest';
 
 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>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();
@@ -35,7 +39,8 @@ describe(AuditService.name, () => {
     personMock = newPersonRepositoryMock();
     storageMock = newStorageRepositoryMock();
     userMock = newUserRepositoryMock();
-    sut = new AuditService(accessMock, assetMock, cryptoMock, personMock, auditMock, storageMock, userMock);
+    loggerMock = newLoggerRepositoryMock();
+    sut = new AuditService(accessMock, assetMock, cryptoMock, personMock, auditMock, storageMock, userMock, loggerMock);
   });
 
   it('should work', () => {
@@ -61,13 +66,13 @@ describe(AuditService.name, () => {
 
       expect(auditMock.getAfter).toHaveBeenCalledWith(date, {
         action: DatabaseAction.DELETE,
-        ownerId: authStub.admin.user.id,
+        userIds: [authStub.admin.user.id],
         entityType: EntityType.ASSET,
       });
     });
 
     it('should get any new or updated assets and deleted ids', async () => {
-      auditMock.getAfter.mockResolvedValue([auditStub.delete]);
+      auditMock.getAfter.mockResolvedValue([auditStub.delete.entityId]);
 
       const date = new Date();
       await expect(sut.getDeletes(authStub.admin, { after: date, entityType: EntityType.ASSET })).resolves.toEqual({
@@ -77,7 +82,7 @@ describe(AuditService.name, () => {
 
       expect(auditMock.getAfter).toHaveBeenCalledWith(date, {
         action: DatabaseAction.DELETE,
-        ownerId: authStub.admin.user.id,
+        userIds: [authStub.admin.user.id],
         entityType: EntityType.ASSET,
       });
     });

server/src/services/audit.service.ts

@@ -20,16 +20,15 @@ import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { IAuditRepository } from 'src/interfaces/audit.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { JOBS_ASSET_PAGINATION_SIZE, JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
-import { ImmichLogger } from 'src/utils/logger';
 import { usePagination } from 'src/utils/pagination';
 
 @Injectable()
 export class AuditService {
   private access: AccessCore;
-  private logger = new ImmichLogger(AuditService.name);
 
   constructor(
     @Inject(IAccessRepository) accessRepository: IAccessRepository,
@@ -39,8 +38,10 @@ export class AuditService {
     @Inject(IAuditRepository) private repository: IAuditRepository,
     @Inject(IStorageRepository) private storageRepository: IStorageRepository,
     @Inject(IUserRepository) private userRepository: IUserRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
     this.access = AccessCore.create(accessRepository);
+    this.logger.setContext(AuditService.name);
   }
 
   async handleCleanup(): Promise<JobStatus> {
@@ -53,7 +54,7 @@ export class AuditService {
     await this.access.requirePermission(auth, Permission.TIMELINE_READ, userId);
 
     const audits = await this.repository.getAfter(dto.after, {
-      ownerId: userId,
+      userIds: [userId],
       entityType: dto.entityType,
       action: DatabaseAction.DELETE,
     });
@@ -62,7 +63,7 @@ export class AuditService {
 
     return {
       needsFullSync: duration > AUDIT_LOG_MAX_DURATION,
-      ids: audits.map(({ entityId }) => entityId),
+      ids: audits,
     };
   }
 

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

@@ -8,6 +8,7 @@ import { UserEntity } from 'src/entities/user.entity';
 import { IKeyRepository } from 'src/interfaces/api-key.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { ISharedLinkRepository } from 'src/interfaces/shared-link.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { IUserTokenRepository } from 'src/interfaces/user-token.interface';
@@ -23,10 +24,12 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newKeyRepositoryMock } from 'test/repositories/api-key.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
 import { newLibraryRepositoryMock } from 'test/repositories/library.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newSharedLinkRepositoryMock } from 'test/repositories/shared-link.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
 import { newUserTokenRepositoryMock } from 'test/repositories/user-token.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mock, Mocked, vitest } from 'vitest';
 
 // const token = Buffer.from('my-api-key', 'utf8').toString('base64');
 
@@ -56,33 +59,34 @@ 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 accessMock: Mocked<IAccessRepositoryMock>;
+  let cryptoMock: Mocked<ICryptoRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let libraryMock: Mocked<ILibraryRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let userTokenMock: Mocked<IUserTokenRepository>;
+  let shareMock: Mocked<ISharedLinkRepository>;
+  let keyMock: Mocked<IKeyRepository>;
 
-  let callbackMock: jest.Mock;
-  let userinfoMock: jest.Mock;
+  let callbackMock: Mock;
+  let userinfoMock: Mock;
 
   beforeEach(() => {
-    callbackMock = jest.fn().mockReturnValue({ access_token: 'access-token' });
-    userinfoMock = jest.fn().mockResolvedValue({ sub, email });
+    callbackMock = vitest.fn().mockReturnValue({ access_token: 'access-token' });
+    userinfoMock = vitest.fn().mockResolvedValue({ sub, email });
 
-    jest.spyOn(generators, 'state').mockReturnValue('state');
-    jest.spyOn(Issuer, 'discover').mockResolvedValue({
+    vitest.spyOn(generators, 'state').mockReturnValue('state');
+    vitest.spyOn(Issuer, 'discover').mockResolvedValue({
       id_token_signing_alg_values_supported: ['RS256'],
-      Client: jest.fn().mockResolvedValue({
+      Client: vitest.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: vitest.fn().mockReturnValue('http://authorization-url'),
+        callbackParams: vitest.fn().mockReturnValue({ state: 'state' }),
         callback: callbackMock,
         userinfo: userinfoMock,
       }),
@@ -92,12 +96,23 @@ describe('AuthService', () => {
     cryptoMock = newCryptoRepositoryMock();
     userMock = newUserRepositoryMock();
     libraryMock = newLibraryRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
     configMock = newSystemConfigRepositoryMock();
     userTokenMock = newUserTokenRepositoryMock();
     shareMock = newSharedLinkRepositoryMock();
     keyMock = newKeyRepositoryMock();
 
-    sut = new AuthService(accessMock, cryptoMock, configMock, libraryMock, userMock, userTokenMock, shareMock, keyMock);
+    sut = new AuthService(
+      accessMock,
+      cryptoMock,
+      configMock,
+      libraryMock,
+      loggerMock,
+      userMock,
+      userTokenMock,
+      shareMock,
+      keyMock,
+    );
   });
 
   it('should be defined', () => {

server/src/services/auth.service.ts

@@ -43,12 +43,12 @@ import { IAccessRepository } from 'src/interfaces/access.interface';
 import { IKeyRepository } from 'src/interfaces/api-key.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { ISharedLinkRepository } from 'src/interfaces/shared-link.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { IUserTokenRepository } from 'src/interfaces/user-token.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
 import { HumanReadableSize } from 'src/utils/bytes';
-import { ImmichLogger } from 'src/utils/logger';
 
 export interface LoginDetails {
   isSecure: boolean;
@@ -76,7 +76,6 @@ interface ClaimOptions<T> {
 export class AuthService {
   private access: AccessCore;
   private configCore: SystemConfigCore;
-  private logger = new ImmichLogger(AuthService.name);
   private userCore: UserCore;
 
   constructor(
@@ -84,13 +83,15 @@ export class AuthService {
     @Inject(ICryptoRepository) private cryptoRepository: ICryptoRepository,
     @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
     @Inject(ILibraryRepository) libraryRepository: ILibraryRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
     @Inject(IUserRepository) private userRepository: IUserRepository,
     @Inject(IUserTokenRepository) private userTokenRepository: IUserTokenRepository,
     @Inject(ISharedLinkRepository) private sharedLinkRepository: ISharedLinkRepository,
     @Inject(IKeyRepository) private keyRepository: IKeyRepository,
   ) {
+    this.logger.setContext(AuthService.name);
     this.access = AccessCore.create(accessRepository);
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.configCore = SystemConfigCore.create(configRepository, logger);
     this.userCore = UserCore.create(cryptoRepository, libraryRepository, userRepository);
 
     custom.setHttpOptionsDefaults({ timeout: 30_000 });

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

@@ -1,17 +1,20 @@
 import { DatabaseExtension, IDatabaseRepository, VectorIndex } from 'src/interfaces/database.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { DatabaseService } from 'src/services/database.service';
-import { ImmichLogger } from 'src/utils/logger';
 import { Version, VersionType } from 'src/utils/version';
 import { newDatabaseRepositoryMock } from 'test/repositories/database.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(DatabaseService.name, () => {
   let sut: DatabaseService;
-  let databaseMock: jest.Mocked<IDatabaseRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     databaseMock = newDatabaseRepositoryMock();
-
-    sut = new DatabaseService(databaseMock);
+    loggerMock = newLoggerRepositoryMock();
+    sut = new DatabaseService(databaseMock, loggerMock);
   });
 
   it('should work', () => {
@@ -22,18 +25,11 @@ 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;
-
     beforeEach(() => {
-      fatalLog = jest.spyOn(ImmichLogger.prototype, 'fatal');
-      errorLog = jest.spyOn(ImmichLogger.prototype, 'error');
-      warnLog = jest.spyOn(ImmichLogger.prototype, 'warn');
       databaseMock.getPreferredVectorExtension.mockReturnValue(vectorExt);
       databaseMock.getExtensionVersion.mockResolvedValue(minVersion);
 
-      sut = new DatabaseService(databaseMock);
+      sut = new DatabaseService(databaseMock, loggerMock);
 
       sut.minVectorVersion = minVersion;
       sut.minVectorsVersion = minVersion;
@@ -41,11 +37,6 @@ describe(DatabaseService.name, () => {
       sut.vectorsVersionPin = VersionType.MINOR;
     });
 
-    afterEach(() => {
-      fatalLog.mockRestore();
-      warnLog.mockRestore();
-    });
-
     it(`should resolve successfully if minimum supported PostgreSQL and ${extName} version are installed`, async () => {
       databaseMock.getPostgresVersion.mockResolvedValueOnce(new Version(14, 0, 0));
 
@@ -56,7 +47,7 @@ describe(DatabaseService.name, () => {
       expect(databaseMock.createExtension).toHaveBeenCalledTimes(1);
       expect(databaseMock.getExtensionVersion).toHaveBeenCalled();
       expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-      expect(fatalLog).not.toHaveBeenCalled();
+      expect(loggerMock.fatal).not.toHaveBeenCalled();
     });
 
     it('should throw an error if PostgreSQL version is below minimum supported version', async () => {
@@ -73,7 +64,7 @@ describe(DatabaseService.name, () => {
       expect(databaseMock.createExtension).toHaveBeenCalledWith(vectorExt);
       expect(databaseMock.createExtension).toHaveBeenCalledTimes(1);
       expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-      expect(fatalLog).not.toHaveBeenCalled();
+      expect(loggerMock.fatal).not.toHaveBeenCalled();
     });
 
     it(`should throw an error if ${extName} version is not installed even after createVectorExtension`, async () => {
@@ -133,7 +124,7 @@ describe(DatabaseService.name, () => {
 
       await expect(sut.init()).rejects.toThrow('Failed to create extension');
 
-      expect(fatalLog).toHaveBeenCalledTimes(1);
+      expect(loggerMock.fatal).toHaveBeenCalledTimes(1);
       expect(databaseMock.createExtension).toHaveBeenCalledTimes(1);
       expect(databaseMock.runMigrations).not.toHaveBeenCalled();
     });
@@ -147,7 +138,7 @@ describe(DatabaseService.name, () => {
       expect(databaseMock.updateVectorExtension).toHaveBeenCalledWith(vectorExt, version);
       expect(databaseMock.updateVectorExtension).toHaveBeenCalledTimes(1);
       expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-      expect(fatalLog).not.toHaveBeenCalled();
+      expect(loggerMock.fatal).not.toHaveBeenCalled();
     });
 
     it(`should not update ${extName} if a newer version is higher than the maximum`, async () => {
@@ -158,7 +149,7 @@ describe(DatabaseService.name, () => {
 
       expect(databaseMock.updateVectorExtension).not.toHaveBeenCalled();
       expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-      expect(fatalLog).not.toHaveBeenCalled();
+      expect(loggerMock.fatal).not.toHaveBeenCalled();
     });
 
     it(`should warn if attempted to update ${extName} and failed`, async () => {
@@ -168,10 +159,10 @@ describe(DatabaseService.name, () => {
 
       await expect(sut.init()).resolves.toBeUndefined();
 
-      expect(warnLog).toHaveBeenCalledTimes(1);
-      expect(warnLog.mock.calls[0][0]).toContain(extName);
-      expect(errorLog).toHaveBeenCalledTimes(1);
-      expect(fatalLog).not.toHaveBeenCalled();
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      expect(loggerMock.warn.mock.calls[0][0]).toContain(extName);
+      expect(loggerMock.error).toHaveBeenCalledTimes(1);
+      expect(loggerMock.fatal).not.toHaveBeenCalled();
       expect(databaseMock.updateVectorExtension).toHaveBeenCalledWith(vectorExt, version);
       expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
     });
@@ -183,11 +174,11 @@ describe(DatabaseService.name, () => {
 
       await expect(sut.init()).resolves.toBeUndefined();
 
-      expect(warnLog).toHaveBeenCalledTimes(1);
-      expect(warnLog.mock.calls[0][0]).toContain(extName);
+      expect(loggerMock.warn).toHaveBeenCalledTimes(1);
+      expect(loggerMock.warn.mock.calls[0][0]).toContain(extName);
       expect(databaseMock.updateVectorExtension).toHaveBeenCalledWith(vectorExt, version);
       expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-      expect(fatalLog).not.toHaveBeenCalled();
+      expect(loggerMock.fatal).not.toHaveBeenCalled();
     });
 
     it.each([{ index: VectorIndex.CLIP }, { index: VectorIndex.FACE }])(
@@ -202,7 +193,7 @@ describe(DatabaseService.name, () => {
         expect(databaseMock.reindex).toHaveBeenCalledWith(index);
         expect(databaseMock.reindex).toHaveBeenCalledTimes(1);
         expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-        expect(fatalLog).not.toHaveBeenCalled();
+        expect(loggerMock.fatal).not.toHaveBeenCalled();
       },
     );
 
@@ -216,7 +207,7 @@ describe(DatabaseService.name, () => {
         expect(databaseMock.shouldReindex).toHaveBeenCalledTimes(2);
         expect(databaseMock.reindex).not.toHaveBeenCalled();
         expect(databaseMock.runMigrations).toHaveBeenCalledTimes(1);
-        expect(fatalLog).not.toHaveBeenCalled();
+        expect(loggerMock.fatal).not.toHaveBeenCalled();
       },
     );
   });

server/src/services/database.service.ts

@@ -7,12 +7,11 @@ import {
   VectorIndex,
   extName,
 } from 'src/interfaces/database.interface';
-import { ImmichLogger } from 'src/utils/logger';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { Version, VersionType } from 'src/utils/version';
 
 @Injectable()
 export class DatabaseService {
-  private logger = new ImmichLogger(DatabaseService.name);
   private vectorExt: VectorExtension;
   minPostgresVersion = 14;
   minVectorsVersion = new Version(0, 2, 0);
@@ -20,7 +19,11 @@ export class DatabaseService {
   minVectorVersion = new Version(0, 5, 0);
   vectorVersionPin = VersionType.MAJOR;
 
-  constructor(@Inject(IDatabaseRepository) private databaseRepository: IDatabaseRepository) {
+  constructor(
+    @Inject(IDatabaseRepository) private databaseRepository: IDatabaseRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(DatabaseService.name);
     this.vectorExt = this.databaseRepository.getPreferredVectorExtension();
   }
 

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

@@ -1,6 +1,6 @@
 import { BadRequestException } from '@nestjs/common';
-import { when } from 'jest-when';
 import { DownloadResponseDto } from 'src/dtos/download.dto';
+import { AssetEntity } from 'src/entities/asset.entity';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { DownloadService } from 'src/services/download.service';
@@ -11,6 +11,7 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { Readable } from 'typeorm/platform/PlatformTools.js';
+import { Mocked, vitest } from 'vitest';
 
 const downloadResponse: DownloadResponseDto = {
   totalSize: 105_000,
@@ -25,8 +26,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();
@@ -82,8 +83,8 @@ describe(DownloadService.name, () => {
 
     it('should download an archive', async () => {
       const archiveMock = {
-        addFile: jest.fn(),
-        finalize: jest.fn(),
+        addFile: vitest.fn(),
+        finalize: vitest.fn(),
         stream: new Readable(),
       };
 
@@ -105,8 +106,8 @@ describe(DownloadService.name, () => {
 
     it('should handle duplicate file names', async () => {
       const archiveMock = {
-        addFile: jest.fn(),
-        finalize: jest.fn(),
+        addFile: vitest.fn(),
+        finalize: vitest.fn(),
         stream: new Readable(),
       };
 
@@ -128,8 +129,8 @@ describe(DownloadService.name, () => {
 
     it('should be deterministic', async () => {
       const archiveMock = {
-        addFile: jest.fn(),
-        finalize: jest.fn(),
+        addFile: vitest.fn(),
+        finalize: vitest.fn(),
         stream: new Readable(),
       };
 
@@ -223,14 +224,15 @@ describe(DownloadService.name, () => {
 
     it('should include the video portion of a live photo', async () => {
       const assetIds = [assetStub.livePhotoStillAsset.id];
+      const assets = [assetStub.livePhotoStillAsset, assetStub.livePhotoMotionAsset];
 
       accessMock.asset.checkOwnerAccess.mockResolvedValue(new Set(assetIds));
-      when(assetMock.getByIds)
-        .calledWith([assetStub.livePhotoStillAsset.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.livePhotoStillAsset]);
-      when(assetMock.getByIds)
-        .calledWith([assetStub.livePhotoMotionAsset.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.livePhotoMotionAsset]);
+      assetMock.getByIds.mockImplementation(
+        (ids) =>
+          Promise.resolve(
+            ids.map((id) => assets.find((asset) => asset.id === id)).filter((asset) => !!asset),
+          ) as Promise<AssetEntity[]>,
+      );
 
       await expect(sut.getDownloadInfo(authStub.admin, { assetIds })).resolves.toEqual({
         totalSize: 125_000,

server/src/services/index.ts

@@ -22,6 +22,7 @@ import { SharedLinkService } from 'src/services/shared-link.service';
 import { SmartInfoService } from 'src/services/smart-info.service';
 import { StorageTemplateService } from 'src/services/storage-template.service';
 import { StorageService } from 'src/services/storage.service';
+import { SyncService } from 'src/services/sync.service';
 import { SystemConfigService } from 'src/services/system-config.service';
 import { TagService } from 'src/services/tag.service';
 import { TimelineService } from 'src/services/timeline.service';
@@ -53,6 +54,7 @@ export const services = [
   SmartInfoService,
   StorageService,
   StorageTemplateService,
+  SyncService,
   SystemConfigService,
   TagService,
   TimelineService,

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

@@ -12,6 +12,7 @@ import {
   JobStatus,
   QueueName,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMetricRepository } from 'src/interfaces/metric.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
@@ -20,12 +21,14 @@ import { assetStub } from 'test/fixtures/asset.stub';
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMetricRepositoryMock } from 'test/repositories/metric.repository.mock';
 import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { Mocked, vitest } from 'vitest';
 
 const makeMockHandlers = (status: JobStatus) => {
-  const mock = jest.fn().mockResolvedValue(status);
+  const mock = vitest.fn().mockResolvedValue(status);
   return Object.fromEntries(Object.values(JobName).map((jobName) => [jobName, mock])) as unknown as Record<
     JobName,
     JobHandler
@@ -34,12 +37,13 @@ const makeMockHandlers = (status: JobStatus) => {
 
 describe(JobService.name, () => {
   let sut: JobService;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let eventMock: jest.Mocked<IEventRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let personMock: jest.Mocked<IPersonRepository>;
-  let metricMock: jest.Mocked<IMetricRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let eventMock: Mocked<IEventRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let personMock: Mocked<IPersonRepository>;
+  let metricMock: Mocked<IMetricRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();
@@ -48,7 +52,8 @@ describe(JobService.name, () => {
     jobMock = newJobRepositoryMock();
     personMock = newPersonRepositoryMock();
     metricMock = newMetricRepositoryMock();
-    sut = new JobService(assetMock, eventMock, jobMock, configMock, personMock, metricMock);
+    loggerMock = newLoggerRepositoryMock();
+    sut = new JobService(assetMock, eventMock, jobMock, configMock, personMock, metricMock, loggerMock);
   });
 
   it('should work', () => {
@@ -234,7 +239,7 @@ describe(JobService.name, () => {
     it('should subscribe to config changes', async () => {
       await sut.init(makeMockHandlers(JobStatus.FAILED));
 
-      SystemConfigCore.create(newSystemConfigRepositoryMock(false)).config$.next({
+      SystemConfigCore.create(newSystemConfigRepositoryMock(false), newLoggerRepositoryMock()).config$.next({
         job: {
           [QueueName.BACKGROUND_TASK]: { concurrency: 10 },
           [QueueName.SMART_SEARCH]: { concurrency: 10 },

server/src/services/job.service.ts

@@ -17,14 +17,13 @@ import {
   QueueCleanType,
   QueueName,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMetricRepository } from 'src/interfaces/metric.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 
 @Injectable()
 export class JobService {
-  private logger = new ImmichLogger(JobService.name);
   private configCore: SystemConfigCore;
 
   constructor(
@@ -34,8 +33,10 @@ export class JobService {
     @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
     @Inject(IPersonRepository) private personRepository: IPersonRepository,
     @Inject(IMetricRepository) private metricRepository: IMetricRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(JobService.name);
+    this.configCore = SystemConfigCore.create(configRepository, logger);
   }
 
   async handleCommand(queueName: QueueName, dto: JobCommandDto): Promise<JobStatusDto> {

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

@@ -1,6 +1,4 @@
 import { BadRequestException } from '@nestjs/common';
-import { when } from 'jest-when';
-import { R_OK } from 'node:constants';
 import { Stats } from 'node:fs';
 import { SystemConfigCore } from 'src/cores/system-config.core';
 import { mapLibrary } from 'src/dtos/library.dto';
@@ -13,7 +11,8 @@ import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { IJobRepository, ILibraryFileJob, ILibraryRefreshJob, JobName, JobStatus } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
-import { IStorageRepository, StorageEventType } from 'src/interfaces/storage.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
+import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { LibraryService } from 'src/services/library.service';
 import { assetStub } from 'test/fixtures/asset.stub';
@@ -26,19 +25,22 @@ import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.moc
 import { newDatabaseRepositoryMock } from 'test/repositories/database.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
 import { newLibraryRepositoryMock } from 'test/repositories/library.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { makeMockWatcher, newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { Mocked, vitest } from 'vitest';
 
 describe(LibraryService.name, () => {
   let sut: LibraryService;
 
-  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>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     configMock = newSystemConfigRepositoryMock();
@@ -48,8 +50,18 @@ describe(LibraryService.name, () => {
     cryptoMock = newCryptoRepositoryMock();
     storageMock = newStorageRepositoryMock();
     databaseMock = newDatabaseRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
-    sut = new LibraryService(assetMock, configMock, cryptoMock, jobMock, libraryMock, storageMock, databaseMock);
+    sut = new LibraryService(
+      assetMock,
+      configMock,
+      cryptoMock,
+      jobMock,
+      libraryMock,
+      storageMock,
+      databaseMock,
+      loggerMock,
+    );
 
     databaseMock.tryLock.mockResolvedValue(true);
   });
@@ -69,7 +81,7 @@ describe(LibraryService.name, () => {
       expect(configMock.load).toHaveBeenCalled();
       expect(jobMock.addCronJob).toHaveBeenCalled();
 
-      SystemConfigCore.create(newSystemConfigRepositoryMock(false)).config$.next({
+      SystemConfigCore.create(newSystemConfigRepositoryMock(false), newLoggerRepositoryMock()).config$.next({
         library: {
           scan: {
             enabled: true,
@@ -89,15 +101,13 @@ describe(LibraryService.name, () => {
       ]);
 
       configMock.load.mockResolvedValue(systemConfigStub.libraryWatchEnabled);
-      libraryMock.get.mockResolvedValue(libraryStub.externalLibrary1);
-
-      when(libraryMock.get)
-        .calledWith(libraryStub.externalLibraryWithImportPaths1.id)
-        .mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-
-      when(libraryMock.get)
-        .calledWith(libraryStub.externalLibraryWithImportPaths2.id)
-        .mockResolvedValue(libraryStub.externalLibraryWithImportPaths2);
+      libraryMock.get.mockImplementation((id) =>
+        Promise.resolve(
+          [libraryStub.externalLibraryWithImportPaths1, libraryStub.externalLibraryWithImportPaths2].find(
+            (library) => library.id === id,
+          ) || null,
+        ),
+      );
 
       await sut.init();
 
@@ -160,7 +170,7 @@ describe(LibraryService.name, () => {
       storageMock.walk.mockImplementation(async function* generator() {
         yield '/data/user1/photo.jpg';
       });
-      assetMock.getLibraryAssetPaths.mockResolvedValue({ items: [], hasNextPage: false });
+      assetMock.getExternalLibraryAssetPaths.mockResolvedValue({ items: [], hasNextPage: false });
 
       await sut.handleQueueAssetRefresh(mockLibraryJob);
 
@@ -189,7 +199,7 @@ describe(LibraryService.name, () => {
       storageMock.walk.mockImplementation(async function* generator() {
         yield '/data/user1/photo.jpg';
       });
-      assetMock.getLibraryAssetPaths.mockResolvedValue({ items: [], hasNextPage: false });
+      assetMock.getExternalLibraryAssetPaths.mockResolvedValue({ items: [], hasNextPage: false });
 
       await sut.handleQueueAssetRefresh(mockLibraryJob);
 
@@ -238,7 +248,7 @@ describe(LibraryService.name, () => {
       };
 
       libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-      assetMock.getLibraryAssetPaths.mockResolvedValue({ items: [], hasNextPage: false });
+      assetMock.getExternalLibraryAssetPaths.mockResolvedValue({ items: [], hasNextPage: false });
 
       await sut.handleQueueAssetRefresh(mockLibraryJob);
 
@@ -256,8 +266,8 @@ describe(LibraryService.name, () => {
       };
 
       libraryMock.get.mockResolvedValue(libraryStub.externalLibrary1);
-      assetMock.getLibraryAssetPaths.mockResolvedValue({
-        items: [assetStub.image],
+      assetMock.getExternalLibraryAssetPaths.mockResolvedValue({
+        items: [assetStub.external],
         hasNextPage: false,
       });
 
@@ -278,16 +288,16 @@ describe(LibraryService.name, () => {
       libraryMock.get.mockResolvedValue(libraryStub.externalLibrary1);
       // eslint-disable-next-line @typescript-eslint/require-await
       storageMock.walk.mockImplementation(async function* generator() {
-        yield assetStub.offline.originalPath;
+        yield assetStub.externalOffline.originalPath;
       });
-      assetMock.getLibraryAssetPaths.mockResolvedValue({
-        items: [assetStub.offline],
+      assetMock.getExternalLibraryAssetPaths.mockResolvedValue({
+        items: [assetStub.externalOffline],
         hasNextPage: false,
       });
 
       await sut.handleQueueAssetRefresh(mockLibraryJob);
 
-      expect(assetMock.updateAll).toHaveBeenCalledWith([assetStub.offline.id], { isOffline: false });
+      expect(assetMock.updateAll).toHaveBeenCalledWith([assetStub.externalOffline.id], { isOffline: false });
       expect(assetMock.updateAll).not.toHaveBeenCalledWith(expect.anything(), { isOffline: true });
       expect(jobMock.queueAll).not.toHaveBeenCalled();
     });
@@ -751,7 +761,7 @@ describe(LibraryService.name, () => {
 
       configMock.load.mockResolvedValue(systemConfigStub.libraryWatchEnabled);
 
-      const mockClose = jest.fn();
+      const mockClose = vitest.fn();
       storageMock.watch.mockImplementation(makeMockWatcher({ close: mockClose }));
 
       await sut.init();
@@ -933,12 +943,6 @@ describe(LibraryService.name, () => {
           type: LibraryType.EXTERNAL,
           importPaths: libraryStub.externalLibraryWithImportPaths1.importPaths,
         });
-
-        expect(storageMock.watch).toHaveBeenCalledWith(
-          libraryStub.externalLibraryWithImportPaths1.importPaths,
-          expect.anything(),
-          expect.anything(),
-        );
       });
 
       it('should create with exclusion patterns', async () => {
@@ -1087,45 +1091,6 @@ describe(LibraryService.name, () => {
       await expect(sut.update('library-id', {})).resolves.toEqual(mapLibrary(libraryStub.uploadLibrary1));
       expect(libraryMock.update).toHaveBeenCalledWith(expect.objectContaining({ id: 'library-id' }));
     });
-
-    it('should re-watch library when updating import paths', async () => {
-      libraryMock.update.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-      libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-
-      storageMock.stat.mockResolvedValue({
-        isDirectory: () => true,
-      } as Stats);
-
-      storageMock.checkFileExists.mockResolvedValue(true);
-
-      await expect(sut.update('library-id', { importPaths: ['/data/user1/foo'] })).resolves.toEqual(
-        mapLibrary(libraryStub.externalLibraryWithImportPaths1),
-      );
-
-      expect(libraryMock.update).toHaveBeenCalledWith(expect.objectContaining({ id: 'library-id' }));
-      expect(storageMock.watch).toHaveBeenCalledWith(
-        libraryStub.externalLibraryWithImportPaths1.importPaths,
-        expect.anything(),
-        expect.anything(),
-      );
-    });
-
-    it('should re-watch library when updating exclusion patterns', async () => {
-      libraryMock.update.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-      configMock.load.mockResolvedValue(systemConfigStub.libraryWatchEnabled);
-      libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
-
-      await expect(sut.update('library-id', { exclusionPatterns: ['bar'] })).resolves.toEqual(
-        mapLibrary(libraryStub.externalLibraryWithImportPaths1),
-      );
-
-      expect(libraryMock.update).toHaveBeenCalledWith(expect.objectContaining({ id: 'library-id' }));
-      expect(storageMock.watch).toHaveBeenCalledWith(
-        expect.arrayContaining([expect.any(String)]),
-        expect.anything(),
-        expect.anything(),
-      );
-    });
   });
 
   describe('watchAll', () => {
@@ -1168,7 +1133,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 = vitest.fn();
         storageMock.watch.mockImplementation(makeMockWatcher({ close: mockClose }));
 
         await sut.watchAll();
@@ -1198,9 +1163,7 @@ describe(LibraryService.name, () => {
       it('should handle a new file event', async () => {
         libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
         libraryMock.getAll.mockResolvedValue([libraryStub.externalLibraryWithImportPaths1]);
-        storageMock.watch.mockImplementation(
-          makeMockWatcher({ items: [{ event: StorageEventType.ADD, value: '/foo/photo.jpg' }] }),
-        );
+        storageMock.watch.mockImplementation(makeMockWatcher({ items: [{ event: 'add', value: '/foo/photo.jpg' }] }));
 
         await sut.watchAll();
 
@@ -1221,7 +1184,7 @@ describe(LibraryService.name, () => {
         libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
         libraryMock.getAll.mockResolvedValue([libraryStub.externalLibraryWithImportPaths1]);
         storageMock.watch.mockImplementation(
-          makeMockWatcher({ items: [{ event: StorageEventType.CHANGE, value: '/foo/photo.jpg' }] }),
+          makeMockWatcher({ items: [{ event: 'change', value: '/foo/photo.jpg' }] }),
         );
 
         await sut.watchAll();
@@ -1244,7 +1207,7 @@ describe(LibraryService.name, () => {
         libraryMock.getAll.mockResolvedValue([libraryStub.externalLibraryWithImportPaths1]);
         assetMock.getByLibraryIdAndOriginalPath.mockResolvedValue(assetStub.external);
         storageMock.watch.mockImplementation(
-          makeMockWatcher({ items: [{ event: StorageEventType.UNLINK, value: '/foo/photo.jpg' }] }),
+          makeMockWatcher({ items: [{ event: 'unlink', value: '/foo/photo.jpg' }] }),
         );
 
         await sut.watchAll();
@@ -1258,19 +1221,17 @@ describe(LibraryService.name, () => {
         libraryMock.getAll.mockResolvedValue([libraryStub.externalLibraryWithImportPaths1]);
         storageMock.watch.mockImplementation(
           makeMockWatcher({
-            items: [{ event: StorageEventType.ERROR, value: 'Error!' }],
+            items: [{ event: 'error', value: 'Error!' }],
           }),
         );
 
-        await expect(sut.watchAll()).rejects.toThrow('Error!');
+        await expect(sut.watchAll()).resolves.toBeUndefined();
       });
 
       it('should ignore unknown extensions', async () => {
         libraryMock.get.mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
         libraryMock.getAll.mockResolvedValue([libraryStub.externalLibraryWithImportPaths1]);
-        storageMock.watch.mockImplementation(
-          makeMockWatcher({ items: [{ event: StorageEventType.ADD, value: '/foo/photo.jpg' }] }),
-        );
+        storageMock.watch.mockImplementation(makeMockWatcher({ items: [{ event: 'add', value: '/foo/photo.jpg' }] }));
 
         await sut.watchAll();
 
@@ -1280,9 +1241,7 @@ describe(LibraryService.name, () => {
       it('should ignore excluded paths', async () => {
         libraryMock.get.mockResolvedValue(libraryStub.patternPath);
         libraryMock.getAll.mockResolvedValue([libraryStub.patternPath]);
-        storageMock.watch.mockImplementation(
-          makeMockWatcher({ items: [{ event: StorageEventType.ADD, value: '/dir1/photo.txt' }] }),
-        );
+        storageMock.watch.mockImplementation(makeMockWatcher({ items: [{ event: 'add', value: '/dir1/photo.txt' }] }));
 
         await sut.watchAll();
 
@@ -1292,9 +1251,7 @@ describe(LibraryService.name, () => {
       it('should ignore excluded paths without case sensitivity', async () => {
         libraryMock.get.mockResolvedValue(libraryStub.patternPath);
         libraryMock.getAll.mockResolvedValue([libraryStub.patternPath]);
-        storageMock.watch.mockImplementation(
-          makeMockWatcher({ items: [{ event: StorageEventType.ADD, value: '/DIR1/photo.txt' }] }),
-        );
+        storageMock.watch.mockImplementation(makeMockWatcher({ items: [{ event: 'add', value: '/DIR1/photo.txt' }] }));
 
         await sut.watchAll();
 
@@ -1313,15 +1270,15 @@ describe(LibraryService.name, () => {
       configMock.load.mockResolvedValue(systemConfigStub.libraryWatchEnabled);
       libraryMock.get.mockResolvedValue(libraryStub.externalLibrary1);
 
-      when(libraryMock.get)
-        .calledWith(libraryStub.externalLibraryWithImportPaths1.id)
-        .mockResolvedValue(libraryStub.externalLibraryWithImportPaths1);
+      libraryMock.get.mockImplementation((id) =>
+        Promise.resolve(
+          [libraryStub.externalLibraryWithImportPaths1, libraryStub.externalLibraryWithImportPaths2].find(
+            (library) => library.id === id,
+          ) || null,
+        ),
+      );
 
-      when(libraryMock.get)
-        .calledWith(libraryStub.externalLibraryWithImportPaths2.id)
-        .mockResolvedValue(libraryStub.externalLibraryWithImportPaths2);
-
-      const mockClose = jest.fn();
+      const mockClose = vitest.fn();
       storageMock.watch.mockImplementation(makeMockWatcher({ close: mockClose }));
 
       await sut.init();
@@ -1598,7 +1555,7 @@ describe(LibraryService.name, () => {
     it('should detect when import path is in immich media folder', async () => {
       storageMock.stat.mockResolvedValue({ isDirectory: () => true } as Stats);
       const validImport = libraryStub.hasImmichPaths.importPaths[1];
-      when(storageMock.checkFileExists).calledWith(validImport, R_OK).mockResolvedValue(true);
+      storageMock.checkFileExists.mockImplementation((importPath) => Promise.resolve(importPath === validImport));
 
       await expect(
         sut.validate('library-id', { importPaths: libraryStub.hasImmichPaths.importPaths }),

server/src/services/library.service.ts

@@ -1,7 +1,6 @@
 import { BadRequestException, Inject, Injectable } from '@nestjs/common';
 import { Trie } from 'mnemonist';
 import { R_OK } from 'node:constants';
-import { EventEmitter } from 'node:events';
 import { Stats } from 'node:fs';
 import path, { basename, parse } from 'node:path';
 import picomatch from 'picomatch';
@@ -37,9 +36,9 @@ import {
   JobStatus,
 } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
-import { IStorageRepository, StorageEventType } from 'src/interfaces/storage.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
+import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 import { mimeTypes } from 'src/utils/mime-types';
 import { handlePromiseError } from 'src/utils/misc';
 import { usePagination } from 'src/utils/pagination';
@@ -48,8 +47,7 @@ import { validateCronExpression } from 'src/validation';
 const LIBRARY_SCAN_BATCH_SIZE = 5000;
 
 @Injectable()
-export class LibraryService extends EventEmitter {
-  readonly logger = new ImmichLogger(LibraryService.name);
+export class LibraryService {
   private configCore: SystemConfigCore;
   private watchLibraries = false;
   private watchLock = false;
@@ -63,9 +61,10 @@ export class LibraryService extends EventEmitter {
     @Inject(ILibraryRepository) private repository: ILibraryRepository,
     @Inject(IStorageRepository) private storageRepository: IStorageRepository,
     @Inject(IDatabaseRepository) private databaseRepository: IDatabaseRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    super();
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(LibraryService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
   }
 
   async init() {
@@ -152,7 +151,6 @@ export class LibraryService extends EventEmitter {
             if (matcher(path)) {
               await this.scanAssets(library.id, [path], library.ownerId, false);
             }
-            this.emit(StorageEventType.ADD, path);
           };
           return handlePromiseError(handler(), this.logger);
         },
@@ -163,7 +161,6 @@ export class LibraryService extends EventEmitter {
               // Note: if the changed file was not previously imported, it will be imported now.
               await this.scanAssets(library.id, [path], library.ownerId, false);
             }
-            this.emit(StorageEventType.CHANGE, path);
           };
           return handlePromiseError(handler(), this.logger);
         },
@@ -174,13 +171,11 @@ export class LibraryService extends EventEmitter {
             if (asset && matcher(path)) {
               await this.assetRepository.update({ id: asset.id, isOffline: true });
             }
-            this.emit(StorageEventType.UNLINK, path);
           };
           return handlePromiseError(handler(), this.logger);
         },
         onError: (error) => {
           this.logger.error(`Library watcher for library ${library.id} encountered error: ${error}`);
-          this.emit(StorageEventType.ERROR, error);
         },
       },
     );
@@ -281,10 +276,6 @@ export class LibraryService extends EventEmitter {
 
     this.logger.log(`Creating ${dto.type} library for ${dto.ownerId}}`);
 
-    if (dto.type === LibraryType.EXTERNAL) {
-      await this.watch(library.id);
-    }
-
     return mapLibrary(library);
   }
 
@@ -368,11 +359,6 @@ export class LibraryService extends EventEmitter {
       }
     }
 
-    if (dto.importPaths || dto.exclusionPatterns) {
-      // Re-watch library to use new paths and/or exclusion patterns
-      await this.watch(id);
-    }
-
     return mapLibrary(library);
   }
 
@@ -616,7 +602,7 @@ export class LibraryService extends EventEmitter {
     const assetIdsToMarkOffline = [];
     const assetIdsToMarkOnline = [];
     const pagination = usePagination(LIBRARY_SCAN_BATCH_SIZE, (pagination) =>
-      this.assetRepository.getLibraryAssetPaths(pagination, library.id),
+      this.assetRepository.getExternalLibraryAssetPaths(pagination, library.id),
     );
 
     this.logger.verbose(`Crawled asset paths paginated`);

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

@@ -14,6 +14,7 @@ import {
 import { IAssetRepository, WithoutProperty } from 'src/interfaces/asset.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IJobRepository, JobName, JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMediaRepository } from 'src/interfaces/media.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
@@ -27,22 +28,25 @@ import { personStub } from 'test/fixtures/person.stub';
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock';
 import { newMoveRepositoryMock } from 'test/repositories/move.repository.mock';
 import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { Mocked } from 'vitest';
 
 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>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();
@@ -53,8 +57,19 @@ describe(MediaService.name, () => {
     personMock = newPersonRepositoryMock();
     storageMock = newStorageRepositoryMock();
     cryptoMock = newCryptoRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
-    sut = new MediaService(assetMock, personMock, jobMock, mediaMock, storageMock, configMock, moveMock, cryptoMock);
+    sut = new MediaService(
+      assetMock,
+      personMock,
+      jobMock,
+      mediaMock,
+      storageMock,
+      configMock,
+      moveMock,
+      cryptoMock,
+      loggerMock,
+    );
   });
 
   it('should be defined', () => {

server/src/services/media.service.ts

@@ -25,12 +25,12 @@ import {
   JobStatus,
   QueueName,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { AudioStreamInfo, IMediaRepository, VideoCodecHWConfig, VideoStreamInfo } from 'src/interfaces/media.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 import {
   AV1Config,
   H264Config,
@@ -46,7 +46,6 @@ import { usePagination } from 'src/utils/pagination';
 
 @Injectable()
 export class MediaService {
-  private logger = new ImmichLogger(MediaService.name);
   private configCore: SystemConfigCore;
   private storageCore: StorageCore;
   private hasOpenCL?: boolean = undefined;
@@ -60,15 +59,18 @@ export class MediaService {
     @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
     @Inject(IMoveRepository) moveRepository: IMoveRepository,
     @Inject(ICryptoRepository) cryptoRepository: ICryptoRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(MediaService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
     this.storageCore = StorageCore.create(
       assetRepository,
+      cryptoRepository,
       moveRepository,
       personRepository,
-      cryptoRepository,
-      configRepository,
       storageRepository,
+      configRepository,
+      this.logger,
     );
   }
 

server/src/services/memory.service.spec.ts

@@ -7,10 +7,11 @@ import { memoryStub } from 'test/fixtures/memory.stub';
 import { userStub } from 'test/fixtures/user.stub';
 import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
 import { newMemoryRepositoryMock } from 'test/repositories/memory.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(MemoryService.name, () => {
   let accessMock: IAccessRepositoryMock;
-  let memoryMock: jest.Mocked<IMemoryRepository>;
+  let memoryMock: Mocked<IMemoryRepository>;
   let sut: MemoryService;
 
   beforeEach(() => {

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

@@ -1,5 +1,4 @@
 import { BinaryField } from 'exiftool-vendored';
-import { when } from 'jest-when';
 import { randomBytes } from 'node:crypto';
 import { Stats } from 'node:fs';
 import { constants } from 'node:fs/promises';
@@ -12,12 +11,14 @@ import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { ClientEvent, IEventRepository } from 'src/interfaces/event.interface';
 import { IJobRepository, JobName, JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMediaRepository } from 'src/interfaces/media.interface';
 import { IMetadataRepository, ImmichTags } from 'src/interfaces/metadata.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
+import { IUserRepository } from 'src/interfaces/user.interface';
 import { MetadataService, Orientation } from 'src/services/metadata.service';
 import { assetStub } from 'test/fixtures/asset.stub';
 import { fileStub } from 'test/fixtures/file.stub';
@@ -28,26 +29,31 @@ import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.moc
 import { newDatabaseRepositoryMock } from 'test/repositories/database.repository.mock';
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock';
 import { newMetadataRepositoryMock } from 'test/repositories/metadata.repository.mock';
 import { newMoveRepositoryMock } from 'test/repositories/move.repository.mock';
 import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked } from 'vitest';
 
 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 eventMock: jest.Mocked<IEventRepository>;
-  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 eventMock: Mocked<IEventRepository>;
+  let databaseMock: Mocked<IDatabaseRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
   let sut: MetadataService;
 
   beforeEach(() => {
@@ -63,6 +69,8 @@ describe(MetadataService.name, () => {
     storageMock = newStorageRepositoryMock();
     mediaMock = newMediaRepositoryMock();
     databaseMock = newDatabaseRepositoryMock();
+    userMock = newUserRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
     sut = new MetadataService(
       albumMock,
@@ -77,6 +85,8 @@ describe(MetadataService.name, () => {
       personMock,
       storageMock,
       configMock,
+      userMock,
+      loggerMock,
     );
   });
 
@@ -248,14 +258,13 @@ describe(MetadataService.name, () => {
       const originalDate = new Date('2023-11-21T16:13:17.517Z');
       const sidecarDate = new Date('2022-01-01T00:00:00.000Z');
       assetMock.getByIds.mockResolvedValue([assetStub.sidecar]);
-      when(metadataMock.readTags)
-        .calledWith(assetStub.sidecar.originalPath)
-        // higher priority tag
-        .mockResolvedValue({ CreationDate: originalDate.toISOString() });
-      when(metadataMock.readTags)
-        .calledWith(assetStub.sidecar.sidecarPath as string)
-        // lower priority tag, but in sidecar
-        .mockResolvedValue({ CreateDate: sidecarDate.toISOString() });
+      metadataMock.readTags.mockImplementation((path) => {
+        const map = {
+          [assetStub.sidecar.originalPath]: originalDate.toISOString(),
+          [assetStub.sidecar.sidecarPath as string]: sidecarDate.toISOString(),
+        };
+        return Promise.resolve({ CreationDate: map[path] ?? new Date().toISOString() });
+      });
 
       await sut.handleMetadataExtraction({ id: assetStub.image.id });
       expect(assetMock.getByIds).toHaveBeenCalledWith([assetStub.sidecar.id]);
@@ -368,6 +377,7 @@ describe(MetadataService.name, () => {
       );
       expect(assetMock.getByIds).toHaveBeenCalledWith([assetStub.livePhotoStillAsset.id]);
       expect(assetMock.create).toHaveBeenCalled(); // This could have arguments added
+      expect(userMock.updateUsage).toHaveBeenCalledWith(assetStub.livePhotoMotionAsset.ownerId, 512);
       expect(storageMock.writeFile).toHaveBeenCalledWith(assetStub.livePhotoMotionAsset.originalPath, video);
       expect(assetMock.update).toHaveBeenNthCalledWith(1, {
         id: assetStub.livePhotoStillAsset.id,
@@ -396,6 +406,7 @@ describe(MetadataService.name, () => {
       );
       expect(assetMock.getByIds).toHaveBeenCalledWith([assetStub.livePhotoStillAsset.id]);
       expect(assetMock.create).toHaveBeenCalled(); // This could have arguments added
+      expect(userMock.updateUsage).toHaveBeenCalledWith(assetStub.livePhotoMotionAsset.ownerId, 512);
       expect(storageMock.writeFile).toHaveBeenCalledWith(assetStub.livePhotoMotionAsset.originalPath, video);
       expect(assetMock.update).toHaveBeenNthCalledWith(1, {
         id: assetStub.livePhotoStillAsset.id,
@@ -422,6 +433,7 @@ describe(MetadataService.name, () => {
       expect(assetMock.getByIds).toHaveBeenCalledWith([assetStub.livePhotoStillAsset.id]);
       expect(storageMock.readFile).toHaveBeenCalledWith(assetStub.livePhotoStillAsset.originalPath, expect.any(Object));
       expect(assetMock.create).toHaveBeenCalled(); // This could have arguments added
+      expect(userMock.updateUsage).toHaveBeenCalledWith(assetStub.livePhotoMotionAsset.ownerId, 512);
       expect(storageMock.writeFile).toHaveBeenCalledWith(assetStub.livePhotoMotionAsset.originalPath, video);
       expect(assetMock.update).toHaveBeenNthCalledWith(1, {
         id: assetStub.livePhotoStillAsset.id,
@@ -440,6 +452,8 @@ describe(MetadataService.name, () => {
       cryptoRepository.hashSha1.mockReturnValue(randomBytes(512));
       assetMock.getByChecksum.mockResolvedValue(null);
       assetMock.create.mockImplementation((asset) => Promise.resolve({ ...assetStub.livePhotoMotionAsset, ...asset }));
+      const video = randomBytes(512);
+      storageMock.readFile.mockResolvedValue(video);
 
       await sut.handleMetadataExtraction({ id: assetStub.livePhotoStillAsset.id });
       expect(jobMock.queue).toHaveBeenNthCalledWith(2, {
@@ -448,7 +462,7 @@ describe(MetadataService.name, () => {
       });
     });
 
-    it('should not create a new motionphoto video asset if the of the extracted video matches an existing asset', async () => {
+    it('should not create a new motion photo video asset if the hash of the extracted video matches an existing asset', async () => {
       assetMock.getByIds.mockResolvedValue([assetStub.livePhotoStillAsset]);
       metadataMock.readTags.mockResolvedValue({
         Directory: 'foo/bar/',
@@ -458,6 +472,8 @@ describe(MetadataService.name, () => {
       });
       cryptoRepository.hashSha1.mockReturnValue(randomBytes(512));
       assetMock.getByChecksum.mockResolvedValue(assetStub.livePhotoMotionAsset);
+      const video = randomBytes(512);
+      storageMock.readFile.mockResolvedValue(video);
 
       await sut.handleMetadataExtraction({ id: assetStub.livePhotoStillAsset.id });
       expect(assetMock.create).toHaveBeenCalledTimes(0);
@@ -491,6 +507,26 @@ describe(MetadataService.name, () => {
       });
     });
 
+    it('should not update storage usage if motion photo is external', async () => {
+      assetMock.getByIds.mockResolvedValue([
+        { ...assetStub.livePhotoStillAsset, livePhotoVideoId: null, isExternal: true },
+      ]);
+      metadataMock.readTags.mockResolvedValue({
+        Directory: 'foo/bar/',
+        MotionPhoto: 1,
+        MicroVideo: 1,
+        MicroVideoOffset: 1,
+      });
+      cryptoRepository.hashSha1.mockReturnValue(randomBytes(512));
+      assetMock.getByChecksum.mockResolvedValue(null);
+      assetMock.create.mockResolvedValue(assetStub.livePhotoMotionAsset);
+      const video = randomBytes(512);
+      storageMock.readFile.mockResolvedValue(video);
+
+      await sut.handleMetadataExtraction({ id: assetStub.livePhotoStillAsset.id });
+      expect(userMock.updateUsage).not.toHaveBeenCalled();
+    });
+
     it('should save all metadata', async () => {
       const tags: ImmichTags = {
         BitsPerSample: 1,

server/src/services/metadata.service.ts

@@ -25,13 +25,14 @@ import {
   JobStatus,
   QueueName,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMediaRepository } from 'src/interfaces/media.interface';
 import { IMetadataRepository, ImmichTags } from 'src/interfaces/metadata.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
+import { IUserRepository } from 'src/interfaces/user.interface';
 import { handlePromiseError } from 'src/utils/misc';
 import { usePagination } from 'src/utils/pagination';
 
@@ -97,7 +98,6 @@ const validate = <T>(value: T): NonNullable<T> | null => {
 
 @Injectable()
 export class MetadataService {
-  private logger = new ImmichLogger(MetadataService.name);
   private storageCore: StorageCore;
   private configCore: SystemConfigCore;
   private subscription: Subscription | null = null;
@@ -115,15 +115,19 @@ export class MetadataService {
     @Inject(IPersonRepository) personRepository: IPersonRepository,
     @Inject(IStorageRepository) private storageRepository: IStorageRepository,
     @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
+    @Inject(IUserRepository) private userRepository: IUserRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(MetadataService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
     this.storageCore = StorageCore.create(
       assetRepository,
+      cryptoRepository,
       moveRepository,
       personRepository,
-      cryptoRepository,
-      configRepository,
       storageRepository,
+      configRepository,
+      this.logger,
     );
   }
 
@@ -444,10 +448,14 @@ export class MetadataService {
         this.storageCore.ensureFolders(motionPath);
         await this.storageRepository.writeFile(motionAsset.originalPath, video);
         await this.jobRepository.queue({ name: JobName.METADATA_EXTRACTION, data: { id: motionAsset.id } });
+        if (!asset.isExternal) {
+          await this.userRepository.updateUsage(asset.ownerId, video.byteLength);
+        }
       }
 
       if (asset.livePhotoVideoId !== motionAsset.id) {
         await this.assetRepository.update({ id: asset.id, livePhotoVideoId: motionAsset.id });
+
         // If the asset already had an associated livePhotoVideo, delete it, because
         // its checksum doesn't match the checksum of the motionAsset we just extracted
         // (if it did, getByChecksum() would've returned a motionAsset with the same ID as livePhotoVideoId)

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

@@ -7,6 +7,7 @@ import { PartnerService } from 'src/services/partner.service';
 import { authStub } from 'test/fixtures/auth.stub';
 import { partnerStub } from 'test/fixtures/partner.stub';
 import { newPartnerRepositoryMock } from 'test/repositories/partner.repository.mock';
+import { Mocked } from 'vitest';
 
 const responseDto = {
   admin: <PartnerResponseDto>{
@@ -49,8 +50,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/services/person.service.spec.ts

@@ -6,6 +6,7 @@ import { Colorspace, SystemConfigKey } from 'src/entities/system-config.entity';
 import { IAssetRepository, WithoutProperty } from 'src/interfaces/asset.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IJobRepository, JobName, JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { IMediaRepository } from 'src/interfaces/media.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
@@ -23,6 +24,7 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMachineLearningRepositoryMock } from 'test/repositories/machine-learning.repository.mock';
 import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock';
 import { newMoveRepositoryMock } from 'test/repositories/move.repository.mock';
@@ -31,6 +33,7 @@ import { newSearchRepositoryMock } from 'test/repositories/search.repository.moc
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
 import { IsNull } from 'typeorm';
+import { Mocked } from 'vitest';
 
 const responseDto: PersonResponseDto = {
   id: 'person-1',
@@ -61,16 +64,17 @@ 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 loggerMock: Mocked<ILoggerRepository>;
   let sut: PersonService;
 
   beforeEach(() => {
@@ -85,6 +89,7 @@ describe(PersonService.name, () => {
     storageMock = newStorageRepositoryMock();
     searchMock = newSearchRepositoryMock();
     cryptoMock = newCryptoRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
     sut = new PersonService(
       accessMock,
       assetMock,
@@ -97,6 +102,7 @@ describe(PersonService.name, () => {
       jobMock,
       searchMock,
       cryptoMock,
+      loggerMock,
     );
 
     mediaMock.crop.mockResolvedValue(croppedFace);

server/src/services/person.service.ts

@@ -38,6 +38,7 @@ import {
   JobStatus,
   QueueName,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { CropOptions, IMediaRepository } from 'src/interfaces/media.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
@@ -46,7 +47,6 @@ import { ISearchRepository } from 'src/interfaces/search.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { CacheControl, ImmichFileResponse } from 'src/utils/file';
-import { ImmichLogger } from 'src/utils/logger';
 import { mimeTypes } from 'src/utils/mime-types';
 import { usePagination } from 'src/utils/pagination';
 import { IsNull } from 'typeorm';
@@ -56,7 +56,6 @@ export class PersonService {
   private access: AccessCore;
   private configCore: SystemConfigCore;
   private storageCore: StorageCore;
-  readonly logger = new ImmichLogger(PersonService.name);
 
   constructor(
     @Inject(IAccessRepository) accessRepository: IAccessRepository,
@@ -70,16 +69,19 @@ export class PersonService {
     @Inject(IJobRepository) private jobRepository: IJobRepository,
     @Inject(ISearchRepository) private smartInfoRepository: ISearchRepository,
     @Inject(ICryptoRepository) cryptoRepository: ICryptoRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
     this.access = AccessCore.create(accessRepository);
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(PersonService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
     this.storageCore = StorageCore.create(
       assetRepository,
+      cryptoRepository,
       moveRepository,
       repository,
-      cryptoRepository,
-      configRepository,
       storageRepository,
+      configRepository,
+      this.logger,
     );
   }
 

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

@@ -2,6 +2,7 @@ import { mapAsset } from 'src/dtos/asset-response.dto';
 import { SearchDto } from 'src/dtos/search.dto';
 import { SystemConfigKey } from 'src/entities/system-config.entity';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { IMetadataRepository } from 'src/interfaces/metadata.interface';
 import { IPartnerRepository } from 'src/interfaces/partner.interface';
@@ -13,24 +14,27 @@ import { assetStub } from 'test/fixtures/asset.stub';
 import { authStub } from 'test/fixtures/auth.stub';
 import { personStub } from 'test/fixtures/person.stub';
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMachineLearningRepositoryMock } from 'test/repositories/machine-learning.repository.mock';
 import { newMetadataRepositoryMock } from 'test/repositories/metadata.repository.mock';
 import { newPartnerRepositoryMock } from 'test/repositories/partner.repository.mock';
 import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newSearchRepositoryMock } from 'test/repositories/search.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { Mocked, vitest } from 'vitest';
 
-jest.useFakeTimers();
+vitest.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>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();
@@ -40,8 +44,18 @@ describe(SearchService.name, () => {
     searchMock = newSearchRepositoryMock();
     partnerMock = newPartnerRepositoryMock();
     metadataMock = newMetadataRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
-    sut = new SearchService(configMock, machineMock, personMock, searchMock, assetMock, partnerMock, metadataMock);
+    sut = new SearchService(
+      configMock,
+      machineMock,
+      personMock,
+      searchMock,
+      assetMock,
+      partnerMock,
+      metadataMock,
+      loggerMock,
+    );
   });
 
   it('should work', () => {

server/src/services/search.service.ts

@@ -18,6 +18,7 @@ import {
 import { AssetOrder } from 'src/entities/album.entity';
 import { AssetEntity } from 'src/entities/asset.entity';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { IMetadataRepository } from 'src/interfaces/metadata.interface';
 import { IPartnerRepository } from 'src/interfaces/partner.interface';
@@ -37,8 +38,10 @@ export class SearchService {
     @Inject(IAssetRepository) private assetRepository: IAssetRepository,
     @Inject(IPartnerRepository) private partnerRepository: IPartnerRepository,
     @Inject(IMetadataRepository) private metadataRepository: IMetadataRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(SearchService.name);
+    this.configCore = SystemConfigCore.create(configRepository, logger);
   }
 
   async searchPerson(auth: AuthDto, dto: SearchPeopleDto): Promise<PersonResponseDto[]> {

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

@@ -1,6 +1,7 @@
 import { serverVersion } from 'src/constants';
 import { SystemMetadataKey } from 'src/entities/system-metadata.entity';
 import { IEventRepository } from 'src/interfaces/event.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IServerInfoRepository } from 'src/interfaces/server-info.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
@@ -8,20 +9,23 @@ import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interf
 import { IUserRepository } from 'src/interfaces/user.interface';
 import { ServerInfoService } from 'src/services/server-info.service';
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
 import { newServerInfoRepositoryMock } from 'test/repositories/system-info.repository.mock';
 import { newSystemMetadataRepositoryMock } from 'test/repositories/system-metadata.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(ServerInfoService.name, () => {
   let sut: ServerInfoService;
-  let eventMock: jest.Mocked<IEventRepository>;
-  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 eventMock: Mocked<IEventRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let serverInfoMock: Mocked<IServerInfoRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let systemMetadataMock: Mocked<ISystemMetadataRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     configMock = newSystemConfigRepositoryMock();
@@ -30,8 +34,17 @@ describe(ServerInfoService.name, () => {
     storageMock = newStorageRepositoryMock();
     userMock = newUserRepositoryMock();
     systemMetadataMock = newSystemMetadataRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
-    sut = new ServerInfoService(eventMock, configMock, userMock, serverInfoMock, storageMock, systemMetadataMock);
+    sut = new ServerInfoService(
+      eventMock,
+      configMock,
+      userMock,
+      serverInfoMock,
+      storageMock,
+      systemMetadataMock,
+      loggerMock,
+    );
   });
 
   it('should work', () => {

server/src/services/server-info.service.ts

@@ -15,19 +15,18 @@ import {
 } from 'src/dtos/server-info.dto';
 import { SystemMetadataKey } from 'src/entities/system-metadata.entity';
 import { ClientEvent, IEventRepository, ServerEvent, ServerEventMap } from 'src/interfaces/event.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IServerInfoRepository } from 'src/interfaces/server-info.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
 import { IUserRepository, UserStatsQueryResponse } from 'src/interfaces/user.interface';
 import { asHumanReadable } from 'src/utils/bytes';
-import { ImmichLogger } from 'src/utils/logger';
 import { mimeTypes } from 'src/utils/mime-types';
 import { Version } from 'src/utils/version';
 
 @Injectable()
 export class ServerInfoService {
-  private logger = new ImmichLogger(ServerInfoService.name);
   private configCore: SystemConfigCore;
   private releaseVersion = serverVersion;
   private releaseVersionCheckedAt: DateTime | null = null;
@@ -38,9 +37,11 @@ export class ServerInfoService {
     @Inject(IUserRepository) private userRepository: IUserRepository,
     @Inject(IServerInfoRepository) private repository: IServerInfoRepository,
     @Inject(IStorageRepository) private storageRepository: IStorageRepository,
-    @Inject(ISystemMetadataRepository) private readonly systemMetadataRepository: ISystemMetadataRepository,
+    @Inject(ISystemMetadataRepository) private systemMetadataRepository: ISystemMetadataRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(ServerInfoService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
   }
 
   onConnect() {}

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

@@ -12,12 +12,13 @@ import { sharedLinkResponseStub, sharedLinkStub } from 'test/fixtures/shared-lin
 import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
 import { newSharedLinkRepositoryMock } from 'test/repositories/shared-link.repository.mock';
+import { Mocked } from 'vitest';
 
 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/services/smart-info.service.spec.ts

@@ -3,6 +3,7 @@ import { SystemConfigKey } from 'src/entities/system-config.entity';
 import { IAssetRepository, WithoutProperty } from 'src/interfaces/asset.interface';
 import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { IJobRepository, JobName } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { ISearchRepository } from 'src/interfaces/search.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
@@ -12,9 +13,11 @@ import { assetStub } from 'test/fixtures/asset.stub';
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newDatabaseRepositoryMock } from 'test/repositories/database.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMachineLearningRepositoryMock } from 'test/repositories/machine-learning.repository.mock';
 import { newSearchRepositoryMock } from 'test/repositories/search.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { Mocked } from 'vitest';
 
 const asset = {
   id: 'asset-1',
@@ -23,12 +26,13 @@ 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>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     assetMock = newAssetRepositoryMock();
@@ -37,7 +41,8 @@ describe(SmartInfoService.name, () => {
     jobMock = newJobRepositoryMock();
     machineMock = newMachineLearningRepositoryMock();
     databaseMock = newDatabaseRepositoryMock();
-    sut = new SmartInfoService(assetMock, databaseMock, jobMock, machineMock, searchMock, configMock);
+    loggerMock = newLoggerRepositoryMock();
+    sut = new SmartInfoService(assetMock, databaseMock, jobMock, machineMock, searchMock, configMock, loggerMock);
 
     assetMock.getByIds.mockResolvedValue([asset]);
   });

server/src/services/smart-info.service.ts

@@ -11,16 +11,15 @@ import {
   JobStatus,
   QueueName,
 } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMachineLearningRepository } from 'src/interfaces/machine-learning.interface';
 import { ISearchRepository } from 'src/interfaces/search.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 import { usePagination } from 'src/utils/pagination';
 
 @Injectable()
 export class SmartInfoService {
   private configCore: SystemConfigCore;
-  private logger = new ImmichLogger(SmartInfoService.name);
 
   constructor(
     @Inject(IAssetRepository) private assetRepository: IAssetRepository,
@@ -29,8 +28,10 @@ export class SmartInfoService {
     @Inject(IMachineLearningRepository) private machineLearning: IMachineLearningRepository,
     @Inject(ISearchRepository) private repository: ISearchRepository,
     @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(SmartInfoService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
   }
 
   async init() {

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

@@ -1,6 +1,6 @@
-import { when } from 'jest-when';
 import { Stats } from 'node:fs';
 import { SystemConfigCore, defaults } from 'src/cores/system-config.core';
+import { AssetEntity } from 'src/entities/asset.entity';
 import { AssetPathType } from 'src/entities/move.entity';
 import { SystemConfig, SystemConfigKey } from 'src/entities/system-config.entity';
 import { IAlbumRepository } from 'src/interfaces/album.interface';
@@ -8,6 +8,7 @@ import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
@@ -20,23 +21,26 @@ import { newAlbumRepositoryMock } from 'test/repositories/album.repository.mock'
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
 import { newDatabaseRepositoryMock } from 'test/repositories/database.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newMoveRepositoryMock } from 'test/repositories/move.repository.mock';
 import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked } from 'vitest';
 
 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>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();
@@ -52,6 +56,7 @@ describe(StorageTemplateService.name, () => {
     userMock = newUserRepositoryMock();
     cryptoMock = newCryptoRepositoryMock();
     databaseMock = newDatabaseRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
     configMock.load.mockResolvedValue([{ key: SystemConfigKey.STORAGE_TEMPLATE_ENABLED, value: true }]);
 
@@ -65,9 +70,10 @@ describe(StorageTemplateService.name, () => {
       userMock,
       cryptoMock,
       databaseMock,
+      loggerMock,
     );
 
-    SystemConfigCore.create(configMock).config$.next(defaults);
+    SystemConfigCore.create(configMock, loggerMock).config$.next(defaults);
   });
 
   describe('onValidateConfig', () => {
@@ -118,43 +124,28 @@ describe(StorageTemplateService.name, () => {
       const newMotionPicturePath = `upload/library/${userStub.user1.id}/2022/2022-06-19/${assetStub.livePhotoStillAsset.id}.mp4`;
       const newStillPicturePath = `upload/library/${userStub.user1.id}/2022/2022-06-19/${assetStub.livePhotoStillAsset.id}.jpeg`;
 
-      when(assetMock.getByIds)
-        .calledWith([assetStub.livePhotoStillAsset.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.livePhotoStillAsset]);
+      assetMock.getByIds.mockImplementation((ids) => {
+        const assets = [assetStub.livePhotoStillAsset, assetStub.livePhotoMotionAsset];
+        return Promise.resolve(
+          ids.map((id) => assets.find((asset) => asset.id === id)).filter((asset) => !!asset),
+        ) as Promise<AssetEntity[]>;
+      });
 
-      when(assetMock.getByIds)
-        .calledWith([assetStub.livePhotoMotionAsset.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.livePhotoMotionAsset]);
+      moveMock.create.mockResolvedValueOnce({
+        id: '123',
+        entityId: assetStub.livePhotoStillAsset.id,
+        pathType: AssetPathType.ORIGINAL,
+        oldPath: assetStub.livePhotoStillAsset.originalPath,
+        newPath: newStillPicturePath,
+      });
 
-      when(moveMock.create)
-        .calledWith({
-          entityId: assetStub.livePhotoStillAsset.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.livePhotoStillAsset.originalPath,
-          newPath: newStillPicturePath,
-        })
-        .mockResolvedValue({
-          id: '123',
-          entityId: assetStub.livePhotoStillAsset.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.livePhotoStillAsset.originalPath,
-          newPath: newStillPicturePath,
-        });
-
-      when(moveMock.create)
-        .calledWith({
-          entityId: assetStub.livePhotoMotionAsset.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.livePhotoMotionAsset.originalPath,
-          newPath: newMotionPicturePath,
-        })
-        .mockResolvedValue({
-          id: '124',
-          entityId: assetStub.livePhotoMotionAsset.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.livePhotoMotionAsset.originalPath,
-          newPath: newMotionPicturePath,
-        });
+      moveMock.create.mockResolvedValueOnce({
+        id: '124',
+        entityId: assetStub.livePhotoMotionAsset.id,
+        pathType: AssetPathType.ORIGINAL,
+        oldPath: assetStub.livePhotoMotionAsset.originalPath,
+        newPath: newMotionPicturePath,
+      });
 
       await expect(sut.handleMigrationSingle({ id: assetStub.livePhotoStillAsset.id })).resolves.toBe(
         JobStatus.SUCCESS,
@@ -177,34 +168,22 @@ describe(StorageTemplateService.name, () => {
       const previousFailedNewPath = `upload/library/${userStub.user1.id}/2023/Feb/${assetStub.image.id}.jpg`;
       const newPath = `upload/library/${userStub.user1.id}/2023/2023-02-23/${assetStub.image.id}.jpg`;
 
-      when(storageMock.checkFileExists).calledWith(assetStub.image.originalPath).mockResolvedValue(true);
-      when(storageMock.checkFileExists).calledWith(previousFailedNewPath).mockResolvedValue(false);
-
-      when(moveMock.getByEntity).calledWith(assetStub.image.id, AssetPathType.ORIGINAL).mockResolvedValue({
+      storageMock.checkFileExists.mockImplementation((path) => Promise.resolve(path === assetStub.image.originalPath));
+      moveMock.getByEntity.mockResolvedValue({
         id: '123',
         entityId: assetStub.image.id,
         pathType: AssetPathType.ORIGINAL,
         oldPath: assetStub.image.originalPath,
         newPath: previousFailedNewPath,
       });
-
-      when(assetMock.getByIds)
-        .calledWith([assetStub.image.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.image]);
-
-      when(moveMock.update)
-        .calledWith({
-          id: '123',
-          oldPath: assetStub.image.originalPath,
-          newPath,
-        })
-        .mockResolvedValue({
-          id: '123',
-          entityId: assetStub.image.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.image.originalPath,
-          newPath,
-        });
+      assetMock.getByIds.mockResolvedValue([assetStub.image]);
+      moveMock.update.mockResolvedValue({
+        id: '123',
+        entityId: assetStub.image.id,
+        pathType: AssetPathType.ORIGINAL,
+        oldPath: assetStub.image.originalPath,
+        newPath,
+      });
 
       await expect(sut.handleMigrationSingle({ id: assetStub.image.id })).resolves.toBe(JobStatus.SUCCESS);
 
@@ -226,38 +205,24 @@ describe(StorageTemplateService.name, () => {
       const previousFailedNewPath = `upload/library/${userStub.user1.id}/2023/Feb/${assetStub.image.id}.jpg`;
       const newPath = `upload/library/${userStub.user1.id}/2023/2023-02-23/${assetStub.image.id}.jpg`;
 
-      when(storageMock.checkFileExists).calledWith(assetStub.image.originalPath).mockResolvedValue(false);
-      when(storageMock.checkFileExists).calledWith(previousFailedNewPath).mockResolvedValue(true);
-      when(storageMock.stat)
-        .calledWith(previousFailedNewPath)
-        .mockResolvedValue({ size: 5000 } as Stats);
-      when(cryptoMock.hashFile).calledWith(previousFailedNewPath).mockResolvedValue(assetStub.image.checksum);
-
-      when(moveMock.getByEntity).calledWith(assetStub.image.id, AssetPathType.ORIGINAL).mockResolvedValue({
+      storageMock.checkFileExists.mockImplementation((path) => Promise.resolve(path === previousFailedNewPath));
+      storageMock.stat.mockResolvedValue({ size: 5000 } as Stats);
+      cryptoMock.hashFile.mockResolvedValue(assetStub.image.checksum);
+      moveMock.getByEntity.mockResolvedValue({
         id: '123',
         entityId: assetStub.image.id,
         pathType: AssetPathType.ORIGINAL,
         oldPath: assetStub.image.originalPath,
         newPath: previousFailedNewPath,
       });
-
-      when(assetMock.getByIds)
-        .calledWith([assetStub.image.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.image]);
-
-      when(moveMock.update)
-        .calledWith({
-          id: '123',
-          oldPath: previousFailedNewPath,
-          newPath,
-        })
-        .mockResolvedValue({
-          id: '123',
-          entityId: assetStub.image.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: previousFailedNewPath,
-          newPath,
-        });
+      assetMock.getByIds.mockResolvedValue([assetStub.image]);
+      moveMock.update.mockResolvedValue({
+        id: '123',
+        entityId: assetStub.image.id,
+        pathType: AssetPathType.ORIGINAL,
+        oldPath: previousFailedNewPath,
+        newPath,
+      });
 
       await expect(sut.handleMigrationSingle({ id: assetStub.image.id })).resolves.toBe(JobStatus.SUCCESS);
 
@@ -281,30 +246,17 @@ describe(StorageTemplateService.name, () => {
       userMock.get.mockResolvedValue(userStub.user1);
       const newPath = `upload/library/${userStub.user1.id}/2023/2023-02-23/${assetStub.image.id}.jpg`;
 
-      when(storageMock.rename).calledWith(assetStub.image.originalPath, newPath).mockRejectedValue({ code: 'EXDEV' });
-      when(storageMock.stat)
-        .calledWith(newPath)
-        .mockResolvedValue({ size: 5000 } as Stats);
-      when(cryptoMock.hashFile).calledWith(newPath).mockResolvedValue(Buffer.from('different-hash', 'utf8'));
-
-      when(assetMock.getByIds)
-        .calledWith([assetStub.image.id], { exifInfo: true })
-        .mockResolvedValue([assetStub.image]);
-
-      when(moveMock.create)
-        .calledWith({
-          entityId: assetStub.image.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.image.originalPath,
-          newPath: newPath,
-        })
-        .mockResolvedValue({
-          id: '123',
-          entityId: assetStub.image.id,
-          pathType: AssetPathType.ORIGINAL,
-          oldPath: assetStub.image.originalPath,
-          newPath,
-        });
+      storageMock.rename.mockRejectedValue({ code: 'EXDEV' });
+      storageMock.stat.mockResolvedValue({ size: 5000 } as Stats);
+      cryptoMock.hashFile.mockResolvedValue(Buffer.from('different-hash', 'utf8'));
+      assetMock.getByIds.mockResolvedValue([assetStub.image]);
+      moveMock.create.mockResolvedValue({
+        id: '123',
+        entityId: assetStub.image.id,
+        pathType: AssetPathType.ORIGINAL,
+        oldPath: assetStub.image.originalPath,
+        newPath,
+      });
 
       await expect(sut.handleMigrationSingle({ id: assetStub.image.id })).resolves.toBe(JobStatus.SUCCESS);
 
@@ -335,38 +287,24 @@ describe(StorageTemplateService.name, () => {
         const previousFailedNewPath = `upload/library/${userStub.user1.id}/2023/Feb/${assetStub.image.id}.jpg`;
         const newPath = `upload/library/${userStub.user1.id}/2023/2023-02-23/${assetStub.image.id}.jpg`;
 
-        when(storageMock.checkFileExists).calledWith(assetStub.image.originalPath).mockResolvedValue(false);
-        when(storageMock.checkFileExists).calledWith(previousFailedNewPath).mockResolvedValue(true);
-        when(storageMock.stat)
-          .calledWith(previousFailedNewPath)
-          .mockResolvedValue({ size: failedPathSize } as Stats);
-        when(cryptoMock.hashFile).calledWith(previousFailedNewPath).mockResolvedValue(failedPathChecksum);
-
-        when(moveMock.getByEntity).calledWith(assetStub.image.id, AssetPathType.ORIGINAL).mockResolvedValue({
+        storageMock.checkFileExists.mockImplementation((path) => Promise.resolve(previousFailedNewPath === path));
+        storageMock.stat.mockResolvedValue({ size: failedPathSize } as Stats);
+        cryptoMock.hashFile.mockResolvedValue(failedPathChecksum);
+        moveMock.getByEntity.mockResolvedValue({
           id: '123',
           entityId: assetStub.image.id,
           pathType: AssetPathType.ORIGINAL,
           oldPath: assetStub.image.originalPath,
           newPath: previousFailedNewPath,
         });
-
-        when(assetMock.getByIds)
-          .calledWith([assetStub.image.id], { exifInfo: true })
-          .mockResolvedValue([assetStub.image]);
-
-        when(moveMock.update)
-          .calledWith({
-            id: '123',
-            oldPath: previousFailedNewPath,
-            newPath,
-          })
-          .mockResolvedValue({
-            id: '123',
-            entityId: assetStub.image.id,
-            pathType: AssetPathType.ORIGINAL,
-            oldPath: previousFailedNewPath,
-            newPath,
-          });
+        assetMock.getByIds.mockResolvedValue([assetStub.image]);
+        moveMock.update.mockResolvedValue({
+          id: '123',
+          entityId: assetStub.image.id,
+          pathType: AssetPathType.ORIGINAL,
+          oldPath: previousFailedNewPath,
+          newPath,
+        });
 
         await expect(sut.handleMigrationSingle({ id: assetStub.image.id })).resolves.toBe(JobStatus.SUCCESS);
 
@@ -408,13 +346,8 @@ describe(StorageTemplateService.name, () => {
         newPath: 'upload/library/user-id/2023/2023-02-23/asset-id+1.jpg',
       });
 
-      when(storageMock.checkFileExists)
-        .calledWith('upload/library/user-id/2023/2023-02-23/asset-id.jpg')
-        .mockResolvedValue(true);
-
-      when(storageMock.checkFileExists)
-        .calledWith('upload/library/user-id/2023/2023-02-23/asset-id+1.jpg')
-        .mockResolvedValue(false);
+      storageMock.checkFileExists.mockResolvedValueOnce(true);
+      storageMock.checkFileExists.mockResolvedValueOnce(false);
 
       await sut.handleMigration();
 
@@ -538,18 +471,18 @@ describe(StorageTemplateService.name, () => {
         oldPath: assetStub.image.originalPath,
         newPath,
       });
-      when(storageMock.stat)
-        .calledWith(newPath)
-        .mockResolvedValue({
-          size: 5000,
-        } as Stats);
-      when(storageMock.stat)
-        .calledWith(assetStub.image.originalPath)
-        .mockResolvedValue({
-          atime: new Date(),
-          mtime: new Date(),
-        } as Stats);
-      when(cryptoMock.hashFile).calledWith(newPath).mockResolvedValue(assetStub.image.checksum);
+      storageMock.stat.mockResolvedValueOnce({
+        atime: new Date(),
+        mtime: new Date(),
+      } as Stats);
+      storageMock.stat.mockResolvedValueOnce({
+        size: 5000,
+      } as Stats);
+      storageMock.stat.mockResolvedValueOnce({
+        atime: new Date(),
+        mtime: new Date(),
+      } as Stats);
+      cryptoMock.hashFile.mockResolvedValue(assetStub.image.checksum);
 
       await sut.handleMigration();
 
@@ -581,11 +514,9 @@ describe(StorageTemplateService.name, () => {
         oldPath: assetStub.image.originalPath,
         newPath: 'upload/library/user-id/2023/2023-02-23/asset-id.jpg',
       });
-      when(storageMock.stat)
-        .calledWith('upload/library/user-id/2023/2023-02-23/asset-id.jpg')
-        .mockResolvedValue({
-          size: 100,
-        } as Stats);
+      storageMock.stat.mockResolvedValue({
+        size: 100,
+      } as Stats);
 
       await sut.handleMigration();
 

server/src/services/storage-template.service.ts

@@ -24,13 +24,13 @@ import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { DatabaseLock, IDatabaseRepository } from 'src/interfaces/database.interface';
 import { ServerAsyncEvent, ServerAsyncEventMap } from 'src/interfaces/event.interface';
 import { IEntityJob, JOBS_ASSET_PAGINATION_SIZE, JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
 import { getLivePhotoMotionFilename } from 'src/utils/file';
-import { ImmichLogger } from 'src/utils/logger';
 import { usePagination } from 'src/utils/pagination';
 
 export interface MoveAssetMetadata {
@@ -47,7 +47,6 @@ interface RenderMetadata {
 
 @Injectable()
 export class StorageTemplateService {
-  private logger = new ImmichLogger(StorageTemplateService.name);
   private configCore: SystemConfigCore;
   private storageCore: StorageCore;
   private _template: {
@@ -73,16 +72,19 @@ export class StorageTemplateService {
     @Inject(IUserRepository) private userRepository: IUserRepository,
     @Inject(ICryptoRepository) cryptoRepository: ICryptoRepository,
     @Inject(IDatabaseRepository) private databaseRepository: IDatabaseRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(StorageTemplateService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
     this.configCore.config$.subscribe((config) => this.onConfig(config));
     this.storageCore = StorageCore.create(
       assetRepository,
+      cryptoRepository,
       moveRepository,
       personRepository,
-      cryptoRepository,
-      configRepository,
       storageRepository,
+      configRepository,
+      this.logger,
     );
   }
 

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

@@ -1,14 +1,19 @@
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { StorageService } from 'src/services/storage.service';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(StorageService.name, () => {
   let sut: StorageService;
-  let storageMock: jest.Mocked<IStorageRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     storageMock = newStorageRepositoryMock();
-    sut = new StorageService(storageMock);
+    loggerMock = newLoggerRepositoryMock();
+    sut = new StorageService(storageMock, loggerMock);
   });
 
   it('should work', () => {

server/src/services/storage.service.ts

@@ -1,14 +1,17 @@
 import { Inject, Injectable } from '@nestjs/common';
 import { StorageCore, StorageFolder } from 'src/cores/storage.core';
 import { IDeleteFilesJob, JobStatus } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
-import { ImmichLogger } from 'src/utils/logger';
 
 @Injectable()
 export class StorageService {
-  private logger = new ImmichLogger(StorageService.name);
-
-  constructor(@Inject(IStorageRepository) private storageRepository: IStorageRepository) {}
+  constructor(
+    @Inject(IStorageRepository) private storageRepository: IStorageRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
+  ) {
+    this.logger.setContext(StorageService.name);
+  }
 
   init() {
     const libraryBase = StorageCore.getBaseFolder(StorageFolder.LIBRARY);

server/src/services/sync.service.spec.ts

@@ -0,0 +1,102 @@
+import { mapAsset } from 'src/dtos/asset-response.dto';
+import { AssetEntity } from 'src/entities/asset.entity';
+import { IAccessRepository } from 'src/interfaces/access.interface';
+import { IAssetRepository } from 'src/interfaces/asset.interface';
+import { IAuditRepository } from 'src/interfaces/audit.interface';
+import { IPartnerRepository } from 'src/interfaces/partner.interface';
+import { SyncService } from 'src/services/sync.service';
+import { assetStub } from 'test/fixtures/asset.stub';
+import { authStub } from 'test/fixtures/auth.stub';
+import { partnerStub } from 'test/fixtures/partner.stub';
+import { newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
+import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
+import { newAuditRepositoryMock } from 'test/repositories/audit.repository.mock';
+import { newPartnerRepositoryMock } from 'test/repositories/partner.repository.mock';
+import { Mocked } from 'vitest';
+
+const untilDate = new Date(2024);
+const mapAssetOpts = { auth: authStub.user1, stripMetadata: false, withStack: true };
+
+describe(SyncService.name, () => {
+  let sut: SyncService;
+  let accessMock: Mocked<IAccessRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let partnerMock: Mocked<IPartnerRepository>;
+  let auditMock: Mocked<IAuditRepository>;
+
+  beforeEach(() => {
+    partnerMock = newPartnerRepositoryMock();
+    assetMock = newAssetRepositoryMock();
+    accessMock = newAccessRepositoryMock();
+    auditMock = newAuditRepositoryMock();
+    sut = new SyncService(accessMock, assetMock, partnerMock, auditMock);
+  });
+
+  it('should exist', () => {
+    expect(sut).toBeDefined();
+  });
+
+  describe('getAllAssetsForUserFullSync', () => {
+    it('should return a list of all assets owned by the user', async () => {
+      assetMock.getAllForUserFullSync.mockResolvedValue([assetStub.external, assetStub.hasEncodedVideo]);
+      await expect(
+        sut.getAllAssetsForUserFullSync(authStub.user1, { limit: 2, updatedUntil: untilDate }),
+      ).resolves.toEqual([
+        mapAsset(assetStub.external, mapAssetOpts),
+        mapAsset(assetStub.hasEncodedVideo, mapAssetOpts),
+      ]);
+      expect(assetMock.getAllForUserFullSync).toHaveBeenCalledWith({
+        ownerId: authStub.user1.user.id,
+        updatedUntil: untilDate,
+        limit: 2,
+      });
+    });
+  });
+
+  describe('getChangesForDeltaSync', () => {
+    it('should return a response requiring a full sync when partners are out of sync', async () => {
+      partnerMock.getAll.mockResolvedValue([partnerStub.adminToUser1]);
+      await expect(
+        sut.getChangesForDeltaSync(authStub.user1, { updatedAfter: new Date(), userIds: [authStub.user1.user.id] }),
+      ).resolves.toEqual({ needsFullSync: true, upserted: [], deleted: [] });
+      expect(assetMock.getChangedDeltaSync).toHaveBeenCalledTimes(0);
+      expect(auditMock.getAfter).toHaveBeenCalledTimes(0);
+    });
+
+    it('should return a response requiring a full sync when last sync was too long ago', async () => {
+      partnerMock.getAll.mockResolvedValue([]);
+      await expect(
+        sut.getChangesForDeltaSync(authStub.user1, { updatedAfter: new Date(2000), userIds: [authStub.user1.user.id] }),
+      ).resolves.toEqual({ needsFullSync: true, upserted: [], deleted: [] });
+      expect(assetMock.getChangedDeltaSync).toHaveBeenCalledTimes(0);
+      expect(auditMock.getAfter).toHaveBeenCalledTimes(0);
+    });
+
+    it('should return a response requiring a full sync when there are too many changes', async () => {
+      partnerMock.getAll.mockResolvedValue([]);
+      assetMock.getChangedDeltaSync.mockResolvedValue(
+        Array.from<AssetEntity>({ length: 10_000 }).fill(assetStub.image),
+      );
+      await expect(
+        sut.getChangesForDeltaSync(authStub.user1, { updatedAfter: new Date(), userIds: [authStub.user1.user.id] }),
+      ).resolves.toEqual({ needsFullSync: true, upserted: [], deleted: [] });
+      expect(assetMock.getChangedDeltaSync).toHaveBeenCalledTimes(1);
+      expect(auditMock.getAfter).toHaveBeenCalledTimes(0);
+    });
+
+    it('should return a response with changes and deletions', async () => {
+      partnerMock.getAll.mockResolvedValue([]);
+      assetMock.getChangedDeltaSync.mockResolvedValue([assetStub.image1]);
+      auditMock.getAfter.mockResolvedValue([assetStub.external.id]);
+      await expect(
+        sut.getChangesForDeltaSync(authStub.user1, { updatedAfter: new Date(), userIds: [authStub.user1.user.id] }),
+      ).resolves.toEqual({
+        needsFullSync: false,
+        upserted: [mapAsset(assetStub.image1, mapAssetOpts)],
+        deleted: [assetStub.external.id],
+      });
+      expect(assetMock.getChangedDeltaSync).toHaveBeenCalledTimes(1);
+      expect(auditMock.getAfter).toHaveBeenCalledTimes(1);
+    });
+  });
+});

server/src/services/sync.service.ts

@@ -0,0 +1,77 @@
+import { Inject } from '@nestjs/common';
+import _ from 'lodash';
+import { DateTime } from 'luxon';
+import { AUDIT_LOG_MAX_DURATION } from 'src/constants';
+import { AccessCore, Permission } from 'src/cores/access.core';
+import { AssetResponseDto, mapAsset } from 'src/dtos/asset-response.dto';
+import { AuthDto } from 'src/dtos/auth.dto';
+import { AssetDeltaSyncDto, AssetDeltaSyncResponseDto, AssetFullSyncDto } from 'src/dtos/sync.dto';
+import { DatabaseAction, EntityType } from 'src/entities/audit.entity';
+import { IAccessRepository } from 'src/interfaces/access.interface';
+import { IAssetRepository } from 'src/interfaces/asset.interface';
+import { IAuditRepository } from 'src/interfaces/audit.interface';
+import { IPartnerRepository } from 'src/interfaces/partner.interface';
+
+export class SyncService {
+  private access: AccessCore;
+
+  constructor(
+    @Inject(IAccessRepository) accessRepository: IAccessRepository,
+    @Inject(IAssetRepository) private assetRepository: IAssetRepository,
+    @Inject(IPartnerRepository) private partnerRepository: IPartnerRepository,
+    @Inject(IAuditRepository) private auditRepository: IAuditRepository,
+  ) {
+    this.access = AccessCore.create(accessRepository);
+  }
+
+  async getAllAssetsForUserFullSync(auth: AuthDto, dto: AssetFullSyncDto): Promise<AssetResponseDto[]> {
+    const userId = dto.userId || auth.user.id;
+    await this.access.requirePermission(auth, Permission.TIMELINE_READ, userId);
+    const assets = await this.assetRepository.getAllForUserFullSync({
+      ownerId: userId,
+      lastCreationDate: dto.lastCreationDate,
+      updatedUntil: dto.updatedUntil,
+      lastId: dto.lastId,
+      limit: dto.limit,
+    });
+    const options = { auth, stripMetadata: false, withStack: true };
+    return assets.map((a) => mapAsset(a, options));
+  }
+
+  async getChangesForDeltaSync(auth: AuthDto, dto: AssetDeltaSyncDto): Promise<AssetDeltaSyncResponseDto> {
+    await this.access.requirePermission(auth, Permission.TIMELINE_READ, dto.userIds);
+    const partner = await this.partnerRepository.getAll(auth.user.id);
+    const userIds = [auth.user.id, ...partner.filter((p) => p.sharedWithId == auth.user.id).map((p) => p.sharedById)];
+    userIds.sort();
+    dto.userIds.sort();
+    const duration = DateTime.now().diff(DateTime.fromJSDate(dto.updatedAfter));
+
+    if (!_.isEqual(userIds, dto.userIds) || duration > AUDIT_LOG_MAX_DURATION) {
+      // app does not have the correct partners synced
+      // or app has not synced in the last 100 days
+      return { needsFullSync: true, deleted: [], upserted: [] };
+    }
+
+    const limit = 10_000;
+    const upserted = await this.assetRepository.getChangedDeltaSync({ limit, updatedAfter: dto.updatedAfter, userIds });
+
+    if (upserted.length === limit) {
+      // too many changes -> do a full sync (paginated) instead
+      return { needsFullSync: true, deleted: [], upserted: [] };
+    }
+
+    const deleted = await this.auditRepository.getAfter(dto.updatedAfter, {
+      userIds: userIds,
+      entityType: EntityType.ASSET,
+      action: DatabaseAction.DELETE,
+    });
+
+    const options = { auth, stripMetadata: false, withStack: true };
+    const result = {
+      needsFullSync: false,
+      upserted: upserted.map((a) => mapAsset(a, options)),
+      deleted,
+    };
+    return result;
+  }
+}

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

@@ -16,12 +16,14 @@ import {
 } from 'src/entities/system-config.entity';
 import { IEventRepository, ServerEvent } from 'src/interfaces/event.interface';
 import { QueueName } from 'src/interfaces/job.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { ISearchRepository } from 'src/interfaces/search.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { SystemConfigService } from 'src/services/system-config.service';
-import { ImmichLogger } from 'src/utils/logger';
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
+import { Mocked } from 'vitest';
 
 const updates: SystemConfigEntity[] = [
   { key: SystemConfigKey.FFMPEG_CRF, value: 30 },
@@ -154,15 +156,17 @@ const updatedConfig = Object.freeze<SystemConfig>({
 
 describe(SystemConfigService.name, () => {
   let sut: SystemConfigService;
-  let configMock: jest.Mocked<ISystemConfigRepository>;
-  let eventMock: jest.Mocked<IEventRepository>;
-  let smartInfoMock: jest.Mocked<ISearchRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let eventMock: Mocked<IEventRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
+  let smartInfoMock: Mocked<ISearchRepository>;
 
   beforeEach(() => {
     delete process.env.IMMICH_CONFIG_FILE;
     configMock = newSystemConfigRepositoryMock();
     eventMock = newEventRepositoryMock();
-    sut = new SystemConfigService(configMock, eventMock, smartInfoMock);
+    loggerMock = newLoggerRepositoryMock();
+    sut = new SystemConfigService(configMock, eventMock, loggerMock, smartInfoMock);
   });
 
   it('should work', () => {
@@ -179,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,7 +260,7 @@ describe(SystemConfigService.name, () => {
       configMock.readFile.mockResolvedValue(partialConfig);
 
       await sut.getConfig();
-      expect(warnLog).toHaveBeenCalled();
+      expect(loggerMock.warn).toHaveBeenCalled();
     });
 
     const tests = [
@@ -285,7 +279,7 @@ describe(SystemConfigService.name, () => {
 
         if (test.warn) {
           await sut.getConfig();
-          expect(warnLog).toHaveBeenCalled();
+          expect(loggerMock.warn).toHaveBeenCalled();
         } else {
           await expect(sut.getConfig()).rejects.toBeInstanceOf(Error);
         }

server/src/services/system-config.service.ts

@@ -22,21 +22,22 @@ import {
   ServerAsyncEventMap,
   ServerEvent,
 } from 'src/interfaces/event.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { ISearchRepository } from 'src/interfaces/search.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
-import { ImmichLogger } from 'src/utils/logger';
 
 @Injectable()
 export class SystemConfigService {
-  private logger = new ImmichLogger(SystemConfigService.name);
   private core: SystemConfigCore;
 
   constructor(
     @Inject(ISystemConfigRepository) private repository: ISystemConfigRepository,
     @Inject(IEventRepository) private eventRepository: IEventRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
     @Inject(ISearchRepository) private smartInfoRepository: ISearchRepository,
   ) {
-    this.core = SystemConfigCore.create(repository);
+    this.logger.setContext(SystemConfigService.name);
+    this.core = SystemConfigCore.create(repository, this.logger);
     this.core.config$.subscribe((config) => this.setLogLevel(config));
   }
 
@@ -130,7 +131,7 @@ export class SystemConfigService {
     const envLevel = this.getEnvLogLevel();
     const configLevel = logging.enabled ? logging.level : false;
     const level = envLevel ?? configLevel;
-    ImmichLogger.setLogLevel(level);
+    this.logger.setLogLevel(level);
     this.logger.log(`LogLevel=${level} ${envLevel ? '(set via LOG_LEVEL)' : '(set via system config)'}`);
   }
 

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

@@ -1,5 +1,4 @@
 import { BadRequestException } from '@nestjs/common';
-import { when } from 'jest-when';
 import { AssetIdErrorReason } from 'src/dtos/asset-ids.response.dto';
 import { TagType } from 'src/entities/tag.entity';
 import { ITagRepository } from 'src/interfaces/tag.interface';
@@ -8,10 +7,11 @@ import { assetStub } from 'test/fixtures/asset.stub';
 import { authStub } from 'test/fixtures/auth.stub';
 import { tagResponseStub, tagStub } from 'test/fixtures/tag.stub';
 import { newTagRepositoryMock } from 'test/repositories/tag.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(TagService.name, () => {
   let sut: TagService;
-  let tagMock: jest.Mocked<ITagRepository>;
+  let tagMock: Mocked<ITagRepository>;
 
   beforeEach(() => {
     tagMock = newTagRepositoryMock();
@@ -129,9 +129,7 @@ describe(TagService.name, () => {
 
     it('should reject duplicate asset ids and accept new ones', async () => {
       tagMock.getById.mockResolvedValue(tagStub.tag1);
-
-      when(tagMock.hasAsset).calledWith(authStub.admin.user.id, 'tag-1', 'asset-1').mockResolvedValue(true);
-      when(tagMock.hasAsset).calledWith(authStub.admin.user.id, 'tag-1', 'asset-2').mockResolvedValue(false);
+      tagMock.hasAsset.mockImplementation((userId, tagId, assetId) => Promise.resolve(assetId === 'asset-1'));
 
       await expect(
         sut.addAssets(authStub.admin, 'tag-1', {
@@ -160,9 +158,7 @@ describe(TagService.name, () => {
 
     it('should accept accept ids that are tagged and reject the rest', async () => {
       tagMock.getById.mockResolvedValue(tagStub.tag1);
-
-      when(tagMock.hasAsset).calledWith(authStub.admin.user.id, 'tag-1', 'asset-1').mockResolvedValue(true);
-      when(tagMock.hasAsset).calledWith(authStub.admin.user.id, 'tag-1', 'asset-2').mockResolvedValue(false);
+      tagMock.hasAsset.mockImplementation((userId, tagId, assetId) => Promise.resolve(assetId === 'asset-1'));
 
       await expect(
         sut.removeAssets(authStub.admin, 'tag-1', {

server/src/services/timeline.service.spec.ts

@@ -7,12 +7,13 @@ import { authStub } from 'test/fixtures/auth.stub';
 import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositories/access.repository.mock';
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newPartnerRepositoryMock } from 'test/repositories/partner.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(TimelineService.name, () => {
   let sut: TimelineService;
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let partnerMock: jest.Mocked<IPartnerRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let partnerMock: Mocked<IPartnerRepository>;
   beforeEach(() => {
     accessMock = newAccessRepositoryMock();
     assetMock = newAssetRepositoryMock();

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

@@ -9,13 +9,14 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newEventRepositoryMock } from 'test/repositories/event.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
+import { Mocked } from 'vitest';
 
 describe(TrashService.name, () => {
   let sut: TrashService;
   let accessMock: IAccessRepositoryMock;
-  let assetMock: jest.Mocked<IAssetRepository>;
-  let jobMock: jest.Mocked<IJobRepository>;
-  let eventMock: jest.Mocked<IEventRepository>;
+  let assetMock: Mocked<IAssetRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let eventMock: Mocked<IEventRepository>;
 
   it('should work', () => {
     expect(sut).toBeDefined();

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

@@ -4,13 +4,13 @@ import {
   InternalServerErrorException,
   NotFoundException,
 } from '@nestjs/common';
-import { when } from 'jest-when';
 import { UpdateUserDto, mapUser } from 'src/dtos/user.dto';
 import { UserEntity, UserStatus } from 'src/entities/user.entity';
 import { IAlbumRepository } from 'src/interfaces/album.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IJobRepository, JobName } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
@@ -23,9 +23,11 @@ import { newAlbumRepositoryMock } from 'test/repositories/album.repository.mock'
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
 import { newLibraryRepositoryMock } from 'test/repositories/library.repository.mock';
+import { newLoggerRepositoryMock } from 'test/repositories/logger.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemConfigRepositoryMock } from 'test/repositories/system-config.repository.mock';
 import { newUserRepositoryMock } from 'test/repositories/user.repository.mock';
+import { Mocked, vitest } from 'vitest';
 
 const makeDeletedAt = (daysAgo: number) => {
   const deletedAt = new Date();
@@ -35,14 +37,15 @@ const makeDeletedAt = (daysAgo: number) => {
 
 describe(UserService.name, () => {
   let sut: UserService;
-  let userMock: jest.Mocked<IUserRepository>;
-  let cryptoRepositoryMock: jest.Mocked<ICryptoRepository>;
+  let userMock: Mocked<IUserRepository>;
+  let cryptoRepositoryMock: 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 albumMock: Mocked<IAlbumRepository>;
+  let jobMock: Mocked<IJobRepository>;
+  let libraryMock: Mocked<ILibraryRepository>;
+  let storageMock: Mocked<IStorageRepository>;
+  let configMock: Mocked<ISystemConfigRepository>;
+  let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
     albumMock = newAlbumRepositoryMock();
@@ -52,13 +55,22 @@ describe(UserService.name, () => {
     libraryMock = newLibraryRepositoryMock();
     storageMock = newStorageRepositoryMock();
     userMock = newUserRepositoryMock();
+    loggerMock = newLoggerRepositoryMock();
 
-    sut = new UserService(albumMock, cryptoRepositoryMock, jobMock, libraryMock, storageMock, configMock, userMock);
+    sut = new UserService(
+      albumMock,
+      cryptoRepositoryMock,
+      jobMock,
+      libraryMock,
+      storageMock,
+      configMock,
+      userMock,
+      loggerMock,
+    );
 
-    when(userMock.get).calledWith(authStub.admin.user.id, {}).mockResolvedValue(userStub.admin);
-    when(userMock.get).calledWith(authStub.admin.user.id, { withDeleted: true }).mockResolvedValue(userStub.admin);
-    when(userMock.get).calledWith(authStub.user1.user.id, {}).mockResolvedValue(userStub.user1);
-    when(userMock.get).calledWith(authStub.user1.user.id, { withDeleted: true }).mockResolvedValue(userStub.user1);
+    userMock.get.mockImplementation((userId) =>
+      Promise.resolve([userStub.admin, userStub.user1].find((user) => user.id === userId) ?? null),
+    );
   });
 
   describe('getAll', () => {
@@ -136,12 +148,10 @@ describe(UserService.name, () => {
     });
 
     it('user can only update its information', async () => {
-      when(userMock.get)
-        .calledWith('not_immich_auth_user_id', {})
-        .mockResolvedValueOnce({
-          ...userStub.user1,
-          id: 'not_immich_auth_user_id',
-        });
+      userMock.get.mockResolvedValueOnce({
+        ...userStub.user1,
+        id: 'not_immich_auth_user_id',
+      });
 
       const result = sut.update(
         { user: userStub.user1 },
@@ -195,7 +205,7 @@ describe(UserService.name, () => {
         shouldChangePassword: true,
       };
 
-      when(userMock.update).calledWith(userStub.user1.id, update).mockResolvedValueOnce(userStub.user1);
+      userMock.update.mockResolvedValueOnce(userStub.user1);
       await sut.update(authStub.admin, update);
       expect(userMock.update).toHaveBeenCalledWith(userStub.user1.id, {
         id: 'user-id',
@@ -204,7 +214,7 @@ describe(UserService.name, () => {
     });
 
     it('update user information should throw error if user not found', async () => {
-      when(userMock.get).calledWith(userStub.user1.id, {}).mockResolvedValueOnce(null);
+      userMock.get.mockResolvedValueOnce(null);
 
       const result = sut.update(authStub.admin, {
         id: userStub.user1.id,
@@ -217,7 +227,7 @@ describe(UserService.name, () => {
     it('should let the admin update himself', async () => {
       const dto = { id: userStub.admin.id, shouldChangePassword: true, isAdmin: true };
 
-      when(userMock.update).calledWith(userStub.admin.id, dto).mockResolvedValueOnce(userStub.admin);
+      userMock.update.mockResolvedValueOnce(userStub.admin);
 
       await sut.update(authStub.admin, dto);
 
@@ -227,7 +237,7 @@ describe(UserService.name, () => {
     it('should not let the another user become an admin', async () => {
       const dto = { id: userStub.user1.id, shouldChangePassword: true, isAdmin: true };
 
-      when(userMock.get).calledWith(userStub.user1.id, {}).mockResolvedValueOnce(userStub.user1);
+      userMock.get.mockResolvedValueOnce(userStub.user1);
 
       await expect(sut.update(authStub.admin, dto)).rejects.toBeInstanceOf(BadRequestException);
     });
@@ -235,7 +245,7 @@ describe(UserService.name, () => {
 
   describe('restore', () => {
     it('should throw error if user could not be found', async () => {
-      when(userMock.get).calledWith(userStub.admin.id, { withDeleted: true }).mockResolvedValue(null);
+      userMock.get.mockResolvedValue(null);
       await expect(sut.restore(authStub.admin, userStub.admin.id)).rejects.toThrowError(BadRequestException);
       expect(userMock.update).not.toHaveBeenCalled();
     });
@@ -298,7 +308,7 @@ describe(UserService.name, () => {
 
   describe('create', () => {
     it('should not create a user if there is no local admin account', async () => {
-      when(userMock.getAdmin).calledWith().mockResolvedValueOnce(null);
+      userMock.getAdmin.mockResolvedValueOnce(null);
 
       await expect(
         sut.create({
@@ -335,6 +345,7 @@ describe(UserService.name, () => {
   describe('createProfileImage', () => {
     it('should throw an error if the user does not exist', async () => {
       const file = { path: '/profile/path' } as Express.Multer.File;
+      userMock.get.mockResolvedValue(null);
       userMock.update.mockResolvedValue({ ...userStub.admin, profileImagePath: file.path });
 
       await expect(sut.createProfileImage(authStub.admin, file)).rejects.toThrowError(BadRequestException);
@@ -422,7 +433,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 = vitest.fn().mockResolvedValue('new-password');
 
       await expect(sut.resetAdminPassword(ask)).rejects.toBeInstanceOf(BadRequestException);
 
@@ -431,7 +442,7 @@ describe(UserService.name, () => {
 
     it('should default to a random password', async () => {
       userMock.getAdmin.mockResolvedValue(userStub.admin);
-      const ask = jest.fn().mockImplementation(() => {});
+      const ask = vitest.fn().mockImplementation(() => {});
 
       const response = await sut.resetAdminPassword(ask);
 
@@ -445,7 +456,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 = vitest.fn().mockResolvedValue('new-password');
 
       const response = await sut.resetAdminPassword(ask);
 

server/src/services/user.service.ts

@@ -11,16 +11,15 @@ import { IAlbumRepository } from 'src/interfaces/album.interface';
 import { ICryptoRepository } from 'src/interfaces/crypto.interface';
 import { IEntityJob, IJobRepository, JobName, JobStatus } from 'src/interfaces/job.interface';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
 import { ISystemConfigRepository } from 'src/interfaces/system-config.interface';
 import { IUserRepository, UserFindOptions } from 'src/interfaces/user.interface';
 import { CacheControl, ImmichFileResponse } from 'src/utils/file';
-import { ImmichLogger } from 'src/utils/logger';
 
 @Injectable()
 export class UserService {
   private configCore: SystemConfigCore;
-  private logger = new ImmichLogger(UserService.name);
   private userCore: UserCore;
 
   constructor(
@@ -31,9 +30,11 @@ export class UserService {
     @Inject(IStorageRepository) private storageRepository: IStorageRepository,
     @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
     @Inject(IUserRepository) private userRepository: IUserRepository,
+    @Inject(ILoggerRepository) private logger: ILoggerRepository,
   ) {
     this.userCore = UserCore.create(cryptoRepository, libraryRepository, userRepository);
-    this.configCore = SystemConfigCore.create(configRepository);
+    this.logger.setContext(UserService.name);
+    this.configCore = SystemConfigCore.create(configRepository, this.logger);
   }
 
   async getAll(auth: AuthDto, isAll: boolean): Promise<UserResponseDto[]> {

server/src/utils/logger.ts

@@ -4,6 +4,7 @@ import { LogLevel } from 'src/entities/system-config.entity';
 
 const LOG_LEVELS = [LogLevel.VERBOSE, LogLevel.DEBUG, LogLevel.LOG, LogLevel.WARN, LogLevel.ERROR, LogLevel.FATAL];
 
+// TODO move implementation to logger.repository.ts
 export class ImmichLogger extends ConsoleLogger {
   private static logLevels: LogLevel[] = [LogLevel.LOG, LogLevel.WARN, LogLevel.ERROR, LogLevel.FATAL];
 

server/src/utils/misc.ts

@@ -17,12 +17,12 @@ import {
   IMMICH_API_KEY_NAME,
   serverVersion,
 } from 'src/constants';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { Metadata } from 'src/middleware/auth.guard';
-import { ImmichLogger } from 'src/utils/logger';
 
 export const isConnectionAborted = (error: Error | any) => error.code === 'ECONNABORTED';
 
-export const handlePromiseError = <T>(promise: Promise<T>, logger: ImmichLogger): void => {
+export const handlePromiseError = <T>(promise: Promise<T>, logger: ILoggerRepository): void => {
   promise.catch((error: Error | any) => logger.error(`Promise error: ${error}`, error?.stack));
 };
 

server/src/utils/sql.ts

@@ -12,6 +12,7 @@ import { format } from 'sql-formatter';
 import { databaseConfig } from 'src/database.config';
 import { GENERATE_SQL_KEY, GenerateSqlQueries } from 'src/decorators';
 import { entities } from 'src/entities';
+import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { repositories } from 'src/repositories';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { AuthService } from 'src/services/auth.service';
@@ -58,6 +59,9 @@ class SqlGenerator {
     try {
       await this.setup();
       for (const repository of repositories) {
+        if (repository.provide === ILoggerRepository) {
+          continue;
+        }
         await this.process(repository);
       }
       await this.write();