@aws-amplify/datastore-storage-adapter 1.2.13 → 1.2.14-unstable.1

package/src/SQLiteAdapter/SQLiteAdapter.ts

@@ -1,478 +1,8 @@
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
 import SQLiteDatabase from './SQLiteDatabase';
-import {
-	generateSchemaStatements,
-	queryByIdStatement,
-	modelUpdateStatement,
-	modelInsertStatement,
-	queryAllStatement,
-	queryOneStatement,
-	deleteByIdStatement,
-	deleteByPredicateStatement,
-	ParameterizedStatement,
-} from './SQLiteUtils';
 
-import {
-	StorageAdapter,
-	ModelInstanceCreator,
-	ModelPredicateCreator,
-	ModelSortPredicateCreator,
-	InternalSchema,
-	isPredicateObj,
-	ModelInstanceMetadata,
-	ModelPredicate,
-	NamespaceResolver,
-	OpType,
-	PaginationInput,
-	PersistentModel,
-	PersistentModelConstructor,
-	PredicateObject,
-	PredicatesGroup,
-	QueryOne,
-	utils,
-} from '@aws-amplify/datastore';
+const SQLiteAdapter: CommonSQLiteAdapter = new CommonSQLiteAdapter(
+	new SQLiteDatabase()
+);
 
-const { traverseModel, validatePredicate, isModelConstructor } = utils;
-
-const logger = new Logger('DataStore');
-export class SQLiteAdapter implements StorageAdapter {
-	private schema: InternalSchema;
-	private namespaceResolver: NamespaceResolver;
-	private modelInstanceCreator: ModelInstanceCreator;
-	private getModelConstructorByModelName: (
-		namsespaceName: string,
-		modelName: string
-	) => PersistentModelConstructor<any>;
-	private db: SQLiteDatabase;
-	private initPromise: Promise<void>;
-	private resolve: (value?: any) => void;
-	private reject: (value?: any) => void;
-
-	public async setUp(
-		theSchema: InternalSchema,
-		namespaceResolver: NamespaceResolver,
-		modelInstanceCreator: ModelInstanceCreator,
-		getModelConstructorByModelName: (
-			namsespaceName: string,
-			modelName: string
-		) => PersistentModelConstructor<any>
-	) {
-		if (!this.initPromise) {
-			this.initPromise = new Promise((res, rej) => {
-				this.resolve = res;
-				this.reject = rej;
-			});
-		} else {
-			await this.initPromise;
-			return;
-		}
-		this.schema = theSchema;
-		this.namespaceResolver = namespaceResolver;
-		this.modelInstanceCreator = modelInstanceCreator;
-		this.getModelConstructorByModelName = getModelConstructorByModelName;
-
-		try {
-			if (!this.db) {
-				this.db = new SQLiteDatabase();
-				await this.db.init();
-
-				const statements = generateSchemaStatements(this.schema);
-				await this.db.createSchema(statements);
-				this.resolve();
-			}
-		} catch (error) {
-			this.reject(error);
-		}
-	}
-
-	async clear(): Promise<void> {
-		await this.db.clear();
-
-		this.db = undefined;
-		this.initPromise = undefined;
-	}
-
-	async save<T extends PersistentModel>(
-		model: T,
-		condition?: ModelPredicate<T>
-	): Promise<[T, OpType.INSERT | OpType.UPDATE][]> {
-		const modelConstructor = Object.getPrototypeOf(model)
-			.constructor as PersistentModelConstructor<T>;
-		const { name: tableName } = modelConstructor;
-		const connectedModels = traverseModel(
-			modelConstructor.name,
-			model,
-			this.schema.namespaces[this.namespaceResolver(modelConstructor)],
-			this.modelInstanceCreator,
-			this.getModelConstructorByModelName
-		);
-
-		const connectionStoreNames = Object.values(connectedModels).map(
-			({ modelName, item, instance }) => {
-				return { modelName, item, instance };
-			}
-		);
-
-		const [queryStatement, params] = queryByIdStatement(model.id, tableName);
-
-		const fromDB = await this.db.get(queryStatement, params);
-
-		if (condition && fromDB) {
-			const predicates = ModelPredicateCreator.getPredicates(condition);
-			const { predicates: predicateObjs, type } = predicates;
-
-			const isValid = validatePredicate(fromDB, type, predicateObjs);
-
-			if (!isValid) {
-				const msg = 'Conditional update failed';
-				logger.error(msg, { model: fromDB, condition: predicateObjs });
-
-				throw new Error(msg);
-			}
-		}
-
-		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
-		const saveStatements = new Set<ParameterizedStatement>();
-
-		for await (const resItem of connectionStoreNames) {
-			const { modelName, item, instance } = resItem;
-			const { id } = item;
-
-			const [queryStatement, params] = queryByIdStatement(id, modelName);
-			const fromDB = await this.db.get(queryStatement, params);
-
-			const opType: OpType =
-				fromDB === undefined ? OpType.INSERT : OpType.UPDATE;
-
-			const saveStatement = fromDB
-				? modelUpdateStatement(instance, modelName)
-				: modelInsertStatement(instance, modelName);
-
-			if (id === model.id || opType === OpType.INSERT) {
-				saveStatements.add(saveStatement);
-				result.push([instance, opType]);
-			}
-		}
-
-		await this.db.batchSave(saveStatements);
-		return result;
-	}
-
-	private async load<T>(
-		namespaceName: string,
-		srcModelName: string,
-		records: T[]
-	): Promise<T[]> {
-		const namespace = this.schema.namespaces[namespaceName];
-		const relations = namespace.relationships[srcModelName].relationTypes;
-		const connectionTableNames = relations.map(({ modelName }) => modelName);
-
-		const modelConstructor = this.getModelConstructorByModelName(
-			namespaceName,
-			srcModelName
-		);
-
-		if (connectionTableNames.length === 0) {
-			return records.map(record =>
-				this.modelInstanceCreator(modelConstructor, record)
-			);
-		}
-
-		for await (const relation of relations) {
-			const {
-				fieldName,
-				modelName: tableName,
-				targetName,
-				relationType,
-			} = relation;
-
-			const modelConstructor = this.getModelConstructorByModelName(
-				namespaceName,
-				tableName
-			);
-
-			// TODO: use SQL JOIN instead
-			switch (relationType) {
-				case 'HAS_ONE':
-					for await (const recordItem of records) {
-						const getByfield = recordItem[targetName] ? targetName : fieldName;
-						if (!recordItem[getByfield]) break;
-
-						const [queryStatement, params] = queryByIdStatement(
-							recordItem[getByfield],
-							tableName
-						);
-
-						const connectionRecord = await this.db.get(queryStatement, params);
-
-						recordItem[fieldName] =
-							connectionRecord &&
-							this.modelInstanceCreator(modelConstructor, connectionRecord);
-					}
-
-					break;
-				case 'BELONGS_TO':
-					for await (const recordItem of records) {
-						if (recordItem[targetName]) {
-							const [queryStatement, params] = queryByIdStatement(
-								recordItem[targetName],
-								tableName
-							);
-							const connectionRecord = await this.db.get(
-								queryStatement,
-								params
-							);
-
-							recordItem[fieldName] =
-								connectionRecord &&
-								this.modelInstanceCreator(modelConstructor, connectionRecord);
-							delete recordItem[targetName];
-						}
-					}
-
-					break;
-				case 'HAS_MANY':
-					// TODO: Lazy loading
-					break;
-				default:
-					const _: never = relationType as never;
-					throw new Error(`invalid relation type ${relationType}`);
-					break;
-			}
-		}
-
-		return records.map(record =>
-			this.modelInstanceCreator(modelConstructor, record)
-		);
-	}
-
-	async query<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<T>,
-		predicate?: ModelPredicate<T>,
-		pagination?: PaginationInput<T>
-	): Promise<T[]> {
-		const { name: tableName } = modelConstructor;
-		const namespaceName = this.namespaceResolver(modelConstructor);
-
-		const predicates =
-			predicate && ModelPredicateCreator.getPredicates(predicate);
-		const sortPredicates =
-			pagination &&
-			pagination.sort &&
-			ModelSortPredicateCreator.getPredicates(pagination.sort);
-		const limit = pagination && pagination.limit;
-		const page = limit && pagination.page;
-
-		const queryById = predicates && this.idFromPredicate(predicates);
-
-		const records: T[] = <T[]>await (async () => {
-			if (queryById) {
-				const record = await this.getById(tableName, queryById);
-				return record ? [record] : [];
-			}
-
-			const [queryStatement, params] = queryAllStatement(
-				tableName,
-				predicates,
-				sortPredicates,
-				limit,
-				page
-			);
-
-			return await this.db.getAll(queryStatement, params);
-		})();
-
-		return await this.load(namespaceName, modelConstructor.name, records);
-	}
-
-	private async getById<T extends PersistentModel>(
-		tableName: string,
-		id: string
-	): Promise<T> {
-		const [queryStatement, params] = queryByIdStatement(id, tableName);
-		const record = await this.db.get<T>(queryStatement, params);
-		return record;
-	}
-
-	private idFromPredicate<T extends PersistentModel>(
-		predicates: PredicatesGroup<T>
-	) {
-		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;
-	}
-
-	async queryOne<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<T>,
-		firstOrLast: QueryOne = QueryOne.FIRST
-	): Promise<T | undefined> {
-		const { name: tableName } = modelConstructor;
-		const [queryStatement, params] = queryOneStatement(firstOrLast, tableName);
-
-		const result = await this.db.get<T>(queryStatement, params);
-
-		const modelInstance =
-			result && this.modelInstanceCreator(modelConstructor, result);
-
-		return modelInstance;
-	}
-
-	// Currently does not cascade
-	// TODO: use FKs in relations and have `ON DELETE CASCADE` set
-	// For Has Many and Has One relations to have SQL handle cascades automatically
-	async delete<T extends PersistentModel>(
-		modelOrModelConstructor: T | PersistentModelConstructor<T>,
-		condition?: ModelPredicate<T>
-	): Promise<[T[], T[]]> {
-		if (isModelConstructor(modelOrModelConstructor)) {
-			const modelConstructor = modelOrModelConstructor;
-			const namespaceName = this.namespaceResolver(modelConstructor);
-			const { name: tableName } = modelConstructor;
-
-			const predicates =
-				condition && ModelPredicateCreator.getPredicates(condition);
-
-			const queryStatement = queryAllStatement(tableName, predicates);
-			const deleteStatement = deleteByPredicateStatement(tableName, predicates);
-
-			const models = await this.db.selectAndDelete(
-				queryStatement,
-				deleteStatement
-			);
-
-			const modelInstances = await this.load(
-				namespaceName,
-				modelConstructor.name,
-				models
-			);
-
-			return [modelInstances, modelInstances];
-		} else {
-			const model = modelOrModelConstructor as T;
-			const modelConstructor = Object.getPrototypeOf(model)
-				.constructor as PersistentModelConstructor<T>;
-			const { name: tableName } = modelConstructor;
-
-			if (condition) {
-				const [queryStatement, params] = queryByIdStatement(
-					model.id,
-					tableName
-				);
-
-				const fromDB = await this.db.get(queryStatement, params);
-
-				if (fromDB === undefined) {
-					const msg = 'Model instance not found in storage';
-					logger.warn(msg, { model });
-
-					return [[model], []];
-				}
-
-				const predicates = ModelPredicateCreator.getPredicates(condition);
-				const { predicates: predicateObjs, type } = predicates;
-
-				const isValid = validatePredicate(fromDB, type, predicateObjs);
-
-				if (!isValid) {
-					const msg = 'Conditional update failed';
-					logger.error(msg, { model: fromDB, condition: predicateObjs });
-
-					throw new Error(msg);
-				}
-
-				const [deleteStatement, deleteParams] = deleteByIdStatement(
-					model.id,
-					tableName
-				);
-				await this.db.save(deleteStatement, deleteParams);
-				return [[model], [model]];
-			} else {
-				const [deleteStatement, params] = deleteByIdStatement(
-					model.id,
-					tableName
-				);
-				await this.db.save(deleteStatement, params);
-				return [[model], [model]];
-			}
-		}
-	}
-
-	async batchSave<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<any>,
-		items: ModelInstanceMetadata[]
-	): Promise<[T, OpType][]> {
-		const { name: tableName } = modelConstructor;
-
-		const result: [T, OpType][] = [];
-
-		const itemsToSave: T[] = [];
-		// To determine whether an item should result in an insert or update operation
-		// We first need to query the local DB on the item id
-		const queryStatements = new Set<ParameterizedStatement>();
-		// Deletes don't need to be queried first, because if the item doesn't exist,
-		// the delete operation will be a no-op
-		const deleteStatements = new Set<ParameterizedStatement>();
-		const saveStatements = new Set<ParameterizedStatement>();
-
-		for (const item of items) {
-			const connectedModels = traverseModel(
-				modelConstructor.name,
-				this.modelInstanceCreator(modelConstructor, item),
-				this.schema.namespaces[this.namespaceResolver(modelConstructor)],
-				this.modelInstanceCreator,
-				this.getModelConstructorByModelName
-			);
-
-			const { id, _deleted } = item;
-
-			const { instance } = connectedModels.find(
-				({ instance }) => instance.id === id
-			);
-
-			if (_deleted) {
-				// create the delete statements right away
-				const deleteStatement = deleteByIdStatement(instance.id, tableName);
-				deleteStatements.add(deleteStatement);
-				result.push([<T>(<unknown>item), OpType.DELETE]);
-			} else {
-				// query statements for the saves at first
-				const queryStatement = queryByIdStatement(id, tableName);
-				queryStatements.add(queryStatement);
-				// combination of insert and update items
-				itemsToSave.push(instance);
-			}
-		}
-
-		// returns the query results for each of the save items
-		const queryResponses = await this.db.batchQuery(queryStatements);
-
-		queryResponses.forEach((response, idx) => {
-			if (response === undefined) {
-				const insertStatement = modelInsertStatement(
-					itemsToSave[idx],
-					tableName
-				);
-				saveStatements.add(insertStatement);
-				result.push([<T>(<unknown>itemsToSave[idx]), OpType.INSERT]);
-			} else {
-				const updateStatement = modelUpdateStatement(
-					itemsToSave[idx],
-					tableName
-				);
-				saveStatements.add(updateStatement);
-				result.push([<T>(<unknown>itemsToSave[idx]), OpType.UPDATE]);
-			}
-		});
-
-		// perform all of the insert/update/delete operations in a single transaction
-		await this.db.batchSave(saveStatements, deleteStatements);
-		return result;
-	}
-}
-
-export default new SQLiteAdapter();
+export default SQLiteAdapter;

package/src/SQLiteAdapter/SQLiteDatabase.ts

@@ -1,7 +1,8 @@
 import SQLite from 'react-native-sqlite-storage';
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
 import { PersistentModel } from '@aws-amplify/datastore';
-import { ParameterizedStatement } from './SQLiteUtils';
+import { DB_NAME } from '../common/constants';
+import { CommonSQLiteDatabase, ParameterizedStatement } from '../common/types';
 
 const logger = new Logger('SQLiteDatabase');
 
@@ -11,13 +12,6 @@ if (Logger.LOG_LEVEL === 'DEBUG') {
 	SQLite.DEBUG(true);
 }
 
-const DB_NAME = 'AmplifyDatastore';
-const DB_DISPLAYNAME = 'AWS Amplify DataStore SQLite Database';
-
-// TODO: make these configurable
-const DB_SIZE = 200000;
-const DB_VERSION = '1.0';
-
 /*
 
 Note: 
@@ -31,47 +25,41 @@ get the result of an `executeSql` command inside of a transaction
 
 */
 
-class SQLiteDatabase {
+class SQLiteDatabase implements CommonSQLiteDatabase {
 	private db: SQLite.SQLiteDatabase;
 
 	public async init(): Promise<void> {
-		this.db = await SQLite.openDatabase(
-			DB_NAME,
-			DB_VERSION,
-			DB_DISPLAYNAME,
-			DB_SIZE
-		);
+		// only open database once.
+		if (!this.db) {
+			this.db = await SQLite.openDatabase({
+				name: DB_NAME,
+				location: 'default',
+			});
+		}
 	}
 
-	public async createSchema(statements: string[]) {
+	public async createSchema(statements: string[]): Promise<void> {
 		return await this.executeStatements(statements);
 	}
 
-	public async clear() {
+	public async clear(): Promise<void> {
 		await this.closeDB();
 		logger.debug('Deleting database');
-		await SQLite.deleteDatabase(DB_NAME);
+		await SQLite.deleteDatabase({ name: DB_NAME, location: 'default' });
 		logger.debug('Database deleted');
 	}
 
 	public async get<T extends PersistentModel>(
 		statement: string,
-		params: any[]
+		params: (string | number)[]
 	): Promise<T> {
-		const [resultSet] = await this.db.executeSql(statement, params);
-		const result =
-			resultSet &&
-			resultSet.rows &&
-			resultSet.rows.length &&
-			resultSet.rows.raw &&
-			resultSet.rows.raw();
-
-		return result?.[0] || undefined;
+		const results: T[] = await this.getAll(statement, params);
+		return results[0];
 	}
 
 	public async getAll<T extends PersistentModel>(
 		statement: string,
-		params: any[]
+		params: (string | number)[]
 	): Promise<T[]> {
 		const [resultSet] = await this.db.executeSql(statement, params);
 		const result =
@@ -84,19 +72,24 @@ class SQLiteDatabase {
 		return result || [];
 	}
 
-	public async save(statement: string, params: any[]): Promise<void> {
+	public async save(
+		statement: string,
+		params: (string | number)[]
+	): Promise<void> {
 		await this.db.executeSql(statement, params);
 	}
 
-	public async batchQuery(queryStatements: Set<ParameterizedStatement>) {
+	public async batchQuery<T = any>(
+		queryParameterizedStatements: Set<ParameterizedStatement>
+	): Promise<T[]> {
 		const results = [];
 
-		await this.db.readTransaction(function (tx) {
-			for (const [statement, params] of queryStatements) {
+		await this.db.readTransaction(tx => {
+			for (const [statement, params] of queryParameterizedStatements) {
 				tx.executeSql(
 					statement,
 					params,
-					function (_tx, res) {
+					(_, res) => {
 						results.push(res.rows.raw()[0]);
 					},
 					logger.warn
@@ -108,35 +101,37 @@ class SQLiteDatabase {
 	}
 
 	public async batchSave(
-		saveStatements: Set<ParameterizedStatement>,
-		deleteStatements?: Set<ParameterizedStatement>
-	) {
-		await this.db.transaction(function (tx) {
-			for (const [statement, params] of saveStatements) {
+		saveParameterizedStatements: Set<ParameterizedStatement>,
+		deleteParameterizedStatements?: Set<ParameterizedStatement>
+	): Promise<void> {
+		await this.db.transaction(tx => {
+			for (const [statement, params] of saveParameterizedStatements) {
 				tx.executeSql(statement, params);
 			}
-			if (deleteStatements) {
-				for (const [statement, params] of deleteStatements) {
+		});
+		if (deleteParameterizedStatements) {
+			await this.db.transaction(tx => {
+				for (const [statement, params] of deleteParameterizedStatements) {
 					tx.executeSql(statement, params);
 				}
-			}
-		});
+			});
+		}
 	}
 
-	public async selectAndDelete(
-		query: ParameterizedStatement,
-		_delete: ParameterizedStatement
-	) {
-		let results = [];
+	public async selectAndDelete<T = any>(
+		queryParameterizedStatement: ParameterizedStatement,
+		deleteParameterizedStatement: ParameterizedStatement
+	): Promise<T[]> {
+		let results: T[] = [];
 
-		const [queryStatement, queryParams] = query;
-		const [deleteStatement, deleteParams] = _delete;
+		const [queryStatement, queryParams] = queryParameterizedStatement;
+		const [deleteStatement, deleteParams] = deleteParameterizedStatement;
 
-		await this.db.transaction(function (tx) {
+		await this.db.transaction(tx => {
 			tx.executeSql(
 				queryStatement,
 				queryParams,
-				function (_tx, res) {
+				(_, res) => {
 					results = res.rows.raw();
 				},
 				logger.warn
@@ -148,7 +143,7 @@ class SQLiteDatabase {
 	}
 
 	private async executeStatements(statements: string[]): Promise<void> {
-		return await this.db.transaction(function (tx) {
+		await this.db.transaction(tx => {
 			for (const statement of statements) {
 				tx.executeSql(statement);
 			}
@@ -160,6 +155,7 @@ class SQLiteDatabase {
 			logger.debug('Closing Database');
 			await this.db.close();
 			logger.debug('Database closed');
+			this.db = undefined;
 		}
 	}
 }