@quillsql/node 0.6.8 → 0.6.10

package/src/db/Postgres.ts

@@ -1,185 +0,0 @@
-import { Pool } from "pg";
-// import { Client } from "../models/Client";
-import { QuillQueryResults } from "./DatabaseHelper";
-import { capitalize, depluralize } from "../utils/textProcessing";
-import { PG_TYPES } from "../assets/pgtypes";
-
-export type PostgresConnectionConfig = {
-  connectionString: string;
-  ssl?: {
-    rejectUnauthorized: false;
-    ca?: string;
-    key?: string;
-    cert?: string;
-  };
-};
-
-export function connectToPostgres(config: PostgresConnectionConfig): Pool {
-  return new Pool(config);
-}
-
-export function disconnectFromPostgres(pool: Pool) {
-  pool.end();
-}
-
-export async function runQueryPostgres(
-  sql: string,
-  pool: Pool,
-): Promise<QuillQueryResults> {
-  const results = await pool.query(sql);
-  return {
-    fields: results.fields.map((field: any) => ({
-      name: field.name,
-      dataTypeID: field.dataTypeID,
-    })),
-    rows: results.rows,
-  };
-}
-
-export async function getSchemasPostgres(pool: Pool): Promise<string[]> {
-  const sql = `SELECT schema_name FROM information_schema.schemata 
-    WHERE schema_name NOT LIKE 'pg_%' AND schema_name != 'information_schema';`;
-  const results = await runQueryPostgres(sql, pool);
-  return results.rows.map((row) => row.schema_name);
-}
-
-export async function getTablesBySchemaPostgres(
-  pool: Pool,
-  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 runQueryPostgres(sql, pool);
-      return results.rows.map((row) => {
-        return { tableName: row.table_name, schemaName: row.table_schema };
-      });
-    }),
-  );
-  return allColumns.flat();
-}
-
-export async function getColumnsByTablePostgres(
-  pool: Pool,
-  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 runQueryPostgres(sql, pool);
-  return results.rows.map((row) => row.column_name);
-}
-
-export async function getForeignKeysPostgres(
-  pool: Pool,
-  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 runQueryPostgres(sql, pool);
-  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 information_schema.columns 
-      WHERE table_schema = '${schemaName}' 
-      and table_name != '${tableName}' 
-      and (column_name like '${tableName}%' 
-      or column_name like '%\\_id' 
-      or column_name like '%Id' 
-      or column_name like '%\\_${primaryKey}' 
-      or column_name like '%${capitalize(primaryKey)}')`;
-    const results = await runQueryPostgres(sql, pool);
-    foreignKeysString = results.rows.map((key) => {
-      return key.column_name;
-    });
-    foreignKeysString = [...new Set(foreignKeysString)];
-  }
-  return foreignKeysString;
-}
-
-export async function getSchemaColumnInfoPostgress(
-  pool: Pool,
-  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", udt_name as "fieldType"
-      FROM information_schema.columns
-      WHERE table_schema = '${tableName.schemaName}' 
-      AND table_name = '${tableName.tableName}'
-      ORDER BY ordinal_position;
-    `;
-      const results = await runQueryPostgres(query, pool);
-      return {
-        tableName: `${tableName.schemaName}.${tableName.tableName}`,
-        displayName: `${tableName.schemaName}.${tableName.tableName}`,
-        columns: results.rows.map((row) => {
-          let pgType = PG_TYPES.find((pgType) => {
-            return pgType.typname === row.fieldType;
-          })?.oid;
-          if (!pgType) {
-            pgType = 1043;
-          }
-          return {
-            columnName: row.columnName,
-            displayName: row.columnName,
-            dataTypeID: pgType,
-            fieldType: row.fieldType,
-          };
-        }),
-      };
-    }),
-  );
-  return allColumns;
-}
-
-export function formatPostgresConfig(
-  connectionString: string,
-): PostgresConnectionConfig {
-  return { connectionString, ssl: { rejectUnauthorized: false } };
-}
-
-// CURRENTLY UNUSED BUT MAYBE USEFUL IN THE FUTURE
-// function getSslConfig(client: Client):
-//   | {
-//       rejectUnauthorized: false;
-//       ca?: string;
-//       key?: string;
-//       cert?: string;
-//     }
-//   | undefined {
-//   if (!client.useSsl) {
-//     return undefined;
-//   }
-//   if (client.serverCa && client.clientKey && client.clientCert) {
-//     return {
-//       rejectUnauthorized: false,
-//       ca: client.serverCa,
-//       key: client.clientKey,
-//       cert: client.clientCert,
-//     };
-//   }
-//   if (client.serverCa) {
-//     return {
-//       rejectUnauthorized: false,
-//       ca: client.serverCa,
-//     };
-//   }
-//   // if using ssl with no certificates
-//   return { rejectUnauthorized: false };
-// }

package/src/db/Snowflake.ts

@@ -1,240 +0,0 @@
-import snowflake from "snowflake-sdk";
-import { QuillQueryResults } from "./DatabaseHelper";
-import { capitalize, depluralize } from "../utils/textProcessing";
-
-const POSTGRES_SNOWFLAKE_MAP: { [type: string]: number } = {
-  // Numeric Types
-  NUMBER: 1700, // NUMERIC
-  DECIMAL: 1700, // NUMERIC
-  NUMERIC: 1700, // NUMERIC
-  INT: 23, // INTEGER
-  INTEGER: 23, // INTEGER
-  BIGINT: 20, // BIGINT
-  SMALLINT: 21, // SMALLINT
-  TINYINT: 21, // SMALLINT (PostgreSQL doesn't have TINYINT)
-  BYTEINT: 21, // SMALLINT (PostgreSQL doesn't have BYTEINT)
-  FLOAT: 701, // DOUBLE PRECISION
-  FLOAT4: 700, // REAL
-  FLOAT8: 701, // DOUBLE PRECISION
-  DOUBLE: 701, // DOUBLE PRECISION
-  REAL: 700, // REAL
-
-  // Boolean Type
-  BOOLEAN: 16, // BOOLEAN
-
-  // String Types
-  VARCHAR: 1043, // VARCHAR
-  CHAR: 1042, // CHAR
-  CHARACTER: 1042, // CHAR
-  STRING: 25, // TEXT
-  TEXT: 25, // TEXT
-
-  // Binary Types
-  BINARY: 17, // BYTEA
-  VARBINARY: 17, // BYTEA
-
-  // Date and Time Types
-  DATE: 1082, // DATE
-  DATETIME: 1184, // TIMESTAMP
-  TIME: 1083, // TIME
-  TIMESTAMP: 1184, // TIMESTAMP
-  TIMESTAMP_LTZ: 1184, // TIMESTAMP WITH TIME ZONE
-  TIMESTAMP_NTZ: 1114, // TIMESTAMP WITHOUT TIME ZONE
-  TIMESTAMP_TZ: 1184, // TIMESTAMP WITH TIME ZONE
-
-  // Semi-structured Data Types
-  VARIANT: 3802, // JSONB
-  OBJECT: 3802, // JSONB
-  ARRAY: 2277, // JSON[] (closest equivalent)
-
-  // Geospatial Type
-  GEOGRAPHY: 25, // TEXT (PostgreSQL doesn't have a direct equivalent)
-  GEOMETRY: 25, // TEXT (PostgreSQL doesn't have a direct equivalent)
-
-  // Vector Type
-  VECTOR: 3802, // JSONB (closest equivalent without extensions)
-};
-
-export type SnowflakeConnectionConfig = {
-  account: string;
-  username: string;
-  password: string;
-  database: string;
-  warehouse: string;
-};
-
-export async function runQuerySnowflake(
-  sql: string,
-  connection: snowflake.Connection,
-): Promise<QuillQueryResults> {
-  const results = await new Promise((resolve, reject) => {
-    connection.execute({
-      sqlText: sql,
-      complete: (err, stmt, rows) => {
-        if (err) {
-          reject(err);
-          return { success: false, message: err.message };
-        } else {
-          resolve({
-            rows,
-            fields: stmt.getColumns().map((col) => ({
-              name: col.getName(),
-              dataTypeID: POSTGRES_SNOWFLAKE_MAP[col.getType().toUpperCase()],
-            })),
-          });
-        }
-      },
-    });
-  });
-  return results as QuillQueryResults;
-}
-
-export async function getSchemasSnowflake(
-  connection: snowflake.Connection,
-): Promise<string[]> {
-  const sql = `SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA
-    WHERE SCHEMA_NAME != 'INFORMATION_SCHEMA'`;
-  const results = await runQuerySnowflake(sql, connection);
-  return results.rows.map((row) => row.SCHEMA_NAME);
-}
-
-export async function getTablesBySchemaSnowflake(
-  connection: snowflake.Connection,
-  schemaNames: string[],
-): Promise<{ tableName: string; schemaName: string }[]> {
-  const allColumns = await Promise.all(
-    schemaNames.map(async (schema) => {
-      const query = `SELECT 
-      TABLE_NAME as "tableName",
-      TABLE_SCHEMA as "schemaName"
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE  TABLE_SCHEMA = '${schema}';
-    `;
-      const results = await runQuerySnowflake(query, connection);
-      return results.rows.map((row) => {
-        return { tableName: row.tableName, schemaName: row.schemaName };
-      });
-    }),
-  );
-  return allColumns.flat();
-}
-
-export async function getColumnsByTableSnowflake(
-  connection: snowflake.Connection,
-  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 runQuerySnowflake(sql, connection);
-  return results.rows.map((row) => row.COLUMN_NAME);
-}
-
-export function formatSnowflakeConfig(
-  connectionString: string,
-): SnowflakeConnectionConfig {
-  const parsed = new URL(connectionString);
-  return {
-    account: parsed.hostname,
-    username: parsed.username,
-    password: parsed.password,
-    database: parsed.pathname.split("/")[1],
-    warehouse: parsed.pathname.split("/")[2],
-  };
-}
-
-export function connectToSnowflake(
-  config: SnowflakeConnectionConfig,
-): snowflake.Connection {
-  const connection = snowflake.createConnection({
-    ...config,
-    clientSessionKeepAlive: true,
-  });
-  connection.connect((err) => {
-    if (err) {
-      console.error(`Failed to connect to Snowflake: ${err.message}`);
-    }
-  });
-  return connection;
-}
-
-export async function disconnectFromSnowflake(
-  connection: snowflake.Connection,
-) {
-  connection.destroy((err) => {
-    if (err) {
-      console.error(`Failed to disconnect from Snowflake: ${err.message}`);
-    }
-  });
-}
-
-export async function getForeignKeysSnowflake(
-  connection: snowflake.Connection,
-  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 = '${schemaName}' 
-    and TABLE_NAME != '${tableName}' 
-    and (COLUMN_NAME = '${primaryKey}' 
-    or COLUMN_NAME = '${depluralizedTableName}_${primaryKey}' 
-    or COLUMN_NAME = '${depluralizedTableName}${capitalize(primaryKey)}')`;
-  const results = await runQuerySnowflake(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 INFORMATION_SCHEMA.COLUMNS 
-      WHERE TABLE_SCHEMA = '${schemaName}' 
-      AND TABLE_NAME = '${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 runQuerySnowflake(sql, connection);
-    foreignKeysString = results.rows.map((key) => {
-      return key.COLUMN_NAME;
-    });
-    foreignKeysString = [...new Set(foreignKeysString)];
-  }
-  return foreignKeysString;
-}
-
-export async function getSchemaColumnInfoSnowflake(
-  connection: snowflake.Connection,
-  schemaName: string,
-  tableNames: { tableName: string; schemaName: string }[],
-) {
-  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 runQuerySnowflake(query, connection);
-      return {
-        tableName: `${tableName.schemaName}.${tableName.tableName}`,
-        displayName: `${tableName.schemaName}.${tableName.tableName}`,
-        columns: results.rows.map((row) => {
-          const postgresType = POSTGRES_SNOWFLAKE_MAP[row.dataType];
-          return {
-            columnName: row.columnName,
-            displayName: row.columnName,
-            dataTypeID: postgresType,
-            fieldType: row.dataType,
-          };
-        }),
-      };
-    }),
-  );
-  return allColumns;
-}