@aws-amplify/api-graphql 4.0.17 → 4.0.18-experimental-lerna-test.d2b0b08.55

package/src/internals/InternalGraphQLAPI.ts

@@ -3,39 +3,43 @@
 import {
 	DocumentNode,
 	OperationDefinitionNode,
-	print,
-	parse,
-	GraphQLError,
 	OperationTypeNode,
+	parse,
+	print,
 } from 'graphql';
 import { Observable, catchError } from 'rxjs';
-import { AmplifyClassV6, ConsoleLogger } from '@aws-amplify/core';
+import { AmplifyClassV6 } from '@aws-amplify/core';
 import {
-	GraphQLAuthMode,
+	AmplifyUrl,
 	CustomUserAgentDetails,
+	GraphQLAuthMode,
 	getAmplifyUserAgent,
-	AmplifyUrl,
 } from '@aws-amplify/core/internals/utils';
-import {
-	GraphQLAuthError,
-	GraphQLResult,
-	GraphQLOperation,
-	GraphQLOptions,
-} from '../types';
 import { isCancelError as isCancelErrorREST } from '@aws-amplify/api-rest';
 import {
-	post,
 	cancel as cancelREST,
+	post,
 	updateRequestToBeCancellable,
 } from '@aws-amplify/api-rest/internals';
-import { AWSAppSyncRealTimeProvider } from '../Providers/AWSAppSyncRealTimeProvider';
 import { CustomHeaders, RequestOptions } from '@aws-amplify/data-schema-types';
+
+import { AWSAppSyncRealTimeProvider } from '../Providers/AWSAppSyncRealTimeProvider';
+import { GraphQLOperation, GraphQLOptions, GraphQLResult } from '../types';
 import { resolveConfig, resolveLibraryOptions } from '../utils';
-import { repackageUnauthError } from '../utils/errors/repackageAuthError';
+import { repackageUnauthorizedError } from '../utils/errors/repackageAuthError';
+import {
+	NO_API_KEY,
+	NO_AUTH_TOKEN_HEADER,
+	NO_ENDPOINT,
+	NO_SIGNED_IN_USER,
+	NO_VALID_AUTH_TOKEN,
+	NO_VALID_CREDENTIALS,
+} from '../utils/errors/constants';
+import { GraphQLApiError, createGraphQLResultWithError } from '../utils/errors';
 
-const USER_AGENT_HEADER = 'x-amz-user-agent';
+import { isGraphQLResponseWithErrors } from './utils/runtimeTypeGuards/isGraphQLResponseWithErrors';
 
-const logger = new ConsoleLogger('GraphQLAPI');
+const USER_AGENT_HEADER = 'x-amz-user-agent';
 
 const isAmplifyInstance = (
 	amplify:
@@ -70,54 +74,60 @@ export class InternalGraphQLAPIClass {
 		authMode: GraphQLAuthMode,
 		additionalHeaders: Record<string, string> = {},
 	) {
-		const {
-			region: region,
-			endpoint: appSyncGraphqlEndpoint,
-			apiKey,
-		} = resolveConfig(amplify);
+		const { apiKey } = resolveConfig(amplify);
 
 		let headers = {};
 
 		switch (authMode) {
 			case 'apiKey':
 				if (!apiKey) {
-					throw new Error(GraphQLAuthError.NO_API_KEY);
+					throw new GraphQLApiError(NO_API_KEY);
 				}
 				headers = {
 					'X-Api-Key': apiKey,
 				};
 				break;
-			case 'iam':
+			case 'iam': {
 				const session = await amplify.Auth.fetchAuthSession();
 				if (session.credentials === undefined) {
-					throw new Error(GraphQLAuthError.NO_CREDENTIALS);
+					throw new GraphQLApiError(NO_VALID_CREDENTIALS);
 				}
 				break;
+			}
 			case 'oidc':
-			case 'userPool':
-				try {
-					let token;
+			case 'userPool': {
+				let token: string | undefined;
 
+				try {
 					token = (
 						await amplify.Auth.fetchAuthSession()
 					).tokens?.accessToken.toString();
-
-					if (!token) {
-						throw new Error(GraphQLAuthError.NO_FEDERATED_JWT);
-					}
-					headers = {
-						Authorization: token,
-					};
 				} catch (e) {
-					throw new Error(GraphQLAuthError.NO_CURRENT_USER);
+					// fetchAuthSession failed
+					throw new GraphQLApiError({
+						...NO_SIGNED_IN_USER,
+						underlyingError: e,
+					});
+				}
+
+				// `fetchAuthSession()` succeeded but didn't return `tokens`.
+				// This may happen when unauthenticated access is enabled and there is
+				// no user signed in.
+				if (!token) {
+					throw new GraphQLApiError(NO_VALID_AUTH_TOKEN);
 				}
+
+				headers = {
+					Authorization: token,
+				};
 				break;
+			}
 			case 'lambda':
 				if (
 					typeof additionalHeaders === 'object' &&
 					!additionalHeaders.Authorization
 				) {
-					throw new Error(GraphQLAuthError.NO_AUTH_TOKEN);
+					throw new GraphQLApiError(NO_AUTH_TOKEN_HEADER);
 				}
 
 				headers = {
@@ -139,8 +149,7 @@ export class InternalGraphQLAPIClass {
 	 */
 	getGraphqlOperationType(operation: GraphQLOperation): OperationTypeNode {
 		const doc = parse(operation);
-		const definitions =
-			doc.definitions as ReadonlyArray<OperationDefinitionNode>;
+		const definitions = doc.definitions as readonly OperationDefinitionNode[];
 		const [{ operation: operationType }] = definitions;
 
 		return operationType;
@@ -176,7 +185,7 @@ export class InternalGraphQLAPIClass {
 
 		switch (operationType) {
 			case 'query':
-			case 'mutation':
+			case 'mutation': {
 				const abortController = new AbortController();
 
 				let responsePromise: Promise<GraphQLResult<T>>;
@@ -215,7 +224,9 @@ export class InternalGraphQLAPIClass {
 					responsePromise,
 					abortController,
 				);
+
 				return responsePromise;
+			}
 			case 'subscription':
 				return this._graphqlSubscribe(
 					amplify as AmplifyClassV6,
@@ -238,7 +249,7 @@ export class InternalGraphQLAPIClass {
 		authToken?: string,
 	): Promise<GraphQLResult<T>> {
 		const {
-			region: region,
+			region,
 			endpoint: appSyncGraphqlEndpoint,
 			customEndpoint,
 			customEndpointRegion,
@@ -355,17 +366,15 @@ export class InternalGraphQLAPIClass {
 		const endpoint = customEndpoint || appSyncGraphqlEndpoint;
 
 		if (!endpoint) {
-			const error = new GraphQLError('No graphql endpoint provided.');
-
-			throw {
-				data: {},
-				errors: [error],
-			};
+			throw createGraphQLResultWithError<T>(new GraphQLApiError(NO_ENDPOINT));
 		}
 
 		let response: any;
 
 		try {
+			// See the inline doc of the REST `post()` API for possible errors to be thrown.
+			// As these errors are catastrophic they should be caught and handled by GraphQL
+			// API consumers.
 			const { body: responseBody } = await this._api.post(amplify, {
 				url: new AmplifyUrl(endpoint),
 				options: {
@@ -377,39 +386,20 @@ export class InternalGraphQLAPIClass {
 				abortController,
 			});
 
-			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 (this.isCancelError(err)) {
-				throw err;
+			response = await responseBody.json();
+		} catch (error) {
+			if (this.isCancelError(error)) {
+				throw error;
 			}
 
-			response = {
-				data: {},
-				errors: [
-					new GraphQLError(
-						(err as any).message,
-						null,
-						null,
-						null,
-						null,
-						err as any,
-					),
-				],
-			};
+			response = createGraphQLResultWithError<T>(error as any);
 		}
 
-		const { errors } = response;
-
-		if (errors && errors.length) {
-			throw repackageUnauthError(response);
+		if (isGraphQLResponseWithErrors(response)) {
+			throw repackageUnauthorizedError(response);
 		}
 
-		return response;
+		return response as unknown as GraphQLResult<T>;
 	}
 
 	/**
@@ -467,7 +457,7 @@ export class InternalGraphQLAPIClass {
 			.pipe(
 				catchError(e => {
 					if (e.errors) {
-						throw repackageUnauthError(e);
+						throw repackageUnauthorizedError(e);
 					}
 					throw e;
 				}),

package/src/internals/clientUtils.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type {
-	SchemaModel,
 	ModelAttribute,
+	SchemaModel,
 	SecondaryIndexAttribute,
 } from '@aws-amplify/core/internals/utils';
 

package/src/internals/generateClient.ts

@@ -1,11 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { Hub } from '@aws-amplify/core';
-import { EnumTypes, ModelTypes } from '@aws-amplify/data-schema-types';
-import { graphql, cancel, isCancelError } from './v6';
-import { generateEnumsProperty } from './utils/generateEnumsProperty';
-import { generateModelsProperty } from './utils/generateModelsProperty';
-import { isApiGraphQLConfig } from './utils/isApiGraphQLProviderConfig';
+import {
+	CustomMutations,
+	CustomQueries,
+	CustomSubscriptions,
+	EnumTypes,
+	ModelTypes,
+} from '@aws-amplify/data-schema-types';
+
 import {
 	V6Client,
 	__amplify,
@@ -13,8 +16,18 @@ import {
 	__authToken,
 	__headers,
 } from '../types';
+
+import { cancel, graphql, isCancelError } from './v6';
+import { generateEnumsProperty } from './utils/clientProperties/generateEnumsProperty';
+import { generateModelsProperty } from './utils/clientProperties/generateModelsProperty';
+import { isApiGraphQLConfig } from './utils/runtimeTypeGuards/isApiGraphQLProviderConfig';
+import {
+	generateCustomMutationsProperty,
+	generateCustomQueriesProperty,
+	generateCustomSubscriptionsProperty,
+} from './generateCustomOperationsProperty';
 import { ClientGenerationParams } from './types';
-import { isConfigureEventWithResourceConfig } from './utils/isConfigureEventWithResourceConfig';
+import { isConfigureEventWithResourceConfig } from './utils/runtimeTypeGuards/isConfigureEventWithResourceConfig';
 
 /**
  * @private
@@ -38,6 +51,9 @@ export function generateClient<T extends Record<any, any> = never>(
 		isCancelError,
 		models: emptyProperty as ModelTypes<never>,
 		enums: emptyProperty as EnumTypes<never>,
+		queries: emptyProperty as CustomQueries<never>,
+		mutations: emptyProperty as CustomMutations<never>,
+		subscriptions: emptyProperty as CustomSubscriptions<never>,
 	} as any;
 
 	const apiGraphqlConfig = params.amplify.getConfig().API?.GraphQL;
@@ -45,6 +61,15 @@ export function generateClient<T extends Record<any, any> = never>(
 	if (isApiGraphQLConfig(apiGraphqlConfig)) {
 		client.models = generateModelsProperty<T>(client, apiGraphqlConfig);
 		client.enums = generateEnumsProperty<T>(apiGraphqlConfig);
+		client.queries = generateCustomQueriesProperty<T>(client, apiGraphqlConfig);
+		client.mutations = generateCustomMutationsProperty<T>(
+			client,
+			apiGraphqlConfig,
+		);
+		client.subscriptions = generateCustomSubscriptionsProperty(
+			client,
+			apiGraphqlConfig,
+		);
 	} else {
 		// This happens when the `Amplify.configure()` call gets evaluated after the `generateClient()` call.
 		//
@@ -75,6 +100,18 @@ const generateModelsPropertyOnAmplifyConfigure = (clientRef: any) => {
 		if (isApiGraphQLConfig(apiGraphQLConfig)) {
 			clientRef.models = generateModelsProperty(clientRef, apiGraphQLConfig);
 			clientRef.enums = generateEnumsProperty(apiGraphQLConfig);
+			clientRef.queries = generateCustomQueriesProperty(
+				clientRef,
+				apiGraphQLConfig,
+			);
+			clientRef.mutations = generateCustomMutationsProperty(
+				clientRef,
+				apiGraphQLConfig,
+			);
+			clientRef.subscriptions = generateCustomSubscriptionsProperty(
+				clientRef,
+				apiGraphQLConfig,
+			);
 		}
 	});
 };

package/src/internals/generateCustomOperationsProperty.ts

@@ -0,0 +1,112 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import {
+	CustomMutations,
+	CustomQueries,
+	CustomSubscriptions,
+} from '@aws-amplify/data-schema-types';
+import {
+	GraphQLProviderConfig,
+	ModelIntrospectionSchema,
+} from '@aws-amplify/core/internals/utils';
+
+import { V6Client, __amplify } from '../types';
+
+import { customOpFactory } from './operations/custom';
+
+type OpTypes = 'queries' | 'mutations' | 'subscriptions';
+
+type CustomOpsProperty<
+	T extends Record<any, any>,
+	OpType extends OpTypes,
+> = OpType extends 'queries'
+	? CustomQueries<T>
+	: OpType extends 'mutations'
+		? CustomMutations<T>
+		: OpType extends 'subscriptions'
+			? CustomSubscriptions<T>
+			: never;
+
+const operationTypeMap = {
+	queries: 'query',
+	mutations: 'mutation',
+	subscriptions: 'subscription',
+} as const;
+
+export function generateCustomOperationsProperty<
+	T extends Record<any, any>,
+	OpType extends OpTypes,
+>(
+	client: V6Client<Record<string, any>>,
+	config: GraphQLProviderConfig['GraphQL'],
+	operationsType: OpType,
+): OpType extends 'queries' ? CustomQueries<T> : CustomMutations<T> {
+	// some bundlers end up with `Amplify.configure` being called *after* generate client.
+	// if that occurs, we need to *not error* while we wait. handling for late configuration
+	// occurs in `generateClient()`. we do not need to subscribe to Hub events here.
+	if (!config) {
+		return {} as CustomOpsProperty<T, OpType>;
+	}
+
+	const modelIntrospection: ModelIntrospectionSchema | undefined =
+		config.modelIntrospection;
+
+	// model intro schema might be absent if there's not actually a configured GraphQL API
+	if (!modelIntrospection) {
+		return {} as CustomOpsProperty<T, OpType>;
+	}
+
+	// custom operations will be absent from model intro schema if no custom ops
+	// are present on the source schema.
+	const operations = modelIntrospection[operationsType];
+	if (!operations) {
+		return {} as CustomOpsProperty<T, OpType>;
+	}
+
+	const ops = {} as CustomOpsProperty<T, OpType>;
+	const useContext = client[__amplify] === null;
+	for (const operation of Object.values(operations)) {
+		(ops as any)[operation.name] = customOpFactory(
+			client,
+			modelIntrospection,
+			operationTypeMap[operationsType],
+			operation,
+			useContext,
+		);
+	}
+
+	return ops;
+}
+
+export function generateCustomMutationsProperty<T extends Record<any, any>>(
+	client: V6Client<Record<string, any>>,
+	config: GraphQLProviderConfig['GraphQL'],
+) {
+	return generateCustomOperationsProperty<T, 'mutations'>(
+		client,
+		config,
+		'mutations',
+	);
+}
+
+export function generateCustomQueriesProperty<T extends Record<any, any>>(
+	client: V6Client<Record<string, any>>,
+	config: GraphQLProviderConfig['GraphQL'],
+) {
+	return generateCustomOperationsProperty<T, 'queries'>(
+		client,
+		config,
+		'queries',
+	);
+}
+
+export function generateCustomSubscriptionsProperty<T extends Record<any, any>>(
+	client: V6Client<Record<string, any>>,
+	config: GraphQLProviderConfig['GraphQL'],
+) {
+	return generateCustomOperationsProperty<T, 'subscriptions'>(
+		client,
+		config,
+		'subscriptions',
+	);
+}