@aws-amplify/datastore-storage-adapter 1.2.8-cloud-logging.7 → 1.2.8-cloud-logging.8

package/src/SQLiteAdapter/SQLiteDatabase.ts

@@ -66,7 +66,7 @@ class SQLiteDatabase {
 			resultSet.rows.raw &&
 			resultSet.rows.raw();
 
-		return result[0] || undefined;
+		return result?.[0] || undefined;
 	}
 
 	public async getAll<T extends PersistentModel>(
@@ -91,12 +91,12 @@ class SQLiteDatabase {
 	public async batchQuery(queryStatements: Set<ParameterizedStatement>) {
 		const results = [];
 
-		await this.db.readTransaction(function(tx) {
+		await this.db.readTransaction(function (tx) {
 			for (const [statement, params] of queryStatements) {
 				tx.executeSql(
 					statement,
 					params,
-					function(_tx, res) {
+					function (_tx, res) {
 						results.push(res.rows.raw()[0]);
 					},
 					logger.warn
@@ -111,7 +111,7 @@ class SQLiteDatabase {
 		saveStatements: Set<ParameterizedStatement>,
 		deleteStatements?: Set<ParameterizedStatement>
 	) {
-		await this.db.transaction(function(tx) {
+		await this.db.transaction(function (tx) {
 			for (const [statement, params] of saveStatements) {
 				tx.executeSql(statement, params);
 			}
@@ -132,11 +132,11 @@ class SQLiteDatabase {
 		const [queryStatement, queryParams] = query;
 		const [deleteStatement, deleteParams] = _delete;
 
-		await this.db.transaction(function(tx) {
+		await this.db.transaction(function (tx) {
 			tx.executeSql(
 				queryStatement,
 				queryParams,
-				function(_tx, res) {
+				function (_tx, res) {
 					results = res.rows.raw();
 				},
 				logger.warn
@@ -148,7 +148,7 @@ class SQLiteDatabase {
 	}
 
 	private async executeStatements(statements: string[]): Promise<void> {
-		return await this.db.transaction(function(tx) {
+		return await this.db.transaction(function (tx) {
 			for (const statement of statements) {
 				tx.executeSql(statement);
 			}

package/src/SQLiteAdapter/SQLiteUtils.ts

@@ -236,6 +236,30 @@ const logicalOperatorMap = {
 	between: 'BETWEEN',
 };
 
+/**
+ * If the given (operator, operand) indicate the need for a special `NULL` comparison,
+ * that `WHERE` clause condition will be returned. If not special `NULL` handling is
+ * needed, `null` will be returned, and the caller should construct the `WHERE`
+ * clause component using the normal operator map(s) and parameterization.
+ *
+ * @param operator "beginsWith" | "contains" | "notContains" | "between"
+ * | "eq" | "ne" | "le" | "lt" | "ge" | "gt"
+ * @param operand any
+ * @returns (string | null) The `WHERE` clause component or `null` if N/A.
+ */
+function buildSpecialNullComparison(field, operator, operand) {
+	if (operand === null || operand === undefined) {
+		if (operator === 'eq') {
+			return `"${field}" IS NULL`;
+		} else if (operator === 'ne') {
+			return `"${field}" IS NOT NULL`;
+		}
+	}
+
+	// no special null handling required
+	return null;
+}
+
 const whereConditionFromPredicateObject = ({
 	field,
 	operator,
@@ -247,8 +271,16 @@ const whereConditionFromPredicateObject = ({
 		| keyof typeof comparisonOperatorMap;
 	operand: any;
 }): ParameterizedStatement => {
-	const comparisonOperator = comparisonOperatorMap[operator];
+	const specialNullClause = buildSpecialNullComparison(
+		field,
+		operator,
+		operand
+	);
+	if (specialNullClause) {
+		return [specialNullClause, []];
+	}
 
+	const comparisonOperator = comparisonOperatorMap[operator];
 	if (comparisonOperator) {
 		return [`"${field}" ${comparisonOperator} ?`, [operand]];
 	}