@quillsql/node 0.5.8 → 0.6.0

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 };
+// }

package/src/db/Snowflake.ts

@@ -1,5 +1,4 @@
 import snowflake from "snowflake-sdk";
-import { Client } from "../models/Client";
 import { QuillQueryResults } from "./DatabaseHelper";
 import { capitalize, depluralize } from "../utils/textProcessing";
 
@@ -31,7 +30,7 @@ export type SnowflakeConnectionConfig = {
 
 export async function runQuerySnowflake(
   sql: string,
-  connection: snowflake.Connection
+  connection: snowflake.Connection,
 ): Promise<QuillQueryResults> {
   const results = await new Promise((resolve, reject) => {
     connection.execute({
@@ -56,7 +55,7 @@ export async function runQuerySnowflake(
 }
 
 export async function getSchemasSnowflake(
-  connection: snowflake.Connection
+  connection: snowflake.Connection,
 ): Promise<string[]> {
   const sql = `SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA
     WHERE SCHEMA_NAME != 'INFORMATION_SCHEMA'`;
@@ -66,7 +65,7 @@ export async function getSchemasSnowflake(
 
 export async function getTablesBySchemaSnowflake(
   connection: snowflake.Connection,
-  schemaNames: string[]
+  schemaNames: string[],
 ): Promise<{ tableName: string; schemaName: string }[]> {
   const allColumns = await Promise.all(
     schemaNames.map(async (schema) => {
@@ -80,7 +79,7 @@ export async function getTablesBySchemaSnowflake(
       return results.rows.map((row) => {
         return { tableName: row.tableName, schemaName: row.schemaName };
       });
-    })
+    }),
   );
   return allColumns.flat();
 }
@@ -88,7 +87,7 @@ export async function getTablesBySchemaSnowflake(
 export async function getColumnsByTableSnowflake(
   connection: snowflake.Connection,
   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 runQuerySnowflake(sql, connection);
@@ -96,7 +95,7 @@ export async function getColumnsByTableSnowflake(
 }
 
 export function formatSnowflakeConfig(
-  connectionString: string
+  connectionString: string,
 ): SnowflakeConnectionConfig {
   const parsed = new URL(connectionString);
   return {
@@ -109,7 +108,7 @@ export function formatSnowflakeConfig(
 }
 
 export function connectToSnowflake(
-  config: SnowflakeConnectionConfig
+  config: SnowflakeConnectionConfig,
 ): snowflake.Connection {
   const connection = snowflake.createConnection({
     ...config,
@@ -124,9 +123,9 @@ export function connectToSnowflake(
 }
 
 export async function disconnectFromSnowflake(
-  connection: snowflake.Connection
+  connection: snowflake.Connection,
 ) {
-  connection.destroy((err, conn) => {
+  connection.destroy((err) => {
     if (err) {
       console.error(`Failed to disconnect from Snowflake: ${err.message}`);
     }
@@ -137,9 +136,9 @@ export async function getForeignKeysSnowflake(
   connection: snowflake.Connection,
   schemaName: string,
   tableName: string,
-  primaryKey: string
+  primaryKey: string,
 ): Promise<string[]> {
-  let depluralizedTableName = depluralize(tableName);
+  const depluralizedTableName = depluralize(tableName);
   let sql = `SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS 
     WHERE TABLE_SCHEMA = '${schemaName}' 
     AND TABLE_NAME = '${schemaName}' 
@@ -152,7 +151,7 @@ export async function getForeignKeysSnowflake(
     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) {
@@ -177,7 +176,7 @@ export async function getForeignKeysSnowflake(
 export async function getSchemaColumnInfoSnowflake(
   connection: snowflake.Connection,
   schemaName: string,
-  tableNames: { tableName: string; schemaName: string }[]
+  tableNames: { tableName: string; schemaName: string }[],
 ) {
   const allColumns = await Promise.all(
     tableNames.map(async (tableName) => {
@@ -200,7 +199,7 @@ export async function getSchemaColumnInfoSnowflake(
           };
         }),
       };
-    })
+    }),
   );
   return allColumns;
 }

package/src/index.ts

@@ -1,4 +1,3 @@
-import QuillServerClient from "./clients/QuillServerClient";
 import { CacheCredentials } from "./models/Cache";
 import {
   AdditionalProcessing,
@@ -76,13 +75,13 @@ export class Quill {
     if (databaseConnectionString) {
       credentials = getDatabaseCredentials(
         databaseType,
-        databaseConnectionString
+        databaseConnectionString,
       );
     }
     this.targetConnection = new CachedConnection(
       databaseType,
       credentials,
-      cache || {}
+      cache || {},
     );
   }
 
@@ -92,13 +91,18 @@ export class Quill {
   }: QuillQueryParams): Promise<QuillQueryResult> {
     this.targetConnection.orgId = orgId;
     let responseMetadata: any = {};
+
+    if (!metadata.task) {
+      return { error: "Missing task.", status: "error", data: {} };
+    }
+
     try {
       const preQueryResults = metadata.preQueries
         ? await this.runQueries(
             metadata.preQueries,
             this.targetConnection.databaseType,
             metadata.databaseType,
-            metadata.runQueryConfig
+            metadata.runQueryConfig,
           )
         : {};
       if (metadata.runQueryConfig?.overridePost) {
@@ -114,7 +118,11 @@ export class Quill {
         viewQuery: metadata.preQueries ? metadata.preQueries[0] : undefined,
       });
       if (response.error) {
-        return { status: "error", error: response.error };
+        return {
+          status: "error",
+          error: response.error,
+          data: response.metadata || {},
+        };
       }
       // if there is no metadata object in the response, create one
       if (response.metadata) {
@@ -124,7 +132,7 @@ export class Quill {
         response.queries,
         this.targetConnection.databaseType,
         metadata.databaseType,
-        responseMetadata.runQueryConfig
+        responseMetadata.runQueryConfig,
       );
       // QUICK JANKY FIX TO UPDATE METADATA AFTER GETTING MAPPED ARRAYS
       if (results.mappedArray && responseMetadata.runQueryConfig?.arrayToMap) {
@@ -153,8 +161,8 @@ export class Quill {
     } catch (err) {
       return {
         status: "error",
-        error: (err as any).message,
-        data: responseMetadata,
+        error: (err as any).response?.data?.error ?? (err as any).message,
+        data: responseMetadata || {},
       };
     }
   }
@@ -163,7 +171,7 @@ export class Quill {
     queries: any[] | undefined,
     pkDatabaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
     databaseType?: string,
-    runQueryConfig?: AdditionalProcessing
+    runQueryConfig?: AdditionalProcessing,
   ) {
     let results: any;
     if (!queries) return { ...results, queryResults: [] };
@@ -177,12 +185,13 @@ export class Quill {
         queryResults: [],
       };
     }
+
     if (runQueryConfig?.arrayToMap) {
       const mappedArray = await mapQueries(queries, this.targetConnection);
       return { ...results, queryResults: [], mappedArray };
     } else if (runQueryConfig?.getColumns) {
       const queryResult = await this.targetConnection.query(
-        `${queries[0].replace(/;/, "")} limit 1`
+        `${queries[0].replace(/;/, "")} limit 1`,
       );
       const columns = queryResult.fields.map((field: any) => {
         return {
@@ -209,7 +218,7 @@ export class Quill {
           }
           try {
             const queryResult = await this.targetConnection.query(
-              `${table.viewQuery.replace(/;/, "")} ${limit}`
+              `${table.viewQuery.replace(/;/, "")} ${limit}`,
             );
             const columns = queryResult.fields.map((field: any) => {
               return {
@@ -221,10 +230,15 @@ export class Quill {
               };
             });
             return { ...table, columns: columns, rows: queryResult.rows };
-          } catch (err) {
-            return { ...table, error: "Error fetching columns" };
+          } catch (err: any) {
+            return {
+              ...table,
+              error: err.message
+                ? `Error fetching columns: ${err.message}`
+                : "Error fetching columns",
+            };
           }
-        })
+        }),
       );
       results = { ...results, queryResults };
       if (runQueryConfig?.fieldsToRemove) {
@@ -241,15 +255,16 @@ export class Quill {
     } else if (runQueryConfig?.getTables) {
       const queryResult = await getTablesBySchemaByDatabase(
         this.targetConnection.databaseType,
-        this.targetConnection.pool,
-        runQueryConfig.schemaNames! || runQueryConfig.schema
+        this.targetConnection.getPool(),
+        runQueryConfig.schemaNames! || runQueryConfig.schema,
       );
       const schemaInfo = await getColumnInfoBySchemaByDatabase(
         this.targetConnection.databaseType,
-        this.targetConnection.pool,
+        this.targetConnection.getPool(),
         runQueryConfig.schema!,
-        queryResult!
+        queryResult!,
       );
+      this.targetConnection.close();
       return schemaInfo;
     } else {
       if (runQueryConfig?.limitThousand) {
@@ -264,7 +279,7 @@ export class Quill {
       const queryResults = await Promise.all(
         queries.map(async (query) => {
           return await this.targetConnection.query(query);
-        })
+        }),
       );
       results = { ...results, queryResults };
       if (runQueryConfig?.fieldsToRemove) {
@@ -298,12 +313,12 @@ export class Quill {
 
   private async postQuill(
     path: string,
-    payload: any
+    payload: any,
   ): Promise<QuillClientResponse> {
     const response = await axios.post(
       `${this.baseUrl}/sdk/${path}`,
       payload,
-      this.config
+      this.config,
     );
     return response.data;
   }

package/src/models/Cache.ts

@@ -4,7 +4,7 @@ export interface Mapable {
     key: string,
     value: string,
     type?: string,
-    ttl?: number
+    ttl?: number,
   ): Promise<string | null>;
 }
 
@@ -15,4 +15,4 @@ export interface CacheCredentials {
   port: string;
   cacheType: string;
   ttl?: number;
-}
+}

package/src/utils/Error.ts

@@ -4,18 +4,32 @@ export class PgError extends Error {
   hint?: string;
   position?: string;
   // Add other properties if needed
+  constructor(
+    message: string,
+    detail?: string,
+    hint?: string,
+    position?: string,
+    code?: string,
+  ) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+    this.hint = hint;
+    this.position = position;
+  }
 }
 
 export function isSuperset(obj: any, baseClass: any): boolean {
-  // Get the property names of the base class
-  const baseProps = Object.getOwnPropertyNames(baseClass.prototype);
+  // Get the property names of the base class instance
+  const baseInstance = new baseClass();
+  const baseProps = Object.keys(baseInstance);
 
   // Check if the object has all the properties of the base class
   for (const prop of baseProps) {
-    if (!obj.hasOwnProperty(prop)) {
+    if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
       return false;
     }
   }
 
   return true;
-}
+}

package/src/utils/RunQueryProcesses.ts

@@ -1,6 +1,6 @@
 import { CachedConnection } from "../db/CachedConnection";
 
-interface TableSchemaInfo {
+export interface TableSchemaInfo {
   fieldType: string;
   name: string;
   displayName: string;
@@ -9,7 +9,7 @@ interface TableSchemaInfo {
 
 export function removeFields(queryResults: any, fieldsToRemove: string[]): any {
   const fields = queryResults.fields.filter(
-    (field: { name: any }) => !fieldsToRemove.includes(field.name)
+    (field: { name: any }) => !fieldsToRemove.includes(field.name),
   );
   const rows = queryResults.rows.map((row: any) => {
     fieldsToRemove.forEach((field) => {
@@ -22,7 +22,7 @@ export function removeFields(queryResults: any, fieldsToRemove: string[]): any {
 
 export async function mapQueries(
   queries: string[],
-  targetConnection: CachedConnection
+  targetConnection: CachedConnection,
 ): Promise<any[]> {
   const mappedArray = [];
   for (let i = 0; i < queries.length; i++) {

package/src/utils/textProcessing.ts

@@ -10,4 +10,4 @@ export function depluralize(text: string): string {
     return text.slice(0, -1);
   }
   return text;
-}
+}