@quillsql/node 0.6.8 → 0.6.10

package/src/db/DatabaseHelper.ts

@@ -1,373 +0,0 @@
-import { Pool } from "pg";
-import snowflake from "snowflake-sdk";
-import { Pool as MysqlPool } from "mysql2";
-import { BigQuery } from "@google-cloud/bigquery";
-import {
-  PostgresConnectionConfig,
-  connectToPostgres,
-  disconnectFromPostgres,
-  formatPostgresConfig,
-  getTablesBySchemaPostgres,
-  getColumnsByTablePostgres,
-  runQueryPostgres,
-  getForeignKeysPostgres,
-  getSchemaColumnInfoPostgress,
-  getSchemasPostgres,
-} from "./Postgres";
-import {
-  SnowflakeConnectionConfig,
-  connectToSnowflake,
-  disconnectFromSnowflake,
-  formatSnowflakeConfig,
-  getTablesBySchemaSnowflake,
-  getColumnsByTableSnowflake,
-  runQuerySnowflake,
-  getForeignKeysSnowflake,
-  getSchemaColumnInfoSnowflake,
-  getSchemasSnowflake,
-} from "./Snowflake";
-import {
-  formatBigQueryConfig,
-  BigQueryConfig,
-  connectToBigQuery,
-  runQueryBigQuery,
-  getTablesBySchemaBigQuery,
-  getColumnsByTableBigQuery,
-  getForeignKeysBigQuery,
-  getSchemaColumnInfoBigQuery,
-  getSchemaBigQuery,
-} from "./BigQuery";
-import {
-  MysqlConnectionConfig,
-  connectToMysql,
-  disconnectFromMysql,
-  formatMysqlConfig,
-  runQueryMysql,
-  getTablesBySchemaMysql,
-  getColumnsByTableMysql,
-  getForeignKeysMysql,
-  getSchemaColumnInfoMysql,
-  getSchemasMysql,
-} from "./Mysql";
-
-// export all database connections types
-export type DatabaseConnection =
-  | Pool
-  | snowflake.Connection
-  | BigQuery
-  | MysqlPool;
-
-export interface QuillQueryResults {
-  fields: { name: string; dataTypeID: number }[];
-  rows: { [fieldName: string]: any }[];
-}
-
-export function getDatabaseCredentials(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connectionString: string,
-):
-  | PostgresConnectionConfig
-  | SnowflakeConnectionConfig
-  | BigQueryConfig
-  | MysqlConnectionConfig {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return formatPostgresConfig(connectionString);
-    case "postgresql":
-      return formatPostgresConfig(connectionString);
-    case "snowflake":
-      return formatSnowflakeConfig(connectionString);
-    case "bigquery":
-      return formatBigQueryConfig(connectionString);
-    case "mysql":
-      return formatMysqlConfig(connectionString);
-    default:
-      throw new Error("Invalid database type");
-  }
-}
-
-export function connectToDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  config:
-    | PostgresConnectionConfig
-    | SnowflakeConnectionConfig
-    | BigQueryConfig
-    | MysqlConnectionConfig,
-): DatabaseConnection {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return connectToPostgres(config as PostgresConnectionConfig);
-    case "postgresql":
-      return connectToPostgres(config as PostgresConnectionConfig);
-    case "snowflake":
-      return connectToSnowflake(config as SnowflakeConnectionConfig);
-    case "bigquery":
-      return connectToBigQuery(config as BigQueryConfig);
-    case "mysql":
-      return connectToMysql(config as MysqlConnectionConfig);
-    default:
-      return connectToPostgres(config as PostgresConnectionConfig);
-  }
-}
-
-export async function withConnection<T>(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connectionString: string,
-  callback: (connection: DatabaseConnection) => T,
-): Promise<T> {
-  const config = getDatabaseCredentials(databaseType, connectionString);
-  const connection = connectToDatabase(databaseType, config);
-  try {
-    return await callback(connection);
-  } catch (e: any) {
-    return new Promise((_, reject) =>
-      reject({ success: false, message: e.message || e.error || e }),
-    );
-  } finally {
-    await disconnectFromDatabase(databaseType, connection);
-  }
-}
-
-export function runQueryByDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection,
-  sql: string,
-): Promise<QuillQueryResults> | undefined {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return runQueryPostgres(sql, connection as Pool);
-    case "postgresql":
-      return runQueryPostgres(sql, connection as Pool);
-    case "snowflake":
-      return runQuerySnowflake(sql, connection as snowflake.Connection);
-    case "bigquery":
-      return runQueryBigQuery(sql, connection as BigQuery);
-    case "mysql":
-      return runQueryMysql(sql, connection as MysqlPool);
-    default:
-      return undefined;
-  }
-}
-
-export async function connectAndRunQuery(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connectionString: string,
-  sql: string,
-): Promise<QuillQueryResults | undefined> {
-  return withConnection(
-    databaseType,
-    connectionString,
-    async (connection) =>
-      await runQueryByDatabase(databaseType, connection, sql),
-  );
-}
-
-export function disconnectFromDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  database: DatabaseConnection,
-) {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return disconnectFromPostgres(database as Pool);
-    case "postgresql":
-      return disconnectFromPostgres(database as Pool);
-    case "snowflake":
-      return disconnectFromSnowflake(database as snowflake.Connection);
-    case "bigquery":
-      return; // BigQuery does not need to be disconnected
-    case "mysql":
-      return disconnectFromMysql(database as MysqlPool);
-    default:
-      return undefined;
-  }
-}
-
-export async function getSchemasByDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection,
-): Promise<string[] | undefined> {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return getSchemasPostgres(connection as Pool);
-    case "postgresql":
-      return getSchemasPostgres(connection as Pool);
-    case "snowflake":
-      return getSchemasSnowflake(connection as snowflake.Connection);
-    case "bigquery":
-      return getSchemaBigQuery(connection as BigQuery);
-    case "mysql":
-      return getSchemasMysql(connection as MysqlPool);
-    default:
-      return undefined;
-  }
-}
-
-// INFORMATION SCHEMA SELECTS
-export async function getTablesBySchemaByDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection,
-  schemaName: string | string[],
-): Promise<string[] | { tableName: string; schemaName: string }[] | undefined> {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return getTablesBySchemaPostgres(
-        connection as Pool,
-        schemaName as string[],
-      );
-    case "postgresql":
-      return getTablesBySchemaPostgres(
-        connection as Pool,
-        schemaName as string[],
-      );
-    case "snowflake":
-      return getTablesBySchemaSnowflake(
-        connection as snowflake.Connection,
-        schemaName as string[],
-      );
-    case "bigquery":
-      return getTablesBySchemaBigQuery(
-        connection as BigQuery,
-        schemaName as string[],
-      );
-    case "mysql":
-      return getTablesBySchemaMysql(
-        connection as MysqlPool,
-        schemaName as string[],
-      );
-    default:
-      return undefined;
-  }
-}
-
-// INFORMATION SCHEMA SELECTS
-export async function getColumnsByTableByDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection,
-  schemaName: string,
-  tableName: string,
-): Promise<string[] | undefined> {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return getColumnsByTablePostgres(
-        connection as Pool,
-        schemaName,
-        tableName,
-      );
-    case "postgresql":
-      return getColumnsByTablePostgres(
-        connection as Pool,
-        schemaName,
-        tableName,
-      );
-    case "snowflake":
-      return getColumnsByTableSnowflake(
-        connection as snowflake.Connection,
-        schemaName,
-        tableName,
-      );
-    case "bigquery":
-      return getColumnsByTableBigQuery(
-        connection as BigQuery,
-        schemaName,
-        tableName,
-      );
-    case "mysql":
-      return getColumnsByTableMysql(
-        connection as MysqlPool,
-        schemaName,
-        tableName,
-      );
-    default:
-      return undefined;
-  }
-}
-
-export async function getForiegnKeysByDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection,
-  schemaName: string,
-  tableName: string,
-  primaryKey: string,
-): Promise<string[] | undefined> {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return getForeignKeysPostgres(
-        connection as Pool,
-        schemaName,
-        tableName,
-        primaryKey,
-      );
-    case "postgresql":
-      return getForeignKeysPostgres(
-        connection as Pool,
-        schemaName,
-        tableName,
-        primaryKey,
-      );
-    case "snowflake":
-      return getForeignKeysSnowflake(
-        connection as snowflake.Connection,
-        schemaName,
-        tableName,
-        primaryKey,
-      );
-    case "bigquery":
-      return getForeignKeysBigQuery(
-        connection as BigQuery,
-        schemaName,
-        tableName,
-        primaryKey,
-      );
-    case "mysql":
-      return getForeignKeysMysql(
-        connection as MysqlPool,
-        schemaName,
-        tableName,
-        primaryKey,
-      );
-    default:
-      return undefined;
-  }
-}
-
-export function getColumnInfoBySchemaByDatabase(
-  databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection,
-  schemaName: string,
-  tables: string[] | { tableName: string; schemaName: string }[],
-) {
-  switch (databaseType.toLowerCase()) {
-    case "postgres":
-      return getSchemaColumnInfoPostgress(
-        connection as Pool,
-        schemaName,
-        tables as { tableName: string; schemaName: string }[],
-      );
-    case "postgresql":
-      return getSchemaColumnInfoPostgress(
-        connection as Pool,
-        schemaName,
-        tables as { tableName: string; schemaName: string }[],
-      );
-    case "snowflake":
-      return getSchemaColumnInfoSnowflake(
-        connection as snowflake.Connection,
-        schemaName,
-        tables as { tableName: string; schemaName: string }[],
-      );
-    case "bigquery":
-      return getSchemaColumnInfoBigQuery(
-        connection as BigQuery,
-        schemaName,
-        tables as { tableName: string; schemaName: string }[],
-      );
-    case "mysql":
-      return getSchemaColumnInfoMysql(
-        connection as MysqlPool,
-        schemaName,
-        tables as { tableName: string; schemaName: string }[],
-      );
-    default:
-      return undefined;
-  }
-}

package/src/db/Mysql.ts

@@ -1,262 +0,0 @@
-import mysql, { Pool as MysqlPool } from "mysql2";
-import { QuillQueryResults } from "./DatabaseHelper";
-import url from "url";
-import { capitalize, depluralize } from "../utils/textProcessing";
-
-export interface MysqlConnectionConfig {
-  host: string;
-  user: string;
-  password: string;
-  database: string;
-  port: number;
-}
-
-export function formatMysqlConfig(
-  connectionString: string,
-): MysqlConnectionConfig {
-  const parsedUrl = url.parse(connectionString);
-  const [user, password] = (parsedUrl.auth || "").split(":");
-  return {
-    host: parsedUrl.hostname || "",
-    user: user || "",
-    password: password || "",
-    database: (parsedUrl.pathname || "").slice(1),
-    port: parsedUrl.port ? parseInt(parsedUrl.port) : 3306,
-  };
-}
-
-export function connectToMysql(config: MysqlConnectionConfig): MysqlPool {
-  const pool = mysql.createPool({
-    ...config,
-    waitForConnections: true,
-    connectionLimit: 24,
-    queueLimit: 0,
-  });
-  return pool;
-}
-
-export function disconnectFromMysql(connection: MysqlPool) {
-  connection.end();
-}
-
-export async function runQueryMysql(
-  sql: string,
-  connection: MysqlPool,
-): Promise<QuillQueryResults> {
-  const result: QuillQueryResults = await 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: any) => {
-            return JSON.parse(JSON.stringify(row));
-          })
-        : [];
-
-      resolve({ fields: mappedFields, rows: processRows });
-    });
-  });
-  return result;
-}
-
-export async function getSchemasMysql(
-  connection: MysqlPool,
-): Promise<string[]> {
-  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 = await runQueryMysql(sql, connection);
-  return results.rows.map((row) => row.SCHEMA_NAME);
-}
-
-export async function getTablesBySchemaMysql(
-  connection: MysqlPool,
-  schemaNames: string[],
-): Promise<{ tableName: string; schemaName: string }[]> {
-  const allColumns = await Promise.all(
-    schemaNames.map(async (schema) => {
-      const sql = `SELECT TABLE_NAME, TABLE_SCHEMA FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '${schema}'`;
-      const results = await runQueryMysql(sql, connection);
-      return results.rows.map((row) => {
-        return { tableName: row.TABLE_NAME, schemaName: row.TABLE_SCHEMA };
-      });
-    }),
-  );
-  return allColumns.flat();
-}
-
-export async function getColumnsByTableMysql(
-  connection: MysqlPool,
-  schemaName: string,
-  tableName: string,
-): Promise<string[]> {
-  const sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${schemaName}' AND TABLE_NAME = '${tableName}'`;
-  const results = await runQueryMysql(sql, connection);
-  return results.rows.map((row) => row.COLUMN_NAME);
-}
-
-export async function getForeignKeysMysql(
-  connection: MysqlPool,
-  schemaName: string,
-  tableName: string,
-  primaryKey: string,
-): Promise<string[]> {
-  const depluralizedTableName = 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}${capitalize(primaryKey)}' )`;
-  const results = await 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 '%${capitalize(primaryKey)}')`;
-    const results = await runQueryMysql(sql, connection);
-    foreignKeysString = results.rows.map((key) => {
-      return key.COLUMN_NAME;
-    });
-    foreignKeysString = [...new Set(foreignKeysString)];
-  }
-  return foreignKeysString;
-}
-
-export async function getSchemaColumnInfoMysql(
-  connection: MysqlPool,
-  schemaName: string,
-  tableNames: { tableName: string; schemaName: string }[],
-): Promise<
-  { tableName: string; columns: { columnName: string; dataTypeID: number }[] }[]
-> {
-  const allColumns = await Promise.all(
-    tableNames.map(async (tableName) => {
-      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 = await runQueryMysql(query, connection);
-      return {
-        tableName: `${tableName.schemaName}.${tableName.tableName}`,
-        displayName: `${tableName.schemaName}.${tableName.tableName}`,
-        columns: results.rows.map((row: any) => ({
-          columnName: row.columnName,
-          displayName: row.columnName,
-          dataTypeID: mysqlTextDataTypeToPostgresOID(row.dataType),
-          fieldType: row.dataType,
-        })),
-      };
-    }),
-  );
-  return allColumns;
-}
-
-function mysqlTextDataTypeToPostgresOID(type: string): number {
-  switch (type) {
-    case "bigint": // BIGINT in MySQL
-      return 20; // BIGINT in PostgreSQL
-    case "tinyint": // TINYINT in MySQL
-      return 21; // SMALLINT in PostgreSQL
-    case "smallint": // SMALLINT in MySQL
-      return 21; // SMALLINT in PostgreSQL
-    case "int": // INT in MySQL
-      return 23; // INTEGER in PostgreSQL
-    case "float": // FLOAT in MySQL
-      return 701; // DOUBLE PRECISION in PostgreSQL
-    case "double": // DOUBLE in MySQL
-      return 701; // DOUBLE PRECISION in PostgreSQL
-    case "varchar": // VARCHAR in MySQL
-      return 1043; // VARCHAR in PostgreSQL
-    case "char": // CHAR in MySQL
-      return 1042; // CHAR in PostgreSQL
-    case "timestamp": // TIMESTAMP in MySQL
-      return 1114; // TIMESTAMP in PostgreSQL
-    case "date": // DATE in MySQL
-      return 1082; // DATE in PostgreSQL
-    case "datetime": // DATETIME in MySQL
-      return 1114; // TIMESTAMP in PostgreSQL
-    case "time": // TIME in MySQL
-      return 1083; // TIME in PostgreSQL
-    case "year": // YEAR in MySQL
-      return 23; // INTEGER in PostgreSQL
-    case "binary": // BINARY in MySQL
-      return 17; // BYTEA in PostgreSQL
-    case "blob": // BLOB in MySQL
-      return 17; // BYTEA in PostgreSQL
-    case "text": // TEXT in MySQL
-      return 25; // TEXT in PostgreSQL
-    case "json": // JSON in MySQL
-      return 114; // JSON in PostgreSQL
-    default:
-      return 1043; // VARCHAR in PostgreSQL (fallback)
-  }
-}
-
-function mysqlDataTypeIdToPostgresType(type: number): number {
-  switch (type) {
-    case 0: // DECIMAL
-    case 1: // TINY
-    case 2: // SHORT
-    case 3: // LONG
-    case 8: // LONGLONG
-    case 9: // INT24
-    case 13: // YEAR
-      return 23; // INTEGER
-
-    case 4: // FLOAT
-    case 5: // DOUBLE
-      return 701; // DOUBLE PRECISION
-
-    case 7: // TIMESTAMP
-    case 12: // DATETIME
-      return 1114; // TIMESTAMP
-
-    case 10: // DATE
-    case 242: // NEWDATE
-      return 1082; // DATE
-
-    case 15: // VARCHAR
-    case 25: // VAR_STRING
-    case 250: // STRING
-    case 254: // ENUM
-    case 255: // SET
-      return 1043; // VARCHAR
-
-    case 16: // BIT
-    case 245: // TINY_BLOB
-    case 246: // MEDIUM_BLOB
-    case 247: // LONG_BLOB
-    case 248: // BLOB
-    case 251: // GEOMETRY
-      return 17; // BYTEA
-
-    default:
-      return 1043; // Default to VARCHAR if unknown
-  }
-}