@aws-amplify/api-graphql 4.0.2-unstable.ff85fa5.0 → 4.0.2

package/src/internals/InternalGraphQLAPI.ts

@@ -35,17 +35,11 @@ const USER_AGENT_HEADER = 'x-amz-user-agent';
 
 const logger = new ConsoleLogger('GraphQLAPI');
 
-export const graphqlOperation = (
-	query,
-	variables = {},
-	authToken?: string
-) => ({
-	query,
-	variables,
-	authToken,
-});
-
-const isAmplifyInstance = (amplify): amplify is AmplifyClassV6 => {
+const isAmplifyInstance = (
+	amplify:
+		| AmplifyClassV6
+		| ((fn: (amplify: any) => Promise<any>) => Promise<AmplifyClassV6>)
+): amplify is AmplifyClassV6 => {
 	return typeof amplify !== 'function';
 };
 
@@ -56,8 +50,7 @@ export class InternalGraphQLAPIClass {
 	/**
 	 * @private
 	 */
-	private _options;
-	private appSyncRealTime: AWSAppSyncRealTimeProvider | null;
+	private appSyncRealTime = new AWSAppSyncRealTimeProvider();
 
 	private _api = {
 		post,
@@ -66,15 +59,6 @@ export class InternalGraphQLAPIClass {
 		updateRequestToBeCancellable,
 	};
 
-	/**
-	 * Initialize GraphQL API with AWS configuration
-	 * @param {Object} options - Configuration object for API
-	 */
-	constructor(options) {
-		this._options = options;
-		logger.debug('API Options', this._options);
-	}
-
 	public getModuleName() {
 		return 'InternalGraphQLAPI';
 	}
@@ -208,7 +192,7 @@ export class InternalGraphQLAPIClass {
 						customUserAgentDetails
 					);
 				} else {
-					const wrapper = amplifyInstance =>
+					const wrapper = (amplifyInstance: AmplifyClassV6) =>
 						this._graphql<T>(
 							amplifyInstance,
 							{ query, variables, authMode },
@@ -307,7 +291,7 @@ export class InternalGraphQLAPIClass {
 				authMode !== 'iam' &&
 				authMode !== 'lambda')
 		) {
-			signingServiceInfo = null;
+			signingServiceInfo = undefined;
 		} else {
 			signingServiceInfo = {
 				service: !customEndpointRegion ? 'appsync' : 'execute-api',
@@ -326,7 +310,7 @@ export class InternalGraphQLAPIClass {
 			};
 		}
 
-		let response;
+		let response: any;
 		try {
 			const { body: responseBody } = await this._api.post({
 				url: new AmplifyUrl(endpoint),
@@ -352,7 +336,16 @@ export class InternalGraphQLAPIClass {
 
 			response = {
 				data: {},
-				errors: [new GraphQLError(err.message, null, null, null, null, err)],
+				errors: [
+					new GraphQLError(
+						(err as any).message,
+						null,
+						null,
+						null,
+						null,
+						err as any
+					),
+				],
 			};
 		}
 
@@ -391,16 +384,13 @@ export class InternalGraphQLAPIClass {
 	): Observable<any> {
 		const config = resolveConfig(amplify);
 
-		if (!this.appSyncRealTime) {
-			this.appSyncRealTime = new AWSAppSyncRealTimeProvider();
-		}
 		return this.appSyncRealTime.subscribe(
 			{
 				query: print(query as DocumentNode),
 				variables,
 				appSyncGraphqlEndpoint: config?.endpoint,
 				region: config?.region,
-				authenticationType: authMode ?? config?.defaultAuthMode,
+				authenticationType: authMode || config?.defaultAuthMode,
 				apiKey: config?.apiKey,
 				additionalHeaders,
 			},
@@ -409,4 +399,4 @@ export class InternalGraphQLAPIClass {
 	}
 }
 
-export const InternalGraphQLAPI = new InternalGraphQLAPIClass(null);
+export const InternalGraphQLAPI = new InternalGraphQLAPIClass();

package/src/internals/generateClient.ts

@@ -0,0 +1,33 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { graphql, cancel, isCancelError } from './v6';
+import { generateModelsProperty } from './generateModelsProperty';
+import { V6Client, __amplify, __authMode, __authToken } from '../types';
+import { ClientGenerationParams } from './types';
+
+/**
+ * @private
+ *
+ * Creates a client that can be used to make GraphQL requests, using a provided `AmplifyClassV6`
+ * compatible context object for config and auth fetching.
+ *
+ * @param params
+ * @returns
+ */
+export function generateClient<T extends Record<any, any> = never>(
+	params: ClientGenerationParams
+): V6Client<T> {
+	const client = {
+		[__amplify]: params.amplify,
+		[__authMode]: params.authMode,
+		[__authToken]: params.authToken,
+		graphql,
+		cancel,
+		isCancelError,
+		models: {},
+	} as any;
+
+	client.models = generateModelsProperty<T>(client, params);
+
+	return client as V6Client<T>;
+}

package/src/internals/generateModelsProperty.ts

@@ -0,0 +1,73 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { ModelTypes } from '@aws-amplify/data-schema-types';
+import { graphQLOperationsInfo, ModelOperation } from './APIClient';
+import { ClientGenerationParams } from './types';
+import { V6Client, __authMode, __authToken } from '../types';
+
+import { listFactory } from './operations/list';
+import { getFactory } from './operations/get';
+import { subscriptionFactory } from './operations/subscription';
+import { observeQueryFactory } from './operations/observeQuery';
+import { ModelIntrospectionSchema } from '@aws-amplify/core/internals/utils';
+
+export function generateModelsProperty<T extends Record<any, any> = never>(
+	client: V6Client<Record<string, any>>,
+	params: ClientGenerationParams
+): ModelTypes<T> {
+	const models = {} as any;
+	const config = params.amplify.getConfig();
+
+	if (!config.API?.GraphQL) {
+		throw new Error(
+			'The API configuration is missing. This is likely due to Amplify.configure() not being called prior to generateClient().'
+		);
+	}
+
+	const modelIntrospection: ModelIntrospectionSchema | undefined =
+		config.API.GraphQL.modelIntrospection;
+
+	if (!modelIntrospection) {
+		return {} as ModelTypes<never>;
+	}
+
+	const SUBSCRIPTION_OPS = ['ONCREATE', 'ONUPDATE', 'ONDELETE'];
+
+	for (const model of Object.values(modelIntrospection.models)) {
+		const { name } = model;
+
+		models[name] = {} as Record<string, any>;
+
+		Object.entries(graphQLOperationsInfo).forEach(
+			([key, { operationPrefix }]) => {
+				const operation = key as ModelOperation;
+
+				if (operation === 'LIST') {
+					models[name][operationPrefix] = listFactory(
+						client,
+						modelIntrospection,
+						model
+					);
+				} else if (SUBSCRIPTION_OPS.includes(operation)) {
+					models[name][operationPrefix] = subscriptionFactory(
+						client,
+						modelIntrospection,
+						model,
+						operation
+					);
+				} else if (operation === 'OBSERVE_QUERY') {
+					models[name][operationPrefix] = observeQueryFactory(models, model);
+				} else {
+					models[name][operationPrefix] = getFactory(
+						client,
+						modelIntrospection,
+						model,
+						operation
+					);
+				}
+			}
+		);
+	}
+
+	return models;
+}

package/src/internals/index.ts

@@ -6,3 +6,4 @@ export {
 } from './InternalGraphQLAPI';
 
 export { graphql, cancel, isCancelError } from './v6';
+export { generateClient } from './generateClient';

package/src/internals/operations/get.ts

@@ -0,0 +1,131 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
+import {
+	initializeModel,
+	generateGraphQLDocument,
+	buildGraphQLVariables,
+	flattenItems,
+	authModeParams,
+	ModelOperation,
+} from '../APIClient';
+import {
+	AuthModeParams,
+	ClientWithModels,
+	GraphQLOptionsV6,
+	GraphQLResult,
+	ListArgs,
+	QueryArgs,
+	V6Client,
+	V6ClientSSRRequest,
+} from '../../types';
+import {
+	ModelIntrospectionSchema,
+	SchemaModel,
+} from '@aws-amplify/core/internals/utils';
+
+export function getFactory(
+	client: ClientWithModels,
+	modelIntrospection: ModelIntrospectionSchema,
+	model: SchemaModel,
+	operation: ModelOperation,
+	useContext = false
+) {
+	const getWithContext = async (
+		contextSpec: AmplifyServer.ContextSpec & GraphQLOptionsV6<unknown, string>,
+		arg?: any,
+		options?: any
+	) => {
+		return _get(
+			client,
+			modelIntrospection,
+			model,
+			arg,
+			options,
+			operation,
+			contextSpec
+		);
+	};
+
+	const get = async (arg?: any, options?: any) => {
+		return _get(client, modelIntrospection, model, arg, options, operation);
+	};
+
+	return useContext ? getWithContext : get;
+}
+
+async function _get(
+	client: ClientWithModels,
+	modelIntrospection: ModelIntrospectionSchema,
+	model: SchemaModel,
+	arg: QueryArgs,
+	options: AuthModeParams & ListArgs,
+	operation: ModelOperation,
+	context?: AmplifyServer.ContextSpec
+) {
+	const { name } = model;
+
+	const query = generateGraphQLDocument(
+		modelIntrospection.models,
+		name,
+		operation,
+		options
+	);
+	const variables = buildGraphQLVariables(
+		model,
+		operation,
+		arg,
+		modelIntrospection
+	);
+
+	try {
+		const auth = authModeParams(client, options);
+		const { data, extensions } = context
+			? ((await (client as V6ClientSSRRequest<Record<string, any>>).graphql(
+					context,
+					{
+						...auth,
+						query,
+						variables,
+					}
+			  )) as GraphQLResult<any>)
+			: ((await (client as V6Client<Record<string, any>>).graphql({
+					...auth,
+					query,
+					variables,
+			  })) as GraphQLResult<any>);
+
+		// flatten response
+		if (data) {
+			const [key] = Object.keys(data);
+			const flattenedResult = flattenItems(data)[key];
+
+			if (options?.selectionSet) {
+				return { data: flattenedResult, extensions };
+			} else {
+				// TODO: refactor to avoid destructuring here
+				const [initialized] = initializeModel(
+					client,
+					name,
+					[flattenedResult],
+					modelIntrospection,
+					auth.authMode,
+					auth.authToken,
+					!!context
+				);
+
+				return { data: initialized, extensions };
+			}
+		} else {
+			return { data: null, extensions };
+		}
+	} catch (error: any) {
+		if (error.errors) {
+			// graphql errors pass through
+			return error as any;
+		} else {
+			// non-graphql errors re re-thrown
+			throw error;
+		}
+	}
+}

package/src/internals/operations/list.ts

@@ -0,0 +1,132 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
+import {
+	initializeModel,
+	generateGraphQLDocument,
+	buildGraphQLVariables,
+	flattenItems,
+	authModeParams,
+} from '../APIClient';
+import {
+	AuthModeParams,
+	ClientWithModels,
+	ListArgs,
+	V6Client,
+	V6ClientSSRRequest,
+	GraphQLResult,
+} from '../../types';
+import {
+	ModelIntrospectionSchema,
+	SchemaModel,
+} from '@aws-amplify/core/internals/utils';
+
+export function listFactory(
+	client: ClientWithModels,
+	modelIntrospection: ModelIntrospectionSchema,
+	model: SchemaModel,
+	context = false
+) {
+	const listWithContext = async (
+		contextSpec: AmplifyServer.ContextSpec,
+		args?: ListArgs
+	) => {
+		return _list(client, modelIntrospection, model, args, contextSpec);
+	};
+
+	const list = async (args?: any) => {
+		return _list(client, modelIntrospection, model, args);
+	};
+
+	return context ? listWithContext : list;
+}
+
+async function _list(
+	client: ClientWithModels,
+	modelIntrospection: ModelIntrospectionSchema,
+	model: SchemaModel,
+	args?: ListArgs & AuthModeParams,
+	contextSpec?: AmplifyServer.ContextSpec
+) {
+	const { name } = model;
+
+	const query = generateGraphQLDocument(
+		modelIntrospection.models,
+		name,
+		'LIST',
+		args
+	);
+	const variables = buildGraphQLVariables(
+		model,
+		'LIST',
+		args,
+		modelIntrospection
+	);
+
+	try {
+		const auth = authModeParams(client, args);
+
+		const { data, extensions } = !!contextSpec
+			? ((await (client as V6ClientSSRRequest<Record<string, any>>).graphql(
+					contextSpec,
+					{
+						...auth,
+						query,
+						variables,
+					}
+			  )) as GraphQLResult<any>)
+			: ((await (client as V6Client<Record<string, any>>).graphql({
+					...auth,
+					query,
+					variables,
+			  })) as GraphQLResult<any>);
+
+		// flatten response
+		if (data !== undefined) {
+			const [key] = Object.keys(data);
+
+			if (data[key].items) {
+				const flattenedResult = flattenItems(data)[key];
+
+				// don't init if custom selection set
+				if (args?.selectionSet) {
+					return {
+						data: flattenedResult,
+						nextToken: data[key].nextToken,
+						extensions,
+					};
+				} else {
+					const initialized = initializeModel(
+						client,
+						name,
+						flattenedResult,
+						modelIntrospection,
+						auth.authMode,
+						auth.authToken,
+						!!contextSpec
+					);
+
+					return {
+						data: initialized,
+						nextToken: data[key].nextToken,
+						extensions,
+					};
+				}
+			}
+
+			return {
+				data: data[key],
+				nextToken: data[key].nextToken,
+				extensions,
+			};
+		}
+	} catch (error: any) {
+		if (error.errors) {
+			// graphql errors pass through
+			return error as any;
+		} else {
+			// non-graphql errors re re-thrown
+			throw error;
+		}
+	}
+}

package/src/internals/operations/observeQuery.ts

@@ -0,0 +1,144 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { Observable } from 'rxjs';
+import { findIndexByFields, resolvePKFields } from '../../utils';
+import { SchemaModel } from '@aws-amplify/core/internals/utils';
+
+export function observeQueryFactory(models: any, model: SchemaModel) {
+	const { name } = model;
+
+	const observeQuery = (arg?: any) =>
+		new Observable(subscriber => {
+			// what we'll be sending to our subscribers
+			const items: object[] = [];
+
+			// To enqueue subscription messages while we collect our initial
+			// result set.
+			const messageQueue = [] as {
+				type: 'create' | 'update' | 'delete';
+				item: object;
+			}[];
+
+			// operation to take when message(s) arrive.
+			// this operation will be swapped out once initial "sync" is complete
+			// to immediately ingest messsages.
+			let receiveMessages = (...messages: typeof messageQueue) => {
+				return messageQueue.push(...messages);
+			};
+
+			// start subscriptions
+			const onCreateSub = models[name].onCreate(arg).subscribe({
+				next(item: object) {
+					receiveMessages({ item, type: 'create' });
+				},
+				error(error: any) {
+					subscriber.error({ type: 'onCreate', error });
+				},
+			});
+			const onUpdateSub = models[name].onUpdate(arg).subscribe({
+				next(item: object) {
+					receiveMessages({ item, type: 'update' });
+				},
+				error(error: any) {
+					subscriber.error({ type: 'onUpdate', error });
+				},
+			});
+			const onDeleteSub = models[name].onDelete(arg).subscribe({
+				next(item: object) {
+					receiveMessages({ item, type: 'delete' });
+				},
+				error(error: any) {
+					subscriber.error({ type: 'onDelete', error });
+				},
+			});
+
+			// consumes a list of messages and sends a snapshot
+			function ingestMessages(messages: typeof messageQueue) {
+				for (const message of messages) {
+					const idx = findIndexByFields(message.item, items, pkFields as any);
+					switch (message.type) {
+						case 'create':
+							if (idx < 0) items.push(message.item);
+							break;
+						case 'update':
+							if (idx >= 0) items[idx] = message.item;
+							break;
+						case 'delete':
+							if (idx >= 0) items.splice(idx, 1);
+							break;
+						default:
+							console.error('Unrecognized message in observeQuery.', message);
+					}
+				}
+				subscriber.next({
+					items,
+					isSynced: true,
+				});
+			}
+
+			const pkFields = resolvePKFields(model);
+
+			// initial results
+			(async () => {
+				let firstPage = true;
+				let nextToken: string | null = null;
+				while (!subscriber.closed && (firstPage || nextToken)) {
+					firstPage = false;
+
+					const {
+						data: page,
+						errors,
+						nextToken: _nextToken,
+					}: {
+						data: any;
+						errors: any;
+						nextToken: string | null;
+					} = await models[name].list({ ...arg, nextToken });
+					nextToken = _nextToken;
+
+					items.push(...page);
+
+					// if there are no more pages and no items we already know about
+					// that need to be merged in from sub, we're "synced"
+					const isSynced =
+						messageQueue.length === 0 &&
+						(nextToken === null || nextToken === undefined);
+
+					subscriber.next({
+						items,
+						isSynced,
+					});
+
+					if (Array.isArray(errors)) {
+						for (const error of errors) {
+							subscriber.error(error);
+						}
+					}
+				}
+
+				// play through the queue
+				if (messageQueue.length > 0) {
+					ingestMessages(messageQueue);
+				}
+
+				// switch the queue to write directly to the items collection
+				receiveMessages = (...messages: typeof messageQueue) => {
+					ingestMessages(messages);
+					return items.length;
+				};
+			})();
+
+			// when subscriber unsubscribes, tear down internal subs
+			return () => {
+				// 1. tear down internal subs
+				onCreateSub.unsubscribe();
+				onUpdateSub.unsubscribe();
+				onDeleteSub.unsubscribe();
+
+				// 2. there is no need to explicitly stop paging. instead, we
+				// just check `subscriber.closed` above before fetching each page.
+			};
+		});
+
+	return observeQuery;
+}

package/src/internals/operations/subscription.ts

@@ -0,0 +1,65 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { map } from 'rxjs';
+import { V6Client, GraphqlSubscriptionResult } from '../../types';
+import {
+	initializeModel,
+	generateGraphQLDocument,
+	buildGraphQLVariables,
+	authModeParams,
+	ModelOperation,
+} from '../APIClient';
+import {
+	ModelIntrospectionSchema,
+	SchemaModel,
+} from '@aws-amplify/core/internals/utils';
+
+export function subscriptionFactory(
+	client: any,
+	modelIntrospection: ModelIntrospectionSchema,
+	model: SchemaModel,
+	operation: ModelOperation
+) {
+	const { name } = model as any;
+
+	const subscription = (args?: any) => {
+		const query = generateGraphQLDocument(
+			modelIntrospection.models,
+			name,
+			operation
+		);
+		const variables = buildGraphQLVariables(
+			model,
+			operation,
+			args,
+			modelIntrospection
+		);
+
+		const auth = authModeParams(client, args);
+
+		const observable = client.graphql({
+			...auth,
+			query,
+			variables,
+		}) as GraphqlSubscriptionResult<object>;
+
+		return observable.pipe(
+			map(value => {
+				const [key] = Object.keys(value.data);
+				const data = (value.data as any)[key];
+				const [initialized] = initializeModel(
+					client as V6Client<Record<string, any>>,
+					name,
+					[data],
+					modelIntrospection,
+					auth.authMode,
+					auth.authToken
+				);
+				return initialized;
+			})
+		);
+	};
+
+	return subscription;
+}