@aws-amplify/datastore 3.12.11 → 3.12.13-unstable.1

package/src/sync/utils.ts

@@ -11,6 +11,7 @@ import {
 	isGraphQLScalarType,
 	isPredicateObj,
 	isSchemaModel,
+	isSchemaModelWithAttributes,
 	isTargetNameAssociation,
 	isNonModelFieldType,
 	ModelFields,
@@ -27,7 +28,12 @@ import {
 	InternalSchema,
 	AuthModeStrategy,
 } from '../types';
-import { exhaustiveCheck } from '../util';
+import {
+	exhaustiveCheck,
+	extractPrimaryKeyFieldNames,
+	establishRelationAndKeys,
+	IDENTIFIER_KEY_SEPARATOR,
+} from '../util';
 import { MutationEvent } from './';
 
 const logger = new Logger('DataStore');
@@ -47,7 +53,7 @@ export enum TransformerMutationType {
 	GET = 'Get',
 }
 
-const dummyMetadata: Omit<ModelInstanceMetadata, 'id'> = {
+const dummyMetadata: ModelInstanceMetadata = {
 	_version: undefined,
 	_lastChangedAt: undefined,
 	_deleted: undefined,
@@ -79,7 +85,7 @@ export function generateSelectionSet(
 	if (isSchemaModel(modelDefinition)) {
 		scalarAndMetadataFields = scalarAndMetadataFields
 			.concat(getMetadataFields())
-			.concat(getConnectionFields(modelDefinition));
+			.concat(getConnectionFields(modelDefinition, namespace));
 	}
 
 	const result = scalarAndMetadataFields.join('\n');
@@ -103,7 +109,7 @@ function getOwnerFields(
 	modelDefinition: SchemaModel | SchemaNonModel
 ): string[] {
 	const ownerFields: string[] = [];
-	if (isSchemaModel(modelDefinition) && modelDefinition.attributes) {
+	if (isSchemaModelWithAttributes(modelDefinition)) {
 		modelDefinition.attributes.forEach(attr => {
 			if (attr.properties && attr.properties.rules) {
 				const rule = attr.properties.rules.find(rule => rule.allow === 'owner');
@@ -138,8 +144,12 @@ function getScalarFields(
 	return result;
 }
 
-function getConnectionFields(modelDefinition: SchemaModel): string[] {
-	const result = [];
+// Used for generating the selection set for queries and mutations
+function getConnectionFields(
+	modelDefinition: SchemaModel,
+	namespace: SchemaNamespace
+): string[] {
+	const result: string[] = [];
 
 	Object.values(modelDefinition.fields)
 		.filter(({ association }) => association && Object.keys(association).length)
@@ -153,7 +163,26 @@ function getConnectionFields(modelDefinition: SchemaModel): string[] {
 					break;
 				case 'BELONGS_TO':
 					if (isTargetNameAssociation(association)) {
-						result.push(`${name} { id _deleted }`);
+						// New codegen (CPK)
+						if (association.targetNames && association.targetNames.length > 0) {
+							// Need to retrieve relations in order to get connected model keys
+							const [relations] = establishRelationAndKeys(namespace);
+
+							const connectedModelName =
+								modelDefinition.fields[name].type['model'];
+
+							const byPkIndex = relations[connectedModelName].indexes.find(
+								([name]) => name === 'byPk'
+							);
+							const keyFields = byPkIndex && byPkIndex[1];
+							const keyFieldSelectionSet = keyFields?.join(' ');
+
+							// We rely on `_deleted` when we process the sync query (e.g. in batchSave in the adapters)
+							result.push(`${name} { ${keyFieldSelectionSet} _deleted }`);
+						} else {
+							// backwards-compatability for schema generated prior to custom primary key support
+							result.push(`${name} { id _deleted }`);
+						}
 					}
 					break;
 				default:
@@ -412,10 +441,13 @@ export function createMutationInstanceFromModelOperation<
 		return v;
 	};
 
+	const modelId = getIdentifierValue(modelDefinition, element);
+	const optionalId = OpType.INSERT && id ? { id } : {};
+
 	const mutationEvent = modelInstanceCreator(MutationEventConstructor, {
-		...(id ? { id } : {}),
+		...optionalId,
 		data: JSON.stringify(element, replacer),
-		modelId: element.id,
+		modelId,
 		model: model.name,
 		operation,
 		condition: JSON.stringify(condition),
@@ -425,7 +457,8 @@ export function createMutationInstanceFromModelOperation<
 }
 
 export function predicateToGraphQLCondition(
-	predicate: PredicatesGroup<any>
+	predicate: PredicatesGroup<any>,
+	modelDefinition: SchemaModel
 ): GraphQLCondition {
 	const result = {};
 
@@ -433,17 +466,27 @@ export function predicateToGraphQLCondition(
 		return result;
 	}
 
+	const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+
 	predicate.predicates.forEach(p => {
 		if (isPredicateObj(p)) {
 			const { field, operator, operand } = p;
 
-			if (field === 'id') {
+			// This is compatible with how the GQL Transform currently generates the Condition Input,
+			// i.e. any PK and SK fields are omitted and can't be used as conditions.
+			// However, I think this limits usability.
+			// What if we want to delete all records where SK > some value
+			// Or all records where PK = some value but SKs are different values
+
+			// TODO: if the Transform gets updated ^ we'll need to modify this logic to only omit
+			// key fields from the predicate/condition when ALL of the keyFields are present and using `eq` operators
+			if (keyFields.includes(field as string)) {
 				return;
 			}
 
 			result[field] = { [operator]: operand };
 		} else {
-			result[p.type] = predicateToGraphQLCondition(p);
+			result[p.type] = predicateToGraphQLCondition(p, modelDefinition);
 		}
 	});
 
@@ -610,3 +653,17 @@ export async function getTokenForCustomAuth(
 		}
 	}
 }
+
+// Util that takes a modelDefinition and model and returns either the id value(s) or the custom primary key value(s)
+export function getIdentifierValue(
+	modelDefinition: SchemaModel,
+	model: ModelInstanceMetadata | PersistentModel
+): string {
+	const pkFieldNames = extractPrimaryKeyFieldNames(modelDefinition);
+
+	const idOrPk = pkFieldNames
+		.map(f => model[f])
+		.join(IDENTIFIER_KEY_SEPARATOR);
+
+	return idOrPk;
+}

package/src/types.ts

@@ -10,6 +10,7 @@ import {
 	isAWSURL,
 	isAWSPhone,
 	isAWSIPAddress,
+	extractPrimaryKeyFieldNames,
 } from './util';
 import { PredicateAll } from './predicates';
 import { GRAPHQL_AUTH_MODE } from '@aws-amplify/api-graphql';
@@ -46,9 +47,17 @@ export type SchemaModel = {
 	fields: ModelFields;
 	syncable?: boolean;
 };
+
 export function isSchemaModel(obj: any): obj is SchemaModel {
 	return obj && (<SchemaModel>obj).pluralName !== undefined;
 }
+
+export function isSchemaModelWithAttributes(
+	m: SchemaModel | SchemaNonModel
+): m is SchemaModel {
+	return isSchemaModel(m) && (m as SchemaModel).attributes !== undefined;
+}
+
 export type SchemaNonModels = Record<string, SchemaNonModel>;
 export type SchemaNonModel = {
 	name: string;
@@ -63,25 +72,29 @@ type SchemaEnum = {
 export type ModelAssociation = AssociatedWith | TargetNameAssociation;
 type AssociatedWith = {
 	connectionType: 'HAS_MANY' | 'HAS_ONE';
-	associatedWith: string;
+	associatedWith: string | string[];
 	targetName?: string;
+	targetNames?: string[];
 };
+
 export function isAssociatedWith(obj: any): obj is AssociatedWith {
 	return obj && obj.associatedWith;
 }
 
 type TargetNameAssociation = {
 	connectionType: 'BELONGS_TO';
-	targetName: string;
+	targetName?: string;
+	targetNames?: string[];
 };
+
 export function isTargetNameAssociation(
 	obj: any
 ): obj is TargetNameAssociation {
-	return obj && obj.targetName;
+	return obj?.targetName || obj?.targetNames;
 }
 
 export type ModelAttributes = ModelAttribute[];
-type ModelAttribute = { type: string; properties?: Record<string, any> };
+export type ModelAttribute = { type: string; properties?: Record<string, any> };
 
 export type ModelAuthRule = {
 	allow: string;
@@ -123,6 +136,7 @@ type ModelAttributeKey = {
 type ModelAttributePrimaryKey = {
 	type: 'key';
 	properties: {
+		name: never;
 		fields: string[];
 	};
 };
@@ -336,33 +350,138 @@ export type NonModelTypeConstructor<T> = {
 };
 
 // Class for model
-export type PersistentModelConstructor<
-	T extends PersistentModel,
-	K extends PersistentModelMetaData = {
-		readOnlyFields: 'createdAt' | 'updatedAt';
-	}
-> = {
-	new (init: ModelInit<T, K>): T;
-	copyOf(src: T, mutator: (draft: MutableModel<T, K>) => void): T;
+export type PersistentModelConstructor<T extends PersistentModel> = {
+	new (init: ModelInit<T, PersistentModelMetaData<T>>): T;
+	copyOf(
+		src: T,
+		mutator: (draft: MutableModel<T, PersistentModelMetaData<T>>) => void
+	): T;
 };
 
 export type TypeConstructorMap = Record<
 	string,
-	PersistentModelConstructor<any> | NonModelTypeConstructor<any>
+	PersistentModelConstructor<any> | NonModelTypeConstructor<unknown>
+>;
+
+/**
+ * Each identifier type is represented using nominal types, see:
+ * https://basarat.gitbook.io/typescript/main-1/nominaltyping
+ */
+export declare const __identifierBrand__: unique symbol;
+export type IdentifierBrand<T, K> = T & { [__identifierBrand__]: K };
+
+// datastore generates a uuid for you
+export type ManagedIdentifier<T, F extends keyof T> = IdentifierBrand<
+	{ field: F extends string ? F : never; type: T },
+	'ManagedIdentifier'
+>;
+
+// you can provide a value, if not, datastore generates a uuid for you
+export type OptionallyManagedIdentifier<T, F extends keyof T> = IdentifierBrand<
+	{ field: F extends string ? F : never; type: T },
+	'OptionallyManagedIdentifier'
 >;
 
+// You provide the values
+export type CompositeIdentifier<T, K extends Array<keyof T>> = IdentifierBrand<
+	{ fields: K; type: T },
+	'CompositeIdentifier'
+>;
+
+// You provide the value
+export type CustomIdentifier<T, K extends keyof T> = CompositeIdentifier<
+	T,
+	[K]
+>;
+
+export type Identifier<T> =
+	| ManagedIdentifier<T, any>
+	| OptionallyManagedIdentifier<T, any>
+	| CompositeIdentifier<T, any>
+	| CustomIdentifier<T, any>;
+
+export type IdentifierFields<
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T> = never
+> = (MetadataOrDefault<T, M>['identifier'] extends
+	| ManagedIdentifier<any, any>
+	| OptionallyManagedIdentifier<any, any>
+	? MetadataOrDefault<T, M>['identifier']['field']
+	: MetadataOrDefault<T, M>['identifier'] extends CompositeIdentifier<
+			T,
+			infer B
+	  >
+	? B[number] // B[number]
+	: MetadataOrDefault<T, M>['identifier']['field']) &
+	string;
+
+export type IdentifierFieldsForInit<
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T>
+> = MetadataOrDefault<T, M>['identifier'] extends
+	| DefaultPersistentModelMetaData
+	| ManagedIdentifier<T, any>
+	? never
+	: MetadataOrDefault<T, M>['identifier'] extends OptionallyManagedIdentifier<
+			T,
+			any
+	  >
+	? IdentifierFields<T, M>
+	: MetadataOrDefault<T, M>['identifier'] extends CompositeIdentifier<T, any>
+	? IdentifierFields<T, M>
+	: never;
+
 // Instance of model
-export type PersistentModelMetaData = {
-	readOnlyFields: string;
+export declare const __modelMeta__: unique symbol;
+
+export type PersistentModelMetaData<T> = {
+	identifier?: Identifier<T>;
+	readOnlyFields?: string;
 };
 
-export type PersistentModel = Readonly<{ id: string } & Record<string, any>>;
+export type DefaultPersistentModelMetaData = {
+	identifier: ManagedIdentifier<{ id: string }, 'id'>;
+	readOnlyFields: never;
+};
+
+export type MetadataOrDefault<
+	T extends PersistentModel,
+	_ extends PersistentModelMetaData<T> = never
+> = T extends {
+	[__modelMeta__]: PersistentModelMetaData<T>;
+}
+	? T[typeof __modelMeta__]
+	: DefaultPersistentModelMetaData;
+
+export type PersistentModel = Readonly<Record<string, any>>;
+
+export type MetadataReadOnlyFields<
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T>
+> = Extract<
+	MetadataOrDefault<T, M>['readOnlyFields'] | M['readOnlyFields'],
+	keyof T
+>;
+
+// This type omits the metadata field in the constructor init object
+// This type omits identifier fields in the constructor init object
+// This type omits readOnlyFields in the constructor init object
+// This type requires some identifiers in the constructor init object (e.g. CustomIdentifier)
+// This type makes optional some identifiers in the constructor init object (e.g. OptionallyManagedIdentifier)
 export type ModelInit<
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T> = {}
+> = Omit<
 	T,
-	K extends PersistentModelMetaData = {
-		readOnlyFields: 'createdAt' | 'updatedAt';
-	}
-> = Omit<T, 'id' | K['readOnlyFields']>;
+	typeof __modelMeta__ | IdentifierFields<T, M> | MetadataReadOnlyFields<T, M>
+> &
+	(MetadataOrDefault<T, M>['identifier'] extends OptionallyManagedIdentifier<
+		T,
+		any
+	>
+		? Partial<Pick<T, IdentifierFieldsForInit<T, M>>>
+		: Required<Pick<T, IdentifierFieldsForInit<T, M>>>);
+
 type DeepWritable<T> = {
 	-readonly [P in keyof T]: T[P] extends TypeName<T[P]>
 		? T[P]
@@ -370,22 +489,45 @@ type DeepWritable<T> = {
 };
 
 export type MutableModel<
-	T extends Record<string, any>,
-	K extends PersistentModelMetaData = {
-		readOnlyFields: 'createdAt' | 'updatedAt';
-	}
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T> = {}
 	// This provides Intellisense with ALL of the properties, regardless of read-only
 	// but will throw a linting error if trying to overwrite a read-only property
-> = DeepWritable<Omit<T, 'id' | K['readOnlyFields']>> &
-	Readonly<Pick<T, 'id' | K['readOnlyFields']>>;
+> = DeepWritable<
+	Omit<T, IdentifierFields<T, M> | MetadataReadOnlyFields<T, M>>
+> &
+	Readonly<Pick<T, IdentifierFields<T, M> | MetadataReadOnlyFields<T, M>>>;
 
 export type ModelInstanceMetadata = {
-	id: string;
 	_version: number;
 	_lastChangedAt: number;
 	_deleted: boolean;
 };
 
+export type IdentifierFieldValue<
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T>
+> = MetadataOrDefault<T, M>['identifier'] extends CompositeIdentifier<T, any>
+	? MetadataOrDefault<T, M>['identifier']['fields'] extends [any]
+		? T[MetadataOrDefault<T, M>['identifier']['fields'][0]]
+		: never
+	: T[MetadataOrDefault<T, M>['identifier']['field']];
+
+export type IdentifierFieldOrIdentifierObject<
+	T extends PersistentModel,
+	M extends PersistentModelMetaData<T>
+> = Pick<T, IdentifierFields<T, M>> | IdentifierFieldValue<T, M>;
+
+export function isIdentifierObject<T extends PersistentModel>(
+	obj: any,
+	modelDefinition: SchemaModel
+): obj is IdentifierFields<T extends PersistentModel ? T : never, any> {
+	const keys = extractPrimaryKeyFieldNames(modelDefinition);
+
+	return (
+		typeof obj === 'object' && obj && keys.every(k => obj[k] !== undefined)
+	);
+}
 //#endregion
 
 //#region Subscription messages
@@ -635,11 +777,21 @@ export type RelationType = {
 	modelName: string;
 	relationType: 'HAS_ONE' | 'HAS_MANY' | 'BELONGS_TO';
 	targetName?: string;
-	associatedWith?: string;
+	targetNames?: string[];
+	associatedWith?: string | string[];
+};
+
+type IndexOptions = {
+	unique?: boolean;
 };
 
+export type IndexesType = Array<[string, string[], IndexOptions?]>;
+
 export type RelationshipType = {
-	[modelName: string]: { indexes: string[]; relationTypes: RelationType[] };
+	[modelName: string]: {
+		indexes: IndexesType;
+		relationTypes: RelationType[];
+	};
 };
 
 //#endregion