@aws-amplify/api-graphql 4.0.1-api-v6-models.c1977f8.0 → 4.0.1-api-v6-models.891fe0d.0

package/src/Providers/AWSAppSyncRealTimeProvider/index.ts

@@ -2,11 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 import { Observable, SubscriptionLike } from 'rxjs';
 import { GraphQLError } from 'graphql';
-import * as url from 'url';
-import { Buffer } from 'buffer';
 import { Hub, fetchAuthSession, ConsoleLogger } from '@aws-amplify/core';
 import { signRequest } from '@aws-amplify/core/internals/aws-client-utils';
 import {
+	base64Encoder,
 	GraphQLAuthMode,
 	CustomUserAgentDetails,
 	NonRetryableError,
@@ -700,9 +699,9 @@ export class AWSAppSyncRealTimeProvider {
 					});
 
 					const headerString = authHeader ? JSON.stringify(authHeader) : '';
-					const headerQs = Buffer.from(headerString).toString('base64');
+					const headerQs = base64Encoder.convert(headerString);
 
-					const payloadQs = Buffer.from(payloadString).toString('base64');
+					const payloadQs = base64Encoder.convert(payloadString);
 
 					let discoverableEndpoint = appSyncGraphqlEndpoint ?? '';
 
@@ -900,7 +899,9 @@ export class AWSAppSyncRealTimeProvider {
 		} else {
 			const handler = headerHandler[authenticationType];
 
-			const { host } = url.parse(appSyncGraphqlEndpoint ?? '');
+			const host = appSyncGraphqlEndpoint
+				? new AmplifyUrl(appSyncGraphqlEndpoint).host
+				: undefined;
 
 			logger.debug(`Authenticating with ${JSON.stringify(authenticationType)}`);
 			let resolvedApiKey;

package/src/internals/APIClient.ts

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 import { resolveOwnerFields } from '../utils/resolveOwnerFields';
 import { GraphQLAuthMode } from '@aws-amplify/core/internals/utils';
+import { V6Client, __authMode, __authToken } from '../types';
+import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
 
 type ListArgs = { selectionSet?: string[]; filter?: {} };
 
@@ -48,8 +50,9 @@ export function initializeModel(
 	modelName: string,
 	result: any[],
 	modelIntrospection: any,
-	authMode: GraphQLAuthMode,
-	authToken: string | undefined
+	authMode: GraphQLAuthMode | undefined,
+	authToken: string | undefined,
+	context = false
 ): any[] {
 	const introModel = modelIntrospection.models[modelName];
 	const introModelFields = introModel.fields;
@@ -91,21 +94,45 @@ export function initializeModel(
 						{}
 					);
 
-					initializedRelationalFields[field] = (options?: LazyLoadOptions) => {
-						if (record[targetNames[0]]) {
-							return client.models[relatedModelName].get(
-								{
-									[relatedModelPKFieldName]: record[targetNames[0]],
-									...sortKeyValues,
-								},
-								{
-									authMode: options?.authMode || authMode,
-									authToken: options?.authToken || authToken,
-								}
-							);
-						}
-						return undefined;
-					};
+					if (context) {
+						initializedRelationalFields[field] = (
+							contextSpec: AmplifyServer.ContextSpec,
+							options?: LazyLoadOptions
+						) => {
+							if (record[targetNames[0]]) {
+								return client.models[relatedModelName].get(
+									contextSpec,
+									{
+										[relatedModelPKFieldName]: record[targetNames[0]],
+										...sortKeyValues,
+									},
+									{
+										authMode: options?.authMode || authMode,
+										authToken: options?.authToken || authToken,
+									}
+								);
+							}
+							return undefined;
+						};
+					} else {
+						initializedRelationalFields[field] = (
+							options?: LazyLoadOptions
+						) => {
+							if (record[targetNames[0]]) {
+								return client.models[relatedModelName].get(
+									{
+										[relatedModelPKFieldName]: record[targetNames[0]],
+										...sortKeyValues,
+									},
+									{
+										authMode: options?.authMode || authMode,
+										authToken: options?.authToken || authToken,
+									}
+								);
+							}
+							return undefined;
+						};
+					}
 
 					break;
 				case connectionType.HAS_MANY:
@@ -125,6 +152,61 @@ export function initializeModel(
 							return { [field]: { eq: record[parentSK[idx - 1]] } };
 						});
 
+						if (context) {
+							initializedRelationalFields[field] = (
+								contextSpec: AmplifyServer.ContextSpec,
+								options?: LazyLoadOptions
+							) => {
+								if (record[parentPk]) {
+									return client.models[relatedModelName].list(contextSpec, {
+										filter: { and: hasManyFilter },
+										authMode: options?.authMode || authMode,
+										authToken: options?.authToken || authToken,
+									});
+								}
+								return [];
+							};
+						} else {
+							initializedRelationalFields[field] = (
+								options?: LazyLoadOptions
+							) => {
+								if (record[parentPk]) {
+									return client.models[relatedModelName].list({
+										filter: { and: hasManyFilter },
+										authMode: options?.authMode || authMode,
+										authToken: options?.authToken || authToken,
+									});
+								}
+								return [];
+							};
+						}
+
+						break;
+					}
+
+					const hasManyFilter = connectionFields.map((field, idx) => {
+						if (idx === 0) {
+							return { [field]: { eq: record[parentPk] } };
+						}
+
+						return { [field]: { eq: record[parentSK[idx - 1]] } };
+					});
+
+					if (context) {
+						initializedRelationalFields[field] = (
+							contextSpec: AmplifyServer.ContextSpec,
+							options?: LazyLoadOptions
+						) => {
+							if (record[parentPk]) {
+								return client.models[relatedModelName].list(contextSpec, {
+									filter: { and: hasManyFilter },
+									authMode: options?.authMode || authMode,
+									authToken: options?.authToken || authToken,
+								});
+							}
+							return [];
+						};
+					} else {
 						initializedRelationalFields[field] = (
 							options?: LazyLoadOptions
 						) => {
@@ -137,27 +219,8 @@ export function initializeModel(
 							}
 							return [];
 						};
-						break;
 					}
 
-					const hasManyFilter = connectionFields.map((field, idx) => {
-						if (idx === 0) {
-							return { [field]: { eq: record[parentPk] } };
-						}
-
-						return { [field]: { eq: record[parentSK[idx - 1]] } };
-					});
-
-					initializedRelationalFields[field] = (options?: LazyLoadOptions) => {
-						if (record[parentPk]) {
-							return client.models[relatedModelName].list({
-								filter: { and: hasManyFilter },
-								authMode: options?.authMode || authMode,
-								authToken: options?.authToken || authToken,
-							});
-						}
-						return [];
-					};
 					break;
 				default:
 					break;
@@ -622,3 +685,27 @@ export function normalizeMutationInput(
 
 	return normalized;
 }
+
+type AuthModeParams = {
+	authMode?: GraphQLAuthMode;
+	authToken?: string;
+};
+
+/**
+ * Produces a parameter object that can contains auth mode/token overrides
+ * only if present in either `options` (first) or configured on the `client`
+ * as a fallback.
+ *
+ * @param client Configured client from `generateClient`
+ * @param options Args/Options obect from call site.
+ * @returns
+ */
+export function authModeParams(
+	client: V6Client,
+	options: AuthModeParams = {}
+): AuthModeParams {
+	return {
+		authMode: options.authMode || client[__authMode],
+		authToken: options.authToken || client[__authToken],
+	};
+}

package/src/internals/InternalGraphQLAPI.ts

@@ -45,6 +45,10 @@ export const graphqlOperation = (
 	authToken,
 });
 
+const isAmplifyInstance = (amplify): amplify is AmplifyClassV6 => {
+	return typeof amplify !== 'function';
+};
+
 /**
  * Export Cloud Logic APIs
  */
@@ -163,7 +167,9 @@ export class InternalGraphQLAPIClass {
 	 * @returns An Observable if the query is a subscription query, else a promise of the graphql result.
 	 */
 	graphql<T = any>(
-		amplify: AmplifyClassV6,
+		amplify:
+			| AmplifyClassV6
+			| ((fn: (amplify: any) => Promise<any>) => Promise<AmplifyClassV6>),
 		{ query: paramQuery, variables = {}, authMode, authToken }: GraphQLOptions,
 		additionalHeaders?: { [key: string]: string },
 		customUserAgentDetails?: CustomUserAgentDetails
@@ -190,13 +196,32 @@ export class InternalGraphQLAPIClass {
 			case 'query':
 			case 'mutation':
 				const abortController = new AbortController();
-				const responsePromise = this._graphql<T>(
-					amplify,
-					{ query, variables, authMode },
-					headers,
-					abortController,
-					customUserAgentDetails
-				);
+
+				let responsePromise: Promise<GraphQLResult<T>>;
+
+				if (isAmplifyInstance(amplify)) {
+					responsePromise = this._graphql<T>(
+						amplify,
+						{ query, variables, authMode },
+						headers,
+						abortController,
+						customUserAgentDetails
+					);
+				} else {
+					const wrapper = amplifyInstance =>
+						this._graphql<T>(
+							amplifyInstance,
+							{ query, variables, authMode },
+							headers,
+							abortController,
+							customUserAgentDetails
+						);
+
+					responsePromise = amplify(wrapper) as unknown as Promise<
+						GraphQLResult<T>
+					>;
+				}
+
 				this._api.updateRequestToBeCancellable(
 					responsePromise,
 					abortController
@@ -204,7 +229,7 @@ export class InternalGraphQLAPIClass {
 				return responsePromise;
 			case 'subscription':
 				return this._graphqlSubscribe(
-					amplify,
+					amplify as AmplifyClassV6,
 					{ query, variables, authMode },
 					headers,
 					customUserAgentDetails
@@ -321,7 +346,7 @@ export class InternalGraphQLAPIClass {
 			// 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.isCancelErrorREST(err)) {
+			if (this.isCancelError(err)) {
 				throw err;
 			}
 

package/src/internals/generateClient.ts

@@ -1,9 +1,8 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { AmplifyClassV6 } from '@aws-amplify/core';
 import { graphql, cancel, isCancelError } from './v6';
 import { generateModelsProperty } from './generateModelsProperty';
-import { V6Client, __amplify } from '../types';
+import { V6Client, __amplify, __authMode, __authToken } from '../types';
 import { ClientGenerationParams } from './types';
 
 /**
@@ -20,6 +19,8 @@ export function generateClient<T extends Record<any, any> = never>(
 ): V6Client<T> {
 	const client = {
 		[__amplify]: params.amplify,
+		[__authMode]: params.authMode,
+		[__authToken]: params.authToken,
 		graphql,
 		cancel,
 		isCancelError,

package/src/internals/generateModelsProperty.ts

@@ -1,18 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { ModelTypes } from '@aws-amplify/amplify-api-next-types-alpha';
-import {
-	initializeModel,
-	generateGraphQLDocument,
-	buildGraphQLVariables,
-	graphQLOperationsInfo,
-	ModelOperation,
-	flattenItems,
-} from './APIClient';
+import { graphQLOperationsInfo, ModelOperation } from './APIClient';
 import { ClientGenerationParams } from './types';
-import { V6Client, GraphqlSubscriptionResult } from '../types';
-import { findIndexByFields, resolvePKFields } from '../utils';
-import { Observable, map } from 'rxjs';
+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';
 
 export function generateModelsProperty<T extends Record<any, any> = never>(
 	client: V6Client,
@@ -26,8 +22,8 @@ export function generateModelsProperty<T extends Record<any, any> = never>(
 		return {} as any;
 	}
 
-	// TODO: refactor this to use separate methods for each CRUDL.
-	// Doesn't make sense to gen the methods dynamically given the different args and return values
+	const SUBSCRIPTION_OPS = ['ONCREATE', 'ONUPDATE', 'ONDELETE'];
+
 	for (const model of Object.values(modelIntrospection.models)) {
 		const { name } = model as any;
 
@@ -38,309 +34,27 @@ export function generateModelsProperty<T extends Record<any, any> = never>(
 				const operation = key as ModelOperation;
 
 				if (operation === 'LIST') {
-					models[name][operationPrefix] = async (args?: any) => {
-						const query = generateGraphQLDocument(
-							modelIntrospection.models,
-							name,
-							'LIST',
-							args
-						);
-						const variables = buildGraphQLVariables(
-							model,
-							'LIST',
-							args,
-							modelIntrospection
-						);
-
-						try {
-							const options: Record<string, any> = {};
-							if (args?.authMode) options.authMode = args?.authMode;
-							if (args?.authToken) options.authToken = args?.authToken;
-
-							const { data, extensions } = (await client.graphql({
-								...options,
-								query,
-								variables,
-							})) as 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,
-											options.authMode,
-											options.authToken
-										);
-
-										return {
-											data: initialized,
-											nextToken: data[key].nextToken,
-											extensions,
-										};
-									}
-								}
-
-								return {
-									data: data[key],
-									nextToken: data[key].nextToken,
-									extensions,
-								};
-							}
-						} catch (error) {
-							if (error.errors) {
-								// graphql errors pass through
-								return error as any;
-							} else {
-								// non-graphql errors re re-thrown
-								throw error;
-							}
-						}
-					};
-				} else if (['ONCREATE', 'ONUPDATE', 'ONDELETE'].includes(operation)) {
-					models[name][operationPrefix] = (args?: any) => {
-						const query = generateGraphQLDocument(
-							modelIntrospection.models,
-							name,
-							operation
-						);
-						const variables = buildGraphQLVariables(
-							model,
-							operation,
-							args,
-							modelIntrospection
-						);
-
-						const options: Record<string, any> = {};
-						if (args?.authMode) options.authMode = args?.authMode;
-						if (args?.authToken) options.authToken = args?.authToken;
-
-						const observable = client.graphql({
-							...options,
-							query,
-							variables,
-						}) as GraphqlSubscriptionResult<object>;
-
-						return observable.pipe(
-							map(value => {
-								const [key] = Object.keys(value.data);
-								const [initialized] = initializeModel(
-									client,
-									name,
-									[value.data[key]],
-									modelIntrospection,
-									options?.authMode,
-									options?.authToken
-								);
-								return initialized;
-							})
-						);
-					};
+					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] = (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) {
-									receiveMessages({ item, type: 'create' });
-								},
-								error(error) {
-									subscriber.error({ type: 'onCreate', error });
-								},
-							});
-							const onUpdateSub = models[name].onUpdate(arg).subscribe({
-								next(item) {
-									receiveMessages({ item, type: 'update' });
-								},
-								error(error) {
-									subscriber.error({ type: 'onUpdate', error });
-								},
-							});
-							const onDeleteSub = models[name].onDelete(arg).subscribe({
-								next(item) {
-									receiveMessages({ item, type: 'delete' });
-								},
-								error(error) {
-									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,
-									} = 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.
-							};
-						});
+					models[name][operationPrefix] = observeQueryFactory(models, model);
 				} else {
-					models[name][operationPrefix] = async (arg?: any, options?: any) => {
-						const query = generateGraphQLDocument(
-							modelIntrospection.models,
-							name,
-							operation,
-							options
-						);
-						const variables = buildGraphQLVariables(
-							model,
-							operation,
-							arg,
-							modelIntrospection
-						);
-
-						try {
-							const { data, extensions } = (await client.graphql({
-								...options,
-								query,
-								variables,
-							})) as any;
-
-							// flatten response
-							if (data !== undefined) {
-								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,
-										options?.authMode,
-										options?.authToken
-									);
-
-									return { data: initialized, extensions };
-								}
-							} else {
-								return { data: null, extensions };
-							}
-						} catch (error) {
-							if (error.errors) {
-								// graphql errors pass through
-								return error as any;
-							} else {
-								// non-graphql errors re re-thrown
-								throw error;
-							}
-						}
-					};
+					models[name][operationPrefix] = getFactory(
+						client,
+						modelIntrospection,
+						model,
+						operation
+					);
 				}
 			}
 		);