feat(mobile): SyncAssetEditV1 (#26518)

* feat(mobile): SyncAssetEditV1

* fix: websocket handling

* fix: server version requirement

* fix: revert pubspec changes

mobile/lib/domain/models/asset_edit.model.dart

@@ -0,0 +1,21 @@
+import "package:openapi/api.dart" as api show AssetEditAction;
+
+enum AssetEditAction { rotate, crop, mirror, other }
+
+extension AssetEditActionExtension on AssetEditAction {
+  api.AssetEditAction? toDto() {
+    return switch (this) {
+      AssetEditAction.rotate => api.AssetEditAction.rotate,
+      AssetEditAction.crop => api.AssetEditAction.crop,
+      AssetEditAction.mirror => api.AssetEditAction.mirror,
+      AssetEditAction.other => null,
+    };
+  }
+}
+
+class AssetEdit {
+  final AssetEditAction action;
+  final Map<String, dynamic> parameters;
+
+  const AssetEdit({required this.action, required this.parameters});
+}

mobile/lib/domain/services/sync_stream.service.dart

@@ -205,6 +205,10 @@ class SyncStreamService {
         return _syncStreamRepository.deleteAssetsV1(data.cast());
       case SyncEntityType.assetExifV1:
         return _syncStreamRepository.updateAssetsExifV1(data.cast());
+      case SyncEntityType.assetEditV1:
+        return _syncStreamRepository.updateAssetEditsV1(data.cast());
+      case SyncEntityType.assetEditDeleteV1:
+        return _syncStreamRepository.deleteAssetEditsV1(data.cast());
       case SyncEntityType.assetMetadataV1:
         return _syncStreamRepository.updateAssetsMetadataV1(data.cast());
       case SyncEntityType.assetMetadataDeleteV1:
@@ -336,39 +340,43 @@ class SyncStreamService {
     }
   }
 
-  Future<void> handleWsAssetEditReadyV1Batch(List<dynamic> batchData) async {
+  Future<void> handleWsAssetEditReadyV1(dynamic data) async {
-    if (batchData.isEmpty) return;
+    _logger.info('Processing AssetEditReadyV1 event');
-
-    _logger.info('Processing batch of ${batchData.length} AssetEditReadyV1 events');
-
-    final List<SyncAssetV1> assets = [];
 
     try {
-      for (final data in batchData) {
       if (data is! Map<String, dynamic>) {
-          continue;
+        throw ArgumentError("Invalid data format for AssetEditReadyV1 event");
       }
 
       final payload = data;
-        final assetData = payload['asset'];
 
-        if (assetData == null) {
+      if (payload['asset'] == null) {
-          continue;
+        throw ArgumentError("Missing 'asset' field in AssetEditReadyV1 event data");
       }
 
-        final asset = SyncAssetV1.fromJson(assetData);
+      final asset = SyncAssetV1.fromJson(payload['asset']);
-
+      if (asset == null) {
-        if (asset != null) {
+        throw ArgumentError("Failed to parse 'asset' field in AssetEditReadyV1 event data");
-          assets.add(asset);
-        }
       }
 
-      if (assets.isNotEmpty) {
+      List<SyncAssetEditV1> assetEdits = [];
-        await _syncStreamRepository.updateAssetsV1(assets, debugLabel: 'websocket-edit');
+
-        _logger.info('Successfully processed ${assets.length} edited assets');
+      // Edits are only send on v2.6.0+
+      if (payload['edit'] != null && payload['edit'] is List<dynamic>) {
+        assetEdits = (payload['edit'] as List<dynamic>)
+            .map((e) => SyncAssetEditV1.fromJson(e))
+            .whereType<SyncAssetEditV1>()
+            .toList();
       }
+
+      await _syncStreamRepository.updateAssetsV1([asset], debugLabel: 'websocket-edit');
+      await _syncStreamRepository.replaceAssetEditsV1(asset.id, assetEdits, debugLabel: 'websocket-edit');
+
+      _logger.info(
+        'Successfully processed AssetEditReadyV1 event for asset ${asset.id} with ${assetEdits.length} edits',
+      );
     } catch (error, stackTrace) {
-      _logger.severe("Error processing AssetEditReadyV1 websocket batch events", error, stackTrace);
+      _logger.severe("Error processing AssetEditReadyV1 websocket event", error, stackTrace);
     }
   }
 

mobile/lib/domain/utils/background_sync.dart

@@ -196,11 +196,11 @@ class BackgroundSyncManager {
     });
   }
 
-  Future<void> syncWebsocketEditBatch(List<dynamic> batchData) {
+  Future<void> syncWebsocketEdit(dynamic data) {
     if (_syncWebsocketTask != null) {
       return _syncWebsocketTask!.future;
     }
-    _syncWebsocketTask = _handleWsAssetEditReadyV1Batch(batchData);
+    _syncWebsocketTask = _handleWsAssetEditReadyV1(data);
     return _syncWebsocketTask!.whenComplete(() {
       _syncWebsocketTask = null;
     });
@@ -242,7 +242,7 @@ Cancelable<void> _handleWsAssetUploadReadyV1Batch(List<dynamic> batchData) => ru
   debugLabel: 'websocket-batch',
 );
 
-Cancelable<void> _handleWsAssetEditReadyV1Batch(List<dynamic> batchData) => runInIsolateGentle(
+Cancelable<void> _handleWsAssetEditReadyV1(dynamic data) => runInIsolateGentle(
-  computation: (ref) => ref.read(syncStreamServiceProvider).handleWsAssetEditReadyV1Batch(batchData),
+  computation: (ref) => ref.read(syncStreamServiceProvider).handleWsAssetEditReadyV1(data),
   debugLabel: 'websocket-edit',
 );

mobile/lib/infrastructure/entities/asset_edit.entity.dart

@@ -0,0 +1,33 @@
+import 'package:drift/drift.dart';
+import 'package:immich_mobile/domain/models/asset_edit.model.dart';
+import 'package:immich_mobile/infrastructure/entities/asset_edit.entity.drift.dart';
+import 'package:immich_mobile/infrastructure/entities/remote_asset.entity.dart';
+import 'package:immich_mobile/infrastructure/utils/drift_default.mixin.dart';
+
+@TableIndex.sql('CREATE INDEX IF NOT EXISTS idx_asset_edit_asset_id ON asset_edit_entity (asset_id)')
+class AssetEditEntity extends Table with DriftDefaultsMixin {
+  const AssetEditEntity();
+
+  TextColumn get id => text()();
+
+  TextColumn get assetId => text().references(RemoteAssetEntity, #id, onDelete: KeyAction.cascade)();
+
+  IntColumn get action => intEnum<AssetEditAction>()();
+
+  BlobColumn get parameters => blob().map(editParameterConverter)();
+
+  IntColumn get sequence => integer()();
+
+  @override
+  Set<Column> get primaryKey => {id};
+}
+
+final JsonTypeConverter2<Map<String, Object?>, Uint8List, Object?> editParameterConverter = TypeConverter.jsonb(
+  fromJson: (json) => json as Map<String, Object?>,
+);
+
+extension AssetEditEntityDataDomainEx on AssetEditEntityData {
+  AssetEdit toDto() {
+    return AssetEdit(action: action, parameters: parameters);
+  }
+}

mobile/lib/infrastructure/entities/asset_edit.entity.drift.dart

@@ -0,0 +1,752 @@
+// dart format width=80
+// ignore_for_file: type=lint
+import 'package:drift/drift.dart' as i0;
+import 'package:immich_mobile/infrastructure/entities/asset_edit.entity.drift.dart'
+    as i1;
+import 'package:immich_mobile/domain/models/asset_edit.model.dart' as i2;
+import 'dart:typed_data' as i3;
+import 'package:immich_mobile/infrastructure/entities/asset_edit.entity.dart'
+    as i4;
+import 'package:immich_mobile/infrastructure/entities/remote_asset.entity.drift.dart'
+    as i5;
+import 'package:drift/internal/modular.dart' as i6;
+
+typedef $$AssetEditEntityTableCreateCompanionBuilder =
+    i1.AssetEditEntityCompanion Function({
+      required String id,
+      required String assetId,
+      required i2.AssetEditAction action,
+      required Map<String, Object?> parameters,
+      required int sequence,
+    });
+typedef $$AssetEditEntityTableUpdateCompanionBuilder =
+    i1.AssetEditEntityCompanion Function({
+      i0.Value<String> id,
+      i0.Value<String> assetId,
+      i0.Value<i2.AssetEditAction> action,
+      i0.Value<Map<String, Object?>> parameters,
+      i0.Value<int> sequence,
+    });
+
+final class $$AssetEditEntityTableReferences
+    extends
+        i0.BaseReferences<
+          i0.GeneratedDatabase,
+          i1.$AssetEditEntityTable,
+          i1.AssetEditEntityData
+        > {
+  $$AssetEditEntityTableReferences(
+    super.$_db,
+    super.$_table,
+    super.$_typedResult,
+  );
+
+  static i5.$RemoteAssetEntityTable _assetIdTable(i0.GeneratedDatabase db) =>
+      i6.ReadDatabaseContainer(db)
+          .resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity')
+          .createAlias(
+            i0.$_aliasNameGenerator(
+              i6.ReadDatabaseContainer(db)
+                  .resultSet<i1.$AssetEditEntityTable>('asset_edit_entity')
+                  .assetId,
+              i6.ReadDatabaseContainer(
+                db,
+              ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity').id,
+            ),
+          );
+
+  i5.$$RemoteAssetEntityTableProcessedTableManager get assetId {
+    final $_column = $_itemColumn<String>('asset_id')!;
+
+    final manager = i5
+        .$$RemoteAssetEntityTableTableManager(
+          $_db,
+          i6.ReadDatabaseContainer(
+            $_db,
+          ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+        )
+        .filter((f) => f.id.sqlEquals($_column));
+    final item = $_typedResult.readTableOrNull(_assetIdTable($_db));
+    if (item == null) return manager;
+    return i0.ProcessedTableManager(
+      manager.$state.copyWith(prefetchedData: [item]),
+    );
+  }
+}
+
+class $$AssetEditEntityTableFilterComposer
+    extends i0.Composer<i0.GeneratedDatabase, i1.$AssetEditEntityTable> {
+  $$AssetEditEntityTableFilterComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  i0.ColumnFilters<String> get id => $composableBuilder(
+    column: $table.id,
+    builder: (column) => i0.ColumnFilters(column),
+  );
+
+  i0.ColumnWithTypeConverterFilters<i2.AssetEditAction, i2.AssetEditAction, int>
+  get action => $composableBuilder(
+    column: $table.action,
+    builder: (column) => i0.ColumnWithTypeConverterFilters(column),
+  );
+
+  i0.ColumnWithTypeConverterFilters<
+    Map<String, Object?>,
+    Map<String, Object>,
+    i3.Uint8List
+  >
+  get parameters => $composableBuilder(
+    column: $table.parameters,
+    builder: (column) => i0.ColumnWithTypeConverterFilters(column),
+  );
+
+  i0.ColumnFilters<int> get sequence => $composableBuilder(
+    column: $table.sequence,
+    builder: (column) => i0.ColumnFilters(column),
+  );
+
+  i5.$$RemoteAssetEntityTableFilterComposer get assetId {
+    final i5.$$RemoteAssetEntityTableFilterComposer composer = $composerBuilder(
+      composer: this,
+      getCurrentColumn: (t) => t.assetId,
+      referencedTable: i6.ReadDatabaseContainer(
+        $db,
+      ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+      getReferencedColumn: (t) => t.id,
+      builder:
+          (
+            joinBuilder, {
+            $addJoinBuilderToRootComposer,
+            $removeJoinBuilderFromRootComposer,
+          }) => i5.$$RemoteAssetEntityTableFilterComposer(
+            $db: $db,
+            $table: i6.ReadDatabaseContainer(
+              $db,
+            ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+            joinBuilder: joinBuilder,
+            $removeJoinBuilderFromRootComposer:
+                $removeJoinBuilderFromRootComposer,
+          ),
+    );
+    return composer;
+  }
+}
+
+class $$AssetEditEntityTableOrderingComposer
+    extends i0.Composer<i0.GeneratedDatabase, i1.$AssetEditEntityTable> {
+  $$AssetEditEntityTableOrderingComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  i0.ColumnOrderings<String> get id => $composableBuilder(
+    column: $table.id,
+    builder: (column) => i0.ColumnOrderings(column),
+  );
+
+  i0.ColumnOrderings<int> get action => $composableBuilder(
+    column: $table.action,
+    builder: (column) => i0.ColumnOrderings(column),
+  );
+
+  i0.ColumnOrderings<i3.Uint8List> get parameters => $composableBuilder(
+    column: $table.parameters,
+    builder: (column) => i0.ColumnOrderings(column),
+  );
+
+  i0.ColumnOrderings<int> get sequence => $composableBuilder(
+    column: $table.sequence,
+    builder: (column) => i0.ColumnOrderings(column),
+  );
+
+  i5.$$RemoteAssetEntityTableOrderingComposer get assetId {
+    final i5.$$RemoteAssetEntityTableOrderingComposer composer =
+        $composerBuilder(
+          composer: this,
+          getCurrentColumn: (t) => t.assetId,
+          referencedTable: i6.ReadDatabaseContainer(
+            $db,
+          ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+          getReferencedColumn: (t) => t.id,
+          builder:
+              (
+                joinBuilder, {
+                $addJoinBuilderToRootComposer,
+                $removeJoinBuilderFromRootComposer,
+              }) => i5.$$RemoteAssetEntityTableOrderingComposer(
+                $db: $db,
+                $table: i6.ReadDatabaseContainer(
+                  $db,
+                ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer:
+                    $removeJoinBuilderFromRootComposer,
+              ),
+        );
+    return composer;
+  }
+}
+
+class $$AssetEditEntityTableAnnotationComposer
+    extends i0.Composer<i0.GeneratedDatabase, i1.$AssetEditEntityTable> {
+  $$AssetEditEntityTableAnnotationComposer({
+    required super.$db,
+    required super.$table,
+    super.joinBuilder,
+    super.$addJoinBuilderToRootComposer,
+    super.$removeJoinBuilderFromRootComposer,
+  });
+  i0.GeneratedColumn<String> get id =>
+      $composableBuilder(column: $table.id, builder: (column) => column);
+
+  i0.GeneratedColumnWithTypeConverter<i2.AssetEditAction, int> get action =>
+      $composableBuilder(column: $table.action, builder: (column) => column);
+
+  i0.GeneratedColumnWithTypeConverter<Map<String, Object?>, i3.Uint8List>
+  get parameters => $composableBuilder(
+    column: $table.parameters,
+    builder: (column) => column,
+  );
+
+  i0.GeneratedColumn<int> get sequence =>
+      $composableBuilder(column: $table.sequence, builder: (column) => column);
+
+  i5.$$RemoteAssetEntityTableAnnotationComposer get assetId {
+    final i5.$$RemoteAssetEntityTableAnnotationComposer composer =
+        $composerBuilder(
+          composer: this,
+          getCurrentColumn: (t) => t.assetId,
+          referencedTable: i6.ReadDatabaseContainer(
+            $db,
+          ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+          getReferencedColumn: (t) => t.id,
+          builder:
+              (
+                joinBuilder, {
+                $addJoinBuilderToRootComposer,
+                $removeJoinBuilderFromRootComposer,
+              }) => i5.$$RemoteAssetEntityTableAnnotationComposer(
+                $db: $db,
+                $table: i6.ReadDatabaseContainer(
+                  $db,
+                ).resultSet<i5.$RemoteAssetEntityTable>('remote_asset_entity'),
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer:
+                    $removeJoinBuilderFromRootComposer,
+              ),
+        );
+    return composer;
+  }
+}
+
+class $$AssetEditEntityTableTableManager
+    extends
+        i0.RootTableManager<
+          i0.GeneratedDatabase,
+          i1.$AssetEditEntityTable,
+          i1.AssetEditEntityData,
+          i1.$$AssetEditEntityTableFilterComposer,
+          i1.$$AssetEditEntityTableOrderingComposer,
+          i1.$$AssetEditEntityTableAnnotationComposer,
+          $$AssetEditEntityTableCreateCompanionBuilder,
+          $$AssetEditEntityTableUpdateCompanionBuilder,
+          (i1.AssetEditEntityData, i1.$$AssetEditEntityTableReferences),
+          i1.AssetEditEntityData,
+          i0.PrefetchHooks Function({bool assetId})
+        > {
+  $$AssetEditEntityTableTableManager(
+    i0.GeneratedDatabase db,
+    i1.$AssetEditEntityTable table,
+  ) : super(
+        i0.TableManagerState(
+          db: db,
+          table: table,
+          createFilteringComposer: () =>
+              i1.$$AssetEditEntityTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () =>
+              i1.$$AssetEditEntityTableOrderingComposer($db: db, $table: table),
+          createComputedFieldComposer: () => i1
+              .$$AssetEditEntityTableAnnotationComposer($db: db, $table: table),
+          updateCompanionCallback:
+              ({
+                i0.Value<String> id = const i0.Value.absent(),
+                i0.Value<String> assetId = const i0.Value.absent(),
+                i0.Value<i2.AssetEditAction> action = const i0.Value.absent(),
+                i0.Value<Map<String, Object?>> parameters =
+                    const i0.Value.absent(),
+                i0.Value<int> sequence = const i0.Value.absent(),
+              }) => i1.AssetEditEntityCompanion(
+                id: id,
+                assetId: assetId,
+                action: action,
+                parameters: parameters,
+                sequence: sequence,
+              ),
+          createCompanionCallback:
+              ({
+                required String id,
+                required String assetId,
+                required i2.AssetEditAction action,
+                required Map<String, Object?> parameters,
+                required int sequence,
+              }) => i1.AssetEditEntityCompanion.insert(
+                id: id,
+                assetId: assetId,
+                action: action,
+                parameters: parameters,
+                sequence: sequence,
+              ),
+          withReferenceMapper: (p0) => p0
+              .map(
+                (e) => (
+                  e.readTable(table),
+                  i1.$$AssetEditEntityTableReferences(db, table, e),
+                ),
+              )
+              .toList(),
+          prefetchHooksCallback: ({assetId = false}) {
+            return i0.PrefetchHooks(
+              db: db,
+              explicitlyWatchedTables: [],
+              addJoins:
+                  <
+                    T extends i0.TableManagerState<
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic,
+                      dynamic
+                    >
+                  >(state) {
+                    if (assetId) {
+                      state =
+                          state.withJoin(
+                                currentTable: table,
+                                currentColumn: table.assetId,
+                                referencedTable: i1
+                                    .$$AssetEditEntityTableReferences
+                                    ._assetIdTable(db),
+                                referencedColumn: i1
+                                    .$$AssetEditEntityTableReferences
+                                    ._assetIdTable(db)
+                                    .id,
+                              )
+                              as T;
+                    }
+
+                    return state;
+                  },
+              getPrefetchedDataCallback: (items) async {
+                return [];
+              },
+            );
+          },
+        ),
+      );
+}
+
+typedef $$AssetEditEntityTableProcessedTableManager =
+    i0.ProcessedTableManager<
+      i0.GeneratedDatabase,
+      i1.$AssetEditEntityTable,
+      i1.AssetEditEntityData,
+      i1.$$AssetEditEntityTableFilterComposer,
+      i1.$$AssetEditEntityTableOrderingComposer,
+      i1.$$AssetEditEntityTableAnnotationComposer,
+      $$AssetEditEntityTableCreateCompanionBuilder,
+      $$AssetEditEntityTableUpdateCompanionBuilder,
+      (i1.AssetEditEntityData, i1.$$AssetEditEntityTableReferences),
+      i1.AssetEditEntityData,
+      i0.PrefetchHooks Function({bool assetId})
+    >;
+i0.Index get idxAssetEditAssetId => i0.Index(
+  'idx_asset_edit_asset_id',
+  'CREATE INDEX IF NOT EXISTS idx_asset_edit_asset_id ON asset_edit_entity (asset_id)',
+);
+
+class $AssetEditEntityTable extends i4.AssetEditEntity
+    with i0.TableInfo<$AssetEditEntityTable, i1.AssetEditEntityData> {
+  @override
+  final i0.GeneratedDatabase attachedDatabase;
+  final String? _alias;
+  $AssetEditEntityTable(this.attachedDatabase, [this._alias]);
+  static const i0.VerificationMeta _idMeta = const i0.VerificationMeta('id');
+  @override
+  late final i0.GeneratedColumn<String> id = i0.GeneratedColumn<String>(
+    'id',
+    aliasedName,
+    false,
+    type: i0.DriftSqlType.string,
+    requiredDuringInsert: true,
+  );
+  static const i0.VerificationMeta _assetIdMeta = const i0.VerificationMeta(
+    'assetId',
+  );
+  @override
+  late final i0.GeneratedColumn<String> assetId = i0.GeneratedColumn<String>(
+    'asset_id',
+    aliasedName,
+    false,
+    type: i0.DriftSqlType.string,
+    requiredDuringInsert: true,
+    defaultConstraints: i0.GeneratedColumn.constraintIsAlways(
+      'REFERENCES remote_asset_entity (id) ON DELETE CASCADE',
+    ),
+  );
+  @override
+  late final i0.GeneratedColumnWithTypeConverter<i2.AssetEditAction, int>
+  action =
+      i0.GeneratedColumn<int>(
+        'action',
+        aliasedName,
+        false,
+        type: i0.DriftSqlType.int,
+        requiredDuringInsert: true,
+      ).withConverter<i2.AssetEditAction>(
+        i1.$AssetEditEntityTable.$converteraction,
+      );
+  @override
+  late final i0.GeneratedColumnWithTypeConverter<
+    Map<String, Object?>,
+    i3.Uint8List
+  >
+  parameters =
+      i0.GeneratedColumn<i3.Uint8List>(
+        'parameters',
+        aliasedName,
+        false,
+        type: i0.DriftSqlType.blob,
+        requiredDuringInsert: true,
+      ).withConverter<Map<String, Object?>>(
+        i1.$AssetEditEntityTable.$converterparameters,
+      );
+  static const i0.VerificationMeta _sequenceMeta = const i0.VerificationMeta(
+    'sequence',
+  );
+  @override
+  late final i0.GeneratedColumn<int> sequence = i0.GeneratedColumn<int>(
+    'sequence',
+    aliasedName,
+    false,
+    type: i0.DriftSqlType.int,
+    requiredDuringInsert: true,
+  );
+  @override
+  List<i0.GeneratedColumn> get $columns => [
+    id,
+    assetId,
+    action,
+    parameters,
+    sequence,
+  ];
+  @override
+  String get aliasedName => _alias ?? actualTableName;
+  @override
+  String get actualTableName => $name;
+  static const String $name = 'asset_edit_entity';
+  @override
+  i0.VerificationContext validateIntegrity(
+    i0.Insertable<i1.AssetEditEntityData> instance, {
+    bool isInserting = false,
+  }) {
+    final context = i0.VerificationContext();
+    final data = instance.toColumns(true);
+    if (data.containsKey('id')) {
+      context.handle(_idMeta, id.isAcceptableOrUnknown(data['id']!, _idMeta));
+    } else if (isInserting) {
+      context.missing(_idMeta);
+    }
+    if (data.containsKey('asset_id')) {
+      context.handle(
+        _assetIdMeta,
+        assetId.isAcceptableOrUnknown(data['asset_id']!, _assetIdMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_assetIdMeta);
+    }
+    if (data.containsKey('sequence')) {
+      context.handle(
+        _sequenceMeta,
+        sequence.isAcceptableOrUnknown(data['sequence']!, _sequenceMeta),
+      );
+    } else if (isInserting) {
+      context.missing(_sequenceMeta);
+    }
+    return context;
+  }
+
+  @override
+  Set<i0.GeneratedColumn> get $primaryKey => {id};
+  @override
+  i1.AssetEditEntityData map(Map<String, dynamic> data, {String? tablePrefix}) {
+    final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
+    return i1.AssetEditEntityData(
+      id: attachedDatabase.typeMapping.read(
+        i0.DriftSqlType.string,
+        data['${effectivePrefix}id'],
+      )!,
+      assetId: attachedDatabase.typeMapping.read(
+        i0.DriftSqlType.string,
+        data['${effectivePrefix}asset_id'],
+      )!,
+      action: i1.$AssetEditEntityTable.$converteraction.fromSql(
+        attachedDatabase.typeMapping.read(
+          i0.DriftSqlType.int,
+          data['${effectivePrefix}action'],
+        )!,
+      ),
+      parameters: i1.$AssetEditEntityTable.$converterparameters.fromSql(
+        attachedDatabase.typeMapping.read(
+          i0.DriftSqlType.blob,
+          data['${effectivePrefix}parameters'],
+        )!,
+      ),
+      sequence: attachedDatabase.typeMapping.read(
+        i0.DriftSqlType.int,
+        data['${effectivePrefix}sequence'],
+      )!,
+    );
+  }
+
+  @override
+  $AssetEditEntityTable createAlias(String alias) {
+    return $AssetEditEntityTable(attachedDatabase, alias);
+  }
+
+  static i0.JsonTypeConverter2<i2.AssetEditAction, int, int> $converteraction =
+      const i0.EnumIndexConverter<i2.AssetEditAction>(
+        i2.AssetEditAction.values,
+      );
+  static i0.JsonTypeConverter2<Map<String, Object?>, i3.Uint8List, Object?>
+  $converterparameters = i4.editParameterConverter;
+  @override
+  bool get withoutRowId => true;
+  @override
+  bool get isStrict => true;
+}
+
+class AssetEditEntityData extends i0.DataClass
+    implements i0.Insertable<i1.AssetEditEntityData> {
+  final String id;
+  final String assetId;
+  final i2.AssetEditAction action;
+  final Map<String, Object?> parameters;
+  final int sequence;
+  const AssetEditEntityData({
+    required this.id,
+    required this.assetId,
+    required this.action,
+    required this.parameters,
+    required this.sequence,
+  });
+  @override
+  Map<String, i0.Expression> toColumns(bool nullToAbsent) {
+    final map = <String, i0.Expression>{};
+    map['id'] = i0.Variable<String>(id);
+    map['asset_id'] = i0.Variable<String>(assetId);
+    {
+      map['action'] = i0.Variable<int>(
+        i1.$AssetEditEntityTable.$converteraction.toSql(action),
+      );
+    }
+    {
+      map['parameters'] = i0.Variable<i3.Uint8List>(
+        i1.$AssetEditEntityTable.$converterparameters.toSql(parameters),
+      );
+    }
+    map['sequence'] = i0.Variable<int>(sequence);
+    return map;
+  }
+
+  factory AssetEditEntityData.fromJson(
+    Map<String, dynamic> json, {
+    i0.ValueSerializer? serializer,
+  }) {
+    serializer ??= i0.driftRuntimeOptions.defaultSerializer;
+    return AssetEditEntityData(
+      id: serializer.fromJson<String>(json['id']),
+      assetId: serializer.fromJson<String>(json['assetId']),
+      action: i1.$AssetEditEntityTable.$converteraction.fromJson(
+        serializer.fromJson<int>(json['action']),
+      ),
+      parameters: i1.$AssetEditEntityTable.$converterparameters.fromJson(
+        serializer.fromJson<Object?>(json['parameters']),
+      ),
+      sequence: serializer.fromJson<int>(json['sequence']),
+    );
+  }
+  @override
+  Map<String, dynamic> toJson({i0.ValueSerializer? serializer}) {
+    serializer ??= i0.driftRuntimeOptions.defaultSerializer;
+    return <String, dynamic>{
+      'id': serializer.toJson<String>(id),
+      'assetId': serializer.toJson<String>(assetId),
+      'action': serializer.toJson<int>(
+        i1.$AssetEditEntityTable.$converteraction.toJson(action),
+      ),
+      'parameters': serializer.toJson<Object?>(
+        i1.$AssetEditEntityTable.$converterparameters.toJson(parameters),
+      ),
+      'sequence': serializer.toJson<int>(sequence),
+    };
+  }
+
+  i1.AssetEditEntityData copyWith({
+    String? id,
+    String? assetId,
+    i2.AssetEditAction? action,
+    Map<String, Object?>? parameters,
+    int? sequence,
+  }) => i1.AssetEditEntityData(
+    id: id ?? this.id,
+    assetId: assetId ?? this.assetId,
+    action: action ?? this.action,
+    parameters: parameters ?? this.parameters,
+    sequence: sequence ?? this.sequence,
+  );
+  AssetEditEntityData copyWithCompanion(i1.AssetEditEntityCompanion data) {
+    return AssetEditEntityData(
+      id: data.id.present ? data.id.value : this.id,
+      assetId: data.assetId.present ? data.assetId.value : this.assetId,
+      action: data.action.present ? data.action.value : this.action,
+      parameters: data.parameters.present
+          ? data.parameters.value
+          : this.parameters,
+      sequence: data.sequence.present ? data.sequence.value : this.sequence,
+    );
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('AssetEditEntityData(')
+          ..write('id: $id, ')
+          ..write('assetId: $assetId, ')
+          ..write('action: $action, ')
+          ..write('parameters: $parameters, ')
+          ..write('sequence: $sequence')
+          ..write(')'))
+        .toString();
+  }
+
+  @override
+  int get hashCode => Object.hash(id, assetId, action, parameters, sequence);
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is i1.AssetEditEntityData &&
+          other.id == this.id &&
+          other.assetId == this.assetId &&
+          other.action == this.action &&
+          other.parameters == this.parameters &&
+          other.sequence == this.sequence);
+}
+
+class AssetEditEntityCompanion
+    extends i0.UpdateCompanion<i1.AssetEditEntityData> {
+  final i0.Value<String> id;
+  final i0.Value<String> assetId;
+  final i0.Value<i2.AssetEditAction> action;
+  final i0.Value<Map<String, Object?>> parameters;
+  final i0.Value<int> sequence;
+  const AssetEditEntityCompanion({
+    this.id = const i0.Value.absent(),
+    this.assetId = const i0.Value.absent(),
+    this.action = const i0.Value.absent(),
+    this.parameters = const i0.Value.absent(),
+    this.sequence = const i0.Value.absent(),
+  });
+  AssetEditEntityCompanion.insert({
+    required String id,
+    required String assetId,
+    required i2.AssetEditAction action,
+    required Map<String, Object?> parameters,
+    required int sequence,
+  }) : id = i0.Value(id),
+       assetId = i0.Value(assetId),
+       action = i0.Value(action),
+       parameters = i0.Value(parameters),
+       sequence = i0.Value(sequence);
+  static i0.Insertable<i1.AssetEditEntityData> custom({
+    i0.Expression<String>? id,
+    i0.Expression<String>? assetId,
+    i0.Expression<int>? action,
+    i0.Expression<i3.Uint8List>? parameters,
+    i0.Expression<int>? sequence,
+  }) {
+    return i0.RawValuesInsertable({
+      if (id != null) 'id': id,
+      if (assetId != null) 'asset_id': assetId,
+      if (action != null) 'action': action,
+      if (parameters != null) 'parameters': parameters,
+      if (sequence != null) 'sequence': sequence,
+    });
+  }
+
+  i1.AssetEditEntityCompanion copyWith({
+    i0.Value<String>? id,
+    i0.Value<String>? assetId,
+    i0.Value<i2.AssetEditAction>? action,
+    i0.Value<Map<String, Object?>>? parameters,
+    i0.Value<int>? sequence,
+  }) {
+    return i1.AssetEditEntityCompanion(
+      id: id ?? this.id,
+      assetId: assetId ?? this.assetId,
+      action: action ?? this.action,
+      parameters: parameters ?? this.parameters,
+      sequence: sequence ?? this.sequence,
+    );
+  }
+
+  @override
+  Map<String, i0.Expression> toColumns(bool nullToAbsent) {
+    final map = <String, i0.Expression>{};
+    if (id.present) {
+      map['id'] = i0.Variable<String>(id.value);
+    }
+    if (assetId.present) {
+      map['asset_id'] = i0.Variable<String>(assetId.value);
+    }
+    if (action.present) {
+      map['action'] = i0.Variable<int>(
+        i1.$AssetEditEntityTable.$converteraction.toSql(action.value),
+      );
+    }
+    if (parameters.present) {
+      map['parameters'] = i0.Variable<i3.Uint8List>(
+        i1.$AssetEditEntityTable.$converterparameters.toSql(parameters.value),
+      );
+    }
+    if (sequence.present) {
+      map['sequence'] = i0.Variable<int>(sequence.value);
+    }
+    return map;
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('AssetEditEntityCompanion(')
+          ..write('id: $id, ')
+          ..write('assetId: $assetId, ')
+          ..write('action: $action, ')
+          ..write('parameters: $parameters, ')
+          ..write('sequence: $sequence')
+          ..write(')'))
+        .toString();
+  }
+}

mobile/lib/infrastructure/repositories/db.repository.dart

@@ -4,6 +4,7 @@ import 'package:drift/drift.dart';
 import 'package:drift_flutter/drift_flutter.dart';
 import 'package:flutter/foundation.dart';
 import 'package:immich_mobile/domain/interfaces/db.interface.dart';
+import 'package:immich_mobile/infrastructure/entities/asset_edit.entity.dart';
 import 'package:immich_mobile/infrastructure/entities/asset_face.entity.dart';
 import 'package:immich_mobile/infrastructure/entities/auth_user.entity.dart';
 import 'package:immich_mobile/infrastructure/entities/exif.entity.dart';
@@ -65,6 +66,7 @@ class IsarDatabaseRepository implements IDatabaseRepository {
     AssetFaceEntity,
     StoreEntity,
     TrashedLocalAssetEntity,
+    AssetEditEntity,
   ],
   include: {'package:immich_mobile/infrastructure/entities/merged_asset.drift'},
 )
@@ -96,7 +98,7 @@ class Drift extends $Drift implements IDatabaseRepository {
   }
 
   @override
-  int get schemaVersion => 21;
+  int get schemaVersion => 22;
 
   @override
   MigrationStrategy get migration => MigrationStrategy(
@@ -233,6 +235,10 @@ class Drift extends $Drift implements IDatabaseRepository {
             await m.addColumn(v21.localAssetEntity, v21.localAssetEntity.playbackStyle);
             await m.addColumn(v21.trashedLocalAssetEntity, v21.trashedLocalAssetEntity.playbackStyle);
           },
+          from21To22: (m, v22) async {
+            await m.createTable(v22.assetEditEntity);
+            await m.createIndex(v22.idxAssetEditAssetId);
+          },
         ),
       );
 

mobile/lib/infrastructure/repositories/db.repository.drift.dart

@@ -41,9 +41,11 @@ import 'package:immich_mobile/infrastructure/entities/store.entity.drift.dart'
     as i19;
 import 'package:immich_mobile/infrastructure/entities/trashed_local_asset.entity.drift.dart'
     as i20;
-import 'package:immich_mobile/infrastructure/entities/merged_asset.drift.dart'
+import 'package:immich_mobile/infrastructure/entities/asset_edit.entity.drift.dart'
     as i21;
-import 'package:drift/internal/modular.dart' as i22;
+import 'package:immich_mobile/infrastructure/entities/merged_asset.drift.dart'
+    as i22;
+import 'package:drift/internal/modular.dart' as i23;
 
 abstract class $Drift extends i0.GeneratedDatabase {
   $Drift(i0.QueryExecutor e) : super(e);
@@ -85,9 +87,11 @@ abstract class $Drift extends i0.GeneratedDatabase {
   late final i19.$StoreEntityTable storeEntity = i19.$StoreEntityTable(this);
   late final i20.$TrashedLocalAssetEntityTable trashedLocalAssetEntity = i20
       .$TrashedLocalAssetEntityTable(this);
-  i21.MergedAssetDrift get mergedAssetDrift => i22.ReadDatabaseContainer(
+  late final i21.$AssetEditEntityTable assetEditEntity = i21
+      .$AssetEditEntityTable(this);
+  i22.MergedAssetDrift get mergedAssetDrift => i23.ReadDatabaseContainer(
     this,
-  ).accessor<i21.MergedAssetDrift>(i21.MergedAssetDrift.new);
+  ).accessor<i22.MergedAssetDrift>(i22.MergedAssetDrift.new);
   @override
   Iterable<i0.TableInfo<i0.Table, Object?>> get allTables =>
       allSchemaEntities.whereType<i0.TableInfo<i0.Table, Object?>>();
@@ -125,6 +129,7 @@ abstract class $Drift extends i0.GeneratedDatabase {
     assetFaceEntity,
     storeEntity,
     trashedLocalAssetEntity,
+    assetEditEntity,
     i10.idxPartnerSharedWithId,
     i11.idxLatLng,
     i12.idxRemoteAlbumAssetAlbumAsset,
@@ -134,6 +139,7 @@ abstract class $Drift extends i0.GeneratedDatabase {
     i18.idxAssetFaceAssetId,
     i20.idxTrashedLocalAssetChecksum,
     i20.idxTrashedLocalAssetAlbum,
+    i21.idxAssetEditAssetId,
   ];
   @override
   i0.StreamQueryUpdateRules
@@ -325,6 +331,13 @@ abstract class $Drift extends i0.GeneratedDatabase {
       ),
       result: [i0.TableUpdate('asset_face_entity', kind: i0.UpdateKind.update)],
     ),
+    i0.WritePropagation(
+      on: i0.TableUpdateQuery.onTableName(
+        'remote_asset_entity',
+        limitUpdateKind: i0.UpdateKind.delete,
+      ),
+      result: [i0.TableUpdate('asset_edit_entity', kind: i0.UpdateKind.delete)],
+    ),
   ]);
   @override
   i0.DriftDatabaseOptions get options =>
@@ -384,4 +397,6 @@ class $DriftManager {
         _db,
         _db.trashedLocalAssetEntity,
       );
+  i21.$$AssetEditEntityTableTableManager get assetEditEntity =>
+      i21.$$AssetEditEntityTableTableManager(_db, _db.assetEditEntity);
 }

mobile/lib/infrastructure/repositories/db.repository.steps.dart

@@ -9489,6 +9489,565 @@ class Shape31 extends i0.VersionedTable {
       columnsByName['playback_style']! as i1.GeneratedColumn<int>;
 }
 
+final class Schema22 extends i0.VersionedSchema {
+  Schema22({required super.database}) : super(version: 22);
+  @override
+  late final List<i1.DatabaseSchemaEntity> entities = [
+    userEntity,
+    remoteAssetEntity,
+    stackEntity,
+    localAssetEntity,
+    remoteAlbumEntity,
+    localAlbumEntity,
+    localAlbumAssetEntity,
+    idxLocalAlbumAssetAlbumAsset,
+    idxRemoteAlbumOwnerId,
+    idxLocalAssetChecksum,
+    idxLocalAssetCloudId,
+    idxStackPrimaryAssetId,
+    idxRemoteAssetOwnerChecksum,
+    uQRemoteAssetsOwnerChecksum,
+    uQRemoteAssetsOwnerLibraryChecksum,
+    idxRemoteAssetChecksum,
+    idxRemoteAssetStackId,
+    idxRemoteAssetLocalDateTimeDay,
+    idxRemoteAssetLocalDateTimeMonth,
+    authUserEntity,
+    userMetadataEntity,
+    partnerEntity,
+    remoteExifEntity,
+    remoteAlbumAssetEntity,
+    remoteAlbumUserEntity,
+    remoteAssetCloudIdEntity,
+    memoryEntity,
+    memoryAssetEntity,
+    personEntity,
+    assetFaceEntity,
+    storeEntity,
+    trashedLocalAssetEntity,
+    assetEditEntity,
+    idxPartnerSharedWithId,
+    idxLatLng,
+    idxRemoteAlbumAssetAlbumAsset,
+    idxRemoteAssetCloudId,
+    idxPersonOwnerId,
+    idxAssetFacePersonId,
+    idxAssetFaceAssetId,
+    idxTrashedLocalAssetChecksum,
+    idxTrashedLocalAssetAlbum,
+    idxAssetEditAssetId,
+  ];
+  late final Shape20 userEntity = Shape20(
+    source: i0.VersionedTable(
+      entityName: 'user_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_3,
+        _column_84,
+        _column_85,
+        _column_91,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape28 remoteAssetEntity = Shape28(
+    source: i0.VersionedTable(
+      entityName: 'remote_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_1,
+        _column_8,
+        _column_9,
+        _column_5,
+        _column_10,
+        _column_11,
+        _column_12,
+        _column_0,
+        _column_13,
+        _column_14,
+        _column_15,
+        _column_16,
+        _column_17,
+        _column_18,
+        _column_19,
+        _column_20,
+        _column_21,
+        _column_86,
+        _column_101,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape3 stackEntity = Shape3(
+    source: i0.VersionedTable(
+      entityName: 'stack_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [_column_0, _column_9, _column_5, _column_15, _column_75],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape30 localAssetEntity = Shape30(
+    source: i0.VersionedTable(
+      entityName: 'local_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_1,
+        _column_8,
+        _column_9,
+        _column_5,
+        _column_10,
+        _column_11,
+        _column_12,
+        _column_0,
+        _column_22,
+        _column_14,
+        _column_23,
+        _column_98,
+        _column_96,
+        _column_46,
+        _column_47,
+        _column_103,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape9 remoteAlbumEntity = Shape9(
+    source: i0.VersionedTable(
+      entityName: 'remote_album_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_56,
+        _column_9,
+        _column_5,
+        _column_15,
+        _column_57,
+        _column_58,
+        _column_59,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape19 localAlbumEntity = Shape19(
+    source: i0.VersionedTable(
+      entityName: 'local_album_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_5,
+        _column_31,
+        _column_32,
+        _column_90,
+        _column_33,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape22 localAlbumAssetEntity = Shape22(
+    source: i0.VersionedTable(
+      entityName: 'local_album_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id, album_id)'],
+      columns: [_column_34, _column_35, _column_33],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  final i1.Index idxLocalAlbumAssetAlbumAsset = i1.Index(
+    'idx_local_album_asset_album_asset',
+    'CREATE INDEX IF NOT EXISTS idx_local_album_asset_album_asset ON local_album_asset_entity (album_id, asset_id)',
+  );
+  final i1.Index idxRemoteAlbumOwnerId = i1.Index(
+    'idx_remote_album_owner_id',
+    'CREATE INDEX IF NOT EXISTS idx_remote_album_owner_id ON remote_album_entity (owner_id)',
+  );
+  final i1.Index idxLocalAssetChecksum = i1.Index(
+    'idx_local_asset_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_local_asset_checksum ON local_asset_entity (checksum)',
+  );
+  final i1.Index idxLocalAssetCloudId = i1.Index(
+    'idx_local_asset_cloud_id',
+    'CREATE INDEX IF NOT EXISTS idx_local_asset_cloud_id ON local_asset_entity (i_cloud_id)',
+  );
+  final i1.Index idxStackPrimaryAssetId = i1.Index(
+    'idx_stack_primary_asset_id',
+    'CREATE INDEX IF NOT EXISTS idx_stack_primary_asset_id ON stack_entity (primary_asset_id)',
+  );
+  final i1.Index idxRemoteAssetOwnerChecksum = i1.Index(
+    'idx_remote_asset_owner_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_owner_checksum ON remote_asset_entity (owner_id, checksum)',
+  );
+  final i1.Index uQRemoteAssetsOwnerChecksum = i1.Index(
+    'UQ_remote_assets_owner_checksum',
+    'CREATE UNIQUE INDEX IF NOT EXISTS UQ_remote_assets_owner_checksum ON remote_asset_entity (owner_id, checksum) WHERE(library_id IS NULL)',
+  );
+  final i1.Index uQRemoteAssetsOwnerLibraryChecksum = i1.Index(
+    'UQ_remote_assets_owner_library_checksum',
+    'CREATE UNIQUE INDEX IF NOT EXISTS UQ_remote_assets_owner_library_checksum ON remote_asset_entity (owner_id, library_id, checksum) WHERE(library_id IS NOT NULL)',
+  );
+  final i1.Index idxRemoteAssetChecksum = i1.Index(
+    'idx_remote_asset_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_checksum ON remote_asset_entity (checksum)',
+  );
+  final i1.Index idxRemoteAssetStackId = i1.Index(
+    'idx_remote_asset_stack_id',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_stack_id ON remote_asset_entity (stack_id)',
+  );
+  final i1.Index idxRemoteAssetLocalDateTimeDay = i1.Index(
+    'idx_remote_asset_local_date_time_day',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_local_date_time_day ON remote_asset_entity (STRFTIME(\'%Y-%m-%d\', local_date_time))',
+  );
+  final i1.Index idxRemoteAssetLocalDateTimeMonth = i1.Index(
+    'idx_remote_asset_local_date_time_month',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_local_date_time_month ON remote_asset_entity (STRFTIME(\'%Y-%m\', local_date_time))',
+  );
+  late final Shape21 authUserEntity = Shape21(
+    source: i0.VersionedTable(
+      entityName: 'auth_user_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_1,
+        _column_3,
+        _column_2,
+        _column_84,
+        _column_85,
+        _column_92,
+        _column_93,
+        _column_7,
+        _column_94,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape4 userMetadataEntity = Shape4(
+    source: i0.VersionedTable(
+      entityName: 'user_metadata_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(user_id, "key")'],
+      columns: [_column_25, _column_26, _column_27],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape5 partnerEntity = Shape5(
+    source: i0.VersionedTable(
+      entityName: 'partner_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(shared_by_id, shared_with_id)'],
+      columns: [_column_28, _column_29, _column_30],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape8 remoteExifEntity = Shape8(
+    source: i0.VersionedTable(
+      entityName: 'remote_exif_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id)'],
+      columns: [
+        _column_36,
+        _column_37,
+        _column_38,
+        _column_39,
+        _column_40,
+        _column_41,
+        _column_11,
+        _column_10,
+        _column_42,
+        _column_43,
+        _column_44,
+        _column_45,
+        _column_46,
+        _column_47,
+        _column_48,
+        _column_49,
+        _column_50,
+        _column_51,
+        _column_52,
+        _column_53,
+        _column_54,
+        _column_55,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape7 remoteAlbumAssetEntity = Shape7(
+    source: i0.VersionedTable(
+      entityName: 'remote_album_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id, album_id)'],
+      columns: [_column_36, _column_60],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape10 remoteAlbumUserEntity = Shape10(
+    source: i0.VersionedTable(
+      entityName: 'remote_album_user_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(album_id, user_id)'],
+      columns: [_column_60, _column_25, _column_61],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape27 remoteAssetCloudIdEntity = Shape27(
+    source: i0.VersionedTable(
+      entityName: 'remote_asset_cloud_id_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id)'],
+      columns: [
+        _column_36,
+        _column_99,
+        _column_100,
+        _column_96,
+        _column_46,
+        _column_47,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape11 memoryEntity = Shape11(
+    source: i0.VersionedTable(
+      entityName: 'memory_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_9,
+        _column_5,
+        _column_18,
+        _column_15,
+        _column_8,
+        _column_62,
+        _column_63,
+        _column_64,
+        _column_65,
+        _column_66,
+        _column_67,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape12 memoryAssetEntity = Shape12(
+    source: i0.VersionedTable(
+      entityName: 'memory_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(asset_id, memory_id)'],
+      columns: [_column_36, _column_68],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape14 personEntity = Shape14(
+    source: i0.VersionedTable(
+      entityName: 'person_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_9,
+        _column_5,
+        _column_15,
+        _column_1,
+        _column_69,
+        _column_71,
+        _column_72,
+        _column_73,
+        _column_74,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape29 assetFaceEntity = Shape29(
+    source: i0.VersionedTable(
+      entityName: 'asset_face_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [
+        _column_0,
+        _column_36,
+        _column_76,
+        _column_77,
+        _column_78,
+        _column_79,
+        _column_80,
+        _column_81,
+        _column_82,
+        _column_83,
+        _column_102,
+        _column_18,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape18 storeEntity = Shape18(
+    source: i0.VersionedTable(
+      entityName: 'store_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [_column_87, _column_88, _column_89],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape31 trashedLocalAssetEntity = Shape31(
+    source: i0.VersionedTable(
+      entityName: 'trashed_local_asset_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id, album_id)'],
+      columns: [
+        _column_1,
+        _column_8,
+        _column_9,
+        _column_5,
+        _column_10,
+        _column_11,
+        _column_12,
+        _column_0,
+        _column_95,
+        _column_22,
+        _column_14,
+        _column_23,
+        _column_97,
+        _column_103,
+      ],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  late final Shape32 assetEditEntity = Shape32(
+    source: i0.VersionedTable(
+      entityName: 'asset_edit_entity',
+      withoutRowId: true,
+      isStrict: true,
+      tableConstraints: ['PRIMARY KEY(id)'],
+      columns: [_column_0, _column_36, _column_104, _column_105, _column_106],
+      attachedDatabase: database,
+    ),
+    alias: null,
+  );
+  final i1.Index idxPartnerSharedWithId = i1.Index(
+    'idx_partner_shared_with_id',
+    'CREATE INDEX IF NOT EXISTS idx_partner_shared_with_id ON partner_entity (shared_with_id)',
+  );
+  final i1.Index idxLatLng = i1.Index(
+    'idx_lat_lng',
+    'CREATE INDEX IF NOT EXISTS idx_lat_lng ON remote_exif_entity (latitude, longitude)',
+  );
+  final i1.Index idxRemoteAlbumAssetAlbumAsset = i1.Index(
+    'idx_remote_album_asset_album_asset',
+    'CREATE INDEX IF NOT EXISTS idx_remote_album_asset_album_asset ON remote_album_asset_entity (album_id, asset_id)',
+  );
+  final i1.Index idxRemoteAssetCloudId = i1.Index(
+    'idx_remote_asset_cloud_id',
+    'CREATE INDEX IF NOT EXISTS idx_remote_asset_cloud_id ON remote_asset_cloud_id_entity (cloud_id)',
+  );
+  final i1.Index idxPersonOwnerId = i1.Index(
+    'idx_person_owner_id',
+    'CREATE INDEX IF NOT EXISTS idx_person_owner_id ON person_entity (owner_id)',
+  );
+  final i1.Index idxAssetFacePersonId = i1.Index(
+    'idx_asset_face_person_id',
+    'CREATE INDEX IF NOT EXISTS idx_asset_face_person_id ON asset_face_entity (person_id)',
+  );
+  final i1.Index idxAssetFaceAssetId = i1.Index(
+    'idx_asset_face_asset_id',
+    'CREATE INDEX IF NOT EXISTS idx_asset_face_asset_id ON asset_face_entity (asset_id)',
+  );
+  final i1.Index idxTrashedLocalAssetChecksum = i1.Index(
+    'idx_trashed_local_asset_checksum',
+    'CREATE INDEX IF NOT EXISTS idx_trashed_local_asset_checksum ON trashed_local_asset_entity (checksum)',
+  );
+  final i1.Index idxTrashedLocalAssetAlbum = i1.Index(
+    'idx_trashed_local_asset_album',
+    'CREATE INDEX IF NOT EXISTS idx_trashed_local_asset_album ON trashed_local_asset_entity (album_id)',
+  );
+  final i1.Index idxAssetEditAssetId = i1.Index(
+    'idx_asset_edit_asset_id',
+    'CREATE INDEX IF NOT EXISTS idx_asset_edit_asset_id ON asset_edit_entity (asset_id)',
+  );
+}
+
+class Shape32 extends i0.VersionedTable {
+  Shape32({required super.source, required super.alias}) : super.aliased();
+  i1.GeneratedColumn<String> get id =>
+      columnsByName['id']! as i1.GeneratedColumn<String>;
+  i1.GeneratedColumn<String> get assetId =>
+      columnsByName['asset_id']! as i1.GeneratedColumn<String>;
+  i1.GeneratedColumn<int> get action =>
+      columnsByName['action']! as i1.GeneratedColumn<int>;
+  i1.GeneratedColumn<i2.Uint8List> get parameters =>
+      columnsByName['parameters']! as i1.GeneratedColumn<i2.Uint8List>;
+  i1.GeneratedColumn<int> get sequence =>
+      columnsByName['sequence']! as i1.GeneratedColumn<int>;
+}
+
+i1.GeneratedColumn<int> _column_104(String aliasedName) =>
+    i1.GeneratedColumn<int>(
+      'action',
+      aliasedName,
+      false,
+      type: i1.DriftSqlType.int,
+    );
+i1.GeneratedColumn<i2.Uint8List> _column_105(String aliasedName) =>
+    i1.GeneratedColumn<i2.Uint8List>(
+      'parameters',
+      aliasedName,
+      false,
+      type: i1.DriftSqlType.blob,
+    );
+i1.GeneratedColumn<int> _column_106(String aliasedName) =>
+    i1.GeneratedColumn<int>(
+      'sequence',
+      aliasedName,
+      false,
+      type: i1.DriftSqlType.int,
+    );
 i0.MigrationStepWithVersion migrationSteps({
   required Future<void> Function(i1.Migrator m, Schema2 schema) from1To2,
   required Future<void> Function(i1.Migrator m, Schema3 schema) from2To3,
@@ -9510,6 +10069,7 @@ i0.MigrationStepWithVersion migrationSteps({
   required Future<void> Function(i1.Migrator m, Schema19 schema) from18To19,
   required Future<void> Function(i1.Migrator m, Schema20 schema) from19To20,
   required Future<void> Function(i1.Migrator m, Schema21 schema) from20To21,
+  required Future<void> Function(i1.Migrator m, Schema22 schema) from21To22,
 }) {
   return (currentVersion, database) async {
     switch (currentVersion) {
@@ -9613,6 +10173,11 @@ i0.MigrationStepWithVersion migrationSteps({
         final migrator = i1.Migrator(database, schema);
         await from20To21(migrator, schema);
         return 21;
+      case 21:
+        final schema = Schema22(database: database);
+        final migrator = i1.Migrator(database, schema);
+        await from21To22(migrator, schema);
+        return 22;
       default:
         throw ArgumentError.value('Unknown migration from $currentVersion');
     }
@@ -9640,6 +10205,7 @@ i1.OnUpgrade stepByStep({
   required Future<void> Function(i1.Migrator m, Schema19 schema) from18To19,
   required Future<void> Function(i1.Migrator m, Schema20 schema) from19To20,
   required Future<void> Function(i1.Migrator m, Schema21 schema) from20To21,
+  required Future<void> Function(i1.Migrator m, Schema22 schema) from21To22,
 }) => i0.VersionedSchema.stepByStepHelper(
   step: migrationSteps(
     from1To2: from1To2,
@@ -9662,5 +10228,6 @@ i1.OnUpgrade stepByStep({
     from18To19: from18To19,
     from19To20: from19To20,
     from20To21: from20To21,
+    from21To22: from21To22,
   ),
 );

mobile/lib/infrastructure/repositories/sync_api.repository.dart

@@ -48,6 +48,7 @@ class SyncApiRepository {
           SyncRequestType.usersV1,
           SyncRequestType.assetsV1,
           SyncRequestType.assetExifsV1,
+          if (serverVersion >= const SemVer(major: 2, minor: 6, patch: 0)) SyncRequestType.assetEditsV1,
           SyncRequestType.assetMetadataV1,
           SyncRequestType.partnersV1,
           SyncRequestType.partnerAssetsV1,
@@ -151,6 +152,8 @@ const _kResponseMap = <SyncEntityType, Function(Object)>{
   SyncEntityType.assetV1: SyncAssetV1.fromJson,
   SyncEntityType.assetDeleteV1: SyncAssetDeleteV1.fromJson,
   SyncEntityType.assetExifV1: SyncAssetExifV1.fromJson,
+  SyncEntityType.assetEditV1: SyncAssetEditV1.fromJson,
+  SyncEntityType.assetEditDeleteV1: SyncAssetEditDeleteV1.fromJson,
   SyncEntityType.assetMetadataV1: SyncAssetMetadataV1.fromJson,
   SyncEntityType.assetMetadataDeleteV1: SyncAssetMetadataDeleteV1.fromJson,
   SyncEntityType.partnerAssetV1: SyncAssetV1.fromJson,

mobile/lib/infrastructure/repositories/sync_stream.repository.dart

@@ -5,9 +5,11 @@ import 'package:drift/drift.dart';
 import 'package:immich_mobile/constants/constants.dart';
 import 'package:immich_mobile/domain/models/album/album.model.dart';
 import 'package:immich_mobile/domain/models/asset/base_asset.model.dart';
+import 'package:immich_mobile/domain/models/asset_edit.model.dart';
 import 'package:immich_mobile/domain/models/memory.model.dart';
 import 'package:immich_mobile/domain/models/user.model.dart';
 import 'package:immich_mobile/domain/models/user_metadata.model.dart';
+import 'package:immich_mobile/infrastructure/entities/asset_edit.entity.drift.dart';
 import 'package:immich_mobile/infrastructure/entities/asset_face.entity.drift.dart';
 import 'package:immich_mobile/infrastructure/entities/auth_user.entity.drift.dart';
 import 'package:immich_mobile/infrastructure/entities/exif.entity.drift.dart';
@@ -26,8 +28,8 @@ import 'package:immich_mobile/infrastructure/entities/user_metadata.entity.drift
 import 'package:immich_mobile/infrastructure/repositories/db.repository.dart';
 import 'package:immich_mobile/infrastructure/utils/exif.converter.dart';
 import 'package:logging/logging.dart';
-import 'package:openapi/api.dart' as api show AssetVisibility, AlbumUserRole, UserMetadataKey;
+import 'package:openapi/api.dart' as api show AssetVisibility, AlbumUserRole, UserMetadataKey, AssetEditAction;
-import 'package:openapi/api.dart' hide AssetVisibility, AlbumUserRole, UserMetadataKey;
+import 'package:openapi/api.dart' hide AlbumUserRole, UserMetadataKey, AssetEditAction, AssetVisibility;
 
 class SyncStreamRepository extends DriftDatabaseRepository {
   final Logger _logger = Logger('DriftSyncStreamRepository');
@@ -58,6 +60,7 @@ class SyncStreamRepository extends DriftDatabaseRepository {
           await _db.userEntity.deleteAll();
           await _db.userMetadataEntity.deleteAll();
           await _db.remoteAssetCloudIdEntity.deleteAll();
+          await _db.assetEditEntity.deleteAll();
         });
         await _db.customStatement('PRAGMA foreign_keys = ON');
       });
@@ -322,6 +325,63 @@ class SyncStreamRepository extends DriftDatabaseRepository {
     }
   }
 
+  Future<void> updateAssetEditsV1(Iterable<SyncAssetEditV1> data, {String debugLabel = 'user'}) async {
+    try {
+      await _db.batch((batch) {
+        for (final edit in data) {
+          final companion = AssetEditEntityCompanion(
+            id: Value(edit.id),
+            assetId: Value(edit.assetId),
+            action: Value(edit.action.toAssetEditAction()),
+            parameters: Value(edit.parameters as Map<String, Object?>),
+            sequence: Value(edit.sequence),
+          );
+
+          batch.insert(_db.assetEditEntity, companion, onConflict: DoUpdate((_) => companion));
+        }
+      });
+    } catch (error, stack) {
+      _logger.severe('Error: updateAssetEditsV1 - $debugLabel', error, stack);
+      rethrow;
+    }
+  }
+
+  Future<void> replaceAssetEditsV1(String assetId, Iterable<SyncAssetEditV1> data, {String debugLabel = 'user'}) async {
+    try {
+      await _db.batch((batch) {
+        batch.deleteWhere(_db.assetEditEntity, (row) => row.assetId.equals(assetId));
+
+        for (final edit in data) {
+          final companion = AssetEditEntityCompanion(
+            id: Value(edit.id),
+            assetId: Value(edit.assetId),
+            action: Value(edit.action.toAssetEditAction()),
+            parameters: Value(edit.parameters as Map<String, Object?>),
+            sequence: Value(edit.sequence),
+          );
+
+          batch.insert(_db.assetEditEntity, companion);
+        }
+      });
+    } catch (error, stack) {
+      _logger.severe('Error: replaceAssetEditsV1 - $debugLabel', error, stack);
+      rethrow;
+    }
+  }
+
+  Future<void> deleteAssetEditsV1(Iterable<SyncAssetEditDeleteV1> data, {String debugLabel = 'user'}) async {
+    try {
+      await _db.batch((batch) {
+        for (final edit in data) {
+          batch.deleteWhere(_db.assetEditEntity, (row) => row.id.equals(edit.editId));
+        }
+      });
+    } catch (error, stack) {
+      _logger.severe('Error: deleteAssetEditsV1 - $debugLabel', error, stack);
+      rethrow;
+    }
+  }
+
   Future<void> deleteAlbumsV1(Iterable<SyncAlbumDeleteV1> data) async {
     try {
       await _db.batch((batch) {
@@ -798,3 +858,12 @@ extension on String {
 extension on UserAvatarColor {
   AvatarColor? toAvatarColor() => AvatarColor.values.firstWhereOrNull((c) => c.name == value);
 }
+
+extension on api.AssetEditAction {
+  AssetEditAction toAssetEditAction() => switch (this) {
+    api.AssetEditAction.crop => AssetEditAction.crop,
+    api.AssetEditAction.rotate => AssetEditAction.rotate,
+    api.AssetEditAction.mirror => AssetEditAction.mirror,
+    _ => AssetEditAction.other,
+  };
+}

mobile/lib/providers/websocket.provider.dart

@@ -310,7 +310,7 @@ class WebsocketNotifier extends StateNotifier<WebsocketState> {
   }
 
   void _handleSyncAssetEditReady(dynamic data) {
-    unawaited(_ref.read(backgroundSyncProvider).syncWebsocketEditBatch([data]));
+    unawaited(_ref.read(backgroundSyncProvider).syncWebsocketEdit(data));
   }
 
   void _processBatchedAssetUploadReady() {

mobile/test/drift/main/generated/schema.dart

@@ -24,6 +24,7 @@ import 'schema_v18.dart' as v18;
 import 'schema_v19.dart' as v19;
 import 'schema_v20.dart' as v20;
 import 'schema_v21.dart' as v21;
+import 'schema_v22.dart' as v22;
 
 class GeneratedHelper implements SchemaInstantiationHelper {
   @override
@@ -71,6 +72,8 @@ class GeneratedHelper implements SchemaInstantiationHelper {
         return v20.DatabaseAtV20(db);
       case 21:
         return v21.DatabaseAtV21(db);
+      case 22:
+        return v22.DatabaseAtV22(db);
       default:
         throw MissingSchemaException(version, versions);
     }
@@ -98,5 +101,6 @@ class GeneratedHelper implements SchemaInstantiationHelper {
     19,
     20,
     21,
+    22,
   ];
 }