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

package/src/types.ts

@@ -1,6 +1,5 @@
 import { ModelInstanceCreator } from './datastore/datastore';
 import {
-	exhaustiveCheck,
 	isAWSDate,
 	isAWSTime,
 	isAWSDateTime,
@@ -10,18 +9,27 @@ 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;
@@ -34,6 +42,7 @@ export type UserSchema = {
 export type InternalSchema = {
 	namespaces: SchemaNamespaces;
 	version: string;
+	codegenVersion: string;
 };
 export type SchemaNamespaces = Record<string, SchemaNamespace>;
 export type SchemaNamespace = UserSchema & {
@@ -68,7 +77,11 @@ 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';
@@ -93,6 +106,16 @@ 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> };
 
@@ -226,7 +249,7 @@ export namespace GraphQLScalarType {
 			typeof GraphQLScalarType,
 			'getJSType' | 'getValidationFunction'
 		>
-	): 'string' | 'number' | 'boolean' | 'object' {
+	) {
 		switch (scalar) {
 			case 'Boolean':
 				return 'boolean';
@@ -247,7 +270,7 @@ export namespace GraphQLScalarType {
 			case 'AWSJSON':
 				return 'object';
 			default:
-				exhaustiveCheck(scalar as never);
+				throw new Error('Invalid scalar type');
 		}
 	}
 
@@ -256,7 +279,7 @@ export namespace GraphQLScalarType {
 			typeof GraphQLScalarType,
 			'getJSType' | 'getValidationFunction'
 		>
-	): ((val: string | number) => boolean) | undefined {
+	): ((val: string) => boolean) | ((val: number) => boolean) | undefined {
 		switch (scalar) {
 			case 'AWSDate':
 				return isAWSDate;
@@ -301,8 +324,13 @@ export function isGraphQLScalarType(
 	return obj && GraphQLScalarType[obj] !== undefined;
 }
 
-export type ModelFieldType = { model: string };
-export function isModelFieldType(obj: any): obj is ModelFieldType {
+export type ModelFieldType = {
+	model: string;
+	modelConstructor?: ModelMeta<PersistentModel>;
+};
+export function isModelFieldType<T extends PersistentModel>(
+	obj: any
+): obj is ModelFieldType {
 	const modelField: keyof ModelFieldType = 'model';
 	if (obj && obj[modelField]) return true;
 
@@ -358,6 +386,24 @@ 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>
@@ -439,6 +485,53 @@ 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;
@@ -468,7 +561,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 ModelInit<
+export type ModelInitBase<
 	T extends PersistentModel,
 	M extends PersistentModelMetaData<T> = {}
 > = Omit<
@@ -482,9 +575,26 @@ export type ModelInit<
 		? 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]>;
 };
 
@@ -753,10 +863,10 @@ export type SystemComponent = {
 		namespaceResolver: NamespaceResolver,
 		modelInstanceCreator: ModelInstanceCreator,
 		getModelConstructorByModelName: (
-			namsespaceName: string,
+			namsespaceName: NAMESPACES,
 			modelName: string
 		) => PersistentModelConstructor<any>,
-		appId: string
+		appId?: string
 	): Promise<void>;
 };
 
@@ -890,16 +1000,18 @@ syncExpressions: [
 	}),
 ]
 */
+
 type Option0 = [];
-type Option1<T extends PersistentModel> = [ModelPredicate<T> | undefined];
+type Option1<T extends PersistentModel> = [V5ModelPredicate<T> | undefined];
 type Option<T extends PersistentModel> = Option0 | Option1<T>;
 
 type Lookup<T extends PersistentModel> = {
 	0:
-		| ProducerModelPredicate<T>
-		| Promise<ProducerModelPredicate<T>>
-		| typeof PredicateAll;
-	1: ModelPredicate<T> | undefined;
+		| ModelPredicateExtender<T>
+		| Promise<ModelPredicateExtender<T>>
+		| typeof PredicateAll
+		| Promise<typeof PredicateAll | symbol>;
+	1: PredicateInternalsKey | undefined;
 };
 
 type ConditionProducer<T extends PersistentModel, A extends Option<T>> = (

package/src/util.ts

@@ -7,7 +7,6 @@ import {
 	AllOperators,
 	isPredicateGroup,
 	isPredicateObj,
-	ModelInstanceMetadata,
 	PersistentModel,
 	PersistentModelConstructor,
 	PredicateGroups,
@@ -24,6 +23,7 @@ import {
 	isModelAttributePrimaryKey,
 	isModelAttributeCompositeKey,
 	NonModelTypeConstructor,
+	PaginationInput,
 	DeferredCallbackResolverOptions,
 	LimitTimerRaceResolvedValues,
 	SchemaModel,
@@ -32,6 +32,7 @@ import {
 	ModelAssociation,
 } from './types';
 import { WordArray } from 'amazon-cognito-identity-js';
+import { ModelSortPredicateCreator } from './predicates';
 
 export const ID = 'id';
 
@@ -110,7 +111,7 @@ export const validatePredicate = <T extends PersistentModel>(
 			filterType = 'some';
 			break;
 		default:
-			exhaustiveCheck(groupType);
+			throw new Error(`Invalid ${groupType}`);
 	}
 
 	const result: boolean = predicatesOrGroups[filterType](predicateOrGroup => {
@@ -169,7 +170,6 @@ export const validatePredicateField = <T>(
 				(<string>(<unknown>value)).indexOf(<string>(<unknown>operand)) === -1
 			);
 		default:
-			exhaustiveCheck(operator, false);
 			return false;
 	}
 };
@@ -202,155 +202,22 @@ export const traverseModel = <T extends PersistentModel>(
 	namespace: SchemaNamespace,
 	modelInstanceCreator: ModelInstanceCreator,
 	getModelConstructorByModelName: (
-		namsespaceName: string,
+		namsespaceName: NAMESPACES,
 		modelName: string
 	) => PersistentModelConstructor<any>
 ) => {
-	const relationships = namespace.relationships;
-
 	const modelConstructor = getModelConstructorByModelName(
-		namespace.name,
+		namespace.name as NAMESPACES,
 		srcModelName
 	);
 
-	const relation = relationships[srcModelName];
-
 	const result: {
 		modelName: string;
 		item: T;
 		instance: T;
 	}[] = [];
 
-	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;
-			}
-		});
-	});
+	const newInstance = modelConstructor.copyOf(instance, () => {});
 
 	result.unshift({
 		modelName: srcModelName,
@@ -361,7 +228,7 @@ export const traverseModel = <T extends PersistentModel>(
 	if (!topologicallySortedModels.has(namespace)) {
 		topologicallySortedModels.set(
 			namespace,
-			Array.from(namespace.modelTopologicalOrdering.keys())
+			Array.from(namespace.modelTopologicalOrdering!.keys())
 		);
 	}
 
@@ -369,7 +236,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)
 		);
 	});
 
@@ -618,8 +485,8 @@ export function valuesEqual(
 	}
 
 	if (a instanceof Map && b instanceof Map) {
-		a = Object.fromEntries(a);
-		b = Object.fromEntries(b);
+		a = (Object as any).fromEntries(a);
+		b = (Object as any).fromEntries(b);
 	}
 
 	const aKeys = Object.keys(a);
@@ -647,6 +514,97 @@ 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);
 };
@@ -761,7 +719,7 @@ export class DeferredCallbackResolver {
 			this.raceInFlight = false;
 			this.limitPromise = new DeferredPromise();
 
-			return winner;
+			return winner!;
 		}
 	}
 
@@ -811,7 +769,7 @@ export function mergePatches<T>(
 			patches = p;
 		}
 	);
-	return patches;
+	return patches!;
 }
 
 export const getStorename = (namespace: string, modelName: string) => {
@@ -987,14 +945,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') {
@@ -1130,7 +1088,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/build.js

@@ -1,5 +0,0 @@
-'use strict';
-
-const build = require('../../scripts/build');
-
-build(process.argv[2], process.argv[3]);