fix: Better error reporting for structure evaluations

Sources/Confidence/ConfidenceError.swift

@@ -9,6 +9,28 @@ public enum ConfidenceError: Error, Equatable {
     case internalError(message: String)
     case parseError(message: String)
     case invalidContextInMessage
+
+    var errorCode: ErrorCode {
+        switch self {
+        case .grpcError(let message),
+            .cacheError(let message),
+            .corruptedCache(let message),
+            .badRequest(let message?),
+            .internalError(let message):
+            return .generalError(message: message)
+
+        case .flagNotFoundError:
+            return .flagNotFound
+
+        case .parseError(let message):
+            return .parseError(message: message)
+
+        case .invalidContextInMessage:
+            return .invalidContext
+        case .badRequest(message: .none):
+            return .generalError(message: "unknown error")
+        }
+    }
 }
 
 extension ConfidenceError: CustomStringConvertible {

Sources/Confidence/FlagEvaluation.swift

@@ -8,12 +8,14 @@ public struct Evaluation<T> {
     public let errorMessage: String?
 }
 
-public enum ErrorCode {
+public enum ErrorCode: Equatable {
     case providerNotReady
     case invalidContext
     case flagNotFound
     case evaluationError
+    case parseError(message: String)
     case typeMismatch
+    case generalError(message: String)
 }
 
 struct FlagResolution: Encodable, Decodable, Equatable {
@@ -130,6 +132,14 @@ extension FlagResolution {
                     errorMessage: nil
                 )
             }
+        } catch let error as ConfidenceError {
+            return Evaluation(
+                value: defaultValue,
+                variant: nil,
+                reason: .error,
+                errorCode: error.errorCode,
+                errorMessage: error.description
+            )
         } catch {
             return Evaluation(
                 value: defaultValue,
@@ -206,7 +216,7 @@ extension FlagResolution {
 
     private func getValue(path: [String], value: ConfidenceValue) throws -> ConfidenceValue {
         if path.isEmpty {
-            guard value.asStructure() != nil else {
+            guard value.asStructure() == nil else {
                 throw ConfidenceError.parseError(
                     message: "Flag path must contain path to the field for non-object values")
             }

Sources/ConfidenceProvider/ConfidenceFeatureProvider.swift

@@ -99,6 +99,7 @@ public class ConfidenceFeatureProvider: FeatureProvider {
     public func getObjectEvaluation(key: String, defaultValue: OpenFeature.Value, context: EvaluationContext?)
     throws -> OpenFeature.ProviderEvaluation<OpenFeature.Value>
     {
+        // Convert Struct Value to 
         try confidence.getEvaluation(key: key, defaultValue: defaultValue).toProviderEvaluation()
     }
 
@@ -130,6 +131,10 @@ extension Evaluation {
                 throw OpenFeatureError.generalError(message: self.errorMessage ?? "unknown error")
             case .typeMismatch:
                 throw OpenFeatureError.typeMismatchError
+            case .parseError(message: let message):
+                throw OpenFeatureError.parseError(message: message)
+            case .generalError(message: let message):
+                throw OpenFeatureError.generalError(message: message)
             }
         }
         return ProviderEvaluation(

Tests/ConfidenceProviderTests/ConfidenceProviderTest.swift

@@ -129,6 +129,54 @@ class ConfidenceProviderTest: XCTestCase {
             }
         }
     }
+
+    func testProviderThrowsParseErrorOnObjectEval() async throws {
+        let context = MutableContext(targetingKey: "t")
+        let readyExpectation = XCTestExpectation(description: "Ready")
+        let storage = StorageMock()
+        class FakeClient: ConfidenceResolveClient {
+            var resolvedValues: [ResolvedValue] = [
+                ResolvedValue(
+                variant: "variant1",
+                value: .init(structure: ["int": .init(integer: 42)]),
+                flag: "flagName",
+                resolveReason: .match,
+                shouldApply: true)
+            ]
+            func resolve(ctx: ConfidenceStruct) async throws -> ResolvesResult {
+                return .init(resolvedValues: resolvedValues, resolveToken: "token")
+            }
+        }
+
+        let confidence = Confidence.Builder(clientSecret: "test")
+            .withContext(initialContext: ["targeting_key": .init(string: "t")])
+            .withFlagResolverClient(flagResolver: FakeClient())
+            .withStorage(storage: storage)
+            .build()
+
+        let provider = ConfidenceFeatureProvider(confidence: confidence, initializationStrategy: .fetchAndActivate)
+        OpenFeatureAPI.shared.setProvider(provider: provider)
+        let cancellable = OpenFeatureAPI.shared.observe().sink { event in
+            if event == .ready {
+                readyExpectation.fulfill()
+            } else {
+                print(event.debugDescription)
+            }
+        }
+        await fulfillment(of: [readyExpectation], timeout: 1.0)
+        cancellable.cancel()
+        XCTAssertThrowsError(
+            try provider.getIntegerEvaluation(key: "flagName", defaultValue: -1, context: context))
+        { error in
+            if let specificError = error as? OpenFeatureError {
+                XCTAssertEqual(specificError.errorCode(), ErrorCode.parseError)
+                XCTAssertEqual(specificError.description, "Parse error: Flag path " +
+                    "must contain path to the field for non-object values")
+            } else {
+                XCTFail("expected a flag not found error")
+            }
+        }
+    }
 }
 
 private class StorageMock: Storage {

Tests/ConfidenceTests/ConfidenceTest.swift

@@ -201,6 +201,49 @@ class ConfidenceTest: XCTestCase {
         XCTAssertEqual(flagApplier.applyCallCount, 1)
     }
 
+    func testResolveStructureFails() async throws {
+        class FakeClient: ConfidenceResolveClient {
+            var resolveStats: Int = 0
+            var resolvedValues: [ResolvedValue] = []
+            func resolve(ctx: ConfidenceStruct) async throws -> ResolvesResult {
+                self.resolveStats += 1
+                return .init(resolvedValues: resolvedValues, resolveToken: "token")
+            }
+        }
+
+        let client = FakeClient()
+        client.resolvedValues = [
+            ResolvedValue(
+                variant: "control",
+                value: .init(structure: ["size": .init(integer: 3)]),
+                flag: "flag",
+                resolveReason: .match,
+                shouldApply: true)
+        ]
+
+        let confidence = Confidence.Builder(clientSecret: "test")
+            .withContext(initialContext: ["targeting_key": .init(string: "user2")])
+            .withFlagResolverClient(flagResolver: client)
+            .withFlagApplier(flagApplier: flagApplier)
+            .build()
+
+        try await confidence.fetchAndActivate()
+        let evaluation = confidence.getEvaluation(
+            key: "flag",
+            defaultValue: ConfidenceValue.init(structure: [:]))
+
+
+        XCTAssertEqual(client.resolveStats, 1)
+        XCTAssertEqual(evaluation.value, ConfidenceValue.init(structure: [:]))
+        XCTAssertEqual(evaluation.errorCode, .parseError(message:
+            "Flag path must contain path to the field for non-object values"))
+        XCTAssertEqual(evaluation.errorMessage, "Parse error occurred: Flag path must " +
+            "contain path to the field for non-object values")
+        XCTAssertEqual(evaluation.reason, .error)
+        XCTAssertNil(evaluation.variant)
+        XCTAssertEqual(client.resolveStats, 1)
+        XCTAssertEqual(flagApplier.applyCallCount, 0)
+    }
 
     func testResolveIntegerFlagWithInt64() async throws {
         class FakeClient: ConfidenceResolveClient {