Revert error parity changes

Signed-off-by: Cathleen Yan <cathleen.yan@databricks.com>

Author: cathleeny

CHANGELOG.md

@@ -5,10 +5,6 @@
 - Kernel backend (`useKernel: true`): preserve qualified `INTERVAL MONTH` and
   `INTERVAL DAY` parameter types on the SEA wire by using the kernel raw-parameter
   path.
-- Error handling (all backends): `StatusError` now extends `HiveDriverError` (and
-  therefore native `Error`). `instanceof Error` / `instanceof HiveDriverError`
-  catches now match it, SQLSTATE is retained, and server error code `0` is no
-  longer replaced with `-1`. Kernel request-time SQL failures use this same shape.
 - Kernel backend source builds (`useKernel: true`, built from `KERNEL_REV`): `getTypeInfo()` now matches the Thrift backend's canonical 18-column, 20-row type-info result. Customer-facing npm installs require a follow-up bump to a published native package containing this Kernel change. ([databricks-sql-kernel#291](https://github.com/databricks/databricks-sql-kernel/pull/291), PECOBLR-4166)
 - Kernel backend (`useKernel: true`): **Azure Entra (Azure AD) auth is now threaded through the kernel path.** On `authType: 'databricks-oauth'`: **U2M** (no secret) always routes to `OAuthU2m` — the kernel runs one cloud-blind in-house workspace-federated browser flow (it uses the workspace's OIDC-discovered authorize endpoint verbatim), which works against Azure workspaces, so Azure U2M forwards the in-house app (`databricks-sql-connector`) + `sql offline_access` scopes exactly like AWS/GCP, regardless of `useDatabricksOAuthInAzure` (verified E2E against a live Azure workspace). **M2M** (secret): `useDatabricksOAuthInAzure: true` (or non-Azure) → `OAuthM2m` (workspace-OIDC client-credentials); an Azure host with `useDatabricksOAuthInAzure` absent/`false` → the Entra-direct Azure service-principal M2M (`AzureSpM2m`, the Entra SP creds ride `oauthClientId`/`oauthClientSecret`, `azureTenantId` optional and auto-discovered when omitted). On a non-Azure host `useDatabricksOAuthInAzure` is inert. The `AzureSpM2m` path requires a `databricks-sql-kernel` native module that exposes the Azure SP surface — landed on `main` via [databricks-sql-kernel#282](https://github.com/databricks/databricks-sql-kernel/pull/282) (which the pinned `KERNEL_REV` `ef1a6f2` carries; the surface was originally proposed in [#280](https://github.com/databricks/databricks-sql-kernel/pull/280), which never reached `main`); U2M works on any kernel build. (PECOBLR-4141 / PECOBLR-4120)
 

lib/errors/StatusError.ts

@@ -1,44 +1,21 @@
-import HiveDriverError from './HiveDriverError';
+import { TStatus } from '../../thrift/TCLIService_types';
 
-/** Protocol-neutral details for constructing a driver StatusError. */
-export interface StatusErrorOptions {
-  message?: string;
-  code?: number;
-  sqlState?: string;
-  infoMessages?: ReadonlyArray<string>;
-}
-
-/**
- * Legacy shape accepted by the original constructor. Keeping this structural
- * type means existing Thrift call sites remain source-compatible without making
- * StatusError itself depend on generated Thrift types.
- */
-interface LegacyStatusErrorOptions {
-  statusCode?: number;
-  errorMessage?: string;
-  errorCode?: number;
-  sqlState?: string;
-  infoMessages?: ReadonlyArray<string>;
-}
+export default class StatusError implements Error {
+  public name: string;
 
-export default class StatusError extends HiveDriverError {
-  public name = 'Status Error';
+  public message: string;
 
   public code: number;
 
-  public sqlState?: string;
-
-  constructor(options: StatusErrorOptions | LegacyStatusErrorOptions) {
-    const { message, code } = options as StatusErrorOptions;
-    const { errorMessage, errorCode } = options as LegacyStatusErrorOptions;
-    const normalizedMessage = message ?? errorMessage ?? '';
-    super(normalizedMessage);
+  public stack?: string;
 
-    this.code = code ?? errorCode ?? -1;
-    this.sqlState = options.sqlState;
+  constructor(status: TStatus) {
+    this.name = 'Status Error';
+    this.message = status.errorMessage || '';
+    this.code = status.errorCode || -1;
 
-    if (Array.isArray(options.infoMessages)) {
-      this.stack = options.infoMessages.join('\n');
+    if (Array.isArray(status.infoMessages)) {
+      this.stack = status.infoMessages.join('\n');
     }
   }
 }

lib/kernel/KernelErrorMapping.ts

@@ -2,7 +2,6 @@ import HiveDriverError from '../errors/HiveDriverError';
 import AuthenticationError from '../errors/AuthenticationError';
 import OperationStateError, { OperationStateErrorCode } from '../errors/OperationStateError';
 import ParameterError from '../errors/ParameterError';
-import StatusError from '../errors/StatusError';
 
 /**
  * Sentinel prefix the napi binding's `napi_err_from_kernel` puts on
@@ -28,11 +27,6 @@ export interface KernelErrorShape {
   message: string;
   /** Optional SQLSTATE — five-char alphanumeric, when the kernel was able to surface it. */
   sqlstate?: string;
-  /**
-   * Server statement id attached to SQL failures. An empty id means the
-   * ExecuteStatement request itself was rejected before an operation existed.
-   */
-  queryId?: string;
 }
 
 /**
@@ -126,12 +120,10 @@ function defineErrorMetadata<K extends string, V>(error: Error, key: K, value: V
  *   Cancelled                          → OperationStateError(Canceled)
  *   Timeout                            → OperationStateError(Timeout)
  *   InvalidArgument                    → ParameterError
- *   SqlError, empty queryId            → StatusError
- *   SqlError, non-empty/missing queryId→ OperationStateError(Error)
  *   NetworkError, Unavailable,
  *   NotFound, ResourceExhausted,
  *   DataLoss, Internal,
- *   InvalidStatementHandle             → HiveDriverError
+ *   InvalidStatementHandle, SqlError   → HiveDriverError
  *
  * Unknown `code` values (e.g. if the kernel adds a new variant) fall through
  * to HiveDriverError so the driver never silently drops an error. The kernel's
@@ -141,7 +133,7 @@ function defineErrorMetadata<K extends string, V>(error: Error, key: K, value: V
  * class is returned.
  */
 export function mapKernelErrorToJsError(kErr: KernelErrorShape): ErrorWithSqlState {
-  const { code, message, sqlstate, queryId } = kErr;
+  const { code, message, sqlstate } = kErr;
 
   let error: ErrorWithSqlState;
 
@@ -168,22 +160,16 @@ export function mapKernelErrorToJsError(kErr: KernelErrorShape): ErrorWithSqlSta
       break;
 
     case 'SqlError': {
-      if (queryId === '') {
-        // SEA uses an empty statement id when ExecuteStatement rejects the
-        // request before creating an operation. Thrift surfaces that response
-        // through Status.assert(), so use the same StatusError here.
-        error = new StatusError({
-          message,
-          sqlState: sqlstate,
-        });
-      } else {
-        // A non-empty statement id identifies a real operation that reached a
-        // failed terminal state. Missing ids retain this conservative default
-        // for compatibility with older kernels that did not attach queryId.
-        const stateError = new OperationStateError(OperationStateErrorCode.Error);
-        stateError.message = message;
-        error = stateError;
-      }
+      // A server-reported SQL execution failure (kernel `SqlError`, e.g. a
+      // bad query, missing table, divide-by-zero, invalid cast). The Thrift
+      // backend surfaces the same situation as `OperationStateError(Error)`
+      // when the operation reaches ERROR_STATE (see DBSQLOperation), so map
+      // SqlError to the same class for backend parity. OperationStateError
+      // extends HiveDriverError, so existing `instanceof HiveDriverError`
+      // catches are unaffected.
+      const stateError = new OperationStateError(OperationStateErrorCode.Error);
+      stateError.message = message;
+      error = stateError;
       break;
     }
 
@@ -318,14 +304,10 @@ export function decodeNapiKernelError(err: unknown): Error {
   const code = envelope.code as string;
   const msg = envelope.message as string;
   const sqlState = typeof envelope.sqlState === 'string' ? envelope.sqlState : undefined;
-  const queryId = typeof envelope.queryId === 'string' ? envelope.queryId : undefined;
 
-  const jsErr = mapKernelErrorToJsError({ code, message: msg, sqlstate: sqlState, queryId });
+  const jsErr = mapKernelErrorToJsError({ code, message: msg, sqlstate: sqlState });
 
   const meta = buildKernelMetadata(envelope);
-  if (jsErr instanceof StatusError && meta.vendorCode !== undefined) {
-    jsErr.code = meta.vendorCode;
-  }
   // Skip the namespace attachment entirely when no fields validated
   // through — keeps `err.kernelMetadata` absent rather than `{}` for
   // simple envelopes (the common case). Key-count check so new

tests/e2e/kernel/execution-e2e.test.ts

@@ -16,7 +16,6 @@ import { expect } from 'chai';
 import { DBSQLClient, DBSQLParameter, DBSQLParameterType } from '../../../lib';
 import { ConnectionOptions } from '../../../lib/contracts/IDBSQLClient';
 import { InternalConnectionOptions } from '../../../lib/contracts/InternalConnectionOptions';
-import StatusError from '../../../lib/errors/StatusError';
 
 /**
  * kernel-execution end-to-end test.
@@ -172,7 +171,7 @@ describe('kernel execution end-to-end', function e2eSuite() {
     }
   });
 
-  it('binds qualified INTERVAL MONTH and INTERVAL DAY values', async () => {
+  it('preserves INTERVAL MONTH on the SEA wire', async () => {
     const client = new DBSQLClient();
 
     await client.connect({
@@ -183,81 +182,27 @@ describe('kernel execution end-to-end', function e2eSuite() {
     } as ConnectionOptions & InternalConnectionOptions);
 
     const session = await client.openSession({ initialCatalog: 'main' });
-    let monthOperation;
-    let dayOperation;
+    let operation;
+    let caught: unknown;
     try {
-      monthOperation = await session.executeStatement("SELECT ? = INTERVAL '13' MONTH AS matches", {
+      operation = await session.executeStatement('SELECT ?', {
         ordinalParameters: [
           new DBSQLParameter({
             type: DBSQLParameterType.INTERVALMONTH,
-            value: '13',
-          }),
-        ],
-      });
-      expect(await monthOperation.fetchAll()).to.deep.equal([{ matches: true }]);
-      await monthOperation.close();
-      monthOperation = undefined;
-
-      dayOperation = await session.executeStatement("SELECT ? = INTERVAL '3' DAY AS matches", {
-        ordinalParameters: [
-          new DBSQLParameter({
-            type: DBSQLParameterType.INTERVALDAY,
-            value: '3',
+            value: '2-6',
           }),
         ],
       });
-      expect(await dayOperation.fetchAll()).to.deep.equal([{ matches: true }]);
+      await operation.fetchAll();
+    } catch (error) {
+      caught = error;
     } finally {
-      await monthOperation?.close();
-      await dayOperation?.close();
+      await operation?.close();
       await session.close();
       await client.close();
     }
-  });
-
-  it('maps malformed qualified INTERVAL request failures to StatusError', async () => {
-    const client = new DBSQLClient();
-
-    await client.connect({
-      host: hostName as string,
-      path: httpPath as string,
-      token: token as string,
-      useKernel: true,
-    } as ConnectionOptions & InternalConnectionOptions);
-
-    const session = await client.openSession({ initialCatalog: 'main' });
-    const expectCastFailure = async (
-      parameterType: DBSQLParameterType,
-      value: string,
-      targetType: string,
-      expectedWireType: string,
-    ) => {
-      let operation;
-      let caught: unknown;
-      try {
-        operation = await session.executeStatement(`SELECT CAST(? AS ${targetType}) AS value`, {
-          ordinalParameters: [new DBSQLParameter({ type: parameterType, value })],
-        });
-        await operation.fetchAll();
-      } catch (error) {
-        caught = error;
-      } finally {
-        await operation?.close();
-      }
 
-      expect(caught).to.be.instanceOf(StatusError);
-      expect((caught as StatusError).sqlState).to.equal('22023');
-      expect((caught as StatusError).message).to.include(expectedWireType);
-    };
-
-    try {
-      // Each value is valid for the wider CAST target but malformed for the
-      // qualified parameter type sent on the wire.
-      await expectCastFailure(DBSQLParameterType.INTERVALMONTH, '2-6', 'INTERVAL YEAR TO MONTH', 'INTERVAL MONTH');
-      await expectCastFailure(DBSQLParameterType.INTERVALDAY, '3 04:05:06', 'INTERVAL DAY TO SECOND', 'INTERVAL DAY');
-    } finally {
-      await session.close();
-      await client.close();
-    }
+    // "2-6" is valid YEAR TO MONTH syntax, but invalid for INTERVAL MONTH.
+    expect(caught).to.be.instanceOf(Error);
   });
 });

tests/unit/DBSQLSession.test.ts

@@ -5,9 +5,7 @@ import DBSQLSession, { numberToInt64 } from '../../lib/DBSQLSession';
 import InfoValue from '../../lib/dto/InfoValue';
 import Status from '../../lib/dto/Status';
 import DBSQLOperation from '../../lib/DBSQLOperation';
-import StatusError from '../../lib/errors/StatusError';
-import OperationStateError from '../../lib/errors/OperationStateError';
-import { TSessionHandle, TProtocolVersion, TStatusCode } from '../../thrift/TCLIService_types';
+import { TSessionHandle, TProtocolVersion } from '../../thrift/TCLIService_types';
 import ClientContextStub from './.stubs/ClientContextStub';
 import { createSessionForTest } from './.stubs/createSessionForTest';
 
@@ -78,32 +76,6 @@ describe('DBSQLSession', () => {
       expect(result).instanceOf(DBSQLOperation);
     });
 
-    it('should surface an immediate execution failure as a StatusError with SQLSTATE', async () => {
-      const context = new ClientContextStub();
-      context.driver.executeStatementResp = {
-        status: {
-          statusCode: TStatusCode.ERROR_STATUS,
-          sqlState: '22023',
-          errorCode: 123,
-          errorMessage: 'Invalid interval value',
-        },
-      };
-      const session = createSessionForTest({ handle: sessionHandleStub, context });
-
-      let caught: unknown;
-      try {
-        await session.executeStatement('SELECT CAST(? AS INTERVAL YEAR TO MONTH)');
-      } catch (error) {
-        caught = error;
-      }
-
-      expect(caught).to.be.instanceOf(StatusError);
-      expect(caught).to.be.instanceOf(Error);
-      expect(caught).to.not.be.instanceOf(OperationStateError);
-      expect((caught as StatusError).code).to.equal(123);
-      expect((caught as StatusError).sqlState).to.equal('22023');
-    });
-
     describe('Arrow support', () => {
       it('should not use Arrow if disabled in options', async () => {
         const session = createSessionForTest({

tests/unit/dto/Status.test.ts

@@ -1,8 +1,6 @@
 import { expect } from 'chai';
 import { TStatusCode } from '../../../thrift/TCLIService_types';
 import Status from '../../../lib/dto/Status';
-import StatusError from '../../../lib/errors/StatusError';
-import HiveDriverError from '../../../lib/errors/HiveDriverError';
 
 describe('StatusFactory', () => {
   it('should be success', () => {
@@ -74,28 +72,17 @@ describe('StatusFactory', () => {
 
   describe('assert', () => {
     it('should throw exception on error status', () => {
-      let caught: unknown;
-      try {
+      const error = expect(() => {
         Status.assert({
           statusCode: TStatusCode.ERROR_STATUS,
           errorMessage: 'error',
-          errorCode: 0,
-          sqlState: '22023',
+          errorCode: 1,
           infoMessages: ['line1', 'line2'],
         });
-      } catch (error) {
-        caught = error;
-      }
-
-      expect(caught).to.be.instanceOf(StatusError);
-      expect(caught).to.be.instanceOf(HiveDriverError);
-      expect(caught).to.be.instanceOf(Error);
-      const statusError = caught as StatusError;
-      expect(statusError.message).to.equal('error');
-      expect(statusError.stack).to.equal('line1\nline2');
-      expect(statusError.code).to.equal(0);
-      expect(statusError.sqlState).to.equal('22023');
-      expect(statusError.name).to.equal('Status Error');
+      }).to.throw('error');
+      error.with.property('stack', 'line1\nline2');
+      error.with.property('code', 1);
+      error.with.property('name', 'Status Error');
     });
 
     it('should throw exception on invalid handle status', () => {