@aws-amplify/datastore 3.14.5-unstable.2 → 3.14.5

package/src/types.ts

@@ -1,5 +1,6 @@
 import { ModelInstanceCreator } from './datastore/datastore';
 import {
+	exhaustiveCheck,
 	isAWSDate,
 	isAWSTime,
 	isAWSDateTime,
@@ -9,27 +10,18 @@ import {
 	isAWSURL,
 	isAWSPhone,
 	isAWSIPAddress,
-	NAMESPACES,
 	extractPrimaryKeyFieldNames,
 } from './util';
 import { PredicateAll } from './predicates';
 import { GRAPHQL_AUTH_MODE } from '@aws-amplify/api-graphql';
 import { Auth } from '@aws-amplify/auth';
 import { API } from '@aws-amplify/api';
-import { Cache } from '@aws-amplify/cache';
+import Cache from '@aws-amplify/cache';
 import { Adapter } from './storage/adapter';
-import {
-	ModelPredicateExtender,
-	PredicateInternalsKey,
-	ModelPredicate as V5ModelPredicate,
-} from './predicates/next';
-
-export type Scalar<T> = T extends Array<infer InnerType> ? InnerType : T;
 
 //#region Schema types
 export type Schema = UserSchema & {
 	version: string;
-	codegenVersion: string;
 };
 export type UserSchema = {
 	models: SchemaModels;
@@ -42,7 +34,6 @@ export type UserSchema = {
 export type InternalSchema = {
 	namespaces: SchemaNamespaces;
 	version: string;
-	codegenVersion: string;
 };
 export type SchemaNamespaces = Record<string, SchemaNamespace>;
 export type SchemaNamespace = UserSchema & {
@@ -77,11 +68,7 @@ type SchemaEnum = {
 	name: string;
 	values: string[];
 };
-export type ModelMeta<T extends PersistentModel> = {
-	builder: PersistentModelConstructor<T>;
-	schema: SchemaModel;
-	pkField: string[];
-};
+
 export type ModelAssociation = AssociatedWith | TargetNameAssociation;
 type AssociatedWith = {
 	connectionType: 'HAS_MANY' | 'HAS_ONE';
@@ -106,16 +93,6 @@ export function isTargetNameAssociation(
 	return obj?.targetName || obj?.targetNames;
 }
 
-type FieldAssociation = {
-	connectionType: 'HAS_ONE' | 'BELONGS_TO' | 'HAS_MANY';
-};
-export function isFieldAssociation(
-	obj: any,
-	fieldName: string
-): obj is FieldAssociation {
-	return obj?.fields[fieldName]?.association?.connectionType;
-}
-
 export type ModelAttributes = ModelAttribute[];
 export type ModelAttribute = { type: string; properties?: Record<string, any> };
 
@@ -249,7 +226,7 @@ export namespace GraphQLScalarType {
 			typeof GraphQLScalarType,
 			'getJSType' | 'getValidationFunction'
 		>
-	) {
+	): 'string' | 'number' | 'boolean' | 'object' {
 		switch (scalar) {
 			case 'Boolean':
 				return 'boolean';
@@ -270,7 +247,7 @@ export namespace GraphQLScalarType {
 			case 'AWSJSON':
 				return 'object';
 			default:
-				throw new Error('Invalid scalar type');
+				exhaustiveCheck(scalar as never);
 		}
 	}
 
@@ -279,7 +256,7 @@ export namespace GraphQLScalarType {
 			typeof GraphQLScalarType,
 			'getJSType' | 'getValidationFunction'
 		>
-	): ((val: string) => boolean) | ((val: number) => boolean) | undefined {
+	): ((val: string | number) => boolean) | undefined {
 		switch (scalar) {
 			case 'AWSDate':
 				return isAWSDate;
@@ -324,13 +301,8 @@ export function isGraphQLScalarType(
 	return obj && GraphQLScalarType[obj] !== undefined;
 }
 
-export type ModelFieldType = {
-	model: string;
-	modelConstructor?: ModelMeta<PersistentModel>;
-};
-export function isModelFieldType<T extends PersistentModel>(
-	obj: any
-): obj is ModelFieldType {
+export type ModelFieldType = { model: string };
+export function isModelFieldType(obj: any): obj is ModelFieldType {
 	const modelField: keyof ModelFieldType = 'model';
 	if (obj && obj[modelField]) return true;
 
@@ -386,24 +358,6 @@ export type PersistentModelConstructor<T extends PersistentModel> = {
 	): T;
 };
 
-/**
- * @private
- * Internal use of Amplify only.
- *
- * Indicates to use lazy models or eager models.
- */
-export declare class LazyLoadingDisabled {
-	disabled: true;
-}
-
-/**
- * @private
- * Internal use of Amplify only.
- *
- * Indicates to use lazy models or eager models.
- */
-export declare class LazyLoading {}
-
 export type TypeConstructorMap = Record<
 	string,
 	PersistentModelConstructor<any> | NonModelTypeConstructor<unknown>
@@ -485,53 +439,6 @@ export type PersistentModelMetaData<T> = {
 	readOnlyFields?: string;
 };
 
-export interface AsyncCollection<T> extends AsyncIterable<T> {
-	toArray(options?: { max?: number }): Promise<T[]>;
-}
-
-export type SettableFieldType<T> = T extends Promise<infer InnerPromiseType>
-	? undefined extends InnerPromiseType
-		? InnerPromiseType | null
-		: InnerPromiseType
-	: T extends AsyncCollection<infer InnerCollectionType>
-	? InnerCollectionType[] | undefined
-	: undefined extends T
-	? T | null
-	: T;
-
-export type PredicateFieldType<T> = NonNullable<
-	Scalar<
-		T extends Promise<infer InnerPromiseType>
-			? InnerPromiseType
-			: T extends AsyncCollection<infer InnerCollectionType>
-			? InnerCollectionType
-			: T
-	>
->;
-
-type KeysOfType<T, FilterType> = {
-	[P in keyof T]: T[P] extends FilterType ? P : never;
-}[keyof T];
-
-type KeysOfSuperType<T, FilterType> = {
-	[P in keyof T]: FilterType extends T[P] ? P : never;
-}[keyof T];
-
-type OptionalRelativesOf<T> =
-	| KeysOfType<T, AsyncCollection<any>>
-	| KeysOfSuperType<T, Promise<undefined>>;
-
-type OmitOptionalRelatives<T> = Omit<T, OptionalRelativesOf<T>>;
-type PickOptionalRelatives<T> = Pick<T, OptionalRelativesOf<T>>;
-type OmitOptionalFields<T> = Omit<
-	T,
-	KeysOfSuperType<T, undefined> | OptionalRelativesOf<T>
->;
-type PickOptionalFields<T> = Pick<
-	T,
-	KeysOfSuperType<T, undefined> | OptionalRelativesOf<T>
->;
-
 export type DefaultPersistentModelMetaData = {
 	identifier: ManagedIdentifier<{ id: string }, 'id'>;
 	readOnlyFields: never;
@@ -561,7 +468,7 @@ export type MetadataReadOnlyFields<
 // 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 ModelInitBase<
+export type ModelInit<
 	T extends PersistentModel,
 	M extends PersistentModelMetaData<T> = {}
 > = Omit<
@@ -575,26 +482,9 @@ export type ModelInitBase<
 		? Partial<Pick<T, IdentifierFieldsForInit<T, M>>>
 		: Required<Pick<T, IdentifierFieldsForInit<T, M>>>);
 
-export type ModelInit<
-	T extends PersistentModel,
-	M extends PersistentModelMetaData<T> = {}
-> = {
-	[P in keyof OmitOptionalRelatives<ModelInitBase<T, M>>]: SettableFieldType<
-		ModelInitBase<T, M>[P]
-	>;
-} & {
-	[P in keyof PickOptionalRelatives<ModelInitBase<T, M>>]+?: SettableFieldType<
-		ModelInitBase<T, M>[P]
-	>;
-};
-
 type DeepWritable<T> = {
 	-readonly [P in keyof T]: T[P] extends TypeName<T[P]>
 		? T[P]
-		: T[P] extends Promise<infer InnerPromiseType>
-		? InnerPromiseType
-		: T[P] extends AsyncCollection<infer InnerCollectionType>
-		? InnerCollectionType[] | undefined
 		: DeepWritable<T[P]>;
 };
 
@@ -863,10 +753,10 @@ export type SystemComponent = {
 		namespaceResolver: NamespaceResolver,
 		modelInstanceCreator: ModelInstanceCreator,
 		getModelConstructorByModelName: (
-			namsespaceName: NAMESPACES,
+			namsespaceName: string,
 			modelName: string
 		) => PersistentModelConstructor<any>,
-		appId?: string
+		appId: string
 	): Promise<void>;
 };
 
@@ -1000,18 +890,16 @@ syncExpressions: [
 	}),
 ]
 */
-
 type Option0 = [];
-type Option1<T extends PersistentModel> = [V5ModelPredicate<T> | undefined];
+type Option1<T extends PersistentModel> = [ModelPredicate<T> | undefined];
 type Option<T extends PersistentModel> = Option0 | Option1<T>;
 
 type Lookup<T extends PersistentModel> = {
 	0:
-		| ModelPredicateExtender<T>
-		| Promise<ModelPredicateExtender<T>>
-		| typeof PredicateAll
-		| Promise<typeof PredicateAll | symbol>;
-	1: PredicateInternalsKey | undefined;
+		| ProducerModelPredicate<T>
+		| Promise<ProducerModelPredicate<T>>
+		| typeof PredicateAll;
+	1: ModelPredicate<T> | undefined;
 };
 
 type ConditionProducer<T extends PersistentModel, A extends Option<T>> = (

package/src/util.ts

@@ -7,6 +7,7 @@ import {
 	AllOperators,
 	isPredicateGroup,
 	isPredicateObj,
+	ModelInstanceMetadata,
 	PersistentModel,
 	PersistentModelConstructor,
 	PredicateGroups,
@@ -23,7 +24,6 @@ import {
 	isModelAttributePrimaryKey,
 	isModelAttributeCompositeKey,
 	NonModelTypeConstructor,
-	PaginationInput,
 	DeferredCallbackResolverOptions,
 	LimitTimerRaceResolvedValues,
 	SchemaModel,
@@ -32,7 +32,6 @@ import {
 	ModelAssociation,
 } from './types';
 import { WordArray } from 'amazon-cognito-identity-js';
-import { ModelSortPredicateCreator } from './predicates';
 
 export const ID = 'id';
 
@@ -111,7 +110,7 @@ export const validatePredicate = <T extends PersistentModel>(
 			filterType = 'some';
 			break;
 		default:
-			throw new Error(`Invalid ${groupType}`);
+			exhaustiveCheck(groupType);
 	}
 
 	const result: boolean = predicatesOrGroups[filterType](predicateOrGroup => {
@@ -170,6 +169,7 @@ export const validatePredicateField = <T>(
 				(<string>(<unknown>value)).indexOf(<string>(<unknown>operand)) === -1
 			);
 		default:
+			exhaustiveCheck(operator, false);
 			return false;
 	}
 };
@@ -202,22 +202,155 @@ export const traverseModel = <T extends PersistentModel>(
 	namespace: SchemaNamespace,
 	modelInstanceCreator: ModelInstanceCreator,
 	getModelConstructorByModelName: (
-		namsespaceName: NAMESPACES,
+		namsespaceName: string,
 		modelName: string
 	) => PersistentModelConstructor<any>
 ) => {
+	const relationships = namespace.relationships;
+
 	const modelConstructor = getModelConstructorByModelName(
-		namespace.name as NAMESPACES,
+		namespace.name,
 		srcModelName
 	);
 
+	const relation = relationships[srcModelName];
+
 	const result: {
 		modelName: string;
 		item: T;
 		instance: T;
 	}[] = [];
 
-	const newInstance = modelConstructor.copyOf(instance, () => {});
+	const newInstance = modelConstructor.copyOf(instance, draftInstance => {
+		relation.relationTypes.forEach((rItem: RelationType) => {
+			const modelConstructor = getModelConstructorByModelName(
+				namespace.name,
+				rItem.modelName
+			);
+
+			switch (rItem.relationType) {
+				case 'HAS_ONE':
+					if (instance[rItem.fieldName]) {
+						let modelInstance: T;
+						try {
+							modelInstance = modelInstanceCreator(
+								modelConstructor,
+								instance[rItem.fieldName]
+							);
+						} catch (error) {
+							// Do nothing
+							console.log(error);
+						}
+
+						result.push({
+							modelName: rItem.modelName,
+							item: instance[rItem.fieldName],
+							instance: modelInstance,
+						});
+
+						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 (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]
+							)).id;
+						}
+					}
+
+					break;
+				case 'BELONGS_TO':
+					if (instance[rItem.fieldName]) {
+						let modelInstance: T;
+						try {
+							modelInstance = modelInstanceCreator(
+								modelConstructor,
+								instance[rItem.fieldName]
+							);
+						} catch (error) {
+							// Do nothing
+						}
+
+						const isDeleted = (<ModelInstanceMetadata>(
+							draftInstance[rItem.fieldName]
+						))._deleted;
+
+						if (!isDeleted) {
+							result.push({
+								modelName: rItem.modelName,
+								item: instance[rItem.fieldName],
+								instance: modelInstance,
+							});
+						}
+					}
+
+					if (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;
+				case 'HAS_MANY':
+					// Intentionally blank
+					break;
+				default:
+					exhaustiveCheck(rItem.relationType);
+					break;
+			}
+		});
+	});
 
 	result.unshift({
 		modelName: srcModelName,
@@ -228,7 +361,7 @@ export const traverseModel = <T extends PersistentModel>(
 	if (!topologicallySortedModels.has(namespace)) {
 		topologicallySortedModels.set(
 			namespace,
-			Array.from(namespace.modelTopologicalOrdering!.keys())
+			Array.from(namespace.modelTopologicalOrdering.keys())
 		);
 	}
 
@@ -236,7 +369,7 @@ export const traverseModel = <T extends PersistentModel>(
 
 	result.sort((a, b) => {
 		return (
-			sortedModels!.indexOf(a.modelName) - sortedModels!.indexOf(b.modelName)
+			sortedModels.indexOf(a.modelName) - sortedModels.indexOf(b.modelName)
 		);
 	});
 
@@ -485,8 +618,8 @@ export function valuesEqual(
 	}
 
 	if (a instanceof Map && b instanceof Map) {
-		a = (Object as any).fromEntries(a);
-		b = (Object as any).fromEntries(b);
+		a = Object.fromEntries(a);
+		b = Object.fromEntries(b);
 	}
 
 	const aKeys = Object.keys(a);
@@ -514,97 +647,6 @@ export function valuesEqual(
 	return true;
 }
 
-/**
- * Statelessly extracts the specified page from an array.
- *
- * @param records - The source array to extract a page from.
- * @param pagination - A definition of the page to extract.
- * @returns This items from `records` matching the `pagination` definition.
- */
-export function inMemoryPagination<T extends PersistentModel>(
-	records: T[],
-	pagination?: PaginationInput<T>
-): T[] {
-	if (pagination && records.length > 1) {
-		if (pagination.sort) {
-			const sortPredicates = ModelSortPredicateCreator.getPredicates(
-				pagination.sort
-			);
-
-			if (sortPredicates.length) {
-				const compareFn = sortCompareFunction(sortPredicates);
-				records.sort(compareFn);
-			}
-		}
-		const { page = 0, limit = 0 } = pagination;
-		const start = Math.max(0, page * limit) || 0;
-
-		const end = limit > 0 ? start + limit : records.length;
-
-		return records.slice(start, end);
-	}
-	return records;
-}
-
-/**
- * An `aysnc` implementation of `Array.some()`. Returns as soon as a match is found.
- * @param items The items to check.
- * @param matches The async matcher function, expected to
- * return Promise<boolean>: `true` for a matching item, `false` otherwise.
- * @returns A `Promise<boolean>`, `true` if "some" items match; `false` otherwise.
- */
-export async function asyncSome(
-	items: Record<string, any>[],
-	matches: (item: Record<string, any>) => Promise<boolean>
-): Promise<boolean> {
-	for (const item of items) {
-		if (await matches(item)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * An `aysnc` implementation of `Array.every()`. Returns as soon as a non-match is found.
- * @param items The items to check.
- * @param matches The async matcher function, expected to
- * return Promise<boolean>: `true` for a matching item, `false` otherwise.
- * @returns A `Promise<boolean>`, `true` if every item matches; `false` otherwise.
- */
-export async function asyncEvery(
-	items: Record<string, any>[],
-	matches: (item: Record<string, any>) => Promise<boolean>
-): Promise<boolean> {
-	for (const item of items) {
-		if (!(await matches(item))) {
-			return false;
-		}
-	}
-	return true;
-}
-
-/**
- * An `async` implementation of `Array.filter()`. Returns after all items have been filtered.
- * TODO: Return AsyncIterable.
- * @param items The items to filter.
- * @param matches The `async` matcher function, expected to
- * return Promise<boolean>: `true` for a matching item, `false` otherwise.
- * @returns A `Promise<T>` of matching items.
- */
-export async function asyncFilter<T>(
-	items: T[],
-	matches: (item: T) => Promise<boolean>
-): Promise<T[]> {
-	const results: T[] = [];
-	for (const item of items) {
-		if (await matches(item)) {
-			results.push(item);
-		}
-	}
-	return results;
-}
-
 export const isAWSDate = (val: string): boolean => {
 	return !!/^\d{4}-\d{2}-\d{2}(Z|[+-]\d{2}:\d{2}($|:\d{2}))?$/.exec(val);
 };
@@ -719,7 +761,7 @@ export class DeferredCallbackResolver {
 			this.raceInFlight = false;
 			this.limitPromise = new DeferredPromise();
 
-			return winner!;
+			return winner;
 		}
 	}
 
@@ -769,7 +811,7 @@ export function mergePatches<T>(
 			patches = p;
 		}
 	);
-	return patches!;
+	return patches;
 }
 
 export const getStorename = (namespace: string, modelName: string) => {
@@ -945,14 +987,14 @@ export const establishRelationAndKeys = (
 				typeof fieldAttribute.type === 'object' &&
 				'model' in fieldAttribute.type
 			) {
-				const connectionType = fieldAttribute.association!.connectionType;
+				const connectionType = fieldAttribute.association.connectionType;
 				relationship[mKey].relationTypes.push({
 					fieldName: fieldAttribute.name,
 					modelName: fieldAttribute.type.model,
 					relationType: connectionType,
-					targetName: fieldAttribute.association!['targetName'],
-					targetNames: fieldAttribute.association!['targetNames'],
-					associatedWith: fieldAttribute.association!['associatedWith'],
+					targetName: fieldAttribute.association['targetName'],
+					targetNames: fieldAttribute.association['targetNames'],
+					associatedWith: fieldAttribute.association['associatedWith'],
 				});
 
 				if (connectionType === 'BELONGS_TO') {
@@ -1088,7 +1130,7 @@ export const getIndexKeys = (
 	namespace: SchemaNamespace,
 	modelName: string
 ): string[] => {
-	const keyPath = namespace?.keys?.[modelName]?.primaryKey;
+	const keyPath = namespace?.keys[modelName]?.primaryKey;
 
 	if (keyPath) {
 		return keyPath;

package/webpack.config.dev.js

@@ -0,0 +1,6 @@
+var config = require('./webpack.config.js');
+
+var entry = {
+	'aws-amplify-datastore': './lib-esm/index.js',
+};
+module.exports = Object.assign(config, { entry, mode: 'development' });

package/lib/authModeStrategies/defaultAuthStrategy.d.ts

@@ -1,2 +0,0 @@
-import { AuthModeStrategy } from '../types';
-export declare const defaultAuthStrategy: AuthModeStrategy;

package/lib/authModeStrategies/index.d.ts

@@ -1,2 +0,0 @@
-export { defaultAuthStrategy } from './defaultAuthStrategy';
-export { multiAuthStrategy } from './multiAuthStrategy';

package/lib/authModeStrategies/multiAuthStrategy.d.ts

@@ -1,13 +0,0 @@
-import { AuthModeStrategy, AmplifyContext } from '../types';
-/**
- * Returns an array of auth modes to try based on the schema, model, and
- * authenticated user (or lack thereof). Rules are sourced from `getAuthRules`
- * and returned in the order they ought to be attempted.
- *
- * @see sortAuthRulesWithPriority
- * @see getAuthRules
- *
- * @param param0 The `{schema, modelName}` to inspect.
- * @returns A sorted array of auth modes to attempt.
- */
-export declare const multiAuthStrategy: (amplifyContext: AmplifyContext) => AuthModeStrategy;