chore: kickoff release

Author: phantumcode

AmplifyPlugins/API/Sources/AWSAPIPlugin/Operation/AWSGraphQLSubscriptionTaskRunner.swift

@@ -378,6 +378,31 @@ fileprivate func toAPIError<R: Decodable>(_ errors: [Error], type: R.Type) -> AP
         (hasAuthorizationError ? ": \(APIError.UnauthorizedMessageString)" : "")
     }
 
+#if swift(<5.8)
+    if let errors = errors.cast(to: AppSyncRealTimeRequest.Error.self) {
+        let hasAuthorizationError = errors.contains(where: { $0 == .unauthorized})
+        return APIError.operationError(
+            errorDescription(hasAuthorizationError),
+            "",
+            errors.first
+        )
+    } else if let errors = errors.cast(to: GraphQLError.self) {
+        let hasAuthorizationError = errors.map(\.extensions)
+            .compactMap { $0.flatMap { $0["errorType"]?.stringValue } }
+            .contains(where: { AppSyncErrorType($0) == .unauthorized })
+        return APIError.operationError(
+            errorDescription(hasAuthorizationError),
+            "",
+            GraphQLResponseError<R>.error(errors)
+        )
+    } else {
+        return APIError.operationError(
+            errorDescription(),
+            "",
+            errors.first
+        )
+    }
+#else
     switch errors {
     case let errors as [AppSyncRealTimeRequest.Error]:
         let hasAuthorizationError = errors.contains(where: { $0 == .unauthorized})
@@ -402,5 +427,5 @@ fileprivate func toAPIError<R: Decodable>(_ errors: [Error], type: R.Type) -> AP
             errors.first
         )
     }
-
+#endif
 }

AmplifyPlugins/API/Sources/AWSAPIPlugin/Support/Utils/Array+Error+TypeCast.swift

@@ -0,0 +1,21 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+import Foundation
+
+@_spi(AmplifyAPI)
+extension Array where Element == Error {
+    func cast<T>(to type: T.Type) -> [T]? {
+        self.reduce([]) { partialResult, ele in
+            if let partialResult, let ele = ele as? T {
+                return partialResult + [ele]
+            }
+            return nil
+        }
+    }
+}

AmplifyPlugins/API/Tests/AWSAPIPluginTests/Support/Utils/Array+Error+TypeCastTests.swift

@@ -0,0 +1,62 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+import XCTest
+@testable @_spi(AmplifyAPI) import AWSAPIPlugin
+
+class ArrayWithErrorElementExtensionTests: XCTestCase {
+
+    /**
+     Given: errors with generic protocol type
+     When: cast to the correct underlying concrete type
+     Then: successfully casted to underlying concrete type
+     */
+    func testCast_toCorrectErrorType_returnCastedErrorType() {
+        let errors: [Error] = [
+            Error1(), Error1(), Error1()
+        ]
+
+        let error1s = errors.cast(to: Error1.self)
+        XCTAssertNotNil(error1s)
+        XCTAssertTrue(!error1s!.isEmpty)
+        XCTAssertEqual(errors.count, error1s!.count)
+    }
+
+    /**
+     Given: errors with generic protocol type
+     When: cast to the wong underlying concrete type
+     Then: return nil
+     */
+    func testCast_toWrongErrorType_returnNil() {
+        let errors: [Error] = [
+            Error1(), Error1(), Error1()
+        ]
+
+        let error2s = errors.cast(to: Error2.self)
+        XCTAssertNil(error2s)
+    }
+
+    /**
+     Given: errors with generic protocol type
+     When: some of the elements failed to cast to the underlying concrete type
+     Then: return nil
+     */
+
+    func testCast_partiallyToWrongErrorType_returnNil() {
+        let errors: [Error] = [
+            Error2(), Error2(), Error1()
+        ]
+
+        let error2s = errors.cast(to: Error2.self)
+        XCTAssertNil(error2s)
+    }
+
+    struct Error1: Error { }
+
+    struct Error2: Error { }
+}

AmplifyPlugins/Auth/Sources/AWSCognitoAuthPlugin/Operations/Helpers/FetchAuthSessionOperationHelper.swift

@@ -157,13 +157,21 @@ class FetchAuthSessionOperationHelper: DefaultLogger {
             }
 
         case .service(let error):
-            if let authError = (error as? AuthErrorConvertible)?.authError {
-                let session = AWSAuthCognitoSession(isSignedIn: isSignedIn,
-                                                    identityIdResult: .failure(authError),
-                                                    awsCredentialsResult: .failure(authError),
-                                                    cognitoTokensResult: .failure(authError))
-                return session
+            var authError: AuthError
+            if let convertedAuthError = (error as? AuthErrorConvertible)?.authError {
+                authError = convertedAuthError
+            } else {
+                authError = AuthError.service(
+                    "Unknown service error occurred",
+                    "See the attached error for more details",
+                    error)
             }
+            let session = AWSAuthCognitoSession(
+                isSignedIn: isSignedIn,
+                identityIdResult: .failure(authError),
+                awsCredentialsResult: .failure(authError),
+                cognitoTokensResult: .failure(authError))
+            return session
         default: break
 
         }

AmplifyPlugins/Auth/Tests/AWSCognitoAuthPluginUnitTests/TaskTests/AuthorizationTests/AWSAuthFetchSignInSessionOperationTests.swift

@@ -736,4 +736,61 @@ class AWSAuthFetchSignInSessionOperationTests: BaseAuthorizationTests {
         let identityId = try? (session as? AuthCognitoIdentityProvider)?.getIdentityId().get()
         XCTAssertNotNil(identityId)
     }
+
+    /// Test signedIn session with invalid response for aws credentials
+    ///
+    /// - Given: Given an auth plugin with signedIn state
+    /// - When:
+    ///    - I invoke fetchAuthSession and service throws NSError
+    /// - Then:
+    ///    - I should get an a valid session with the following details:
+    ///         - isSignedIn = true
+    ///         - aws credentails = service error
+    ///         - identity id = service error
+    ///         - cognito tokens = service error
+    ///
+    func testSignInSessionWithNSError() async throws {
+        let initialState = AuthState.configured(
+            AuthenticationState.signedIn(.testData),
+            AuthorizationState.sessionEstablished(
+                AmplifyCredentials.testDataWithExpiredTokens))
+
+        let initAuth: MockIdentityProvider.MockInitiateAuthResponse = { _ in
+            return InitiateAuthOutput(authenticationResult: .init(accessToken: "accessToken",
+                                                                  expiresIn: 1000,
+                                                                  idToken: "idToken",
+                                                                  refreshToken: "refreshToke"))
+        }
+
+        let awsCredentials: MockIdentity.MockGetCredentialsResponse = { _ in
+            throw NSError(domain: NSURLErrorDomain, code: 1, userInfo: nil)
+        }
+        let plugin = configurePluginWith(
+            userPool: { MockIdentityProvider(mockInitiateAuthResponse: initAuth) },
+            identityPool: { MockIdentity(mockGetCredentialsResponse: awsCredentials) },
+            initialState: initialState)
+
+        let session = try await plugin.fetchAuthSession(options: AuthFetchSessionRequest.Options())
+
+        XCTAssertTrue(session.isSignedIn)
+        let credentialsResult = (session as? AuthAWSCredentialsProvider)?.getAWSCredentials()
+        guard case .failure(let error) = credentialsResult, case .service = error else {
+            XCTFail("Should return service error")
+            return
+        }
+
+        let identityIdResult = (session as? AuthCognitoIdentityProvider)?.getIdentityId()
+        guard case .failure(let identityIdError) = identityIdResult,
+              case .service = identityIdError else {
+            XCTFail("Should return service error")
+            return
+        }
+
+        let tokensResult = (session as? AuthCognitoTokensProvider)?.getCognitoTokens()
+        guard case .failure(let tokenError) = tokensResult,
+              case .service = tokenError else {
+            XCTFail("Should return service error")
+            return
+        }
+    }
 }

AmplifyPlugins/DataStore/Sources/AWSDataStorePlugin/Storage/StorageEngine.swift

@@ -206,6 +206,7 @@ final class StorageEngine: StorageEngineBehavior {
                 "Cannot apply a condition on model which does not exist.",
                 "Save the model instance without a condition first.")
             completion(.failure(causedBy: dataStoreError))
+            return
         }
 
         do {

AmplifyPlugins/DataStore/Tests/AWSDataStorePluginTests/Storage/StorageEngineTestsHasOne.swift

@@ -70,6 +70,28 @@ class StorageEngineTestsHasOne: StorageEngineTestsBase {
         }
     }
 
+    /// Given: A model that does not exist
+    /// When: save is called with a predicate
+    /// Then: A DataStoreError.invalidCondition error is returned
+    func testSaveModelWithPredicate_shouldFail() {
+        let team = Team(name: "Team")
+        let saveFinished = expectation(description: "Save finished")
+        storageEngine.save(team, condition: Team.keys.name.beginsWith("T")) { result in
+            defer {
+                saveFinished.fulfill()
+            }
+            guard case .failure(let error) = result,
+                  case . invalidCondition(let errorDescription, let recoverySuggestion, _) = error else {
+                XCTFail("Expected failure with .invalidCondition, got \(result)")
+                return
+            }
+
+            XCTAssertEqual(errorDescription, "Cannot apply a condition on model which does not exist.")
+            XCTAssertEqual(recoverySuggestion, "Save the model instance without a condition first.")
+        }
+        wait(for: [saveFinished], timeout: defaultTimeout)
+    }
+
     func testBelongsToRelationshipWithoutOwner() {
         let teamA = Team(name: "A-Team")
         let projectA = Project(name: "ProjectA", team: teamA)