fix(api): move error handling to multi-auth operation (#1399)

Author: rjuliano

aws-datastore/src/main/java/com/amplifyframework/datastore/appsync/AppSyncExtensions.java renamed to aws-api-appsync/src/main/java/com/amplifyframework/datastore/appsync/AppSyncExtensions.java

@@ -129,6 +129,15 @@ public String toString() {
             '}';
     }
 
+    /**
+     * Checks whether the current extension data indicates an authorization related error.
+     * @return True if it is authorization related, false otherwise.
+     */
+    public boolean isUnauthorizedErrorType() {
+        return AppSyncExtensions.AppSyncErrorType.UNAUTHORIZED.equals(this.getErrorType()) ||
+               AppSyncExtensions.AppSyncErrorType.UNAUTHORIZED_EXCEPTION.equals(this.getErrorType());
+    }
+
     /**
      * An enumeration of the various error types that we expect
      * to see in the value of {@link AppSyncExtensions#getErrorType()}.
@@ -151,6 +160,11 @@ public enum AppSyncErrorType {
          */
         OPERATION_DISABLED("OperationDisabled"),
 
+        /**
+         * An Unauthorized error will occur if the provided credentials are not authorized for the requested operation.
+         */
+        UNAUTHORIZED_EXCEPTION("UnauthorizedException"),
+
         /**
          * An Unauthorized error will occur if the provided credentials are not authorized for the requested operation.
          */

aws-api/src/main/java/com/amplifyframework/api/aws/MultiAuthAppSyncGraphQLOperation.java

@@ -29,7 +29,9 @@
 import com.amplifyframework.core.Amplify;
 import com.amplifyframework.core.Consumer;
 import com.amplifyframework.core.model.auth.AuthorizationTypeIterator;
+import com.amplifyframework.datastore.appsync.AppSyncExtensions;
 import com.amplifyframework.logging.Logger;
+import com.amplifyframework.util.Empty;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -116,7 +118,7 @@ private void dispatchRequest() {
             } catch (ApiException apiException) {
                 LOG.warn("Failed to make a successful request with " + authType, apiException);
                 // Only queue up a retry if it's an auth-related exception.
-                if (apiException instanceof ApiAuthException) {
+                if (apiException instanceof ApiAuthException && authTypes.hasNext()) {
                     executorService.submit(this::dispatchRequest);
                 } else {
                     onFailure.accept(apiException);
@@ -141,6 +143,16 @@ public void cancel() {
         }
     }
 
+    private boolean hasAuthRelatedErrors(GraphQLResponse<R> response) {
+        for (GraphQLResponse.Error error : response.getErrors()) {
+            if (!Empty.check(error.getExtensions())) {
+                AppSyncExtensions extensions = new AppSyncExtensions(error.getExtensions());
+                return extensions.isUnauthorizedErrorType();
+            }
+        }
+        return false;
+    }
+
     static <R> Builder<R> builder() {
         return new Builder<>();
     }
@@ -165,17 +177,8 @@ public void onResponse(@NonNull Call call, @NonNull Response response) {
 
             try {
                 GraphQLResponse<R> graphQLResponse = wrapResponse(jsonResponse);
-                if (graphQLResponse.hasErrors()) {
-                    for (GraphQLResponse.Error error : graphQLResponse.getErrors()) {
-                        if (error.getExtensions() != null &&
-                            UNAUTHORIZED_EXCEPTION.equals(error.getExtensions().get("errorType"))) {
-                            executorService.submit(MultiAuthAppSyncGraphQLOperation.this::dispatchRequest);
-                            return;
-                        }
-                    }
-                    onFailure.accept(new ApiException("The server response contains errors:" +
-                                                                    graphQLResponse.getErrors().toString(),
-                                                                AmplifyException.TODO_RECOVERY_SUGGESTION));
+                if (graphQLResponse.hasErrors() && hasAuthRelatedErrors(graphQLResponse) && authTypes.hasNext()) {
+                    executorService.submit(MultiAuthAppSyncGraphQLOperation.this::dispatchRequest);
                 } else {
                     onResponse.accept(graphQLResponse);
                 }

aws-api/src/main/java/com/amplifyframework/api/aws/MutiAuthSubscriptionOperation.java

@@ -28,7 +28,9 @@
 import com.amplifyframework.core.Amplify;
 import com.amplifyframework.core.Consumer;
 import com.amplifyframework.core.model.auth.AuthorizationTypeIterator;
+import com.amplifyframework.datastore.appsync.AppSyncExtensions;
 import com.amplifyframework.logging.Logger;
+import com.amplifyframework.util.Empty;
 
 import java.util.Objects;
 import java.util.concurrent.ExecutorService;
@@ -37,7 +39,6 @@
 
 final class MutiAuthSubscriptionOperation<T> extends GraphQLOperation<T> {
     private static final Logger LOG = Amplify.Logging.forNamespace("amplify:aws-api");
-    private static final String UNAUTHORIZED_EXCEPTION = "UnauthorizedException";
 
     private final SubscriptionEndpoint subscriptionEndpoint;
     private final ExecutorService executorService;
@@ -116,10 +117,19 @@ private void dispatchRequest() {
                     MutiAuthSubscriptionOperation.this.subscriptionId = subscriptionId;
                     onSubscriptionStart.accept(subscriptionId);
                 },
-                onNextItem,
+                response -> {
+                    if (response.hasErrors() && hasAuthRelatedErrors(response) && authTypes.hasNext()) {
+                        // If there are auth-related errors, dispatch an ApiAuthException
+                        executorService.submit(this::dispatchRequest);
+                    } else {
+                        // Otherwise, we just want to dispatch it as a next item and
+                        // let callers deal with the errors.
+                        onNextItem.accept(response);
+                    }
+                },
                 apiException -> {
                     LOG.warn("A subscription error occurred.", apiException);
-                    if (apiException instanceof ApiAuthException) {
+                    if (apiException instanceof ApiAuthException && authTypes.hasNext()) {
                         executorService.submit(this::dispatchRequest);
                     } else {
                         emitErrorAndCancelSubscription(apiException);
@@ -151,6 +161,16 @@ public synchronized void cancel() {
         }
     }
 
+    private boolean hasAuthRelatedErrors(GraphQLResponse<T> response) {
+        for (GraphQLResponse.Error error : response.getErrors()) {
+            if (!Empty.check(error.getExtensions())) {
+                AppSyncExtensions extensions = new AppSyncExtensions(error.getExtensions());
+                return extensions.isUnauthorizedErrorType();
+            }
+        }
+        return false;
+    }
+
     private void emitErrorAndCancelSubscription(ApiException apiException) {
         cancel();
         onSubscriptionError.accept(apiException);

aws-api/src/main/java/com/amplifyframework/api/aws/SubscriptionEndpoint.java

@@ -410,32 +410,11 @@ void awaitSubscriptionCompleted() {
         }
 
         void dispatchNextMessage(String message) {
-            GraphQLResponse<T> response;
             try {
-                response = responseFactory.buildResponse(request, message);
+                onNextItem.accept(responseFactory.buildResponse(request, message));
             } catch (ApiException exception) {
                 dispatchError(exception);
-                return;
-            }
-            // If the message received has errors,
-            if (response.hasErrors()) {
-                // If there are auth-related errors, dispatch an ApiAuthException
-                if (hasAuthRelatedErrors(response)) {
-                    dispatchError(new ApiAuthException(
-                        "Authorization error in subscription response: " + response.getErrors(),
-                        AmplifyException.TODO_RECOVERY_SUGGESTION)
-                    );
-                    return;
-                }
-                // Otherwise, just dispatch as an ApiException
-                dispatchError(new ApiException(
-                    "Error in subscription response: " + response.getErrors(),
-                    AmplifyException.TODO_RECOVERY_SUGGESTION)
-                );
-            } else {
-                onNextItem.accept(response);
             }
-
         }
 
         void dispatchError(ApiException error) {
@@ -446,16 +425,6 @@ void dispatchCompleted() {
             onSubscriptionComplete.call();
         }
 
-        private boolean hasAuthRelatedErrors(GraphQLResponse<T> response) {
-            for (GraphQLResponse.Error error : response.getErrors()) {
-                if (error.getExtensions() != null &&
-                    UNAUTHORIZED_EXCEPTION.equals(error.getExtensions().get("errorType"))) {
-                    return true;
-                }
-            }
-            return false;
-        }
-
         @Override
         public boolean equals(Object thatObject) {
             if (this == thatObject) {