Merge pull request #2706 from aws-amplify/v1

chore: kickoff v1 release

Author: phantumcode

AWSPluginsCore.podspec

@@ -10,7 +10,7 @@
 $AMPLIFY_VERSION = '1.28.4'
 $AMPLIFY_RELEASE_TAG = "v#{$AMPLIFY_VERSION}"
 
-$AWS_SDK_VERSION = '2.29.1'
+$AWS_SDK_VERSION = '2.30.1'
 $OPTIMISTIC_AWS_SDK_VERSION = "~> #{$AWS_SDK_VERSION}"
 
 Pod::Spec.new do |s|

AWSPredictionsPlugin.podspec

@@ -2,7 +2,7 @@
 $AMPLIFY_VERSION = '1.28.4'
 $AMPLIFY_RELEASE_TAG = "v#{$AMPLIFY_VERSION}"
 
-$AWS_SDK_VERSION = '2.29.1'
+$AWS_SDK_VERSION = '2.30.1'
 $OPTIMISTIC_AWS_SDK_VERSION = "~> #{$AWS_SDK_VERSION}"
 
 Pod::Spec.new do |s|

Amplify/Categories/API/Request/RESTRequest.swift

@@ -32,9 +32,14 @@ public class RESTRequest {
                 headers: [String: String]? = nil,
                 queryParameters: [String: String]? = nil,
                 body: Data? = nil) {
+        let inputHeaders = headers ?? [:]
+        self.headers = inputHeaders.merging(
+            ["Cache-Control": "no-store"],
+            uniquingKeysWith: { current, _ in current}
+        )
+
         self.apiName = apiName
         self.path = path
-        self.headers = headers
         self.queryParameters = queryParameters
         self.body = body
     }

Amplify/Categories/DataStore/DataStoreCategory+Behavior+Combine.swift

@@ -53,7 +53,7 @@ public extension DataStoreBaseBehavior {
         _ modelType: M.Type,
         withIdentifier identifier: String,
         where predicate: QueryPredicate? = nil
-    )  -> DataStorePublisher<Void> where M: ModelIdentifiable, M.IdentifierFormat == ModelIdentifierFormat.Default {
+    ) -> DataStorePublisher<Void> where M: ModelIdentifiable, M.IdentifierFormat == ModelIdentifierFormat.Default {
         Future { promise in
             self.delete(modelType, withIdentifier: identifier, where: predicate) { promise($0) }
         }.eraseToAnyPublisher()
@@ -70,7 +70,7 @@ public extension DataStoreBaseBehavior {
         _ modelType: M.Type,
         withIdentifier identifier: ModelIdentifier<M, M.IdentifierFormat>,
         where predicate: QueryPredicate? = nil
-    )  -> DataStorePublisher<Void> where M: ModelIdentifiable {
+    ) -> DataStorePublisher<Void> where M: ModelIdentifiable {
         Future { promise in
             self.delete(modelType, withIdentifier: identifier, where: predicate) { promise($0) }
         }.eraseToAnyPublisher()

AmplifyPlugins.podspec

@@ -10,7 +10,7 @@
 $AMPLIFY_VERSION = '1.28.4'
 $AMPLIFY_RELEASE_TAG = "v#{$AMPLIFY_VERSION}"
 
-$AWS_SDK_VERSION = '2.29.1'
+$AWS_SDK_VERSION = '2.30.1'
 $OPTIMISTIC_AWS_SDK_VERSION = "~> #{$AWS_SDK_VERSION}"
 
 Pod::Spec.new do |s|
@@ -36,7 +36,7 @@ Pod::Spec.new do |s|
 
   s.subspec 'AWSAPIPlugin' do |ss|
     ss.source_files = 'AmplifyPlugins/API/AWSAPICategoryPlugin/**/*.swift'
-    ss.dependency 'AppSyncRealTimeClient', "~> 2.0"
+    ss.dependency 'AppSyncRealTimeClient', "~> 3.0"
   end
 
   s.subspec 'AWSCognitoAuthPlugin' do |ss|

AmplifyPlugins/API/AWSAPICategoryPlugin/Operation/AWSGraphQLSubscriptionOperation.swift

@@ -93,15 +93,17 @@ final public class AWSGraphQLSubscriptionOperation<R: Decodable>: GraphQLSubscri
         // Retrieve request plugin option and
         // auth type in case of a multi-auth setup
         let pluginOptions = request.options.pluginOptions as? AWSPluginOptions
+        let urlRequest = generateSubscriptionURLRequest(from: endpointConfig)
 
         // Retrieve the subscription connection
         subscriptionQueue.sync {
             do {
                 subscriptionConnection = try subscriptionConnectionFactory
                     .getOrCreateConnection(for: endpointConfig,
-                                              authService: authService,
-                                              authType: pluginOptions?.authType,
-                                              apiAuthProviderFactory: apiAuthProviderFactory)
+                                           urlRequest: urlRequest,
+                                           authService: authService,
+                                           authType: pluginOptions?.authType,
+                                           apiAuthProviderFactory: apiAuthProviderFactory)
             } catch {
                 let error = APIError.operationError("Unable to get connection for api \(endpointConfig.name)", "", error)
                 dispatch(result: .failure(error))
@@ -119,6 +121,17 @@ final public class AWSGraphQLSubscriptionOperation<R: Decodable>: GraphQLSubscri
         }
     }
 
+    private func generateSubscriptionURLRequest(
+        from endpointConfig: AWSAPICategoryPluginConfiguration.EndpointConfig
+    ) -> URLRequest {
+        var urlRequest = URLRequest(url: endpointConfig.baseURL)
+        urlRequest.setValue(
+            AmplifyAWSServiceConfiguration.baseUserAgent(),
+            forHTTPHeaderField: URLRequestConstants.Header.userAgent
+        )
+        return urlRequest
+    }
+
     private func onAsyncSubscriptionEvent(event: SubscriptionItemEvent) {
         switch event {
         case .connection(let subscriptionConnectionEvent):

AmplifyPlugins/API/AWSAPICategoryPlugin/SubscriptionFactory/AWSSubscriptionConnectionFactory.swift

@@ -23,23 +23,24 @@ class AWSSubscriptionConnectionFactory: SubscriptionConnectionFactory {
 
     private var apiToConnectionProvider: [MapperCacheKey: ConnectionProvider] = [:]
 
-    func getOrCreateConnection(for endpointConfig: AWSAPICategoryPluginConfiguration.EndpointConfig,
-                               authService: AWSAuthServiceBehavior,
-                               authType: AWSAuthorizationType? = nil,
-                               apiAuthProviderFactory: APIAuthProviderFactory) throws -> SubscriptionConnection {
+    func getOrCreateConnection(
+        for endpointConfig: AWSAPICategoryPluginConfiguration.EndpointConfig,
+        urlRequest: URLRequest,
+        authService: AWSAuthServiceBehavior,
+        authType: AWSAuthorizationType? = nil,
+        apiAuthProviderFactory: APIAuthProviderFactory
+    ) throws -> SubscriptionConnection {
         return try concurrencyQueue.sync {
             let apiName = endpointConfig.name
 
-            let url = endpointConfig.baseURL
-
             let authInterceptor = try getInterceptor(for: getOrCreateAuthConfiguration(from: endpointConfig,
                                                                                        authType: authType),
                                                      authService: authService,
                                                      apiAuthProviderFactory: apiAuthProviderFactory)
 
             // create or retrieve the connection provider. If creating, add interceptors onto the provider.
             let connectionProvider = apiToConnectionProvider[MapperCacheKey(apiName: apiName, authType: authType)] ??
-                ConnectionProviderFactory.createConnectionProvider(for: url,
+                ConnectionProviderFactory.createConnectionProvider(for: urlRequest,
                                                                    authInterceptor: authInterceptor,
                                                                    connectionType: .appSyncRealtime)
 

AmplifyPlugins/API/AWSAPICategoryPlugin/SubscriptionFactory/SubscriptionConnectionFactory.swift

@@ -5,6 +5,8 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+import Foundation
+
 import Amplify
 import AWSPluginsCore
 import AppSyncRealTimeClient
@@ -14,6 +16,7 @@ protocol SubscriptionConnectionFactory {
 
     /// Get connection based on the connection type
     func getOrCreateConnection(for endpointConfig: AWSAPICategoryPluginConfiguration.EndpointConfig,
+                               urlRequest: URLRequest,
                                authService: AWSAuthServiceBehavior,
                                authType: AWSAuthorizationType?,
                                apiAuthProviderFactory: APIAuthProviderFactory) throws -> SubscriptionConnection

AmplifyPlugins/API/AWSAPICategoryPlugin/Support/Utils/GraphQLOperationRequestUtils.swift

@@ -22,7 +22,7 @@ class GraphQLOperationRequestUtils {
     // Construct a graphQL specific HTTP POST request with the request payload
     static func constructRequest(with baseUrl: URL, requestPayload: Data) -> URLRequest {
         var baseRequest = URLRequest(url: baseUrl)
-        let headers = ["content-type": "application/json"]
+        let headers = ["content-type": "application/json", "Cache-Control": "no-store"]
         baseRequest.allHTTPHeaderFields = headers
         baseRequest.httpMethod = "POST"
         baseRequest.httpBody = requestPayload

AmplifyPlugins/API/AWSAPICategoryPluginFunctionalTests/GraphQLModelBased/GraphQLConnectionScenario3Tests+List.swift

@@ -194,13 +194,27 @@ extension GraphQLConnectionScenario3Tests {
         let requestInvokedSuccessfully = expectation(description: "request completed")
         let post = Post3.keys
         let predicate = post.id == uuid && post.title == uniqueTitle
-        _ = Amplify.API.query(request: .list(Post3.self, where: predicate)) { event in
+        _ = Amplify.API.query(request: .paginatedList(Post3.self, where: predicate)) { event in
             switch event {
             case .success(let graphQLResponse):
-                guard case let .success(posts) = graphQLResponse else {
+                guard case var .success(posts) = graphQLResponse else {
                     XCTFail("Missing successful response")
                     return
                 }
+
+                while posts.isEmpty, posts.hasNextPage() {
+                    let getNextPageCompleted = self.expectation(description: "get next page completed")
+                    posts.getNextPage { result in
+                        switch result {
+                        case .success(let nextPage):
+                            posts = nextPage
+                            getNextPageCompleted.fulfill()
+                        case .failure(let error):
+                            XCTFail("Failed with error \(error)")
+                        }
+                    }
+                    self.wait(for: [getNextPageCompleted], timeout: TestCommonConstants.networkTimeout)
+                }
                 XCTAssertEqual(posts.count, 1)
                 guard let singlePost = posts.first else {
                     XCTFail("Should only have a single post with the unique title")