@aws-amplify/api-graphql 4.0.2-unstable.51ed7b4.0 → 4.0.2-unstable.a5eb335.0

package/src/internals/APIClient.ts

@@ -1,12 +1,27 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // 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 {
+	GraphQLAuthMode,
+	ModelIntrospectionSchema,
+	ModelFieldType,
+	SchemaModel,
+	SchemaModels,
+	AssociationHasOne,
+	AssociationBelongsTo,
+} from '@aws-amplify/core/internals/utils';
+import {
+	AuthModeParams,
+	ClientWithModels,
+	ListArgs,
+	QueryArgs,
+	V6Client,
+	V6ClientSSRRequest,
+	__authMode,
+	__authToken,
+} from '../types';
 import { AmplifyServer } from '@aws-amplify/core/internals/adapter-core';
 
-type ListArgs = { selectionSet?: string[]; filter?: {} };
-
 type LazyLoadOptions = {
 	authMode?: GraphQLAuthMode;
 	authToken?: string | undefined;
@@ -48,10 +63,10 @@ export const flattenItems = (obj: Record<string, any>): Record<string, any> => {
 
 // TODO: this should accept single result to support CRUD methods; create helper for array/list
 export function initializeModel(
-	client: any,
+	client: ClientWithModels,
 	modelName: string,
 	result: any[],
-	modelIntrospection: any,
+	modelIntrospection: ModelIntrospectionSchema,
 	authMode: GraphQLAuthMode | undefined,
 	authToken: string | undefined,
 	context = false
@@ -64,12 +79,14 @@ export function initializeModel(
 		.map(([fieldName]) => fieldName);
 
 	return result.map(record => {
-		const initializedRelationalFields = {};
+		const initializedRelationalFields: Record<string, any> = {};
 
-		for (const field of modelFields) {
-			const relatedModelName = introModelFields[field].type.model;
+		for (const fieldName of modelFields) {
+			const modelField = introModelFields[fieldName];
+			const modelFieldType = modelField?.type as ModelFieldType;
 
-			const relatedModel = modelIntrospection.models[relatedModelName];
+			const relatedModelName = modelFieldType.model;
+			const relatedModel = modelIntrospection.models[relatedModelName!];
 
 			const relatedModelPKFieldName =
 				relatedModel.primaryKeyInfo.primaryKeyFieldName;
@@ -77,18 +94,26 @@ export function initializeModel(
 			const relatedModelSKFieldNames =
 				relatedModel.primaryKeyInfo.sortKeyFieldNames;
 
-			const relationType = introModelFields[field].association.connectionType;
-			const connectionFields =
-				introModelFields[field].association.associatedWith;
+			const relationType = modelField.association?.connectionType;
 
-			const targetNames =
-				introModelFields[field].association?.targetNames || [];
+			let connectionFields: string[] = [];
+			if (
+				modelField.association &&
+				'associatedWith' in modelField.association
+			) {
+				connectionFields = modelField.association.associatedWith;
+			}
+
+			let targetNames: string[] = [];
+			if (modelField.association && 'targetNames' in modelField.association) {
+				targetNames = modelField.association.targetNames;
+			}
 
 			switch (relationType) {
 				case connectionType.HAS_ONE:
 				case connectionType.BELONGS_TO:
 					const sortKeyValues = relatedModelSKFieldNames.reduce(
-						(acc, curVal) => {
+						(acc: Record<string, any>, curVal) => {
 							if (record[curVal]) {
 								return (acc[curVal] = record[curVal]);
 							}
@@ -97,12 +122,14 @@ export function initializeModel(
 					);
 
 					if (context) {
-						initializedRelationalFields[field] = (
+						initializedRelationalFields[fieldName] = (
 							contextSpec: AmplifyServer.ContextSpec,
 							options?: LazyLoadOptions
 						) => {
 							if (record[targetNames[0]]) {
-								return client.models[relatedModelName].get(
+								return (
+									client as V6ClientSSRRequest<Record<string, any>>
+								).models[relatedModelName].get(
 									contextSpec,
 									{
 										[relatedModelPKFieldName]: record[targetNames[0]],
@@ -117,11 +144,13 @@ export function initializeModel(
 							return undefined;
 						};
 					} else {
-						initializedRelationalFields[field] = (
+						initializedRelationalFields[fieldName] = (
 							options?: LazyLoadOptions
 						) => {
 							if (record[targetNames[0]]) {
-								return client.models[relatedModelName].get(
+								return (client as V6Client<Record<string, any>>).models[
+									relatedModelName
+								].get(
 									{
 										[relatedModelPKFieldName]: record[targetNames[0]],
 										...sortKeyValues,
@@ -142,25 +171,37 @@ export function initializeModel(
 					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 relatedModelField = relatedModel.fields[connectionFields[0]];
+					const relatedModelFieldType =
+						relatedModelField.type as ModelFieldType;
+					if (relatedModelFieldType.model) {
+						let relatedTargetNames: string[] = [];
+						if (
+							relatedModelField.association &&
+							'targetNames' in relatedModelField.association
+						) {
+							relatedTargetNames = relatedModelField.association?.targetNames;
+						}
 
-						const hasManyFilter = relatedTargetNames.map((field, idx) => {
-							if (idx === 0) {
-								return { [field]: { eq: record[parentPk] } };
-							}
+						const hasManyFilter: Record<string, any> = relatedTargetNames.map(
+							(field, idx) => {
+								if (idx === 0) {
+									return { [field]: { eq: record[parentPk] } };
+								}
 
-							return { [field]: { eq: record[parentSK[idx - 1]] } };
-						});
+								return { [field]: { eq: record[parentSK[idx - 1]] } };
+							}
+						);
 
 						if (context) {
-							initializedRelationalFields[field] = (
+							initializedRelationalFields[fieldName] = (
 								contextSpec: AmplifyServer.ContextSpec,
 								options?: LazyLoadOptions
 							) => {
 								if (record[parentPk]) {
-									return client.models[relatedModelName].list(contextSpec, {
+									return (
+										client as V6ClientSSRRequest<Record<string, any>>
+									).models[relatedModelName].list(contextSpec, {
 										filter: { and: hasManyFilter },
 										limit: options?.limit,
 										nextToken: options?.nextToken,
@@ -171,11 +212,13 @@ export function initializeModel(
 								return [];
 							};
 						} else {
-							initializedRelationalFields[field] = (
+							initializedRelationalFields[fieldName] = (
 								options?: LazyLoadOptions
 							) => {
 								if (record[parentPk]) {
-									return client.models[relatedModelName].list({
+									return (client as V6Client<Record<string, any>>).models[
+										relatedModelName
+									].list({
 										filter: { and: hasManyFilter },
 										limit: options?.limit,
 										nextToken: options?.nextToken,
@@ -190,21 +233,25 @@ export function initializeModel(
 						break;
 					}
 
-					const hasManyFilter = connectionFields.map((field, idx) => {
-						if (idx === 0) {
-							return { [field]: { eq: record[parentPk] } };
-						}
+					const hasManyFilter: Record<string, any> = connectionFields.map(
+						(field, idx) => {
+							if (idx === 0) {
+								return { [field]: { eq: record[parentPk] } };
+							}
 
-						return { [field]: { eq: record[parentSK[idx - 1]] } };
-					});
+							return { [field]: { eq: record[parentSK[idx - 1]] } };
+						}
+					);
 
 					if (context) {
-						initializedRelationalFields[field] = (
+						initializedRelationalFields[fieldName] = (
 							contextSpec: AmplifyServer.ContextSpec,
 							options?: LazyLoadOptions
 						) => {
 							if (record[parentPk]) {
-								return client.models[relatedModelName].list(contextSpec, {
+								return (
+									client as V6ClientSSRRequest<Record<string, any>>
+								).models[relatedModelName].list(contextSpec, {
 									filter: { and: hasManyFilter },
 									limit: options?.limit,
 									nextToken: options?.nextToken,
@@ -215,11 +262,13 @@ export function initializeModel(
 							return [];
 						};
 					} else {
-						initializedRelationalFields[field] = (
+						initializedRelationalFields[fieldName] = (
 							options?: LazyLoadOptions
 						) => {
 							if (record[parentPk]) {
-								return client.models[relatedModelName].list({
+								return (client as V6Client<Record<string, any>>).models[
+									relatedModelName
+								].list({
 									filter: { and: hasManyFilter },
 									limit: options?.limit,
 									nextToken: options?.nextToken,
@@ -260,7 +309,7 @@ type OperationPrefix =
 const graphQLDocumentsCache = new Map<string, Map<ModelOperation, string>>();
 const SELECTION_SET_WILDCARD = '*';
 
-function defaultSelectionSetForModel(modelDefinition: any): string[] {
+function defaultSelectionSetForModel(modelDefinition: SchemaModel): string[] {
 	// fields that are explicitly part of the graphql schema; not
 	// inferred from owner auth rules.
 	const { fields } = modelDefinition;
@@ -280,7 +329,7 @@ const FIELD_IR = '';
 /**
  * Generates nested Custom Selection Set IR from path
  *
- * @param modelIntrospection
+ * @param modelDefinitions
  * @param modelName
  * @param selectionSet - array of object paths
  * @example
@@ -297,31 +346,32 @@ const FIELD_IR = '';
  * ```
  */
 export function customSelectionSetToIR(
-	modelIntrospection: any,
+	modelDefinitions: SchemaModels,
 	modelName: string,
 	selectionSet: string[]
 ): Record<string, string | object> {
-	const modelDefinition = modelIntrospection[modelName];
+	const modelDefinition = modelDefinitions[modelName];
 	const { fields: modelFields } = modelDefinition;
 
-	return selectionSet.reduce((resultObj, path) => {
+	return selectionSet.reduce((resultObj: Record<string, any>, path) => {
 		const [fieldName, nested, ...rest] = path.split('.');
 
 		if (nested) {
-			const relatedModel = modelFields[fieldName]?.type?.model;
+			const fieldType = modelFields[fieldName]?.type as ModelFieldType;
+			const relatedModel = fieldType.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 relatedModelDefinition = modelDefinitions[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, [
+					  customSelectionSetToIR(modelDefinitions, relatedModel, [
 							[nested, ...rest].join('.'),
 					  ]);
 
@@ -353,15 +403,18 @@ export function customSelectionSetToIR(
 	}, {});
 }
 
-const defaultSelectionSetIR = relatedModelDefinition => {
+const defaultSelectionSetIR = (relatedModelDefinition: SchemaModel) => {
 	const defaultSelectionSet = defaultSelectionSetForModel(
 		relatedModelDefinition
 	);
 
-	const reduced = defaultSelectionSet.reduce((acc, curVal) => {
-		acc[curVal] = FIELD_IR;
-		return acc;
-	}, {});
+	const reduced = defaultSelectionSet.reduce(
+		(acc: Record<string, any>, curVal) => {
+			acc[curVal] = FIELD_IR;
+			return acc;
+		},
+		{}
+	);
 
 	return reduced;
 };
@@ -410,18 +463,18 @@ export function selectionSetIRToString(
 }
 
 export function generateSelectionSet(
-	modelIntrospection: any,
+	modelDefinitions: SchemaModels,
 	modelName: string,
 	selectionSet?: string[]
 ) {
-	const modelDefinition = modelIntrospection[modelName];
+	const modelDefinition = modelDefinitions[modelName];
 
 	if (!selectionSet) {
 		return defaultSelectionSetForModel(modelDefinition).join(' ');
 	}
 
 	const selSetIr = customSelectionSetToIR(
-		modelIntrospection,
+		modelDefinitions,
 		modelName,
 		selectionSet
 	);
@@ -431,12 +484,12 @@ export function generateSelectionSet(
 }
 
 export function generateGraphQLDocument(
-	modelIntrospection: any,
+	modelDefinitions: SchemaModels,
 	modelName: string,
 	modelOperation: ModelOperation,
 	listArgs?: ListArgs
 ): string {
-	const modelDefinition = modelIntrospection[modelName];
+	const modelDefinition = modelDefinitions[modelName];
 
 	const {
 		name,
@@ -469,7 +522,7 @@ export function generateGraphQLDocument(
 	let graphQLArguments: Record<string, any> | undefined;
 
 	const selectionSetFields = generateSelectionSet(
-		modelIntrospection,
+		modelDefinitions,
 		modelName,
 		selectionSet
 	);
@@ -490,7 +543,7 @@ export function generateGraphQLDocument(
 			graphQLArguments ??
 				(graphQLArguments = isCustomPrimaryKey
 					? [primaryKeyFieldName, ...sortKeyFieldNames].reduce(
-							(acc, fieldName) => {
+							(acc: Record<string, any>, fieldName) => {
 								acc[fieldName] = fields[fieldName].type;
 
 								return acc;
@@ -548,10 +601,10 @@ export function generateGraphQLDocument(
 }
 
 export function buildGraphQLVariables(
-	modelDefinition: any,
+	modelDefinition: SchemaModel,
 	operation: ModelOperation,
-	arg: any,
-	modelIntrospection
+	arg: QueryArgs | undefined,
+	modelIntrospection: ModelIntrospectionSchema
 ): object {
 	const {
 		fields,
@@ -568,36 +621,42 @@ export function buildGraphQLVariables(
 	switch (operation) {
 		case 'CREATE':
 			variables = {
-				input: normalizeMutationInput(arg, modelDefinition, modelIntrospection),
+				input: arg
+					? 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;
-					})
-				),
+				input: arg
+					? 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];
+			if (arg) {
+				variables = isCustomPrimaryKey
+					? [primaryKeyFieldName, ...sortKeyFieldNames].reduce(
+							(acc: Record<string, any>, fieldName) => {
+								acc[fieldName] = arg[fieldName];
 
-							return acc;
-						},
-						{}
-				  )
-				: { [primaryKeyFieldName]: arg[primaryKeyFieldName] };
+								return acc;
+							},
+							{}
+					  )
+					: { [primaryKeyFieldName]: arg[primaryKeyFieldName] };
+			}
 
 			if (operation === 'DELETE') {
 				variables = { input: variables };
@@ -649,34 +708,36 @@ export function buildGraphQLVariables(
  *
  */
 export function normalizeMutationInput(
-	mutationInput: any,
-	model: any,
-	modelDefinition: any
-): Record<string, unknown> {
+	mutationInput: QueryArgs,
+	model: SchemaModel,
+	modelIntrospection: ModelIntrospectionSchema
+): QueryArgs {
 	const { fields } = model;
 
-	const normalized = {};
+	const normalized: Record<string, unknown> = {};
 
 	Object.entries(mutationInput).forEach(([inputFieldName, inputValue]) => {
-		const relatedModelName: string | undefined =
-			fields[inputFieldName]?.type?.model;
+		const fieldType = fields[inputFieldName]?.type as ModelFieldType;
+		const relatedModelName = fieldType?.model;
 
 		if (relatedModelName) {
 			const association = fields[inputFieldName]?.association;
-			const relatedModelDef = modelDefinition.models[relatedModelName];
+			const relatedModelDef = modelIntrospection.models[relatedModelName];
 			const relatedModelPkInfo = relatedModelDef.primaryKeyInfo;
 
-			if (association.connectionType === connectionType.HAS_ONE) {
-				association.targetNames.forEach((targetName, idx) => {
-					const associatedFieldName = association.associatedWith[idx];
+			if (association?.connectionType === connectionType.HAS_ONE) {
+				const associationHasOne = association as AssociationHasOne;
+				associationHasOne.targetNames.forEach((targetName, idx) => {
+					const associatedFieldName = associationHasOne.associatedWith[idx];
 					normalized[targetName] = (inputValue as Record<string, unknown>)[
 						associatedFieldName
 					];
 				});
 			}
 
-			if (association.connectionType === connectionType.BELONGS_TO) {
-				association.targetNames.forEach((targetName, idx) => {
+			if (association?.connectionType === connectionType.BELONGS_TO) {
+				const associationBelongsTo = association as AssociationBelongsTo;
+				associationBelongsTo.targetNames.forEach((targetName, idx) => {
 					if (idx === 0) {
 						const associatedFieldName = relatedModelPkInfo.primaryKeyFieldName;
 						normalized[targetName] = (inputValue as Record<string, unknown>)[
@@ -699,11 +760,6 @@ 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`
@@ -714,7 +770,7 @@ type AuthModeParams = {
  * @returns
  */
 export function authModeParams(
-	client: V6Client,
+	client: ClientWithModels,
 	options: AuthModeParams = {}
 ): AuthModeParams {
 	return {

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,9 +384,6 @@ 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),
@@ -409,4 +399,4 @@ export class InternalGraphQLAPIClass {
 	}
 }
 
-export const InternalGraphQLAPI = new InternalGraphQLAPIClass(null);
+export const InternalGraphQLAPI = new InternalGraphQLAPIClass();

package/src/internals/generateModelsProperty.ts

@@ -9,9 +9,10 @@ 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,
+	client: V6Client<Record<string, any>>,
 	params: ClientGenerationParams
 ): ModelTypes<T> {
 	const models = {} as any;
@@ -23,17 +24,19 @@ export function generateModelsProperty<T extends Record<any, any> = never>(
 		);
 	}
 
-	const modelIntrospection = config.API?.GraphQL?.modelIntrospection;
+	const modelIntrospection: ModelIntrospectionSchema | undefined =
+		config.API.GraphQL.modelIntrospection;
+
 	if (!modelIntrospection) {
-		return {} as any;
+		return {} as ModelTypes<never>;
 	}
 
 	const SUBSCRIPTION_OPS = ['ONCREATE', 'ONUPDATE', 'ONDELETE'];
 
 	for (const model of Object.values(modelIntrospection.models)) {
-		const { name } = model as any;
+		const { name } = model;
 
-		models[name] = {} as any;
+		models[name] = {} as Record<string, any>;
 
 		Object.entries(graphQLOperationsInfo).forEach(
 			([key, { operationPrefix }]) => {