@aws-amplify/datastore 3.12.6-next.20 → 3.12.6-next.32

package/src/storage/adapter/AsyncStorageDatabase.ts

@@ -6,7 +6,11 @@ import {
 	PersistentModel,
 	QueryOne,
 } from '../../types';
-import { monotonicUlidFactory } from '../../util';
+import {
+	DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR,
+	indexNameFromKeys,
+	monotonicUlidFactory,
+} from '../../util';
 import { createInMemoryStore } from './InMemoryStore';
 
 const DB_NAME = '@AmplifyDatastore';
@@ -23,6 +27,11 @@ class AsyncStorageDatabase {
 
 	private storage = createInMemoryStore();
 
+	/**
+	 * Collection index is map of stores (i.e. sync, metadata, mutation event, and data)
+	 * @param storeName {string} - Name of the store
+	 * @returns Map of ulid->id
+	 */
 	private getCollectionIndex(storeName: string) {
 		if (!this._collectionInMemoryIndex.has(storeName)) {
 			this._collectionInMemoryIndex.set(storeName, new Map());
@@ -31,6 +40,11 @@ class AsyncStorageDatabase {
 		return this._collectionInMemoryIndex.get(storeName);
 	}
 
+	/**
+	 * Return ULID for store if it exists, otherwise create a new one
+	 * @param storeName {string} - Name of the store
+	 * @returns ulid
+	 */
 	private getMonotonicFactory(storeName: string): ULID {
 		if (!monotonicFactoriesMap.has(storeName)) {
 			monotonicFactoriesMap.set(storeName, monotonicUlidFactory());
@@ -85,39 +99,63 @@ class AsyncStorageDatabase {
 		}
 	}
 
-	async save<T extends PersistentModel>(item: T, storeName: string) {
+	async save<T extends PersistentModel>(
+		item: T,
+		storeName: string,
+		keys: string[],
+		keyValuesPath: string
+	) {
+		const idxName = indexNameFromKeys(keys);
+
 		const ulid =
-			this.getCollectionIndex(storeName).get(item.id) ||
+			this.getCollectionIndex(storeName).get(idxName) ||
 			this.getMonotonicFactory(storeName)();
 
-		const itemKey = this.getKeyForItem(storeName, item.id, ulid);
+		// Retrieve db key for item
+		const itemKey = this.getKeyForItem(storeName, keyValuesPath, ulid);
 
-		this.getCollectionIndex(storeName).set(item.id, ulid);
+		// Set key in collection index
+		this.getCollectionIndex(storeName).set(keyValuesPath, ulid);
 
+		// Save item in db
 		await this.storage.setItem(itemKey, JSON.stringify(item));
 	}
 
 	async batchSave<T extends PersistentModel>(
 		storeName: string,
-		items: ModelInstanceMetadata[]
+		items: ModelInstanceMetadata[],
+		keys: string[]
 	): Promise<[T, OpType][]> {
 		if (items.length === 0) {
 			return [];
 		}
 
 		const result: [T, OpType][] = [];
-
 		const collection = this.getCollectionIndex(storeName);
 
 		const keysToDelete = new Set<string>();
 		const keysToSave = new Set<string>();
 		const allItemsKeys = [];
 		const itemsMap: Record<string, { ulid: string; model: T }> = {};
+
+		/* Populate allItemKeys, keysToDelete, and keysToSave */
 		for (const item of items) {
-			const { id, _deleted } = item;
-			const ulid = collection.get(id) || this.getMonotonicFactory(storeName)();
+			// Extract keys from concatenated key path, map to item values
+			const keyValues = keys.map(field => item[field]);
 
-			const key = this.getKeyForItem(storeName, id, ulid);
+			const { _deleted } = item;
+
+			// If id is in the store, retrieve, otherwise generate new ULID
+			const ulid =
+				collection.get(keyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR)) ||
+				this.getMonotonicFactory(storeName)();
+
+			// Generate the "longer key" for the item
+			const key = this.getKeyForItem(
+				storeName,
+				keyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR),
+				ulid
+			);
 
 			allItemsKeys.push(key);
 			itemsMap[key] = { ulid, model: <T>(<unknown>item) };
@@ -136,6 +174,7 @@ class AsyncStorageDatabase {
 			.filter(([, v]) => !!v)
 			.reduce((set, [k]) => set.add(k), new Set<string>());
 
+		// Delete
 		await new Promise((resolve, reject) => {
 			if (keysToDelete.size === 0) {
 				resolve();
@@ -144,9 +183,15 @@ class AsyncStorageDatabase {
 
 			const keysToDeleteArray = Array.from(keysToDelete);
 
-			keysToDeleteArray.forEach(key =>
-				collection.delete(itemsMap[key].model.id)
-			);
+			keysToDeleteArray.forEach(key => {
+				// key: full db key
+				// keys: PK and/or SK keys
+				const primaryKeyValues: string = keys
+					.map(field => itemsMap[key].model[field])
+					.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+
+				collection.delete(primaryKeyValues);
+			});
 
 			this.storage.multiRemove(keysToDeleteArray, (errors?: Error[]) => {
 				if (errors && errors.length > 0) {
@@ -157,6 +202,7 @@ class AsyncStorageDatabase {
 			});
 		});
 
+		// Save
 		await new Promise((resolve, reject) => {
 			if (keysToSave.size === 0) {
 				resolve();
@@ -169,12 +215,14 @@ class AsyncStorageDatabase {
 			]);
 
 			keysToSave.forEach(key => {
-				const {
-					model: { id },
-					ulid,
-				} = itemsMap[key];
+				const { model, ulid } = itemsMap[key];
+
+				// Retrieve values from model, use as key for collection index
+				const keyValues: string = keys
+					.map(field => model[field])
+					.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
 
-				collection.set(id, ulid);
+				collection.set(keyValues, ulid);
 			});
 
 			this.storage.multiSet(entriesToSet, (errors?: Error[]) => {
@@ -201,11 +249,11 @@ class AsyncStorageDatabase {
 	}
 
 	async get<T extends PersistentModel>(
-		id: string,
+		keyValuePath: string,
 		storeName: string
 	): Promise<T> {
-		const ulid = this.getCollectionIndex(storeName).get(id);
-		const itemKey = this.getKeyForItem(storeName, id, ulid);
+		const ulid = this.getCollectionIndex(storeName).get(keyValuePath);
+		const itemKey = this.getKeyForItem(storeName, keyValuePath, ulid);
 		const recordAsString = await this.storage.getItem(itemKey);
 		const record = recordAsString && JSON.parse(recordAsString);
 		return record;
@@ -227,6 +275,7 @@ class AsyncStorageDatabase {
 						return [id, ulid];
 				  })();
 		const itemKey = this.getKeyForItem(storeName, itemId, ulid);
+
 		const itemString = itemKey && (await this.storage.getItem(itemKey));
 
 		const result = itemString ? JSON.parse(itemString) || undefined : undefined;
@@ -272,11 +321,10 @@ class AsyncStorageDatabase {
 		return records;
 	}
 
-	async delete(id: string, storeName: string) {
-		const ulid = this.getCollectionIndex(storeName).get(id);
-		const itemKey = this.getKeyForItem(storeName, id, ulid);
-
-		this.getCollectionIndex(storeName).delete(id);
+	async delete(key: string, storeName: string) {
+		const ulid = this.getCollectionIndex(storeName).get(key);
+		const itemKey = this.getKeyForItem(storeName, key, ulid);
+		this.getCollectionIndex(storeName).delete(key);
 		await this.storage.removeItem(itemKey);
 	}