feat: track upgrade history (#13097)

server/src/controllers/server.controller.ts

@@ -10,6 +10,7 @@ import {
   ServerStatsResponseDto,
   ServerStorageResponseDto,
   ServerThemeDto,
+  ServerVersionHistoryResponseDto,
   ServerVersionResponseDto,
 } from 'src/dtos/server.dto';
 import { Authenticated } from 'src/middleware/auth.guard';
@@ -46,6 +47,11 @@ export class ServerController {
     return this.versionService.getVersion();
   }
 
+  @Get('version-history')
+  getVersionHistory(): Promise<ServerVersionHistoryResponseDto[]> {
+    return this.versionService.getVersionHistory();
+  }
+
   @Get('features')
   getServerFeatures(): Promise<ServerFeaturesDto> {
     return this.service.getFeatures();

server/src/dtos/server.dto.ts

@@ -68,6 +68,12 @@ export class ServerVersionResponseDto {
   }
 }
 
+export class ServerVersionHistoryResponseDto {
+  id!: string;
+  createdAt!: Date;
+  version!: string;
+}
+
 export class UsageByUserDto {
   @ApiProperty({ type: 'string' })
   userId!: string;

server/src/entities/index.ts

@@ -25,6 +25,7 @@ import { SystemMetadataEntity } from 'src/entities/system-metadata.entity';
 import { TagEntity } from 'src/entities/tag.entity';
 import { UserMetadataEntity } from 'src/entities/user-metadata.entity';
 import { UserEntity } from 'src/entities/user.entity';
+import { VersionHistoryEntity } from 'src/entities/version-history.entity';
 
 export const entities = [
   ActivityEntity,
@@ -54,4 +55,5 @@ export const entities = [
   UserMetadataEntity,
   SessionEntity,
   LibraryEntity,
+  VersionHistoryEntity,
 ];

server/src/entities/version-history.entity.ts

@@ -0,0 +1,13 @@
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('version_history')
+export class VersionHistoryEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @Column()
+  version!: string;
+}

server/src/interfaces/database.interface.ts

@@ -17,6 +17,7 @@ export enum DatabaseLock {
   Migrations = 200,
   SystemFileMounts = 300,
   StorageTemplateMigration = 420,
+  VersionHistory = 500,
   CLIPDimSize = 512,
   LibraryWatch = 1337,
   GetSystemConfig = 69,

server/src/interfaces/version-history.interface.ts

@@ -0,0 +1,9 @@
+import { VersionHistoryEntity } from 'src/entities/version-history.entity';
+
+export const IVersionHistoryRepository = 'IVersionHistoryRepository';
+
+export interface IVersionHistoryRepository {
+  create(version: Omit<VersionHistoryEntity, 'id' | 'createdAt'>): Promise<VersionHistoryEntity>;
+  getAll(): Promise<VersionHistoryEntity[]>;
+  getLatest(): Promise<VersionHistoryEntity | null>;
+}

server/src/migrations/1727797340951-AddVersionHistory.ts

@@ -0,0 +1,14 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddVersionHistory1727797340951 implements MigrationInterface {
+    name = 'AddVersionHistory1727797340951'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "version_history" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "version" character varying NOT NULL, CONSTRAINT "PK_5db259cbb09ce82c0d13cfd1b23" PRIMARY KEY ("id"))`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`DROP TABLE "version_history"`);
+    }
+
+}

server/src/repositories/index.ts

@@ -32,6 +32,7 @@ import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interf
 import { ITagRepository } from 'src/interfaces/tag.interface';
 import { ITrashRepository } from 'src/interfaces/trash.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
+import { IVersionHistoryRepository } from 'src/interfaces/version-history.interface';
 import { IViewRepository } from 'src/interfaces/view.interface';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
@@ -67,6 +68,7 @@ import { SystemMetadataRepository } from 'src/repositories/system-metadata.repos
 import { TagRepository } from 'src/repositories/tag.repository';
 import { TrashRepository } from 'src/repositories/trash.repository';
 import { UserRepository } from 'src/repositories/user.repository';
+import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
 import { ViewRepository } from 'src/repositories/view-repository';
 
 export const repositories = [
@@ -104,5 +106,6 @@ export const repositories = [
   { provide: ITagRepository, useClass: TagRepository },
   { provide: ITrashRepository, useClass: TrashRepository },
   { provide: IUserRepository, useClass: UserRepository },
+  { provide: IVersionHistoryRepository, useClass: VersionHistoryRepository },
   { provide: IViewRepository, useClass: ViewRepository },
 ];

server/src/repositories/version-history.repository.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { VersionHistoryEntity } from 'src/entities/version-history.entity';
+import { IVersionHistoryRepository } from 'src/interfaces/version-history.interface';
+import { Instrumentation } from 'src/utils/instrumentation';
+import { Repository } from 'typeorm';
+
+@Instrumentation()
+@Injectable()
+export class VersionHistoryRepository implements IVersionHistoryRepository {
+  constructor(@InjectRepository(VersionHistoryEntity) private repository: Repository<VersionHistoryEntity>) {}
+
+  async getAll(): Promise<VersionHistoryEntity[]> {
+    return this.repository.find({ order: { createdAt: 'DESC' } });
+  }
+
+  async getLatest(): Promise<VersionHistoryEntity | null> {
+    const results = await this.repository.find({ order: { createdAt: 'DESC' }, take: 1 });
+    return results[0] || null;
+  }
+
+  create(version: Omit<VersionHistoryEntity, 'id' | 'createdAt'>): Promise<VersionHistoryEntity> {
+    return this.repository.save(version);
+  }
+}

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

@@ -1,17 +1,21 @@
 import { DateTime } from 'luxon';
 import { serverVersion } from 'src/constants';
 import { SystemMetadataKey } from 'src/enum';
+import { IDatabaseRepository } from 'src/interfaces/database.interface';
 import { IEventRepository } from 'src/interfaces/event.interface';
 import { IJobRepository, JobName, JobStatus } from 'src/interfaces/job.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IServerInfoRepository } from 'src/interfaces/server-info.interface';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
+import { IVersionHistoryRepository } from 'src/interfaces/version-history.interface';
 import { VersionService } from 'src/services/version.service';
+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 { newServerInfoRepositoryMock } from 'test/repositories/server-info.repository.mock';
 import { newSystemMetadataRepositoryMock } from 'test/repositories/system-metadata.repository.mock';
+import { newVersionHistoryRepositoryMock } from 'test/repositories/version-history.repository.mock';
 import { Mocked } from 'vitest';
 
 const mockRelease = (version: string) => ({
@@ -26,26 +30,47 @@ const mockRelease = (version: string) => ({
 
 describe(VersionService.name, () => {
   let sut: VersionService;
+  let databaseMock: Mocked<IDatabaseRepository>;
   let eventMock: Mocked<IEventRepository>;
   let jobMock: Mocked<IJobRepository>;
   let serverMock: Mocked<IServerInfoRepository>;
   let systemMock: Mocked<ISystemMetadataRepository>;
+  let versionMock: Mocked<IVersionHistoryRepository>;
   let loggerMock: Mocked<ILoggerRepository>;
 
   beforeEach(() => {
+    databaseMock = newDatabaseRepositoryMock();
     eventMock = newEventRepositoryMock();
     jobMock = newJobRepositoryMock();
     serverMock = newServerInfoRepositoryMock();
     systemMock = newSystemMetadataRepositoryMock();
+    versionMock = newVersionHistoryRepositoryMock();
     loggerMock = newLoggerRepositoryMock();
 
-    sut = new VersionService(eventMock, jobMock, serverMock, systemMock, loggerMock);
+    sut = new VersionService(databaseMock, eventMock, jobMock, serverMock, systemMock, versionMock, loggerMock);
   });
 
   it('should work', () => {
     expect(sut).toBeDefined();
   });
 
+  describe('onBootstrap', () => {
+    it('should record a new version', async () => {
+      await expect(sut.onBootstrap()).resolves.toBeUndefined();
+      expect(versionMock.create).toHaveBeenCalledWith({ version: expect.any(String) });
+    });
+
+    it('should skip a duplicate version', async () => {
+      versionMock.getLatest.mockResolvedValue({
+        id: 'version-1',
+        createdAt: new Date(),
+        version: serverVersion.toString(),
+      });
+      await expect(sut.onBootstrap()).resolves.toBeUndefined();
+      expect(versionMock.create).not.toHaveBeenCalled();
+    });
+  });
+
   describe('getVersion', () => {
     it('should respond the server version', () => {
       expect(sut.getVersion()).toEqual({
@@ -56,6 +81,14 @@ describe(VersionService.name, () => {
     });
   });
 
+  describe('getVersionHistory', () => {
+    it('should respond the server version history', async () => {
+      const upgrade = { id: 'upgrade-1', createdAt: new Date(), version: '1.0.0' };
+      versionMock.getAll.mockResolvedValue([upgrade]);
+      await expect(sut.getVersionHistory()).resolves.toEqual([upgrade]);
+    });
+  });
+
   describe('handQueueVersionCheck', () => {
     it('should queue a version check job', async () => {
       await expect(sut.handleQueueVersionCheck()).resolves.toBeUndefined();

server/src/services/version.service.ts

@@ -6,11 +6,13 @@ import { OnEvent } from 'src/decorators';
 import { ReleaseNotification, ServerVersionResponseDto } from 'src/dtos/server.dto';
 import { VersionCheckMetadata } from 'src/entities/system-metadata.entity';
 import { SystemMetadataKey } from 'src/enum';
+import { DatabaseLock, IDatabaseRepository } from 'src/interfaces/database.interface';
 import { ArgOf, IEventRepository } from 'src/interfaces/event.interface';
 import { IJobRepository, JobName, JobStatus } from 'src/interfaces/job.interface';
 import { ILoggerRepository } from 'src/interfaces/logger.interface';
 import { IServerInfoRepository } from 'src/interfaces/server-info.interface';
 import { ISystemMetadataRepository } from 'src/interfaces/system-metadata.interface';
+import { IVersionHistoryRepository } from 'src/interfaces/version-history.interface';
 import { BaseService } from 'src/services/base.service';
 
 const asNotification = ({ checkedAt, releaseVersion }: VersionCheckMetadata): ReleaseNotification => {
@@ -25,10 +27,12 @@ const asNotification = ({ checkedAt, releaseVersion }: VersionCheckMetadata): Re
 @Injectable()
 export class VersionService extends BaseService {
   constructor(
+    @Inject(IDatabaseRepository) private databaseRepository: IDatabaseRepository,
     @Inject(IEventRepository) private eventRepository: IEventRepository,
     @Inject(IJobRepository) private jobRepository: IJobRepository,
     @Inject(IServerInfoRepository) private repository: IServerInfoRepository,
     @Inject(ISystemMetadataRepository) systemMetadataRepository: ISystemMetadataRepository,
+    @Inject(IVersionHistoryRepository) private versionRepository: IVersionHistoryRepository,
     @Inject(ILoggerRepository) logger: ILoggerRepository,
   ) {
     super(systemMetadataRepository, logger);
@@ -38,12 +42,25 @@ export class VersionService extends BaseService {
   @OnEvent({ name: 'app.bootstrap' })
   async onBootstrap(): Promise<void> {
     await this.handleVersionCheck();
+
+    await this.databaseRepository.withLock(DatabaseLock.VersionHistory, async () => {
+      const latest = await this.versionRepository.getLatest();
+      const current = serverVersion.toString();
+      if (!latest || latest.version !== current) {
+        this.logger.log(`Version has changed, adding ${current} to history`);
+        await this.versionRepository.create({ version: current });
+      }
+    });
   }
 
   getVersion() {
     return ServerVersionResponseDto.fromSemVer(serverVersion);
   }
 
+  getVersionHistory() {
+    return this.versionRepository.getAll();
+  }
+
   async handleQueueVersionCheck() {
     await this.jobRepository.queue({ name: JobName.VERSION_CHECK, data: {} });
   }