@aws-amplify/api-graphql 3.4.11 → 4.0.1-console-preview.047a1dd.0

package/lib-esm/internals/InternalGraphQLAPI.js

@@ -1,13 +1,12 @@
-import { __assign, __awaiter, __generator, __read, __rest } from "tslib";
+import { __assign, __awaiter, __generator, __read } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { print, parse, GraphQLError, } from 'graphql';
-import { Amplify, ConsoleLogger as Logger, Credentials, getAmplifyUserAgent, INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER, } from '@aws-amplify/core';
-import { InternalPubSub } from '@aws-amplify/pubsub/internals';
-import { Auth } from '@aws-amplify/auth';
-import { Cache } from '@aws-amplify/cache';
+import { Amplify, Cache, fetchAuthSession } from '@aws-amplify/core';
+import { ConsoleLogger as Logger, getAmplifyUserAgent, } from '@aws-amplify/core/internals/utils';
 import { GraphQLAuthError, } from '../types';
-import { RestClient } from '@aws-amplify/api-rest';
+import { post } from '@aws-amplify/api-rest';
+import { AWSAppSyncRealTimeProvider } from '../Providers/AWSAppSyncRealTimeProvider';
 var USER_AGENT_HEADER = 'x-amz-user-agent';
 var logger = new Logger('GraphQLAPI');
 export var graphqlOperation = function (query, variables, authToken) {
@@ -27,146 +26,78 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
      * @param {Object} options - Configuration object for API
      */
     function InternalGraphQLAPIClass(options) {
-        this._api = null;
-        this.Auth = Auth;
         this.Cache = Cache;
-        this.Credentials = Credentials;
         this._options = options;
         logger.debug('API Options', this._options);
     }
     InternalGraphQLAPIClass.prototype.getModuleName = function () {
         return 'InternalGraphQLAPI';
     };
-    /**
-     * Configure API
-     * @param {Object} config - Configuration of the API
-     * @return {Object} - The current configuration
-     */
-    InternalGraphQLAPIClass.prototype.configure = function (options) {
-        var _a = options || {}, _b = _a.API, API = _b === void 0 ? {} : _b, otherOptions = __rest(_a, ["API"]);
-        var opt = __assign(__assign({}, otherOptions), API);
-        logger.debug('configure GraphQL API', { opt: opt });
-        if (opt['aws_project_region']) {
-            opt = Object.assign({}, opt, {
-                region: opt['aws_project_region'],
-                header: {},
-            });
-        }
-        if (typeof opt.graphql_headers !== 'undefined' &&
-            typeof opt.graphql_headers !== 'function') {
-            logger.warn('graphql_headers should be a function');
-            opt.graphql_headers = undefined;
-        }
-        this._options = Object.assign({}, this._options, opt);
-        this.createInstance();
-        return this._options;
-    };
-    /**
-     * Create an instance of API for the library
-     * @return - A promise of true if Success
-     */
-    InternalGraphQLAPIClass.prototype.createInstance = function () {
-        logger.debug('create Rest instance');
-        if (this._options) {
-            this._api = new RestClient(this._options);
-            // Share instance Credentials with client for SSR
-            this._api.Credentials = this.Credentials;
-            return true;
-        }
-        else {
-            return Promise.reject('API not configured');
-        }
-    };
-    InternalGraphQLAPIClass.prototype._headerBasedAuth = function (defaultAuthenticationType, additionalHeaders) {
+    InternalGraphQLAPIClass.prototype._headerBasedAuth = function (defaultAuthenticationType, additionalHeaders, customUserAgentDetails) {
         if (additionalHeaders === void 0) { additionalHeaders = {}; }
+        var _a;
         return __awaiter(this, void 0, void 0, function () {
-            var _a, aws_appsync_authenticationType, apiKey, authenticationType, headers, _b, credentialsOK, token, federatedInfo, currentUser, e_1, session, e_2;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var config, _b, region, appSyncGraphqlEndpoint, authenticationType, headers, _c, session, token, e_1;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
-                        _a = this._options, aws_appsync_authenticationType = _a.aws_appsync_authenticationType, apiKey = _a.aws_appsync_apiKey;
-                        authenticationType = defaultAuthenticationType || aws_appsync_authenticationType || 'AWS_IAM';
+                        config = Amplify.getConfig();
+                        _b = config.API.AppSync, region = _b.region, appSyncGraphqlEndpoint = _b.endpoint, authenticationType = _b.defaultAuthMode;
                         headers = {};
-                        _b = authenticationType;
-                        switch (_b) {
-                            case 'API_KEY': return [3 /*break*/, 1];
-                            case 'AWS_IAM': return [3 /*break*/, 2];
-                            case 'OPENID_CONNECT': return [3 /*break*/, 4];
-                            case 'AMAZON_COGNITO_USER_POOLS': return [3 /*break*/, 11];
-                            case 'AWS_LAMBDA': return [3 /*break*/, 15];
+                        _c = authenticationType.type;
+                        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];
                         }
-                        return [3 /*break*/, 16];
+                        return [3 /*break*/, 9];
                     case 1:
-                        if (!apiKey) {
+                        if (!authenticationType.apiKey) {
                             throw new Error(GraphQLAuthError.NO_API_KEY);
                         }
                         headers = {
-                            Authorization: null,
-                            'X-Api-Key': apiKey,
+                            'X-Api-Key': authenticationType.apiKey,
                         };
-                        return [3 /*break*/, 17];
-                    case 2: return [4 /*yield*/, this._ensureCredentials()];
+                        return [3 /*break*/, 10];
+                    case 2: return [4 /*yield*/, fetchAuthSession()];
                     case 3:
-                        credentialsOK = _c.sent();
-                        if (!credentialsOK) {
+                        session = _d.sent();
+                        if (session.credentials === undefined) {
                             throw new Error(GraphQLAuthError.NO_CREDENTIALS);
                         }
-                        return [3 /*break*/, 17];
+                        return [3 /*break*/, 10];
                     case 4:
-                        _c.trys.push([4, 9, , 10]);
+                        _d.trys.push([4, 6, , 7]);
                         token = void 0;
-                        return [4 /*yield*/, Cache.getItem('federatedInfo')];
+                        return [4 /*yield*/, fetchAuthSession()];
                     case 5:
-                        federatedInfo = _c.sent();
-                        if (!federatedInfo) return [3 /*break*/, 6];
-                        token = federatedInfo.token;
-                        return [3 /*break*/, 8];
-                    case 6: return [4 /*yield*/, Auth.currentAuthenticatedUser()];
-                    case 7:
-                        currentUser = _c.sent();
-                        if (currentUser) {
-                            token = currentUser.token;
-                        }
-                        _c.label = 8;
-                    case 8:
+                        token = (_a = (_d.sent()).tokens) === null || _a === void 0 ? void 0 : _a.accessToken.toString();
                         if (!token) {
                             throw new Error(GraphQLAuthError.NO_FEDERATED_JWT);
                         }
                         headers = {
                             Authorization: token,
                         };
-                        return [3 /*break*/, 10];
-                    case 9:
-                        e_1 = _c.sent();
-                        throw new Error(GraphQLAuthError.NO_CURRENT_USER);
-                    case 10: return [3 /*break*/, 17];
-                    case 11:
-                        _c.trys.push([11, 13, , 14]);
-                        return [4 /*yield*/, this.Auth.currentSession()];
-                    case 12:
-                        session = _c.sent();
-                        headers = {
-                            Authorization: session.getAccessToken().getJwtToken(),
-                        };
-                        return [3 /*break*/, 14];
-                    case 13:
-                        e_2 = _c.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        e_1 = _d.sent();
                         throw new Error(GraphQLAuthError.NO_CURRENT_USER);
-                    case 14: return [3 /*break*/, 17];
-                    case 15:
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
                         if (!additionalHeaders.Authorization) {
                             throw new Error(GraphQLAuthError.NO_AUTH_TOKEN);
                         }
                         headers = {
                             Authorization: additionalHeaders.Authorization,
                         };
-                        return [3 /*break*/, 17];
-                    case 16:
+                        return [3 /*break*/, 10];
+                    case 9:
                         headers = {
                             Authorization: null,
                         };
-                        return [3 /*break*/, 17];
-                    case 17: return [2 /*return*/, headers];
+                        return [3 /*break*/, 10];
+                    case 10: return [2 /*return*/, headers];
                 }
             });
         });
@@ -203,14 +134,7 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
         switch (operationType) {
             case 'query':
             case 'mutation':
-                this.createInstanceIfNotCreated();
-                var cancellableToken = this._api.getCancellableToken();
-                var initParams = {
-                    cancellableToken: cancellableToken,
-                    withCredentials: this._options.withCredentials,
-                };
-                var responsePromise = this._graphql({ query: query, variables: variables, authMode: authMode }, headers, initParams, customUserAgentDetails);
-                this._api.updateRequestToBeCancellable(responsePromise, cancellableToken);
+                var responsePromise = this._graphql({ query: query, variables: variables, authMode: authMode }, headers, customUserAgentDetails);
                 return responsePromise;
             case 'subscription':
                 return this._graphqlSubscribe({ query: query, variables: variables, authMode: authMode }, headers, customUserAgentDetails);
@@ -218,59 +142,49 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                 throw new Error("invalid operation type: " + operationType);
         }
     };
-    InternalGraphQLAPIClass.prototype._graphql = function (_a, additionalHeaders, initParams, customUserAgentDetails) {
+    InternalGraphQLAPIClass.prototype._graphql = function (_a, additionalHeaders, customUserAgentDetails) {
         var query = _a.query, variables = _a.variables, authMode = _a.authMode;
         if (additionalHeaders === void 0) { additionalHeaders = {}; }
-        if (initParams === void 0) { initParams = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var _b, region, appSyncGraphqlEndpoint, _c, graphql_headers, customGraphqlEndpoint, customEndpointRegion, headers, _d, _e, _f, _g, _h, _j, body, init, endpoint, error, response, err_1, errors;
-            var _k;
-            return __generator(this, function (_l) {
-                switch (_l.label) {
+            var config, _b, region, appSyncGraphqlEndpoint, customGraphqlEndpoint, customEndpointRegion, headers, _c, _d, _e, _f, _g, body, endpoint, error, response, err_1, errors;
+            var _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
                     case 0:
-                        this.createInstanceIfNotCreated();
-                        _b = this._options, region = _b.aws_appsync_region, appSyncGraphqlEndpoint = _b.aws_appsync_graphqlEndpoint, _c = _b.graphql_headers, graphql_headers = _c === void 0 ? function () { return ({}); } : _c, customGraphqlEndpoint = _b.graphql_endpoint, customEndpointRegion = _b.graphql_endpoint_iam_region;
-                        _d = [{}];
-                        _e = !customGraphqlEndpoint;
-                        if (!_e) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders)];
+                        config = Amplify.getConfig();
+                        _b = config.API.AppSync, 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)];
                     case 1:
-                        _e = (_l.sent());
-                        _l.label = 2;
+                        _d = (_j.sent());
+                        _j.label = 2;
                     case 2:
-                        _f = [__assign.apply(void 0, _d.concat([(_e)]))];
-                        _g = customGraphqlEndpoint;
-                        if (!_g) return [3 /*break*/, 6];
+                        _e = [__assign.apply(void 0, _c.concat([(_d)]))];
+                        _f = customGraphqlEndpoint;
+                        if (!_f) return [3 /*break*/, 6];
                         if (!customEndpointRegion) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders)];
+                        return [4 /*yield*/, this._headerBasedAuth(authMode, additionalHeaders, customUserAgentDetails)];
                     case 3:
-                        _h = _l.sent();
+                        _g = _j.sent();
                         return [3 /*break*/, 5];
                     case 4:
-                        _h = { Authorization: null };
-                        _l.label = 5;
+                        _g = { Authorization: null };
+                        _j.label = 5;
                     case 5:
-                        _g = (_h);
-                        _l.label = 6;
+                        _f = (_g);
+                        _j.label = 6;
                     case 6:
-                        _j = [__assign.apply(void 0, _f.concat([(_g)]))];
-                        return [4 /*yield*/, graphql_headers({ query: query, variables: variables })];
-                    case 7:
-                        headers = __assign.apply(void 0, [__assign.apply(void 0, [__assign.apply(void 0, _j.concat([(_l.sent())])), additionalHeaders]), (!customGraphqlEndpoint && (_k = {},
-                                _k[USER_AGENT_HEADER] = getAmplifyUserAgent(customUserAgentDetails),
-                                _k))]);
+                        headers = __assign.apply(void 0, [__assign.apply(void 0, [__assign.apply(void 0, _e.concat([(_f)])), additionalHeaders]), (!customGraphqlEndpoint && (_h = {},
+                                _h[USER_AGENT_HEADER] = getAmplifyUserAgent(customUserAgentDetails),
+                                _h))]);
                         body = {
                             query: print(query),
                             variables: variables,
                         };
-                        init = Object.assign({
-                            headers: headers,
-                            body: body,
-                            signerServiceInfo: {
-                                service: !customGraphqlEndpoint ? 'appsync' : 'execute-api',
-                                region: !customGraphqlEndpoint ? region : customEndpointRegion,
-                            },
-                        }, initParams);
                         endpoint = customGraphqlEndpoint || appSyncGraphqlEndpoint;
                         if (!endpoint) {
                             error = new GraphQLError('No graphql endpoint provided.');
@@ -279,27 +193,26 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
                                 errors: [error],
                             };
                         }
-                        _l.label = 8;
+                        _j.label = 7;
+                    case 7:
+                        _j.trys.push([7, 9, , 10]);
+                        return [4 /*yield*/, post(endpoint, {
+                                headers: headers,
+                                body: body,
+                                region: region,
+                                serviceName: 'appsync',
+                            })];
                     case 8:
-                        _l.trys.push([8, 10, , 11]);
-                        return [4 /*yield*/, this._api.post(endpoint, init)];
+                        response = _j.sent();
+                        return [3 /*break*/, 10];
                     case 9:
-                        response = _l.sent();
-                        return [3 /*break*/, 11];
-                    case 10:
-                        err_1 = _l.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 (this._api.isCancel(err_1)) {
-                            throw err_1;
-                        }
+                        err_1 = _j.sent();
                         response = {
                             data: {},
                             errors: [new GraphQLError(err_1.message, null, null, null, null, err_1)],
                         };
-                        return [3 /*break*/, 11];
-                    case 11:
+                        return [3 /*break*/, 10];
+                    case 10:
                         errors = response.errors;
                         if (errors && errors.length) {
                             throw response;
@@ -309,90 +222,23 @@ var InternalGraphQLAPIClass = /** @class */ (function () {
             });
         });
     };
-    InternalGraphQLAPIClass.prototype.createInstanceIfNotCreated = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!!this._api) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.createInstance()];
-                    case 1:
-                        _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * 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.isCancel = function (error) {
-        return this._api.isCancel(error);
-    };
-    /**
-     * Cancels an inflight request. Only applicable for graphql queries and mutations
-     * @param {any} request - request to cancel
-     * @return {boolean} - A boolean indicating if the request was cancelled
-     */
-    InternalGraphQLAPIClass.prototype.cancel = function (request, message) {
-        return this._api.cancel(request, message);
-    };
-    /**
-     * Check if the request has a corresponding cancel token in the WeakMap.
-     * @params request - The request promise
-     * @return if the request has a corresponding cancel token.
-     */
-    InternalGraphQLAPIClass.prototype.hasCancelToken = function (request) {
-        return this._api.hasCancelToken(request);
-    };
     InternalGraphQLAPIClass.prototype._graphqlSubscribe = function (_a, additionalHeaders, customUserAgentDetails) {
         var query = _a.query, variables = _a.variables, defaultAuthenticationType = _a.authMode, authToken = _a.authToken;
         if (additionalHeaders === void 0) { additionalHeaders = {}; }
-        var _b = this._options, region = _b.aws_appsync_region, appSyncGraphqlEndpoint = _b.aws_appsync_graphqlEndpoint, aws_appsync_authenticationType = _b.aws_appsync_authenticationType, apiKey = _b.aws_appsync_apiKey, _c = _b.graphql_headers, graphql_headers = _c === void 0 ? function () { return ({}); } : _c;
-        var authenticationType = defaultAuthenticationType || aws_appsync_authenticationType || 'AWS_IAM';
-        if (InternalPubSub && typeof InternalPubSub.subscribe === 'function') {
-            return InternalPubSub.subscribe('', {
-                provider: INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER,
-                appSyncGraphqlEndpoint: appSyncGraphqlEndpoint,
-                authenticationType: authenticationType,
-                apiKey: apiKey,
-                query: print(query),
-                region: region,
-                variables: variables,
-                graphql_headers: graphql_headers,
-                additionalHeaders: additionalHeaders,
-                authToken: authToken,
-            }, customUserAgentDetails);
-        }
-        else {
-            logger.debug('No pubsub module applied for subscription');
-            throw new Error('No pubsub module applied for subscription');
+        var _b;
+        var AppSync = ((_b = Amplify.getConfig().API) !== null && _b !== void 0 ? _b : {}).AppSync;
+        if (!this.appSyncRealTime) {
+            this.appSyncRealTime = new AWSAppSyncRealTimeProvider();
         }
-    };
-    /**
-     * @private
-     */
-    InternalGraphQLAPIClass.prototype._ensureCredentials = function () {
-        var _this = this;
-        return this.Credentials.get()
-            .then(function (credentials) {
-            if (!credentials)
-                return false;
-            var cred = _this.Credentials.shear(credentials);
-            logger.debug('set credentials for api', cred);
-            return true;
-        })
-            .catch(function (err) {
-            logger.warn('ensure credentials error', err);
-            return false;
+        return this.appSyncRealTime.subscribe({
+            query: print(query),
+            variables: variables,
+            appSyncGraphqlEndpoint: AppSync.endpoint,
+            region: AppSync.region,
+            authenticationType: AppSync.defaultAuthMode,
         });
     };
     return InternalGraphQLAPIClass;
 }());
 export { InternalGraphQLAPIClass };
 export var InternalGraphQLAPI = new InternalGraphQLAPIClass(null);
-Amplify.register(InternalGraphQLAPI);
-//# sourceMappingURL=InternalGraphQLAPI.js.map

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

@@ -1 +1,2 @@
 export { InternalGraphQLAPI, InternalGraphQLAPIClass, } from './InternalGraphQLAPI';
+export { graphql } 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';
-//# sourceMappingURL=index.js.map
+export { graphql } from './v6';

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

@@ -0,0 +1,89 @@
+import { GraphQLOptionsV6, GraphQLResponseV6 } from '../types';
+/**
+ * Invokes graphql operations against a graphql service, providing correct input and
+ * output types if Amplify-generated graphql from a recent version of the CLI/codegen
+ * are used *or* correct typing is provided via the type argument.
+ *
+ * Amplify-generated "branded" graphql queries will look similar to this:
+ *
+ * ```ts
+ *                               //
+ *                               // |-- branding
+ *                               // v
+ * export const getModel = `...` as GeneratedQuery<
+ * 	GetModelQueryVariables,
+ * 	GetModelQuery
+ * >;
+ * ```
+ *
+ * If this branding is not in your generated graphql, update to a newer version of
+ * CLI/codegen and regenerate your graphql using `amplify codegen`.
+ *
+ * ## Using Amplify-generated graphql
+ *
+ * ```ts
+ * import * as queries from './graphql/queries';
+ *
+ * //
+ * //    |-- correctly typed graphql response containing a Widget
+ * //    v
+ * const queryResult = await graphql({
+ * 	query: queries.getWidget,
+ * 	variables: {
+ * 		id: "abc", // <-- type hinted/enforced
+ * 	},
+ * });
+ *
+ * //
+ * //    |-- a correctly typed Widget
+ * //    v
+ * const fetchedWidget = queryResult.data?.getWidget!;
+ * ```
+ *
+ * ## Custom input + result types
+ *
+ * To provide input types (`variables`) and result types:
+ *
+ * ```ts
+ * type GetById_NameOnly = {
+ * 	variables: {
+ * 		id: string
+ * 	},
+ * 	result: Promise<{
+ * 		data: { getWidget: { name: string } }
+ * 	}>
+ * }
+ *
+ * //
+ * //    |-- type is GetById_NameOnly["result"]
+ * //    v
+ * const result = graphql<GetById_NameOnly>({
+ * 	query: "...",
+ * 	variables: { id: "abc" }  // <-- type of GetById_NameOnly["variables"]
+ * });
+ * ```
+ *
+ * ## Custom result type only
+ *
+ * To specify result types only, use a type that is *not* in the `{variables, result}` shape:
+ *
+ * ```ts
+ * type MyResultType = Promise<{
+ * 	data: {
+ * 		getWidget: { name: string }
+ * 	}
+ * }>
+ *
+ * //
+ * //    |-- type is MyResultType
+ * //    v
+ * const result = graphql<MyResultType>({query: "..."});
+ * ```
+ *
+ * @param options
+ * @param additionalHeaders
+ */
+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>;
+export { GraphQLOptionsV6, GraphQLResponseV6 };

package/lib-esm/internals/v6.js

@@ -0,0 +1,96 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { GraphQLAPI } from '../GraphQLAPI';
+/**
+ * Invokes graphql operations against a graphql service, providing correct input and
+ * output types if Amplify-generated graphql from a recent version of the CLI/codegen
+ * are used *or* correct typing is provided via the type argument.
+ *
+ * Amplify-generated "branded" graphql queries will look similar to this:
+ *
+ * ```ts
+ *                               //
+ *                               // |-- branding
+ *                               // v
+ * export const getModel = `...` as GeneratedQuery<
+ * 	GetModelQueryVariables,
+ * 	GetModelQuery
+ * >;
+ * ```
+ *
+ * If this branding is not in your generated graphql, update to a newer version of
+ * CLI/codegen and regenerate your graphql using `amplify codegen`.
+ *
+ * ## Using Amplify-generated graphql
+ *
+ * ```ts
+ * import * as queries from './graphql/queries';
+ *
+ * //
+ * //    |-- correctly typed graphql response containing a Widget
+ * //    v
+ * const queryResult = await graphql({
+ * 	query: queries.getWidget,
+ * 	variables: {
+ * 		id: "abc", // <-- type hinted/enforced
+ * 	},
+ * });
+ *
+ * //
+ * //    |-- a correctly typed Widget
+ * //    v
+ * const fetchedWidget = queryResult.data?.getWidget!;
+ * ```
+ *
+ * ## Custom input + result types
+ *
+ * To provide input types (`variables`) and result types:
+ *
+ * ```ts
+ * type GetById_NameOnly = {
+ * 	variables: {
+ * 		id: string
+ * 	},
+ * 	result: Promise<{
+ * 		data: { getWidget: { name: string } }
+ * 	}>
+ * }
+ *
+ * //
+ * //    |-- type is GetById_NameOnly["result"]
+ * //    v
+ * const result = graphql<GetById_NameOnly>({
+ * 	query: "...",
+ * 	variables: { id: "abc" }  // <-- type of GetById_NameOnly["variables"]
+ * });
+ * ```
+ *
+ * ## Custom result type only
+ *
+ * To specify result types only, use a type that is *not* in the `{variables, result}` shape:
+ *
+ * ```ts
+ * type MyResultType = Promise<{
+ * 	data: {
+ * 		getWidget: { name: string }
+ * 	}
+ * }>
+ *
+ * //
+ * //    |-- type is MyResultType
+ * //    v
+ * const result = graphql<MyResultType>({query: "..."});
+ * ```
+ *
+ * @param options
+ * @param additionalHeaders
+ */
+export function graphql(options, additionalHeaders) {
+    /**
+     * The correctness of these typings depends on correct string branding or overrides.
+     * Neither of these can actually be validated at runtime. Hence, we don't perform
+     * any validation or type-guarding here.
+     */
+    var result = GraphQLAPI.graphql(options, additionalHeaders);
+    return result;
+}