@aws-amplify/datastore 5.0.32 → 5.0.33-s-auth.30d0cd2.0

package/src/index.ts

@@ -1,10 +1,19 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+import {
+	USER,
+	isModelConstructor,
+	isNonModelConstructor,
+	traverseModel,
+	validatePredicate,
+} from './util';
+
 export {
 	DataStore,
 	DataStoreClass,
 	initSchema,
 	ModelInstanceCreator,
+	// eslint-disable-next-line import/export
 	AsyncCollection,
 	AsyncItem,
 } from './datastore/datastore';
@@ -16,14 +25,6 @@ export {
 } from './predicates';
 export { Adapter as StorageAdapter } from './storage/adapter';
 
-import {
-	traverseModel,
-	validatePredicate,
-	USER,
-	isNonModelConstructor,
-	isModelConstructor,
-} from './util';
-
 export { NAMESPACES } from './util';
 
 export const utils = {
@@ -34,4 +35,5 @@ export const utils = {
 	isModelConstructor,
 };
 
+// eslint-disable-next-line import/export
 export * from './types';

package/src/predicates/index.ts

@@ -39,6 +39,7 @@ const groupKeys = new Set(['and', 'or', 'not']);
  */
 const isGroup = o => {
 	const keys = [...Object.keys(o)];
+
 	return keys.length === 1 && groupKeys.has(keys[0]);
 };
 
@@ -77,6 +78,7 @@ export const comparisonKeys = new Set([
  */
 const isComparison = o => {
 	const keys = [...Object.keys(o)];
+
 	return !Array.isArray(o) && keys.length === 1 && comparisonKeys.has(keys[0]);
 };
 
@@ -98,11 +100,12 @@ export const PredicateAll = Symbol('A predicate that matches all records');
 
 export class Predicates {
 	public static get ALL(): typeof PredicateAll {
+		// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
 		const predicate = <ProducerModelPredicate<any>>(c => c);
 
 		predicatesAllSet.add(predicate);
 
-		return <typeof PredicateAll>(<unknown>predicate);
+		return predicate as unknown as typeof PredicateAll;
 	}
 }
 
@@ -140,7 +143,7 @@ export class ModelPredicateCreator {
 	 */
 	static getPredicates<T extends PersistentModel>(
 		predicate: ModelPredicate<T>,
-		throwOnInvalid: boolean = true,
+		throwOnInvalid = true,
 	) {
 		if (throwOnInvalid && !ModelPredicateCreator.isValidPredicate(predicate)) {
 			throw new Error('The predicate is not valid');
@@ -167,6 +170,7 @@ export class ModelPredicateCreator {
 		const predicate = this.createFromAST<T>(modelDefinition, {
 			and: keyFields.map((field, idx) => {
 				const operand = keyValues[idx];
+
 				return { [field]: { eq: operand } };
 			}),
 		});
@@ -190,6 +194,7 @@ export class ModelPredicateCreator {
 		const ast = {
 			and: Object.entries(flatEqualities).map(([k, v]) => ({ [k]: { eq: v } })),
 		};
+
 		return this.createFromAST<T>(modelDefinition, ast);
 	}
 
@@ -231,12 +236,14 @@ export class ModelPredicateCreator {
 			const children = this.transformGraphQLFilterNodeToPredicateAST(
 				gql[groupkey],
 			);
+
 			return {
 				type: groupkey,
 				predicates: Array.isArray(children) ? children : [children],
 			};
 		} else if (isComparison(gql)) {
 			const operatorKey = Object.keys(gql)[0];
+
 			return {
 				operator: operatorKey,
 				operand: gql[operatorKey],
@@ -246,6 +253,7 @@ export class ModelPredicateCreator {
 				return gql.map(o => this.transformGraphQLFilterNodeToPredicateAST(o));
 			} else {
 				const fieldKey = Object.keys(gql)[0];
+
 				return {
 					field: fieldKey,
 					...this.transformGraphQLFilterNodeToPredicateAST(gql[fieldKey]),

package/src/predicates/next.ts

@@ -1,38 +1,38 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import {
-	PersistentModel,
+	AllFieldOperators,
 	ModelFieldType,
 	ModelMeta,
-	ModelPredicate as StoragePredicate,
-	AllFieldOperators,
-	PredicateInternalsKey,
 	V5ModelPredicate as ModelPredicate,
+	PersistentModel,
+	PredicateInternalsKey,
 	RecursiveModelPredicate,
-	RecursiveModelPredicateExtender,
 	RecursiveModelPredicateAggregateExtender,
+	RecursiveModelPredicateExtender,
+	ModelPredicate as StoragePredicate,
 } from '../types';
+import { ExclusiveStorage as StorageAdapter } from '../storage/storage';
+import { ModelRelationship } from '../storage/relationship';
+import { asyncEvery, asyncSome } from '../util';
 
 import {
 	ModelPredicateCreator as FlatModelPredicateCreator,
 	comparisonKeys,
 } from './index';
-import { ExclusiveStorage as StorageAdapter } from '../storage/storage';
-import { ModelRelationship } from '../storage/relationship';
-import { asyncSome, asyncEvery } from '../util';
 
 const ops = [...comparisonKeys] as AllFieldOperators[];
 
 type GroupOperator = 'and' | 'or' | 'not';
 
-type UntypedCondition = {
-	fetch: (storage: StorageAdapter) => Promise<Record<string, any>[]>;
-	matches: (item: Record<string, any>) => Promise<boolean>;
+interface UntypedCondition {
+	fetch(storage: StorageAdapter): Promise<Record<string, any>[]>;
+	matches(item: Record<string, any>): Promise<boolean>;
 	copy(
 		extract?: GroupCondition,
 	): [UntypedCondition, GroupCondition | undefined];
 	toAST(): any;
-};
+}
 
 /**
  * A map from keys (exposed to customers) to the internal predicate data
@@ -52,6 +52,7 @@ const predicateInternalsMap = new Map<PredicateInternalsKey, GroupCondition>();
 const registerPredicateInternals = (condition: GroupCondition, key?: any) => {
 	const finalKey = key || new PredicateInternalsKey();
 	predicateInternalsMap.set(finalKey, condition);
+
 	return finalKey;
 };
 
@@ -72,6 +73,7 @@ export const internals = (key: any) => {
 			"Invalid predicate. Terminate your predicate with a valid condition (e.g., `p => p.field.eq('value')`) or pass `Predicates.ALL`.",
 		);
 	}
+
 	return predicateInternalsMap.get(key)!;
 };
 
@@ -113,7 +115,7 @@ export class FieldCondition {
 	 * @param extract Not used. Present only to fulfill the `UntypedCondition` interface.
 	 * @returns A new, identitical `FieldCondition`.
 	 */
-	copy(extract?: GroupCondition): [FieldCondition, GroupCondition | undefined] {
+	copy(): [FieldCondition, GroupCondition | undefined] {
 		return [
 			new FieldCondition(this.field, this.operator, [...this.operands]),
 			undefined,
@@ -191,7 +193,8 @@ export class FieldCondition {
 	 * @param storage N/A. If ever implemented, the storage adapter to query.
 	 * @returns N/A. If ever implemented, return items from `storage` that match.
 	 */
-	async fetch(storage: StorageAdapter): Promise<Record<string, any>[]> {
+	async fetch(): Promise<Record<string, any>[]> {
+		// eslint-disable-next-line prefer-promise-reject-errors
 		return Promise.reject('No implementation needed [yet].');
 	}
 
@@ -217,6 +220,7 @@ export class FieldCondition {
 		const operation = operations[this.operator as keyof typeof operations];
 		if (operation) {
 			const result = operation();
+
 			return result;
 		} else {
 			throw new Error(`Invalid operator given: ${this.operator}`);
@@ -234,6 +238,7 @@ export class FieldCondition {
 		 */
 		const argumentCount = count => {
 			const argsClause = count === 1 ? 'argument is' : 'arguments are';
+
 			return () => {
 				if (this.operands.length !== count) {
 					return `Exactly ${count} ${argsClause} required.`;
@@ -278,6 +283,7 @@ export class FieldCondition {
  */
 const getGroupId = (() => {
 	let seed = 1;
+
 	return () => `group_${seed++}`;
 })();
 
@@ -345,7 +351,7 @@ export class GroupCondition {
 		 * This is used to guard against infinitely fetch -> optimize -> fetch
 		 * recursion.
 		 */
-		public isOptimized: boolean = false,
+		public isOptimized = false,
 	) {}
 
 	/**
@@ -386,6 +392,7 @@ export class GroupCondition {
 	 */
 	withFieldConditionsOnly(negate: boolean) {
 		const negateChildren = negate !== (this.operator === 'not');
+
 		return new GroupCondition(
 			this.model,
 			undefined,
@@ -495,7 +502,7 @@ export class GroupCondition {
 			return this.optimized().fetch(storage);
 		}
 
-		const resultGroups: Array<Record<string, any>[]> = [];
+		const resultGroups: Record<string, any>[][] = [];
 
 		const operator = (negate ? negations[this.operator] : this.operator) as
 			| 'or'
@@ -564,7 +571,7 @@ export class GroupCondition {
 
 				const relationship = ModelRelationship.from(this.model, g.field);
 
-				type JoinCondition = { [x: string]: { eq: any } };
+				type JoinCondition = Record<string, { eq: any }>;
 				if (relationship) {
 					const allJoinConditions: { and: JoinCondition[] }[] = [];
 					for (const relative of relatives) {
@@ -665,7 +672,7 @@ export class GroupCondition {
 	 */
 	async matches(
 		item: Record<string, any>,
-		ignoreFieldName: boolean = false,
+		ignoreFieldName = false,
 	): Promise<boolean> {
 		const itemToCheck =
 			this.field && !ignoreFieldName ? await item[this.field] : item;
@@ -686,6 +693,7 @@ export class GroupCondition {
 					return true;
 				}
 			}
+
 			return false;
 		}
 
@@ -699,6 +707,7 @@ export class GroupCondition {
 					'Invalid arguments! `not()` accepts exactly one predicate expression.',
 				);
 			}
+
 			return !(await this.operands[0].matches(itemToCheck));
 		} else {
 			throw new Error('Invalid group operator!');
@@ -769,7 +778,7 @@ export class GroupCondition {
  */
 export function recursivePredicateFor<T extends PersistentModel>(
 	ModelType: ModelMeta<T>,
-	allowRecursion: boolean = true,
+	allowRecursion = true,
 	field?: string,
 	query?: GroupCondition,
 	tail?: GroupCondition,
@@ -788,15 +797,16 @@ export function recursivePredicateFor<T extends PersistentModel>(
 	registerPredicateInternals(baseCondition, link);
 
 	const copyLink = () => {
-		const [query, newTail] = baseCondition.copy(tailCondition);
+		const [copiedQuery, newTail] = baseCondition.copy(tailCondition);
 		const newLink = recursivePredicateFor(
 			ModelType,
 			allowRecursion,
 			undefined,
-			query,
+			copiedQuery,
 			newTail,
 		);
-		return { query, newTail, newLink };
+
+		return { query: copiedQuery, newTail, newLink };
 	};
 
 	// Adds .or() and .and() methods to the link.
@@ -805,7 +815,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 		link[op] = (builder: RecursiveModelPredicateAggregateExtender<T>) => {
 			// or() and and() will return a copy of the original link
 			// to head off mutability concerns.
-			const { query, newTail } = copyLink();
+			const { query: copiedLinkQuery, newTail } = copyLink();
 
 			const childConditions = builder(
 				recursivePredicateFor(ModelType, allowRecursion),
@@ -829,7 +839,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 			);
 
 			// FinalPredicate
-			return registerPredicateInternals(query);
+			return registerPredicateInternals(copiedLinkQuery);
 		};
 	});
 
@@ -839,7 +849,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 	): PredicateInternalsKey => {
 		// not() will return a copy of the original link
 		// to head off mutability concerns.
-		const { query, newTail } = copyLink();
+		const { query: copiedLinkQuery, newTail } = copyLink();
 
 		// unlike and() and or(), the customer will supply a "singular" child predicate.
 		// the difference being: not() does not accept an array of predicate-like objects.
@@ -853,7 +863,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 		// A `FinalModelPredicate`.
 		// Return a thing that can no longer be extended, but instead used to `async filter(items)`
 		// or query storage: `.__query.fetch(storage)`.
-		return registerPredicateInternals(query);
+		return registerPredicateInternals(copiedLinkQuery);
 	};
 
 	// For each field on the model schema, we want to add a getter
@@ -881,7 +891,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 							[operator]: (...operands: any[]) => {
 								// build off a fresh copy of the existing `link`, just in case
 								// the same link is being used elsewhere by the customer.
-								const { query, newTail } = copyLink();
+								const { query: copiedLinkQuery, newTail } = copyLink();
 
 								// normalize operands. if any of the values are `undefiend`, use
 								// `null` instead, because that's what will be stored cross-platform.
@@ -898,7 +908,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 								// A `FinalModelPredicate`.
 								// Return a thing that can no longer be extended, but instead used to `async filter(items)`
 								// or query storage: `.__query.fetch(storage)`.
-								return registerPredicateInternals(query);
+								return registerPredicateInternals(copiedLinkQuery);
 							},
 						};
 					}, {});
@@ -945,6 +955,7 @@ export function recursivePredicateFor<T extends PersistentModel>(
 							newquery,
 							newtail,
 						);
+
 						return newlink;
 					} else {
 						throw new Error(

package/src/predicates/sort.ts

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 import {
 	PersistentModel,
-	SchemaModel,
-	SortPredicate,
 	ProducerSortPredicate,
+	SchemaModel,
 	SortDirection,
+	SortPredicate,
 	SortPredicatesGroup,
 } from '../types';
 
@@ -21,32 +21,29 @@ export class ModelSortPredicateCreator {
 		const { name: modelName } = modelDefinition;
 		const fieldNames = new Set<keyof T>(Object.keys(modelDefinition.fields));
 
-		let handler: ProxyHandler<SortPredicate<T>>;
-		const predicate = new Proxy(
-			{} as SortPredicate<T>,
-			(handler = {
-				get(_target, propertyKey, receiver: SortPredicate<T>) {
-					const field = propertyKey as keyof T;
+		const predicate = new Proxy({} as SortPredicate<T>, {
+			get(_target, propertyKey, receiver: SortPredicate<T>) {
+				const field = propertyKey as keyof T;
 
-					if (!fieldNames.has(field)) {
-						throw new Error(
-							`Invalid field for model. field: ${String(
-								field,
-							)}, model: ${modelName}`,
-						);
-					}
+				if (!fieldNames.has(field)) {
+					throw new Error(
+						`Invalid field for model. field: ${String(
+							field,
+						)}, model: ${modelName}`,
+					);
+				}
 
-					const result = (sortDirection: SortDirection) => {
-						ModelSortPredicateCreator.sortPredicateGroupsMap
-							.get(receiver)
-							?.push({ field, sortDirection });
+				const result = (sortDirection: SortDirection) => {
+					ModelSortPredicateCreator.sortPredicateGroupsMap
+						.get(receiver)
+						?.push({ field, sortDirection });
 
-						return receiver;
-					};
-					return result;
-				},
-			}),
-		);
+					return receiver;
+				};
+
+				return result;
+			},
+		});
 
 		ModelSortPredicateCreator.sortPredicateGroupsMap.set(predicate, []);
 
@@ -61,7 +58,7 @@ export class ModelSortPredicateCreator {
 
 	static getPredicates<T extends PersistentModel>(
 		predicate: SortPredicate<T>,
-		throwOnInvalid: boolean = true,
+		throwOnInvalid = true,
 	): SortPredicatesGroup<T> {
 		if (
 			throwOnInvalid &&

package/src/storage/adapter/AsyncStorageAdapter.ts

@@ -1,6 +1,5 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import AsyncStorageDatabase from './AsyncStorageDatabase';
 import {
 	ModelInstanceMetadata,
 	ModelPredicate,
@@ -13,21 +12,27 @@ import {
 } from '../../types';
 import {
 	DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR,
-	traverseModel,
-	validatePredicate,
+	getIndexKeys,
+	getStorename,
 	inMemoryPagination,
 	keysEqual,
-	getStorename,
-	getIndexKeys,
+	traverseModel,
+	validatePredicate,
 } from '../../util';
+
+import AsyncStorageDatabase from './AsyncStorageDatabase';
 import { StorageAdapterBase } from './StorageAdapterBase';
 
 export class AsyncStorageAdapter extends StorageAdapterBase {
 	protected db!: AsyncStorageDatabase;
 
-	// no-ops for this adapter
-	protected async preSetUpChecks() {}
-	protected async preOpCheck() {}
+	protected async preSetUpChecks() {
+		// no-ops for AsyncStorageAdapter
+	}
+
+	protected async preOpCheck() {
+		// no-ops for AsyncStorageAdapter
+	}
 
 	/**
 	 * Open AsyncStorage database
@@ -40,6 +45,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 	protected async initDb(): Promise<AsyncStorageDatabase> {
 		const db = new AsyncStorageDatabase();
 		await db.init();
+
 		return db;
 	}
 
@@ -77,15 +83,20 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 
 			const keyValuesPath = this.getIndexKeyValuesPath(model);
 
-			const { instance } = connectedModels.find(({ instance }) => {
-				const instanceKeyValuesPath = this.getIndexKeyValuesPath(instance);
-				return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
-			})!;
+			const { instance } = connectedModels.find(
+				({ instance: connectedModelInstance }) => {
+					const instanceKeyValuesPath = this.getIndexKeyValuesPath(
+						connectedModelInstance,
+					);
+
+					return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
+				},
+			)!;
 
 			batch.push(instance);
 		}
 
-		return await this.db.batchSave(storeName, batch, keys);
+		return this.db.batchSave(storeName, batch, keys);
 	}
 
 	protected async _get<T>(storeName: string, keyArr: string[]): Promise<T> {
@@ -93,7 +104,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 			DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR,
 		);
 
-		return <T>await this.db.get(itemKeyValuesPath, storeName);
+		return (await this.db.get(itemKeyValuesPath, storeName)) as T;
 	}
 
 	async save<T extends PersistentModel>(
@@ -109,12 +120,15 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 
 		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
 		for await (const resItem of connectionStoreNames) {
-			const { storeName, item, instance, keys } = resItem;
+			const { storeName: storeNameForRestItem, item, instance, keys } = resItem;
 
 			const itemKeyValues: string[] = keys.map(key => item[key]);
 
-			const fromDB = <T>await this._get(storeName, itemKeyValues);
-			const opType: OpType = fromDB ? OpType.UPDATE : OpType.INSERT;
+			const fromDBForRestItem = (await this._get(
+				storeNameForRestItem,
+				itemKeyValues,
+			)) as T;
+			const opType: OpType = fromDBForRestItem ? OpType.UPDATE : OpType.INSERT;
 
 			if (
 				keysEqual(itemKeyValues, modelKeyValues) ||
@@ -122,7 +136,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 			) {
 				await this.db.save(
 					item,
-					storeName,
+					storeNameForRestItem,
 					keys,
 					itemKeyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR),
 				);
@@ -130,6 +144,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 				result.push([instance, opType]);
 			}
 		}
+
 		return result;
 	}
 
@@ -151,36 +166,39 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 			if (queryByKey) {
 				const keyValues = queryByKey.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
 				const record = await this.getByKey(storeName, keyValues);
+
 				return record ? [record] : [];
 			}
 
 			if (predicates) {
 				const filtered = await this.filterOnPredicate(storeName, predicates);
+
 				return this.inMemoryPagination(filtered, pagination);
 			}
 
 			if (hasSort || hasPagination) {
 				const all = await this.getAll(storeName);
+
 				return this.inMemoryPagination(all, pagination);
 			}
 
 			return this.getAll(storeName);
 		})()) as T[];
 
-		return await this.load(namespaceName, modelConstructor.name, records);
+		return this.load(namespaceName, modelConstructor.name, records);
 	}
 
 	private async getByKey<T extends PersistentModel>(
 		storeName: string,
 		keyValuePath: string,
 	): Promise<T> {
-		return <T>await this.db.get(keyValuePath, storeName);
+		return (await this.db.get(keyValuePath, storeName)) as T;
 	}
 
 	private async getAll<T extends PersistentModel>(
 		storeName: string,
 	): Promise<T[]> {
-		return await this.db.getAll(storeName);
+		return this.db.getAll(storeName);
 	}
 
 	private async filterOnPredicate<T extends PersistentModel>(
@@ -189,7 +207,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 	) {
 		const { predicates: predicateObjs, type } = predicates;
 
-		const all = <T[]>await this.getAll(storeName);
+		const all = (await this.getAll(storeName)) as T[];
 
 		const filtered = predicateObjs
 			? all.filter(m => validatePredicate(m, type, predicateObjs))
@@ -210,7 +228,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 		firstOrLast: QueryOne = QueryOne.FIRST,
 	): Promise<T | undefined> {
 		const storeName = this.getStorenameForModel(modelConstructor);
-		const result = <T>await this.db.getOne(firstOrLast, storeName);
+		const result = (await this.db.getOne(firstOrLast, storeName)) as T;
 
 		return result && this.modelInstanceCreator(modelConstructor, result);
 	}
@@ -232,7 +250,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 		}
 	}
 
-	//#region platform-specific helper methods
+	// #region platform-specific helper methods
 
 	/**
 	 * Retrieves concatenated primary key values from a model
@@ -246,7 +264,7 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 		);
 	}
 
-	//#endregion
+	// #endregion
 }
 
 export default new AsyncStorageAdapter();