@aws-amplify/api-graphql 4.0.1-console-preview.b5a42af.0 → 4.0.1-console-preview.9607e4a.0

package/src/internals/InternalGraphQLAPI.ts

@@ -11,6 +11,7 @@ import {
 import { Observable } from 'rxjs';
 import { Amplify, Cache, fetchAuthSession } from '@aws-amplify/core';
 import {
+	APIAuthMode,
 	CustomUserAgentDetails,
 	ConsoleLogger as Logger,
 	getAmplifyUserAgent,
@@ -21,7 +22,12 @@ import {
 	GraphQLOperation,
 	GraphQLOptions,
 } from '../types';
-import { post } from '@aws-amplify/api-rest/internals';
+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';
 
 const USER_AGENT_HEADER = 'x-amz-user-agent';
@@ -49,7 +55,7 @@ export class InternalGraphQLAPIClass {
 	private appSyncRealTime: AWSAppSyncRealTimeProvider | null;
 
 	Cache = Cache;
-	private _api = { post };
+	private _api = { post, updateRequestToBeCancellable };
 
 	/**
 	 * Initialize GraphQL API with AWS configuration
@@ -65,9 +71,8 @@ export class InternalGraphQLAPIClass {
 	}
 
 	private async _headerBasedAuth(
-		defaultAuthenticationType?,
-		additionalHeaders: { [key: string]: string } = {},
-		customUserAgentDetails?: CustomUserAgentDetails
+		authMode: APIAuthMode,
+		additionalHeaders: { [key: string]: string } = {}
 	) {
 		const config = Amplify.getConfig();
 		const {
@@ -75,11 +80,12 @@ export class InternalGraphQLAPIClass {
 			endpoint: appSyncGraphqlEndpoint,
 			apiKey,
 			defaultAuthMode,
-		} = config.API.GraphQL;
+		} = config.API?.GraphQL || {};
 
+		const authenticationType = authMode || defaultAuthMode || 'iam';
 		let headers = {};
 
-		switch (defaultAuthMode) {
+		switch (authenticationType) {
 			case 'apiKey':
 				if (!apiKey) {
 					throw new Error(GraphQLAuthError.NO_API_KEY);
@@ -177,11 +183,17 @@ export class InternalGraphQLAPIClass {
 		switch (operationType) {
 			case 'query':
 			case 'mutation':
+				const abortController = new AbortController();
 				const responsePromise = this._graphql<T>(
 					{ query, variables, authMode },
 					headers,
+					abortController,
 					customUserAgentDetails
 				);
+				this._api.updateRequestToBeCancellable(
+					responsePromise,
+					abortController
+				);
 				return responsePromise;
 			case 'subscription':
 				return this._graphqlSubscribe(
@@ -197,31 +209,26 @@ export class InternalGraphQLAPIClass {
 	private async _graphql<T = any>(
 		{ query, variables, authMode }: GraphQLOptions,
 		additionalHeaders = {},
+		abortController: AbortController,
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Promise<GraphQLResult<T>> {
 		const config = Amplify.getConfig();
 
 		const { region: region, endpoint: appSyncGraphqlEndpoint } =
-			config.API.GraphQL;
+			config.API?.GraphQL || {};
 
 		const customGraphqlEndpoint = null;
 		const customEndpointRegion = null;
 
+		// TODO: Figure what we need to do to remove `!`'s.
 		const headers = {
 			...(!customGraphqlEndpoint &&
-				(await this._headerBasedAuth(
-					authMode,
-					additionalHeaders,
-					customUserAgentDetails
-				))),
-			...(customGraphqlEndpoint &&
+				(await this._headerBasedAuth(authMode!, additionalHeaders))),
+			...((customGraphqlEndpoint &&
 				(customEndpointRegion
-					? await this._headerBasedAuth(
-							authMode,
-							additionalHeaders,
-							customUserAgentDetails
-					  )
-					: { Authorization: null })),
+					? await this._headerBasedAuth(authMode!, additionalHeaders)
+					: { Authorization: null })) ||
+				{}),
 			...additionalHeaders,
 			...(!customGraphqlEndpoint && {
 				[USER_AGENT_HEADER]: getAmplifyUserAgent(customUserAgentDetails),
@@ -230,7 +237,7 @@ export class InternalGraphQLAPIClass {
 
 		const body = {
 			query: print(query as DocumentNode),
-			variables,
+			variables: variables || null,
 		};
 
 		const endpoint = customGraphqlEndpoint || appSyncGraphqlEndpoint;
@@ -246,7 +253,7 @@ export class InternalGraphQLAPIClass {
 
 		let response;
 		try {
-			const { body: responsePayload } = await this._api.post({
+			const { body: responseBody } = await this._api.post({
 				url: new URL(endpoint),
 				options: {
 					headers,
@@ -256,9 +263,20 @@ export class InternalGraphQLAPIClass {
 						region,
 					},
 				},
+				abortController,
 			});
-			response = await responsePayload.json();
+
+			const result = await responseBody.json();
+
+			response = result;
 		} 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 (isCancelErrorREST(err)) {
+				throw err;
+			}
+
 			response = {
 				data: {},
 				errors: [new GraphQLError(err.message, null, null, null, null, err)],
@@ -274,13 +292,26 @@ export class InternalGraphQLAPIClass {
 		return response;
 	}
 
+	/**
+	 * 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 {
+		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
+	 */
+	cancel(request: Promise<any>, message?: string): boolean {
+		return cancelREST(request, message);
+	}
+
 	private _graphqlSubscribe(
-		{
-			query,
-			variables,
-			authMode: defaultAuthenticationType,
-			authToken,
-		}: GraphQLOptions,
+		{ query, variables, authMode }: GraphQLOptions,
 		additionalHeaders = {},
 		customUserAgentDetails?: CustomUserAgentDetails
 	): Observable<any> {
@@ -288,14 +319,18 @@ export class InternalGraphQLAPIClass {
 		if (!this.appSyncRealTime) {
 			this.appSyncRealTime = new AWSAppSyncRealTimeProvider();
 		}
-		return this.appSyncRealTime.subscribe({
-			query: print(query as DocumentNode),
-			variables,
-			appSyncGraphqlEndpoint: GraphQL?.endpoint,
-			region: GraphQL?.region,
-			authenticationType: GraphQL?.defaultAuthMode,
-			apiKey: GraphQL?.apiKey,
-		});
+		return this.appSyncRealTime.subscribe(
+			{
+				query: print(query as DocumentNode),
+				variables,
+				appSyncGraphqlEndpoint: GraphQL?.endpoint,
+				region: GraphQL?.region,
+				authenticationType: authMode ?? GraphQL?.defaultAuthMode,
+				apiKey: GraphQL?.apiKey,
+				additionalHeaders,
+			},
+			customUserAgentDetails
+		);
 	}
 }
 

package/src/internals/index.ts

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

package/src/internals/v6.ts

@@ -103,4 +103,22 @@ export function graphql<
 	return result as any;
 }
 
+/**
+ * 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: Promise<any>, message?: string): boolean {
+	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: any): boolean {
+	return GraphQLAPI.isCancelError(error);
+}
+
 export { GraphQLOptionsV6, GraphQLResponseV6 };

package/src/types/PubSub.ts

@@ -52,5 +52,5 @@ export enum ConnectionState {
 	ConnectedPendingKeepAlive = 'ConnectedPendingKeepAlive',
 }
 
-export type PubSubContent = Record<string, unknown> | string;
+export type PubSubContent = Record<string, unknown>;
 export type PubSubContentObserver = Observer<PubSubContent>;

package/src/types/index.ts

@@ -12,7 +12,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
@@ -21,7 +21,7 @@ export interface GraphQLOptions {
 }
 
 export interface GraphQLResult<T = object> {
-	data?: T;
+	data: T;
 	errors?: GraphQLError[];
 	extensions?: {
 		[key: string]: any;
@@ -36,6 +36,82 @@ export type GraphQLSubscription<T> = T & {
 	readonly [queryType]: 'subscription';
 };
 
+/**
+ * Accepts a code generated model type and returns a supertype that
+ * can accept return values from the relevant graphql operations.
+ *
+ * For example:
+ *
+ * ```typescript
+ * import { GraphQLReturnType } from 'aws-amplify/api';
+ * import { MyModel } from './API';
+ * import { getMyModel } from './graphql/queries';
+ *
+ * const [item, setItem] = useState<GraphQLReturnType<MyModel>>();
+ * setItem(await client.graphql({ query: getMyModel }).data.getMyModel!)
+ * ```
+ *
+ * Trying to assign the result of a `getMyModel` operation directly to a
+ * `MyModel` variables won't necessarily work, because normally-required related
+ * models might not be part of the selection set.
+ *
+ * This util simply makes related model properties optional recursively.
+ */
+export type GraphQLReturnType<T> = T extends {}
+	? {
+			[K in keyof T]?: GraphQLReturnType<T[K]>;
+	  }
+	: T;
+
+/**
+ * Describes a paged list result from AppSync, which can either
+ * live at the top query or property (e.g., related model) level.
+ */
+type PagedList<T, TYPENAME> = {
+	__typename: TYPENAME;
+	nextToken?: string | null | undefined;
+	items: Array<T>;
+};
+
+/**
+ * Recursively looks through a result type and removes nulls and
+ * and undefined from `PagedList` types.
+ *
+ * Although a graphql response might contain empty values in an
+ * array, this will only be the case when we also have errors,
+ * which will then be *thrown*.
+ */
+type WithListsFixed<T> = T extends PagedList<infer IT, infer NAME>
+	? PagedList<Exclude<IT, null | undefined>, NAME>
+	: T extends {}
+	? {
+			[K in keyof T]: WithListsFixed<T[K]>;
+	  }
+	: T;
+
+/**
+ * Returns an updated response type to always return a value.
+ */
+type NeverEmpty<T> = {
+	[K in keyof T]-?: Exclude<WithListsFixed<T[K]>, undefined | null>;
+};
+
+/**
+ * Replaces all list result types in a query result with types to exclude
+ * nulls and undefined from list member unions.
+ *
+ * If empty members are present, there will also be errors present,
+ * and the response will instead be *thrown*.
+ */
+type FixedQueryResult<T> = Exclude<
+	T[keyof T],
+	null | undefined
+> extends PagedList<any, any>
+	? {
+			[K in keyof T]-?: WithListsFixed<Exclude<T[K], null | undefined>>;
+	  }
+	: T;
+
 /**
  * The return value from a `graphql({query})` call when `query` is a subscription.
  *
@@ -77,7 +153,7 @@ export type GraphqlSubscriptionResult<T> = Observable<
  * ```
  */
 export type GraphqlSubscriptionMessage<T> = {
-	data?: T;
+	data: T;
 };
 
 export interface AWSAppSyncRealTimeProviderOptions {
@@ -165,11 +241,11 @@ export type GraphQLResponseV6<
 	FALLBACK_TYPE = unknown,
 	TYPED_GQL_STRING extends string = string
 > = TYPED_GQL_STRING extends GeneratedQuery<infer IN, infer QUERY_OUT>
-	? Promise<GraphQLResult<QUERY_OUT>>
+	? Promise<GraphQLResult<FixedQueryResult<QUERY_OUT>>>
 	: TYPED_GQL_STRING extends GeneratedMutation<infer IN, infer MUTATION_OUT>
-	? Promise<GraphQLResult<MUTATION_OUT>>
+	? Promise<GraphQLResult<NeverEmpty<MUTATION_OUT>>>
 	: TYPED_GQL_STRING extends GeneratedSubscription<infer IN, infer SUB_OUT>
-	? GraphqlSubscriptionResult<SUB_OUT>
+	? GraphqlSubscriptionResult<NeverEmpty<SUB_OUT>>
 	: FALLBACK_TYPE extends GraphQLQuery<infer T>
 	? Promise<GraphQLResult<FALLBACK_TYPE>>
 	: FALLBACK_TYPE extends GraphQLSubscription<infer T>