@quillsql/node 0.3.7 → 0.4.0

package/dist/db/BigQuery.js

@@ -0,0 +1,201 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaColumnInfoBigQuery = exports.getForeignKeysBigQuery = exports.getColumnsByTableBigQuery = exports.getTablesBySchemaBigQuery = exports.getSchemaBigQuery = exports.runQueryBigQuery = exports.connectToBigQuery = exports.formatBigQueryConfig = void 0;
+const bigquery_1 = require("@google-cloud/bigquery");
+const textProcessing_1 = require("../utils/textProcessing");
+function formatBigQueryConfig(connectionString) {
+    const jsonStartIndex = connectionString.indexOf("{");
+    if (jsonStartIndex === -1) {
+        throw new Error("Invalid input string. No JSON data found.");
+    }
+    const datasetName = connectionString.substring(0, jsonStartIndex).trim();
+    const jsonString = connectionString.substring(jsonStartIndex);
+    try {
+        const serviceAccount = JSON.parse(jsonString);
+        // Validate if required fields are present
+        if (!serviceAccount.project_id || !serviceAccount.private_key) {
+            throw new Error("Invalid service account JSON. Required fields are missing.");
+        }
+        return {
+            datasetName,
+            projectId: serviceAccount.project_id,
+            credentials: serviceAccount,
+        };
+    }
+    catch (error) {
+        throw new Error("Failed to parse JSON string: " + error);
+    }
+}
+exports.formatBigQueryConfig = formatBigQueryConfig;
+function connectToBigQuery(config) {
+    return new bigquery_1.BigQuery(config);
+}
+exports.connectToBigQuery = connectToBigQuery;
+function runQueryBigQuery(sql, bigQuery) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rows = yield bigQuery.query(sql);
+        if (!rows[0] || rows[0].length === 0)
+            return { fields: [], rows: [] };
+        const typedRows = rows[0];
+        const fields = Object.keys(typedRows[0]).map((name) => ({
+            name,
+            dataTypeID: 1043,
+        }));
+        fields.forEach((field) => {
+            typedRows.some((row) => {
+                if (row[field.name] === null)
+                    return false;
+                field.dataTypeID = inferType(row[field.name]);
+                return true;
+            });
+        });
+        return {
+            fields: fields,
+            rows: typedRows,
+        };
+    });
+}
+exports.runQueryBigQuery = runQueryBigQuery;
+function getSchemaBigQuery(bigQuery) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [datasets] = yield bigQuery.getDatasets();
+        const definedDatasets = datasets.map((dataset) => dataset.id);
+        const filtered = [];
+        definedDatasets.forEach((dataset) => {
+            if (dataset !== undefined) {
+                filtered.push(dataset);
+            }
+        });
+        return filtered;
+    });
+}
+exports.getSchemaBigQuery = getSchemaBigQuery;
+function getTablesBySchemaBigQuery(bigQuery, schemaNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(schemaNames.map((schema) => __awaiter(this, void 0, void 0, function* () {
+            const sql = `SELECT table_name FROM ${schema}.INFORMATION_SCHEMA.TABLES WHERE table_type = 'BASE TABLE'`;
+            const rows = yield bigQuery.query(sql);
+            return rows[0].map((row) => {
+                return { tableName: row.table_name, schemaName: schema };
+            });
+        })));
+        return allColumns.flat();
+    });
+}
+exports.getTablesBySchemaBigQuery = getTablesBySchemaBigQuery;
+function getColumnsByTableBigQuery(bigQuery, schemaName, tableName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS WHERE table_name = '${tableName}'`;
+        const rows = yield bigQuery.query(sql);
+        return rows[0].map((row) => row.column_name);
+    });
+}
+exports.getColumnsByTableBigQuery = getColumnsByTableBigQuery;
+function getForeignKeysBigQuery(connection, schemaName, tableName, primaryKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
+        let sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS 
+    WHERE table_name != '${tableName}' 
+    and (column_name = '${primaryKey}' 
+      or column_name = '${depluralizedTableName}_${primaryKey}' 
+      or column_name = '${depluralizedTableName}${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+        const results = yield runQueryBigQuery(sql, connection);
+        let foreignKeysString = results.rows.map((key) => {
+            return key.column_name;
+        });
+        foreignKeysString = foreignKeysString.filter((key) => key !== "id" && key !== "_id_");
+        foreignKeysString = [...new Set(foreignKeysString)];
+        if (foreignKeysString.length === 0) {
+            sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS 
+      WHERE table_name != '${tableName}' 
+      and (column_name like '${depluralizedTableName}%'
+      or column_name like '%_id' 
+      or column_name like '%Id' 
+      or column_name like '%_${primaryKey}' 
+      or column_name like '%${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+            const results = yield runQueryBigQuery(sql, connection);
+            foreignKeysString = results.rows.map((key) => {
+                return key.column_name;
+            });
+            foreignKeysString = [...new Set(foreignKeysString)];
+        }
+        return foreignKeysString;
+    });
+}
+exports.getForeignKeysBigQuery = getForeignKeysBigQuery;
+function getSchemaColumnInfoBigQuery(connection, schemaName, tableNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(tableNames.map((tableName) => __awaiter(this, void 0, void 0, function* () {
+            const query = `
+      SELECT column_name as columnName, data_type as dataType
+      FROM ${tableName.schemaName}.INFORMATION_SCHEMA.COLUMNS
+      WHERE table_name = '${tableName.tableName}'
+      ORDER BY ordinal_position;
+    `;
+            const results = yield runQueryBigQuery(query, connection);
+            return {
+                tableName: `${tableName.schemaName}.${tableName.tableName}`,
+                displayName: `${tableName.schemaName}.${tableName.tableName}`,
+                columns: results.rows.map((row) => ({
+                    columnName: row.columnName,
+                    displayName: row.columnName,
+                    dataTypeID: convertBigQueryTypeToPostgresOID(row.dataType),
+                    fieldType: row.dataType,
+                })),
+            };
+        })));
+        return allColumns;
+    });
+}
+exports.getSchemaColumnInfoBigQuery = getSchemaColumnInfoBigQuery;
+function convertBigQueryTypeToPostgresOID(type) {
+    const typeToOidMap = {
+        VARCHAR: 1043,
+        INTEGER: 23,
+        FLOAT: 700,
+        TIMESTAMP: 1114,
+        DATE: 1082,
+    };
+    const postgresType = typeToOidMap[type.toUpperCase()] || "VARCHAR"; // Default to 'text' if the type is not recognized
+    return typeToOidMap[postgresType] || 1043; // Default to OID for 'text' if the type is not recognized
+}
+function inferType(elem) {
+    if (typeof elem === "number") {
+        // Check if the number is a float or an integer
+        return Number.isInteger(elem) ? 23 : 700; // 23: integer, 700: real
+    }
+    if (typeof elem === "object") {
+        if (/^\d{4}-\d{2}-\d{2}$/.test(elem.value))
+            return 1082; // date
+    }
+    if (typeof elem === "string") {
+        // Attempt to infer date, time, and timestamp formats
+        // Date in YYYY-MM-DD format
+        if (/^\d{4}-\d{2}-\d{2}$/.test(elem))
+            return 1082; // date
+        // Date in MM\DD\YYYY or MM\DD\YY format
+        if (/^\d{2}\/\d{2}\/\d{2,4}$/.test(elem))
+            return 1082; // date
+        // Timestamp in YYYY-MM-DDTHH:MM:SS[.fraction] format
+        if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?$/.test(elem))
+            return 1114; // timestamp without timezone
+        // Timestamp in YYYY-MM-DDTHH:MM:SS[.fraction]Z format
+        if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(elem))
+            return 1184; // timestamp with timezone
+        // Time in HH:MM:SS format
+        if (/^\d{2}:\d{2}:\d{2}$/.test(elem))
+            return 1083; // time
+        return 1043; // varchar
+    }
+    // Add more specific cases or different data types as needed
+    return 1043; // default or unknown type
+}

package/dist/db/{CachedPools.js → CachedConnection.js}

@@ -9,10 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CachedPool = void 0;
-const pg_1 = require("pg");
+exports.CachedConnection = void 0;
 const redis_1 = require("redis");
 const Error_1 = require("../utils/Error");
+const DatabaseHelper_1 = require("./DatabaseHelper");
 class PgError extends Error {
     // Add other properties if needed
     constructor(detail, hint, position) {
@@ -24,10 +24,11 @@ class PgError extends Error {
 }
 /** The TTL for new cache entries (default: 1h) */
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
-class CachedPool {
-    constructor(config, cacheConfig = {}) {
+class CachedConnection {
+    constructor(databaseType, config, cacheConfig = {}) {
         var _a;
-        this.pool = new pg_1.Pool(config);
+        this.databaseType = databaseType;
+        this.pool = (0, DatabaseHelper_1.connectToDatabase)(databaseType, config);
         this.ttl = (_a = cacheConfig === null || cacheConfig === void 0 ? void 0 : cacheConfig.ttl) !== null && _a !== void 0 ? _a : DEFAULT_CACHE_TTL;
         this.cache = this.getCache(cacheConfig);
     }
@@ -35,14 +36,7 @@ class CachedPool {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 if (!this.cache) {
-                    const results = yield this.pool.query(text, values);
-                    return {
-                        fields: results.fields.map((field) => ({
-                            name: field.name,
-                            dataTypeID: field.dataTypeID,
-                        })),
-                        rows: results.rows,
-                    };
+                    return yield (0, DatabaseHelper_1.runQueryByDatabase)(this.databaseType, this.pool, text);
                 }
                 const key = `${this.orgId}:${text}`;
                 const cachedResult = yield this.cache.get(key);
@@ -50,16 +44,10 @@ class CachedPool {
                     return JSON.parse(cachedResult);
                 }
                 else {
-                    const newResult = yield this.pool.query(text, values);
+                    const newResult = yield (0, DatabaseHelper_1.runQueryByDatabase)(this.databaseType, this.pool, text);
                     const newResultString = JSON.stringify(newResult);
                     yield this.cache.set(key, newResultString, "EX", DEFAULT_CACHE_TTL);
-                    return {
-                        fields: newResult.fields.map((field) => ({
-                            name: field.name,
-                            dataTypeID: field.dataTypeID,
-                        })),
-                        rows: newResult.rows,
-                    };
+                    return newResult;
                 }
             }
             catch (err) {
@@ -84,8 +72,8 @@ class CachedPool {
     }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.pool.end();
+            yield (0, DatabaseHelper_1.disconnectFromDatabase)(this.databaseType, this.pool);
         });
     }
 }
-exports.CachedPool = CachedPool;
+exports.CachedConnection = CachedConnection;

package/dist/db/DatabaseHelper.js

@@ -0,0 +1,187 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getColumnInfoBySchemaByDatabase = exports.getForiegnKeysByDatabase = exports.getColumnsByTableByDatabase = exports.getTablesBySchemaByDatabase = exports.getSchemasByDatabase = exports.disconnectFromDatabase = exports.runQueryByDatabase = exports.connectToDatabase = exports.getDatabaseCredentials = exports.DatabaseType = void 0;
+const Postgres_1 = require("./Postgres");
+const Snowflake_1 = require("./Snowflake");
+const BigQuery_1 = require("./BigQuery");
+const Mysql_1 = require("./Mysql");
+var DatabaseType;
+(function (DatabaseType) {
+    DatabaseType["postgres"] = "postgres";
+    DatabaseType["postgresql"] = "postgresql";
+    DatabaseType["snowflake"] = "snowflake";
+    DatabaseType["bigquery"] = "bigquery";
+    DatabaseType["mysql"] = "mysql";
+})(DatabaseType || (exports.DatabaseType = DatabaseType = {}));
+function getDatabaseCredentials(databaseType, connectionString) {
+    switch (databaseType.toLowerCase()) {
+        case "postgres":
+            return (0, Postgres_1.formatPostgresConfig)(connectionString);
+        case "postgresql":
+            return (0, Postgres_1.formatPostgresConfig)(connectionString);
+        case "snowflake":
+            return (0, Snowflake_1.formatSnowflakeConfig)(connectionString);
+        case "bigquery":
+            return (0, BigQuery_1.formatBigQueryConfig)(connectionString);
+        case "mysql":
+            return (0, Mysql_1.formatMysqlConfig)(connectionString);
+        default:
+            return undefined;
+    }
+}
+exports.getDatabaseCredentials = getDatabaseCredentials;
+function connectToDatabase(databaseType, config) {
+    switch (databaseType.toLowerCase()) {
+        case "postgres":
+            return (0, Postgres_1.connectToPostgres)(config);
+        case "postgresql":
+            return (0, Postgres_1.connectToPostgres)(config);
+        case "snowflake":
+            return (0, Snowflake_1.connectToSnowflake)(config);
+        case "bigquery":
+            return (0, BigQuery_1.connectToBigQuery)(config);
+        case "mysql":
+            return (0, Mysql_1.connectToMysql)(config);
+        default:
+            return (0, Postgres_1.connectToPostgres)(config);
+    }
+}
+exports.connectToDatabase = connectToDatabase;
+function runQueryByDatabase(databaseType, connection, sql) {
+    switch (databaseType.toLowerCase()) {
+        case "postgres":
+            return (0, Postgres_1.runQueryPostgres)(sql, connection);
+        case "postgresql":
+            return (0, Postgres_1.runQueryPostgres)(sql, connection);
+        case "snowflake":
+            return (0, Snowflake_1.runQuerySnowflake)(sql, connection);
+        case "bigquery":
+            return (0, BigQuery_1.runQueryBigQuery)(sql, connection);
+        case "mysql":
+            return (0, Mysql_1.runQueryMysql)(sql, connection);
+        default:
+            return undefined;
+    }
+}
+exports.runQueryByDatabase = runQueryByDatabase;
+function disconnectFromDatabase(databaseType, database) {
+    switch (databaseType.toLowerCase()) {
+        case "postgres":
+            return (0, Postgres_1.disconnectFromPostgres)(database);
+        case "postgresql":
+            return (0, Postgres_1.disconnectFromPostgres)(database);
+        case "snowflake":
+            return (0, Snowflake_1.disconnectFromSnowflake)(database);
+        case "bigquery":
+            return; // BigQuery does not need to be disconnected
+        case "mysql":
+            return (0, Mysql_1.disconnectFromMysql)(database);
+        default:
+            return undefined;
+    }
+}
+exports.disconnectFromDatabase = disconnectFromDatabase;
+function getSchemasByDatabase(databaseType, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (databaseType.toLowerCase()) {
+            case "postgres":
+                return (0, Postgres_1.getSchemasPostgres)(connection);
+            case "postgresql":
+                return (0, Postgres_1.getSchemasPostgres)(connection);
+            case "snowflake":
+                return (0, Snowflake_1.getSchemasSnowflake)(connection);
+            case "bigquery":
+                return (0, BigQuery_1.getSchemaBigQuery)(connection);
+            case "mysql":
+                return (0, Mysql_1.getSchemasMysql)(connection);
+            default:
+                return undefined;
+        }
+    });
+}
+exports.getSchemasByDatabase = getSchemasByDatabase;
+// INFORMATION SCHEMA SELECTS
+function getTablesBySchemaByDatabase(databaseType, connection, schemaName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (databaseType.toLowerCase()) {
+            case "postgres":
+                return (0, Postgres_1.getTablesBySchemaPostgres)(connection, schemaName);
+            case "postgresql":
+                return (0, Postgres_1.getTablesBySchemaPostgres)(connection, schemaName);
+            case "snowflake":
+                return (0, Snowflake_1.getTablesBySchemaSnowflake)(connection, schemaName);
+            case "bigquery":
+                return (0, BigQuery_1.getTablesBySchemaBigQuery)(connection, schemaName);
+            case "mysql":
+                return (0, Mysql_1.getTablesBySchemaMysql)(connection, schemaName);
+            default:
+                return undefined;
+        }
+    });
+}
+exports.getTablesBySchemaByDatabase = getTablesBySchemaByDatabase;
+// INFORMATION SCHEMA SELECTS
+function getColumnsByTableByDatabase(databaseType, connection, schemaName, tableName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (databaseType.toLowerCase()) {
+            case "postgres":
+                return (0, Postgres_1.getColumnsByTablePostgres)(connection, schemaName, tableName);
+            case "postgresql":
+                return (0, Postgres_1.getColumnsByTablePostgres)(connection, schemaName, tableName);
+            case "snowflake":
+                return (0, Snowflake_1.getColumnsByTableSnowflake)(connection, schemaName, tableName);
+            case "bigquery":
+                return (0, BigQuery_1.getColumnsByTableBigQuery)(connection, schemaName, tableName);
+            case "mysql":
+                return (0, Mysql_1.getColumnsByTableMysql)(connection, schemaName, tableName);
+            default:
+                return undefined;
+        }
+    });
+}
+exports.getColumnsByTableByDatabase = getColumnsByTableByDatabase;
+function getForiegnKeysByDatabase(databaseType, connection, schemaName, tableName, primaryKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (databaseType.toLowerCase()) {
+            case "postgres":
+                return (0, Postgres_1.getForeignKeysPostgres)(connection, schemaName, tableName, primaryKey);
+            case "postgresql":
+                return (0, Postgres_1.getForeignKeysPostgres)(connection, schemaName, tableName, primaryKey);
+            case "snowflake":
+                return (0, Snowflake_1.getForeignKeysSnowflake)(connection, schemaName, tableName, primaryKey);
+            case "bigquery":
+                return (0, BigQuery_1.getForeignKeysBigQuery)(connection, schemaName, tableName, primaryKey);
+            case "mysql":
+                return (0, Mysql_1.getForeignKeysMysql)(connection, schemaName, tableName, primaryKey);
+            default:
+                return undefined;
+        }
+    });
+}
+exports.getForiegnKeysByDatabase = getForiegnKeysByDatabase;
+function getColumnInfoBySchemaByDatabase(databaseType, connection, schemaName, tables) {
+    switch (databaseType.toLowerCase()) {
+        case "postgres":
+            return (0, Postgres_1.getSchemaColumnInfoPostgress)(connection, schemaName, tables);
+        case "postgresql":
+            return (0, Postgres_1.getSchemaColumnInfoPostgress)(connection, schemaName, tables);
+        case "snowflake":
+            return (0, Snowflake_1.getSchemaColumnInfoSnowflake)(connection, schemaName, tables);
+        case "bigquery":
+            return (0, BigQuery_1.getSchemaColumnInfoBigQuery)(connection, schemaName, tables);
+        case "mysql":
+            return (0, Mysql_1.getSchemaColumnInfoMysql)(connection, schemaName, tables);
+        default:
+            return undefined;
+    }
+}
+exports.getColumnInfoBySchemaByDatabase = getColumnInfoBySchemaByDatabase;

package/dist/db/Mysql.js

@@ -0,0 +1,192 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaColumnInfoMysql = exports.getForeignKeysMysql = exports.getColumnsByTableMysql = exports.getTablesBySchemaMysql = exports.getSchemasMysql = exports.runQueryMysql = exports.disconnectFromMysql = exports.connectToMysql = exports.formatMysqlConfig = void 0;
+const mysql2_1 = __importDefault(require("mysql2"));
+const url_1 = __importDefault(require("url"));
+const textProcessing_1 = require("../utils/textProcessing");
+function formatMysqlConfig(connectionString) {
+    const parsedUrl = url_1.default.parse(connectionString);
+    const [user, password] = (parsedUrl.auth || "").split(":");
+    return {
+        host: parsedUrl.hostname || "",
+        user: user || "",
+        password: password || "",
+        database: (parsedUrl.pathname || "").slice(1),
+    };
+}
+exports.formatMysqlConfig = formatMysqlConfig;
+function connectToMysql(config) {
+    const pool = mysql2_1.default.createPool(Object.assign(Object.assign({}, config), { waitForConnections: true, connectionLimit: 10, queueLimit: 0 }));
+    return pool;
+}
+exports.connectToMysql = connectToMysql;
+function disconnectFromMysql(connection) {
+    connection.end();
+}
+exports.disconnectFromMysql = disconnectFromMysql;
+function runQueryMysql(sql, connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield new Promise((resolve, reject) => {
+            connection.query(sql, (error, results, fields) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                const mappedFields = fields
+                    ? fields.map((field) => ({
+                        name: field.name,
+                        dataTypeID: mysqlDataTypeIdToPostgresType(field.type || 1043), // Provide a default value for dataTypeID
+                    }))
+                    : [];
+                const processRows = Array.isArray(results)
+                    ? results.map((row) => {
+                        return JSON.parse(JSON.stringify(row));
+                    })
+                    : [];
+                resolve({ fields: mappedFields, rows: processRows });
+            });
+        });
+        return result;
+    });
+}
+exports.runQueryMysql = runQueryMysql;
+function getSchemasMysql(connection) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA
+    WHERE schema_name != 'information_schema' 
+    AND schema_name != 'performance_schema'
+    and schema_name != 'sys';`;
+        const results = yield runQueryMysql(sql, connection);
+        return results.rows.map((row) => row.SCHEMA_NAME);
+    });
+}
+exports.getSchemasMysql = getSchemasMysql;
+function getTablesBySchemaMysql(connection, schemaNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(schemaNames.map((schema) => __awaiter(this, void 0, void 0, function* () {
+            const sql = `SELECT TABLE_NAME, TABLE_SCHEMA FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${schema}'`;
+            const results = yield runQueryMysql(sql, connection);
+            return results.rows.map((row) => {
+                return { tableName: row.TABLE_NAME, schemaName: row.TABLE_SCHEMA };
+            });
+        })));
+        return allColumns.flat();
+    });
+}
+exports.getTablesBySchemaMysql = getTablesBySchemaMysql;
+function getColumnsByTableMysql(connection, schemaName, tableName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_NAME = '${tableName}'`;
+        const results = yield runQueryMysql(sql, connection);
+        return results.rows.map((row) => row.COLUMN_NAME);
+    });
+}
+exports.getColumnsByTableMysql = getColumnsByTableMysql;
+function getForeignKeysMysql(connection, schemaName, tableName, primaryKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const depluralizedTableName = (0, textProcessing_1.depluralize)(tableName);
+        let sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
+    WHERE TABLE_SCHEMA = '${schemaName}' 
+    and table_name != '${tableName}' 
+    and (column_name = '${primaryKey}' 
+    or column_name = '${depluralizedTableName}\\_${primaryKey}' 
+    or column_name = '${depluralizedTableName}${(0, textProcessing_1.capitalize)(primaryKey)}' )`;
+        const results = yield runQueryMysql(sql, connection);
+        let foreignKeysString = results.rows.map((key) => {
+            return key.COLUMN_NAME;
+        });
+        // remove any foreignKeyStrings that are just 'id'
+        foreignKeysString = foreignKeysString.filter((key) => key !== "id" && key !== "_id_");
+        foreignKeysString = [...new Set(foreignKeysString)];
+        if (foreignKeysString.length === 0) {
+            sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
+        WHERE TABLE_SCHEMA = '${schemaName}' 
+        and table_name != '${tableName}' 
+        and (column_name like '${depluralizedTableName}%' 
+        or column_name like '%\\_id' 
+        or column_name like '%Id'
+        or column_name like '%\\_${primaryKey}' 
+        or column_name like '%${(0, textProcessing_1.capitalize)(primaryKey)}')`;
+            const results = yield runQueryMysql(sql, connection);
+            foreignKeysString = results.rows.map((key) => {
+                return key.COLUMN_NAME;
+            });
+            foreignKeysString = [...new Set(foreignKeysString)];
+        }
+        return foreignKeysString;
+    });
+}
+exports.getForeignKeysMysql = getForeignKeysMysql;
+function getSchemaColumnInfoMysql(connection, schemaName, tableNames) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allColumns = yield Promise.all(tableNames.map((tableName) => __awaiter(this, void 0, void 0, function* () {
+            const query = `
+      SELECT COLUMN_NAME as columnName, 
+      DATA_TYPE as dataType FROM INFORMATION_SCHEMA.COLUMNS 
+      WHERE TABLE_SCHEMA = '${tableName.schemaName}' 
+      AND TABLE_NAME = '${tableName.tableName}'
+    `;
+            const results = yield runQueryMysql(query, connection);
+            return {
+                tableName: `${tableName.schemaName}.${tableName.tableName}`,
+                displayName: `${tableName.schemaName}.${tableName.tableName}`,
+                columns: results.rows.map((row) => ({
+                    columnName: row.columnName,
+                    displayName: row.columnName,
+                    dataTypeID: mysqlTextDataTypeToPostgresOID(row.dataType),
+                    fieldType: row.dataType,
+                })),
+            };
+        })));
+        return allColumns;
+    });
+}
+exports.getSchemaColumnInfoMysql = getSchemaColumnInfoMysql;
+function mysqlTextDataTypeToPostgresOID(type) {
+    switch (type) {
+        case "bigint": // int
+            return 23;
+        case "tinyint": // int
+            return 23;
+        case "float": // float
+            return 700;
+        case "varchar": // varchar
+            return 1043;
+        case "timestamp": // date
+            return 1082;
+        default: // varchar
+            return 1043;
+    }
+}
+function mysqlDataTypeIdToPostgresType(type) {
+    switch (type) {
+        case 8: // int
+            return 23;
+        case 3: // int
+            return 23;
+        case 2: // int
+            return 23;
+        case 5: // float
+            return 700;
+        case 253: // varchar
+            return 1043;
+        case 7: // date
+            return 1082;
+        case 7: // date
+            return 1082;
+        default: // varchar
+            return 1043;
+    }
+}