@malloydata/db-publisher 0.0.321 → 0.0.322

package/src/publisher_connection.ts

@@ -26,6 +26,7 @@ import type {
   RawAxiosRequestConfig,
 } from './client';
 import {Configuration, ConnectionsApi, ConnectionsTestApi} from './client';
+import {AxiosError} from 'axios';
 
 interface PublisherConnectionOptions {
   connectionUri: string;
@@ -147,33 +148,51 @@ export class PublisherConnection
     _tableKey: string,
     tablePath: string
   ): Promise<TableSourceDef> {
-    const response = await this.connectionsApi.getTable(
-      this.projectName,
-      this.name,
-      tablePath.split('.')[0],
-      tablePath,
-      {
-        headers: PublisherConnection.getAuthHeaders(this.accessToken),
-      }
-    );
-    return JSON.parse(response.data.source as string) as TableSourceDef;
+    let result = {} as TableSourceDef;
+    try {
+      const response = await this.connectionsApi.getTable(
+        this.projectName,
+        this.name,
+        tablePath.split('.')[0],
+        tablePath,
+        {
+          headers: PublisherConnection.getAuthHeaders(this.accessToken),
+        }
+      );
+      result = JSON.parse(response.data.source as string) as TableSourceDef;
+    } catch (error: AxiosError | unknown) {
+      this.extractAndThrowError(
+        error,
+        `Failed to fetch table schema for ${tablePath}`
+      );
+    }
+    return result;
   }
 
   public async fetchSelectSchema(
     sqlRef: SQLSourceRequest
   ): Promise<SQLSourceDef> {
-    const request: PostSqlsourceRequest = {
-      sqlStatement: sqlRef.selectStr,
-    };
-    const response = await this.connectionsApi.postSqlsource(
-      this.projectName,
-      this.name,
-      request,
-      {
-        headers: PublisherConnection.getAuthHeaders(this.accessToken),
-      }
-    );
-    return JSON.parse(response.data.source as string) as SQLSourceDef;
+    let result = {} as SQLSourceDef;
+    try {
+      const request: PostSqlsourceRequest = {
+        sqlStatement: sqlRef.selectStr,
+      };
+      const response = await this.connectionsApi.postSqlsource(
+        this.projectName,
+        this.name,
+        request,
+        {
+          headers: PublisherConnection.getAuthHeaders(this.accessToken),
+        }
+      );
+      result = JSON.parse(response.data.source as string) as SQLSourceDef;
+    } catch (error: AxiosError | unknown) {
+      this.extractAndThrowError(
+        error,
+        'Failed to fetch select schema for SQL query'
+      );
+    }
+    return result;
   }
 
   public async estimateQueryCost(_sqlCommand: string): Promise<QueryRunStats> {
@@ -185,76 +204,112 @@ export class PublisherConnection
     sql: string,
     options: RunSQLOptions = {}
   ): Promise<MalloyQueryData> {
-    // TODO: Add support for abortSignal.
-    options.abortSignal = undefined;
-    const request: PostSqlsourceRequest = {
-      sqlStatement: sql,
-    };
-    const response = await this.connectionsApi.postQuerydata(
-      this.projectName,
-      this.name,
-      request,
-      JSON.stringify(options),
-      {
-        headers: PublisherConnection.getAuthHeaders(this.accessToken),
-      }
-    );
-    return JSON.parse(response.data.data as string) as MalloyQueryData;
+    let result = {} as MalloyQueryData;
+    try {
+      // TODO: Add support for abortSignal.
+      options.abortSignal = undefined;
+      const request: PostSqlsourceRequest = {
+        sqlStatement: sql,
+      };
+      const response = await this.connectionsApi.postQuerydata(
+        this.projectName,
+        this.name,
+        request,
+        JSON.stringify(options),
+        {
+          headers: PublisherConnection.getAuthHeaders(this.accessToken),
+        }
+      );
+      result = JSON.parse(response.data.data as string) as MalloyQueryData;
+    } catch (error: AxiosError | unknown) {
+      this.extractAndThrowError(error, 'Failed to execute SQL query');
+    }
+    return result;
   }
 
   public async *runSQLStream(
     sqlCommand: string,
     options: RunSQLOptions = {}
   ): AsyncIterableIterator<QueryDataRow> {
-    // TODO: Add support for abortSignal.
-    options.abortSignal = undefined;
-    // TODO: Add real streaming support to publisher API.
-    const request: PostSqlsourceRequest = {
-      sqlStatement: sqlCommand,
-    };
-    const response = await this.connectionsApi.postQuerydata(
-      this.projectName,
-      this.name,
-      request,
-      JSON.stringify(options),
-      {
-        headers: PublisherConnection.getAuthHeaders(this.accessToken),
+    try {
+      // TODO: Add support for abortSignal.
+      options.abortSignal = undefined;
+      // TODO: Add real streaming support to publisher API.
+      const request: PostSqlsourceRequest = {
+        sqlStatement: sqlCommand,
+      };
+      const response = await this.connectionsApi.postQuerydata(
+        this.projectName,
+        this.name,
+        request,
+        JSON.stringify(options),
+        {
+          headers: PublisherConnection.getAuthHeaders(this.accessToken),
+        }
+      );
+      const queryData = JSON.parse(
+        response.data.data as string
+      ) as MalloyQueryData;
+      for (const row of queryData.rows) {
+        yield row;
       }
-    );
-    const queryData = JSON.parse(
-      response.data.data as string
-    ) as MalloyQueryData;
-    for (const row of queryData.rows) {
-      yield row;
+    } catch (error: AxiosError | unknown) {
+      this.extractAndThrowError(error, 'Failed to execute streaming SQL query');
+      return;
     }
   }
 
   public async test(): Promise<void> {
-    await this.connectionsTestApi.testConnectionConfiguration(
-      this.connectionData,
-      {
-        headers: PublisherConnection.getAuthHeaders(this.accessToken),
-      }
-    );
+    try {
+      await this.connectionsTestApi.testConnectionConfiguration(
+        this.connectionData,
+        {
+          headers: PublisherConnection.getAuthHeaders(this.accessToken),
+        }
+      );
+    } catch (error: AxiosError | unknown) {
+      this.extractAndThrowError(
+        error,
+        'Failed to test connection configuration'
+      );
+    }
   }
 
   public async manifestTemporaryTable(sqlCommand: string): Promise<string> {
-    const request: PostSqlsourceRequest = {
-      sqlStatement: sqlCommand,
-    };
-    const response = await this.connectionsApi.postTemporarytable(
-      this.projectName,
-      this.name,
-      request,
-      {
-        headers: PublisherConnection.getAuthHeaders(this.accessToken),
-      }
-    );
-    return response.data.table as string;
+    let result = '';
+    try {
+      const request: PostSqlsourceRequest = {
+        sqlStatement: sqlCommand,
+      };
+      const response = await this.connectionsApi.postTemporarytable(
+        this.projectName,
+        this.name,
+        request,
+        {
+          headers: PublisherConnection.getAuthHeaders(this.accessToken),
+        }
+      );
+      result = response.data.table as string;
+    } catch (error: AxiosError | unknown) {
+      this.extractAndThrowError(error, 'Failed to manifest temporary table');
+    }
+    return result;
   }
 
   public async close(): Promise<void> {
     // Can't close the remote connection.
     return;
   }
+
+  private extractAndThrowError(
+    error: AxiosError | unknown,
+    defaultMessage: string
+  ): void {
+    if (error instanceof AxiosError) {
+      const errorMessage =
+        error?.response?.data?.message || error?.message || defaultMessage;
+      throw new Error(errorMessage);
+    }
+    throw error;
+  }
 }

package/tsconfig.json

@@ -5,6 +5,8 @@
     "outDir": "dist",
     "composite": true
   },
+  "include": ["src/**/*"],
+  "exclude": ["scripts", "dist", "node_modules"],
   "references": [
     {
       "path": "../malloy"