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

package/src/storage/relationship.ts

@@ -0,0 +1,272 @@
+import { isFieldAssociation, ModelFieldType, ModelMeta } from '../types';
+
+/**
+ * Defines a relationship from a LOCAL model.field to a REMOTE model.field and helps
+ * navigate the relationship, providing a simplified peek at the relationship details
+ * pertinent to setting FK's and constructing join conditions.
+ *
+ * Because I mean, relationships are tough.
+ *
+ */
+export class ModelRelationship<T> {
+	private localModel: ModelMeta<T>;
+	private _field: string;
+
+	/**
+	 * @param modelDefinition The "local" model.
+	 * @param field The "local" model field.
+	 */
+	constructor(model: ModelMeta<T>, field: string) {
+		if (!isFieldAssociation(model.schema, field)) {
+			throw new Error(`${model.schema.name}.${field} is not a relationship.`);
+		}
+		this.localModel = model;
+		this._field = field;
+	}
+
+	/**
+	 * Returns a ModelRelationship for the the given model and field if the pair
+	 * indicates a relationship to another model. Else, returns `null`.
+	 *
+	 * @param model The model the relationship field exists in.
+	 * @param field The field that may relates the local model to the remote model.
+	 */
+	static from<T>(model: ModelMeta<T>, field: string) {
+		if (isFieldAssociation(model.schema, field)) {
+			return new this(model, field);
+		} else {
+			return null;
+		}
+	}
+
+	/**
+	 * Enumerates all valid `ModelRelationship`'s on the given model.
+	 *
+	 * @param model The model definition to enumerate relationships of.
+	 */
+	static allFrom<T>(model: ModelMeta<T>) {
+		const relationships: ModelRelationship<T>[] = [];
+		for (const field of Object.keys(model.schema.fields)) {
+			const relationship = ModelRelationship.from(model, field);
+			relationship && relationships.push(relationship);
+		}
+		return relationships;
+	}
+
+	private get localDefinition() {
+		return this.localModel.schema;
+	}
+
+	/**
+	 * The virtual/computed field on the local model that should contain
+	 * the related model.
+	 */
+	get field() {
+		return this._field;
+	}
+
+	/**
+	 * The constructor that can be used to query DataStore or create instance for
+	 * the local model.
+	 */
+	get localConstructor() {
+		return this.localModel.builder;
+	}
+
+	/**
+	 * The name/type of the relationship the local model has with the remote model
+	 * via the defined local model field.
+	 */
+	get type() {
+		return this.localAssocation.connectionType;
+	}
+
+	/**
+	 * Raw details about the local FK as-is from the local model's field definition in
+	 * the schema. This field requires interpretation.
+	 *
+	 * @see localJoinFields
+	 * @see localAssociatedWith
+	 */
+	private get localAssocation() {
+		return this.localDefinition.fields[this.field].association!;
+	}
+
+	/**
+	 * The field names on the local model that can be used to query or queried to match
+	 * with instances of the remote model.
+	 *
+	 * Fields are returned in-order to match the order of `this.remoteKeyFields`.
+	 */
+	get localJoinFields() {
+		/**
+		 * This is relatively straightforward, actually.
+		 *
+		 * If we have explicitly stated targetNames, codegen is telling us authoritatively
+		 * to use those fields for this relationship. The local model "points to" fields
+		 * in the remote one.
+		 *
+		 * In other cases, the remote model points to this one's
+		 */
+		if (this.localAssocation.targetName) {
+			// This case is theoretically unnecessary going forward.
+			return [this.localAssocation.targetName];
+		} else if (this.localAssocation.targetNames) {
+			return this.localAssocation.targetNames;
+		} else {
+			return this.localPKFields;
+		}
+	}
+
+	/**
+	 * The field names on the local model that uniquely identify it.
+	 *
+	 * These fields may or may not be relevant to the join fields.
+	 */
+	get localPKFields() {
+		return this.localModel.pkField;
+	}
+
+	get remoteDefinition() {
+		return this.remoteModelType.modelConstructor?.schema;
+	}
+
+	private get remoteModelType() {
+		return this.localDefinition.fields[this.field].type as ModelFieldType;
+	}
+
+	/**
+	 * Constructor that can be used to query DataStore or create instances for
+	 * the remote model.
+	 */
+	get remoteModelConstructor() {
+		return this.remoteModelType.modelConstructor!.builder!;
+	}
+
+	/**
+	 * The field names on the remote model that uniquely identify it.
+	 *
+	 * These fields may or may not be relevant to the join fields.
+	 */
+	get remotePKFields() {
+		return this.remoteModelType.modelConstructor?.pkField || ['id'];
+	}
+
+	/**
+	 * The `associatedWith` fields from the local perspective.
+	 *
+	 * When present, these fields indicate which fields on the remote model to use
+	 * when looking for a remote association and/or determining the final remote
+	 * key fields.
+	 */
+	private get localAssociatedWith() {
+		if (
+			this.localAssocation.connectionType === 'HAS_MANY' ||
+			this.localAssocation.connectionType === 'HAS_ONE'
+		) {
+			// This de-arraying is theoretically unnecessary going forward.
+			return Array.isArray(this.localAssocation.associatedWith)
+				? this.localAssocation.associatedWith
+				: [this.localAssocation.associatedWith];
+		} else {
+			return undefined;
+		}
+	}
+
+	private get explicitRemoteAssociation() {
+		if (this.localAssociatedWith) {
+			if (this.localAssociatedWith.length === 1) {
+				return this.remoteDefinition!.fields[this.localAssociatedWith[0]]
+					?.association;
+			} else {
+				return undefined;
+			}
+		}
+	}
+
+	/**
+	 * The field names on the remote model that can used to query or queried to match
+	 * with instances of the local model.
+	 *
+	 * Fields are returned in-order to match the order of `this.localKeyFields`.
+	 */
+	get remoteJoinFields() {
+		/**
+		 * If the local relationship explicitly names "associated with" fields, we
+		 * need to see if this points direction to a reciprocating assocation. If it
+		 * does, the remote assocation indicates what fields to use.
+		 */
+
+		if (this.explicitRemoteAssociation?.targetName) {
+			// This case is theoretically unnecessary going forward.
+			return [this.explicitRemoteAssociation.targetName!];
+		} else if (this.explicitRemoteAssociation?.targetNames) {
+			return this.explicitRemoteAssociation?.targetNames!;
+		} else if (this.localAssociatedWith) {
+			return this.localAssociatedWith;
+		} else {
+			return this.remotePKFields;
+		}
+	}
+
+	/**
+	 * Whether this relationship everything necessary to get, set, and query from
+	 * the perspective of the local model provided at instantiation.
+	 */
+	get isComplete() {
+		return this.localJoinFields.length > 0 && this.remoteJoinFields.length > 0;
+	}
+
+	/**
+	 * Creates an FK mapper object with respect to the given related instance.
+	 *
+	 * E.g., if the local FK fields are `[parentId, parentName]` and point to
+	 * `[customId, name]` on the remote model, `createLocalFKObject(remote)`
+	 * will return:
+	 *
+	 * ```
+	 * {
+	 * 	parentId: remote.customId,
+	 * 	parentName: remote.name
+	 * }
+	 * ```
+	 *
+	 * @param remote The remote related instance.
+	 */
+	createLocalFKObject(remote: any) {
+		const fk = {} as Record<string, string>;
+		for (let i = 0; i < this.localJoinFields.length; i++) {
+			fk[this.localJoinFields[i]] = remote[this.remoteJoinFields[i]];
+		}
+		return fk;
+	}
+
+	/**
+	 * Creates an query mapper object to help fetch the remote instance(s) or
+	 * `null` if any of the necessary local fields are `null` or `undefined`.
+	 *
+	 * E.g., if the local FK fields are `[parentId, parentName]` and point to
+	 * `[customId, name]` on the remote model, `createLocalFKObject(remote)`
+	 * will return:
+	 *
+	 * ```
+	 * {
+	 * 	customId: local.parentId
+	 * 	name: local.parentName
+	 * }
+	 * ```
+	 *
+	 * If the local fields are not populated, returns
+	 *
+	 * @param local The local instance.
+	 */
+	createRemoteQueryObject(local: T) {
+		const query = {} as Record<string, string>;
+		for (let i = 0; i < this.remoteJoinFields.length; i++) {
+			const localValue = local[this.localJoinFields[i]];
+			if (localValue === null || localValue === undefined) return null;
+			query[this.remoteJoinFields[i]] = local[this.localJoinFields[i]];
+		}
+		return query;
+	}
+}

package/src/storage/storage.ts

@@ -25,6 +25,7 @@ import {
 	STORAGE,
 	validatePredicate,
 	valuesEqual,
+	NAMESPACES,
 } from '../util';
 import { getIdentifierValue } from '../sync/utils';
 import { Adapter } from './adapter';
@@ -40,7 +41,7 @@ export type Storage = InstanceType<typeof StorageClass>;
 
 const logger = new Logger('DataStore');
 class StorageClass implements StorageFacade {
-	private initialized: Promise<void>;
+	private initialized: Promise<void> | undefined;
 	private readonly pushStream: {
 		observable: Observable<StorageSubscriptionMessage<PersistentModel>>;
 	} & Required<
@@ -51,7 +52,7 @@ class StorageClass implements StorageFacade {
 		private readonly schema: InternalSchema,
 		private readonly namespaceResolver: NamespaceResolver,
 		private readonly getModelConstructorByModelName: (
-			namsespaceName: string,
+			namsespaceName: NAMESPACES,
 			modelName: string
 		) => PersistentModelConstructor<any>,
 		private readonly modelInstanceCreator: ModelInstanceCreator,
@@ -59,7 +60,7 @@ class StorageClass implements StorageFacade {
 		private readonly sessionId?: string
 	) {
 		this.adapter = this.adapter || getDefaultAdapter();
-		this.pushStream = new PushStream();
+		this.pushStream = new PushStream() as any;
 	}
 
 	static getNamespace() {
@@ -89,15 +90,13 @@ class StorageClass implements StorageFacade {
 			reject = rej;
 		});
 
-		this.adapter
-			.setUp(
-				this.schema,
-				this.namespaceResolver,
-				this.modelInstanceCreator,
-				this.getModelConstructorByModelName,
-				this.sessionId
-			)
-			.then(resolve, reject);
+		this.adapter!.setUp(
+			this.schema,
+			this.namespaceResolver,
+			this.modelInstanceCreator,
+			this.getModelConstructorByModelName,
+			this.sessionId
+		).then(resolve!, reject!);
 
 		await this.initialized;
 	}
@@ -109,6 +108,9 @@ class StorageClass implements StorageFacade {
 		patchesTuple?: [Patch[], PersistentModel]
 	): Promise<[T, OpType.INSERT | OpType.UPDATE][]> {
 		await this.init();
+		if (!this.adapter) {
+			throw new Error('Storage adapter is missing');
+		}
 
 		const result = await this.adapter.save(model, condition);
 
@@ -152,11 +154,14 @@ class StorageClass implements StorageFacade {
 				.constructor as PersistentModelConstructor<T>;
 
 			this.pushStream.next({
-				model: modelConstructor,
+				model: modelConstructor as any,
 				opType,
 				element,
 				mutator,
-				condition: ModelPredicateCreator.getPredicates(condition, false),
+				condition:
+					(condition &&
+						ModelPredicateCreator.getPredicates(condition, false)) ||
+					null,
 				savedElement,
 			});
 		});
@@ -180,9 +185,12 @@ class StorageClass implements StorageFacade {
 		mutator?: Symbol
 	): Promise<[T[], T[]]> {
 		await this.init();
+		if (!this.adapter) {
+			throw new Error('Storage adapter is missing');
+		}
 
-		let deleted: T[];
 		let models: T[];
+		let deleted: T[] | undefined;
 
 		[models, deleted] = await this.adapter.delete(
 			modelOrModelConstructor,
@@ -216,21 +224,21 @@ class StorageClass implements StorageFacade {
 			const modelConstructor = (Object.getPrototypeOf(model) as Object)
 				.constructor as PersistentModelConstructor<T>;
 
-			let theCondition: PredicatesGroup<any>;
+			let theCondition: PredicatesGroup<any> | undefined;
 
 			if (!isModelConstructor(modelOrModelConstructor)) {
 				const modelId = getIdentifierValue(modelDefinition, model);
 				theCondition = modelIds.has(modelId)
-					? ModelPredicateCreator.getPredicates(condition, false)
+					? ModelPredicateCreator.getPredicates(condition!, false)
 					: undefined;
 			}
 
 			this.pushStream.next({
-				model: modelConstructor,
+				model: modelConstructor as any,
 				opType: OpType.DELETE,
 				element: model,
 				mutator,
-				condition: theCondition,
+				condition: theCondition || null,
 			});
 		});
 
@@ -243,6 +251,9 @@ class StorageClass implements StorageFacade {
 		pagination?: PaginationInput<T>
 	): Promise<T[]> {
 		await this.init();
+		if (!this.adapter) {
+			throw new Error('Storage adapter is missing');
+		}
 
 		return await this.adapter.query(modelConstructor, predicate, pagination);
 	}
@@ -250,22 +261,24 @@ class StorageClass implements StorageFacade {
 	async queryOne<T extends PersistentModel>(
 		modelConstructor: PersistentModelConstructor<T>,
 		firstOrLast: QueryOne = QueryOne.FIRST
-	): Promise<T> {
+	): Promise<T | undefined> {
 		await this.init();
+		if (!this.adapter) {
+			throw new Error('Storage adapter is missing');
+		}
 
-		const record = await this.adapter.queryOne(modelConstructor, firstOrLast);
-		return record;
+		return await this.adapter.queryOne(modelConstructor, firstOrLast);
 	}
 
 	observe<T extends PersistentModel>(
-		modelConstructor?: PersistentModelConstructor<T>,
-		predicate?: ModelPredicate<T>,
+		modelConstructor?: PersistentModelConstructor<T> | null,
+		predicate?: ModelPredicate<T> | null,
 		skipOwn?: Symbol
 	): Observable<SubscriptionMessage<T>> {
 		const listenToAll = !modelConstructor;
 		const { predicates, type } =
-			ModelPredicateCreator.getPredicates(predicate, false) || {};
-		const hasPredicate = !!predicates;
+			(predicate && ModelPredicateCreator.getPredicates(predicate, false)) ||
+			{};
 
 		let result = this.pushStream.observable
 			.filter(({ mutator }) => {
@@ -281,7 +294,7 @@ class StorageClass implements StorageFacade {
 					return false;
 				}
 
-				if (hasPredicate) {
+				if (!!predicates && !!type) {
 					return validatePredicate(element, type, predicates);
 				}
 
@@ -294,6 +307,9 @@ class StorageClass implements StorageFacade {
 
 	async clear(completeObservable = true) {
 		this.initialized = undefined;
+		if (!this.adapter) {
+			throw new Error('Storage adapter is missing');
+		}
 
 		await this.adapter.clear();
 
@@ -308,6 +324,9 @@ class StorageClass implements StorageFacade {
 		mutator?: Symbol
 	): Promise<[T, OpType][]> {
 		await this.init();
+		if (!this.adapter) {
+			throw new Error('Storage adapter is missing');
+		}
 
 		const result = await this.adapter.batchSave(modelConstructor, items);
 
@@ -317,7 +336,7 @@ class StorageClass implements StorageFacade {
 				opType,
 				element,
 				mutator,
-				condition: undefined,
+				condition: null,
 			});
 		});
 
@@ -335,7 +354,7 @@ class StorageClass implements StorageFacade {
 			return null;
 		}
 
-		const [patches, source] = patchesTuple;
+		const [patches, source] = patchesTuple!;
 		const updatedElement = {};
 		// extract array of updated fields from patches
 		const updatedFields = <string[]>(
@@ -349,7 +368,7 @@ class StorageClass implements StorageFacade {
 		const { fields } =
 			this.schema.namespaces[namespace].models[modelConstructor.name];
 		const { primaryKey, compositeKeys = [] } =
-			this.schema.namespaces[namespace].keys[modelConstructor.name];
+			this.schema.namespaces[namespace].keys?.[modelConstructor.name] || {};
 
 		// set original values for these fields
 		updatedFields.forEach((field: string) => {
@@ -440,7 +459,7 @@ class ExclusiveStorage implements StorageFacade {
 		schema: InternalSchema,
 		namespaceResolver: NamespaceResolver,
 		getModelConstructorByModelName: (
-			namsespaceName: string,
+			namsespaceName: NAMESPACES,
 			modelName: string
 		) => PersistentModelConstructor<any>,
 		modelInstanceCreator: ModelInstanceCreator,
@@ -491,11 +510,11 @@ class ExclusiveStorage implements StorageFacade {
 			if (isModelConstructor(modelOrModelConstructor)) {
 				const modelConstructor = modelOrModelConstructor;
 
-				return storage.delete(modelConstructor, condition, mutator);
+				return storage.delete(modelConstructor as any, condition, mutator);
 			} else {
 				const model = modelOrModelConstructor;
 
-				return storage.delete(model, condition, mutator);
+				return storage.delete(model as any, condition, mutator);
 			}
 		});
 	}
@@ -513,8 +532,8 @@ class ExclusiveStorage implements StorageFacade {
 	async queryOne<T extends PersistentModel>(
 		modelConstructor: PersistentModelConstructor<T>,
 		firstOrLast: QueryOne = QueryOne.FIRST
-	): Promise<T> {
-		return this.runExclusive<T>(storage =>
+	): Promise<T | undefined> {
+		return this.runExclusive<T | undefined>(storage =>
 			storage.queryOne<T>(modelConstructor, firstOrLast)
 		);
 	}
@@ -524,8 +543,8 @@ class ExclusiveStorage implements StorageFacade {
 	}
 
 	observe<T extends PersistentModel>(
-		modelConstructor?: PersistentModelConstructor<T>,
-		predicate?: ModelPredicate<T>,
+		modelConstructor?: PersistentModelConstructor<T> | null,
+		predicate?: ModelPredicate<T> | null,
 		skipOwn?: Symbol
 	): Observable<SubscriptionMessage<T>> {
 		return this.storage.observe(modelConstructor, predicate, skipOwn);

package/src/sync/datastoreConnectivity.ts

@@ -13,9 +13,9 @@ type ConnectionStatus = {
 
 export default class DataStoreConnectivity {
 	private connectionStatus: ConnectionStatus;
-	private observer: ZenObservable.SubscriptionObserver<ConnectionStatus>;
-	private subscription: ZenObservable.Subscription;
-	private timeout: ReturnType<typeof setTimeout>;
+	private observer!: ZenObservable.SubscriptionObserver<ConnectionStatus>;
+	private subscription!: ZenObservable.Subscription;
+	private timeout!: ReturnType<typeof setTimeout>;
 	constructor() {
 		this.connectionStatus = {
 			online: false,
@@ -26,7 +26,7 @@ export default class DataStoreConnectivity {
 		if (this.observer) {
 			throw new Error('Subscriber already exists');
 		}
-		return new Observable(observer => {
+		return new Observable((observer) => {
 			this.observer = observer;
 			// Will be used to forward socket connection changes, enhancing Reachability
 

package/src/sync/index.ts

@@ -32,7 +32,7 @@ import {
 // tslint:disable:no-duplicate-imports
 import type { __modelMeta__ } from '../types';
 
-import { exhaustiveCheck, getNow, SYNC, USER } from '../util';
+import { getNow, SYNC, USER } from '../util';
 import DataStoreConnectivity from './datastoreConnectivity';
 import { ModelMerger } from './merger';
 import { MutationEventOutbox } from './outbox';
@@ -122,7 +122,7 @@ export class SyncEngine {
 	public getModelSyncedStatus(
 		modelConstructor: PersistentModelConstructor<any>
 	): boolean {
-		return this.modelSyncedStatus.get(modelConstructor);
+		return this.modelSyncedStatus.get(modelConstructor)!;
 	}
 
 	constructor(
@@ -235,14 +235,8 @@ export class SyncEngine {
 										);
 									} else {
 										//#region GraphQL Subscriptions
-										[
-											// const ctlObservable: Observable<CONTROL_MSG>
-											ctlSubsObservable,
-											// const dataObservable: Observable<[TransformerMutationType, SchemaModel, Readonly<{
-											// id: string;
-											// } & Record<string, any>>]>
-											dataSubsObservable,
-										] = this.subscriptionsProcessor.start();
+										[ctlSubsObservable, dataSubsObservable] =
+											this.subscriptionsProcessor.start();
 
 										try {
 											await new Promise((resolve, reject) => {
@@ -362,7 +356,7 @@ export class SyncEngine {
 									// TODO: extract to function
 									if (!isNode) {
 										subscriptions.push(
-											dataSubsObservable.subscribe(
+											dataSubsObservable!.subscribe(
 												([_transformerMutationType, modelDefinition, item]) =>
 													this.runningProcesses.add(async () => {
 														const modelConstructor = this.userModelClasses[
@@ -421,11 +415,11 @@ export class SyncEngine {
 								] as PersistentModelConstructor<MutationEvent>;
 								const modelDefinition = this.getModelDefinition(model);
 								const graphQLCondition = predicateToGraphQLCondition(
-									condition,
+									condition!,
 									modelDefinition
 								);
 								const mutationEvent = createMutationInstanceFromModelOperation(
-									namespace.relationships,
+									namespace.relationships!,
 									this.getModelDefinition(model),
 									opType,
 									model,
@@ -500,7 +494,7 @@ export class SyncEngine {
 					fullSyncInterval,
 					lastSyncPredicate,
 				}) => {
-					const nextFullSync = lastFullSync + fullSyncInterval;
+					const nextFullSync = lastFullSync! + fullSyncInterval;
 					const syncFrom =
 						!lastFullSync || nextFullSync < currentTimeStamp
 							? 0 // perform full sync if expired
@@ -508,7 +502,7 @@ export class SyncEngine {
 
 					return [
 						this.schema.namespaces[namespace].models[model],
-						[namespace, syncFrom],
+						[namespace, syncFrom!],
 					];
 				}
 			)
@@ -631,7 +625,7 @@ export class SyncEngine {
 												))
 											);
 
-											const counts = count.get(modelConstructor);
+											const counts = count.get(modelConstructor)!;
 
 											opTypeCount.forEach(([, opType]) => {
 												switch (opType) {
@@ -645,7 +639,7 @@ export class SyncEngine {
 														counts.deleted++;
 														break;
 													default:
-														exhaustiveCheck(opType);
+														throw new Error(`Invalid opType ${opType}`);
 												}
 											});
 										});
@@ -665,10 +659,10 @@ export class SyncEngine {
 
 											newestFullSyncStartedAt =
 												newestFullSyncStartedAt === undefined
-													? lastFullSync
+													? lastFullSync!
 													: Math.max(
 															newestFullSyncStartedAt,
-															isFullSync ? startedAt : lastFullSync
+															isFullSync ? startedAt : lastFullSync!
 													  );
 
 											modelMetadata = (
@@ -728,9 +722,9 @@ export class SyncEngine {
 						});
 
 						const msNextFullSync =
-							newestFullSyncStartedAt +
-							theInterval -
-							(newestStartedAt + duration);
+							newestFullSyncStartedAt! +
+							theInterval! -
+							(newestStartedAt! + duration!);
 
 						logger.debug(
 							`Next fullSync in ${msNextFullSync / 1000} seconds. (${new Date(
@@ -843,7 +837,7 @@ export class SyncEngine {
 		const promises = models.map(async ([namespace, model]) => {
 			const modelMetadata = await this.getModelMetadata(namespace, model.name);
 			const syncPredicate = ModelPredicateCreator.getPredicates(
-				this.syncPredicates.get(model),
+				this.syncPredicates.get(model)!,
 				false
 			);
 			const lastSyncPredicate = syncPredicate
@@ -855,9 +849,9 @@ export class SyncEngine {
 					this.modelInstanceCreator(ModelMetadataConstructor, {
 						model: model.name,
 						namespace,
-						lastSync: null,
+						lastSync: null!,
 						fullSyncInterval,
-						lastFullSync: null,
+						lastFullSync: null!,
 						lastSyncPredicate,
 					}),
 					undefined,
@@ -875,9 +869,9 @@ export class SyncEngine {
 						// perform a base sync if the syncPredicate changed in between calls to DataStore.start
 						// ensures that the local store contains all the data specified by the syncExpression
 						if (syncPredicateUpdated) {
-							draft.lastSync = null;
-							draft.lastFullSync = null;
-							draft.lastSyncPredicate = lastSyncPredicate;
+							draft.lastSync = null!;
+							draft.lastFullSync = null!;
+							(draft.lastSyncPredicate as any) = lastSyncPredicate;
 						}
 					})
 				);