fix(api): OIDC/Lambda Fixes (#862)

* Clean up pinpoint

* Clean up pinpoint dart

* Update iOS script

* Update CI order

* Add Dart lints to API

* Apply Android/iOS lints to API

* Rename uuid

* Small changes

* Fix scripts

* Clean up

* Fix unit tests

* Continue impl

* Fix android unit tests

* Remove duplicate lint check

* Fix analytics app

* Adjust java options

* Bump java RAM

* Remove concurrency

* Disable gradle daemon

* Update gradle properties

* Update gradle config

* Revert "Update gradle config"

This reverts commit a43ad29.

* Revert gradle changes

* Disable gradle daemon

* Add kotlin style flags

* Disable gradle daemon

* Bump JVM memory

* Change daemon setting

* Adjust JVM memory

* Lint debug only

* Fix API tests

* Bump deps and fix coverage script

* Fix Gradle version

* Revert unnecessary changes

* Update melos postclean files

* Enable fatal infos

* Fix analyze scope

* Fix postbootstrap

* Fix missing sample app

* Fix order in CI

* Revert add sample app

* Revert order change

* Merge branch 'datastore/multiauth' into chore/api-lints

* Revert multiauth

* Fix updateTokens

* Fix GraphQL error decoding

* Fix formatting

* Clean up

* Clean up

* Clean up

* Fix analysis for Flutter 2.5.0

Author: dnys1

melos.yaml

@@ -68,7 +68,7 @@ scripts:
 
   analyze:
     run: melos exec -c 1 --fail-fast -- \
-      flutter analyze
+      flutter analyze --no-fatal-infos
     description: >
       Analyzes all packages and fails if there are any errors.
     select-package:

packages/amplify_api/android/src/main/kotlin/com/amazonaws/amplify/amplify_api/AmplifyApiPlugin.kt

@@ -22,6 +22,7 @@ import androidx.annotation.NonNull
 import androidx.annotation.VisibleForTesting
 import com.amazonaws.amplify.amplify_api.auth.FlutterAuthProviders
 import com.amazonaws.amplify.amplify_api.rest_api.FlutterRestApi
+import com.amazonaws.amplify.amplify_core.cast
 import com.amazonaws.amplify.amplify_core.exception.ExceptionUtil.Companion.createSerializedUnrecognizedError
 import com.amazonaws.amplify.amplify_core.exception.ExceptionUtil.Companion.handleAddPluginException
 import com.amazonaws.amplify.amplify_core.exception.ExceptionUtil.Companion.postExceptionToFlutterChannel
@@ -105,16 +106,7 @@ class AmplifyApiPlugin : FlutterPlugin, MethodCallHandler {
             // Update tokens if included with request
             val tokens = arguments["tokens"] as? List<*>
             if (tokens != null && tokens.isNotEmpty()) {
-                for (authToken in tokens as List<Map<*, *>>) {
-                    val token = authToken["token"] as? String?
-                    val tokenType = authToken["type"] as? String ?: throw invalidTokenType()
-                    val authType: AuthorizationType = try {
-                        AuthorizationType.from(tokenType)
-                    } catch (e: Exception) {
-                        throw invalidTokenType(tokenType)
-                    }
-                    FlutterAuthProviders.setToken(authType, token)
-                }
+                updateTokens(tokens)
             }
 
             when (call.method) {
@@ -131,6 +123,17 @@ class AmplifyApiPlugin : FlutterPlugin, MethodCallHandler {
                     arguments,
                     graphqlSubscriptionStreamHandler
                 )
+                "updateTokens" -> {
+                    if (tokens == null || tokens.isEmpty()) {
+                        throw ApiException(
+                            "Invalid token map provided",
+                            "Provide tokens in the \"tokens\" field"
+                        )
+                    }
+
+                    // Tokens already updated
+                    result.success(null)
+                }
                 else -> result.notImplemented()
             }
         } catch (e: Exception) {
@@ -159,6 +162,19 @@ class AmplifyApiPlugin : FlutterPlugin, MethodCallHandler {
         }
     }
 
+    private fun updateTokens(tokens: List<*>) {
+        for (authToken in tokens.cast<Map<String, Any?>>()) {
+            val token = authToken["token"] as? String?
+            val tokenType = authToken["type"] as? String ?: throw invalidTokenType()
+            val authType: AuthorizationType = try {
+                AuthorizationType.from(tokenType)
+            } catch (e: Exception) {
+                throw invalidTokenType(tokenType)
+            }
+            FlutterAuthProviders.setToken(authType, token)
+        }
+    }
+
     override fun onDetachedFromEngine(@NonNull binding: FlutterPlugin.FlutterPluginBinding) {
         channel.setMethodCallHandler(null)
     }

packages/amplify_api/android/src/main/kotlin/com/amazonaws/amplify/amplify_api/FlutterGraphQLApi.kt

@@ -21,6 +21,7 @@ import com.amazonaws.amplify.amplify_core.exception.ExceptionUtil
 import com.amplifyframework.api.ApiException
 import com.amplifyframework.api.aws.GsonVariablesSerializer
 import com.amplifyframework.api.graphql.GraphQLOperation
+import com.amplifyframework.api.graphql.GraphQLPathSegment
 import com.amplifyframework.api.graphql.GraphQLResponse
 import com.amplifyframework.api.graphql.SimpleGraphQLRequest
 import com.amplifyframework.core.Action
@@ -62,7 +63,7 @@ class FlutterGraphQLApi {
 
                 val result: Map<String, Any> = mapOf(
                     "data" to response.data,
-                    "errors" to response.errors.map { it.message }
+                    "errors" to response.errors.map { it.toMap() }
                 )
                 LOG.debug("GraphQL query operation succeeded with response: $result")
                 handler.post { flutterResult.success(result) }
@@ -138,7 +139,7 @@ class FlutterGraphQLApi {
 
                 val result: Map<String, Any> = mapOf(
                     "data" to response.data,
-                    "errors" to response.errors.map { it.message }
+                    "errors" to response.errors.map { it.toMap() }
                 )
                 LOG.debug("GraphQL mutate operation succeeded with response : $result")
                 handler.post { flutterResult.success(result) }
@@ -223,7 +224,7 @@ class FlutterGraphQLApi {
             val responseCallback = Consumer<GraphQLResponse<String>> { response ->
                 val payload: Map<String, Any> = mapOf(
                     "data" to response.data,
-                    "errors" to response.errors.map { it.message }
+                    "errors" to response.errors.map { it.toMap() }
                 )
                 LOG.debug("GraphQL subscription event received: $payload")
                 graphqlSubscriptionStreamHandler.sendEvent(
@@ -293,4 +294,17 @@ class FlutterGraphQLApi {
             }
         }
     }
-}
+}
+
+fun GraphQLResponse.Error.toMap(): Map<String, Any?> = mapOf(
+    "message" to message,
+    "locations" to locations?.map { mapOf("line" to it.line, "column" to it.column) },
+    "path" to path?.map<GraphQLPathSegment, Any?> {
+        when {
+            it.isInteger -> it.asInt
+            it.isString -> it.asString
+            else -> null
+        }
+    },
+    "extensions" to extensions
+)

packages/amplify_api/ios/Classes/FlutterApiResponse.swift

@@ -19,6 +19,45 @@ import AmplifyPlugins
 
 import amplify_core
 
+extension GraphQLError.Location: Encodable {
+    enum CodingKeys: String, CodingKey {
+        case line
+        case column
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(line, forKey: .line)
+        try container.encode(column, forKey: .column)
+    }
+}
+
+extension GraphQLError: Encodable {
+    enum CodingKeys: String, CodingKey {
+        case message
+        case locations
+        case path
+        case extensions
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(message, forKey: .message)
+        try container.encode(locations, forKey: .locations)
+        try container.encode(path, forKey: .path)
+        try container.encode(extensions, forKey: .extensions)
+    }
+}
+
+extension Encodable {
+  func asDictionary() -> [String: Any]? {
+    guard let data = try? JSONEncoder().encode(self) else {
+        return nil
+    }
+    return try? JSONSerialization.jsonObject(with: data, options: .allowFragments) as? [String: Any]
+  }
+}
+
 class FlutterApiResponse {
     static func handleGraphQLErrorResponse(
         flutterResult: @escaping FlutterResult,
@@ -28,14 +67,14 @@ class FlutterApiResponse {
         case .error(let errorList):
             let result: [String: Any?] = [
                 "data": nil,
-                "errors": errorList.map { $0.message }
+                "errors": errorList.compactMap { $0.asDictionary() }
             ]
             print("Received a GraphQL response with errors: \(errorList)")
             flutterResult(result)
         case .partial(let data, let errorList):
             let result: [String: Any?] = [
                 "data": data,
-                "errors": errorList.map { $0.message }
+                "errors": errorList.compactMap { $0.asDictionary() }
             ]
             print("Received a partially successful GraphQL response: \(result)")
             flutterResult(result)
@@ -65,7 +104,7 @@ class FlutterApiResponse {
         case .error(let errorList):
             let payload: [String: Any?] = [
                 "data": nil,
-                "errors": errorList.map { $0.message }
+                "errors": errorList.compactMap { $0.asDictionary() }
             ]
             print("Received a GraphQL subscription event with errors: \(errorList)")
             graphQLSubscriptionsStreamHandler.sendEvent(
@@ -75,7 +114,7 @@ class FlutterApiResponse {
         case .partial(let data, let errorList):
             let payload: [String: Any?] = [
                 "data": data,
-                "errors": errorList.map { $0.message }
+                "errors": errorList.compactMap { $0.asDictionary() }
             ]
             print("Received a partially successful GraphQL subscription event: \(payload)")
             graphQLSubscriptionsStreamHandler.sendEvent(

packages/amplify_api/ios/Classes/SwiftAmplifyApiPlugin.swift

@@ -64,17 +64,7 @@ public class SwiftAmplifyApiPlugin: NSObject, FlutterPlugin {
 
             // Update tokens if included in request.
             if let tokens = arguments["tokens"] as? [[String: Any?]] {
-                for tokenMap in tokens {
-                    guard let type = tokenMap["type"] as? String,
-                          let awsAuthType = AWSAuthorizationType(rawValue: type),
-                          let token = tokenMap["token"] as? String? else {
-                        throw APIError.unknown(
-                            "Invalid arguments",
-                            "A valid AWSAuthorizationType and token entry are required",
-                            nil)
-                    }
-                    FlutterAuthProviders.setToken(type: awsAuthType, token: token)
-                }
+                try updateTokens(tokens)
             }
 
             try innerHandle(method: method, arguments: arguments, result: result)
@@ -141,6 +131,15 @@ public class SwiftAmplifyApiPlugin: NSObject, FlutterPlugin {
                 request: arguments, bridge: bridge,
                 graphQLSubscriptionsStreamHandler: graphQLSubscriptionsStreamHandler
             )
+        case "updateTokens":
+            guard let _ = arguments["tokens"] as? [[String: Any?]] else {
+                throw APIError.unknown("Invalid token map provided",
+                                        "Provide tokens in the \"tokens\" field",
+                                        nil)
+            }
+
+            // Tokens already updated
+            result(nil)
         default:
             result(FlutterMethodNotImplemented)
         }
@@ -160,4 +159,18 @@ public class SwiftAmplifyApiPlugin: NSObject, FlutterPlugin {
                             details: "Operation does not exist"))
         }
     }
+
+    private func updateTokens(_ tokens: [[String: Any?]]) throws {
+        for tokenMap in tokens {
+            guard let type = tokenMap["type"] as? String,
+                  let awsAuthType = AWSAuthorizationType(rawValue: type),
+                  let token = tokenMap["token"] as? String? else {
+                throw APIError.unknown(
+                    "Invalid arguments",
+                    "A valid AWSAuthorizationType and token entry are required",
+                    nil)
+            }
+            FlutterAuthProviders.setToken(type: awsAuthType, token: token)
+        }
+    }
 }

packages/amplify_api/lib/amplify_api.dart

@@ -41,7 +41,7 @@ class AmplifyAPI extends APIPluginInterface {
   }
 
   @override
-  Future<void> addPlugin() async {
+  Future<APIAuthProviderRefresher> addPlugin() async {
     return _instance.addPlugin();
   }
 

packages/amplify_api/lib/method_channel_api.dart

@@ -41,9 +41,10 @@ class AmplifyAPIMethodChannel extends AmplifyAPI {
   final Map<APIAuthorizationType, APIAuthProvider> _authProviders = {};
 
   @override
-  Future<void> addPlugin() async {
+  Future<APIAuthProviderRefresher> addPlugin() async {
     try {
-      return await _channel.invokeMethod('addPlugin');
+      await _channel.invokeMethod<void>('addPlugin');
+      return _authProviderRefresher;
     } on PlatformException catch (e) {
       if (e.code == 'AmplifyAlreadyConfiguredException') {
         throw const AmplifyAlreadyConfiguredException(
@@ -63,13 +64,45 @@ class AmplifyAPIMethodChannel extends AmplifyAPI {
     _authProviders[authProvider.type] = authProvider;
   }
 
+  /// A token refresher which can be used outside of this plugin (i.e. in DataStore)
+  /// without exposing the auth providers themselves or their tokens.
+  Future<void> _authProviderRefresher([
+    APIAuthorizationType? authType,
+  ]) {
+    if (_authProviders.isEmpty) {
+      return SynchronousFuture(null);
+    }
+    Future<List<Map<String, dynamic>>> _tokensFuture;
+    if (authType != null) {
+      final provider = _authProviders[authType];
+      if (provider == null) {
+        throw ApiException(
+          'No provider registered for type: $authType',
+          recoverySuggestion:
+              'Make sure to call addPlugin with a list of auth providers.',
+        );
+      }
+      _tokensFuture = provider.authToken.then((token) => [token]);
+    } else {
+      _tokensFuture = _getLatestAuthTokens();
+    }
+    return _tokensFuture.then(_updateAuthTokens);
+  }
+
   /// Retrieves the latest tokens for all registered [_authProviders].
   Future<List<Map<String, dynamic>>> _getLatestAuthTokens() {
     return Future.wait(_authProviders.values.map(
       (authProvider) => authProvider.authToken,
     ));
   }
 
+  /// Updates authorization tokens on the platform side.
+  Future<void> _updateAuthTokens(List<Map<String, dynamic>> tokens) {
+    return _channel.invokeMethod('updateTokens', {
+      _authTokensMapKey: tokens,
+    });
+  }
+
   @override
   GraphQLOperation<T> query<T>({required GraphQLRequest<T> request}) {
     Future<GraphQLResponse<T>> response =

packages/amplify_api/test/graphql_error_test.dart

@@ -0,0 +1,55 @@
+import 'package:amplify_api/amplify_api.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  const apiChannel = MethodChannel('com.amazonaws.amplify/api');
+  final api = AmplifyAPI();
+
+  test('GraphQL Error Decoding', () async {
+    const message = 'Not Authorized';
+    const locations = [
+      {'line': 2, 'column': 3},
+      {'line': 4, 'column': 5}
+    ];
+    const path = ['a', 1, 'b'];
+    const extensions = {
+      'a': 'blah',
+      'b': {'c': 'd'}
+    };
+    const expected = GraphQLResponseError(
+      message: message,
+      locations: [
+        GraphQLResponseErrorLocation(2, 3),
+        GraphQLResponseErrorLocation(4, 5),
+      ],
+      path: <dynamic>[...path],
+      extensions: <String, dynamic>{...extensions},
+    );
+
+    apiChannel.setMockMethodCallHandler((MethodCall call) async {
+      return {
+        'data': null,
+        'errors': [
+          {
+            'message': message,
+            'locations': locations,
+            'path': path,
+            'extensions': extensions,
+          },
+        ]
+      };
+    });
+
+    final resp = await api
+        .query(
+          request: GraphQLRequest<String>(document: ''),
+        )
+        .response;
+
+    expect(resp.data, equals(''));
+    expect(resp.errors.single, equals(expected));
+  });
+}

packages/amplify_api_plugin_interface/lib/amplify_api_plugin_interface.dart

@@ -25,7 +25,7 @@ export 'src/types.dart';
 abstract class APIPluginInterface extends AmplifyPluginInterface {
   APIPluginInterface({required Object token}) : super(token: token);
 
-  Future<void> addPlugin() async {
+  Future<APIAuthProviderRefresher> addPlugin() async {
     throw UnimplementedError('addPlugin() has not been implemented.');
   }