[SEA-NodeJS] surface server statement_id as op.id on the sync path

On the sync (cancellable) execute path the operation id was a client UUID,
because the server statement_id isn't known at construction — the kernel
publishes it mid-`result()` once the initial execute round-trip returns. That
left a cancelled/closed sync op untraceable against server/kernel logs (the
async path already had the id from `submit`).

`id` now prefers the server statement_id once known (captured from the resolved
`Statement`, then the live canceller slot), falling back to the construction-time
UUID until then. Updated the fake to model the real null-until-resolved
`statementId` and assert op.id flips from UUID → server id after the execute
completes. Validated live: SELECT 1 op.id is a UUID before fetch and the real
`01f1…` statement id after.

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

Author: msrathore-db

lib/sea/SeaOperationBackend.ts

@@ -157,6 +157,10 @@ export default class SeaOperationBackend implements IOperationBackend {
   // Undefined on the async / metadata paths.
   private readonly cancellableExecution?: SeaNativeCancellableExecution;
 
+  // Sync path: the server statement id captured from the resolved `Statement`
+  // once `result()` settles. Undefined until then; surfaced via `id`.
+  private resolvedStatementId?: string;
+
   // Metadata path: terminal statement. Also the resolved fetch handle on the
   // sync-execute path once `cancellableExecution.result()` settles.
   private blockingStatement?: SeaOperationStatement;
@@ -231,7 +235,14 @@ export default class SeaOperationBackend implements IOperationBackend {
   }
 
   public get id(): string {
-    return this._id;
+    // On the sync (cancellable) path the server statement id isn't known at
+    // construction — it's published mid-`result()` once the initial execute
+    // round-trip returns. Surface it once available (preferring the id captured
+    // from the resolved `Statement`, then the live canceller slot) so a
+    // cancelled/closed sync operation is traceable by the same id the server and
+    // kernel logs key on, matching the async path (which has it from `submit`).
+    // Falls back to the construction-time id (a client UUID) until then.
+    return this.resolvedStatementId ?? this.cancellableExecution?.statementId ?? this._id;
   }
 
   public hasResultSet(): boolean {
@@ -544,6 +555,9 @@ export default class SeaOperationBackend implements IOperationBackend {
           .result()
           .then((stmt) => {
             this.blockingStatement = stmt as unknown as SeaOperationStatement;
+            // Capture the now-known server statement id (stable on the resolved
+            // Statement) so `id` reports it for the rest of the lifecycle.
+            this.resolvedStatementId = this.blockingStatement.statementId ?? this.resolvedStatementId;
             return stmt as unknown as SeaFetchHandle;
           })
           .catch((err) => {

tests/unit/sea/execution.test.ts

@@ -137,7 +137,10 @@ class FakeCancellableExecution {
 
   public resultError: Error | null = null;
 
-  public readonly statementId = '01ef-fake-sync-id';
+  // Mirrors the real `CancellableExecution.statementId`: `null` until the
+  // initial execute round-trip publishes the server id mid-`result()`. The
+  // resolved `Statement` (resultHandle) carries the id (`FakeNativeStatement`).
+  public readonly statementId: string | null = null;
 
   // When set, the result() promise stays pending until cancel() rejects it,
   // modelling a still-running blocking execute that a concurrent cancel aborts.
@@ -991,9 +994,18 @@ describe('SeaOperationBackend — sync (executeStatementCancellable) path', () =
     ).to.throw(HiveDriverError, /exactly one/);
   });
 
-  it('id defaults to the cancellable execution statement id', () => {
+  it('surfaces the resolved server statement id as op.id once the sync execute completes', async () => {
     const op = makeSyncOp(new FakeCancellableExecution());
-    expect(op.id).to.equal('01ef-fake-sync-id');
+    // Before result() resolves, the server id is not yet known (real
+    // `CancellableExecution.statementId` is null pre-round-trip), so op.id is the
+    // construction-time fallback — a client UUID, NOT the server statement id.
+    const idBefore = op.id;
+    expect(idBefore).to.be.a('string').and.have.length.greaterThan(0);
+    expect(idBefore).to.not.equal('01ef-fake-statement-id');
+    // Driving the blocking execute to terminal publishes the server id; op.id
+    // then reports it (parity with the async path, traceable in server logs).
+    await op.waitUntilReady();
+    expect(op.id).to.equal('01ef-fake-statement-id');
   });
 
   it('status() reports Running before result() and Succeeded after', async () => {