@malloy-publisher/server 0.0.132 → 0.0.134

package/dist/server.js

@@ -131914,6 +131914,8 @@ function validateAndBuildTrinoConfig(trinoConfig) {
       }
     };
     delete baseConfig.password;
+    delete baseConfig.catalog;
+    delete baseConfig.schema;
   } else if (trinoConfig.server?.startsWith("https://") && trinoConfig.password) {
     baseConfig.password = trinoConfig.password;
   }
@@ -132541,7 +132543,35 @@ async function getSchemasForConnection(connection, malloyConnection) {
       throw new Error("Trino connection is required");
     }
     try {
-      const result = await malloyConnection.runSQL(`SHOW SCHEMAS FROM ${connection.trinoConnection.catalog}`);
+      let result;
+      if (connection.trinoConnection.catalog) {
+        result = await malloyConnection.runSQL(`SHOW SCHEMAS FROM ${connection.trinoConnection.catalog}`);
+      } else {
+        const catalogs = await malloyConnection.runSQL(`SHOW CATALOGS`);
+        console.log("catalogs", catalogs);
+        let catalogNames = standardizeRunSQLResult(catalogs);
+        catalogNames = catalogNames.map((catalog) => {
+          const typedCatalog = catalog;
+          return typedCatalog.Catalog;
+        });
+        const schemas = [];
+        console.log("catalogNames", catalogNames);
+        for (const catalog of catalogNames) {
+          const schemasResult = await malloyConnection.runSQL(`SHOW SCHEMAS FROM ${catalog}`);
+          const schemasResultRows = standardizeRunSQLResult(schemasResult);
+          console.log("schemasResultRows", schemasResultRows);
+          const schemasWithCatalog = schemasResultRows.map((row) => {
+            const typedRow = row;
+            return {
+              ...typedRow,
+              Schema: `${catalog}.${typedRow.Schema ?? typedRow.schema ?? ""}`
+            };
+          });
+          schemas.push(...schemasWithCatalog);
+          console.log("schemas", schemas);
+        }
+        result = schemas;
+      }
       const rows = standardizeRunSQLResult(result);
       return rows.map((row) => {
         const typedRow = row;
@@ -132618,7 +132648,11 @@ async function getTablesForSchema(connection, schemaName, malloyConnection) {
     try {
       let tablePath;
       if (connection.type === "trino") {
-        tablePath = `${connection.trinoConnection?.catalog}.${schemaName}.${tableName}`;
+        if (connection.trinoConnection?.catalog) {
+          tablePath = `${connection.trinoConnection?.catalog}.${schemaName}.${tableName}`;
+        } else {
+          tablePath = `${schemaName}.${tableName}`;
+        }
       } else {
         tablePath = `${schemaName}.${tableName}`;
       }
@@ -132651,15 +132685,20 @@ async function getConnectionTableSource(malloyConnection, tableKey, tablePath) {
     });
     const source = await malloyConnection.fetchTableSchema(tableKey, tablePath);
     if (source === undefined) {
-      throw new ConnectionError(`Table ${tablePath} not found`);
+      throw new ConnectionError(`Table ${tablePath} not found: ${JSON.stringify(source)}`);
     }
-    if (!source || typeof source !== "object") {
+    if (!source) {
       throw new ConnectionError(`Invalid table source returned for ${tablePath}`);
+    } else if (typeof source !== "object") {
+      throw new ConnectionError(JSON.stringify(source));
     }
     const malloyFields = source.fields;
     if (!malloyFields || !Array.isArray(malloyFields)) {
       throw new ConnectionError(`Table ${tablePath} has no fields or invalid field structure`);
     }
+    if (malloyFields.length === 0) {
+      throw new ConnectionError(`Table ${tablePath} not found`);
+    }
     const fields = malloyFields.map((field) => {
       return {
         name: field.name,
@@ -132675,8 +132714,13 @@ async function getConnectionTableSource(malloyConnection, tableKey, tablePath) {
       columns: fields
     };
   } catch (error) {
-    logger2.error("fetchTableSchema error", { error, tableKey, tablePath });
-    throw new ConnectionError(error.message);
+    const errorMessage = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error);
+    logger2.error("fetchTableSchema error", {
+      error,
+      tableKey,
+      tablePath
+    });
+    throw new ConnectionError(errorMessage);
   }
 }
 async function listTablesForSchema(connection, schemaName, malloyConnection) {
@@ -132737,7 +132781,12 @@ async function listTablesForSchema(connection, schemaName, malloyConnection) {
       throw new Error("Trino connection is required");
     }
     try {
-      const result = await malloyConnection.runSQL(`SHOW TABLES FROM ${connection.trinoConnection.catalog}.${schemaName}`);
+      let result;
+      if (connection.trinoConnection?.catalog) {
+        result = await malloyConnection.runSQL(`SHOW TABLES FROM ${connection.trinoConnection.catalog}.${schemaName}`);
+      } else {
+        result = await malloyConnection.runSQL(`SHOW TABLES FROM ${schemaName}`);
+      }
       const rows = standardizeRunSQLResult(result);
       return rows.map((row) => {
         const typedRow = row;
@@ -139063,7 +139112,34 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     const rowLimit = (await runnable.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
     const endTime = performance.now();
     const executionTime = endTime - startTime;
-    const queryResults = await runnable.run({ rowLimit });
+    let queryResults;
+    try {
+      queryResults = await runnable.run({ rowLimit });
+    } catch (error) {
+      const errorEndTime = performance.now();
+      const errorExecutionTime = errorEndTime - startTime;
+      this.queryExecutionHistogram.record(errorExecutionTime, {
+        "malloy.model.path": this.modelPath,
+        "malloy.model.query.name": queryName,
+        "malloy.model.query.source": sourceName,
+        "malloy.model.query.query": query,
+        "malloy.model.query.status": "error"
+      });
+      if (error instanceof import_malloy2.MalloyError) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger2.error("Query execution error", {
+        error,
+        errorMessage,
+        projectName: this.packageName,
+        modelPath: this.modelPath,
+        query,
+        queryName,
+        sourceName
+      });
+      throw new BadRequestError(`Query execution failed: ${errorMessage}`);
+    }
     this.queryExecutionHistogram.record(executionTime, {
       "malloy.model.path": this.modelPath,
       "malloy.model.query.name": queryName,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@malloy-publisher/server",
   "description": "Malloy Publisher Server",
-  "version": "0.0.132",
+  "version": "0.0.134",
   "main": "dist/server.js",
   "bin": {
     "malloy-publisher": "dist/server.js"

package/src/service/connection.ts

@@ -61,6 +61,8 @@ function validateAndBuildTrinoConfig(
          },
       };
       delete baseConfig.password;
+      delete baseConfig.catalog;
+      delete baseConfig.schema;
    } else if (
       trinoConfig.server?.startsWith("https://") &&
       trinoConfig.password

package/src/service/db_utils.ts

@@ -188,10 +188,47 @@ export async function getSchemasForConnection(
          throw new Error("Trino connection is required");
       }
       try {
+         let result: unknown;
          // Use the connection's runSQL method to query schemas
-         const result = await malloyConnection.runSQL(
-            `SHOW SCHEMAS FROM ${connection.trinoConnection.catalog}`,
-         );
+         if (connection.trinoConnection.catalog) {
+            result = await malloyConnection.runSQL(
+               `SHOW SCHEMAS FROM ${connection.trinoConnection.catalog}`,
+            );
+         } else {
+            const catalogs = await malloyConnection.runSQL(`SHOW CATALOGS`);
+            console.log("catalogs", catalogs);
+            let catalogNames = standardizeRunSQLResult(catalogs);
+            catalogNames = catalogNames.map((catalog: unknown) => {
+               const typedCatalog = catalog as Record<string, unknown>;
+               return typedCatalog.Catalog as string;
+            });
+
+            const schemas: unknown[] = [];
+
+            console.log("catalogNames", catalogNames);
+            for (const catalog of catalogNames) {
+               const schemasResult = await malloyConnection.runSQL(
+                  `SHOW SCHEMAS FROM ${catalog}`,
+               );
+               const schemasResultRows = standardizeRunSQLResult(schemasResult);
+               console.log("schemasResultRows", schemasResultRows);
+
+               // Concat catalog name to schema name for each schema row
+               const schemasWithCatalog = schemasResultRows.map(
+                  (row: unknown) => {
+                     const typedRow = row as Record<string, unknown>;
+                     // For display, use the convention "catalog.schema"
+                     return {
+                        ...typedRow,
+                        Schema: `${catalog}.${typedRow.Schema ?? typedRow.schema ?? ""}`,
+                     };
+                  },
+               );
+               schemas.push(...schemasWithCatalog);
+               console.log("schemas", schemas);
+            }
+            result = schemas;
+         }
 
          const rows = standardizeRunSQLResult(result);
          return rows.map((row: unknown) => {
@@ -316,7 +353,12 @@ export async function getTablesForSchema(
          let tablePath: string;
 
          if (connection.type === "trino") {
-            tablePath = `${connection.trinoConnection?.catalog}.${schemaName}.${tableName}`;
+            if (connection.trinoConnection?.catalog) {
+               tablePath = `${connection.trinoConnection?.catalog}.${schemaName}.${tableName}`;
+            } else {
+               // Catalog name is included in the schema name
+               tablePath = `${schemaName}.${tableName}`;
+            }
          } else {
             tablePath = `${schemaName}.${tableName}`;
          }
@@ -374,14 +416,18 @@ export async function getConnectionTableSource(
          }
       ).fetchTableSchema(tableKey, tablePath);
       if (source === undefined) {
-         throw new ConnectionError(`Table ${tablePath} not found`);
+         throw new ConnectionError(
+            `Table ${tablePath} not found: ${JSON.stringify(source)}`,
+         );
       }
 
       // Validate that source has the expected structure
-      if (!source || typeof source !== "object") {
+      if (!source) {
          throw new ConnectionError(
             `Invalid table source returned for ${tablePath}`,
          );
+      } else if (typeof source !== "object") {
+         throw new ConnectionError(JSON.stringify(source));
       }
 
       const malloyFields = (source as TableSourceDef).fields;
@@ -391,6 +437,13 @@ export async function getConnectionTableSource(
          );
       }
 
+      //This is for the Trino connection. The connection will not throw an error if the table is not found.
+      // Instead it will return an empty fields array. So we need to check for that.
+      // But it is fine to have it for all other connections as well.
+      if (malloyFields.length === 0) {
+         throw new ConnectionError(`Table ${tablePath} not found`);
+      }
+
       const fields = malloyFields.map((field) => {
          return {
             name: field.name,
@@ -406,8 +459,18 @@ export async function getConnectionTableSource(
          columns: fields,
       };
    } catch (error) {
-      logger.error("fetchTableSchema error", { error, tableKey, tablePath });
-      throw new ConnectionError((error as Error).message);
+      const errorMessage =
+         error instanceof Error
+            ? error.message
+            : typeof error === "string"
+              ? error
+              : JSON.stringify(error);
+      logger.error("fetchTableSchema error", {
+         error,
+         tableKey,
+         tablePath,
+      });
+      throw new ConnectionError(errorMessage);
    }
 }
 
@@ -505,9 +568,18 @@ export async function listTablesForSchema(
          throw new Error("Trino connection is required");
       }
       try {
-         const result = await malloyConnection.runSQL(
-            `SHOW TABLES FROM ${connection.trinoConnection.catalog}.${schemaName}`,
-         );
+         let result: unknown;
+
+         if (connection.trinoConnection?.catalog) {
+            result = await malloyConnection.runSQL(
+               `SHOW TABLES FROM ${connection.trinoConnection.catalog}.${schemaName}`,
+            );
+         } else {
+            // Catalog name is included in the schema name
+            result = await malloyConnection.runSQL(
+               `SHOW TABLES FROM ${schemaName}`,
+            );
+         }
          const rows = standardizeRunSQLResult(result);
          return rows.map((row: unknown) => {
             const typedRow = row as Record<string, unknown>;

package/src/service/model.ts

@@ -269,7 +269,42 @@ export class Model {
          (await runnable.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
       const endTime = performance.now();
       const executionTime = endTime - startTime;
-      const queryResults = await runnable.run({ rowLimit });
+
+      let queryResults;
+      try {
+         queryResults = await runnable.run({ rowLimit });
+      } catch (error) {
+         // Record error metrics
+         const errorEndTime = performance.now();
+         const errorExecutionTime = errorEndTime - startTime;
+         this.queryExecutionHistogram.record(errorExecutionTime, {
+            "malloy.model.path": this.modelPath,
+            "malloy.model.query.name": queryName,
+            "malloy.model.query.source": sourceName,
+            "malloy.model.query.query": query,
+            "malloy.model.query.status": "error",
+         });
+
+         // Re-throw Malloy errors as-is (they will be handled by error handler)
+         if (error instanceof MalloyError) {
+            throw error;
+         }
+
+         // For other runtime errors (like divide by zero), throw as BadRequestError
+         const errorMessage =
+            error instanceof Error ? error.message : String(error);
+         logger.error("Query execution error", {
+            error,
+            errorMessage,
+            projectName: this.packageName,
+            modelPath: this.modelPath,
+            query,
+            queryName,
+            sourceName,
+         });
+         throw new BadRequestError(`Query execution failed: ${errorMessage}`);
+      }
+
       this.queryExecutionHistogram.record(executionTime, {
          "malloy.model.path": this.modelPath,
          "malloy.model.query.name": queryName,