@aws-amplify/api-graphql 4.0.1-console-preview.11cf989.0 → 4.0.1-console-preview.4ae78ed.0

package/lib/types/index.d.ts

@@ -1,8 +1,7 @@
 import { Source, DocumentNode, GraphQLError } from 'graphql';
 export { OperationTypeNode } from 'graphql';
 import { Observable } from 'rxjs';
-import { DocumentType } from '@aws-amplify/api-rest';
-import { GraphQLAuthModeKeys } from '@aws-amplify/core/internals/utils';
+import { APIAuthMode, DocumentType } from '@aws-amplify/core/internals/utils';
 export { CONTROL_MSG, ConnectionState } from './PubSub';
 /**
  * Loose/Unknown options for raw GraphQLAPICategory `graphql()`.
@@ -10,7 +9,7 @@ export { CONTROL_MSG, ConnectionState } from './PubSub';
 export interface GraphQLOptions {
     query: string | DocumentNode;
     variables?: Record<string, DocumentType>;
-    authMode?: string;
+    authMode?: APIAuthMode;
     authToken?: string;
     /**
      * @deprecated This property should not be used
@@ -73,7 +72,7 @@ export declare type GraphqlSubscriptionMessage<T> = {
 };
 export interface AWSAppSyncRealTimeProviderOptions {
     appSyncGraphqlEndpoint?: string;
-    authenticationType?: GraphQLAuthModeKeys;
+    authenticationType?: APIAuthMode;
     query?: string;
     variables?: Record<string, unknown>;
     apiKey?: string;
@@ -105,7 +104,7 @@ export declare type GraphQLOperation = Source | string;
 export interface GraphQLOptionsV6<FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string> {
     query: TYPED_GQL_STRING | DocumentNode;
     variables?: GraphQLVariablesV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
-    authMode?: GraphQLAuthModeKeys;
+    authMode?: APIAuthMode;
     authToken?: string;
     /**
      * @deprecated This property should not be used

package/lib/utils/resolveConfig.d.ts

@@ -4,5 +4,5 @@
 export declare const resolveConfig: () => {
     endpoint: string;
     region: string;
-    defaultAuthMode: import("@aws-amplify/core/lib-esm/libraryUtils").GraphQLAuthMode;
+    defaultAuthMode: import("@aws-amplify/core/lib-esm/libraryUtils").APIAuthMode;
 };

package/lib/utils/resolveConfig.js

@@ -9,7 +9,7 @@ var errors_1 = require("./errors");
  */
 exports.resolveConfig = function () {
     var _a, _b;
-    var _c = (_b = (_a = core_1.Amplify.getConfig().API) === null || _a === void 0 ? void 0 : _a.AppSync) !== null && _b !== void 0 ? _b : {}, region = _c.region, defaultAuthMode = _c.defaultAuthMode, endpoint = _c.endpoint;
+    var _c = (_b = (_a = core_1.Amplify.getConfig().API) === null || _a === void 0 ? void 0 : _a.GraphQL) !== null && _b !== void 0 ? _b : {}, region = _c.region, defaultAuthMode = _c.defaultAuthMode, endpoint = _c.endpoint;
     errors_1.assertValidationError(!!endpoint, errors_1.APIValidationErrorCode.NoAppId);
     errors_1.assertValidationError(!!region, errors_1.APIValidationErrorCode.NoRegion);
     errors_1.assertValidationError(!!defaultAuthMode, errors_1.APIValidationErrorCode.NoDefaultAuthMode);

package/lib-esm/GraphQLAPI.d.ts

@@ -21,5 +21,17 @@ export declare class GraphQLAPIClass extends InternalGraphQLAPIClass {
     graphql<T = any>(options: GraphQLOptions, additionalHeaders?: {
         [key: string]: string;
     }): Observable<GraphQLResult<T>> | Promise<GraphQLResult<T>>;
+    /**
+     * Checks to see if an error thrown is from an api request cancellation
+     * @param error - Any error
+     * @returns A boolean indicating if the error was from an api request cancellation
+     */
+    isCancelError(error: any): boolean;
+    /**
+     * Cancels an inflight request. Only applicable for graphql queries and mutations
+     * @param {any} request - request to cancel
+     * @returns A boolean indicating if the request was cancelled
+     */
+    cancel(request: Promise<any>, message?: string): boolean;
 }
 export declare const GraphQLAPI: GraphQLAPIClass;

package/lib-esm/GraphQLAPI.js

@@ -29,6 +29,22 @@ var GraphQLAPIClass = /** @class */ (function (_super) {
     GraphQLAPIClass.prototype.graphql = function (options, additionalHeaders) {
         return _super.prototype.graphql.call(this, options, additionalHeaders);
     };
+    /**
+     * Checks to see if an error thrown is from an api request cancellation
+     * @param error - Any error
+     * @returns A boolean indicating if the error was from an api request cancellation
+     */
+    GraphQLAPIClass.prototype.isCancelError = function (error) {
+        return _super.prototype.isCancelError.call(this, error);
+    };
+    /**
+     * Cancels an inflight request. Only applicable for graphql queries and mutations
+     * @param {any} request - request to cancel
+     * @returns A boolean indicating if the request was cancelled
+     */
+    GraphQLAPIClass.prototype.cancel = function (request, message) {
+        return _super.prototype.cancel.call(this, request, message);
+    };
     return GraphQLAPIClass;
 }(InternalGraphQLAPIClass));
 export { GraphQLAPIClass };

package/lib-esm/Providers/AWSAppSyncRealTimeProvider/index.d.ts

@@ -1,8 +1,7 @@
 import { Observable } from 'rxjs';
+import { APIAuthMode, CustomUserAgentDetails, DocumentType } from '@aws-amplify/core/internals/utils';
 import { PubSubContentObserver } from '../../types/PubSub';
 import { SUBSCRIPTION_STATUS } from '../constants';
-import { CustomUserAgentDetails, GraphQLAuthMode } from '@aws-amplify/core/internals/utils';
-import { DocumentType } from '@aws-amplify/api-rest';
 export declare type ObserverQuery = {
     observer: PubSubContentObserver;
     query: string;
@@ -14,7 +13,7 @@ export declare type ObserverQuery = {
 };
 export interface AWSAppSyncRealTimeProviderOptions {
     appSyncGraphqlEndpoint?: string;
-    authenticationType?: GraphQLAuthMode;
+    authenticationType?: APIAuthMode;
     query?: string;
     variables?: Record<string, DocumentType>;
     apiKey?: string;
@@ -58,7 +57,7 @@ export declare class AWSAppSyncRealTimeProvider {
     private _initializeRetryableHandshake;
     private _initializeHandshake;
     private _awsRealTimeHeaderBasedAuth;
-    private _awsRealTimeOPENIDHeader;
+    private _awsAuthTokenHeader;
     private _awsRealTimeApiKeyHeader;
     private _awsRealTimeIAMHeader;
     private _customAuthHeader;

package/lib-esm/Providers/AWSAppSyncRealTimeProvider/index.js

@@ -7,12 +7,12 @@ import * as url from 'url';
 import { v4 as uuid } from 'uuid';
 import { Buffer } from 'buffer';
 import { Hub, fetchAuthSession } from '@aws-amplify/core';
-import { CONTROL_MSG, ConnectionState, } from '../../types/PubSub';
 import { signRequest } from '@aws-amplify/core/internals/aws-client-utils';
+import { Logger, NonRetryableError, USER_AGENT_HEADER, getAmplifyUserAgent, isNonRetryableError, jitteredExponentialRetry, } from '@aws-amplify/core/internals/utils';
+import { CONTROL_MSG, ConnectionState, } from '../../types/PubSub';
 import { AMPLIFY_SYMBOL, AWS_APPSYNC_REALTIME_HEADERS, CONNECTION_INIT_TIMEOUT, DEFAULT_KEEP_ALIVE_TIMEOUT, DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT, MAX_DELAY_MS, MESSAGE_TYPES, NON_RETRYABLE_CODES, SOCKET_STATUS, START_ACK_TIMEOUT, SUBSCRIPTION_STATUS, CONNECTION_STATE_CHANGE, } from '../constants';
 import { ConnectionStateMonitor, CONNECTION_CHANGE, } from '../../utils/ConnectionStateMonitor';
 import { ReconnectEvent, ReconnectionMonitor, } from '../../utils/ReconnectionMonitor';
-import { Logger, NonRetryableError, USER_AGENT_HEADER, getAmplifyUserAgent, isNonRetryableError, jitteredExponentialRetry, } from '@aws-amplify/core/internals/utils';
 var logger = new Logger('AWSAppSyncRealTimeProvider');
 var dispatchApiEvent = function (payload) {
     Hub.dispatch('api', payload, 'PubSub', AMPLIFY_SYMBOL);
@@ -83,7 +83,7 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
     };
     AWSAppSyncRealTimeProvider.prototype.subscribe = function (options, customUserAgentDetails) {
         var _this = this;
-        var _a = options || {}, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region, query = _a.query, variables = _a.variables, authenticationType = _a.authenticationType, additionalHeaders = _a.additionalHeaders;
+        var _a = options || {}, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region, query = _a.query, variables = _a.variables, authenticationType = _a.authenticationType, additionalHeaders = _a.additionalHeaders, apiKey = _a.apiKey;
         return new Observable(function (observer) {
             if (!options || !appSyncGraphqlEndpoint) {
                 observer.error({
@@ -107,6 +107,7 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
                                 authenticationType: authenticationType,
                                 appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
                                 additionalHeaders: additionalHeaders,
+                                apiKey: apiKey,
                             },
                             observer: observer,
                             subscriptionId: subscriptionId_1,
@@ -678,34 +679,36 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
         });
     };
     AWSAppSyncRealTimeProvider.prototype._awsRealTimeHeaderBasedAuth = function (_a) {
-        var authenticationType = _a.authenticationType, payload = _a.payload, canonicalUri = _a.canonicalUri, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region, additionalHeaders = _a.additionalHeaders;
+        var apiKey = _a.apiKey, authenticationType = _a.authenticationType, payload = _a.payload, canonicalUri = _a.canonicalUri, appSyncGraphqlEndpoint = _a.appSyncGraphqlEndpoint, region = _a.region, additionalHeaders = _a.additionalHeaders;
         return __awaiter(this, void 0, void 0, function () {
-            var headerHandler, handler, host, apiKey, result;
+            var headerHandler, handler, host, resolvedApiKey, result;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         headerHandler = {
                             apiKey: this._awsRealTimeApiKeyHeader.bind(this),
                             iam: this._awsRealTimeIAMHeader.bind(this),
-                            jwt: this._awsRealTimeOPENIDHeader.bind(this),
-                            custom: this._customAuthHeader,
+                            oidc: this._awsAuthTokenHeader.bind(this),
+                            userPool: this._awsAuthTokenHeader.bind(this),
+                            lambda: this._customAuthHeader,
+                            none: this._customAuthHeader,
                         };
-                        if (!(!authenticationType || !headerHandler[authenticationType.type])) return [3 /*break*/, 1];
+                        if (!(!authenticationType || !headerHandler[authenticationType])) return [3 /*break*/, 1];
                         logger.debug("Authentication type " + authenticationType + " not supported");
                         return [2 /*return*/, undefined];
                     case 1:
-                        handler = headerHandler[authenticationType.type];
+                        handler = headerHandler[authenticationType];
                         host = url.parse(appSyncGraphqlEndpoint !== null && appSyncGraphqlEndpoint !== void 0 ? appSyncGraphqlEndpoint : '').host;
                         logger.debug("Authenticating with " + JSON.stringify(authenticationType));
-                        apiKey = void 0;
-                        if (authenticationType.type === 'apiKey') {
-                            apiKey = authenticationType.apiKey;
+                        resolvedApiKey = void 0;
+                        if (authenticationType === 'apiKey') {
+                            resolvedApiKey = apiKey;
                         }
                         return [4 /*yield*/, handler({
                                 payload: payload,
                                 canonicalUri: canonicalUri,
                                 appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                                apiKey: apiKey,
+                                apiKey: resolvedApiKey,
                                 region: region,
                                 host: host,
                                 additionalHeaders: additionalHeaders,
@@ -717,7 +720,7 @@ var AWSAppSyncRealTimeProvider = /** @class */ (function () {
             });
         });
     };
-    AWSAppSyncRealTimeProvider.prototype._awsRealTimeOPENIDHeader = function (_a) {
+    AWSAppSyncRealTimeProvider.prototype._awsAuthTokenHeader = function (_a) {
         var host = _a.host;
         var _b, _c;
         return __awaiter(this, void 0, void 0, function () {

package/lib-esm/internals/InternalGraphQLAPI.d.ts

@@ -41,6 +41,18 @@ export declare class InternalGraphQLAPIClass {
         [key: string]: string;
     }, customUserAgentDetails?: CustomUserAgentDetails): Observable<GraphQLResult<T>> | Promise<GraphQLResult<T>>;
     private _graphql;
+    /**
+     * Checks to see if an error thrown is from an api request cancellation
+     * @param {any} error - Any error
+     * @return {boolean} - A boolean indicating if the error was from an api request cancellation
+     */
+    isCancelError(error: any): boolean;
+    /**
+     * Cancels an inflight request. Only applicable for graphql queries and mutations
+     * @param {any} request - request to cancel
+     * @returns - A boolean indicating if the request was cancelled
+     */
+    cancel(request: Promise<any>, message?: string): boolean;
     private _graphqlSubscribe;
 }
 export declare const InternalGraphQLAPI: InternalGraphQLAPIClass;

package/lib-esm/internals/InternalGraphQLAPI.js

@@ -5,7 +5,8 @@ import { print, parse, GraphQLError, } from 'graphql';
 import { Amplify, Cache, fetchAuthSession } from '@aws-amplify/core';
 import { ConsoleLogger as Logger, getAmplifyUserAgent, } from '@aws-amplify/core/internals/utils';
 import { GraphQLAuthError, } from '../types';
-import { post } from '@aws-amplify/api-rest';
+import { isCancelError as isCancelErrorREST } from '@aws-amplify/api-rest';
+import { post, cancel as cancelREST, updateRequestToBeCancellable, } from '@aws-amplify/api-rest/internals';
 import { AWSAppSyncRealTimeProvider } from '../Providers/AWSAppSyncRealTimeProvider';
 var USER_AGENT_HEADER = 'x-amz-user-agent';
 var logger = new Logger('GraphQLAPI');
@@ -27,47 +28,50 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
      */
     function InternalGraphQLAPIClass(options) {
         this.Cache = Cache;
-        this._api = { post: post };
+        this._api = { post: post, updateRequestToBeCancellable: updateRequestToBeCancellable };
         this._options = options;
         logger.debug('API Options', this._options);
     }
     InternalGraphQLAPIClass.prototype.getModuleName = function () {
         return 'InternalGraphQLAPI';
     };
-    InternalGraphQLAPIClass.prototype._headerBasedAuth = function (defaultAuthenticationType, additionalHeaders, customUserAgentDetails) {
+    InternalGraphQLAPIClass.prototype._headerBasedAuth = function (authMode, additionalHeaders) {
         if (additionalHeaders === void 0) { additionalHeaders = {}; }
         var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var config, _b, region, appSyncGraphqlEndpoint, authenticationType, headers, _c, session, token, e_1;
+            var config, _b, region, appSyncGraphqlEndpoint, apiKey, defaultAuthMode, authenticationType, headers, _c, session, token, e_1;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
                         config = Amplify.getConfig();
-                        _b = config.API.AppSync, region = _b.region, appSyncGraphqlEndpoint = _b.endpoint, authenticationType = _b.defaultAuthMode;
+                        _b = config.API.GraphQL, region = _b.region, appSyncGraphqlEndpoint = _b.endpoint, apiKey = _b.apiKey, defaultAuthMode = _b.defaultAuthMode;
+                        authenticationType = authMode || defaultAuthMode || 'iam';
                         headers = {};
-                        _c = authenticationType.type;
+                        _c = authenticationType;
                         switch (_c) {
                             case 'apiKey': return [3 /*break*/, 1];
                             case 'iam': return [3 /*break*/, 2];
-                            case 'jwt': return [3 /*break*/, 4];
-                            case 'custom': return [3 /*break*/, 8];
+                            case 'oidc': return [3 /*break*/, 4];
+                            case 'userPool': return [3 /*break*/, 4];
+                            case 'lambda': return [3 /*break*/, 8];
+                            case 'none': return [3 /*break*/, 9];
                         }
-                        return [3 /*break*/, 9];
+                        return [3 /*break*/, 10];
                     case 1:
-                        if (!authenticationType.apiKey) {
+                        if (!apiKey) {
                             throw new Error(GraphQLAuthError.NO_API_KEY);
                         }
                         headers = {
-                            'X-Api-Key': authenticationType.apiKey,
+                            'X-Api-Key': apiKey,
                         };
-                        return [3 /*break*/, 10];
+                        return [3 /*break*/, 11];
                     case 2: return [4 /*yield*/, fetchAuthSession()];
                     case 3:
                         session = _d.sent();
                         if (session.credentials === undefined) {
                             throw new Error(GraphQLAuthError.NO_CREDENTIALS);
                         }
-                        return [3 /*break*/, 10];
+                        return [3 /*break*/, 11];
                     case 4:
                         _d.trys.push([4, 6, , 7]);
                         token = void 0;
@@ -84,7 +88,7 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                     case 6:
                         e_1 = _d.sent();
                         throw new Error(GraphQLAuthError.NO_CURRENT_USER);
-                    case 7: return [3 /*break*/, 10];
+                    case 7: return [3 /*break*/, 11];
                     case 8:
                         if (!additionalHeaders.Authorization) {
                             throw new Error(GraphQLAuthError.NO_AUTH_TOKEN);
@@ -92,13 +96,14 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                         headers = {
                             Authorization: additionalHeaders.Authorization,
                         };
-                        return [3 /*break*/, 10];
-                    case 9:
+                        return [3 /*break*/, 11];
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
                         headers = {
                             Authorization: null,
                         };
-                        return [3 /*break*/, 10];
-                    case 10: return [2 /*return*/, headers];
+                        return [3 /*break*/, 11];
+                    case 11: return [2 /*return*/, headers];
                 }
             });
         });
@@ -135,7 +140,9 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
         switch (operationType) {
             case 'query':
             case 'mutation':
-                var responsePromise = this._graphql({ query: query, variables: variables, authMode: authMode }, headers, customUserAgentDetails);
+                var abortController = new AbortController();
+                var responsePromise = this._graphql({ query: query, variables: variables, authMode: authMode }, headers, abortController, customUserAgentDetails);
+                this._api.updateRequestToBeCancellable(responsePromise, abortController);
                 return responsePromise;
             case 'subscription':
                 return this._graphqlSubscribe({ query: query, variables: variables, authMode: authMode }, headers, customUserAgentDetails);
@@ -143,23 +150,23 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                 throw new Error("invalid operation type: " + operationType);
         }
     };
-    InternalGraphQLAPIClass.prototype._graphql = function (_a, additionalHeaders, customUserAgentDetails) {
+    InternalGraphQLAPIClass.prototype._graphql = function (_a, additionalHeaders, abortController, customUserAgentDetails) {
         var query = _a.query, variables = _a.variables, authMode = _a.authMode;
         if (additionalHeaders === void 0) { additionalHeaders = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var config, _b, region, appSyncGraphqlEndpoint, customGraphqlEndpoint, customEndpointRegion, headers, _c, _d, _e, _f, _g, body, endpoint, error, response, err_1, errors;
+            var config, _b, region, appSyncGraphqlEndpoint, customGraphqlEndpoint, customEndpointRegion, headers, _c, _d, _e, _f, _g, body, endpoint, error, response, responseBody, result, err_1, errors;
             var _h;
             return __generator(this, function (_j) {
                 switch (_j.label) {
                     case 0:
                         config = Amplify.getConfig();
-                        _b = config.API.AppSync, region = _b.region, appSyncGraphqlEndpoint = _b.endpoint;
+                        _b = config.API.GraphQL, region = _b.region, appSyncGraphqlEndpoint = _b.endpoint;
                         customGraphqlEndpoint = null;
                         customEndpointRegion = null;
                         _c = [{}];
                         _d = !customGraphqlEndpoint;
                         if (!_d) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders, customUserAgentDetails)];
+                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders)];
                     case 1:
                         _d = (_j.sent());
                         _j.label = 2;
@@ -168,7 +175,7 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                         _f = customGraphqlEndpoint;
                         if (!_f) return [3 /*break*/, 6];
                         if (!customEndpointRegion) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders, customUserAgentDetails)];
+                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders)];
                     case 3:
                         _g = _j.sent();
                         return [3 /*break*/, 5];
@@ -196,24 +203,40 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                         }
                         _j.label = 7;
                     case 7:
-                        _j.trys.push([7, 9, , 10]);
-                        return [4 /*yield*/, this._api.post(endpoint, {
-                                headers: headers,
-                                body: body,
-                                region: region,
-                                serviceName: 'appsync',
+                        _j.trys.push([7, 10, , 11]);
+                        return [4 /*yield*/, this._api.post({
+                                url: new URL(endpoint),
+                                options: {
+                                    headers: headers,
+                                    body: body,
+                                    signingServiceInfo: {
+                                        service: 'appsync',
+                                        region: region,
+                                    },
+                                },
+                                abortController: abortController,
                             })];
                     case 8:
-                        response = _j.sent();
-                        return [3 /*break*/, 10];
+                        responseBody = (_j.sent()).body;
+                        return [4 /*yield*/, responseBody.json()];
                     case 9:
+                        result = _j.sent();
+                        response = result;
+                        return [3 /*break*/, 11];
+                    case 10:
                         err_1 = _j.sent();
+                        // If the exception is because user intentionally
+                        // cancelled the request, do not modify the exception
+                        // so that clients can identify the exception correctly.
+                        if (isCancelErrorREST(err_1)) {
+                            throw err_1;
+                        }
                         response = {
                             data: {},
                             errors: [new GraphQLError(err_1.message, null, null, null, null, err_1)],
                         };
-                        return [3 /*break*/, 10];
-                    case 10:
+                        return [3 /*break*/, 11];
+                    case 11:
                         errors = response.errors;
                         if (errors && errors.length) {
                             throw response;
@@ -223,21 +246,39 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Checks to see if an error thrown is from an api request cancellation
+     * @param {any} error - Any error
+     * @return {boolean} - A boolean indicating if the error was from an api request cancellation
+     */
+    InternalGraphQLAPIClass.prototype.isCancelError = function (error) {
+        return isCancelErrorREST(error);
+    };
+    /**
+     * Cancels an inflight request. Only applicable for graphql queries and mutations
+     * @param {any} request - request to cancel
+     * @returns - A boolean indicating if the request was cancelled
+     */
+    InternalGraphQLAPIClass.prototype.cancel = function (request, message) {
+        return cancelREST(request, message);
+    };
     InternalGraphQLAPIClass.prototype._graphqlSubscribe = function (_a, additionalHeaders, customUserAgentDetails) {
-        var query = _a.query, variables = _a.variables, defaultAuthenticationType = _a.authMode, authToken = _a.authToken;
+        var query = _a.query, variables = _a.variables, authMode = _a.authMode;
         if (additionalHeaders === void 0) { additionalHeaders = {}; }
         var _b;
-        var AppSync = ((_b = Amplify.getConfig().API) !== null && _b !== void 0 ? _b : {}).AppSync;
+        var GraphQL = ((_b = Amplify.getConfig().API) !== null && _b !== void 0 ? _b : {}).GraphQL;
         if (!this.appSyncRealTime) {
             this.appSyncRealTime = new AWSAppSyncRealTimeProvider();
         }
         return this.appSyncRealTime.subscribe({
             query: print(query),
             variables: variables,
-            appSyncGraphqlEndpoint: AppSync === null || AppSync === void 0 ? void 0 : AppSync.endpoint,
-            region: AppSync === null || AppSync === void 0 ? void 0 : AppSync.region,
-            authenticationType: AppSync === null || AppSync === void 0 ? void 0 : AppSync.defaultAuthMode,
-        });
+            appSyncGraphqlEndpoint: GraphQL === null || GraphQL === void 0 ? void 0 : GraphQL.endpoint,
+            region: GraphQL === null || GraphQL === void 0 ? void 0 : GraphQL.region,
+            authenticationType: authMode !== null && authMode !== void 0 ? authMode : GraphQL === null || GraphQL === void 0 ? void 0 : GraphQL.defaultAuthMode,
+            apiKey: GraphQL === null || GraphQL === void 0 ? void 0 : GraphQL.apiKey,
+            additionalHeaders: additionalHeaders,
+        }, customUserAgentDetails);
     };
     return InternalGraphQLAPIClass;
 }());

package/lib-esm/internals/index.d.ts

@@ -1,2 +1,2 @@
 export { InternalGraphQLAPI, InternalGraphQLAPIClass, } from './InternalGraphQLAPI';
-export { graphql } from './v6';
+export { graphql, cancel, isCancelError } from './v6';

package/lib-esm/internals/index.js

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 export { InternalGraphQLAPI, InternalGraphQLAPIClass, } from './InternalGraphQLAPI';
-export { graphql } from './v6';
+export { graphql, cancel, isCancelError } from './v6';

package/lib-esm/internals/v6.d.ts

@@ -86,4 +86,16 @@ import { GraphQLOptionsV6, GraphQLResponseV6 } from '../types';
 export declare function graphql<FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>, additionalHeaders?: {
     [key: string]: string;
 }): GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
+/**
+ * Cancels an inflight request. Only applicable for graphql queries and mutations
+ * @param {any} request - request to cancel
+ * @returns - A boolean indicating if the request was cancelled
+ */
+export declare function cancel(promise: Promise<any>, message?: string): boolean;
+/**
+ * Checks to see if an error thrown is from an api request cancellation
+ * @param {any} error - Any error
+ * @returns - A boolean indicating if the error was from an api request cancellation
+ */
+export declare function isCancelError(error: any): boolean;
 export { GraphQLOptionsV6, GraphQLResponseV6 };

package/lib-esm/internals/v6.js

@@ -94,3 +94,19 @@ export function graphql(options, additionalHeaders) {
     var result = GraphQLAPI.graphql(options, additionalHeaders);
     return result;
 }
+/**
+ * Cancels an inflight request. Only applicable for graphql queries and mutations
+ * @param {any} request - request to cancel
+ * @returns - A boolean indicating if the request was cancelled
+ */
+export function cancel(promise, message) {
+    return GraphQLAPI.cancel(promise, message);
+}
+/**
+ * Checks to see if an error thrown is from an api request cancellation
+ * @param {any} error - Any error
+ * @returns - A boolean indicating if the error was from an api request cancellation
+ */
+export function isCancelError(error) {
+    return GraphQLAPI.isCancelError(error);
+}