[REFACTORING] Convert Promise-based methods to async/await (#132)

kravets-levko · web-flow · commit d9c9ce594ac4 · 2023-04-06T09:50:48.000+03:00
* Convert DBSQLClient methods to use async/await syntax; add some access modifiers

Signed-off-by: Levko Kravets &lt;levko.ne@gmail.com&gt;

* Convert DBSQLSession methods to use async/await syntax; add some access modifiers

Signed-off-by: Levko Kravets &lt;levko.ne@gmail.com&gt;

* Convert DBSQLOperation methods to use async/await syntax; add some access modifiers

Signed-off-by: Levko Kravets &lt;levko.ne@gmail.com&gt;

* Add some more access modifiers

Signed-off-by: Levko Kravets &lt;levko.ne@gmail.com&gt;

---------

Signed-off-by: Levko Kravets &lt;levko.ne@gmail.com&gt;
diff --git a/lib/DBSQLClient.ts b/lib/DBSQLClient.ts
@@ -46,15 +46,15 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient {
 
   private connection: IThriftConnection | null;
 
-  private statusFactory: StatusFactory;
+  private readonly statusFactory: StatusFactory;
 
   private connectionProvider: IConnectionProvider;
 
   private authProvider: IAuthentication;
 
-  private logger: IDBSQLLogger;
+  private readonly logger: IDBSQLLogger;
 
-  private thrift = thrift;
+  private readonly thrift = thrift;
 
   constructor(options?: ClientOptions) {
     super();
@@ -89,7 +89,7 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient {
    * @example
    * const session = client.connect({host, path, token});
    */
-  async connect(options: ConnectionOptions, authProvider?: IAuthentication): Promise<IDBSQLClient> {
+  public async connect(options: ConnectionOptions, authProvider?: IAuthentication): Promise<IDBSQLClient> {
     this.authProvider =
       authProvider ||
       new PlainHttpAuthentication({
@@ -143,43 +143,39 @@ export default class DBSQLClient extends EventEmitter implements IDBSQLClient {
    * @example
    * const session = await client.openSession();
    */
-  openSession(request: OpenSessionRequest = {}): Promise<IDBSQLSession> {
+  public async openSession(request: OpenSessionRequest = {}): Promise<IDBSQLSession> {
     if (!this.connection?.isConnected()) {
-      return Promise.reject(new HiveDriverError('DBSQLClient: connection is lost'));
+      throw new HiveDriverError('DBSQLClient: connection is lost');
     }
 
     const driver = new HiveDriver(this.getClient());
 
-    return driver
-      .openSession({
-        client_protocol_i64: new Int64(TProtocolVersion.SPARK_CLI_SERVICE_PROTOCOL_V6),
-        ...getInitialNamespaceOptions(request.initialCatalog, request.initialSchema),
-      })
-      .then((response) => {
-        this.statusFactory.create(response.status);
-        return new DBSQLSession(driver, definedOrError(response.sessionHandle), this.logger);
-      });
+    const response = await driver.openSession({
+      client_protocol_i64: new Int64(TProtocolVersion.SPARK_CLI_SERVICE_PROTOCOL_V6),
+      ...getInitialNamespaceOptions(request.initialCatalog, request.initialSchema),
+    });
+
+    this.statusFactory.create(response.status);
+    return new DBSQLSession(driver, definedOrError(response.sessionHandle), this.logger);
   }
 
-  getClient() {
+  public getClient() {
     if (!this.client) {
       throw new HiveDriverError('DBSQLClient: client is not initialized');
     }
 
     return this.client;
   }
 
-  close(): Promise<void> {
-    if (!this.connection) {
-      return Promise.resolve();
-    }
+  public async close(): Promise<void> {
+    if (this.connection) {
+      const thriftConnection = this.connection.getConnection();
 
-    const thriftConnection = this.connection.getConnection();
+      if (typeof thriftConnection.end === 'function') {
+        this.connection.getConnection().end();
+      }
 
-    if (typeof thriftConnection.end === 'function') {
-      this.connection.getConnection().end();
+      this.connection = null;
     }
-
-    return Promise.resolve();
   }
 }
diff --git a/lib/DBSQLOperation/CompleteOperationHelper.ts b/lib/DBSQLOperation/CompleteOperationHelper.ts
@@ -4,15 +4,15 @@ import StatusFactory from '../factory/StatusFactory';
 import Status from '../dto/Status';
 
 export default class CompleteOperationHelper {
-  private driver: HiveDriver;
+  private readonly driver: HiveDriver;
 
-  private operationHandle: TOperationHandle;
+  private readonly operationHandle: TOperationHandle;
 
-  private statusFactory = new StatusFactory();
+  private readonly statusFactory = new StatusFactory();
 
-  closed: boolean = false;
+  public closed: boolean = false;
 
-  cancelled: boolean = false;
+  public cancelled: boolean = false;
 
   constructor(driver: HiveDriver, operationHandle: TOperationHandle, closeOperation?: TCloseOperationResp) {
     this.driver = driver;
@@ -24,7 +24,7 @@ export default class CompleteOperationHelper {
     }
   }
 
-  async cancel(): Promise<Status> {
+  public async cancel(): Promise<Status> {
     if (this.cancelled) {
       return this.statusFactory.create({
         statusCode: TStatusCode.SUCCESS_STATUS,
@@ -39,7 +39,7 @@ export default class CompleteOperationHelper {
     return status;
   }
 
-  async close(): Promise<Status> {
+  public async close(): Promise<Status> {
     if (this.closed) {
       return this.statusFactory.create({
         statusCode: TStatusCode.SUCCESS_STATUS,
diff --git a/lib/DBSQLOperation/FetchResultsHelper.ts b/lib/DBSQLOperation/FetchResultsHelper.ts
@@ -37,17 +37,17 @@ function checkIfOperationHasMoreRows(response: TFetchResultsResp): boolean {
 }
 
 export default class FetchResultsHelper {
-  private driver: HiveDriver;
+  private readonly driver: HiveDriver;
 
-  private operationHandle: TOperationHandle;
+  private readonly operationHandle: TOperationHandle;
 
   private fetchOrientation: TFetchOrientation = TFetchOrientation.FETCH_FIRST;
 
-  private statusFactory = new StatusFactory();
+  private readonly statusFactory = new StatusFactory();
 
   private prefetchedResults: TFetchResultsResp[] = [];
 
-  hasMoreRows: boolean = false;
+  public hasMoreRows: boolean = false;
 
   constructor(
     driver: HiveDriver,
@@ -74,18 +74,19 @@ export default class FetchResultsHelper {
     return response.results;
   }
 
-  async fetch(maxRows: number) {
+  public async fetch(maxRows: number) {
     const prefetchedResponse = this.prefetchedResults.shift();
     if (prefetchedResponse) {
       return this.processFetchResponse(prefetchedResponse);
     }
-    return this.driver
-      .fetchResults({
-        operationHandle: this.operationHandle,
-        orientation: this.fetchOrientation,
-        maxRows: new Int64(maxRows),
-        fetchType: FetchType.Data,
-      })
-      .then((response) => this.processFetchResponse(response));
+
+    const response = await this.driver.fetchResults({
+      operationHandle: this.operationHandle,
+      orientation: this.fetchOrientation,
+      maxRows: new Int64(maxRows),
+      fetchType: FetchType.Data,
+    });
+
+    return this.processFetchResponse(response);
   }
 }
diff --git a/lib/DBSQLOperation/OperationStatusHelper.ts b/lib/DBSQLOperation/OperationStatusHelper.ts
@@ -13,19 +13,19 @@ async function delay(ms?: number): Promise<void> {
 }
 
 export default class OperationStatusHelper {
-  private driver: HiveDriver;
+  private readonly driver: HiveDriver;
 
-  private operationHandle: TOperationHandle;
+  private readonly operationHandle: TOperationHandle;
 
-  private statusFactory = new StatusFactory();
+  private readonly statusFactory = new StatusFactory();
 
   private state: number = TOperationState.INITIALIZED_STATE;
 
   // Once operation is finished or fails - cache status response, because subsequent calls
   // to `getOperationStatus()` may fail with irrelevant errors, e.g. HTTP 404
   private operationStatus?: TGetOperationStatusResp;
 
-  hasResultSet: boolean = false;
+  public hasResultSet: boolean = false;
 
   constructor(driver: HiveDriver, operationHandle: TOperationHandle, operationStatus?: TGetOperationStatusResp) {
     this.driver = driver;
@@ -64,16 +64,17 @@ export default class OperationStatusHelper {
     return response;
   }
 
-  status(progress: boolean) {
+  public async status(progress: boolean): Promise<TGetOperationStatusResp> {
     if (this.operationStatus) {
-      return Promise.resolve(this.operationStatus);
+      return this.operationStatus;
     }
-    return this.driver
-      .getOperationStatus({
-        operationHandle: this.operationHandle,
-        getProgressUpdate: progress,
-      })
-      .then((response) => this.processOperationStatusResponse(response));
+
+    const response = await this.driver.getOperationStatus({
+      operationHandle: this.operationHandle,
+      getProgressUpdate: progress,
+    });
+
+    return this.processOperationStatusResponse(response);
   }
 
   private async isReady(options?: WaitUntilReadyOptions): Promise<boolean> {
@@ -106,7 +107,7 @@ export default class OperationStatusHelper {
     }
   }
 
-  async waitUntilReady(options?: WaitUntilReadyOptions): Promise<void> {
+  public async waitUntilReady(options?: WaitUntilReadyOptions): Promise<void> {
     if (this.state === TOperationState.FINISHED_STATE) {
       return;
     }
diff --git a/lib/DBSQLOperation/SchemaHelper.ts b/lib/DBSQLOperation/SchemaHelper.ts
@@ -8,11 +8,11 @@ import HiveDriverError from '../errors/HiveDriverError';
 import { definedOrError } from '../utils';
 
 export default class SchemaHelper {
-  private driver: HiveDriver;
+  private readonly driver: HiveDriver;
 
-  private operationHandle: TOperationHandle;
+  private readonly operationHandle: TOperationHandle;
 
-  private statusFactory = new StatusFactory();
+  private readonly statusFactory = new StatusFactory();
 
   private metadata?: TGetResultSetMetadataResp;
 
@@ -34,12 +34,12 @@ export default class SchemaHelper {
     return this.metadata;
   }
 
-  async fetch() {
+  public async fetch() {
     const metadata = await this.fetchMetadata();
     return definedOrError(metadata.schema);
   }
 
-  async getResultHandler(): Promise<IOperationResult> {
+  public async getResultHandler(): Promise<IOperationResult> {
     const metadata = await this.fetchMetadata();
     const resultFormat = definedOrError(metadata.resultFormat);
 
diff --git a/lib/DBSQLOperation/index.ts b/lib/DBSQLOperation/index.ts
diff --git a/lib/DBSQLSession.ts b/lib/DBSQLSession.ts
