@aws-amplify/api-graphql 4.0.18-unstable.b758843.0 → 4.0.18

package/src/internals/APIClient.ts

@@ -5,6 +5,7 @@ import {
 	GraphQLAuthMode,
 	ModelIntrospectionSchema,
 	ModelFieldType,
+	NonModelFieldType,
 	SchemaModel,
 	SchemaModels,
 	AssociationHasOne,
@@ -24,6 +25,7 @@ import {
 } from '../types';
 import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
 import { CustomHeaders } from '@aws-amplify/data-schema-types';
+import { SchemaNonModel } from '@aws-amplify/core/dist/esm/singleton/API/types';
 import type { IndexMeta } from './operations/indexQuery';
 
 type LazyLoadOptions = {
@@ -314,12 +316,13 @@ type OperationPrefix =
 
 const SELECTION_SET_WILDCARD = '*';
 
-function defaultSelectionSetForModel(modelDefinition: SchemaModel): string[] {
-	// fields that are explicitly part of the graphql schema; not
-	// inferred from owner auth rules.
-	const { fields } = modelDefinition;
+function defaultSelectionSetForNonModel(
+	nonModelDefinition: SchemaNonModel
+): string[] {
+	// fields that are explicitly part of the graphql schema;
+	const { fields } = nonModelDefinition;
 	const explicitFields = Object.values<any>(fields)
-		// Default selection set omits model fields
+		// Default selection set omits non-model fields
 		.map(
 			({ type, name }) =>
 				(typeof type === 'string' ||
@@ -328,6 +331,31 @@ function defaultSelectionSetForModel(modelDefinition: SchemaModel): string[] {
 		)
 		.filter(Boolean);
 
+	// fields used for owner auth rules that may or may not also
+	// be explicit on the model.
+
+	return Array.from(new Set(explicitFields));
+}
+
+function defaultSelectionSetForModel(modelDefinition: SchemaModel): 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)
+		// Default selection set omits model fields
+		.map(({ type, name }) => {
+			if (typeof type === 'string') return name;
+
+			if (typeof type === 'object') {
+				if (typeof type?.enum === 'string') {
+					return name;
+				} else if (typeof type?.nonModel === 'string') {
+					return `${name}.${SELECTION_SET_WILDCARD}`;
+				}
+			}
+		})
+		.filter(Boolean);
+
 	// fields used for owner auth rules that may or may not also
 	// be explicit on the model.
 	const ownerFields = resolveOwnerFields(modelDefinition);
@@ -357,44 +385,71 @@ const FIELD_IR = '';
  * ```
  */
 export function customSelectionSetToIR(
-	modelDefinitions: SchemaModels,
+	modelInstrospection: ModelIntrospectionSchema,
 	modelName: string,
 	selectionSet: string[],
 ): Record<string, string | object> {
-	const dotNotationToObject = (
-		path: string,
-		modelName: string,
-	): Record<string, any> => {
+	const dotNotationToObject = (path: string, modelOrNonModelName: string) => {
 		const [fieldName, ...rest] = path.split('.');
 
-		let result: Record<string, any> = {};
+		const nested = rest[0];
+		const modelDefinition = modelInstrospection.models[modelOrNonModelName];
 
-		if (rest.length === 0) {
-			result = { [fieldName]: FIELD_IR };
-		} else {
-			const nested = rest[0];
-			const modelDefinition = modelDefinitions[modelName];
-			const modelFields = modelDefinition.fields;
-			const relatedModel = (modelFields[fieldName]?.type as ModelFieldType)
-				?.model;
-
-			if (!relatedModel) {
-				// TODO: may need to change this to support custom types
-				throw Error(`${fieldName} is not a model field`);
+		const modelFields = modelDefinition?.fields;
+		const relatedModel = (modelFields?.[fieldName]?.type as ModelFieldType)
+			?.model;
+
+		const relatedModelDefinition = modelInstrospection.models[relatedModel];
+		const relatedNonModel = (
+			modelFields?.[fieldName]?.type as NonModelFieldType
+		)?.nonModel;
+		const relatedNonModelDefinition =
+			modelInstrospection.nonModels[relatedNonModel];
+
+		const isModelOrNonModelOrField = relatedModelDefinition
+			? 'model'
+			: relatedNonModelDefinition
+			  ? 'nonModel'
+			  : 'field';
+
+		if (isModelOrNonModelOrField === 'nonModel') {
+			let result: Record<string, any> = {};
+
+			if (!nested) {
+				throw Error(
+					`${fieldName} must declare a wildcard (*) or a field of custom type ${relatedNonModel}`
+				);
 			}
 
 			if (nested === SELECTION_SET_WILDCARD) {
-				const relatedModelDefinition = modelDefinitions[relatedModel];
-
 				result = {
-					[fieldName]: defaultSelectionSetIR(relatedModelDefinition),
+					[fieldName]: nonModelsDefaultSelectionSetIR(
+						relatedNonModelDefinition
+					),
 				};
 			} else {
-				const exists = Boolean(modelFields[fieldName]);
-				if (!exists) {
-					throw Error(`${fieldName} is not a field of model ${modelName}`);
-				}
+				result = {
+					[fieldName]: dotNotationToObject(rest.join('.'), relatedNonModel),
+				};
+			}
+
+			return result;
+		} else if (isModelOrNonModelOrField === 'model') {
+			let result: Record<string, any> = {};
+
+			if (!nested) {
+				throw Error(
+					`${fieldName} must declare a wildcard (*) or a field of model ${relatedModel}`
+				);
+			}
+
+			if (nested === SELECTION_SET_WILDCARD) {
+				const relatedModelDefinition = modelInstrospection.models[relatedModel];
 
+				result = {
+					[fieldName]: modelsDefaultSelectionSetIR(relatedModelDefinition),
+				};
+			} else {
 				result = {
 					[fieldName]: dotNotationToObject(rest.join('.'), relatedModel),
 				};
@@ -407,9 +462,34 @@ export function customSelectionSetToIR(
 					},
 				};
 			}
-		}
 
-		return result;
+			return result;
+		} else {
+			const modelField = modelFields?.[fieldName];
+
+			const nonModelDefinition =
+				modelInstrospection.nonModels[modelOrNonModelName];
+			const nonModelField = nonModelDefinition?.fields?.[fieldName];
+
+			if (!nonModelDefinition) {
+				const isOwnerField =
+					resolveOwnerFields(modelDefinition).includes(fieldName);
+
+				if (!modelField && !isOwnerField) {
+					throw Error(
+						`${fieldName} is not a field of model ${modelOrNonModelName}`
+					);
+				}
+			} else {
+				if (!nonModelField) {
+					throw Error(
+						`${fieldName} is not a field of custom type ${modelOrNonModelName}`
+					);
+				}
+			}
+
+			return { [fieldName]: FIELD_IR };
+		}
 	};
 
 	return selectionSet.reduce(
@@ -422,7 +502,7 @@ export function customSelectionSetToIR(
 	);
 }
 
-const defaultSelectionSetIR = (relatedModelDefinition: SchemaModel) => {
+const modelsDefaultSelectionSetIR = (relatedModelDefinition: SchemaModel) => {
 	const defaultSelectionSet = defaultSelectionSetForModel(
 		relatedModelDefinition,
 	);
@@ -438,6 +518,24 @@ const defaultSelectionSetIR = (relatedModelDefinition: SchemaModel) => {
 	return reduced;
 };
 
+const nonModelsDefaultSelectionSetIR = (
+	relatedNonModelDefinition: SchemaNonModel
+) => {
+	const defaultSelectionSet = defaultSelectionSetForNonModel(
+		relatedNonModelDefinition
+	);
+
+	const reduced = defaultSelectionSet.reduce(
+		(acc: Record<string, any>, curVal) => {
+			acc[curVal] = FIELD_IR;
+			return acc;
+		},
+		{}
+	);
+
+	return reduced;
+};
+
 /**
  * Stringifies selection set IR
  * * @example
@@ -510,20 +608,16 @@ function deepMergeSelectionSetObjects<T extends Record<string, any>>(
 }
 
 export function generateSelectionSet(
-	modelDefinitions: SchemaModels,
+	modelInstrospection: ModelIntrospectionSchema,
 	modelName: string,
 	selectionSet?: string[],
 ) {
-	const modelDefinition = modelDefinitions[modelName];
-
-	if (!selectionSet) {
-		return defaultSelectionSetForModel(modelDefinition).join(' ');
-	}
+	const modelDefinition = modelInstrospection.models[modelName];
 
 	const selSetIr = customSelectionSetToIR(
-		modelDefinitions,
+		modelInstrospection,
 		modelName,
-		selectionSet,
+		selectionSet ?? defaultSelectionSetForModel(modelDefinition)
 	);
 	const selSetString = selectionSetIRToString(selSetIr);
 
@@ -531,13 +625,13 @@ export function generateSelectionSet(
 }
 
 export function generateGraphQLDocument(
-	modelDefinitions: SchemaModels,
+	modelInstrospection: ModelIntrospectionSchema,
 	modelName: string,
 	modelOperation: ModelOperation,
 	listArgs?: ListArgs | QueryArgs,
 	indexMeta?: IndexMeta,
 ): string {
-	const modelDefinition = modelDefinitions[modelName];
+	const modelDefinition = modelInstrospection.models[modelName];
 
 	const {
 		name,
@@ -584,7 +678,7 @@ export function generateGraphQLDocument(
 	let graphQLArguments: Record<string, any> | undefined;
 
 	const selectionSetFields = generateSelectionSet(
-		modelDefinitions,
+		modelInstrospection,
 		modelName,
 		selectionSet as ListArgs['selectionSet'],
 	);

package/src/internals/generateClient.ts

@@ -1,11 +1,20 @@
 // 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 {
+	EnumTypes,
+	ModelTypes,
+	CustomQueries,
+	CustomMutations,
+} from '@aws-amplify/data-schema-types';
 import { generateEnumsProperty } from './utils/generateEnumsProperty';
 import { generateModelsProperty } from './utils/generateModelsProperty';
 import { isApiGraphQLConfig } from './utils/isApiGraphQLProviderConfig';
+import {
+	generateCustomQueriesProperty,
+	generateCustomMutationsProperty,
+} from './generateCustomOperationsProperty';
 import {
 	V6Client,
 	__amplify,
@@ -38,6 +47,8 @@ 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>,
 	} as any;
 
 	const apiGraphqlConfig = params.amplify.getConfig().API?.GraphQL;
@@ -45,6 +56,11 @@ 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,
+		);
 	} else {
 		// This happens when the `Amplify.configure()` call gets evaluated after the `generateClient()` call.
 		//
@@ -75,6 +91,14 @@ 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,
+			);
 		}
 	});
 };

package/src/internals/generateCustomOperationsProperty.ts

@@ -0,0 +1,89 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { CustomQueries, CustomMutations } from '@aws-amplify/data-schema-types';
+import { V6Client, __authMode, __authToken, __amplify } from '../types';
+
+import { customOpFactory } from './operations/custom';
+import {
+	ModelIntrospectionSchema,
+	GraphQLProviderConfig,
+} from '@aws-amplify/core/internals/utils';
+
+type OpTypes = 'queries' | 'mutations';
+
+type CustomOpsProperty<
+	T extends Record<any, any>,
+	OpType extends OpTypes,
+> = OpType extends 'queries' ? CustomQueries<T> : CustomMutations<T>;
+
+const operationTypeMap = {
+	queries: 'query',
+	mutations: 'mutation',
+} 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',
+	);
+}