Change default to no retry for write operations

Author: kirkmorrow

packages/dart/lib/parse_server_sdk.dart

@@ -120,6 +120,7 @@ class Parse {
     ParseUserConstructor? parseUserConstructor,
     ParseFileConstructor? parseFileConstructor,
     List<int>? restRetryIntervals,
+    List<int>? restRetryIntervalsForWrites,
     List<int>? liveListRetryIntervals,
     ParseConnectivityProvider? connectivityProvider,
     String? fileDirectory,
@@ -147,6 +148,7 @@ class Parse {
       parseUserConstructor: parseUserConstructor,
       parseFileConstructor: parseFileConstructor,
       restRetryIntervals: restRetryIntervals,
+      restRetryIntervalsForWrites: restRetryIntervalsForWrites,
       liveListRetryIntervals: liveListRetryIntervals,
       connectivityProvider: connectivityProvider,
       fileDirectory: fileDirectory,

packages/dart/lib/src/data/parse_core_data.dart

@@ -33,6 +33,7 @@ class ParseCoreData {
     ParseUserConstructor? parseUserConstructor,
     ParseFileConstructor? parseFileConstructor,
     List<int>? restRetryIntervals,
+    List<int>? restRetryIntervalsForWrites,
     List<int>? liveListRetryIntervals,
     ParseConnectivityProvider? connectivityProvider,
     String? fileDirectory,
@@ -55,6 +56,8 @@ class ParseCoreData {
     _instance.securityContext = securityContext;
     _instance.restRetryIntervals =
         restRetryIntervals ?? <int>[0, 250, 500, 1000, 2000];
+    _instance.restRetryIntervalsForWrites =
+        restRetryIntervalsForWrites ?? <int>[];
     _instance.liveListRetryIntervals =
         liveListRetryIntervals ??
         (parseIsWeb
@@ -93,6 +96,7 @@ class ParseCoreData {
   late CoreStore storage;
   late ParseSubClassHandler _subClassHandler;
   late List<int> restRetryIntervals;
+  late List<int> restRetryIntervalsForWrites;
   late List<int> liveListRetryIntervals;
   ParseConnectivityProvider? connectivityProvider;
   String? fileDirectory;

packages/dart/lib/src/network/parse_dio_client.dart

@@ -108,6 +108,7 @@ class ParseDioClient extends ParseClient {
     ParseNetworkOptions? options,
   }) async {
     return executeWithRetry(
+      isWriteOperation: true,
       operation: () async {
         try {
           final dio.Response<String> dioResponse = await _client.put<String>(
@@ -137,6 +138,7 @@ class ParseDioClient extends ParseClient {
     ParseNetworkOptions? options,
   }) async {
     return executeWithRetry(
+      isWriteOperation: true,
       operation: () async {
         try {
           final dio.Response<String> dioResponse = await _client.post<String>(
@@ -168,6 +170,7 @@ class ParseDioClient extends ParseClient {
     dynamic cancelToken,
   }) async {
     return executeWithRetry(
+      isWriteOperation: true,
       operation: () async {
         try {
           final dio.Response<String> dioResponse = await _client.post<String>(

packages/dart/lib/src/network/parse_http_client.dart

@@ -103,6 +103,7 @@ class ParseHTTPClient extends ParseClient {
     ParseNetworkOptions? options,
   }) async {
     return executeWithRetry(
+      isWriteOperation: true,
       operation: () async {
         try {
           final http.Response response = await _client.put(
@@ -131,6 +132,7 @@ class ParseHTTPClient extends ParseClient {
     ParseNetworkOptions? options,
   }) async {
     return executeWithRetry(
+      isWriteOperation: true,
       operation: () async {
         try {
           final http.Response response = await _client.post(
@@ -161,6 +163,7 @@ class ParseHTTPClient extends ParseClient {
     dynamic cancelToken,
   }) async {
     return executeWithRetry(
+      isWriteOperation: true,
       operation: () async {
         try {
           final http.Response response = await _client.post(

packages/dart/lib/src/network/parse_network_retry.dart

@@ -24,21 +24,33 @@ part of '../../parse_server_sdk.dart';
 ///
 /// Important Note on Non-Idempotent Methods (POST/PUT):
 ///
-/// This retry mechanism is applied to ALL HTTP methods including POST and PUT.
-/// While GET and DELETE are generally safe to retry, POST and PUT operations
-/// may cause duplicate operations if the original request succeeded but the
-/// response was lost or corrupted.
-///
 /// **Parse Server does not provide automatic optimistic locking or built-in
-/// idempotency guarantees for POST/PUT operations.** Retrying these methods
-/// can result in duplicate data creation or unintended state changes.
+/// idempotency guarantees for POST/PUT operations.** To prevent duplicate
+/// data creation or unintended state changes, this SDK defaults to **no retries**
+/// for write operations (POST/PUT/postBytes).
+///
+/// Default Behavior:
+/// - **Write operations (POST/PUT)**: No retries (`restRetryIntervalsForWrites = []`)
+/// - **Read operations (GET)**: Retries enabled (`restRetryIntervals = [0, 250, 500, 1000, 2000]`)
+/// - **DELETE operations**: Retries enabled (generally safe to retry)
 ///
-/// To mitigate retry risks for critical operations:
+/// If you need to enable retries for write operations, configure
+/// `restRetryIntervalsForWrites` during initialization. Consider these mitigations:
 /// - Implement application-level idempotency keys or version tracking
-/// - Disable retries for create/update operations by setting
-///   `ParseCoreData().restRetryIntervals = []` before critical calls
 /// - Use Parse's experimental `X-Parse-Request-Id` header (if available)
 ///   with explicit duplicate detection in your application logic
+/// - Use conservative retry intervals (e.g., `[1000, 2000]`) to allow time
+///   for server-side processing before retrying
+///
+/// Example:
+/// ```dart
+/// await Parse().initialize(
+///   'appId',
+///   'serverUrl',
+///   // Enable retries for writes (use with caution)
+///   restRetryIntervalsForWrites: [1000, 2000],
+/// );
+/// ```
 ///
 /// Note: Retries only occur on network-level failures (status -1), not on
 /// successful operations that return Parse error codes
@@ -58,6 +70,9 @@ part of '../../parse_server_sdk.dart';
 /// Parameters:
 ///
 /// - [operation]: The network operation to execute and potentially retry
+/// - [isWriteOperation]: Whether this is a write operation (POST/PUT).
+///   Defaults to `false`. When `true`, uses [ParseCoreData.restRetryIntervalsForWrites]
+///   which defaults to no retries to prevent duplicate creates/updates.
 /// - [debug]: Whether to log retry attempts (defaults to [ParseCoreData.debug])
 ///
 /// Returns:
@@ -66,9 +81,12 @@ part of '../../parse_server_sdk.dart';
 /// after all retry attempts are exhausted.
 Future<T> executeWithRetry<T extends ParseNetworkResponse>({
   required Future<T> Function() operation,
+  bool isWriteOperation = false,
   bool? debug,
 }) async {
-  final List<int> retryIntervals = ParseCoreData().restRetryIntervals;
+  final List<int> retryIntervals = isWriteOperation
+      ? ParseCoreData().restRetryIntervalsForWrites
+      : ParseCoreData().restRetryIntervals;
   final bool debugEnabled = debug ?? ParseCoreData().debug;
 
   // Enforce maximum retry limit to prevent excessive attempts

packages/dart/test/src/network/parse_network_retry_test.dart

@@ -510,4 +510,131 @@ void main() {
       expect(result.data, contains('"error"'));
     });
   });
+
+  group('Write Operations (POST/PUT) Retry Behavior', () {
+    test(
+      'should not retry write operations by default (restRetryIntervalsForWrites is empty)',
+      () async {
+        int callCount = 0;
+        final result = await executeWithRetry(
+          isWriteOperation: true,
+          operation: () async {
+            callCount++;
+            return ParseNetworkResponse(
+              data: '{"code":-1,"error":"NetworkError"}',
+              statusCode: -1,
+            );
+          },
+        );
+
+        // Should only be called once (no retries)
+        expect(callCount, 1);
+        expect(result.statusCode, -1);
+      },
+    );
+
+    test(
+      'should use restRetryIntervalsForWrites when configured for write operations',
+      () async {
+        int callCount = 0;
+        final oldWriteIntervals = ParseCoreData().restRetryIntervalsForWrites;
+        ParseCoreData().restRetryIntervalsForWrites = [0, 10]; // 2 retries
+
+        final result = await executeWithRetry(
+          isWriteOperation: true,
+          operation: () async {
+            callCount++;
+            return ParseNetworkResponse(
+              data: '{"code":-1,"error":"NetworkError"}',
+              statusCode: -1,
+            );
+          },
+        );
+
+        // Should be called: initial + 2 retries = 3 times
+        expect(callCount, 3);
+        expect(result.statusCode, -1);
+
+        ParseCoreData().restRetryIntervalsForWrites = oldWriteIntervals;
+      },
+    );
+
+    test(
+      'should use restRetryIntervals for read operations (isWriteOperation=false)',
+      () async {
+        int callCount = 0;
+        final oldIntervals = ParseCoreData().restRetryIntervals;
+        ParseCoreData().restRetryIntervals = [0, 10]; // 2 retries
+
+        final result = await executeWithRetry(
+          isWriteOperation: false,
+          operation: () async {
+            callCount++;
+            return ParseNetworkResponse(
+              data: '{"code":-1,"error":"NetworkError"}',
+              statusCode: -1,
+            );
+          },
+        );
+
+        // Should be called: initial + 2 retries = 3 times
+        expect(callCount, 3);
+        expect(result.statusCode, -1);
+
+        ParseCoreData().restRetryIntervals = oldIntervals;
+      },
+    );
+
+    test(
+      'write operations succeed immediately on success without retries',
+      () async {
+        int callCount = 0;
+        final result = await executeWithRetry(
+          isWriteOperation: true,
+          operation: () async {
+            callCount++;
+            return ParseNetworkResponse(
+              data: '{"objectId":"abc123"}',
+              statusCode: 201,
+            );
+          },
+        );
+
+        expect(callCount, 1);
+        expect(result.statusCode, 201);
+      },
+    );
+
+    test(
+      'write operations can be configured with custom retry intervals',
+      () async {
+        int callCount = 0;
+        final oldWriteIntervals = ParseCoreData().restRetryIntervalsForWrites;
+        ParseCoreData().restRetryIntervalsForWrites = [5, 10, 15];
+
+        final result = await executeWithRetry(
+          isWriteOperation: true,
+          operation: () async {
+            callCount++;
+            if (callCount < 3) {
+              return ParseNetworkResponse(
+                data: '{"code":-1,"error":"NetworkError"}',
+                statusCode: -1,
+              );
+            }
+            return ParseNetworkResponse(
+              data: '{"objectId":"abc123"}',
+              statusCode: 201,
+            );
+          },
+        );
+
+        // Should succeed on third attempt
+        expect(callCount, 3);
+        expect(result.statusCode, 201);
+
+        ParseCoreData().restRetryIntervalsForWrites = oldWriteIntervals;
+      },
+    );
+  });
 }