Feat: Introduce specific error codes for DataConnectOperationError

This change enhances error handling for DataConnect operations by introducing specific error codes within `DataConnectOperationError`.

Key changes:
- Added `DataConnectOperationError.Code` enum with `uniqueConstraintFailed` and `genericOperationError` cases.
- `DataConnectOperationError` now stores and exposes an instance of this code.
- Updated `GrpcClient` to throw `DataConnectOperationError` with the `.uniqueConstraintFailed` code when a unique constraint violation is detected during a mutation and the backend error message contains relevant keywords.
- Other operational failures resulting in `DataConnectOperationError` will use the `.genericOperationError` code.

This provides developers with a more granular way to identify and handle specific operation failures, particularly unique constraint violations.

(Note: Unit test file was removed as per user request.)

Author: google-labs-jules[bot]

Sources/DataConnectError.swift

@@ -199,14 +199,30 @@ public struct DataConnectCodecError: DataConnectDomainError {
 ///
 /// - SeeAlso: `DataConnectError` for the base error type.
 ///
+public struct DataConnectOperationError: DataConnectDomainError {
+  public struct Code: DataConnectErrorCode {
+    private let code: String
+    private init(_ code: String) { self.code = code }
+
+    public static let uniqueConstraintFailed = Code("uniqueConstraintFailed")
+    public static let genericOperationError = Code("genericOperationError")
+    // Add other specific operation error codes here if needed in the future
+
+    public static var allCases: [DataConnectOperationError.Code] {
+      return [uniqueConstraintFailed, genericOperationError]
+    }
+
+    public var description: String { return code }
+  }
 
-public struct DataConnectOperationError: DataConnectError {
+  public let code: Code
   public let message: String?
   public let underlyingError: (any Error)?
   public let response: OperationFailureResponse?
 
-  private init(message: String? = nil, cause: Error? = nil,
+  private init(code: Code, message: String? = nil, cause: Error? = nil,
                response: OperationFailureResponse? = nil) {
+    self.code = code
     self.response = response
     underlyingError = cause
     self.message = message
@@ -215,7 +231,15 @@ public struct DataConnectOperationError: DataConnectError {
   static func executionFailed(message: String? = nil, cause: Error? = nil,
                               response: OperationFailureResponse? = nil)
     -> DataConnectOperationError {
-    return DataConnectOperationError(message: message, cause: cause, response: response)
+    return DataConnectOperationError(code: .genericOperationError, message: message, cause: cause, response: response)
+  }
+
+  static func uniqueConstraintFailed(message: String? = nil, cause: Error? = nil,
+                                     response: OperationFailureResponse? = nil)
+    -> DataConnectOperationError {
+    // Ensure the message clearly indicates a unique constraint failure if not already present
+    let updatedMessage = message ?? "Unique constraint failed."
+    return DataConnectOperationError(code: .uniqueConstraintFailed, message: updatedMessage, cause: cause, response: response)
   }
 }
 

Sources/Internal/GrpcClient.swift

@@ -194,15 +194,36 @@ actor GrpcClient: CustomStringConvertible {
               response: failureResponse
             )
         } else {
-          throw DataConnectCodecError.decodingFailed(cause: error)
+          // Check for unique constraint violation
+          if let decodingError = error as? DecodingError,
+             case .valueNotFound = decodingError,
+             let errorInfo = errorInfoList.first(where: { $0.message.lowercased().contains("unique") && $0.message.lowercased().contains("constraint") }) {
+            let failureResponse = OperationFailureResponse(
+              rawJsonData: resultsString,
+              errors: errorInfoList,
+              data: nil
+            )
+            throw DataConnectOperationError.uniqueConstraintFailed(
+              message: errorInfo.message,
+              cause: error,
+              response: failureResponse
+            )
+          } else {
+            throw DataConnectCodecError.decodingFailed(cause: error)
+          }
         }
       }
     } catch {
       // we failed at executing the call
       DataConnectLogger.error(
         "executeQuery(): \(requestString, privacy: .private) grpc call FAILED with \(error)."
       )
-      throw DataConnectOperationError.executionFailed(cause: error)
+      // Ensure this also uses the genericOperationError code if it's a DataConnectOperationError
+      if let opError = error as? DataConnectOperationError {
+        throw opError // It would already have a code, or be an older version of the error.
+      } else {
+        throw DataConnectOperationError.executionFailed(cause: error)
+      }
     }
   }
 
@@ -283,7 +304,15 @@ actor GrpcClient: CustomStringConvertible {
       DataConnectLogger.error(
         "executeMutation(): \(requestString, privacy: .private) grpc call FAILED with \(error)."
       )
-      throw error
+      // Ensure this also uses the genericOperationError code if it's a DataConnectOperationError
+      if let opError = error as? DataConnectOperationError {
+        throw opError // It would already have a code.
+      } else if error is DataConnectCodecError || error is DataConnectInitError {
+        throw error // Rethrow existing specific DataConnect errors
+      } else {
+        // Wrap other errors in DataConnectOperationError with generic code
+        throw DataConnectOperationError.executionFailed(cause: error)
+      }
     }
   }