chore: kickoff v1 release

Author: sebaland

.github/PULL_REQUEST_TEMPLATE.md

@@ -13,4 +13,9 @@
 - [ ] PR title conforms to conventional commit style
 - [ ] If breaking change, documentation/changelog update with migration instructions
 
+*DataStore checkpoints (check when completed)*
+
+- [ ] Ran AWSDataStorePluginIntegrationTests (includes V2 and CPK)
+- [ ] Ran AWSDataStorePluginAuthIntegrationTests (includes MultiAuth, Cognito Auth, IAM Auth)
+
 By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

AmplifyPlugins/Analytics/AWSPinpointAnalyticsPlugin/AWSPinpointAnalyticsPlugin+ClientBehavior.swift

@@ -107,9 +107,14 @@ extension AWSPinpointAnalyticsPlugin {
         }
 
         pinpoint.submitEvents().continueWith { (task) -> Any? in
-            guard task.error == nil else {
-                // TODO: some error mapping
-                let error = task.error! as NSError
+            if let error = task.error as? NSError{
+                // For "No events to submit" errors, dispatch and empty array instead
+                if error.domain == AWSPinpointAnalyticsErrorDomain,
+                   error.localizedDescription == "No events to submit." {
+                    Amplify.Hub.dispatchFlushEvents([])
+                    return nil
+                }
+
                 Amplify.Hub.dispatchFlushEvents(AnalyticsErrorHelper.getDefaultError(error))
                 return nil
             }

AmplifyPlugins/Analytics/AWSPinpointAnalyticsPlugin/Support/Constants/AnalyticsErrorConstants.swift

@@ -97,4 +97,9 @@ struct AnalyticsPluginErrorConstant {
         "Could not instantiate service configuration from pinpoint targeting region",
         "Make sure the pinpoint targeting region and cognito credentials provider are correct"
     )
+
+    static let deviceOffline: AnalyticsPluginErrorString = (
+        "The device does not have internet access. Please ensure the device is online and try again.",
+        ""
+    )
 }

AmplifyPlugins/Analytics/AWSPinpointAnalyticsPlugin/Support/Utils/AnalyticsErrorHelper.swift

@@ -10,6 +10,13 @@ import Foundation
 
 class AnalyticsErrorHelper {
     static func getDefaultError(_ error: NSError) -> AnalyticsError {
+        if error.isConnectivityError {
+            return .unknown(
+                AnalyticsPluginErrorConstant.deviceOffline.errorDescription,
+                error
+            )
+        }
+
         let errorMessage = """
         Domain: [\(error.domain)
         Code: [\(error.code)
@@ -18,6 +25,20 @@ class AnalyticsErrorHelper {
         LocalizedRecoverySuggestion: [\(error.localizedRecoverySuggestion ?? "")
         """
 
-        return AnalyticsError.unknown(errorMessage)
+        return AnalyticsError.unknown(errorMessage, error)
+    }
+}
+
+private extension NSError {
+    private static let networkErrorCodes = [
+        NSURLErrorCannotFindHost,
+        NSURLErrorCannotConnectToHost,
+        NSURLErrorNetworkConnectionLost,
+        NSURLErrorDNSLookupFailed,
+        NSURLErrorNotConnectedToInternet
+    ]
+
+    var isConnectivityError: Bool {
+        return Self.networkErrorCodes.contains(where: { $0 == code })
     }
 }

AmplifyPlugins/Analytics/AWSPinpointAnalyticsPluginTests/AWSPinpointAnalyticsPluginClientBehaviorTests.swift

@@ -350,6 +350,34 @@ class AWSPinpointAnalyticsPluginClientBehaviorTests: AWSPinpointAnalyticsPluginT
         waitForExpectations(timeout: 1)
     }
 
+    /// Given: AWSPinpoint.submitEvents returns a "No events to submit." error
+    /// When: AnalyticsPlugin.flushEvents is invoked
+    /// Then: AWSPinpoint.submitEvents is invoked
+    ///     and Hub Analytics.flushEvents event is dispatched with an empty array of events
+    func testFlushEvents_noEvents() {
+        let error = NSError(domain: AWSPinpointAnalyticsErrorDomain,
+                            code: AWSPinpointAnalyticsErrorType.unknown.rawValue,
+                            userInfo: [NSLocalizedDescriptionKey: "No events to submit."])
+        mockPinpoint.submitEventsResult = AWSTask<AnyObject>.init(error: error)
+        let methodWasInvokedOnPlugin = expectation(description: "method was invoked on plugin")
+
+        _ = plugin.listen(to: .analytics, isIncluded: nil) { payload in
+            if payload.eventName == HubPayload.EventName.Analytics.flushEvents {
+                methodWasInvokedOnPlugin.fulfill()
+                guard let pinpointEvents = payload.data as? [AWSPinpointEvent] else {
+                    XCTFail("Missing data")
+                    return
+                }
+
+                XCTAssertTrue(pinpointEvents.isEmpty)
+            }
+        }
+
+        analyticsPlugin.flushEvents()
+        mockPinpoint.verifySubmitEvents()
+        waitForExpectations(timeout: 1)
+    }
+
     /// Given: AnalyticsPlugin is disabled
     /// When: AnalyticsPlugin.flushEvents is invoked
     /// Then: AWSPinpoint.submitEvents is not called

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/AWSDataStorePlugin+DataStoreBaseBehavior.swift

@@ -281,14 +281,17 @@ extension AWSDataStorePlugin: DataStoreBaseBehavior {
                 dispatchedModelSynced.set(false)
             }
             if storageEngine == nil {
-
-                completion(.successfulVoid)
+                queue.async {
+                    completion(.successfulVoid)
+                }
                 return
             }
 
             storageEngine.stopSync { result in
                 self.storageEngine = nil
-                completion(result)
+                self.queue.async {
+                    completion(result)
+                }
             }
         }
     }
@@ -309,12 +312,16 @@ extension AWSDataStorePlugin: DataStoreBaseBehavior {
                 dispatchedModelSynced.set(false)
             }
             if storageEngine == nil {
-                completion(.successfulVoid)
+                queue.async {
+                    completion(.successfulVoid)
+                }
                 return
             }
             storageEngine.clear { result in
                 self.storageEngine = nil
-                completion(result)
+                self.queue.async {
+                    completion(result)
+                }
             }
         }
     }

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/AWSDataStorePlugin.swift

@@ -46,6 +46,7 @@ final public class AWSDataStorePlugin: DataStoreCategoryPlugin {
 
     var storageEngine: StorageEngineBehavior!
     var storageEngineInitQueue = DispatchQueue(label: "AWSDataStorePlugin.storageEngineInitQueue")
+    let queue = DispatchQueue(label: "AWSDataStorePlugin.queue", target: DispatchQueue.global())
     var storageEngineBehaviorFactory: StorageEngineBehaviorFactory
 
     var iStorageEngineSink: Any?

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Sync/MutationSync/OutgoingMutationQueue/ProcessMutationErrorFromCloudOperation.swift

@@ -55,25 +55,42 @@ class ProcessMutationErrorFromCloudOperation: AsynchronousOperation {
             return
         }
 
-        if let apiError = apiError, isAuthSignedOutError(apiError: apiError) {
+        if let apiError = apiError {
+            if isAuthSignedOutError(apiError: apiError) {
+                log.verbose("User is signed out, passing error back to the error handler, and removing mutation event.")
+            } else if let underlyingError = apiError.underlyingError {
+                log.debug("Received APIError: \(apiError.localizedDescription) with underlying error: \(underlyingError.localizedDescription)")
+            } else {
+                log.debug("Received APIError: \(apiError.localizedDescription)")
+            }
             dataStoreConfiguration.errorHandler(DataStoreError.api(apiError, mutationEvent))
             finish(result: .success(nil))
             return
         }
 
-        guard let graphQLResponseError = graphQLResponseError,
-            case let .error(graphQLErrors) = graphQLResponseError else {
-                finish(result: .success(nil))
-                return
+        guard let graphQLResponseError = graphQLResponseError else {
+            dataStoreConfiguration.errorHandler(
+                DataStoreError.api(APIError.unknown("This is unexpected. Missing APIError and GraphQLError.", ""),
+                                   mutationEvent))
+            finish(result: .success(nil))
+            return
+        }
+
+        guard case let .error(graphQLErrors) = graphQLResponseError else {
+            dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
+            finish(result: .success(nil))
+            return
         }
 
         guard graphQLErrors.count == 1 else {
             log.error("Received more than one error response: \(String(describing: graphQLResponseError))")
+            dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
             finish(result: .success(nil))
             return
         }
 
         guard let graphQLError = graphQLErrors.first else {
+            dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
             finish(result: .success(nil))
             return
         }
@@ -85,22 +102,26 @@ class ProcessMutationErrorFromCloudOperation: AsynchronousOperation {
                 let payload = HubPayload(eventName: HubPayload.EventName.DataStore.conditionalSaveFailed,
                                          data: mutationEvent)
                 Amplify.Hub.dispatch(to: .dataStore, payload: payload)
+                dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
                 finish(result: .success(nil))
             case .conflictUnhandled:
                 processConflictUnhandled(extensions)
             case .unauthorized:
-                // TODO: dispatch Hub event
                 log.debug("Unauthorized mutation \(errorType)")
+                dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
                 finish(result: .success(nil))
             case .operationDisabled:
                 log.debug("Operation disabled \(errorType)")
+                dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
                 finish(result: .success(nil))
             case .unknown(let errorType):
                 log.debug("Unhandled error with errorType \(errorType)")
+                dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
                 finish(result: .success(nil))
             }
         } else {
             log.debug("GraphQLError missing extensions and errorType \(graphQLError)")
+            dataStoreConfiguration.errorHandler(DataStoreError.api(graphQLResponseError, mutationEvent))
             finish(result: .success(nil))
         }
     }

AmplifyPlugins/DataStore/AWSDataStoreCategoryPlugin/Sync/RequestRetryablePolicy.swift

@@ -38,7 +38,8 @@ class RequestRetryablePolicy: RequestRetryable {
              .cannotConnectToHost,
              .cannotFindHost,
              .timedOut,
-             .dataNotAllowed:
+             .dataNotAllowed,
+             .cannotParseResponse:
             let waitMillis = retryDelayInMillseconds(for: attemptNumber)
             return RequestRetryAdvice(shouldRetry: true, retryInterval: .milliseconds(waitMillis))
         default: