@aws-amplify/datastore 3.7.3 → 3.7.4-custom-pk.86

package/src/util.ts

@@ -1,9 +1,11 @@
 import { Buffer } from 'buffer';
 import { monotonicFactory, ULID } from 'ulid';
 import { v4 as uuid } from 'uuid';
+import { produce, applyPatches, Patch } from 'immer';
 import { ModelInstanceCreator } from './datastore/datastore';
 import {
 	AllOperators,
+	ProducerModelPredicate,
 	isPredicateGroup,
 	isPredicateObj,
 	ModelInstanceMetadata,
@@ -25,9 +27,96 @@ import {
 	NonModelTypeConstructor,
 	DeferredCallbackResolverOptions,
 	LimitTimerRaceResolvedValues,
+	SchemaModel,
+	ModelAttribute,
+	IndexesType,
 } from './types';
 import { WordArray } from 'amazon-cognito-identity-js';
 
+const ID = 'id';
+
+export const errorMessages = {
+	idEmptyString: 'An index field cannot contain an empty string value',
+};
+
+export function extractKeyIfExists(
+	modelDefinition: SchemaModel
+): ModelAttribute | undefined {
+	const keyAttribute = modelDefinition?.attributes?.find(isModelAttributeKey);
+
+	return keyAttribute;
+}
+
+export function extractPrimaryKeyFieldNames(
+	modelDefinition: SchemaModel
+): string[] {
+	const keyAttribute = extractKeyIfExists(modelDefinition);
+	if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
+		return keyAttribute.properties.fields;
+	}
+
+	return [ID];
+}
+
+export function extractPrimaryKeyValues<T extends PersistentModel>(
+	model: T,
+	keyFields: string[]
+): string[] {
+	return keyFields.map(key => model[key]);
+}
+
+export function extractPrimaryKeysAndValues<T extends PersistentModel>(
+	model: T,
+	keyFields: string[]
+): any {
+	const primaryKeysAndValues = {};
+	keyFields.forEach(key => (primaryKeysAndValues[key] = model[key]));
+	return primaryKeysAndValues;
+}
+
+// IdentifierFields<ManagedIdentifier>
+// Default behavior without explicit @primaryKey defined
+export function isIdManaged(modelDefinition: SchemaModel): boolean {
+	const keyAttribute = extractKeyIfExists(modelDefinition);
+
+	if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
+		return false;
+	}
+
+	return true;
+}
+
+// IdentifierFields<OptionallyManagedIdentifier>
+// @primaryKey with explicit `id` in the PK. Single key or composite
+export function isIdOptionallyManaged(modelDefinition: SchemaModel): boolean {
+	const keyAttribute = extractKeyIfExists(modelDefinition);
+
+	if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
+		// const idInKey = !!keyAttribute.properties.fields.find(
+		// 	field => field === ID
+		// );
+		// return idInKey && keyAttribute.properties.fields.length === 1;
+		return keyAttribute.properties.fields[0] === ID;
+	}
+
+	return false;
+}
+
+export enum NAMESPACES {
+	DATASTORE = 'datastore',
+	USER = 'user',
+	SYNC = 'sync',
+	STORAGE = 'storage',
+}
+
+const DATASTORE = NAMESPACES.DATASTORE;
+const USER = NAMESPACES.USER;
+const SYNC = NAMESPACES.SYNC;
+const STORAGE = NAMESPACES.STORAGE;
+
+export { USER, SYNC, STORAGE, DATASTORE };
+export const USER_AGENT_SUFFIX_DATASTORE = '/DataStore';
+
 export const exhaustiveCheck = (obj: never, throwOnError: boolean = true) => {
 	if (throwOnError) {
 		throw new Error(`Invalid ${obj}`);
@@ -146,7 +235,7 @@ export const isNonModelConstructor = (
 	return nonModelClasses.has(obj);
 };
 
-/* 
+/*
   When we have GSI(s) with composite sort keys defined on a model
 	There are some very particular rules regarding which fields must be included in the update mutation input
 	The field selection becomes more complex as the number of GSIs with composite sort keys grows
@@ -156,7 +245,7 @@ export const isNonModelConstructor = (
 	 2. all of the fields from any other composite sort key that intersect with the fields from 1.
 
 	 E.g.,
-	 Model @model 
+	 Model @model
 		@key(name: 'key1' fields: ['hk', 'a', 'b', 'c'])
 		@key(name: 'key2' fields: ['hk', 'a', 'b', 'd'])
 		@key(name: 'key3' fields: ['hk', 'x', 'y', 'z'])
@@ -192,7 +281,7 @@ export const processCompositeKeys = (
 		.filter(isModelAttributeCompositeKey)
 		.map(extractCompositeSortKey);
 
-	/* 
+	/*
 		if 2 sets of fields have any intersecting fields => combine them into 1 union set
 		e.g., ['a', 'b', 'c'] and ['a', 'b', 'd'] => ['a', 'b', 'c', 'd']
 	*/
@@ -256,13 +345,19 @@ export const establishRelationAndKeys = (
 					modelName: fieldAttribute.type.model,
 					relationType: connectionType,
 					targetName: fieldAttribute.association['targetName'],
+					targetNames: fieldAttribute.association['targetNames'],
 					associatedWith: fieldAttribute.association['associatedWith'],
 				});
 
 				if (connectionType === 'BELONGS_TO') {
-					relationship[mKey].indexes.push(
-						fieldAttribute.association['targetName']
+					const targetNames = extractTargetNamesFromSrc(
+						fieldAttribute.association
 					);
+
+					if (targetNames) {
+						const idxName = indexNameFromKeys(targetNames);
+						relationship[mKey].indexes.push([idxName, targetNames]);
+					}
 				}
 			}
 		});
@@ -275,20 +370,36 @@ export const establishRelationAndKeys = (
 					continue;
 				}
 
+				const { fields } = attribute.properties;
+
 				if (isModelAttributePrimaryKey(attribute)) {
-					keys[mKey].primaryKey = attribute.properties.fields;
+					keys[mKey].primaryKey = fields;
+					continue;
 				}
 
-				const { fields } = attribute.properties;
-				for (const field of fields) {
-					// only add index if it hasn't already been added
-					const exists = relationship[mKey].indexes.includes(field);
-					if (!exists) {
-						relationship[mKey].indexes.push(field);
-					}
+				// create indexes for all other keys
+				const idxName = indexNameFromKeys(fields);
+				const idxExists = relationship[mKey].indexes.find(
+					([index]) => index === idxName
+				);
+
+				if (!idxExists) {
+					relationship[mKey].indexes.push([idxName, fields]);
 				}
 			}
 		}
+
+		// set 'id' as the PK for models without a custom PK explicitly defined
+		if (!keys[mKey].primaryKey) {
+			keys[mKey].primaryKey = [ID];
+		}
+
+		// create primary index
+		relationship[mKey].indexes.push([
+			'byPk',
+			keys[mKey].primaryKey as string[],
+			{ unique: true },
+		]);
 	});
 
 	return [relationship, keys];
@@ -307,12 +418,14 @@ export const traverseModel = <T extends PersistentModel>(
 	) => PersistentModelConstructor<any>
 ) => {
 	const relationships = namespace.relationships;
+
 	const modelConstructor = getModelConstructorByModelName(
 		namespace.name,
 		srcModelName
 	);
 
 	const relation = relationships[srcModelName];
+
 	const result: {
 		modelName: string;
 		item: T;
@@ -346,15 +459,36 @@ export const traverseModel = <T extends PersistentModel>(
 							instance: modelInstance,
 						});
 
-						// targetName will be defined for Has One if feature flag
+						const targetNames: string[] | undefined =
+							extractTargetNamesFromSrc(rItem);
+
+						// `targetName` will be defined for Has One if feature flag
 						// https://docs.amplify.aws/cli/reference/feature-flags/#useAppsyncModelgenPlugin
 						// is true (default as of 5/7/21)
 						// Making this conditional for backward-compatibility
-						if (rItem.targetName) {
-							(<any>draftInstance)[rItem.targetName] = (<PersistentModel>(
-								draftInstance[rItem.fieldName]
-							)).id;
-							delete draftInstance[rItem.fieldName];
+						if (targetNames) {
+							targetNames.forEach((targetName, idx) => {
+								// Get the connected record
+								const relatedRecordInProxy = <PersistentModel>(
+									draftInstance[rItem.fieldName]
+								);
+
+								// Previously, we used the hardcoded 'id' as they key,
+								// now we need the value of the key to get the PK (and SK)
+								// values from the related record
+
+								const { primaryKey } = namespace.keys[modelConstructor.name];
+								const keyField = primaryKey && primaryKey[idx];
+
+								// Get the value
+								const relatedRecordInProxyPkValue =
+									relatedRecordInProxy[keyField];
+
+								// Set the targetName value
+								(<any>draftInstance)[targetName] = relatedRecordInProxyPkValue;
+							});
+							// Delete the instance from the proxy
+							delete (<any>draftInstance)[rItem.fieldName];
 						} else {
 							(<any>draftInstance)[rItem.fieldName] = (<PersistentModel>(
 								draftInstance[rItem.fieldName]
@@ -389,10 +523,33 @@ export const traverseModel = <T extends PersistentModel>(
 					}
 
 					if (draftInstance[rItem.fieldName]) {
-						(<any>draftInstance)[rItem.targetName] = (<PersistentModel>(
-							draftInstance[rItem.fieldName]
-						)).id;
-						delete draftInstance[rItem.fieldName];
+						const targetNames: string[] | undefined =
+							extractTargetNamesFromSrc(rItem);
+
+						if (targetNames) {
+							targetNames.forEach((targetName, idx) => {
+								// Get the connected record
+								const relatedRecordInProxy = <PersistentModel>(
+									draftInstance[rItem.fieldName]
+								);
+								// Previously, we used the hardcoded `id` for the key.
+								// Now, we need the value of the key to get the PK (and SK)
+								// values from the related record
+								const { primaryKey } = namespace.keys[modelConstructor.name];
+
+								// fall back to ID if
+								const keyField = primaryKey && primaryKey[idx];
+
+								// Get the value
+								const relatedRecordInProxyPkValue =
+									relatedRecordInProxy[keyField];
+
+								// Set the targetName value
+								(<any>draftInstance)[targetName] = relatedRecordInProxyPkValue;
+							});
+							// Delete the instance from the proxy
+							delete (<any>draftInstance)[rItem.fieldName];
+						}
 					}
 
 					break;
@@ -430,7 +587,7 @@ export const traverseModel = <T extends PersistentModel>(
 	return result;
 };
 
-export const getIndex = (rel: RelationType[], src: string): string => {
+export const getIndex = (rel: RelationType[], src: any): string | undefined => {
 	let index = '';
 	rel.some((relItem: RelationType) => {
 		if (relItem.modelName === src) {
@@ -441,26 +598,20 @@ export const getIndex = (rel: RelationType[], src: string): string => {
 };
 
 export const getIndexFromAssociation = (
-	indexes: string[],
-	src: string
-): string => {
-	const index = indexes.find(idx => idx === src);
-	return index;
-};
-
-export enum NAMESPACES {
-	DATASTORE = 'datastore',
-	USER = 'user',
-	SYNC = 'sync',
-	STORAGE = 'storage',
-}
+	indexes: IndexesType,
+	src: string | string[]
+): string | undefined => {
+	let indexName: string;
 
-const DATASTORE = NAMESPACES.DATASTORE;
-const USER = NAMESPACES.USER;
-const SYNC = NAMESPACES.SYNC;
-const STORAGE = NAMESPACES.STORAGE;
+	if (Array.isArray(src)) {
+		indexName = indexNameFromKeys(src);
+	} else {
+		indexName = src;
+	}
 
-export { USER, SYNC, STORAGE, DATASTORE };
+	const associationIndex = indexes.find(([idxName]) => idxName === indexName);
+	return associationIndex && associationIndex[0];
+};
 
 let privateModeCheckResult;
 
@@ -773,3 +924,66 @@ export class DeferredCallbackResolver {
 		this.limitPromise.resolve(LimitTimerRaceResolvedValues.LIMIT);
 	}
 }
+
+/**
+ * merge two sets of patches created by immer produce.
+ * newPatches take precedent over oldPatches for patches modifying the same path.
+ * In the case many consecutive pathces are merged the original model should
+ * always be the root model.
+ *
+ * Example:
+ * A -> B, patches1
+ * B -> C, patches2
+ *
+ * mergePatches(A, patches1, patches2) to get patches for A -> C
+ *
+ * @param originalSource the original Model the patches should be applied to
+ * @param oldPatches immer produce patch list
+ * @param newPatches immer produce patch list (will take precedence)
+ * @return merged patches
+ */
+export function mergePatches<T>(
+	originalSource: T,
+	oldPatches: Patch[],
+	newPatches: Patch[]
+): Patch[] {
+	const patchesToMerge = oldPatches.concat(newPatches);
+	let patches: Patch[];
+	produce(
+		originalSource,
+		draft => {
+			applyPatches(draft, patchesToMerge);
+		},
+		p => {
+			patches = p;
+		}
+	);
+	return patches;
+}
+
+/* Backwards-compatability for schema generated prior to custom primary key support:
+the single field `targetName` has been replaced with an array of `targetNames`
+*/
+export function extractTargetNamesFromSrc(src: any): string[] | undefined {
+	const targetName = src?.targetName;
+	const targetNames = src?.targetNames;
+
+	if (Array.isArray(targetNames) && targetNames?.length) {
+		return targetNames;
+	} else if (typeof targetName === 'string') {
+		return [targetName];
+	} else {
+		return undefined;
+	}
+}
+
+// Generates snake-cased index name from an aray of key field names
+// E.g. for keys `[id, title]` => 'id-title'
+export function indexNameFromKeys(keys: string[]): string {
+	return keys.reduce((prev: string, cur: string, idx: number) => {
+		if (idx === 0) {
+			return cur;
+		}
+		return `${prev}-${cur}`;
+	}, '');
+}

package/ssr/package.json

@@ -5,4 +5,4 @@
 	"react-native": {
 		"../lib/ssr/index": "../lib-esm/ssr/index.js"
 	}
-}
+}