snowflake-kysely-dialect 0.1.1 → 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/package.json

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