merge: remote-tracking branch 'immich/main' into feat/integrity-checks-izzy

2026-02-13 04:17:56 +03:00 · 2026-01-06 14:19:34 +00:00
parent 7e1e283710 006d02cfaf
commit c4c5358ef7
368 changed files with 18243 additions and 6152 deletions
--- a/server/test/fixtures/asset.stub.ts
+++ b/server/test/fixtures/asset.stub.ts
@@ -65,6 +65,9 @@ export const assetStub = {
    originalFileName: 'IMG_123.jpg',
    fileSizeInByte: 12_345,
    files: [],
+    make: 'FUJIFILM',
+    model: 'X-T50',
+    lensModel: 'XF27mm F2.8 R WR',
    ...asset,
  }),
  noResizePath: Object.freeze({
--- a/server/test/fixtures/shared-link.stub.ts
+++ b/server/test/fixtures/shared-link.stub.ts
@@ -1,10 +1,7 @@
 import { UserAdmin } from 'src/database';
-import { AlbumResponseDto } from 'src/dtos/album.dto';
-import { AssetResponseDto, MapAsset } from 'src/dtos/asset-response.dto';
-import { ExifResponseDto } from 'src/dtos/exif.dto';
+import { MapAsset } from 'src/dtos/asset-response.dto';
 import { SharedLinkResponseDto } from 'src/dtos/shared-link.dto';
-import { mapUser } from 'src/dtos/user.dto';
-import { AssetOrder, AssetStatus, AssetType, AssetVisibility, SharedLinkType } from 'src/enum';
+import { AssetStatus, AssetType, AssetVisibility, SharedLinkType } from 'src/enum';
 import { assetStub } from 'test/fixtures/asset.stub';
 import { authStub } from 'test/fixtures/auth.stub';
 import { userStub } from 'test/fixtures/user.stub';
@@ -20,89 +17,6 @@ const sharedLinkBytes = Buffer.from(
  'hex',
 );

-const assetInfo: ExifResponseDto = {
-  make: 'camera-make',
-  model: 'camera-model',
-  exifImageWidth: 500,
-  exifImageHeight: 500,
-  fileSizeInByte: 100,
-  orientation: 'orientation',
-  dateTimeOriginal: today,
-  modifyDate: today,
-  timeZone: 'America/Los_Angeles',
-  lensModel: 'fancy',
-  fNumber: 100,
-  focalLength: 100,
-  iso: 100,
-  exposureTime: '1/16',
-  latitude: 100,
-  longitude: 100,
-  city: 'city',
-  state: 'state',
-  country: 'country',
-  description: 'description',
-  projectionType: null,
-};
-
-const assetResponse: AssetResponseDto = {
-  id: 'id_1',
-  createdAt: today,
-  deviceAssetId: 'device_asset_id_1',
-  ownerId: 'user_id_1',
-  deviceId: 'device_id_1',
-  type: AssetType.Video,
-  originalMimeType: 'image/jpeg',
-  originalPath: 'fake_path/jpeg',
-  originalFileName: 'asset_1.jpeg',
-  thumbhash: null,
-  fileModifiedAt: today,
-  isOffline: false,
-  fileCreatedAt: today,
-  localDateTime: today,
-  updatedAt: today,
-  isFavorite: false,
-  isArchived: false,
-  duration: '0:00:00.00000',
-  exifInfo: assetInfo,
-  livePhotoVideoId: null,
-  tags: [],
-  people: [],
-  checksum: 'ZmlsZSBoYXNo',
-  isTrashed: false,
-  libraryId: 'library-id',
-  hasMetadata: true,
-  visibility: AssetVisibility.Timeline,
-};
-
-const assetResponseWithoutMetadata = {
-  id: 'id_1',
-  type: AssetType.Video,
-  originalMimeType: 'image/jpeg',
-  thumbhash: null,
-  localDateTime: today,
-  duration: '0:00:00.00000',
-  livePhotoVideoId: null,
-  hasMetadata: false,
-} as AssetResponseDto;
-
-const albumResponse: AlbumResponseDto = {
-  albumName: 'Test Album',
-  description: '',
-  albumThumbnailAssetId: null,
-  createdAt: today,
-  updatedAt: today,
-  id: 'album-123',
-  ownerId: 'admin_id',
-  owner: mapUser(userStub.admin),
-  albumUsers: [],
-  shared: false,
-  hasSharedLink: false,
-  assets: [],
-  assetCount: 1,
-  isActivityEnabled: true,
-  order: AssetOrder.Desc,
-};
-
 export const sharedLinkStub = {
  individual: Object.freeze({
    id: '123',
@@ -161,7 +75,7 @@ export const sharedLinkStub = {
    id: '123',
    userId: authStub.admin.user.id,
    key: sharedLinkBytes,
-    type: SharedLinkType.Album,
+    type: SharedLinkType.Individual,
    createdAt: today,
    expiresAt: tomorrow,
    allowUpload: false,
@@ -169,97 +83,80 @@ export const sharedLinkStub = {
    showExif: false,
    description: null,
    password: null,
-    assets: [],
-    slug: null,
-    albumId: 'album-123',
-    album: {
-      id: 'album-123',
-      updateId: '42',
-      ownerId: authStub.admin.user.id,
-      owner: userStub.admin,
-      albumName: 'Test Album',
-      description: '',
-      createdAt: today,
-      updatedAt: today,
-      deletedAt: null,
-      albumThumbnailAsset: null,
-      albumThumbnailAssetId: null,
-      albumUsers: [],
-      sharedLinks: [],
-      isActivityEnabled: true,
-      order: AssetOrder.Desc,
-      assets: [
-        {
-          id: 'id_1',
-          status: AssetStatus.Active,
-          owner: undefined as unknown as UserAdmin,
-          ownerId: 'user_id_1',
-          deviceAssetId: 'device_asset_id_1',
-          deviceId: 'device_id_1',
-          type: AssetType.Video,
-          originalPath: 'fake_path/jpeg',
-          checksum: Buffer.from('file hash', 'utf8'),
-          fileModifiedAt: today,
-          fileCreatedAt: today,
-          localDateTime: today,
-          createdAt: today,
+    assets: [
+      {
+        id: 'id_1',
+        status: AssetStatus.Active,
+        owner: undefined as unknown as UserAdmin,
+        ownerId: 'user_id_1',
+        deviceAssetId: 'device_asset_id_1',
+        deviceId: 'device_id_1',
+        type: AssetType.Video,
+        originalPath: 'fake_path/jpeg',
+        checksum: Buffer.from('file hash', 'utf8'),
+        fileModifiedAt: today,
+        fileCreatedAt: today,
+        localDateTime: today,
+        createdAt: today,
+        updatedAt: today,
+        isFavorite: false,
+        isArchived: false,
+        isExternal: false,
+        isOffline: false,
+        files: [],
+        thumbhash: null,
+        encodedVideoPath: '',
+        duration: null,
+        livePhotoVideo: null,
+        livePhotoVideoId: null,
+        originalFileName: 'asset_1.jpeg',
+        exifInfo: {
+          projectionType: null,
+          livePhotoCID: null,
+          assetId: 'id_1',
+          description: 'description',
+          exifImageWidth: 500,
+          exifImageHeight: 500,
+          fileSizeInByte: 100,
+          orientation: 'orientation',
+          dateTimeOriginal: today,
+          modifyDate: today,
+          timeZone: 'America/Los_Angeles',
+          latitude: 100,
+          longitude: 100,
+          city: 'city',
+          state: 'state',
+          country: 'country',
+          make: 'camera-make',
+          model: 'camera-model',
+          lensModel: 'fancy',
+          fNumber: 100,
+          focalLength: 100,
+          iso: 100,
+          exposureTime: '1/16',
+          fps: 100,
+          profileDescription: 'sRGB',
+          bitsPerSample: 8,
+          colorspace: 'sRGB',
+          autoStackId: null,
+          rating: 3,
          updatedAt: today,
-          isFavorite: false,
-          isArchived: false,
-          isExternal: false,
-          isOffline: false,
-          files: [],
-          thumbhash: null,
-          encodedVideoPath: '',
-          duration: null,
-          livePhotoVideo: null,
-          livePhotoVideoId: null,
-          originalFileName: 'asset_1.jpeg',
-          exifInfo: {
-            projectionType: null,
-            livePhotoCID: null,
-            assetId: 'id_1',
-            description: 'description',
-            exifImageWidth: 500,
-            exifImageHeight: 500,
-            fileSizeInByte: 100,
-            orientation: 'orientation',
-            dateTimeOriginal: today,
-            modifyDate: today,
-            timeZone: 'America/Los_Angeles',
-            latitude: 100,
-            longitude: 100,
-            city: 'city',
-            state: 'state',
-            country: 'country',
-            make: 'camera-make',
-            model: 'camera-model',
-            lensModel: 'fancy',
-            fNumber: 100,
-            focalLength: 100,
-            iso: 100,
-            exposureTime: '1/16',
-            fps: 100,
-            profileDescription: 'sRGB',
-            bitsPerSample: 8,
-            colorspace: 'sRGB',
-            autoStackId: null,
-            rating: 3,
-            updatedAt: today,
-            updateId: '42',
-          },
-          sharedLinks: [],
-          faces: [],
-          sidecarPath: null,
-          deletedAt: null,
-          duplicateId: null,
          updateId: '42',
-          libraryId: null,
-          stackId: null,
-          visibility: AssetVisibility.Timeline,
        },
-      ],
-    },
+        sharedLinks: [],
+        faces: [],
+        sidecarPath: null,
+        deletedAt: null,
+        duplicateId: null,
+        updateId: '42',
+        libraryId: null,
+        stackId: null,
+        visibility: AssetVisibility.Timeline,
+      },
+    ],
+    albumId: null,
+    album: null,
+    slug: null,
  }),
  passwordRequired: Object.freeze({
    id: '123',
@@ -312,20 +209,4 @@ export const sharedLinkResponseStub = {
    userId: 'admin_id',
    slug: null,
  }),
-  readonlyNoMetadata: Object.freeze<SharedLinkResponseDto>({
-    id: '123',
-    userId: 'admin_id',
-    key: sharedLinkBytes.toString('base64url'),
-    type: SharedLinkType.Album,
-    createdAt: today,
-    expiresAt: tomorrow,
-    description: null,
-    password: null,
-    allowUpload: false,
-    allowDownload: false,
-    showMetadata: false,
-    slug: null,
-    album: { ...albumResponse, startDate: assetResponse.localDateTime, endDate: assetResponse.localDateTime },
-    assets: [{ ...assetResponseWithoutMetadata, exifInfo: undefined }],
-  }),
 };
--- a/server/test/medium.factory.ts
+++ b/server/test/medium.factory.ts
@@ -202,7 +202,7 @@ export class MediumTestContext<S extends BaseService = BaseService> {
  }

  async newExif(dto: Insertable<AssetExifTable>) {
-    const result = await this.get(AssetRepository).upsertExif(dto);
+    const result = await this.get(AssetRepository).upsertExif(dto, { lockedPropertiesBehavior: 'override' });
    return { result };
  }

--- a/server/test/medium/specs/repositories/asset.repository.spec.ts
+++ b/server/test/medium/specs/repositories/asset.repository.spec.ts
@@ -0,0 +1,90 @@
+import { Kysely } from 'kysely';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { LoggingRepository } from 'src/repositories/logging.repository';
+import { DB } from 'src/schema';
+import { BaseService } from 'src/services/base.service';
+import { newMediumService } from 'test/medium.factory';
+import { getKyselyDB } from 'test/utils';
+
+let defaultDatabase: Kysely<DB>;
+
+const setup = (db?: Kysely<DB>) => {
+  const { ctx } = newMediumService(BaseService, {
+    database: db || defaultDatabase,
+    real: [],
+    mock: [LoggingRepository],
+  });
+  return { ctx, sut: ctx.get(AssetRepository) };
+};
+
+beforeAll(async () => {
+  defaultDatabase = await getKyselyDB();
+});
+
+describe(AssetRepository.name, () => {
+  describe('upsertExif', () => {
+    it('should append to locked columns', async () => {
+      const { ctx, sut } = setup();
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({
+        assetId: asset.id,
+        dateTimeOriginal: '2023-11-19T18:11:00',
+        lockedProperties: ['dateTimeOriginal'],
+      });
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({ lockedProperties: ['dateTimeOriginal'] });
+
+      await sut.upsertExif(
+        { assetId: asset.id, lockedProperties: ['description'] },
+        { lockedPropertiesBehavior: 'append' },
+      );
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({ lockedProperties: ['description', 'dateTimeOriginal'] });
+    });
+
+    it('should deduplicate locked columns', async () => {
+      const { ctx, sut } = setup();
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({
+        assetId: asset.id,
+        dateTimeOriginal: '2023-11-19T18:11:00',
+        lockedProperties: ['dateTimeOriginal', 'description'],
+      });
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({ lockedProperties: ['dateTimeOriginal', 'description'] });
+
+      await sut.upsertExif(
+        { assetId: asset.id, lockedProperties: ['description'] },
+        { lockedPropertiesBehavior: 'append' },
+      );
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({ lockedProperties: ['description', 'dateTimeOriginal'] });
+    });
+  });
+});
--- a/server/test/medium/specs/services/asset.service.spec.ts
+++ b/server/test/medium/specs/services/asset.service.spec.ts
@@ -268,4 +268,166 @@ describe(AssetService.name, () => {
      });
    });
  });
+
+  describe('update', () => {
+    it('should automatically lock lockable columns', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queue.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, dateTimeOriginal: '2023-11-19T18:11:00' });
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({ lockedProperties: null });
+
+      await sut.update(auth, asset.id, {
+        latitude: 42,
+        longitude: 42,
+        rating: 3,
+        description: 'foo',
+        dateTimeOriginal: '2023-11-19T18:11:00+01:00',
+      });
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({
+        lockedProperties: ['timeZone', 'rating', 'description', 'latitude', 'longitude', 'dateTimeOriginal'],
+      });
+    });
+
+    it('should update dateTimeOriginal', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queue.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, description: 'test' });
+
+      await sut.update(auth, asset.id, { dateTimeOriginal: '2023-11-19T18:11:00' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({ dateTimeOriginal: '2023-11-19T18:11:00+00:00', timeZone: null }),
+        }),
+      );
+    });
+
+    it('should update dateTimeOriginal with time zone', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queue.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, description: 'test' });
+
+      await sut.update(auth, asset.id, { dateTimeOriginal: '2023-11-19T18:11:00.000-07:00' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({ dateTimeOriginal: '2023-11-20T01:11:00+00:00', timeZone: 'UTC-7' }),
+        }),
+      );
+    });
+  });
+
+  describe('updateAll', () => {
+    it('should automatically lock lockable columns', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, dateTimeOriginal: '2023-11-19T18:11:00' });
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({ lockedProperties: null });
+
+      await sut.updateAll(auth, {
+        ids: [asset.id],
+        latitude: 42,
+        description: 'foo',
+        longitude: 42,
+        rating: 3,
+        dateTimeOriginal: '2023-11-19T18:11:00+01:00',
+      });
+
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select('lockedProperties')
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({
+        lockedProperties: ['timeZone', 'rating', 'description', 'latitude', 'longitude', 'dateTimeOriginal'],
+      });
+    });
+
+    it('should relatively update assets', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, dateTimeOriginal: '2023-11-19T18:11:00' });
+
+      await sut.updateAll(auth, { ids: [asset.id], dateTimeRelative: -11 });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({
+            dateTimeOriginal: '2023-11-19T18:00:00+00:00',
+          }),
+        }),
+      );
+    });
+
+    it('should update dateTimeOriginal', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, description: 'test' });
+
+      await sut.updateAll(auth, { ids: [asset.id], dateTimeOriginal: '2023-11-19T18:11:00' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({ dateTimeOriginal: '2023-11-19T18:11:00+00:00', timeZone: null }),
+        }),
+      );
+    });
+
+    it('should update dateTimeOriginal with time zone', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, description: 'test' });
+
+      await sut.updateAll(auth, { ids: [asset.id], dateTimeOriginal: '2023-11-19T18:11:00.000-07:00' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({ dateTimeOriginal: '2023-11-20T01:11:00+00:00', timeZone: 'UTC-7' }),
+        }),
+      );
+    });
+  });
 });
--- a/server/test/medium/specs/services/metadata.service.spec.ts
+++ b/server/test/medium/specs/services/metadata.service.spec.ts
@@ -95,6 +95,7 @@ describe(MetadataService.name, () => {
          dateTimeOriginal: new Date(expected.dateTimeOriginal),
          timeZone: expected.timeZone,
        }),
+        { lockedPropertiesBehavior: 'skip' },
      );

      expect(mocks.asset.update).toHaveBeenCalledWith(
--- a/server/test/medium/specs/services/search.service.spec.ts
+++ b/server/test/medium/specs/services/search.service.spec.ts
@@ -1,5 +1,6 @@
 import { Kysely } from 'kysely';
 import { AccessRepository } from 'src/repositories/access.repository';
+import { AssetRepository } from 'src/repositories/asset.repository';
 import { DatabaseRepository } from 'src/repositories/database.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { PartnerRepository } from 'src/repositories/partner.repository';
@@ -16,7 +17,14 @@ let defaultDatabase: Kysely<DB>;
 const setup = (db?: Kysely<DB>) => {
  return newMediumService(SearchService, {
    database: db || defaultDatabase,
-    real: [AccessRepository, DatabaseRepository, SearchRepository, PartnerRepository, PersonRepository],
+    real: [
+      AccessRepository,
+      AssetRepository,
+      DatabaseRepository,
+      SearchRepository,
+      PartnerRepository,
+      PersonRepository,
+    ],
    mock: [LoggingRepository],
  });
 };
@@ -52,4 +60,32 @@ describe(SearchService.name, () => {
      expect.objectContaining({ id: assets[1].id }),
    ]);
  });
+
+  describe('searchStatistics', () => {
+    it('should return statistics when filtering by personIds', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      await ctx.newAssetFace({ assetId: asset.id, personId: person.id });
+
+      const auth = factory.auth({ user: { id: user.id } });
+
+      const result = await sut.searchStatistics(auth, { personIds: [person.id] });
+
+      expect(result).toEqual({ total: 1 });
+    });
+
+    it('should return zero when no assets match the personIds filter', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+
+      const auth = factory.auth({ user: { id: user.id } });
+
+      const result = await sut.searchStatistics(auth, { personIds: [person.id] });
+
+      expect(result).toEqual({ total: 0 });
+    });
+  });
 });
--- a/server/test/medium/specs/services/workflow.service.spec.ts
+++ b/server/test/medium/specs/services/workflow.service.spec.ts
@@ -611,6 +611,100 @@ describe(WorkflowService.name, () => {
        sut.update(auth, created.id, { actions: [{ pluginActionId: factory.uuid(), actionConfig: {} }] }),
      ).rejects.toThrow();
    });
+
+    it('should update trigger type', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+
+      const created = await sut.create(auth, {
+        triggerType: PluginTriggerType.PersonRecognized,
+        name: 'test-workflow',
+        description: 'Test',
+        enabled: true,
+        filters: [],
+        actions: [],
+      });
+
+      await sut.update(auth, created.id, {
+        triggerType: PluginTriggerType.AssetCreate,
+      });
+
+      const fetched = await sut.get(auth, created.id);
+      expect(fetched.triggerType).toBe(PluginTriggerType.AssetCreate);
+    });
+
+    it('should add filters', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+
+      const created = await sut.create(auth, {
+        triggerType: PluginTriggerType.AssetCreate,
+        name: 'test-workflow',
+        description: 'Test',
+        enabled: true,
+        filters: [],
+        actions: [],
+      });
+
+      await sut.update(auth, created.id, {
+        filters: [
+          { pluginFilterId: testFilterId, filterConfig: { first: true } },
+          { pluginFilterId: testFilterId, filterConfig: { second: true } },
+        ],
+      });
+
+      const fetched = await sut.get(auth, created.id);
+      expect(fetched.filters).toHaveLength(2);
+      expect(fetched.filters[0].filterConfig).toEqual({ first: true });
+      expect(fetched.filters[1].filterConfig).toEqual({ second: true });
+    });
+
+    it('should replace existing filters', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+
+      const created = await sut.create(auth, {
+        triggerType: PluginTriggerType.AssetCreate,
+        name: 'test-workflow',
+        description: 'Test',
+        enabled: true,
+        filters: [{ pluginFilterId: testFilterId, filterConfig: { original: true } }],
+        actions: [],
+      });
+
+      await sut.update(auth, created.id, {
+        filters: [{ pluginFilterId: testFilterId, filterConfig: { replaced: true } }],
+      });
+
+      const fetched = await sut.get(auth, created.id);
+      expect(fetched.filters).toHaveLength(1);
+      expect(fetched.filters[0].filterConfig).toEqual({ replaced: true });
+    });
+
+    it('should remove existing filters', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+
+      const created = await sut.create(auth, {
+        triggerType: PluginTriggerType.AssetCreate,
+        name: 'test-workflow',
+        description: 'Test',
+        enabled: true,
+        filters: [{ pluginFilterId: testFilterId, filterConfig: { toRemove: true } }],
+        actions: [],
+      });
+
+      await sut.update(auth, created.id, {
+        filters: [],
+      });
+
+      const fetched = await sut.get(auth, created.id);
+      expect(fetched.filters).toHaveLength(0);
+    });
  });

  describe('delete', () => {
--- a/server/test/medium/specs/sync/sync-album-asset-exif.spec.ts
+++ b/server/test/medium/specs/sync/sync-album-asset-exif.spec.ts
@@ -2,6 +2,7 @@ import { Kysely } from 'kysely';
 import { AlbumUserRole, SyncEntityType, SyncRequestType } from 'src/enum';
 import { AssetRepository } from 'src/repositories/asset.repository';
 import { DB } from 'src/schema';
+import { updateLockedColumns } from 'src/utils/database';
 import { SyncTestContext } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
 import { getKyselyDB, wait } from 'test/utils';
@@ -288,10 +289,13 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {

    // update the asset
    const assetRepository = ctx.get(AssetRepository);
-    await assetRepository.upsertExif({
-      assetId: asset.id,
-      city: 'New City',
-    });
+    await assetRepository.upsertExif(
+      updateLockedColumns({
+        assetId: asset.id,
+        city: 'New City',
+      }),
+      { lockedPropertiesBehavior: 'append' },
+    );

    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([
      {
@@ -346,10 +350,13 @@ describe(SyncRequestType.AlbumAssetExifsV1, () => {

    // update the asset
    const assetRepository = ctx.get(AssetRepository);
-    await assetRepository.upsertExif({
-      assetId: assetDelayedExif.id,
-      city: 'Delayed Exif',
-    });
+    await assetRepository.upsertExif(
+      updateLockedColumns({
+        assetId: assetDelayedExif.id,
+        city: 'Delayed Exif',
+      }),
+      { lockedPropertiesBehavior: 'append' },
+    );

    await expect(ctx.syncStream(auth, [SyncRequestType.AlbumAssetExifsV1])).resolves.toEqual([
      {
--- a/server/test/repositories/config.repository.mock.ts
+++ b/server/test/repositories/config.repository.mock.ts
@@ -1,4 +1,4 @@
-import { DatabaseExtension, ImmichEnvironment, ImmichWorker } from 'src/enum';
+import { DatabaseExtension, ImmichEnvironment, ImmichWorker, LogFormat } from 'src/enum';
 import { ConfigRepository, EnvData } from 'src/repositories/config.repository';
 import { RepositoryInterface } from 'src/types';
 import { Mocked, vitest } from 'vitest';
@@ -6,6 +6,7 @@ import { Mocked, vitest } from 'vitest';
 const envData: EnvData = {
  port: 2283,
  environment: ImmichEnvironment.Production,
+  logFormat: LogFormat.Console,

  buildMetadata: {},
  bull: {
@@ -75,6 +76,10 @@ const envData: EnvData = {
    corePlugin: '/build/corePlugin',
  },

+  setup: {
+    allow: true,
+  },
+
  storage: {
    ignoreMountCheckErrors: false,
  },
@@ -88,8 +93,10 @@ const envData: EnvData = {
  workers: [ImmichWorker.Api, ImmichWorker.Microservices],

  plugins: {
-    enabled: true,
-    installFolder: '/app/data/plugins',
+    external: {
+      allow: true,
+      installFolder: '/app/data/plugins',
+    },
  },

  noColor: false,
--- a/server/test/small.factory.ts
+++ b/server/test/small.factory.ts
@@ -4,6 +4,7 @@ import {
  AuthApiKey,
  AuthSharedLink,
  AuthUser,
+  Exif,
  Library,
  Memory,
  Partner,
@@ -319,18 +320,28 @@ const versionHistoryFactory = () => ({
  version: '1.123.45',
 });

-const assetSidecarWriteFactory = () => ({
-  id: newUuid(),
-  originalPath: '/path/to/original-path.jpg.xmp',
-  tags: [],
-  files: [
-    {
-      id: newUuid(),
-      path: '/path/to/original-path.jpg.xmp',
-      type: AssetFileType.Sidecar,
-    },
-  ],
-});
+const assetSidecarWriteFactory = () => {
+  const id = newUuid();
+  return {
+    id,
+    originalPath: '/path/to/original-path.jpg.xmp',
+    tags: [],
+    files: [
+      {
+        id: newUuid(),
+        path: '/path/to/original-path.jpg.xmp',
+        type: AssetFileType.Sidecar,
+      },
+    ],
+    exifInfo: {
+      assetId: id,
+      description: 'this is a description',
+      latitude: 12,
+      longitude: 12,
+      dateTimeOriginal: '2023-11-22T04:56:12.196Z',
+    } as unknown as Exif,
+  };
+};

 const assetOcrFactory = (
  ocr: {