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

package/src/internals/generateModelsProperty.ts

@@ -0,0 +1,192 @@
+// 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 { ClientGenerationParams } from './types';
+import { V6Client, GraphqlSubscriptionResult } from '../types';
+import { Observable, map } from 'rxjs';
+import { Amplify } from '@aws-amplify/core';
+
+export function generateModelsProperty<T extends Record<any, any> = never>(
+	client: V6Client,
+	params: ClientGenerationParams
+): ModelTypes<T> {
+	const models = {} as any;
+	// params.config gets populated in SSR only; otherwise we get it from the singleton
+	const config: any = params.config ?? Amplify.getConfig();
+
+	const modelIntrospection = config.API?.GraphQL?.modelIntrospection;
+	if (!modelIntrospection) {
+		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
+	for (const model of Object.values(modelIntrospection.models)) {
+		const { name } = model as any;
+
+		models[name] = {} as any;
+
+		Object.entries(graphQLOperationsInfo).forEach(
+			([key, { operationPrefix }]) => {
+				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 { data, nextToken, extensions } = (await client.graphql({
+								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,
+											extensions,
+										};
+									} else {
+										const initialized = initializeModel(
+											client,
+											name,
+											flattenedResult,
+											modelIntrospection
+										);
+
+										return {
+											data: initialized,
+											nextToken,
+											extensions,
+										};
+									}
+								}
+
+								return {
+									data: 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] = (arg?: any, options?: any) => {
+						const query = generateGraphQLDocument(
+							modelIntrospection.models,
+							name,
+							operation
+						);
+						const variables = buildGraphQLVariables(
+							model,
+							operation,
+							arg,
+							modelIntrospection
+						);
+
+						const observable = client.graphql({
+							query,
+							variables,
+						}) as GraphqlSubscriptionResult<object>;
+
+						return observable.pipe(
+							map(value => {
+								const [key] = Object.keys(value.data);
+								return value.data[key];
+							})
+						);
+					};
+				} 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({
+								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
+									);
+
+									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;
+							}
+						}
+					};
+				}
+			}
+		);
+	}
+
+	return models;
+}

package/src/internals/index.ts

@@ -6,3 +6,4 @@ export {
 } from './InternalGraphQLAPI';
 
 export { graphql, cancel, isCancelError } from './v6';
+export { generateClient } from './generateClient';

package/src/internals/types.ts

@@ -0,0 +1,15 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AmplifyClassV6 } from '@aws-amplify/core';
+
+/**
+ * @private
+ *
+ * The knobs available for configuring `generateClient` internally.
+ */
+export type ClientGenerationParams = {
+	amplify:
+		| AmplifyClassV6
+		| ((fn: (amplify: any) => Promise<any>) => Promise<AmplifyClassV6>);
+	config?: object;
+};

package/src/types/index.ts

@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { AmplifyClassV6 } from '@aws-amplify/core';
+import { ModelTypes } from '@aws-amplify/amplify-api-next-types-alpha';
 import { Source, DocumentNode, GraphQLError } from 'graphql';
 export { OperationTypeNode } from 'graphql';
 import { Observable } from 'rxjs';
@@ -10,6 +11,9 @@ import {
 	DocumentType,
 } from '@aws-amplify/core/internals/utils';
 export { CONTROL_MSG, ConnectionState } from './PubSub';
+
+export { SelectionSet } from '@aws-amplify/amplify-api-next-types-alpha';
+
 /**
  * Loose/Unknown options for raw GraphQLAPICategory `graphql()`.
  */
@@ -347,6 +351,7 @@ export type GeneratedSubscription<InputType, OutputType> = string & {
 type FilteredKeys<T> = {
 	[P in keyof T]: T[P] extends never ? never : P;
 }[keyof T];
+
 type ExcludeNeverFields<O> = {
 	[K in FilteredKeys<O>]: O[K];
 };
@@ -354,7 +359,7 @@ type ExcludeNeverFields<O> = {
 export const __amplify = Symbol('amplify');
 
 export type V6Client<T extends Record<any, any> = never> = ExcludeNeverFields<{
-	[__amplify]: AmplifyClassV6;
+	[__amplify]: AmplifyClassV6 | (() => Promise<AmplifyClassV6>);
 	graphql: <FALLBACK_TYPES = unknown, TYPED_GQL_STRING extends string = string>(
 		options: GraphQLOptionsV6<FALLBACK_TYPES, TYPED_GQL_STRING>,
 		additionalHeaders?:
@@ -365,4 +370,5 @@ export type V6Client<T extends Record<any, any> = never> = ExcludeNeverFields<{
 	) => GraphQLResponseV6<FALLBACK_TYPES, TYPED_GQL_STRING>;
 	cancel: (promise: Promise<any>, message?: string) => boolean;
 	isCancelError: (error: any) => boolean;
+	models: ModelTypes<T>;
 }>;

package/src/utils/resolveOwnerFields.ts

@@ -0,0 +1,65 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { ResourcesConfig } from '@aws-amplify/core';
+
+type GraphQLConfig = Exclude<ResourcesConfig['API'], undefined>['GraphQL'];
+type ModelIntrospectionSchema = Exclude<
+	Exclude<GraphQLConfig, undefined>['modelIntrospection'],
+	undefined
+>;
+type Model = ModelIntrospectionSchema['models'][string];
+
+type AuthAttribute = {
+	type: 'auth';
+	properties: {
+		rules: AuthRule[];
+	};
+};
+
+/**
+ * Only the portions of an Auth rule we care about.
+ */
+type AuthRule = {
+	allow: string;
+	ownerField?: string;
+};
+
+/**
+ * Given an introspection schema model, returns all owner fields.
+ *
+ * @param model Model from an introspection schema
+ * @returns List of owner field names
+ */
+export function resolveOwnerFields(model: Model): string[] {
+	const ownerFields = new Set<string>();
+	for (const attr of model.attributes || []) {
+		if (isAuthAttribute(attr)) {
+			for (const rule of attr.properties.rules) {
+				if (rule.allow === 'owner') {
+					ownerFields.add(rule.ownerField || 'owner');
+				}
+			}
+		}
+	}
+	return Array.from(ownerFields);
+}
+
+/**
+ * Type guard that identifies an auth attribute with an attached rules list that
+ * specifies an `allow` attribute at a minimum.
+ *
+ * @param attribute Any object. Ideally a model introspection schema model attribute
+ * @returns True if given object is an auth attribute
+ */
+function isAuthAttribute(attribute: any): attribute is AuthAttribute {
+	if (attribute?.type === 'auth') {
+		if (typeof attribute?.properties === 'object') {
+			if (Array.isArray(attribute?.properties?.rules)) {
+				return (attribute?.properties?.rules as Array<any>).every(
+					rule => !!rule.allow
+				);
+			}
+		}
+	}
+	return false;
+}