@quillsql/node 0.5.1 → 0.5.3

package/dist/db/Snowflake.js

@@ -105,7 +105,7 @@ function formatSnowflakeConfig(connectionString) {
 }
 exports.formatSnowflakeConfig = formatSnowflakeConfig;
 function connectToSnowflake(config) {
-    const connection = snowflake_sdk_1.default.createConnection(config);
+    const connection = snowflake_sdk_1.default.createConnection(Object.assign(Object.assign({}, config), { clientSessionKeepAlive: true }));
     connection.connect((err) => {
         if (err) {
             console.error(`Failed to connect to Snowflake: ${err.message}`);

package/dist/index.js

@@ -124,6 +124,38 @@ class Quill {
                 });
                 return { columns };
             }
+            else if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getColumnsForSchema) {
+                const queryResults = yield Promise.all(queries.map((table) => __awaiter(this, void 0, void 0, function* () {
+                    if (!table.viewQuery) {
+                        return table;
+                    }
+                    let limit = "";
+                    if (runQueryConfig.limitBy) {
+                        limit = ` limit ${runQueryConfig.limitBy}`;
+                    }
+                    const queryResult = yield this.targetConnection.query(`${table.viewQuery.replace(/;/, "")} ${limit}`);
+                    const columns = queryResult.fields.map((field) => {
+                        return {
+                            fieldType: (0, schemaConversion_1.convertTypeToPostgres)(field.dataTypeID),
+                            name: field.name,
+                            displayName: field.name,
+                            isVisible: true,
+                            field: field.name,
+                        };
+                    });
+                    return Object.assign(Object.assign({}, table), { columns: columns, rows: queryResult.rows });
+                })));
+                results = Object.assign(Object.assign({}, results), { queryResults });
+                if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.fieldsToRemove) {
+                    results = Object.assign(Object.assign({}, results), { queryResults: queryResults.map((table) => {
+                            const removedColumns = table.columns.filter((column) => {
+                                var _a;
+                                return !((_a = runQueryConfig.fieldsToRemove) === null || _a === void 0 ? void 0 : _a.includes(column.name));
+                            });
+                            return Object.assign(Object.assign({}, table), { columns: removedColumns });
+                        }) });
+                }
+            }
             else if (runQueryConfig === null || runQueryConfig === void 0 ? void 0 : runQueryConfig.getTables) {
                 const queryResult = yield (0, DatabaseHelper_1.getTablesBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.pool, runQueryConfig.schemaNames || runQueryConfig.schema);
                 const schemaInfo = yield (0, DatabaseHelper_1.getColumnInfoBySchemaByDatabase)(this.targetConnection.databaseType, this.targetConnection.pool, runQueryConfig.schema, queryResult);

package/dist/models/Quill.d.ts

@@ -48,6 +48,7 @@ export interface QuillConfig {
 export interface AdditionalProcessing {
     getSchema?: boolean;
     getColumns?: boolean;
+    getColumnsForSchema?: boolean;
     getTables?: boolean;
     schema?: string;
     schemaNames?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/node",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Quill Server SDK for Node.js",
   "main": "dist/index.js",
   "module": "./dist/index.js",

package/src/db/Snowflake.ts

@@ -111,7 +111,10 @@ export function formatSnowflakeConfig(
 export function connectToSnowflake(
   config: SnowflakeConnectionConfig
 ): snowflake.Connection {
-  const connection = snowflake.createConnection(config);
+  const connection = snowflake.createConnection({
+    ...config,
+    clientSessionKeepAlive: true,
+  });
   connection.connect((err) => {
     if (err) {
       console.error(`Failed to connect to Snowflake: ${err.message}`);

package/src/index.ts

@@ -158,7 +158,7 @@ export class Quill {
   }
 
   private async runQueries(
-    queries: string[] | undefined,
+    queries: any[] | undefined,
     pkDatabaseType: "postgresql" | "snowflake" | "bigquery" | "mysql",
     databaseType?: string,
     runQueryConfig?: AdditionalProcessing
@@ -192,6 +192,43 @@ export class Quill {
         };
       });
       return { columns };
+    } else if (runQueryConfig?.getColumnsForSchema) {
+      const queryResults = await Promise.all(
+        queries.map(async (table) => {
+          if (!table.viewQuery) {
+            return table;
+          }
+          let limit = "";
+          if (runQueryConfig.limitBy) {
+            limit = ` limit ${runQueryConfig.limitBy}`;
+          }
+          const queryResult = await this.targetConnection.query(
+            `${table.viewQuery.replace(/;/, "")} ${limit}`
+          );
+          const columns = queryResult.fields.map((field: any) => {
+            return {
+              fieldType: convertTypeToPostgres(field.dataTypeID),
+              name: field.name,
+              displayName: field.name,
+              isVisible: true,
+              field: field.name,
+            };
+          });
+          return { ...table, columns: columns, rows: queryResult.rows };
+        })
+      );
+      results = { ...results, queryResults };
+      if (runQueryConfig?.fieldsToRemove) {
+        results = {
+          ...results,
+          queryResults: queryResults.map((table: any) => {
+            const removedColumns = table.columns.filter((column: any) => {
+              return !runQueryConfig.fieldsToRemove?.includes(column.name);
+            });
+            return { ...table, columns: removedColumns };
+          }),
+        };
+      }
     } else if (runQueryConfig?.getTables) {
       const queryResult = await getTablesBySchemaByDatabase(
         this.targetConnection.databaseType,

package/src/models/Quill.ts

@@ -54,6 +54,7 @@ export interface QuillConfig {
 export interface AdditionalProcessing {
   getSchema?: boolean;
   getColumns?: boolean;
+  getColumnsForSchema?: boolean;
   getTables?: boolean;
   schema?: string;
   schemaNames?: string[];