updateDoc method

@protected Future<TurboResponse<DTO>> updateDoc({ Transaction? transaction, required String id, required UpdateDocDef<DTO, MODEL> doc, TWriteable remoteUpdateRequestBuilder(DTO doc)?, bool doNotifyListeners = true, })

Updates a document both locally and in Firestore.

Performs an optimistic update by updating the local state first, then syncing with Firestore. If the remote update fails, the local state remains updated.

Sends only fields that changed since the last known local state. The pre-mutation DTO is captured before the local state is updated and forwarded to the API as previousWriteable so the API can compute a minimal diff payload (and skip the write entirely on a no-op).

If remoteUpdateRequestBuilder is provided, it must be deterministic — it is applied to BOTH the previous DTO and the new DTO so the diff inputs share the same shape.

Parameters:

• id - The document ID
• doc - The function to update the document
• remoteUpdateRequestBuilder - Optional function to build the remote update request
• doNotifyListeners - Whether to notify listeners of the change
• transaction - Optional transaction for atomic operations

Returns a TurboResponse with the updated document reference

Implementation

@protected
Future<TurboResponse<DTO>> updateDoc({
  Transaction? transaction,
  required String id,
  required UpdateDocDef<DTO, MODEL> doc,
  TWriteable Function(DTO doc)? remoteUpdateRequestBuilder,
  bool doNotifyListeners = true,
}) async {
  try {
    log.debug('Updating doc with id: $id');
    final DTO previousDto = _doc.value.dto;
    final pDoc = updateLocalDoc(
      id: id,
      doc: doc,
      doNotifyListeners: doNotifyListeners,
    );
    final TWriteable newWriteable =
        remoteUpdateRequestBuilder?.call(pDoc) ?? pDoc as TWriteable;
    final TWriteable previousForRemote = remoteUpdateRequestBuilder != null
        ? remoteUpdateRequestBuilder(previousDto)
        : previousDto as TWriteable;
    final future = api.updateDoc(
      writeable: newWriteable,
      previousWriteable: previousForRemote,
      id: id,
      transaction: transaction,
    );
    final turboResponse = await future;
    if (transaction != null) {
      turboResponse.throwWhenFail();
    }
    return turboResponse.mapSuccess((_) => pDoc);
  } catch (error, stackTrace) {
    if (transaction != null) rethrow;
    log.error(
      '$error caught while updating doc',
      error: error,
      stackTrace: stackTrace,
    );
    return TurboResponse.fail(error: error);
  }
}