merge main

server/.nvmrc

@@ -1 +1 @@
-24.11.0
+24.11.1

server/package.json

@@ -120,7 +120,7 @@
     "@nestjs/schematics": "^11.0.0",
     "@nestjs/testing": "^11.0.4",
     "@swc/core": "^1.4.14",
-    "@types/archiver": "^6.0.0",
+    "@types/archiver": "^7.0.0",
     "@types/async-lock": "^1.4.2",
     "@types/bcrypt": "^6.0.0",
     "@types/body-parser": "^1.19.6",
@@ -134,7 +134,7 @@
     "@types/luxon": "^3.6.2",
     "@types/mock-fs": "^4.13.1",
     "@types/multer": "^2.0.0",
-    "@types/node": "^22.19.1",
+    "@types/node": "^24.10.1",
     "@types/nodemailer": "^7.0.0",
     "@types/picomatch": "^4.0.0",
     "@types/pngjs": "^6.0.5",
@@ -166,7 +166,7 @@
     "vitest": "^3.0.0"
   },
   "volta": {
-    "node": "24.11.0"
+    "node": "24.11.1"
   },
   "overrides": {
     "sharp": "^0.34.4"

server/src/constants.ts

@@ -163,6 +163,8 @@ export const endpointTags: Record<ApiTag, string> = {
     'A person is a collection of faces, which can be favorited and named. A person can also be merged into another person. People are automatically created via the face recognition job.',
   [ApiTag.Plugins]:
     'A plugin is an installed module that makes filters and actions available for the workflow feature.',
+  [ApiTag.Queues]:
+    'Queues and background jobs are used for processing tasks asynchronously. Queues can be paused and resumed as needed.',
   [ApiTag.Search]:
     'Endpoints related to searching assets via text, smart search, optical character recognition (OCR), and other filters like person, album, and other metadata. Search endpoints usually support pagination and sorting.',
   [ApiTag.Server]:

server/src/controllers/index.ts

@@ -20,6 +20,7 @@ import { OAuthController } from 'src/controllers/oauth.controller';
 import { PartnerController } from 'src/controllers/partner.controller';
 import { PersonController } from 'src/controllers/person.controller';
 import { PluginController } from 'src/controllers/plugin.controller';
+import { QueueController } from 'src/controllers/queue.controller';
 import { SearchController } from 'src/controllers/search.controller';
 import { ServerController } from 'src/controllers/server.controller';
 import { SessionController } from 'src/controllers/session.controller';
@@ -59,6 +60,7 @@ export const controllers = [
   PartnerController,
   PersonController,
   PluginController,
+  QueueController,
   SearchController,
   ServerController,
   SessionController,

server/src/controllers/job.controller.ts

@@ -1,10 +1,12 @@
 import { Body, Controller, Get, HttpCode, HttpStatus, Param, Post, Put } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { Endpoint, HistoryBuilder } from 'src/decorators';
+import { AuthDto } from 'src/dtos/auth.dto';
 import { JobCreateDto } from 'src/dtos/job.dto';
-import { QueueCommandDto, QueueNameParamDto, QueueResponseDto, QueuesResponseDto } from 'src/dtos/queue.dto';
+import { QueueResponseLegacyDto, QueuesResponseLegacyDto } from 'src/dtos/queue-legacy.dto';
+import { QueueCommandDto, QueueNameParamDto } from 'src/dtos/queue.dto';
 import { ApiTag, Permission } from 'src/enum';
-import { Authenticated } from 'src/middleware/auth.guard';
+import { Auth, Authenticated } from 'src/middleware/auth.guard';
 import { JobService } from 'src/services/job.service';
 import { QueueService } from 'src/services/queue.service';
 
@@ -21,10 +23,10 @@ export class JobController {
   @Endpoint({
     summary: 'Retrieve queue counts and status',
     description: 'Retrieve the counts of the current queue, as well as the current status.',
-    history: new HistoryBuilder().added('v1').beta('v1').stable('v2'),
+    history: new HistoryBuilder().added('v1').beta('v1').stable('v2').deprecated('v2.4.0'),
   })
-  getQueuesLegacy(): Promise<QueuesResponseDto> {
-    return this.queueService.getAll();
+  getQueuesLegacy(@Auth() auth: AuthDto): Promise<QueuesResponseLegacyDto> {
+    return this.queueService.getAllLegacy(auth);
   }
 
   @Post()
@@ -46,9 +48,12 @@ export class JobController {
     summary: 'Run jobs',
     description:
       'Queue all assets for a specific job type. Defaults to only queueing assets that have not yet been processed, but the force command can be used to re-process all assets.',
-    history: new HistoryBuilder().added('v1').beta('v1').stable('v2'),
+    history: new HistoryBuilder().added('v1').beta('v1').stable('v2').deprecated('v2.4.0'),
   })
-  runQueueCommandLegacy(@Param() { name }: QueueNameParamDto, @Body() dto: QueueCommandDto): Promise<QueueResponseDto> {
-    return this.queueService.runCommand(name, dto);
+  runQueueCommandLegacy(
+    @Param() { name }: QueueNameParamDto,
+    @Body() dto: QueueCommandDto,
+  ): Promise<QueueResponseLegacyDto> {
+    return this.queueService.runCommandLegacy(name, dto);
   }
 }

server/src/controllers/queue.controller.ts

@@ -0,0 +1,85 @@
+import { Body, Controller, Delete, Get, HttpCode, HttpStatus, Param, Put, Query } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { Endpoint, HistoryBuilder } from 'src/decorators';
+import { AuthDto } from 'src/dtos/auth.dto';
+import {
+  QueueDeleteDto,
+  QueueJobResponseDto,
+  QueueJobSearchDto,
+  QueueNameParamDto,
+  QueueResponseDto,
+  QueueUpdateDto,
+} from 'src/dtos/queue.dto';
+import { ApiTag, Permission } from 'src/enum';
+import { Auth, Authenticated } from 'src/middleware/auth.guard';
+import { QueueService } from 'src/services/queue.service';
+
+@ApiTags(ApiTag.Queues)
+@Controller('queues')
+export class QueueController {
+  constructor(private service: QueueService) {}
+
+  @Get()
+  @Authenticated({ permission: Permission.QueueRead, admin: true })
+  @Endpoint({
+    summary: 'List all queues',
+    description: 'Retrieves a list of queues.',
+    history: new HistoryBuilder().added('v2.4.0').alpha('v2.4.0'),
+  })
+  getQueues(@Auth() auth: AuthDto): Promise<QueueResponseDto[]> {
+    return this.service.getAll(auth);
+  }
+
+  @Get(':name')
+  @Authenticated({ permission: Permission.QueueRead, admin: true })
+  @Endpoint({
+    summary: 'Retrieve a queue',
+    description: 'Retrieves a specific queue by its name.',
+    history: new HistoryBuilder().added('v2.4.0').alpha('v2.4.0'),
+  })
+  getQueue(@Auth() auth: AuthDto, @Param() { name }: QueueNameParamDto): Promise<QueueResponseDto> {
+    return this.service.get(auth, name);
+  }
+
+  @Put(':name')
+  @Authenticated({ permission: Permission.QueueUpdate, admin: true })
+  @Endpoint({
+    summary: 'Update a queue',
+    description: 'Change the paused status of a specific queue.',
+    history: new HistoryBuilder().added('v2.4.0').alpha('v2.4.0'),
+  })
+  updateQueue(
+    @Auth() auth: AuthDto,
+    @Param() { name }: QueueNameParamDto,
+    @Body() dto: QueueUpdateDto,
+  ): Promise<QueueResponseDto> {
+    return this.service.update(auth, name, dto);
+  }
+
+  @Get(':name/jobs')
+  @Authenticated({ permission: Permission.QueueJobRead, admin: true })
+  @Endpoint({
+    summary: 'Retrieve queue jobs',
+    description: 'Retrieves a list of queue jobs from the specified queue.',
+    history: new HistoryBuilder().added('v2.4.0').alpha('v2.4.0'),
+  })
+  getQueueJobs(
+    @Auth() auth: AuthDto,
+    @Param() { name }: QueueNameParamDto,
+    @Query() dto: QueueJobSearchDto,
+  ): Promise<QueueJobResponseDto[]> {
+    return this.service.searchJobs(auth, name, dto);
+  }
+
+  @Delete(':name/jobs')
+  @Authenticated({ permission: Permission.QueueJobDelete, admin: true })
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @Endpoint({
+    summary: 'Empty a queue',
+    description: 'Removes all jobs from the specified queue.',
+    history: new HistoryBuilder().added('v2.4.0').alpha('v2.4.0'),
+  })
+  emptyQueue(@Auth() auth: AuthDto, @Param() { name }: QueueNameParamDto, @Body() dto: QueueDeleteDto): Promise<void> {
+    return this.service.emptyQueue(auth, name, dto);
+  }
+}

server/src/dtos/queue-legacy.dto.ts

@@ -0,0 +1,89 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { QueueResponseDto, QueueStatisticsDto } from 'src/dtos/queue.dto';
+import { QueueName } from 'src/enum';
+
+export class QueueStatusLegacyDto {
+  isActive!: boolean;
+  isPaused!: boolean;
+}
+
+export class QueueResponseLegacyDto {
+  @ApiProperty({ type: QueueStatusLegacyDto })
+  queueStatus!: QueueStatusLegacyDto;
+
+  @ApiProperty({ type: QueueStatisticsDto })
+  jobCounts!: QueueStatisticsDto;
+}
+
+export class QueuesResponseLegacyDto implements Record<QueueName, QueueResponseLegacyDto> {
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.ThumbnailGeneration]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.MetadataExtraction]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.VideoConversion]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.SmartSearch]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.StorageTemplateMigration]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Migration]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.BackgroundTask]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Search]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.DuplicateDetection]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.FaceDetection]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.FacialRecognition]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Sidecar]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Library]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Notification]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.BackupDatabase]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Ocr]!: QueueResponseLegacyDto;
+
+  @ApiProperty({ type: QueueResponseLegacyDto })
+  [QueueName.Workflow]!: QueueResponseLegacyDto;
+}
+
+export const mapQueueLegacy = (response: QueueResponseDto): QueueResponseLegacyDto => {
+  return {
+    queueStatus: {
+      isPaused: response.isPaused,
+      isActive: response.statistics.active > 0,
+    },
+    jobCounts: response.statistics,
+  };
+};
+
+export const mapQueuesLegacy = (responses: QueueResponseDto[]): QueuesResponseLegacyDto => {
+  const legacy = new QueuesResponseLegacyDto();
+
+  for (const response of responses) {
+    legacy[response.name] = mapQueueLegacy(response);
+  }
+
+  return legacy;
+};

server/src/dtos/queue.dto.ts

@@ -1,5 +1,6 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { QueueCommand, QueueName } from 'src/enum';
+import { HistoryBuilder, Property } from 'src/decorators';
+import { JobName, QueueCommand, QueueJobStatus, QueueName } from 'src/enum';
 import { ValidateBoolean, ValidateEnum } from 'src/validation';
 
 export class QueueNameParamDto {
@@ -15,6 +16,46 @@ export class QueueCommandDto {
   force?: boolean; // TODO: this uses undefined as a third state, which should be refactored to be more explicit
 }
 
+export class QueueUpdateDto {
+  @ValidateBoolean({ optional: true })
+  isPaused?: boolean;
+}
+
+export class QueueDeleteDto {
+  @ValidateBoolean({ optional: true })
+  @Property({
+    description: 'If true, will also remove failed jobs from the queue.',
+    history: new HistoryBuilder().added('v2.4.0').alpha('v2.4.0'),
+  })
+  failed?: boolean;
+}
+
+export class QueueJobSearchDto {
+  @ValidateEnum({ enum: QueueJobStatus, name: 'QueueJobStatus', optional: true, each: true })
+  status?: QueueJobStatus[];
+}
+export class QueueJobResponseDto {
+  id?: string;
+
+  @ValidateEnum({ enum: JobName, name: 'JobName' })
+  name!: JobName;
+
+  data!: object;
+
+  @ApiProperty({ type: 'integer' })
+  timestamp!: number;
+}
+
+export class QueueResponseDto {
+  @ValidateEnum({ enum: QueueName, name: 'QueueName' })
+  name!: QueueName;
+
+  @ValidateBoolean()
+  isPaused!: boolean;
+
+  statistics!: QueueStatisticsDto;
+}
+
 export class QueueStatisticsDto {
   @ApiProperty({ type: 'integer' })
   active!: number;
@@ -29,69 +70,3 @@ export class QueueStatisticsDto {
   @ApiProperty({ type: 'integer' })
   paused!: number;
 }
-
-export class QueueStatusDto {
-  isActive!: boolean;
-  isPaused!: boolean;
-}
-
-export class QueueResponseDto {
-  @ApiProperty({ type: QueueStatisticsDto })
-  jobCounts!: QueueStatisticsDto;
-
-  @ApiProperty({ type: QueueStatusDto })
-  queueStatus!: QueueStatusDto;
-}
-
-export class QueuesResponseDto implements Record<QueueName, QueueResponseDto> {
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.ThumbnailGeneration]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.MetadataExtraction]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.VideoConversion]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.SmartSearch]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.StorageTemplateMigration]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Migration]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.BackgroundTask]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Search]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.DuplicateDetection]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.FaceDetection]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.FacialRecognition]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Sidecar]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Library]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Notification]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.BackupDatabase]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Ocr]!: QueueResponseDto;
-
-  @ApiProperty({ type: QueueResponseDto })
-  [QueueName.Workflow]!: QueueResponseDto;
-}

server/src/enum.ts

@@ -248,6 +248,14 @@ export enum Permission {
   UserProfileImageUpdate = 'userProfileImage.update',
   UserProfileImageDelete = 'userProfileImage.delete',
 
+  QueueRead = 'queue.read',
+  QueueUpdate = 'queue.update',
+
+  QueueJobCreate = 'queueJob.create',
+  QueueJobRead = 'queueJob.read',
+  QueueJobUpdate = 'queueJob.update',
+  QueueJobDelete = 'queueJob.delete',
+
   WorkflowCreate = 'workflow.create',
   WorkflowRead = 'workflow.read',
   WorkflowUpdate = 'workflow.update',
@@ -543,6 +551,15 @@ export enum QueueName {
   Workflow = 'workflow',
 }
 
+export enum QueueJobStatus {
+  Active = 'active',
+  Failed = 'failed',
+  Complete = 'completed',
+  Delayed = 'delayed',
+  Waiting = 'waiting',
+  Paused = 'paused',
+}
+
 export enum JobName {
   AssetDelete = 'AssetDelete',
   AssetDeleteCheck = 'AssetDeleteCheck',
@@ -624,9 +641,13 @@ export enum JobName {
 
 export enum QueueCommand {
   Start = 'start',
+  /** @deprecated Use `updateQueue` instead */
   Pause = 'pause',
+  /** @deprecated Use `updateQueue` instead */
   Resume = 'resume',
+  /** @deprecated Use `emptyQueue` instead */
   Empty = 'empty',
+  /** @deprecated Use `emptyQueue` instead */
   ClearFailed = 'clear-failed',
 }
 
@@ -823,6 +844,7 @@ export enum ApiTag {
   Partners = 'Partners',
   People = 'People',
   Plugins = 'Plugins',
+  Queues = 'Queues',
   Search = 'Search',
   Server = 'Server',
   Sessions = 'Sessions',

server/src/repositories/config.repository.ts

@@ -249,7 +249,7 @@ const getEnv = (): EnvData => {
         prefix: 'immich_bull',
         connection: { ...redisConfig },
         defaultJobOptions: {
-          attempts: 3,
+          attempts: 1,
           removeOnComplete: true,
           removeOnFail: false,
         },

server/src/repositories/job.repository.ts

@@ -5,11 +5,12 @@ import { JobsOptions, Queue, Worker } from 'bullmq';
 import { ClassConstructor } from 'class-transformer';
 import { setTimeout } from 'node:timers/promises';
 import { JobConfig } from 'src/decorators';
-import { JobName, JobStatus, MetadataKey, QueueCleanType, QueueName } from 'src/enum';
+import { QueueJobResponseDto, QueueJobSearchDto } from 'src/dtos/queue.dto';
+import { JobName, JobStatus, MetadataKey, QueueCleanType, QueueJobStatus, QueueName } from 'src/enum';
 import { ConfigRepository } from 'src/repositories/config.repository';
 import { EventRepository } from 'src/repositories/event.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
-import { JobCounts, JobItem, JobOf, QueueStatus } from 'src/types';
+import { JobCounts, JobItem, JobOf } from 'src/types';
 import { getKeyByValue, getMethodNames, ImmichStartupError } from 'src/utils/misc';
 
 type JobMapItem = {
@@ -115,13 +116,14 @@ export class JobRepository {
     worker.concurrency = concurrency;
   }
 
-  async getQueueStatus(name: QueueName): Promise<QueueStatus> {
+  async isActive(name: QueueName): Promise<boolean> {
     const queue = this.getQueue(name);
+    const count = await queue.getActiveCount();
+    return count > 0;
+  }
 
-    return {
-      isActive: !!(await queue.getActiveCount()),
-      isPaused: await queue.isPaused(),
-    };
+  async isPaused(name: QueueName): Promise<boolean> {
+    return this.getQueue(name).isPaused();
   }
 
   pause(name: QueueName) {
@@ -192,17 +194,28 @@ export class JobRepository {
   }
 
   async waitForQueueCompletion(...queues: QueueName[]): Promise<void> {
-    let activeQueue: QueueStatus | undefined;
-    do {
-      const statuses = await Promise.all(queues.map((name) => this.getQueueStatus(name)));
-      activeQueue = statuses.find((status) => status.isActive);
-    } while (activeQueue);
-    {
-      this.logger.verbose(`Waiting for ${activeQueue} queue to stop...`);
+    const getPending = async () => {
+      const results = await Promise.all(queues.map(async (name) => ({ pending: await this.isActive(name), name })));
+      return results.filter(({ pending }) => pending).map(({ name }) => name);
+    };
+
+    let pending = await getPending();
+
+    while (pending.length > 0) {
+      this.logger.verbose(`Waiting for ${pending[0]} queue to stop...`);
       await setTimeout(1000);
+      pending = await getPending();
     }
   }
 
+  async searchJobs(name: QueueName, dto: QueueJobSearchDto): Promise<QueueJobResponseDto[]> {
+    const jobs = await this.getQueue(name).getJobs(dto.status ?? Object.values(QueueJobStatus), 0, 1000);
+    return jobs.map((job) => {
+      const { id, name, timestamp, data } = job;
+      return { id, name: name as JobName, timestamp, data };
+    });
+  }
+
   private getJobOptions(item: JobItem): JobsOptions | null {
     switch (item.name) {
       case JobName.NotifyAlbumUpdate: {

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

@@ -2,6 +2,7 @@ import { BadRequestException } from '@nestjs/common';
 import { defaults, SystemConfig } from 'src/config';
 import { ImmichWorker, JobName, QueueCommand, QueueName } from 'src/enum';
 import { QueueService } from 'src/services/queue.service';
+import { factory } from 'test/small.factory';
 import { newTestService, ServiceMocks } from 'test/utils';
 
 describe(QueueService.name, () => {
@@ -52,80 +53,64 @@ describe(QueueService.name, () => {
 
   describe('getAllJobStatus', () => {
     it('should get all job statuses', async () => {
-      mocks.job.getJobCounts.mockResolvedValue({
-        active: 1,
-        completed: 1,
-        failed: 1,
-        delayed: 1,
-        waiting: 1,
-        paused: 1,
-      });
-      mocks.job.getQueueStatus.mockResolvedValue({
-        isActive: true,
-        isPaused: true,
-      });
+      const stats = factory.queueStatistics({ active: 1 });
+      const expected = { jobCounts: stats, queueStatus: { isActive: true, isPaused: true } };
 
-      const expectedJobStatus = {
-        jobCounts: {
-          active: 1,
-          completed: 1,
-          delayed: 1,
-          failed: 1,
-          waiting: 1,
-          paused: 1,
-        },
-        queueStatus: {
-          isActive: true,
-          isPaused: true,
-        },
-      };
+      mocks.job.getJobCounts.mockResolvedValue(stats);
+      mocks.job.isPaused.mockResolvedValue(true);
 
-      await expect(sut.getAll()).resolves.toEqual({
-        [QueueName.BackgroundTask]: expectedJobStatus,
-        [QueueName.DuplicateDetection]: expectedJobStatus,
-        [QueueName.SmartSearch]: expectedJobStatus,
-        [QueueName.MetadataExtraction]: expectedJobStatus,
-        [QueueName.Search]: expectedJobStatus,
-        [QueueName.StorageTemplateMigration]: expectedJobStatus,
-        [QueueName.Migration]: expectedJobStatus,
-        [QueueName.ThumbnailGeneration]: expectedJobStatus,
-        [QueueName.VideoConversion]: expectedJobStatus,
-        [QueueName.FaceDetection]: expectedJobStatus,
-        [QueueName.FacialRecognition]: expectedJobStatus,
-        [QueueName.Sidecar]: expectedJobStatus,
-        [QueueName.Library]: expectedJobStatus,
-        [QueueName.Notification]: expectedJobStatus,
-        [QueueName.BackupDatabase]: expectedJobStatus,
-        [QueueName.Ocr]: expectedJobStatus,
-        [QueueName.Workflow]: expectedJobStatus,
+      await expect(sut.getAllLegacy(factory.auth())).resolves.toEqual({
+        [QueueName.BackgroundTask]: expected,
+        [QueueName.DuplicateDetection]: expected,
+        [QueueName.SmartSearch]: expected,
+        [QueueName.MetadataExtraction]: expected,
+        [QueueName.Search]: expected,
+        [QueueName.StorageTemplateMigration]: expected,
+        [QueueName.Migration]: expected,
+        [QueueName.ThumbnailGeneration]: expected,
+        [QueueName.VideoConversion]: expected,
+        [QueueName.FaceDetection]: expected,
+        [QueueName.FacialRecognition]: expected,
+        [QueueName.Sidecar]: expected,
+        [QueueName.Library]: expected,
+        [QueueName.Notification]: expected,
+        [QueueName.BackupDatabase]: expected,
+        [QueueName.Ocr]: expected,
+        [QueueName.Workflow]: expected,
       });
     });
   });
 
   describe('handleCommand', () => {
     it('should handle a pause command', async () => {
-      await sut.runCommand(QueueName.MetadataExtraction, { command: QueueCommand.Pause, force: false });
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
+
+      await sut.runCommandLegacy(QueueName.MetadataExtraction, { command: QueueCommand.Pause, force: false });
 
       expect(mocks.job.pause).toHaveBeenCalledWith(QueueName.MetadataExtraction);
     });
 
     it('should handle a resume command', async () => {
-      await sut.runCommand(QueueName.MetadataExtraction, { command: QueueCommand.Resume, force: false });
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
+
+      await sut.runCommandLegacy(QueueName.MetadataExtraction, { command: QueueCommand.Resume, force: false });
 
       expect(mocks.job.resume).toHaveBeenCalledWith(QueueName.MetadataExtraction);
     });
 
     it('should handle an empty command', async () => {
-      await sut.runCommand(QueueName.MetadataExtraction, { command: QueueCommand.Empty, force: false });
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
+
+      await sut.runCommandLegacy(QueueName.MetadataExtraction, { command: QueueCommand.Empty, force: false });
 
       expect(mocks.job.empty).toHaveBeenCalledWith(QueueName.MetadataExtraction);
     });
 
     it('should not start a job that is already running', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: true, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(true);
 
       await expect(
-        sut.runCommand(QueueName.VideoConversion, { command: QueueCommand.Start, force: false }),
+        sut.runCommandLegacy(QueueName.VideoConversion, { command: QueueCommand.Start, force: false }),
       ).rejects.toBeInstanceOf(BadRequestException);
 
       expect(mocks.job.queue).not.toHaveBeenCalled();
@@ -133,33 +118,37 @@ describe(QueueService.name, () => {
     });
 
     it('should handle a start video conversion command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.VideoConversion, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.VideoConversion, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.AssetEncodeVideoQueueAll, data: { force: false } });
     });
 
     it('should handle a start storage template migration command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.StorageTemplateMigration, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.StorageTemplateMigration, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.StorageTemplateMigration });
     });
 
     it('should handle a start smart search command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.SmartSearch, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.SmartSearch, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.SmartSearchQueueAll, data: { force: false } });
     });
 
     it('should handle a start metadata extraction command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.MetadataExtraction, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.MetadataExtraction, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({
         name: JobName.AssetExtractMetadataQueueAll,
@@ -168,17 +157,19 @@ describe(QueueService.name, () => {
     });
 
     it('should handle a start sidecar command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.Sidecar, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.Sidecar, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.SidecarQueueAll, data: { force: false } });
     });
 
     it('should handle a start thumbnail generation command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.ThumbnailGeneration, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.ThumbnailGeneration, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({
         name: JobName.AssetGenerateThumbnailsQueueAll,
@@ -187,34 +178,37 @@ describe(QueueService.name, () => {
     });
 
     it('should handle a start face detection command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.FaceDetection, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.FaceDetection, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.AssetDetectFacesQueueAll, data: { force: false } });
     });
 
     it('should handle a start facial recognition command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.FacialRecognition, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.FacialRecognition, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.FacialRecognitionQueueAll, data: { force: false } });
     });
 
     it('should handle a start backup database command', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
+      mocks.job.getJobCounts.mockResolvedValue(factory.queueStatistics());
 
-      await sut.runCommand(QueueName.BackupDatabase, { command: QueueCommand.Start, force: false });
+      await sut.runCommandLegacy(QueueName.BackupDatabase, { command: QueueCommand.Start, force: false });
 
       expect(mocks.job.queue).toHaveBeenCalledWith({ name: JobName.DatabaseBackup, data: { force: false } });
     });
 
     it('should throw a bad request when an invalid queue is used', async () => {
-      mocks.job.getQueueStatus.mockResolvedValue({ isActive: false, isPaused: false });
+      mocks.job.isActive.mockResolvedValue(false);
 
       await expect(
-        sut.runCommand(QueueName.BackgroundTask, { command: QueueCommand.Start, force: false }),
+        sut.runCommandLegacy(QueueName.BackgroundTask, { command: QueueCommand.Start, force: false }),
       ).rejects.toBeInstanceOf(BadRequestException);
 
       expect(mocks.job.queue).not.toHaveBeenCalled();

server/src/services/queue.service.ts

@@ -2,7 +2,21 @@ import { BadRequestException, Injectable } from '@nestjs/common';
 import { ClassConstructor } from 'class-transformer';
 import { SystemConfig } from 'src/config';
 import { OnEvent } from 'src/decorators';
-import { QueueCommandDto, QueueResponseDto, QueuesResponseDto } from 'src/dtos/queue.dto';
+import { AuthDto } from 'src/dtos/auth.dto';
+import {
+  mapQueueLegacy,
+  mapQueuesLegacy,
+  QueueResponseLegacyDto,
+  QueuesResponseLegacyDto,
+} from 'src/dtos/queue-legacy.dto';
+import {
+  QueueCommandDto,
+  QueueDeleteDto,
+  QueueJobResponseDto,
+  QueueJobSearchDto,
+  QueueResponseDto,
+  QueueUpdateDto,
+} from 'src/dtos/queue.dto';
 import {
   BootstrapEventPriority,
   CronJob,
@@ -86,7 +100,7 @@ export class QueueService extends BaseService {
     this.services = services;
   }
 
-  async runCommand(name: QueueName, dto: QueueCommandDto): Promise<QueueResponseDto> {
+  async runCommandLegacy(name: QueueName, dto: QueueCommandDto): Promise<QueueResponseLegacyDto> {
     this.logger.debug(`Handling command: queue=${name},command=${dto.command},force=${dto.force}`);
 
     switch (dto.command) {
@@ -117,28 +131,60 @@ export class QueueService extends BaseService {
       }
     }
 
+    const response = await this.getByName(name);
+
+    return mapQueueLegacy(response);
+  }
+
+  async getAll(_auth: AuthDto): Promise<QueueResponseDto[]> {
+    return Promise.all(Object.values(QueueName).map((name) => this.getByName(name)));
+  }
+
+  async getAllLegacy(auth: AuthDto): Promise<QueuesResponseLegacyDto> {
+    const responses = await this.getAll(auth);
+    return mapQueuesLegacy(responses);
+  }
+
+  get(auth: AuthDto, name: QueueName): Promise<QueueResponseDto> {
     return this.getByName(name);
   }
 
-  async getAll(): Promise<QueuesResponseDto> {
-    const response = new QueuesResponseDto();
-    for (const name of Object.values(QueueName)) {
-      response[name] = await this.getByName(name);
+  async update(auth: AuthDto, name: QueueName, dto: QueueUpdateDto): Promise<QueueResponseDto> {
+    if (dto.isPaused === true) {
+      if (name === QueueName.BackgroundTask) {
+        throw new BadRequestException(`The BackgroundTask queue cannot be paused`);
+      }
+      await this.jobRepository.pause(name);
     }
-    return response;
+
+    if (dto.isPaused === false) {
+      await this.jobRepository.resume(name);
+    }
+
+    return this.getByName(name);
   }
 
-  async getByName(name: QueueName): Promise<QueueResponseDto> {
-    const [jobCounts, queueStatus] = await Promise.all([
-      this.jobRepository.getJobCounts(name),
-      this.jobRepository.getQueueStatus(name),
-    ]);
+  searchJobs(auth: AuthDto, name: QueueName, dto: QueueJobSearchDto): Promise<QueueJobResponseDto[]> {
+    return this.jobRepository.searchJobs(name, dto);
+  }
 
-    return { jobCounts, queueStatus };
+  async emptyQueue(auth: AuthDto, name: QueueName, dto: QueueDeleteDto) {
+    await this.jobRepository.empty(name);
+    if (dto.failed) {
+      await this.jobRepository.clear(name, QueueCleanType.Failed);
+    }
+  }
+
+  private async getByName(name: QueueName): Promise<QueueResponseDto> {
+    const [statistics, isPaused] = await Promise.all([
+      this.jobRepository.getJobCounts(name),
+      this.jobRepository.isPaused(name),
+    ]);
+    return { name, isPaused, statistics };
   }
 
   private async start(name: QueueName, { force }: QueueCommandDto): Promise<void> {
-    const { isActive } = await this.jobRepository.getQueueStatus(name);
+    const isActive = await this.jobRepository.isActive(name);
     if (isActive) {
       throw new BadRequestException(`Job is already running`);
     }

server/src/types.ts

@@ -291,11 +291,6 @@ export interface JobCounts {
   paused: number;
 }
 
-export interface QueueStatus {
-  isActive: boolean;
-  isPaused: boolean;
-}
-
 export type JobItem =
   // Audit
   | { name: JobName.AuditTableCleanup; data?: IBaseJob }

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

@@ -11,9 +11,11 @@ export const newJobRepositoryMock = (): Mocked<RepositoryInterface<JobRepository
     empty: vitest.fn(),
     pause: vitest.fn(),
     resume: vitest.fn(),
+    searchJobs: vitest.fn(),
     queue: vitest.fn().mockImplementation(() => Promise.resolve()),
     queueAll: vitest.fn().mockImplementation(() => Promise.resolve()),
-    getQueueStatus: vitest.fn(),
+    isActive: vitest.fn(),
+    isPaused: vitest.fn(),
     getJobCounts: vitest.fn(),
     clear: vitest.fn(),
     waitForQueueCompletion: vitest.fn(),

server/test/small.factory.ts

@@ -14,6 +14,7 @@ import {
 } from 'src/database';
 import { MapAsset } from 'src/dtos/asset-response.dto';
 import { AuthDto } from 'src/dtos/auth.dto';
+import { QueueStatisticsDto } from 'src/dtos/queue.dto';
 import { AssetStatus, AssetType, AssetVisibility, MemoryType, Permission, UserMetadataKey, UserStatus } from 'src/enum';
 import { OnThisDayData, UserMetadataItem } from 'src/types';
 import { v4, v7 } from 'uuid';
@@ -139,6 +140,16 @@ const sessionFactory = (session: Partial<Session> = {}) => ({
   ...session,
 });
 
+const queueStatisticsFactory = (dto?: Partial<QueueStatisticsDto>) => ({
+  active: 0,
+  completed: 0,
+  failed: 0,
+  delayed: 0,
+  waiting: 0,
+  paused: 0,
+  ...dto,
+});
+
 const stackFactory = () => ({
   id: newUuid(),
   ownerId: newUuid(),
@@ -353,6 +364,7 @@ export const factory = {
   library: libraryFactory,
   memory: memoryFactory,
   partner: partnerFactory,
+  queueStatistics: queueStatisticsFactory,
   session: sessionFactory,
   stack: stackFactory,
   user: userFactory,