fix: reset/regenerate memories (#16548)

fix: reset memories

server/src/migrations/1741027685381-ResetMemories.ts

@@ -0,0 +1,14 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class ResetMemories1741027685381 implements MigrationInterface {
+  name = 'ResetMemories1741027685381';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DELETE FROM "memories"`);
+    await queryRunner.query(`DELETE FROM "system_metadata" WHERE "key" = 'memories-state'`);
+  }
+
+  public async down(): Promise<void> {
+    // nothing to do
+  }
+}

server/src/services/version.service.ts

@@ -25,11 +25,24 @@ export class VersionService extends BaseService {
     await this.handleVersionCheck();
 
     await this.databaseRepository.withLock(DatabaseLock.VersionHistory, async () => {
-      const latest = await this.versionRepository.getLatest();
+      const previous = await this.versionRepository.getLatest();
       const current = serverVersion.toString();
-      if (!latest || latest.version !== current) {
-        this.logger.log(`Version has changed, adding ${current} to history`);
+
+      if (!previous) {
         await this.versionRepository.create({ version: current });
+        return;
+      }
+
+      if (previous.version !== current) {
+        const previousVersion = new SemVer(previous.version);
+
+        this.logger.log(`Adding ${current} to upgrade history`);
+        await this.versionRepository.create({ version: current });
+
+        const needsNewMemories = semver.lt(previousVersion, '1.129.0');
+        if (needsNewMemories) {
+          await this.jobRepository.queue({ name: JobName.MEMORIES_CREATE });
+        }
       }
     });
   }

server/test/factory.ts

@@ -10,6 +10,7 @@ import { PartnerRepository } from 'src/repositories/partner.repository';
 import { SessionRepository } from 'src/repositories/session.repository';
 import { SyncRepository } from 'src/repositories/sync.repository';
 import { UserRepository } from 'src/repositories/user.repository';
+import { VersionHistoryRepository } from 'src/repositories/version-history.repository';
 
 class CustomWritable extends Writable {
   private data = '';
@@ -162,6 +163,7 @@ export class TestContext {
   sessionRepository: SessionRepository;
   syncRepository: SyncRepository;
   partnerRepository: PartnerRepository;
+  versionHistoryRepository: VersionHistoryRepository;
 
   private constructor(private db: Kysely<DB>) {
     this.userRepository = new UserRepository(this.db);
@@ -170,6 +172,7 @@ export class TestContext {
     this.sessionRepository = new SessionRepository(this.db);
     this.syncRepository = new SyncRepository(this.db);
     this.partnerRepository = new PartnerRepository(this.db);
+    this.versionHistoryRepository = new VersionHistoryRepository(this.db);
   }
 
   static from(db: Kysely<DB>) {

server/test/medium/specs/version.service.spec.ts

@@ -0,0 +1,56 @@
+import { serverVersion } from 'src/constants';
+import { JobName } from 'src/enum';
+import { VersionService } from 'src/services/version.service';
+import { TestContext } from 'test/factory';
+import { getKyselyDB, newTestService } from 'test/utils';
+
+const setup = async () => {
+  const db = await getKyselyDB();
+  const context = await TestContext.from(db).create();
+  const { sut, mocks } = newTestService(VersionService, context);
+
+  return {
+    context,
+    sut,
+    jobMock: mocks.job,
+  };
+};
+
+describe(VersionService.name, () => {
+  describe.concurrent('onBootstrap', () => {
+    it('record the current version on startup', async () => {
+      const { context, sut } = await setup();
+
+      const itemsBefore = await context.versionHistoryRepository.getAll();
+      expect(itemsBefore).toHaveLength(0);
+
+      await sut.onBootstrap();
+
+      const itemsAfter = await context.versionHistoryRepository.getAll();
+      expect(itemsAfter).toHaveLength(1);
+      expect(itemsAfter[0]).toEqual({
+        createdAt: expect.any(Date),
+        id: expect.any(String),
+        version: serverVersion.toString(),
+      });
+    });
+
+    it('should queue memory creation when upgrading from 1.128.0', async () => {
+      const { context, jobMock, sut } = await setup();
+
+      await context.versionHistoryRepository.create({ version: 'v1.128.0' });
+      await sut.onBootstrap();
+
+      expect(jobMock.queue).toHaveBeenCalledWith({ name: JobName.MEMORIES_CREATE });
+    });
+
+    it('should not queue memory creation when upgrading from 1.129.0', async () => {
+      const { context, jobMock, sut } = await setup();
+
+      await context.versionHistoryRepository.create({ version: 'v1.129.0' });
+      await sut.onBootstrap();
+
+      expect(jobMock.queue).not.toHaveBeenCalled();
+    });
+  });
+});

server/test/utils.ts

@@ -97,6 +97,7 @@ type Overrides = {
   metadataRepository?: MetadataRepository;
   syncRepository?: SyncRepository;
   userRepository?: UserRepository;
+  versionHistoryRepository?: VersionHistoryRepository;
 };
 type BaseServiceArgs = ConstructorParameters<typeof BaseService>;
 type Constructor<Type, Args extends Array<any>> = {
@@ -151,7 +152,7 @@ export const newTestService = <T extends BaseService>(
   Service: Constructor<T, BaseServiceArgs>,
   overrides?: Overrides,
 ) => {
-  const { metadataRepository, userRepository, syncRepository } = overrides || {};
+  const { metadataRepository, userRepository, syncRepository, versionHistoryRepository } = overrides || {};
 
   const accessMock = newAccessRepositoryMock();
   const loggerMock = newLoggingRepositoryMock();
@@ -235,7 +236,8 @@ export const newTestService = <T extends BaseService>(
     telemetryMock as unknown as TelemetryRepository,
     trashMock as RepositoryInterface<TrashRepository> as TrashRepository,
     userMock as RepositoryInterface<UserRepository> as UserRepository,
-    versionHistoryMock as RepositoryInterface<VersionHistoryRepository> as VersionHistoryRepository,
+    versionHistoryRepository ||
+      (versionHistoryMock as RepositoryInterface<VersionHistoryRepository> as VersionHistoryRepository),
     viewMock as RepositoryInterface<ViewRepository> as ViewRepository,
   );