@quillsql/node 0.5.9 → 0.6.1

package/src/db/BigQuery.ts

@@ -1,4 +1,3 @@
-import { Client } from "../models/Client";
 import { BigQuery } from "@google-cloud/bigquery";
 import { QuillQueryResults } from "./DatabaseHelper";
 import { capitalize, depluralize } from "../utils/textProcessing";
@@ -24,7 +23,7 @@ export function formatBigQueryConfig(connectionString: string): BigQueryConfig {
     // Validate if required fields are present
     if (!serviceAccount.project_id || !serviceAccount.private_key) {
       throw new Error(
-        "Invalid service account JSON. Required fields are missing."
+        "Invalid service account JSON. Required fields are missing.",
       );
     }
 
@@ -44,7 +43,7 @@ export function connectToBigQuery(config: BigQueryConfig) {
 
 export async function runQueryBigQuery(
   sql: string,
-  bigQuery: BigQuery
+  bigQuery: BigQuery,
 ): Promise<QuillQueryResults> {
   const rows = await bigQuery.query(sql);
   if (!rows[0] || rows[0].length === 0) return { fields: [], rows: [] };
@@ -80,7 +79,7 @@ export async function getSchemaBigQuery(bigQuery: BigQuery): Promise<string[]> {
 
 export async function getTablesBySchemaBigQuery(
   bigQuery: BigQuery,
-  schemaNames: string[]
+  schemaNames: string[],
 ): Promise<{ tableName: string; schemaName: string }[]> {
   const allColumns = await Promise.all(
     schemaNames.map(async (schema) => {
@@ -89,7 +88,7 @@ export async function getTablesBySchemaBigQuery(
       return rows[0].map((row) => {
         return { tableName: row.table_name, schemaName: schema };
       });
-    })
+    }),
   );
   return allColumns.flat();
 }
@@ -97,7 +96,7 @@ export async function getTablesBySchemaBigQuery(
 export async function getColumnsByTableBigQuery(
   bigQuery: BigQuery,
   schemaName: string,
-  tableName: string
+  tableName: string,
 ): Promise<string[]> {
   const sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS WHERE table_name = '${tableName}'`;
   const rows = await bigQuery.query(sql);
@@ -108,7 +107,7 @@ export async function getForeignKeysBigQuery(
   connection: BigQuery,
   schemaName: string,
   tableName: string,
-  primaryKey: string
+  primaryKey: string,
 ): Promise<string[]> {
   const depluralizedTableName = depluralize(tableName);
   let sql = `SELECT column_name FROM ${schemaName}.INFORMATION_SCHEMA.COLUMNS 
@@ -121,7 +120,7 @@ export async function getForeignKeysBigQuery(
     return key.column_name;
   });
   foreignKeysString = foreignKeysString.filter(
-    (key) => key !== "id" && key !== "_id_"
+    (key) => key !== "id" && key !== "_id_",
   );
   foreignKeysString = [...new Set(foreignKeysString)];
   if (foreignKeysString.length === 0) {
@@ -144,7 +143,7 @@ export async function getForeignKeysBigQuery(
 export async function getSchemaColumnInfoBigQuery(
   connection: BigQuery,
   schemaName: string,
-  tableNames: { tableName: string; schemaName: string }[]
+  tableNames: { tableName: string; schemaName: string }[],
 ): Promise<
   { tableName: string; columns: { columnName: string; dataTypeID: number }[] }[]
 > {
@@ -167,7 +166,7 @@ export async function getSchemaColumnInfoBigQuery(
           fieldType: row.dataType,
         })),
       };
-    })
+    }),
   );
   return allColumns;
 }
@@ -179,6 +178,7 @@ function convertBigQueryTypeToPostgresOID(type: string): number {
     FLOAT: 700,
     TIMESTAMP: 1114,
     DATE: 1082,
+    BOOL: 16,
   };
 
   const postgresType = typeToOidMap[type.toUpperCase()] || "VARCHAR"; // Default to 'text' if the type is not recognized

package/src/db/CachedConnection.ts

@@ -1,55 +1,53 @@
-import { Pool } from "pg";
-import { Mapable, CacheCredentials } from "../models/Cache";
+import { Mappable, CacheCredentials } from "../models/Cache";
 import { QuillConfig } from "../models/Quill";
 import { createClient } from "redis";
-import { isSuperset } from "../utils/Error";
+import { isSuperset, PgError } from "../utils/Error";
 import {
   DatabaseConnection,
   connectToDatabase,
   disconnectFromDatabase,
   runQueryByDatabase,
 } from "./DatabaseHelper";
-
-class PgError extends Error {
-  code?: string;
-  detail?: string;
-  hint?: string;
-  position?: string;
-  // Add other properties if needed
-  constructor(detail?: string, hint?: string, position?: string) {
-    super();
-    this.detail = detail;
-    this.hint = hint;
-    this.position = position;
-  }
-}
+import { PostgresConnectionConfig } from "./Postgres";
+import { SnowflakeConnectionConfig } from "./Snowflake";
+import { BigQueryConfig } from "./BigQuery";
+import { MysqlConnectionConfig } from "./Mysql";
 
 /** The TTL for new cache entries (default: 1h) */
 const DEFAULT_CACHE_TTL = 24 * 60 * 60;
 
 export class CachedConnection {
   public databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql";
-  public pool: DatabaseConnection | null;
+  public readonly pool: DatabaseConnection;
   public orgId: any;
   public ttl: number;
-  public cache: Mapable | null;
-  private config: any;
+  public cache: Mappable | null;
+
+  private _isClosed: boolean = false;
+  public get isClosed(): boolean {
+    return this._isClosed;
+  }
 
   constructor(
     databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-    config: any,
+    config:
+      | PostgresConnectionConfig
+      | SnowflakeConnectionConfig
+      | BigQueryConfig
+      | MysqlConnectionConfig,
     cacheConfig: Partial<CacheCredentials> = {},
   ) {
     this.databaseType = databaseType;
     this.pool = connectToDatabase(databaseType, config);
-    this.config = config;
     this.ttl = cacheConfig?.ttl ?? DEFAULT_CACHE_TTL;
     this.cache = this.getCache(cacheConfig);
   }
 
-  public async query(text: string, values?: any[]): Promise<any> {
+  public async query(text: string): Promise<any> {
     try {
-      this.pool = this.getPool();
+      if (this.isClosed) {
+        throw new Error("Connection is closed");
+      }
       if (!this.cache) {
         return await runQueryByDatabase(this.databaseType, this.pool, text);
       }
@@ -70,6 +68,7 @@ export class CachedConnection {
     } catch (err) {
       if (isSuperset(err, PgError)) {
         throw new PgError(
+          (err as any).message,
           (err as any).detail,
           (err as any).hint,
           (err as any).position,
@@ -77,10 +76,6 @@ export class CachedConnection {
       } else if (err instanceof Error) {
         throw new Error(err.message);
       }
-    } finally {
-      if (this.databaseType.toLowerCase() === "mysql") {
-        this.close();
-      }
     }
   }
 
@@ -93,27 +88,22 @@ export class CachedConnection {
     host,
     port,
     cacheType,
-  }: QuillConfig["cache"]): Mapable | null {
+  }: QuillConfig["cache"]): Mappable | null {
     if (cacheType === "redis" || cacheType === "rediss") {
       const redisURL = `${cacheType}://${username}:${password}@${host}:${port}`;
       const client = createClient({ url: redisURL });
       client.connect();
-      return client as Mapable;
+      return client as Mappable;
     }
     return null;
   }
 
   public getPool() {
-    if (!this.pool) {
-      this.pool = connectToDatabase(this.databaseType, this.config);
-    }
     return this.pool;
   }
 
   async close() {
-    if (this.pool) {
-      disconnectFromDatabase(this.databaseType, this.pool);
-      this.pool = null;
-    }
+    disconnectFromDatabase(this.databaseType, this.pool);
+    this._isClosed = true;
   }
 }

package/src/db/DatabaseHelper.ts

@@ -1,6 +1,5 @@
 import { Pool } from "pg";
 import snowflake from "snowflake-sdk";
-import { Client } from "../models/Client";
 import { Pool as MysqlPool } from "mysql2";
 import { BigQuery } from "@google-cloud/bigquery";
 import {
@@ -65,13 +64,12 @@ export interface QuillQueryResults {
 
 export function getDatabaseCredentials(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connectionString: string
+  connectionString: string,
 ):
   | PostgresConnectionConfig
   | SnowflakeConnectionConfig
   | BigQueryConfig
-  | MysqlConnectionConfig
-  | undefined {
+  | MysqlConnectionConfig {
   switch (databaseType.toLowerCase()) {
     case "postgres":
       return formatPostgresConfig(connectionString);
@@ -84,7 +82,7 @@ export function getDatabaseCredentials(
     case "mysql":
       return formatMysqlConfig(connectionString);
     default:
-      return undefined;
+      throw new Error("Invalid database type");
   }
 }
 
@@ -94,7 +92,7 @@ export function connectToDatabase(
     | PostgresConnectionConfig
     | SnowflakeConnectionConfig
     | BigQueryConfig
-    | MysqlConnectionConfig
+    | MysqlConnectionConfig,
 ): DatabaseConnection {
   switch (databaseType.toLowerCase()) {
     case "postgres":
@@ -112,10 +110,24 @@ export function connectToDatabase(
   }
 }
 
+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);
+  } finally {
+    await disconnectFromDatabase(databaseType, connection);
+  }
+}
+
 export function runQueryByDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
   connection: DatabaseConnection,
-  sql: string
+  sql: string,
 ): Promise<QuillQueryResults> | undefined {
   switch (databaseType.toLowerCase()) {
     case "postgres":
@@ -133,9 +145,22 @@ export function runQueryByDatabase(
   }
 }
 
+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
+  database: DatabaseConnection,
 ) {
   switch (databaseType.toLowerCase()) {
     case "postgres":
@@ -155,7 +180,7 @@ export function disconnectFromDatabase(
 
 export async function getSchemasByDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
-  connection: DatabaseConnection
+  connection: DatabaseConnection,
 ): Promise<string[] | undefined> {
   switch (databaseType.toLowerCase()) {
     case "postgres":
@@ -177,33 +202,33 @@ export async function getSchemasByDatabase(
 export async function getTablesBySchemaByDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
   connection: DatabaseConnection,
-  schemaName: string | string[]
+  schemaName: string | string[],
 ): Promise<string[] | { tableName: string; schemaName: string }[] | undefined> {
   switch (databaseType.toLowerCase()) {
     case "postgres":
       return getTablesBySchemaPostgres(
         connection as Pool,
-        schemaName as string[]
+        schemaName as string[],
       );
     case "postgresql":
       return getTablesBySchemaPostgres(
         connection as Pool,
-        schemaName as string[]
+        schemaName as string[],
       );
     case "snowflake":
       return getTablesBySchemaSnowflake(
         connection as snowflake.Connection,
-        schemaName as string[]
+        schemaName as string[],
       );
     case "bigquery":
       return getTablesBySchemaBigQuery(
         connection as BigQuery,
-        schemaName as string[]
+        schemaName as string[],
       );
     case "mysql":
       return getTablesBySchemaMysql(
         connection as MysqlPool,
-        schemaName as string[]
+        schemaName as string[],
       );
     default:
       return undefined;
@@ -215,38 +240,38 @@ export async function getColumnsByTableByDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
   connection: DatabaseConnection,
   schemaName: string,
-  tableName: string
+  tableName: string,
 ): Promise<string[] | undefined> {
   switch (databaseType.toLowerCase()) {
     case "postgres":
       return getColumnsByTablePostgres(
         connection as Pool,
         schemaName,
-        tableName
+        tableName,
       );
     case "postgresql":
       return getColumnsByTablePostgres(
         connection as Pool,
         schemaName,
-        tableName
+        tableName,
       );
     case "snowflake":
       return getColumnsByTableSnowflake(
         connection as snowflake.Connection,
         schemaName,
-        tableName
+        tableName,
       );
     case "bigquery":
       return getColumnsByTableBigQuery(
         connection as BigQuery,
         schemaName,
-        tableName
+        tableName,
       );
     case "mysql":
       return getColumnsByTableMysql(
         connection as MysqlPool,
         schemaName,
-        tableName
+        tableName,
       );
     default:
       return undefined;
@@ -258,7 +283,7 @@ export async function getForiegnKeysByDatabase(
   connection: DatabaseConnection,
   schemaName: string,
   tableName: string,
-  primaryKey: string
+  primaryKey: string,
 ): Promise<string[] | undefined> {
   switch (databaseType.toLowerCase()) {
     case "postgres":
@@ -266,35 +291,35 @@ export async function getForiegnKeysByDatabase(
         connection as Pool,
         schemaName,
         tableName,
-        primaryKey
+        primaryKey,
       );
     case "postgresql":
       return getForeignKeysPostgres(
         connection as Pool,
         schemaName,
         tableName,
-        primaryKey
+        primaryKey,
       );
     case "snowflake":
       return getForeignKeysSnowflake(
         connection as snowflake.Connection,
         schemaName,
         tableName,
-        primaryKey
+        primaryKey,
       );
     case "bigquery":
       return getForeignKeysBigQuery(
         connection as BigQuery,
         schemaName,
         tableName,
-        primaryKey
+        primaryKey,
       );
     case "mysql":
       return getForeignKeysMysql(
         connection as MysqlPool,
         schemaName,
         tableName,
-        primaryKey
+        primaryKey,
       );
     default:
       return undefined;
@@ -305,38 +330,38 @@ export function getColumnInfoBySchemaByDatabase(
   databaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
   connection: DatabaseConnection,
   schemaName: string,
-  tables: string[] | { tableName: string; 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 }[]
+        tables as { tableName: string; schemaName: string }[],
       );
     case "postgresql":
       return getSchemaColumnInfoPostgress(
         connection as Pool,
         schemaName,
-        tables as { tableName: string; schemaName: string }[]
+        tables as { tableName: string; schemaName: string }[],
       );
     case "snowflake":
       return getSchemaColumnInfoSnowflake(
         connection as snowflake.Connection,
         schemaName,
-        tables as { tableName: string; schemaName: string }[]
+        tables as { tableName: string; schemaName: string }[],
       );
     case "bigquery":
       return getSchemaColumnInfoBigQuery(
         connection as BigQuery,
         schemaName,
-        tables as { tableName: string; schemaName: string }[]
+        tables as { tableName: string; schemaName: string }[],
       );
     case "mysql":
       return getSchemaColumnInfoMysql(
         connection as MysqlPool,
         schemaName,
-        tables as { tableName: string; schemaName: string }[]
+        tables as { tableName: string; schemaName: string }[],
       );
     default:
       return undefined;

package/src/db/Mysql.ts

@@ -1,5 +1,3 @@
-import { connect } from "http2";
-import { Client } from "../models/Client";
 import mysql, { Pool as MysqlPool } from "mysql2";
 import { QuillQueryResults } from "./DatabaseHelper";
 import url from "url";

package/src/db/Postgres.ts

@@ -1,10 +1,8 @@
 import { Pool } from "pg";
-import { Client } from "../models/Client";
-import { disconnect } from "process";
+// import { Client } from "../models/Client";
 import { QuillQueryResults } from "./DatabaseHelper";
 import { capitalize, depluralize } from "../utils/textProcessing";
 import { PG_TYPES } from "../assets/pgtypes";
-import { run } from "node:test";
 
 export type PostgresConnectionConfig = {
   connectionString: string;
@@ -26,7 +24,7 @@ export function disconnectFromPostgres(pool: Pool) {
 
 export async function runQueryPostgres(
   sql: string,
-  pool: Pool
+  pool: Pool,
 ): Promise<QuillQueryResults> {
   const results = await pool.query(sql);
   return {
@@ -47,7 +45,7 @@ export async function getSchemasPostgres(pool: Pool): Promise<string[]> {
 
 export async function getTablesBySchemaPostgres(
   pool: Pool,
-  schemaNames: string[]
+  schemaNames: string[],
 ): Promise<{ tableName: string; schemaName: string }[]> {
   const allColumns = await Promise.all(
     schemaNames.map(async (schema) => {
@@ -56,7 +54,7 @@ export async function getTablesBySchemaPostgres(
       return results.rows.map((row) => {
         return { tableName: row.table_name, schemaName: row.table_schema };
       });
-    })
+    }),
   );
   return allColumns.flat();
 }
@@ -64,7 +62,7 @@ export async function getTablesBySchemaPostgres(
 export async function getColumnsByTablePostgres(
   pool: Pool,
   schemaName: string,
-  tableName: 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);
@@ -75,7 +73,7 @@ export async function getForeignKeysPostgres(
   pool: Pool,
   schemaName: string,
   tableName: string,
-  primaryKey: string
+  primaryKey: string,
 ): Promise<string[]> {
   const depluralizedTableName = depluralize(tableName);
   let sql = `SELECT column_name FROM information_schema.columns 
@@ -89,7 +87,7 @@ export async function getForeignKeysPostgres(
     return key.column_name;
   });
   foreignKeysString = foreignKeysString.filter(
-    (key) => key !== "id" && key !== "_id_"
+    (key) => key !== "id" && key !== "_id_",
   );
   foreignKeysString = [...new Set(foreignKeysString)];
   if (foreignKeysString.length === 0) {
@@ -113,7 +111,7 @@ export async function getForeignKeysPostgres(
 export async function getSchemaColumnInfoPostgress(
   pool: Pool,
   schemaName: string,
-  tableNames: { tableName: string; schemaName: string }[]
+  tableNames: { tableName: string; schemaName: string }[],
 ): Promise<
   { tableName: string; columns: { columnName: string; dataTypeID: number }[] }[]
 > {
@@ -145,43 +143,43 @@ export async function getSchemaColumnInfoPostgress(
           };
         }),
       };
-    })
+    }),
   );
   return allColumns;
 }
 
 export function formatPostgresConfig(
-  connectionString: string
+  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 };
-}
+// 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 };
+// }