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

package/src/Providers/constants.ts

@@ -0,0 +1,110 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { AMPLIFY_SYMBOL } from '@aws-amplify/core/internals/utils';
+
+export const MAX_DELAY_MS = 5000;
+
+export const NON_RETRYABLE_CODES = [400, 401, 403];
+
+export const CONNECTION_STATE_CHANGE = 'ConnectionStateChange';
+
+export enum MESSAGE_TYPES {
+	/**
+	 * Client -> Server message.
+	 * This message type is the first message after handshake and this will initialize AWS AppSync RealTime communication
+	 */
+	GQL_CONNECTION_INIT = 'connection_init',
+	/**
+	 * Server -> Client message
+	 * This message type is in case there is an issue with AWS AppSync RealTime when establishing connection
+	 */
+	GQL_CONNECTION_ERROR = 'connection_error',
+	/**
+	 * Server -> Client message.
+	 * This message type is for the ack response from AWS AppSync RealTime for GQL_CONNECTION_INIT message
+	 */
+	GQL_CONNECTION_ACK = 'connection_ack',
+	/**
+	 * Client -> Server message.
+	 * This message type is for register subscriptions with AWS AppSync RealTime
+	 */
+	GQL_START = 'start',
+	/**
+	 * Server -> Client message.
+	 * This message type is for the ack response from AWS AppSync RealTime for GQL_START message
+	 */
+	GQL_START_ACK = 'start_ack',
+	/**
+	 * Server -> Client message.
+	 * This message type is for subscription message from AWS AppSync RealTime
+	 */
+	GQL_DATA = 'data',
+	/**
+	 * Server -> Client message.
+	 * This message type helps the client to know is still receiving messages from AWS AppSync RealTime
+	 */
+	GQL_CONNECTION_KEEP_ALIVE = 'ka',
+	/**
+	 * Client -> Server message.
+	 * This message type is for unregister subscriptions with AWS AppSync RealTime
+	 */
+	GQL_STOP = 'stop',
+	/**
+	 * Server -> Client message.
+	 * This message type is for the ack response from AWS AppSync RealTime for GQL_STOP message
+	 */
+	GQL_COMPLETE = 'complete',
+	/**
+	 * Server -> Client message.
+	 * This message type is for sending error messages from AWS AppSync RealTime to the client
+	 */
+	GQL_ERROR = 'error', // Server -> Client
+}
+
+export enum SUBSCRIPTION_STATUS {
+	PENDING,
+	CONNECTED,
+	FAILED,
+}
+
+export enum SOCKET_STATUS {
+	CLOSED,
+	READY,
+	CONNECTING,
+}
+
+export const AWS_APPSYNC_REALTIME_HEADERS = {
+	accept: 'application/json, text/javascript',
+	'content-encoding': 'amz-1.0',
+	'content-type': 'application/json; charset=UTF-8',
+};
+
+/**
+ * Time in milleseconds to wait for GQL_CONNECTION_INIT message
+ */
+export const CONNECTION_INIT_TIMEOUT = 15000;
+
+/**
+ * Time in milleseconds to wait for GQL_START_ACK message
+ */
+export const START_ACK_TIMEOUT = 15000;
+
+/**
+ * Default Time in milleseconds to wait for GQL_CONNECTION_KEEP_ALIVE message
+ */
+export const DEFAULT_KEEP_ALIVE_TIMEOUT = 5 * 60 * 1000;
+
+/**
+ * Default Time in milleseconds to alert for missed GQL_CONNECTION_KEEP_ALIVE message
+ */
+export const DEFAULT_KEEP_ALIVE_ALERT_TIMEOUT = 65 * 1000;
+
+/**
+ * Default delay time in milleseconds between when reconnect is triggered vs when it is attempted
+ */
+export const RECONNECT_DELAY = 5 * 1000;
+
+/**
+ * Default interval time in milleseconds between when reconnect is re-attempted
+ */
+export const RECONNECT_INTERVAL = 60 * 1000;

package/src/index.ts

@@ -1,8 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { GraphQLAPI } from './GraphQLAPI';
-export { GraphQLResult, GraphQLAuthError, GRAPHQL_AUTH_MODE } from './types';
 export { GraphQLAPI, GraphQLAPIClass, graphqlOperation } from './GraphQLAPI';
 export * from './types';
-export default GraphQLAPI;

package/src/internals/InternalGraphQLAPI.ts

@@ -9,24 +9,21 @@ import {
 	OperationTypeNode,
 } from 'graphql';
 import Observable from 'zen-observable-ts';
+import { Amplify, Cache, fetchAuthSession } from '@aws-amplify/core';
 import {
-	Amplify,
-	ConsoleLogger as Logger,
-	Credentials,
 	CustomUserAgentDetails,
+	ConsoleLogger as Logger,
 	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';
+} from '@aws-amplify/core/internals/utils';
 import {
 	GraphQLAuthError,
-	GraphQLOptions,
 	GraphQLResult,
 	GraphQLOperation,
+	GraphQLOptions,
 } from '../types';
-import { RestClient } from '@aws-amplify/api-rest';
+import { post } from '@aws-amplify/api-rest';
+import { AWSAppSyncRealTimeProvider } from '../Providers/AWSAppSyncRealTimeProvider';
+
 const USER_AGENT_HEADER = 'x-amz-user-agent';
 
 const logger = new Logger('GraphQLAPI');
@@ -49,11 +46,9 @@ export class InternalGraphQLAPIClass {
 	 * @private
 	 */
 	private _options;
-	private _api = null;
+	private appSyncRealTime: AWSAppSyncRealTimeProvider | null;
 
-	Auth = Auth;
 	Cache = Cache;
-	Credentials = Credentials;
 
 	/**
 	 * Initialize GraphQL API with AWS configuration
@@ -68,94 +63,41 @@ export class InternalGraphQLAPIClass {
 		return 'InternalGraphQLAPI';
 	}
 
-	/**
-	 * Configure API
-	 * @param {Object} config - Configuration of the API
-	 * @return {Object} - The current configuration
-	 */
-	configure(options) {
-		const { API = {}, ...otherOptions } = options || {};
-		let opt = { ...otherOptions, ...API };
-		logger.debug('configure GraphQL API', { 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
-	 */
-	createInstance() {
-		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');
-		}
-	}
-
 	private async _headerBasedAuth(
 		defaultAuthenticationType?,
-		additionalHeaders: { [key: string]: string } = {}
+		additionalHeaders: { [key: string]: string } = {},
+		customUserAgentDetails?: CustomUserAgentDetails
 	) {
-		const { aws_appsync_authenticationType, aws_appsync_apiKey: apiKey } =
-			this._options;
-		const authenticationType =
-			defaultAuthenticationType || aws_appsync_authenticationType || 'AWS_IAM';
+		const config = Amplify.getConfig();
+		const {
+			region: region,
+			endpoint: appSyncGraphqlEndpoint,
+			defaultAuthMode: authenticationType,
+		} = config.API.AppSync;
+
 		let headers = {};
 
-		switch (authenticationType) {
-			case 'API_KEY':
-				if (!apiKey) {
+		switch (authenticationType.type) {
+			case 'apiKey':
+				if (!authenticationType.apiKey) {
 					throw new Error(GraphQLAuthError.NO_API_KEY);
 				}
 				headers = {
-					Authorization: null,
-					'X-Api-Key': apiKey,
+					'X-Api-Key': authenticationType.apiKey,
 				};
 				break;
-			case 'AWS_IAM':
-				const credentialsOK = await this._ensureCredentials();
-				if (!credentialsOK) {
+			case 'iam':
+				const session = await fetchAuthSession();
+				if (session.credentials === undefined) {
 					throw new Error(GraphQLAuthError.NO_CREDENTIALS);
 				}
 				break;
-			case 'OPENID_CONNECT':
+			case 'jwt':
 				try {
 					let token;
-					// backwards compatibility
-					const federatedInfo = await Cache.getItem('federatedInfo');
-					if (federatedInfo) {
-						token = federatedInfo.token;
-					} else {
-						const currentUser = await Auth.currentAuthenticatedUser();
-						if (currentUser) {
-							token = currentUser.token;
-						}
-					}
+
+					token = (await fetchAuthSession()).tokens?.accessToken.toString();
+
 					if (!token) {
 						throw new Error(GraphQLAuthError.NO_FEDERATED_JWT);
 					}
@@ -166,17 +108,7 @@ export class InternalGraphQLAPIClass {
 					throw new Error(GraphQLAuthError.NO_CURRENT_USER);
 				}
 				break;
-			case 'AMAZON_COGNITO_USER_POOLS':
-				try {
-					const session = await this.Auth.currentSession();
-					headers = {
-						Authorization: session.getAccessToken().getJwtToken(),
-					};
-				} catch (e) {
-					throw new Error(GraphQLAuthError.NO_CURRENT_USER);
-				}
-				break;
-			case 'AWS_LAMBDA':
+			case 'custom':
 				if (!additionalHeaders.Authorization) {
 					throw new Error(GraphQLAuthError.NO_AUTH_TOKEN);
 				}
@@ -240,22 +172,11 @@ export class InternalGraphQLAPIClass {
 		switch (operationType) {
 			case 'query':
 			case 'mutation':
-				this.createInstanceIfNotCreated();
-				const cancellableToken = this._api.getCancellableToken();
-				const initParams = {
-					cancellableToken,
-					withCredentials: this._options.withCredentials,
-				};
 				const responsePromise = this._graphql<T>(
 					{ query, variables, authMode },
 					headers,
-					initParams,
 					customUserAgentDetails
 				);
-				this._api.updateRequestToBeCancellable(
-					responsePromise,
-					cancellableToken
-				);
 				return responsePromise;
 			case 'subscription':
 				return this._graphqlSubscribe(
@@ -271,26 +192,31 @@ export class InternalGraphQLAPIClass {
 	private async _graphql<T = any>(
 		{ query, variables, authMode }: GraphQLOptions,
 		additionalHeaders = {},
-		initParams = {},
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<GraphQLResult<T>> {
-		this.createInstanceIfNotCreated();
-		const {
-			aws_appsync_region: region,
-			aws_appsync_graphqlEndpoint: appSyncGraphqlEndpoint,
-			graphql_headers = () => ({}),
-			graphql_endpoint: customGraphqlEndpoint,
-			graphql_endpoint_iam_region: customEndpointRegion,
-		} = this._options;
+		const config = Amplify.getConfig();
+
+		const { region: region, endpoint: appSyncGraphqlEndpoint } =
+			config.API.AppSync;
+
+		const customGraphqlEndpoint = null;
+		const customEndpointRegion = null;
 
 		const headers = {
 			...(!customGraphqlEndpoint &&
-				(await this._headerBasedAuth(authMode, additionalHeaders))),
+				(await this._headerBasedAuth(
+					authMode,
+					additionalHeaders,
+					customUserAgentDetails
+				))),
 			...(customGraphqlEndpoint &&
 				(customEndpointRegion
-					? await this._headerBasedAuth(authMode, additionalHeaders)
+					? await this._headerBasedAuth(
+							authMode,
+							additionalHeaders,
+							customUserAgentDetails
+					  )
 					: { Authorization: null })),
-			...(await graphql_headers({ query, variables })),
 			...additionalHeaders,
 			...(!customGraphqlEndpoint && {
 				[USER_AGENT_HEADER]: getAmplifyUserAgent(customUserAgentDetails),
@@ -302,18 +228,6 @@ export class InternalGraphQLAPIClass {
 			variables,
 		};
 
-		const init = Object.assign(
-			{
-				headers,
-				body,
-				signerServiceInfo: {
-					service: !customGraphqlEndpoint ? 'appsync' : 'execute-api',
-					region: !customGraphqlEndpoint ? region : customEndpointRegion,
-				},
-			},
-			initParams
-		);
-
 		const endpoint = customGraphqlEndpoint || appSyncGraphqlEndpoint;
 
 		if (!endpoint) {
@@ -327,14 +241,13 @@ export class InternalGraphQLAPIClass {
 
 		let response;
 		try {
-			response = await this._api.post(endpoint, init);
+			response = await post(endpoint, {
+				headers,
+				body,
+				region,
+				serviceName: 'appsync',
+			});
 		} catch (err) {
-			// 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)) {
-				throw err;
-			}
 			response = {
 				data: {},
 				errors: [new GraphQLError(err.message, null, null, null, null, err)],
@@ -350,39 +263,6 @@ export class InternalGraphQLAPIClass {
 		return response;
 	}
 
-	async createInstanceIfNotCreated() {
-		if (!this._api) {
-			await this.createInstance();
-		}
-	}
-
-	/**
-	 * 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
-	 */
-	isCancel(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
-	 */
-	cancel(request: Promise<any>, message?: string) {
-		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.
-	 */
-	hasCancelToken(request: Promise<any>) {
-		return this._api.hasCancelToken(request);
-	}
-
 	private _graphqlSubscribe(
 		{
 			query,
@@ -393,57 +273,18 @@ export class InternalGraphQLAPIClass {
 		additionalHeaders = {},
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Observable<any> {
-		const {
-			aws_appsync_region: region,
-			aws_appsync_graphqlEndpoint: appSyncGraphqlEndpoint,
-			aws_appsync_authenticationType,
-			aws_appsync_apiKey: apiKey,
-			graphql_headers = () => ({}),
-		} = this._options;
-		const authenticationType =
-			defaultAuthenticationType || aws_appsync_authenticationType || 'AWS_IAM';
-
-		if (InternalPubSub && typeof InternalPubSub.subscribe === 'function') {
-			return InternalPubSub.subscribe(
-				'',
-				{
-					provider: INTERNAL_AWS_APPSYNC_REALTIME_PUBSUB_PROVIDER,
-					appSyncGraphqlEndpoint,
-					authenticationType,
-					apiKey,
-					query: print(query as DocumentNode),
-					region,
-					variables,
-					graphql_headers,
-					additionalHeaders,
-					authToken,
-				},
-				customUserAgentDetails
-			);
-		} else {
-			logger.debug('No pubsub module applied for subscription');
-			throw new Error('No pubsub module applied for subscription');
+		const { AppSync } = Amplify.getConfig().API ?? {};
+		if (!this.appSyncRealTime) {
+			this.appSyncRealTime = new AWSAppSyncRealTimeProvider();
 		}
-	}
-
-	/**
-	 * @private
-	 */
-	_ensureCredentials() {
-		return this.Credentials.get()
-			.then(credentials => {
-				if (!credentials) return false;
-				const cred = this.Credentials.shear(credentials);
-				logger.debug('set credentials for api', cred);
-
-				return true;
-			})
-			.catch(err => {
-				logger.warn('ensure credentials error', err);
-				return false;
-			});
+		return this.appSyncRealTime.subscribe({
+			query: print(query as DocumentNode),
+			variables,
+			appSyncGraphqlEndpoint: AppSync.endpoint,
+			region: AppSync.region,
+			authenticationType: AppSync.defaultAuthMode,
+		});
 	}
 }
 
 export const InternalGraphQLAPI = new InternalGraphQLAPIClass(null);
-Amplify.register(InternalGraphQLAPI);

package/src/internals/index.ts

@@ -4,3 +4,5 @@ export {
 	InternalGraphQLAPI,
 	InternalGraphQLAPIClass,
 } from './InternalGraphQLAPI';
+
+export { graphql } from './v6';

package/src/internals/v6.ts

@@ -0,0 +1,106 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { GraphQLAPI } from '../GraphQLAPI';
+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 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> {
+	/**
+	 * 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.
+	 */
+	const result = GraphQLAPI.graphql(options, additionalHeaders);
+	return result as any;
+}
+
+export { GraphQLOptionsV6, GraphQLResponseV6 };

package/src/types/PubSub.ts

@@ -0,0 +1,58 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { ZenObservable } from 'zen-observable-ts';
+
+export interface SubscriptionObserver<T> {
+	closed: boolean;
+	next(value: T): void;
+	error(errorValue: any): void;
+	complete(): void;
+}
+
+export enum CONTROL_MSG {
+	CONNECTION_CLOSED = 'Connection closed',
+	CONNECTION_FAILED = 'Connection failed',
+	REALTIME_SUBSCRIPTION_INIT_ERROR = 'AppSync Realtime subscription init error',
+	SUBSCRIPTION_ACK = 'Subscription ack',
+	TIMEOUT_DISCONNECT = 'Timeout disconnect',
+}
+
+/** @enum {string} */
+export enum ConnectionState {
+	/*
+	 * The connection is alive and healthy
+	 */
+	Connected = 'Connected',
+	/*
+	 * The connection is alive, but the connection is offline
+	 */
+	ConnectedPendingNetwork = 'ConnectedPendingNetwork',
+	/*
+	 * The connection has been disconnected while in use
+	 */
+	ConnectionDisrupted = 'ConnectionDisrupted',
+	/*
+	 * The connection has been disconnected and the network is offline
+	 */
+	ConnectionDisruptedPendingNetwork = 'ConnectionDisruptedPendingNetwork',
+	/*
+	 * The connection is in the process of connecting
+	 */
+	Connecting = 'Connecting',
+	/*
+	 * The connection is not in use and is being disconnected
+	 */
+	ConnectedPendingDisconnect = 'ConnectedPendingDisconnect',
+	/*
+	 * The connection is not in use and has been disconnected
+	 */
+	Disconnected = 'Disconnected',
+	/*
+	 * The connection is alive, but a keep alive message has been missed
+	 */
+	ConnectedPendingKeepAlive = 'ConnectedPendingKeepAlive',
+}
+
+export type PubSubContent = Record<string, unknown> | string;
+export type PubSubContentObserver =
+	ZenObservable.SubscriptionObserver<PubSubContent>;