@aws-amplify/api-graphql 4.0.1-console-preview.be08038.0 → 4.0.1-server-generate-client.1e317a1.0

package/src/internals/APIClient.ts

@@ -0,0 +1,583 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { resolveOwnerFields } from '../utils/resolveOwnerFields';
+
+type ListArgs = { selectionSet?: string[]; filter?: {} };
+
+const connectionType = {
+	HAS_ONE: 'HAS_ONE',
+	HAS_MANY: 'HAS_MANY',
+	BELONGS_TO: 'BELONGS_TO',
+};
+
+/**
+ *
+ * @param GraphQL response object
+ * @returns response object with `items` properties flattened
+ */
+export const flattenItems = (obj: Record<string, any>): Record<string, any> => {
+	const res: Record<string, any> = {};
+
+	Object.entries(obj).forEach(([prop, value]) => {
+		if (typeof value === 'object' && value !== null) {
+			if (value.items !== undefined) {
+				res[prop] = value.items.map((item: Record<string, any>) =>
+					flattenItems(item)
+				);
+				return;
+			}
+			res[prop] = flattenItems(value);
+			return;
+		}
+
+		res[prop] = value;
+	});
+
+	return res;
+};
+
+// TODO: this should accept single result to support CRUD methods; create helper for array/list
+export function initializeModel(
+	client: any,
+	modelName: string,
+	result: any[],
+	modelIntrospection: any
+): any[] {
+	const introModel = modelIntrospection.models[modelName];
+	const introModelFields = introModel.fields;
+
+	const modelFields: string[] = Object.entries(introModelFields)
+		.filter(([_, field]: [string, any]) => field?.type?.model !== undefined)
+		.map(([fieldName]) => fieldName);
+
+	return result.map(record => {
+		const initializedRelationalFields = {};
+
+		for (const field of modelFields) {
+			const relatedModelName = introModelFields[field].type.model;
+
+			const relatedModel = modelIntrospection.models[relatedModelName];
+
+			const relatedModelPKFieldName =
+				relatedModel.primaryKeyInfo.primaryKeyFieldName;
+
+			const relatedModelSKFieldNames =
+				relatedModel.primaryKeyInfo.sortKeyFieldNames;
+
+			const relationType = introModelFields[field].association.connectionType;
+			const connectionFields =
+				introModelFields[field].association.associatedWith;
+
+			const targetNames =
+				introModelFields[field].association?.targetNames || [];
+
+			switch (relationType) {
+				case connectionType.HAS_ONE:
+				case connectionType.BELONGS_TO:
+					const sortKeyValues = relatedModelSKFieldNames.reduce(
+						(acc, curVal) => {
+							if (record[curVal]) {
+								return (acc[curVal] = record[curVal]);
+							}
+						},
+						{}
+					);
+
+					initializedRelationalFields[field] = () => {
+						if (record[targetNames[0]]) {
+							return client.models[relatedModelName].get({
+								[relatedModelPKFieldName]: record[targetNames[0]],
+								...sortKeyValues,
+							});
+						}
+						return undefined;
+					};
+
+					break;
+				case connectionType.HAS_MANY:
+					const parentPk = introModel.primaryKeyInfo.primaryKeyFieldName;
+					const parentSK = introModel.primaryKeyInfo.sortKeyFieldNames;
+
+					// M:N check - TODO: refactor
+					if (relatedModel.fields[connectionFields[0]]?.type.model) {
+						const relatedTargetNames =
+							relatedModel.fields[connectionFields[0]].association.targetNames;
+
+						const hasManyFilter = relatedTargetNames.map((field, idx) => {
+							if (idx === 0) {
+								return { [field]: { eq: record[parentPk] } };
+							}
+
+							return { [field]: { eq: record[parentSK[idx - 1]] } };
+						});
+
+						initializedRelationalFields[field] = () => {
+							if (record[parentPk]) {
+								return client.models[relatedModelName].list({
+									filter: { and: hasManyFilter },
+								});
+							}
+							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] = () => {
+						if (record[parentPk]) {
+							return client.models[relatedModelName].list({
+								filter: { and: hasManyFilter },
+							});
+						}
+						return [];
+					};
+					break;
+				default:
+					break;
+			}
+		}
+
+		return { ...record, ...initializedRelationalFields };
+	});
+}
+
+export const graphQLOperationsInfo = {
+	CREATE: { operationPrefix: 'create' as const, usePlural: false },
+	READ: { operationPrefix: 'get' as const, usePlural: false },
+	UPDATE: { operationPrefix: 'update' as const, usePlural: false },
+	DELETE: { operationPrefix: 'delete' as const, usePlural: false },
+	LIST: { operationPrefix: 'list' as const, usePlural: true },
+	ONCREATE: { operationPrefix: 'onCreate' as const, usePlural: false },
+	ONUPDATE: { operationPrefix: 'onUpdate' as const, usePlural: false },
+	ONDELETE: { operationPrefix: 'onDelete' as const, usePlural: false },
+};
+export type ModelOperation = keyof typeof graphQLOperationsInfo;
+
+type OperationPrefix =
+	(typeof graphQLOperationsInfo)[ModelOperation]['operationPrefix'];
+
+const graphQLDocumentsCache = new Map<string, Map<ModelOperation, string>>();
+const SELECTION_SET_WILDCARD = '*';
+
+function defaultSelectionSetForModel(modelDefinition: any): string[] {
+	// fields that are explicitly part of the graphql schema; not
+	// inferred from owner auth rules.
+	const { fields } = modelDefinition;
+	const explicitFields = Object.values<any>(fields)
+		.map(({ type, name }) => typeof type === 'string' && name) // Default selection set omits model fields
+		.filter(Boolean);
+
+	// fields used for owner auth rules that may or may not also
+	// be explicit on the model.
+	const ownerFields = resolveOwnerFields(modelDefinition);
+
+	return Array.from(new Set(explicitFields.concat(ownerFields)));
+}
+
+const FIELD_IR = '';
+
+/**
+ * Generates nested Custom Selection Set IR from path
+ *
+ * @param modelIntrospection
+ * @param modelName
+ * @param selectionSet - array of object paths
+ * @example
+ * ### Given
+ * `selectionSet = ['id', 'comments.post.id']`
+ * ### Returns
+ * ```ts
+ * {
+ *   id: '',
+ *   comments: {
+ *     items: { post: { id: '' } }
+ *   }
+ * }
+ * ```
+ */
+export function customSelectionSetToIR(
+	modelIntrospection: any,
+	modelName: string,
+	selectionSet: string[]
+): Record<string, string | object> {
+	const modelDefinition = modelIntrospection[modelName];
+	const { fields: modelFields } = modelDefinition;
+
+	return selectionSet.reduce((resultObj, path) => {
+		const [fieldName, nested, ...rest] = path.split('.');
+
+		if (nested) {
+			const relatedModel = modelFields[fieldName]?.type?.model;
+
+			if (!relatedModel) {
+				// TODO: may need to change this to support custom types
+				throw Error(`${fieldName} is not a model field`);
+			}
+
+			const relatedModelDefinition = modelIntrospection[relatedModel];
+
+			const selectionSet =
+				nested === SELECTION_SET_WILDCARD
+					? defaultSelectionSetIR(relatedModelDefinition)
+					: // if we have a path like 'field.anotherField' recursively build up selection set IR
+					  customSelectionSetToIR(modelIntrospection, relatedModel, [
+							[nested, ...rest].join('.'),
+					  ]);
+
+			if (modelFields[fieldName]?.isArray) {
+				const existing = resultObj[fieldName] || {
+					items: {},
+				};
+				const merged = { ...existing.items, ...selectionSet };
+
+				resultObj[fieldName] = { items: merged };
+				return resultObj;
+			}
+
+			const existingItems = resultObj[fieldName] || {};
+			const merged = { ...existingItems, ...selectionSet };
+
+			resultObj[fieldName] = merged;
+			return resultObj;
+		}
+
+		const exists = Boolean(modelFields[fieldName]);
+
+		if (!exists) {
+			throw Error(`${fieldName} is not a field of model ${modelName}`);
+		}
+
+		resultObj[fieldName] = FIELD_IR;
+		return resultObj;
+	}, {});
+}
+
+const defaultSelectionSetIR = relatedModelDefinition => {
+	const defaultSelectionSet = defaultSelectionSetForModel(
+		relatedModelDefinition
+	);
+
+	const reduced = defaultSelectionSet.reduce((acc, curVal) => {
+		acc[curVal] = FIELD_IR;
+		return acc;
+	}, {});
+
+	return reduced;
+};
+
+/**
+ * Stringifies selection set IR
+ * * @example
+ * ### Given
+ * ```ts
+ * {
+ *   id: '',
+ *   comments: {
+ *     items: { post: { id: '' } }
+ *   }
+ * }
+ * ```
+ * ### Returns
+ * `'id comments { items { post { id } } }'`
+ */
+export function selectionSetIRToString(
+	obj: Record<string, string | any>
+): string {
+	const res: string[] = [];
+
+	Object.entries(obj).forEach(([fieldName, value]) => {
+		if (value === FIELD_IR) {
+			res.push(fieldName);
+		} else if (typeof value === 'object' && value !== null) {
+			if (value?.items) {
+				res.push(
+					fieldName,
+					'{',
+					'items',
+					'{',
+					selectionSetIRToString(value.items),
+					'}',
+					'}'
+				);
+			} else {
+				res.push(fieldName, '{', selectionSetIRToString(value), '}');
+			}
+		}
+	});
+
+	return res.join(' ');
+}
+
+export function generateSelectionSet(
+	modelIntrospection: any,
+	modelName: string,
+	selectionSet?: string[]
+) {
+	const modelDefinition = modelIntrospection[modelName];
+
+	if (!selectionSet) {
+		return defaultSelectionSetForModel(modelDefinition).join(' ');
+	}
+
+	const selSetIr = customSelectionSetToIR(
+		modelIntrospection,
+		modelName,
+		selectionSet
+	);
+	const selSetString = selectionSetIRToString(selSetIr);
+
+	return selSetString;
+}
+
+export function generateGraphQLDocument(
+	modelIntrospection: any,
+	modelName: string,
+	modelOperation: ModelOperation,
+	listArgs?: ListArgs
+): string {
+	const modelDefinition = modelIntrospection[modelName];
+
+	const {
+		name,
+		pluralName,
+		fields,
+		primaryKeyInfo: {
+			isCustomPrimaryKey,
+			primaryKeyFieldName,
+			sortKeyFieldNames,
+		},
+	} = modelDefinition;
+
+	const { operationPrefix, usePlural } = graphQLOperationsInfo[modelOperation];
+
+	const { selectionSet } = listArgs || {};
+
+	const fromCache = graphQLDocumentsCache.get(name)?.get(modelOperation);
+
+	if (fromCache !== undefined) {
+		return fromCache;
+	}
+
+	if (!graphQLDocumentsCache.has(name)) {
+		graphQLDocumentsCache.set(name, new Map());
+	}
+
+	const graphQLFieldName = `${operationPrefix}${usePlural ? pluralName : name}`;
+	let graphQLOperationType: 'mutation' | 'query' | 'subscription' | undefined;
+	let graphQLSelectionSet: string | undefined;
+	let graphQLArguments: Record<string, any> | undefined;
+
+	const selectionSetFields = generateSelectionSet(
+		modelIntrospection,
+		modelName,
+		selectionSet
+	);
+
+	switch (modelOperation) {
+		case 'CREATE':
+		case 'UPDATE':
+		case 'DELETE':
+			graphQLArguments ??
+				(graphQLArguments = {
+					input: `${
+						operationPrefix.charAt(0).toLocaleUpperCase() +
+						operationPrefix.slice(1)
+					}${name}Input!`,
+				});
+			graphQLOperationType ?? (graphQLOperationType = 'mutation');
+		case 'READ':
+			graphQLArguments ??
+				(graphQLArguments = isCustomPrimaryKey
+					? [primaryKeyFieldName, ...sortKeyFieldNames].reduce(
+							(acc, fieldName) => {
+								acc[fieldName] = fields[fieldName].type;
+
+								return acc;
+							},
+							{}
+					  )
+					: {
+							[primaryKeyFieldName]: `${fields[primaryKeyFieldName].type}!`,
+					  });
+			graphQLSelectionSet ?? (graphQLSelectionSet = selectionSetFields);
+		case 'LIST':
+			graphQLArguments ??
+				(graphQLArguments = {
+					filter: `Model${name}FilterInput`,
+				});
+			graphQLOperationType ?? (graphQLOperationType = 'query');
+			graphQLSelectionSet ??
+				(graphQLSelectionSet = `items { ${selectionSetFields} }`);
+		case 'ONCREATE':
+		case 'ONUPDATE':
+		case 'ONDELETE':
+			graphQLArguments ??
+				(graphQLArguments = {
+					filter: `ModelSubscription${name}FilterInput`,
+				});
+			graphQLOperationType ?? (graphQLOperationType = 'subscription');
+			graphQLSelectionSet ?? (graphQLSelectionSet = selectionSetFields);
+	}
+
+	const graphQLDocument = `${graphQLOperationType}${
+		graphQLArguments
+			? `(${Object.entries(graphQLArguments).map(
+					([fieldName, type]) => `\$${fieldName}: ${type}`
+			  )})`
+			: ''
+	} { ${graphQLFieldName}${
+		graphQLArguments
+			? `(${Object.keys(graphQLArguments).map(
+					fieldName => `${fieldName}: \$${fieldName}`
+			  )})`
+			: ''
+	} { ${graphQLSelectionSet} } }`;
+
+	graphQLDocumentsCache.get(name)?.set(modelOperation, graphQLDocument);
+
+	return graphQLDocument;
+}
+
+export function buildGraphQLVariables(
+	modelDefinition: any,
+	operation: ModelOperation,
+	arg: any,
+	modelIntrospection
+): object {
+	const {
+		fields,
+		primaryKeyInfo: {
+			isCustomPrimaryKey,
+			primaryKeyFieldName,
+			sortKeyFieldNames,
+		},
+	} = modelDefinition;
+
+	let variables = {};
+
+	// TODO: process input
+	switch (operation) {
+		case 'CREATE':
+			variables = {
+				input: normalizeMutationInput(arg, modelDefinition, modelIntrospection),
+			};
+			break;
+		case 'UPDATE':
+			// readonly fields are not  updated
+			variables = {
+				input: Object.fromEntries(
+					Object.entries(
+						normalizeMutationInput(arg, modelDefinition, modelIntrospection)
+					).filter(([fieldName]) => {
+						const { isReadOnly } = fields[fieldName];
+
+						return !isReadOnly;
+					})
+				),
+			};
+			break;
+		case 'READ':
+		case 'DELETE':
+			// only identifiers are sent
+			variables = isCustomPrimaryKey
+				? [primaryKeyFieldName, ...sortKeyFieldNames].reduce(
+						(acc, fieldName) => {
+							acc[fieldName] = arg[fieldName];
+
+							return acc;
+						},
+						{}
+				  )
+				: { [primaryKeyFieldName]: arg[primaryKeyFieldName] };
+
+			if (operation === 'DELETE') {
+				variables = { input: variables };
+			}
+			break;
+		case 'LIST':
+		case 'ONCREATE':
+		case 'ONUPDATE':
+		case 'ONDELETE':
+			if (arg?.filter) {
+				variables = { filter: arg.filter };
+			}
+			break;
+		default:
+			const exhaustiveCheck: never = operation;
+			throw new Error(`Unhandled operation case: ${exhaustiveCheck}`);
+	}
+
+	return variables;
+}
+
+/**
+ * Iterates over mutation input values and resolves any model inputs to their corresponding join fields/values
+ *
+ * @example
+ * ### Usage
+ * ```ts
+ * const result = normalizeMutationInput({ post: post }, model, modelDefinition);
+ * ```
+ * ### Result
+ * ```ts
+ * { postId: "abc123" }
+ * ```
+ *
+ */
+export function normalizeMutationInput(
+	mutationInput: any,
+	model: any,
+	modelDefinition: any
+): Record<string, unknown> {
+	const { fields } = model;
+
+	const normalized = {};
+
+	Object.entries(mutationInput).forEach(([inputFieldName, inputValue]) => {
+		const relatedModelName: string | undefined =
+			fields[inputFieldName]?.type?.model;
+
+		if (relatedModelName) {
+			const association = fields[inputFieldName]?.association;
+			const relatedModelDef = modelDefinition.models[relatedModelName];
+			const relatedModelPkInfo = relatedModelDef.primaryKeyInfo;
+
+			if (association.connectionType === connectionType.HAS_ONE) {
+				association.targetNames.forEach((targetName, idx) => {
+					const associatedFieldName = association.associatedWith[idx];
+					normalized[targetName] = (inputValue as Record<string, unknown>)[
+						associatedFieldName
+					];
+				});
+			}
+
+			if (association.connectionType === connectionType.BELONGS_TO) {
+				association.targetNames.forEach((targetName, idx) => {
+					if (idx === 0) {
+						const associatedFieldName = relatedModelPkInfo.primaryKeyFieldName;
+						normalized[targetName] = (inputValue as Record<string, unknown>)[
+							associatedFieldName
+						];
+					} else {
+						const associatedFieldName =
+							relatedModelPkInfo.sortKeyFieldNames[idx - 1];
+						normalized[targetName] = (inputValue as Record<string, unknown>)[
+							associatedFieldName
+						];
+					}
+				});
+			}
+		} else {
+			normalized[inputFieldName] = inputValue;
+		}
+	});
+
+	return normalized;
+}

package/src/internals/InternalGraphQLAPI.ts

@@ -45,6 +45,13 @@ export const graphqlOperation = (
 	authToken,
 });
 
+const isAmplifyInstance = (amplify): amplify is AmplifyClassV6 => {
+	if (typeof amplify !== 'function') {
+		return true;
+	}
+	return false;
+};
+
 /**
  * Export Cloud Logic APIs
  */
@@ -163,7 +170,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 +199,30 @@ 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;
+
+				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);
+				}
+
 				this._api.updateRequestToBeCancellable(
 					responsePromise,
 					abortController
@@ -204,7 +230,7 @@ export class InternalGraphQLAPIClass {
 				return responsePromise;
 			case 'subscription':
 				return this._graphqlSubscribe(
-					amplify,
+					amplify as AmplifyClassV6,
 					{ query, variables, authMode },
 					headers,
 					customUserAgentDetails

package/src/internals/generateClient.ts

@@ -0,0 +1,30 @@
+// 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 } 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,
+		graphql,
+		cancel,
+		isCancelError,
+		models: {},
+	} as any;
+	client.models = generateModelsProperty<T>(client, params);
+
+	return client as V6Client<T>;
+}