chore!: remove old timeline sync endpoints (#27804)

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

@@ -1,26 +0,0 @@
-import { JobStatus } from 'src/enum';
-import { AuditService } from 'src/services/audit.service';
-import { newTestService, ServiceMocks } from 'test/utils';
-
-describe(AuditService.name, () => {
-  let sut: AuditService;
-  let mocks: ServiceMocks;
-
-  beforeEach(() => {
-    ({ sut, mocks } = newTestService(AuditService));
-  });
-
-  it('should work', () => {
-    expect(sut).toBeDefined();
-  });
-
-  describe('handleCleanup', () => {
-    it('should delete old audit entries', async () => {
-      mocks.audit.removeBefore.mockResolvedValue();
-
-      await expect(sut.handleCleanup()).resolves.toBe(JobStatus.Success);
-
-      expect(mocks.audit.removeBefore).toHaveBeenCalledWith(expect.any(Date));
-    });
-  });
-});

server/src/services/audit.service.ts

@@ -1,15 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { DateTime } from 'luxon';
-import { AUDIT_LOG_MAX_DURATION } from 'src/constants';
-import { OnJob } from 'src/decorators';
-import { JobName, JobStatus, QueueName } from 'src/enum';
-import { BaseService } from 'src/services/base.service';
-
-@Injectable()
-export class AuditService extends BaseService {
-  @OnJob({ name: JobName.AuditLogCleanup, queue: QueueName.BackgroundTask })
-  async handleCleanup(): Promise<JobStatus> {
-    await this.auditRepository.removeBefore(DateTime.now().minus(AUDIT_LOG_MAX_DURATION).toJSDate());
-    return JobStatus.Success;
-  }
-}

server/src/services/base.service.ts

@@ -14,7 +14,6 @@ import { AppRepository } from 'src/repositories/app.repository';
 import { AssetEditRepository } from 'src/repositories/asset-edit.repository';
 import { AssetJobRepository } from 'src/repositories/asset-job.repository';
 import { AssetRepository } from 'src/repositories/asset.repository';
-import { AuditRepository } from 'src/repositories/audit.repository';
 import { ConfigRepository } from 'src/repositories/config.repository';
 import { CronRepository } from 'src/repositories/cron.repository';
 import { CryptoRepository } from 'src/repositories/crypto.repository';
@@ -72,7 +71,6 @@ export const BASE_SERVICE_DEPENDENCIES = [
   AssetRepository,
   AssetEditRepository,
   AssetJobRepository,
-  AuditRepository,
   ConfigRepository,
   CronRepository,
   CryptoRepository,
@@ -131,7 +129,6 @@ export class BaseService {
     protected assetRepository: AssetRepository,
     protected assetEditRepository: AssetEditRepository,
     protected assetJobRepository: AssetJobRepository,
-    protected auditRepository: AuditRepository,
     protected configRepository: ConfigRepository,
     protected cronRepository: CronRepository,
     protected cryptoRepository: CryptoRepository,

server/src/services/index.ts

@@ -4,7 +4,6 @@ import { ApiKeyService } from 'src/services/api-key.service';
 import { ApiService } from 'src/services/api.service';
 import { AssetMediaService } from 'src/services/asset-media.service';
 import { AssetService } from 'src/services/asset.service';
-import { AuditService } from 'src/services/audit.service';
 import { AuthAdminService } from 'src/services/auth-admin.service';
 import { AuthService } from 'src/services/auth.service';
 import { CliService } from 'src/services/cli.service';
@@ -54,7 +53,6 @@ export const services = [
   ApiService,
   AssetMediaService,
   AssetService,
-  AuditService,
   AuthService,
   AuthAdminService,
   CliService,

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

@@ -42,7 +42,6 @@ describe(QueueService.name, () => {
         { name: JobName.MemoryCleanup },
         { name: JobName.SessionCleanup },
         { name: JobName.AuditTableCleanup },
-        { name: JobName.AuditLogCleanup },
         { name: JobName.MemoryGenerate },
         { name: JobName.UserSyncUsage },
         { name: JobName.AssetGenerateThumbnailsQueueAll, data: { force: false } },

server/src/services/queue.service.ts

@@ -270,7 +270,6 @@ export class QueueService extends BaseService {
         { name: JobName.MemoryCleanup },
         { name: JobName.SessionCleanup },
         { name: JobName.AuditTableCleanup },
-        { name: JobName.AuditLogCleanup },
       );
     }
 

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

@@ -1,98 +0,0 @@
-import { mapAsset } from 'src/dtos/asset-response.dto';
-import { SyncService } from 'src/services/sync.service';
-import { AssetFactory } from 'test/factories/asset.factory';
-import { PartnerFactory } from 'test/factories/partner.factory';
-import { authStub } from 'test/fixtures/auth.stub';
-import { getForAsset, getForPartner } from 'test/mappers';
-import { factory } from 'test/small.factory';
-import { newTestService, ServiceMocks } from 'test/utils';
-
-const untilDate = new Date(2024);
-const mapAssetOpts = { auth: authStub.user1, stripMetadata: false, withStack: true };
-
-describe(SyncService.name, () => {
-  let sut: SyncService;
-  let mocks: ServiceMocks;
-
-  beforeEach(() => {
-    ({ sut, mocks } = newTestService(SyncService));
-  });
-
-  it('should exist', () => {
-    expect(sut).toBeDefined();
-  });
-
-  describe('getAllAssetsForUserFullSync', () => {
-    it('should return a list of all assets owned by the user', async () => {
-      const [asset1, asset2] = [
-        AssetFactory.from({ libraryId: 'library-id', isExternal: true }).owner(authStub.user1.user).build(),
-        AssetFactory.from().owner(authStub.user1.user).build(),
-      ];
-      mocks.asset.getAllForUserFullSync.mockResolvedValue([getForAsset(asset1), getForAsset(asset2)]);
-      await expect(sut.getFullSync(authStub.user1, { limit: 2, updatedUntil: untilDate })).resolves.toEqual([
-        mapAsset(getForAsset(asset1), mapAssetOpts),
-        mapAsset(getForAsset(asset2), mapAssetOpts),
-      ]);
-      expect(mocks.asset.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 () => {
-      const partner = PartnerFactory.create();
-      const auth = factory.auth({ user: { id: partner.sharedWithId } });
-
-      mocks.partner.getAll.mockResolvedValue([getForPartner(partner)]);
-
-      await expect(
-        sut.getDeltaSync(authStub.user1, { updatedAfter: new Date(), userIds: [auth.user.id] }),
-      ).resolves.toEqual({ needsFullSync: true, upserted: [], deleted: [] });
-
-      expect(mocks.asset.getChangedDeltaSync).toHaveBeenCalledTimes(0);
-      expect(mocks.audit.getAfter).toHaveBeenCalledTimes(0);
-    });
-
-    it('should return a response requiring a full sync when last sync was too long ago', async () => {
-      mocks.partner.getAll.mockResolvedValue([]);
-      await expect(
-        sut.getDeltaSync(authStub.user1, { updatedAfter: new Date(2000), userIds: [authStub.user1.user.id] }),
-      ).resolves.toEqual({ needsFullSync: true, upserted: [], deleted: [] });
-      expect(mocks.asset.getChangedDeltaSync).toHaveBeenCalledTimes(0);
-      expect(mocks.audit.getAfter).toHaveBeenCalledTimes(0);
-    });
-
-    it('should return a response requiring a full sync when there are too many changes', async () => {
-      const asset = AssetFactory.create();
-      mocks.partner.getAll.mockResolvedValue([]);
-      mocks.asset.getChangedDeltaSync.mockResolvedValue(
-        Array.from<ReturnType<typeof getForAsset>>({ length: 10_000 }).fill(getForAsset(asset)),
-      );
-      await expect(
-        sut.getDeltaSync(authStub.user1, { updatedAfter: new Date(), userIds: [authStub.user1.user.id] }),
-      ).resolves.toEqual({ needsFullSync: true, upserted: [], deleted: [] });
-      expect(mocks.asset.getChangedDeltaSync).toHaveBeenCalledTimes(1);
-      expect(mocks.audit.getAfter).toHaveBeenCalledTimes(0);
-    });
-
-    it('should return a response with changes and deletions', async () => {
-      const asset = AssetFactory.create({ ownerId: authStub.user1.user.id });
-      const deletedAsset = AssetFactory.create({ libraryId: 'library-id', isExternal: true });
-      mocks.partner.getAll.mockResolvedValue([]);
-      mocks.asset.getChangedDeltaSync.mockResolvedValue([getForAsset(asset)]);
-      mocks.audit.getAfter.mockResolvedValue([deletedAsset.id]);
-      await expect(
-        sut.getDeltaSync(authStub.user1, { updatedAfter: new Date(), userIds: [authStub.user1.user.id] }),
-      ).resolves.toEqual({
-        needsFullSync: false,
-        upserted: [mapAsset(getForAsset(asset), mapAssetOpts)],
-        deleted: [deletedAsset.id],
-      });
-      expect(mocks.asset.getChangedDeltaSync).toHaveBeenCalledTimes(1);
-      expect(mocks.audit.getAfter).toHaveBeenCalledTimes(1);
-    });
-  });
-});

server/src/services/sync.service.ts

@@ -2,14 +2,9 @@ import { BadRequestException, ForbiddenException, Injectable } from '@nestjs/com
 import { Insertable } from 'kysely';
 import { DateTime, Duration } from 'luxon';
 import { Writable } from 'node:stream';
-import { AUDIT_LOG_MAX_DURATION } from 'src/constants';
 import { OnJob } from 'src/decorators';
-import { AssetResponseDto, mapAsset } from 'src/dtos/asset-response.dto';
 import { AuthDto } from 'src/dtos/auth.dto';
 import {
-  AssetDeltaSyncDto,
-  AssetDeltaSyncResponseDto,
-  AssetFullSyncDto,
   SyncAckDeleteDto,
   SyncAckSetDto,
   syncAssetFaceV2ToV1,
@@ -17,23 +12,12 @@ import {
   SyncItem,
   SyncStreamDto,
 } from 'src/dtos/sync.dto';
-import {
-  AssetVisibility,
-  DatabaseAction,
-  EntityType,
-  JobName,
-  Permission,
-  QueueName,
-  SyncEntityType,
-  SyncRequestType,
-} from 'src/enum';
+import { JobName, QueueName, SyncEntityType, SyncRequestType } from 'src/enum';
 import { SyncQueryOptions } from 'src/repositories/sync.repository';
 import { SessionSyncCheckpointTable } from 'src/schema/tables/sync-checkpoint.table';
 import { BaseService } from 'src/services/base.service';
 import { SyncAck } from 'src/types';
-import { getMyPartnerIds } from 'src/utils/asset.util';
 import { hexOrBufferToBase64 } from 'src/utils/bytes';
-import { setIsEqual } from 'src/utils/set';
 import { fromAck, serialize, SerializeOptions, toAck } from 'src/utils/sync';
 
 type CheckpointMap = Partial<Record<SyncEntityType, SyncAck>>;
@@ -66,7 +50,6 @@ const sendEntityBackfillCompleteAck = (response: Writable, ackType: SyncEntityTy
   send(response, { type: SyncEntityType.SyncAckV1, data: {}, ackType, ids: [id, COMPLETE_ID] });
 };
 
-const FULL_SYNC = { needsFullSync: true, deleted: [], upserted: [] };
 export const SYNC_TYPES_ORDER = [
   SyncRequestType.AuthUsersV1,
   SyncRequestType.UsersV1,
@@ -887,68 +870,4 @@ export class SyncService extends BaseService {
       },
     ]);
   }
-
-  async getFullSync(auth: AuthDto, dto: AssetFullSyncDto): Promise<AssetResponseDto[]> {
-    // mobile implementation is faster if this is a single id
-    const userId = dto.userId || auth.user.id;
-    await this.requireAccess({ auth, permission: Permission.TimelineRead, ids: [userId] });
-    const assets = await this.assetRepository.getAllForUserFullSync({
-      ownerId: userId,
-      updatedUntil: dto.updatedUntil,
-      lastId: dto.lastId,
-      limit: dto.limit,
-    });
-    return assets.map((a) => mapAsset(a, { auth, stripMetadata: false, withStack: true }));
-  }
-
-  async getDeltaSync(auth: AuthDto, dto: AssetDeltaSyncDto): Promise<AssetDeltaSyncResponseDto> {
-    // app has not synced in the last 100 days
-    const duration = DateTime.now().diff(DateTime.fromJSDate(dto.updatedAfter));
-    if (duration > AUDIT_LOG_MAX_DURATION) {
-      return FULL_SYNC;
-    }
-
-    // app does not have the correct partners synced
-    const partnerIds = await getMyPartnerIds({ userId: auth.user.id, repository: this.partnerRepository });
-    const userIds = [auth.user.id, ...partnerIds];
-    if (!setIsEqual(new Set(userIds), new Set(dto.userIds))) {
-      return FULL_SYNC;
-    }
-
-    await this.requireAccess({ auth, permission: Permission.TimelineRead, ids: dto.userIds });
-
-    const limit = 10_000;
-    const upserted = await this.assetRepository.getChangedDeltaSync({ limit, updatedAfter: dto.updatedAfter, userIds });
-
-    // too many changes, need to do a full sync
-    if (upserted.length === limit) {
-      return FULL_SYNC;
-    }
-
-    const deleted = await this.auditRepository.getAfter(dto.updatedAfter, {
-      userIds,
-      entityType: EntityType.Asset,
-      action: DatabaseAction.Delete,
-    });
-
-    const result = {
-      needsFullSync: false,
-      upserted: upserted
-        // do not return archived assets for partner users
-        .filter(
-          (a) =>
-            a.ownerId === auth.user.id || (a.ownerId !== auth.user.id && a.visibility === AssetVisibility.Timeline),
-        )
-        .map((a) =>
-          mapAsset(a, {
-            auth,
-            stripMetadata: false,
-            // ignore stacks for non partner users
-            withStack: a.ownerId === auth.user.id,
-          }),
-        ),
-      deleted,
-    };
-    return result;
-  }
 }