chore(db-compare): port to TypeScript

apps/db-compare/src/compare.ts

@@ -1,12 +1,13 @@
 "use strict";
 
-require('colors');
-const jsDiff = require('diff');
-const sqlite = require('sqlite');
-const sqlite3 = require('sqlite3');
-const sql = require('./sql');
+import jsDiff from "diff";
+import * as sqlite from "sqlite";
+import * as sqlite3 from "sqlite3";
+import sql from "./sql.js";
 
-function printDiff(one, two) {
+import "colors";
+
+function printDiff(one: string, two: string) {
     const diff = jsDiff.diffChars(one, two);
 
     diff.forEach(function(part){
@@ -20,7 +21,7 @@ function printDiff(one, two) {
     console.log("");
 }
 
-function checkMissing(table, name, ids1, ids2) {
+function checkMissing(table: string, name: string, ids1: string[], ids2: string[]) {
     const missing = ids1.filter(item => ids2.indexOf(item) < 0);
 
     if (missing.length > 0) {
@@ -28,7 +29,7 @@ function checkMissing(table, name, ids1, ids2) {
     }
 }
 
-function handleBuffer(obj) {
+function handleBuffer(obj: { content: Buffer | string }) {
     if (obj && Buffer.isBuffer(obj.content)) {
         obj.content = obj.content.toString();
     }
@@ -36,7 +37,7 @@ function handleBuffer(obj) {
     return obj;
 }
 
-function compareRows(table, rsLeft, rsRight, column) {
+function compareRows(table: string, rsLeft: Record<string, any>, rsRight: Record<string, any>, column: string) {
     const leftIds = Object.keys(rsLeft);
     const rightIds = Object.keys(rsRight);
 
@@ -72,7 +73,7 @@ async function main() {
     const dbLeft = await sqlite.open({filename: dbLeftPath, driver: sqlite3.Database});
     const dbRight = await sqlite.open({filename: dbRightPath, driver: sqlite3.Database});
 
-    async function compare(table, column, query) {
+    async function compare(table: string, column: string, query: string) {
         const rsLeft = await sql.getIndexed(dbLeft, column, query);
         const rsRight = await sql.getIndexed(dbRight, column, query);
 

apps/db-compare/src/sql.ts

@@ -1,16 +1,18 @@
 "use strict";
 
-async function getSingleResult(db, query, params = []) {
+import type { Database } from "sqlite";
+
+async function getSingleResult(db: Database, query: string, params: any[] = []) {
     return await wrap(db, async db => db.get(query, ...params));
 }
 
-async function getSingleResultOrNull(db, query, params = []) {
+async function getSingleResultOrNull(db: Database, query: string, params: any[] = []) {
     const all = await wrap(db, async db => db.all(query, ...params));
 
     return all.length > 0 ? all[0] : null;
 }
 
-async function getSingleValue(db, query, params = []) {
+async function getSingleValue(db: Database, query: string, params: any[] = []) {
     const row = await getSingleResultOrNull(db, query, params);
 
     if (!row) {
@@ -20,14 +22,14 @@ async function getSingleValue(db, query, params = []) {
     return row[Object.keys(row)[0]];
 }
 
-async function getResults(db, query, params = []) {
+async function getResults(db: Database, query: string, params: any[] = []) {
     return await wrap(db, async db => db.all(query, ...params));
 }
 
-async function getIndexed(db, column, query, params = []) {
+async function getIndexed(db: Database, column: string, query: string, params: any[] = []) {
     const results = await getResults(db, query, params);
 
-    const map = {};
+    const map: Record<string, any> = {};
 
     for (const row of results) {
         map[row[column]] = row;
@@ -36,8 +38,8 @@ async function getIndexed(db, column, query, params = []) {
     return map;
 }
 
-async function getMap(db, query, params = []) {
-    const map = {};
+async function getMap(db: Database, query: string, params: any[] = []) {
+    const map: Record<string, any> = {};
     const results = await getResults(db, query, params);
 
     for (const row of results) {
@@ -49,7 +51,7 @@ async function getMap(db, query, params = []) {
     return map;
 }
 
-async function getFlattenedResults(db, key, query, params = []) {
+async function getFlattenedResults(db: Database, key: string, query: string, params: any[] = []) {
     const list = [];
     const result = await getResults(db, query, params);
 
@@ -60,24 +62,23 @@ async function getFlattenedResults(db, key, query, params = []) {
     return list;
 }
 
-async function execute(db, query, params = []) {
+async function execute(db: Database, query: string, params: any[] = []) {
     return await wrap(db, async db => db.run(query, ...params));
 }
 
-async function wrap(db, func) {
+async function wrap<T>(db: Database, func: (db: Database) => Promise<T>) {
     const thisError = new Error();
 
     try {
         return await func(db);
-    }
-    catch (e) {
+    } catch (e: any) {
         console.error("Error executing query. Inner exception: " + e.stack + thisError.stack);
 
         throw thisError;
     }
 }
 
-module.exports = {
+export default {
     getSingleValue,
     getSingleResult,
     getSingleResultOrNull,
@@ -86,4 +87,4 @@ module.exports = {
     getMap,
     getFlattenedResults,
     execute
-};
+};