@aws-amplify/datastore 3.7.3 → 3.7.4-custom-pk.79

package/src/predicates/index.ts

@@ -8,7 +8,11 @@ import {
 	ProducerModelPredicate,
 	SchemaModel,
 } from '../types';
-import { exhaustiveCheck } from '../util';
+import {
+	exhaustiveCheck,
+	extractPrimaryKeyFieldNames,
+	extractPrimaryKeyValues,
+} from '../util';
 
 export { ModelSortPredicateCreator } from './sort';
 
@@ -85,7 +89,7 @@ export class ModelPredicateCreator {
 
 								// Push the group to the top-level recorder
 								ModelPredicateCreator.predicateGroupsMap
-									.get(receiver)
+									.get(receiver)!
 									.predicates.push(group);
 
 								return receiver;
@@ -109,7 +113,7 @@ export class ModelPredicateCreator {
 						operand: any
 					) => {
 						ModelPredicateCreator.predicateGroupsMap
-							.get(receiver)
+							.get(receiver)!
 							.predicates.push({ field, operator, operand });
 						return receiver;
 					};
@@ -147,7 +151,7 @@ export class ModelPredicateCreator {
 	// transforms cb-style predicate into Proxy
 	static createFromExisting<T extends PersistentModel>(
 		modelDefinition: SchemaModel,
-		existing: ProducerModelPredicate<T>
+		existing?: ProducerModelPredicate<T>
 	) {
 		if (!existing || !modelDefinition) {
 			return undefined;
@@ -158,13 +162,31 @@ export class ModelPredicateCreator {
 		);
 	}
 
-	static createForId<T extends PersistentModel>(
+	static createForSingleField<T extends PersistentModel>(
 		modelDefinition: SchemaModel,
-		id: string
+		fieldName: string,
+		value: string
 	) {
-		return ModelPredicateCreator.createPredicateBuilder<T>(modelDefinition).id(
-			'eq',
-			<any>id
-		);
+		return ModelPredicateCreator.createPredicateBuilder<T>(modelDefinition)[
+			fieldName
+		](<any>'eq', <any>value);
+	}
+
+	static createForPk<T extends PersistentModel>(
+		modelDefinition: SchemaModel,
+		model: T
+	) {
+		const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+		const keyValues = extractPrimaryKeyValues(model, keyFields);
+
+		let modelPredicate =
+			ModelPredicateCreator.createPredicateBuilder<T>(modelDefinition);
+
+		keyFields.forEach((field, idx) => {
+			const operand = keyValues[idx];
+			modelPredicate = modelPredicate[field](<any>'eq', <any>operand);
+		});
+
+		return modelPredicate;
 	}
 }

package/src/storage/adapter/AsyncStorageAdapter.ts

@@ -33,6 +33,8 @@ import {
 
 const logger = new Logger('DataStore');
 
+const DEFAULT_PRIMARY_KEY_SEPARATOR = '#';
+
 export class AsyncStorageAdapter implements Adapter {
 	private schema: InternalSchema;
 	private namespaceResolver: NamespaceResolver;
@@ -61,6 +63,55 @@ export class AsyncStorageAdapter implements Adapter {
 		return storeName;
 	}
 
+	// Returns primary keys for a model
+	private getIndexKeys(namespaceName: string, modelName: string): string[] {
+		const keyPath =
+			this.schema.namespaces[namespaceName]?.keys[modelName]?.primaryKey;
+
+		if (keyPath) {
+			return keyPath;
+		}
+
+		return ['id'];
+	}
+
+	// Retrieves concatenated primary key values from a model
+	private getIndexKeyValuesPath<T extends PersistentModel>(model: T): string {
+		const modelConstructor = Object.getPrototypeOf(model)
+			.constructor as PersistentModelConstructor<T>;
+		const namespaceName = this.namespaceResolver(modelConstructor);
+		const keys = this.getIndexKeys(namespaceName, modelConstructor.name);
+
+		// Retrieve key values from model
+		const keyValues = keys.map(field => model[field]);
+
+		// Return concatenated key values
+		return keyValues.join(DEFAULT_PRIMARY_KEY_SEPARATOR);
+	}
+
+	// Retrieves concatenated primary key values from a model
+	private getIndexKeyValues<T extends PersistentModel>(model: T): string[] {
+		const modelConstructor = Object.getPrototypeOf(model)
+			.constructor as PersistentModelConstructor<T>;
+		const namespaceName = this.namespaceResolver(modelConstructor);
+		const keys = this.getIndexKeys(namespaceName, modelConstructor.name);
+
+		// Retrieve key values from model
+		return keys.map(field => model[field]);
+	}
+
+	private keysEqual(keysA, keysB): boolean {
+		if (keysA.length !== keysB.length) {
+			return false;
+		}
+
+		if (keysA.length === 1) {
+			return keysA[0] === keysB[0];
+		}
+
+		return keysA.every((key, idx) => key === keysB[idx]);
+	}
+
 	async setUp(
 		theSchema: InternalSchema,
 		namespaceResolver: NamespaceResolver,
@@ -101,23 +152,29 @@ export class AsyncStorageAdapter implements Adapter {
 		const modelConstructor = Object.getPrototypeOf(model)
 			.constructor as PersistentModelConstructor<T>;
 		const storeName = this.getStorenameForModel(modelConstructor);
+
+		const namespaceName = this.namespaceResolver(modelConstructor);
+
 		const connectedModels = traverseModel(
 			modelConstructor.name,
 			model,
-			this.schema.namespaces[this.namespaceResolver(modelConstructor)],
+			this.schema.namespaces[namespaceName],
 			this.modelInstanceCreator,
 			this.getModelConstructorByModelName
 		);
-		const namespaceName = this.namespaceResolver(modelConstructor);
+
 		const set = new Set<string>();
 		const connectionStoreNames = Object.values(connectedModels).map(
 			({ modelName, item, instance }) => {
 				const storeName = this.getStorename(namespaceName, modelName);
 				set.add(storeName);
-				return { storeName, item, instance };
+				const keys = this.getIndexKeys(namespaceName, modelName);
+				return { storeName, item, instance, keys };
 			}
 		);
-		const fromDB = await this.db.get(model.id, storeName);
+		const keyValuesPath = this.getIndexKeyValuesPath(model);
+
+		const fromDB = await this.db.get(keyValuesPath, storeName);
 
 		if (condition && fromDB) {
 			const predicates = ModelPredicateCreator.getPredicates(condition);
@@ -136,14 +193,22 @@ export class AsyncStorageAdapter implements Adapter {
 		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
 
 		for await (const resItem of connectionStoreNames) {
-			const { storeName, item, instance } = resItem;
-			const { id } = item;
+			const { storeName, item, instance, keys } = resItem;
+
+			/* Find the key values in the item, and concatenate them */
+			const itemKeyValues: string[] = keys.map(key => item[key]);
+			const itemKeyValuesPath: string = itemKeyValues.join(
+				DEFAULT_PRIMARY_KEY_SEPARATOR
+			);
 
-			const fromDB = <T>await this.db.get(id, storeName);
+			const fromDB = <T>await this.db.get(itemKeyValuesPath, storeName);
 			const opType: OpType = fromDB ? OpType.UPDATE : OpType.INSERT;
+			const modelKeyValues = this.getIndexKeyValues(model);
+			const keysEqual = this.keysEqual(itemKeyValues, modelKeyValues);
 
-			if (id === model.id || opType === OpType.INSERT) {
-				await this.db.save(item, storeName);
+			// If item key values and model key values are equal, save to db
+			if (keysEqual || opType === OpType.INSERT) {
+				await this.db.save(item, storeName, keys, itemKeyValuesPath);
 
 				result.push([instance, opType]);
 			}
@@ -187,10 +252,9 @@ export class AsyncStorageAdapter implements Adapter {
 						const getByfield = recordItem[targetName] ? targetName : fieldName;
 						if (!recordItem[getByfield]) break;
 
-						const connectionRecord = await this.db.get(
-							recordItem[getByfield],
-							storeName
-						);
+						const key = recordItem[getByfield];
+
+						const connectionRecord = await this.db.get(key, storeName);
 
 						recordItem[fieldName] =
 							connectionRecord &&
@@ -201,10 +265,9 @@ export class AsyncStorageAdapter implements Adapter {
 				case 'BELONGS_TO':
 					for await (const recordItem of records) {
 						if (recordItem[targetName]) {
-							const connectionRecord = await this.db.get(
-								recordItem[targetName],
-								storeName
-							);
+							const key = recordItem[targetName];
+
+							const connectionRecord = await this.db.get(key, storeName);
 
 							recordItem[fieldName] =
 								connectionRecord &&
@@ -238,13 +301,16 @@ export class AsyncStorageAdapter implements Adapter {
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
-		const queryById = predicates && this.idFromPredicate(predicates);
+		const keys = this.getIndexKeys(namespaceName, modelConstructor.name);
+		const queryByKey =
+			predicates && this.keyValueFromPredicate(predicates, keys);
+
 		const hasSort = pagination && pagination.sort;
 		const hasPagination = pagination && pagination.limit;
 
 		const records: T[] = await (async () => {
-			if (queryById) {
-				const record = await this.getById(storeName, queryById);
+			if (queryByKey) {
+				const record = await this.getByKey(storeName, queryByKey);
 				return record ? [record] : [];
 			}
 
@@ -264,11 +330,11 @@ export class AsyncStorageAdapter implements Adapter {
 		return await this.load(namespaceName, modelConstructor.name, records);
 	}
 
-	private async getById<T extends PersistentModel>(
+	private async getByKey<T extends PersistentModel>(
 		storeName: string,
-		id: string
+		keyValuePath: string
 	): Promise<T> {
-		const record = <T>await this.db.get(id, storeName);
+		const record = <T>await this.db.get(keyValuePath, storeName);
 		return record;
 	}
 
@@ -278,17 +344,29 @@ export class AsyncStorageAdapter implements Adapter {
 		return await this.db.getAll(storeName);
 	}
 
-	private idFromPredicate<T extends PersistentModel>(
-		predicates: PredicatesGroup<T>
-	) {
+	private keyValueFromPredicate<T extends PersistentModel>(
+		predicates: PredicatesGroup<T>,
+		keys: string[]
+	): string | undefined {
 		const { predicates: predicateObjs } = predicates;
-		const idPredicate =
-			predicateObjs.length === 1 &&
-			(predicateObjs.find(
-				p => isPredicateObj(p) && p.field === 'id' && p.operator === 'eq'
-			) as PredicateObject<T>);
 
-		return idPredicate && idPredicate.operand;
+		if (predicateObjs.length !== keys.length) {
+			return;
+		}
+
+		const keyValues = [];
+
+		for (const key of keys) {
+			const predicateObj = predicateObjs.find(
+				p => isPredicateObj(p) && p.field === key && p.operator === 'eq'
+			) as PredicateObject<T>;
+
+			predicateObj && keyValues.push(predicateObj.operand);
+		}
+
+		return keyValues.length === keys.length
+			? keyValues.join(DEFAULT_PRIMARY_KEY_SEPARATOR)
+			: undefined;
 	}
 
 	private async filterOnPredicate<T extends PersistentModel>(
@@ -328,6 +406,7 @@ export class AsyncStorageAdapter implements Adapter {
 
 			return records.slice(start, end);
 		}
+
 		return records;
 	}
 
@@ -337,6 +416,7 @@ export class AsyncStorageAdapter implements Adapter {
 	): Promise<T | undefined> {
 		const storeName = this.getStorenameForModel(modelConstructor);
 		const result = <T>await this.db.getOne(firstOrLast, storeName);
+
 		return result && this.modelInstanceCreator(modelConstructor, result);
 	}
 
@@ -372,6 +452,7 @@ export class AsyncStorageAdapter implements Adapter {
 					(acc, { items }) => acc.concat(items),
 					<T[]>[]
 				);
+
 				return [models, deletedModels];
 			} else {
 				await this.deleteTraverse(
@@ -396,11 +477,14 @@ export class AsyncStorageAdapter implements Adapter {
 
 			const modelConstructor = Object.getPrototypeOf(model)
 				.constructor as PersistentModelConstructor<T>;
-			const nameSpace = this.namespaceResolver(modelConstructor);
+			const namespaceName = this.namespaceResolver(modelConstructor);
 
 			const storeName = this.getStorenameForModel(modelConstructor);
+
 			if (condition) {
-				const fromDB = await this.db.get(model.id, storeName);
+				const keyValuePath = this.getIndexKeyValuesPath(model);
+
+				const fromDB = await this.db.get(keyValuePath, storeName);
 
 				if (fromDB === undefined) {
 					const msg = 'Model instance not found in storage';
@@ -421,25 +505,28 @@ export class AsyncStorageAdapter implements Adapter {
 				}
 
 				const relations =
-					this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
-						.relationTypes;
+					this.schema.namespaces[namespaceName].relationships[
+						modelConstructor.name
+					].relationTypes;
+
 				await this.deleteTraverse(
 					relations,
 					[model],
 					modelConstructor.name,
-					nameSpace,
+					namespaceName,
 					deleteQueue
 				);
 			} else {
 				const relations =
-					this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
-						.relationTypes;
+					this.schema.namespaces[namespaceName].relationships[
+						modelConstructor.name
+					].relationTypes;
 
 				await this.deleteTraverse(
 					relations,
 					[model],
 					modelConstructor.name,
-					nameSpace,
+					namespaceName,
 					deleteQueue
 				);
 			}
@@ -464,8 +551,8 @@ export class AsyncStorageAdapter implements Adapter {
 			for await (const item of items) {
 				if (item) {
 					if (typeof item === 'object') {
-						const id = item['id'];
-						await this.db.delete(id, storeName);
+						const keyValuesPath: string = this.getIndexKeyValuesPath(item as T);
+						await this.db.delete(keyValuesPath, storeName);
 					}
 				}
 			}
@@ -487,10 +574,16 @@ export class AsyncStorageAdapter implements Adapter {
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
 		for await (const rel of relations) {
-			const { relationType, modelName, targetName } = rel;
+			const {
+				relationType,
+				modelName,
+				targetName,
+				targetNames,
+				associatedWith,
+			} = rel;
 			const storeName = this.getStorename(nameSpace, modelName);
 
-			const index: string =
+			const index: any =
 				getIndex(
 					this.schema.namespaces[nameSpace].relationships[modelName]
 						.relationTypes,
@@ -507,18 +600,20 @@ export class AsyncStorageAdapter implements Adapter {
 			switch (relationType) {
 				case 'HAS_ONE':
 					for await (const model of models) {
-						const hasOneIndex = index || 'byId';
-
+						const hasOneIndex = index || associatedWith;
 						const hasOneCustomField = targetName in model;
-						const value = hasOneCustomField ? model[targetName] : model.id;
+						const keyValuesPath: string = this.getIndexKeyValuesPath(model);
+						const value = hasOneCustomField ? model[targetName] : keyValuesPath;
+
 						if (!value) break;
 
 						const allRecords = await this.db.getAll(storeName);
+
 						const recordToDelete = allRecords.filter(
 							childItem => childItem[hasOneIndex] === value
-						);
+						) as T[];
 
-						await this.deleteTraverse(
+						await this.deleteTraverse<T>(
 							this.schema.namespaces[nameSpace].relationships[modelName]
 								.relationTypes,
 							recordToDelete,
@@ -530,12 +625,14 @@ export class AsyncStorageAdapter implements Adapter {
 					break;
 				case 'HAS_MANY':
 					for await (const model of models) {
+						const keyValuesPath: string = this.getIndexKeyValuesPath(model);
+
 						const allRecords = await this.db.getAll(storeName);
 						const childrenArray = allRecords.filter(
-							childItem => childItem[index] === model.id
-						);
+							childItem => childItem[index] === keyValuesPath
+						) as T[];
 
-						await this.deleteTraverse(
+						await this.deleteTraverse<T>(
 							this.schema.namespaces[nameSpace].relationships[modelName]
 								.relationTypes,
 							childrenArray,
@@ -579,28 +676,31 @@ export class AsyncStorageAdapter implements Adapter {
 		const { name: modelName } = modelConstructor;
 		const namespaceName = this.namespaceResolver(modelConstructor);
 		const storeName = this.getStorename(namespaceName, modelName);
-
+		const keys = this.getIndexKeys(namespaceName, modelName);
 		const batch: ModelInstanceMetadata[] = [];
 
 		for (const item of items) {
-			const { id } = item;
+			const model = this.modelInstanceCreator(modelConstructor, item);
 
 			const connectedModels = traverseModel(
-				modelConstructor.name,
-				this.modelInstanceCreator(modelConstructor, item),
-				this.schema.namespaces[this.namespaceResolver(modelConstructor)],
+				modelName,
+				model,
+				this.schema.namespaces[namespaceName],
 				this.modelInstanceCreator,
 				this.getModelConstructorByModelName
 			);
 
-			const { instance } = connectedModels.find(
-				({ instance }) => instance.id === id
-			);
+			const keyValuesPath = this.getIndexKeyValuesPath(model);
+
+			const { instance } = connectedModels.find(({ instance }) => {
+				const instanceKeyValuesPath = this.getIndexKeyValuesPath(instance);
+				return this.keysEqual([instanceKeyValuesPath], [keyValuesPath]);
+			});
 
 			batch.push(instance);
 		}
 
-		return await this.db.batchSave(storeName, batch);
+		return await this.db.batchSave(storeName, batch, keys);
 	}
 }
 

package/src/storage/adapter/AsyncStorageDatabase.ts

@@ -15,6 +15,8 @@ const DATA = 'Data';
 
 const monotonicFactoriesMap = new Map<string, ULID>();
 
+const DEFAULT_PRIMARY_KEY_SEPARATOR = ':::';
+
 class AsyncStorageDatabase {
 	/**
 	 * Maps storeNames to a map of ulid->id
@@ -23,14 +25,17 @@ class AsyncStorageDatabase {
 
 	private storage = createInMemoryStore();
 
+	// Collection index is map of stores (i.e. sync, metadata, mutation event, and data)
 	private getCollectionIndex(storeName: string) {
 		if (!this._collectionInMemoryIndex.has(storeName)) {
 			this._collectionInMemoryIndex.set(storeName, new Map());
 		}
 
+		// Map of ulid->id
 		return this._collectionInMemoryIndex.get(storeName);
 	}
 
+	// Return ULID for store if it exists, otherwise create a new one
 	private getMonotonicFactory(storeName: string): ULID {
 		if (!monotonicFactoriesMap.has(storeName)) {
 			monotonicFactoriesMap.set(storeName, monotonicUlidFactory());
@@ -85,39 +90,61 @@ 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 ulid =
-			this.getCollectionIndex(storeName).get(item.id) ||
+			this.getCollectionIndex(storeName).get(keys[0]) ||
 			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_SEPARATOR)) ||
+				this.getMonotonicFactory(storeName)();
+
+			// Generate the "longer key" for the item
+			const key = this.getKeyForItem(
+				storeName,
+				keyValues.join(DEFAULT_PRIMARY_KEY_SEPARATOR),
+				ulid
+			);
 
 			allItemsKeys.push(key);
 			itemsMap[key] = { ulid, model: <T>(<unknown>item) };
@@ -136,6 +163,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 +172,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_SEPARATOR);
+
+				collection.delete(primaryKeyValues);
+			});
 
 			this.storage.multiRemove(keysToDeleteArray, (errors?: Error[]) => {
 				if (errors && errors.length > 0) {
@@ -157,6 +191,7 @@ class AsyncStorageDatabase {
 			});
 		});
 
+		// Save
 		await new Promise((resolve, reject) => {
 			if (keysToSave.size === 0) {
 				resolve();
@@ -169,12 +204,14 @@ class AsyncStorageDatabase {
 			]);
 
 			keysToSave.forEach(key => {
-				const {
-					model: { id },
-					ulid,
-				} = itemsMap[key];
+				const { model, ulid } = itemsMap[key];
 
-				collection.set(id, ulid);
+				// Retrieve values from model, use as key for collection index
+				const keyValues: string = keys
+					.map(field => model[field])
+					.join(DEFAULT_PRIMARY_KEY_SEPARATOR);
+
+				collection.set(keyValues, ulid);
 			});
 
 			this.storage.multiSet(entriesToSet, (errors?: Error[]) => {
@@ -201,11 +238,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 +264,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 +310,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);
 	}