@aws-amplify/datastore 3.4.8 → 3.4.9-in-app-messaging.48

package/src/types.ts

@@ -398,19 +398,23 @@ export type SubscriptionMessage<T extends PersistentModel> = {
 	model: PersistentModelConstructor<T>;
 	condition: PredicatesGroup<T> | null;
 };
+
+export type DataStoreSnapshot<T extends PersistentModel> = {
+	items: T[];
+	isSynced: boolean;
+};
 //#endregion
 
 //#region Predicates
 
-export type PredicateExpression<M extends PersistentModel, FT> = TypeName<
+export type PredicateExpression<
+	M extends PersistentModel,
 	FT
-> extends keyof MapTypeToOperands<FT>
+> = TypeName<FT> extends keyof MapTypeToOperands<FT>
 	? (
 			operator: keyof MapTypeToOperands<FT>[TypeName<FT>],
 			// make the operand type match the type they're trying to filter on
-			operand: MapTypeToOperands<FT>[TypeName<FT>][keyof MapTypeToOperands<
-				FT
-			>[TypeName<FT>]]
+			operand: MapTypeToOperands<FT>[TypeName<FT>][keyof MapTypeToOperands<FT>[TypeName<FT>]]
 	  ) => ModelPredicate<M>
 	: never;
 
@@ -478,8 +482,7 @@ export type PredicateGroups<T extends PersistentModel> = {
 
 export type ModelPredicate<M extends PersistentModel> = {
 	[K in keyof M]-?: PredicateExpression<M, NonNullable<M[K]>>;
-} &
-	PredicateGroups<M>;
+} & PredicateGroups<M>;
 
 export type ProducerModelPredicate<M extends PersistentModel> = (
 	condition: ModelPredicate<M>
@@ -550,6 +553,11 @@ export type ProducerPaginationInput<T extends PersistentModel> = {
 	page?: number;
 };
 
+export type ObserveQueryOptions<T extends PersistentModel> = Pick<
+	ProducerPaginationInput<T>,
+	'sort'
+>;
+
 export type PaginationInput<T extends PersistentModel> = {
 	sort?: SortPredicate<T>;
 	limit?: number;
@@ -564,9 +572,10 @@ export type SortPredicate<T extends PersistentModel> = {
 	[K in keyof T]-?: SortPredicateExpression<T, NonNullable<T[K]>>;
 };
 
-export type SortPredicateExpression<M extends PersistentModel, FT> = TypeName<
+export type SortPredicateExpression<
+	M extends PersistentModel,
 	FT
-> extends keyof MapTypeToOperands<FT>
+> = TypeName<FT> extends keyof MapTypeToOperands<FT>
 	? (sortDirection: keyof typeof SortDirection) => SortPredicate<M>
 	: never;
 
@@ -575,9 +584,8 @@ export enum SortDirection {
 	DESCENDING = 'DESCENDING',
 }
 
-export type SortPredicatesGroup<
-	T extends PersistentModel
-> = SortPredicateObject<T>[];
+export type SortPredicatesGroup<T extends PersistentModel> =
+	SortPredicateObject<T>[];
 
 export type SortPredicateObject<T extends PersistentModel> = {
 	field: keyof T;
@@ -779,4 +787,15 @@ export type ConflictHandler = (
 	| PersistentModel
 	| typeof DISCARD;
 export type ErrorHandler = (error: SyncError) => void;
+
+export type DeferredCallbackResolverOptions = {
+	callback: () => void;
+	maxInterval?: number;
+	errorHandler?: (error: string) => void;
+};
+
+export enum LimitTimerRaceResolvedValues {
+	LIMIT = 'LIMIT',
+	TIMER = 'TIMER',
+}
 //#endregion

package/src/util.ts

@@ -23,6 +23,8 @@ import {
 	isModelAttributePrimaryKey,
 	isModelAttributeCompositeKey,
 	NonModelTypeConstructor,
+	DeferredCallbackResolverOptions,
+	LimitTimerRaceResolvedValues,
 } from './types';
 import { WordArray } from 'amazon-cognito-identity-js';
 
@@ -681,3 +683,81 @@ export const isAWSIPAddress = (val: string): boolean => {
 		val
 	);
 };
+
+export class DeferredPromise {
+	public promise: Promise<string>;
+	public resolve: (value: string | PromiseLike<string>) => void;
+	public reject: () => void;
+	constructor() {
+		const self = this;
+		this.promise = new Promise(
+			(resolve: (value: string | PromiseLike<string>) => void, reject) => {
+				self.resolve = resolve;
+				self.reject = reject;
+			}
+		);
+	}
+}
+
+export class DeferredCallbackResolver {
+	private limitPromise = new DeferredPromise();
+	private timerPromise: Promise<string>;
+	private maxInterval: number;
+	private timer: ReturnType<typeof setTimeout>;
+	private raceInFlight = false;
+	private callback = () => {};
+	private errorHandler: (error: string) => void;
+	private defaultErrorHandler = (
+		msg = 'DeferredCallbackResolver error'
+	): void => {
+		throw new Error(msg);
+	};
+
+	constructor(options: DeferredCallbackResolverOptions) {
+		this.callback = options.callback;
+		this.errorHandler = options.errorHandler || this.defaultErrorHandler;
+		this.maxInterval = options.maxInterval || 2000;
+	}
+
+	private startTimer(): void {
+		this.timerPromise = new Promise((resolve, reject) => {
+			this.timer = setTimeout(() => {
+				resolve(LimitTimerRaceResolvedValues.TIMER);
+			}, this.maxInterval);
+		});
+	}
+
+	private async racePromises(): Promise<string> {
+		let winner: string;
+		try {
+			this.raceInFlight = true;
+			this.startTimer();
+			winner = await Promise.race([
+				this.timerPromise,
+				this.limitPromise.promise,
+			]);
+			this.callback();
+		} catch (err) {
+			this.errorHandler(err);
+		} finally {
+			// reset for the next race
+			this.clear();
+			this.raceInFlight = false;
+			this.limitPromise = new DeferredPromise();
+
+			return winner;
+		}
+	}
+
+	public start(): void {
+		if (!this.raceInFlight) this.racePromises();
+	}
+
+	public clear(): void {
+		clearTimeout(this.timer);
+	}
+
+	public resolve(): void {
+		this.limitPromise.resolve(LimitTimerRaceResolvedValues.LIMIT);
+	}
+}