chore(datastore): remove tslint and enable eslint

.eslintrc.js

@@ -54,26 +54,6 @@ module.exports = {
 		'packages/rtn-push-notification/__tests__',
 		'packages/rtn-web-browser/__tests__',
 		// 'packages/storage/__tests__',
-		// will enable lint by packages
-		// 'adapter-nextjs',
-		// 'packages/analytics',
-		// 'packages/api',
-		// 'packages/api-graphql',
-		// 'packages/api-rest',
-		// 'packages/auth',
-		// 'packages/aws-amplify',
-		// 'packages/core',
-		'packages/datastore',
-		'packages/datastore-storage-adapter',
-		// 'packages/geo',
-		// 'packages/interactions',
-		// 'packages/notifications',
-		// 'packages/predictions',
-		// 'packages/pubsub',
-		// 'packages/react-native',
-		// 'packages/rtn-push-notification',
-		// 'packages/rtn-web-browser',
-		// 'packages/storage',
 	],
 	rules: {
 		camelcase: [

packages/datastore-storage-adapter/package.json

@@ -18,7 +18,8 @@
 		"build": "npm run clean && npm run build:esm-cjs && npm run build:umd",
 		"clean": "rimraf dist lib lib-esm",
 		"format": "echo \"Not implemented\"",
-		"lint": "tslint '{__tests__,src}/**/*.ts'  && npm run ts-coverage",
+		"lint": "eslint '**/*.{ts,tsx}' && npm run ts-coverage",
+		"lint:fix": "eslint '**/*.{ts,tsx}' --fix",
 		"ts-coverage": "typescript-coverage-report -p ./tsconfig.build.json -t 94.16"
 	},
 	"repository": {

packages/datastore-storage-adapter/src/ExpoSQLiteAdapter/ExpoSQLiteAdapter.ts

@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
+
 import ExpoSQLiteDatabase from './ExpoSQLiteDatabase';
 
 const ExpoSQLiteAdapter: CommonSQLiteAdapter = new CommonSQLiteAdapter(

packages/datastore-storage-adapter/src/ExpoSQLiteAdapter/ExpoSQLiteDatabase.ts

@@ -3,17 +3,18 @@
 import { ConsoleLogger } from '@aws-amplify/core';
 import { PersistentModel } from '@aws-amplify/datastore';
 import { deleteAsync, documentDirectory } from 'expo-file-system';
-import { openDatabase, WebSQLDatabase } from 'expo-sqlite';
+import { WebSQLDatabase, openDatabase } from 'expo-sqlite';
+
 import { DB_NAME } from '../common/constants';
 import { CommonSQLiteDatabase, ParameterizedStatement } from '../common/types';
 
 const logger = new ConsoleLogger('ExpoSQLiteDatabase');
 
 /*
 
-Note: 
-ExpoSQLite transaction error callbacks require returning a boolean value to indicate whether the 
-error was handled or not. Returning a true value indicates the error was handled and does not 
+Note:
+ExpoSQLite transaction error callbacks require returning a boolean value to indicate whether the
+error was handled or not. Returning a true value indicates the error was handled and does not
 rollback the whole transaction.
 
 */
@@ -56,6 +57,7 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 		params: (string | number)[],
 	): Promise<T> {
 		const results: T[] = await this.getAll(statement, params);
+
 		return results[0];
 	}
 
@@ -74,6 +76,7 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 					(_, error) => {
 						reject(error);
 						logger.warn(error);
+
 						return true;
 					},
 				);
@@ -93,6 +96,7 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 					(_, error) => {
 						reject(error);
 						logger.warn(error);
+
 						return true;
 					},
 				);
@@ -101,24 +105,27 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 	}
 
 	public batchQuery<T = any>(
-		queryParameterizedStatements: Set<ParameterizedStatement> = new Set(),
+		queryParameterizedStatements = new Set<ParameterizedStatement>(),
 	): Promise<T[]> {
-		return new Promise((resolveTransaction, rejectTransaction) => {
+		return new Promise((resolve, reject) => {
+			const resolveTransaction = resolve;
+			const rejectTransaction = reject;
 			this.db.transaction(async transaction => {
 				try {
 					const results: any[] = await Promise.all(
 						[...queryParameterizedStatements].map(
 							([statement, params]) =>
-								new Promise((resolve, reject) => {
+								new Promise((_resolve, _reject) => {
 									transaction.executeSql(
 										statement,
 										params,
 										(_, result) => {
-											resolve(result.rows._array[0]);
+											_resolve(result.rows._array[0]);
 										},
 										(_, error) => {
-											reject(error);
+											_reject(error);
 											logger.warn(error);
+
 											return true;
 										},
 									);
@@ -135,26 +142,29 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 	}
 
 	public batchSave(
-		saveParameterizedStatements: Set<ParameterizedStatement> = new Set(),
+		saveParameterizedStatements = new Set<ParameterizedStatement>(),
 		deleteParameterizedStatements?: Set<ParameterizedStatement>,
 	): Promise<void> {
-		return new Promise((resolveTransaction, rejectTransaction) => {
+		return new Promise((resolve, reject) => {
+			const resolveTransaction = resolve;
+			const rejectTransaction = reject;
 			this.db.transaction(async transaction => {
 				try {
 					// await for all sql statements promises to resolve
 					await Promise.all(
 						[...saveParameterizedStatements].map(
 							([statement, params]) =>
-								new Promise((resolve, reject) => {
+								new Promise((_resolve, _reject) => {
 									transaction.executeSql(
 										statement,
 										params,
 										() => {
-											resolve(null);
+											_resolve(null);
 										},
 										(_, error) => {
-											reject(error);
+											_reject(error);
 											logger.warn(error);
+
 											return true;
 										},
 									);
@@ -165,20 +175,21 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 						await Promise.all(
 							[...deleteParameterizedStatements].map(
 								([statement, params]) =>
-									new Promise((resolve, reject) =>
+									new Promise((_resolve, _reject) => {
 										transaction.executeSql(
 											statement,
 											params,
 											() => {
-												resolve(null);
+												_resolve(null);
 											},
 											(_, error) => {
-												reject(error);
+												_reject(error);
 												logger.warn(error);
+
 												return true;
 											},
-										),
-									),
+										);
+									}),
 							),
 						);
 					}
@@ -198,33 +209,37 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 		const [queryStatement, queryParams] = queryParameterizedStatement;
 		const [deleteStatement, deleteParams] = deleteParameterizedStatement;
 
-		return new Promise((resolveTransaction, rejectTransaction) => {
+		return new Promise((resolve, reject) => {
+			const resolveTransaction = resolve;
+			const rejectTransaction = reject;
 			this.db.transaction(async transaction => {
 				try {
-					const result: T[] = await new Promise((resolve, reject) => {
+					const result: T[] = await new Promise((_resolve, _reject) => {
 						transaction.executeSql(
 							queryStatement,
 							queryParams,
-							(_, result) => {
-								resolve(result.rows._array || []);
+							(_, sqlResult) => {
+								_resolve(sqlResult.rows._array || []);
 							},
 							(_, error) => {
-								reject(error);
+								_reject(error);
 								logger.warn(error);
+
 								return true;
 							},
 						);
 					});
-					await new Promise((resolve, reject) => {
+					await new Promise((_resolve, _reject) => {
 						transaction.executeSql(
 							deleteStatement,
 							deleteParams,
 							() => {
-								resolve(null);
+								_resolve(null);
 							},
 							(_, error) => {
-								reject(error);
+								_reject(error);
 								logger.warn(error);
+
 								return true;
 							},
 						);
@@ -239,21 +254,24 @@ class ExpoSQLiteDatabase implements CommonSQLiteDatabase {
 	}
 
 	private executeStatements(statements: string[]): Promise<void> {
-		return new Promise((resolveTransaction, rejectTransaction) => {
+		return new Promise((resolve, reject) => {
+			const resolveTransaction = resolve;
+			const rejectTransaction = reject;
 			this.db.transaction(async transaction => {
 				try {
 					await Promise.all(
 						statements.map(
 							statement =>
-								new Promise((resolve, reject) => {
+								new Promise((_resolve, _reject) => {
 									transaction.executeSql(
 										statement,
 										[],
 										() => {
-											resolve(null);
+											_resolve(null);
 										},
 										(_, error) => {
-											reject(error);
+											_reject(error);
+
 											return true;
 										},
 									);

packages/datastore-storage-adapter/src/SQLiteAdapter/SQLiteAdapter.ts

@@ -1,6 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { CommonSQLiteAdapter } from '../common/CommonSQLiteAdapter';
+
 import SQLiteDatabase from './SQLiteDatabase';
 
 const SQLiteAdapter: CommonSQLiteAdapter = new CommonSQLiteAdapter(

packages/datastore-storage-adapter/src/SQLiteAdapter/SQLiteDatabase.ts

@@ -3,6 +3,7 @@
 import SQLite from 'react-native-sqlite-storage';
 import { ConsoleLogger } from '@aws-amplify/core';
 import { PersistentModel } from '@aws-amplify/datastore';
+
 import { DB_NAME } from '../common/constants';
 import { CommonSQLiteDatabase, ParameterizedStatement } from '../common/types';
 
@@ -16,7 +17,7 @@ if (ConsoleLogger.LOG_LEVEL === 'DEBUG') {
 
 /*
 
-Note: 
+Note:
 I purposely avoided using arrow functions () => {} in this class,
 Because I ran into issues with them in some of the SQLite method callbacks
 
@@ -41,7 +42,7 @@ class SQLiteDatabase implements CommonSQLiteDatabase {
 	}
 
 	public async createSchema(statements: string[]): Promise<void> {
-		return await this.executeStatements(statements);
+		await this.executeStatements(statements);
 	}
 
 	public async clear(): Promise<void> {
@@ -56,6 +57,7 @@ class SQLiteDatabase implements CommonSQLiteDatabase {
 		params: (string | number)[],
 	): Promise<T> {
 		const results: T[] = await this.getAll(statement, params);
+
 		return results[0];
 	}
 
@@ -138,7 +140,14 @@ class SQLiteDatabase implements CommonSQLiteDatabase {
 				},
 				logger.warn,
 			);
-			tx.executeSql(deleteStatement, deleteParams, () => {}, logger.warn);
+			tx.executeSql(
+				deleteStatement,
+				deleteParams,
+				() => {
+					// no-op
+				},
+				logger.warn,
+			);
 		});
 
 		return results;