@aws-amplify/api 5.4.6-api-v6.2fd20b7.0 → 5.4.6-api-v6-models.5d6fe9b.0

package/src/API.ts

@@ -11,7 +11,14 @@ import { graphql as v6graphql } from '@aws-amplify/api-graphql/internals';
 import { Amplify, ConsoleLogger as Logger } from '@aws-amplify/core';
 import Observable from 'zen-observable-ts';
 import { InternalAPIClass } from './internals/InternalAPI';
-import type { ModelTypes } from '@aws-amplify/types-package-alpha';
+import {
+	initializeModel,
+	generateGraphQLDocument,
+	buildGraphQLVariables,
+	graphQLOperationsInfo,
+	ModelOperation,
+} from './APIClient';
+import type { ModelTypes } from '@aws-amplify/amplify-api-next-types-alpha';
 
 const logger = new Logger('API');
 /**
@@ -62,6 +69,8 @@ export class APIClass extends InternalAPIClass {
 			models: {},
 		};
 
+		// 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
 		for (const model of Object.values(modelIntrospection.models)) {
 			const { name } = model as any;
 
@@ -71,29 +80,99 @@ export class APIClass extends InternalAPIClass {
 				([key, { operationPrefix }]) => {
 					const operation = key as ModelOperation;
 
-					// e.g. clients.models.Todo.update
-					client.models[name][operationPrefix] = async (arg?: any) => {
-						const query = generateGraphQLDocument(model, operation);
-						const variables = buildGraphQLVariables(model, operation, arg);
-
-						const res = (await this.graphql({
-							query,
-							variables,
-						})) as any;
-
-						// flatten response
-						if (res.data !== undefined) {
-							const [key] = Object.keys(res.data);
-
-							if (res.data[key].items) {
-								return res.data[key].items;
+					if (operation === 'LIST') {
+						client.models[name][operationPrefix] = async (args?: any) => {
+							const query = generateGraphQLDocument(
+								modelIntrospection.models,
+								name,
+								'LIST',
+								args
+							);
+							const variables = buildGraphQLVariables(
+								model,
+								'LIST',
+								args,
+								modelIntrospection
+							);
+
+							console.log('API list', query, variables);
+
+							const res = (await this.graphql({
+								query,
+								variables,
+							})) as any;
+
+							// flatten response
+							if (res.data !== undefined) {
+								const [key] = Object.keys(res.data);
+
+								if (res.data[key].items) {
+									const flattenedResult = res.data[key].items;
+
+									// don't init if custom selection set
+									if (args?.selectionSet) {
+										return flattenedResult;
+									} else {
+										const initialized = initializeModel(
+											client,
+											name,
+											flattenedResult,
+											modelIntrospection
+										);
+
+										console.log('initialized', initialized);
+
+										return initialized;
+									}
+								}
+
+								return res.data[key];
 							}
 
-							return res.data[key];
-						}
+							return res as any;
+						};
+					} else {
+						client.models[name][operationPrefix] = async (
+							arg?: any,
+							options?: any
+						) => {
+							const query = generateGraphQLDocument(
+								modelIntrospection.models,
+								name,
+								operation
+							);
+							const variables = buildGraphQLVariables(
+								model,
+								operation,
+								arg,
+								modelIntrospection
+							);
+
+							console.log(`API ${operationPrefix}`, query, variables);
+
+							const res = (await this.graphql({
+								query,
+								variables,
+							})) as any;
+
+							// flatten response
+							if (res.data !== undefined) {
+								const [key] = Object.keys(res.data);
+
+								// TODO: refactor to avoid destructuring here
+								const [initialized] = initializeModel(
+									client,
+									name,
+									[res.data[key]],
+									modelIntrospection
+								);
+
+								return initialized;
+							}
 
-						return res;
-					};
+							return res;
+						};
+					}
 				}
 			);
 		}
@@ -102,170 +181,10 @@ export class APIClass extends InternalAPIClass {
 	}
 }
 
-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 },
-};
-type ModelOperation = keyof typeof graphQLOperationsInfo;
-type OperationPrefix =
-	(typeof graphQLOperationsInfo)[ModelOperation]['operationPrefix'];
-
-const graphQLDocumentsCache = new Map<string, Map<ModelOperation, string>>();
-
-function generateGraphQLDocument(
-	modelDefinition: any,
-	modelOperation: ModelOperation
-): string {
-	const {
-		name,
-		pluralName,
-		fields,
-		primaryKeyInfo: {
-			isCustomPrimaryKey,
-			primaryKeyFieldName,
-			sortKeyFieldNames,
-		},
-	} = modelDefinition;
-	const { operationPrefix, usePlural } = graphQLOperationsInfo[modelOperation];
-
-	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' | undefined;
-	let graphQLSelectionSet: string | undefined;
-	let graphQLArguments: Record<string, any> | undefined;
-
-	const selectionSetFields = Object.values<any>(fields)
-		.map(({ type, name }) => typeof type === 'string' && name) // Only scalars for now
-		.filter(Boolean)
-		.join(' ');
-
-	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':
-			graphQLOperationType ?? (graphQLOperationType = 'query');
-			graphQLSelectionSet ??
-				(graphQLSelectionSet = `items { ${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;
-}
-
-function buildGraphQLVariables(
-	modelDefinition: any,
-	operation: ModelOperation,
-	arg: any
-): object {
-	const {
-		fields,
-		primaryKeyInfo: {
-			isCustomPrimaryKey,
-			primaryKeyFieldName,
-			sortKeyFieldNames,
-		},
-	} = modelDefinition;
-
-	let variables = {};
-
-	switch (operation) {
-		case 'CREATE':
-			variables = { input: arg };
-			break;
-		case 'UPDATE':
-			// readonly fields are not  updated
-			variables = {
-				input: Object.fromEntries(
-					Object.entries(arg).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':
-			break;
-		default:
-			const exhaustiveCheck: never = operation;
-			throw new Error(`Unhandled operation case: ${exhaustiveCheck}`);
-	}
-
-	return variables;
-}
-
 type FilteredKeys<T> = {
 	[P in keyof T]: T[P] extends never ? never : P;
 }[keyof T];
+
 type ExcludeNeverFields<O> = {
 	[K in FilteredKeys<O>]: O[K];
 };