[SEA-NodeJS] Remove the dead queryTimeout deadline plumbing (kernel field gone)

Follow-on to making queryTimeout a no-op on SEA: now that the kernel's
`query_timeout_secs` field is removed (databricks/databricks-sql-kernel#140) and
SeaSessionBackend no longer passes a timeout, the SeaOperationBackend client-side
deadline is dead code. Remove it:

- `SeaOperationBackend`: drop the `queryTimeoutSecs` option, the `queryTimeoutMs`
  field, and the async poll-loop deadline enforcement (the
  `OperationStateError(Timeout)` + best-effort-cancel branch).
- Regenerated napi `.d.ts`: `ExecuteOptions` no longer carries `queryTimeoutSecs`.
- Tests: remove the obsolete client-side-deadline test; drop the `queryTimeoutSecs`
  args from the `makeAsyncOp` / `makeSyncOp` helpers.
- Comment cleanups in SeaNativeLoader.

queryTimeout remains a no-op on SEA (SQL Warehouses use STATEMENT_TIMEOUT). SEA
unit suite 261 passing; eslint clean; e2e directResults (CREATE/close/cancel)
unaffected.

Co-authored-by: Isaac
Signed-off-by: Madhavendra Rathore <madhavendra.rathore@databricks.com>

Author: msrathore-db

lib/sea/SeaNativeLoader.ts

@@ -56,7 +56,7 @@ export type SeaStatement = NativeStatement;
 // Per-statement execution options and bound-parameter inputs are kernel
 // concerns: the napi binding generates the canonical shapes (`positionalParams`
 // / `namedParams` as `TypedValueInput` / `NamedTypedValueInput`, plus
-// `rowLimit`, `queryTimeoutSecs`, `statementConf`, `queryTags`). We re-export
+// `rowLimit`, `statementConf`, `queryTags`). We re-export
 // rather than re-declare so the driver-side param codec can never drift from
 // the kernel contract.
 export type SeaNativeExecuteOptions = NativeExecuteOptions;

lib/sea/SeaOperationBackend.ts

@@ -140,15 +140,6 @@ export interface SeaOperationBackendOptions {
    * handle exposes one, else a fresh UUIDv4.
    */
   id?: string;
-  /**
-   * Client-side query timeout in whole seconds (the public `queryTimeout`).
-   * The kernel ignores `queryTimeoutSecs` on the async submit path
-   * (`submitStatement` always sends `wait_timeout=0s`), so the JS poll loop
-   * enforces it as a deadline — on expiry it best-effort cancels the statement
-   * and throws `OperationStateError(Timeout)`, matching the Thrift path's
-   * server-side TIMEDOUT outcome. Omitted ⇒ no client-side deadline.
-   */
-  queryTimeoutSecs?: number;
 }
 
 export default class SeaOperationBackend implements IOperationBackend {
@@ -190,17 +181,12 @@ export default class SeaOperationBackend implements IOperationBackend {
   // already-terminal statement. Drives both fetch and result-metadata.
   private fetchHandlePromise?: Promise<SeaFetchHandle>;
 
-  // Client-side query-timeout deadline in ms (the public `queryTimeout`),
-  // undefined when unset. Enforced in the async poll loop.
-  private readonly queryTimeoutMs?: number;
-
   constructor({
     asyncStatement,
     statement,
     cancellableExecution,
     context,
     id,
-    queryTimeoutSecs,
   }: SeaOperationBackendOptions) {
     // Exactly one of the three handle kinds must be supplied.
     const providedCount =
@@ -232,7 +218,6 @@ export default class SeaOperationBackend implements IOperationBackend {
     this.context = context;
     this._id =
       id ?? asyncStatement?.statementId ?? statement?.statementId ?? cancellableExecution?.statementId ?? uuidv4();
-    this.queryTimeoutMs = queryTimeoutSecs !== undefined && queryTimeoutSecs > 0 ? queryTimeoutSecs * 1000 : undefined;
   }
 
   public get id(): string {
@@ -441,9 +426,6 @@ export default class SeaOperationBackend implements IOperationBackend {
     if (this.fetchHandlePromise) {
       return;
     }
-    // Client-side timeout deadline: the kernel ignores queryTimeoutSecs on the
-    // async submit path, so we enforce the public `queryTimeout` here.
-    const deadline = this.queryTimeoutMs !== undefined ? Date.now() + this.queryTimeoutMs : undefined;
     for (;;) {
       // A JS-initiated cancel/close short-circuits before the next poll.
       failIfNotActive(this.lifecycle);
@@ -494,30 +476,8 @@ export default class SeaOperationBackend implements IOperationBackend {
           throw new OperationStateError(OperationStateErrorCode.Unknown);
       }
 
-      // Still Pending/Running — enforce the client-side timeout before sleeping.
-      if (deadline !== undefined && Date.now() >= deadline) {
-        // Best-effort server-side cancel so the statement doesn't keep running
-        // after we stop waiting; never mask the timeout with a cancel failure,
-        // but warn-log a failed cancel so a still-running server statement is
-        // diagnosable (mirrors the fetch-error cleanup path).
-        // eslint-disable-next-line no-await-in-loop
-        await this.cancel().catch((cancelErr) => {
-          const cause = cancelErr instanceof Error ? cancelErr.message : String(cancelErr);
-          this.context
-            .getLogger()
-            .log(
-              LogLevel.warn,
-              `SEA query-timeout cleanup: cancel() failed for operation ${this._id}; the server-side ` +
-                `statement may keep running until the session is closed. Cause: ${cause}`,
-            );
-        });
-        // Release the statement handle too (cancel stops the work; close frees
-        // the handle) — best-effort, mirroring the other terminal branches.
-        // eslint-disable-next-line no-await-in-loop
-        await this.bestEffortClose();
-        throw new OperationStateError(OperationStateErrorCode.Timeout);
-      }
-
+      // Still Pending/Running — sleep before the next poll. (There is no
+      // client-side query-timeout deadline: `queryTimeout` is a no-op on SEA.)
       // eslint-disable-next-line no-await-in-loop
       await delay(STATUS_POLL_INTERVAL_MS);
     }
@@ -526,7 +486,7 @@ export default class SeaOperationBackend implements IOperationBackend {
   /**
    * Sync (`runAsync: false`) execute path. Drives the blocking
    * `CancellableExecution.result()` to a terminal `Statement` (the kernel polls
-   * to completion server-side, honouring `queryTimeoutSecs` on this path). The
+   * to completion server-side). The
    * await is interruptible: a JS-initiated `cancel()` fires the detached
    * canceller, the server flips the statement terminal, and the parked
    * `result()` rejects with `Cancelled` — which we map to the typed

native/sea/index.d.ts

@@ -909,9 +909,9 @@ describe('SeaOperationBackend', () => {
 });
 
 describe('SeaOperationBackend — async (submitStatement) path', () => {
-  const makeAsyncOp = (asyncStatement: FakeAsyncStatement, queryTimeoutSecs?: number) =>
+  const makeAsyncOp = (asyncStatement: FakeAsyncStatement) =>
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    new SeaOperationBackend({ asyncStatement: asyncStatement as any, context: makeContext(), queryTimeoutSecs });
+    new SeaOperationBackend({ asyncStatement: asyncStatement as any, context: makeContext() });
 
   it('rejects when neither asyncStatement nor statement is provided', () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1011,22 +1011,6 @@ describe('SeaOperationBackend — async (submitStatement) path', () => {
     expect((thrown as OperationStateError).errorCode).to.equal(OperationStateErrorCode.Closed);
   });
 
-  it('waitUntilReady() enforces queryTimeout client-side: throws Timeout and cancels a stuck Running statement', async function timeoutTest() {
-    // eslint-disable-next-line no-invalid-this
-    this.timeout(5000);
-    const stmt = new FakeAsyncStatement('Running'); // never reaches a terminal state
-    const op = makeAsyncOp(stmt, 0.05); // 50ms client-side deadline
-    let thrown: unknown;
-    try {
-      await op.waitUntilReady();
-    } catch (err) {
-      thrown = err;
-    }
-    expect(thrown).to.be.instanceOf(OperationStateError);
-    expect((thrown as OperationStateError).errorCode).to.equal(OperationStateErrorCode.Timeout);
-    // Best-effort server-side cancel fired so the statement doesn't keep running.
-    expect(stmt.cancelled).to.equal(true);
-  });
 
   it('cancel() forwards to the async statement and short-circuits a subsequent poll', async () => {
     const stmt = new FakeAsyncStatement(['Running', 'Running', 'Succeeded']);
@@ -1052,12 +1036,11 @@ describe('SeaOperationBackend — async (submitStatement) path', () => {
 });
 
 describe('SeaOperationBackend — sync (executeStatementCancellable) path', () => {
-  const makeSyncOp = (cancellableExecution: FakeCancellableExecution, queryTimeoutSecs?: number) =>
+  const makeSyncOp = (cancellableExecution: FakeCancellableExecution) =>
     new SeaOperationBackend({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       cancellableExecution: cancellableExecution as any,
       context: makeContext(),
-      queryTimeoutSecs,
     });
 
   it('rejects when more than one handle kind is provided', () => {