snowflake-kysely-dialect 0.1.0 → 0.1.2

package/dist/SnowflakeConnection.d.ts

@@ -1,8 +1,13 @@
 import { type CompiledQuery, type DatabaseConnection, type QueryResult } from 'kysely';
 import { type Connection } from 'snowflake-sdk';
+export declare class SnowflakeQueryTimeoutError extends Error {
+    readonly connectionIsUsable: boolean;
+    constructor(message: string, connectionIsUsable: boolean);
+}
 export declare class SnowflakeConnection implements DatabaseConnection {
     #private;
     constructor(conn: Connection);
+    setQueryTimeout(ms: number | undefined): void;
     beginTransaction(): Promise<void>;
     commitTransaction(): Promise<void>;
     rollbackTransaction(): Promise<void>;

package/dist/SnowflakeConnection.js

@@ -1,11 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnowflakeConnection = void 0;
+exports.SnowflakeConnection = exports.SnowflakeQueryTimeoutError = void 0;
+class SnowflakeQueryTimeoutError extends Error {
+    connectionIsUsable;
+    constructor(message, connectionIsUsable) {
+        super(message);
+        this.name = 'SnowflakeQueryTimeoutError';
+        this.connectionIsUsable = connectionIsUsable;
+    }
+}
+exports.SnowflakeQueryTimeoutError = SnowflakeQueryTimeoutError;
 class SnowflakeConnection {
     #conn;
+    #queryTimeoutMs;
     constructor(conn) {
         this.#conn = conn;
     }
+    setQueryTimeout(ms) {
+        this.#queryTimeoutMs = ms;
+    }
     async #executeRaw(sqlText) {
         await new Promise((resolve, reject) => {
             this.#conn.execute({
@@ -34,27 +47,48 @@ class SnowflakeConnection {
     async executeQuery(compiledQuery) {
         const sqlText = this.#translatePlaceholders(compiledQuery.sql);
         const binds = compiledQuery.parameters;
+        const timeoutMs = this.#queryTimeoutMs;
         return new Promise((resolve, reject) => {
-            this.#conn.execute({
+            let settled = false;
+            let timer;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                fn();
+            };
+            const executeOptions = {
                 sqlText,
                 binds,
+                // Pass server-side timeout so Snowflake kills the query at the deadline even
+                // if the client-side cancel doesn't reach the server in time.
+                ...(timeoutMs != null && {
+                    parameters: { STATEMENT_TIMEOUT_IN_SECONDS: Math.ceil(timeoutMs / 1000) },
+                }),
                 complete(err, stmt, rows) {
                     if (err)
-                        return reject(err);
+                        return settle(() => reject(err));
                     const numUpdated = stmt.getNumUpdatedRows();
                     if (numUpdated != null && numUpdated >= 0) {
                         const n = BigInt(numUpdated);
-                        resolve({
-                            rows: (rows ?? []),
-                            numAffectedRows: n,
-                            numChangedRows: n,
-                        });
+                        settle(() => resolve({ rows: (rows ?? []), numAffectedRows: n, numChangedRows: n }));
                     }
                     else {
-                        resolve({ rows: (rows ?? []) });
+                        settle(() => resolve({ rows: (rows ?? []) }));
                     }
                 },
-            });
+            };
+            const statement = this.#conn.execute(executeOptions);
+            if (timeoutMs != null) {
+                timer = setTimeout(() => {
+                    statement.cancel((cancelErr) => {
+                        // Cancel succeeded → Snowflake aborted cleanly, session is usable.
+                        // Cancel failed → session state is unknown, caller should destroy the connection.
+                        settle(() => reject(new SnowflakeQueryTimeoutError(`Query timed out after ${timeoutMs}ms`, cancelErr == null)));
+                    });
+                }, timeoutMs);
+            }
         });
     }
     async *streamQuery(compiledQuery, _chunkSize) {

package/dist/SnowflakeDriver.d.ts

@@ -10,5 +10,6 @@ export declare class SnowflakeDriver implements Driver {
     commitTransaction(conn: SnowflakeConnection): Promise<void>;
     rollbackTransaction(conn: SnowflakeConnection): Promise<void>;
     releaseConnection(conn: SnowflakeConnection): Promise<void>;
+    destroyConnection(conn: SnowflakeConnection): Promise<void>;
     destroy(): Promise<void>;
 }

package/dist/SnowflakeDriver.js

@@ -16,7 +16,8 @@ const DEFAULT_POOL_OPTIONS = {
 class SnowflakeDriver {
     #config;
     #pool = null;
-    #pendingReleases = new Map();
+    // Tracks the underlying SDK connection for each wrapper so we can release or destroy it.
+    #resources = new Map();
     constructor(config) {
         this.#config = config;
     }
@@ -24,15 +25,10 @@ class SnowflakeDriver {
         this.#pool = snowflake_sdk_1.default.createPool(this.#config.connection, { ...DEFAULT_POOL_OPTIONS, ...this.#config.poolOptions });
     }
     async acquireConnection() {
-        return new Promise((resolveAcquire, rejectAcquire) => {
-            this.#pool.use(async (sdkConn) => {
-                const conn = new SnowflakeConnection_js_1.SnowflakeConnection(sdkConn);
-                return new Promise((resolveRelease) => {
-                    this.#pendingReleases.set(conn, resolveRelease);
-                    resolveAcquire(conn);
-                });
-            }).catch(rejectAcquire);
-        });
+        const sdkConn = await this.#pool.acquire();
+        const conn = new SnowflakeConnection_js_1.SnowflakeConnection(sdkConn);
+        this.#resources.set(conn, sdkConn);
+        return conn;
     }
     async beginTransaction(conn) {
         return conn.beginTransaction();
@@ -44,10 +40,17 @@ class SnowflakeDriver {
         return conn.rollbackTransaction();
     }
     async releaseConnection(conn) {
-        const release = this.#pendingReleases.get(conn);
-        if (release) {
-            this.#pendingReleases.delete(conn);
-            release();
+        const sdkConn = this.#resources.get(conn);
+        if (sdkConn) {
+            this.#resources.delete(conn);
+            await this.#pool.release(sdkConn);
+        }
+    }
+    async destroyConnection(conn) {
+        const sdkConn = this.#resources.get(conn);
+        if (sdkConn) {
+            this.#resources.delete(conn);
+            await this.#pool.destroy(sdkConn);
         }
     }
     async destroy() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snowflake-kysely-dialect",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Snowflake dialect for Kysely",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",