@lightdash/warehouses 0.2100.0 → 0.2101.1

package/dist/warehouseClients/SnowflakeWarehouseClient.d.ts

@@ -43,11 +43,19 @@ export declare class SnowflakeSqlBuilder extends WarehouseBaseSqlBuilder {
 export declare class SnowflakeWarehouseClient extends WarehouseBaseClient<CreateSnowflakeCredentials> {
     connectionOptions: ConnectionOptions;
     quotedIdentifiersIgnoreCase?: boolean;
+    private externalBrowserConnectionPromise?;
     constructor(credentials: CreateSnowflakeCredentials);
     private getConnection;
+    /**
+     * Creates and caches a connection for external browser authentication.
+     * This prevents opening multiple browser tabs when parallel queries are executed.
+     */
+    private createExternalBrowserConnection;
+    private createConnection;
     private prepareWarehouse;
     private getFieldsFromStatement;
     private getAsyncStatementResults;
+    private destroyConnection;
     getAsyncQueryResults<TFormattedRow extends Record<string, unknown>>({ sql, page, pageSize, queryId }: WarehouseGetAsyncQueryResultsArgs, rowFormatter?: (row: Record<string, unknown>) => TFormattedRow): Promise<WarehouseGetAsyncQueryResults<TFormattedRow>>;
     executeAsyncQuery({ sql, values, tags, timezone }: WarehouseExecuteAsyncQueryArgs, resultsStreamCallback: (rows: WarehouseResults['rows'], fields: WarehouseResults['fields']) => void): Promise<WarehouseExecuteAsyncQuery>;
     private executeAsyncStatement;

package/dist/warehouseClients/SnowflakeWarehouseClient.js

@@ -82,6 +82,7 @@ const normaliseSnowflakeType = (type) => {
     }
     return match[0];
 };
+const EXTERNAL_BROWSER_AUTHENTICATOR = 'EXTERNALBROWSER';
 const mapFieldType = (type) => {
     switch (normaliseSnowflakeType(type)) {
         case SnowflakeTypes.NUMBER:
@@ -167,7 +168,7 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
         }
         let authenticationOptions = {};
         // if authenticationType is undefined, we assume it is a password authentication, for backwards compatibility
-        if (credentials.authenticationType === 'sso') {
+        if (credentials.authenticationType === common_1.SnowflakeAuthenticationType.SSO) {
             if (!credentials.token) {
                 // Perhaps we forgot to refresh the token before building the client, check buildAdapter for more details
                 throw new common_1.UnexpectedServerError('Snowflake token is required for SSO authentication');
@@ -178,9 +179,16 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
                 authenticator: 'OAUTH',
             };
         }
+        else if (credentials.authenticationType ===
+            common_1.SnowflakeAuthenticationType.EXTERNAL_BROWSER) {
+            authenticationOptions = {
+                authenticator: EXTERNAL_BROWSER_AUTHENTICATOR,
+            };
+        }
         else if (credentials.privateKey &&
             (!credentials.password ||
-                credentials.authenticationType === 'private_key')) {
+                credentials.authenticationType ===
+                    common_1.SnowflakeAuthenticationType.PRIVATE_KEY)) {
             if (!credentials.privateKeyPass) {
                 authenticationOptions = {
                     username: credentials.user,
@@ -242,9 +250,53 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
             warehouse: this.connectionOptions.warehouse,
             accessUrl: this.connectionOptions.accessUrl,
         };
-        console.info(`Initialized snowflake warehouse client with authentication type "${credentials.authenticationType}" and connection options: ${JSON.stringify(logConnectionOptions)}`);
+        if (credentials.requireUserCredentials)
+            console.info(`Initialized snowflake warehouse client with "requireUserCredentials" authentication type "${credentials.authenticationType}" and connection options: ${JSON.stringify(logConnectionOptions)}`);
     }
     async getConnection(connectionOptionsOverrides) {
+        // External browser authentication uses a cached connection to avoid opening multiple browser tabs
+        if (this.connectionOptions.authenticator ===
+            EXTERNAL_BROWSER_AUTHENTICATOR) {
+            return this.createExternalBrowserConnection(connectionOptionsOverrides);
+        }
+        // For other authentication types, create a new connection with optional overrides
+        return this.createConnection(connectionOptionsOverrides);
+    }
+    /**
+     * Creates and caches a connection for external browser authentication.
+     * This prevents opening multiple browser tabs when parallel queries are executed.
+     */
+    async createExternalBrowserConnection(connectionOptionsOverrides) {
+        // Return cached promise if one exists (handles both in-flight and completed connections)
+        if (this.externalBrowserConnectionPromise) {
+            return this.externalBrowserConnectionPromise;
+        }
+        // Create and cache the connection promise
+        this.externalBrowserConnectionPromise = (async () => {
+            let connection;
+            try {
+                connection = (0, snowflake_sdk_1.createConnection)({
+                    ...this.connectionOptions,
+                    ...connectionOptionsOverrides,
+                });
+                console.info(`Connecting to snowflake warehouse with "external_browser" authentication type`);
+                await Util.promisify(connection.connectAsync.bind(connection))();
+            }
+            catch (e) {
+                throw new common_1.WarehouseConnectionError(`Snowflake error: ${(0, common_1.getErrorMessage)(e)}`);
+            }
+            return connection;
+        })();
+        try {
+            return await this.externalBrowserConnectionPromise;
+        }
+        catch (e) {
+            // Clear cache on error to allow retry
+            this.externalBrowserConnectionPromise = undefined;
+            throw e;
+        }
+    }
+    async createConnection(connectionOptionsOverrides) {
         let connection;
         try {
             connection = (0, snowflake_sdk_1.createConnection)({
@@ -328,6 +380,22 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
             numRows: statement.getNumRows(),
         };
     }
+    async destroyConnection(connection, authenticator) {
+        if (authenticator === EXTERNAL_BROWSER_AUTHENTICATOR) {
+            // EXTERNALBROWSER connections are never destroyed - they live for the lifetime of the client✅
+            // Other auth types (password, SSO, private key) still destroy connections after use
+            return;
+        }
+        console.info(`Destroying snowflake connection for authenticator ${authenticator}`);
+        await new Promise((resolve, reject) => {
+            connection.destroy((err, conn) => {
+                if (err) {
+                    reject(new common_1.WarehouseConnectionError(err.message));
+                }
+                resolve(conn);
+            });
+        });
+    }
     async getAsyncQueryResults({ sql, page, pageSize, queryId }, rowFormatter) {
         if (queryId === null) {
             throw new common_1.WarehouseQueryError('Query ID is required');
@@ -350,14 +418,7 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
             throw this.parseError(error, sql);
         }
         finally {
-            await new Promise((resolve, reject) => {
-                connection.destroy((err, conn) => {
-                    if (err) {
-                        reject(new common_1.WarehouseConnectionError(err.message));
-                    }
-                    resolve(conn);
-                });
-            });
+            await this.destroyConnection(connection, this.connectionOptions.authenticator);
         }
     }
     async executeAsyncQuery({ sql, values, tags, timezone }, resultsStreamCallback) {
@@ -451,14 +512,7 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
             throw this.parseError(error, sql);
         }
         finally {
-            await new Promise((resolve, reject) => {
-                connection.destroy((err, conn) => {
-                    if (err) {
-                        reject(new common_1.WarehouseConnectionError(err.message));
-                    }
-                    resolve(conn);
-                });
-            });
+            await this.destroyConnection(connection, this.connectionOptions.authenticator);
         }
     }
     async executeStreamStatement(connection, sqlText, streamCallback, options) {
@@ -522,10 +576,7 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
     }
     async runTableCatalogQuery(database, schema, table) {
         const sqlText = `SHOW COLUMNS IN TABLE ${table}`;
-        const connection = await this.getConnection({
-            schema,
-            database,
-        });
+        const connection = await this.getConnection({ schema, database });
         try {
             return await this.executeStatements(connection, sqlText);
         }
@@ -536,14 +587,7 @@ class SnowflakeWarehouseClient extends WarehouseBaseClient_1.default {
             return undefined;
         }
         finally {
-            await new Promise((resolve, reject) => {
-                connection.destroy((err, conn) => {
-                    if (err) {
-                        reject(new common_1.WarehouseConnectionError(err.message));
-                    }
-                    resolve(conn);
-                });
-            });
+            await this.destroyConnection(connection, this.connectionOptions.authenticator);
         }
     }
     async getCatalog(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightdash/warehouses",
-  "version": "0.2100.0",
+  "version": "0.2101.1",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,10 +14,10 @@
     "lodash": "^4.17.21",
     "pg": "^8.13.1",
     "pg-cursor": "^2.10.0",
-    "snowflake-sdk": "~2.1.3",
+    "snowflake-sdk": "~2.3.1",
     "ssh2": "^1.14.0",
     "trino-client": "0.2.6",
-    "@lightdash/common": "0.2100.0"
+    "@lightdash/common": "0.2101.1"
   },
   "devDependencies": {
     "@types/pg": "^8.11.10",