@malloy-publisher/server 0.0.176 → 0.0.178

package/dist/server.js

@@ -212003,6 +212003,7 @@ function httpMetricsMiddleware(req, res, next) {
 // src/server.ts
 var exports_server = {};
 __export(exports_server, {
+  normalizeQueryArray: () => normalizeQueryArray,
   mcpApp: () => mcpApp
 });
 module.exports = __toCommonJS(exports_server);
@@ -221170,7 +221171,10 @@ async function createProjectConnections(connections = [], projectPath = "", isUp
           },
           poolOptions: {
             min: 1,
-            max: 5
+            max: 5,
+            testOnBorrow: false,
+            testOnReturn: false,
+            testWhileIdle: true
           }
         };
         const snowflakeConnection = new import_db_snowflake.SnowflakeConnection(connection.name, snowflakeConnectionOptions);
@@ -221720,6 +221724,31 @@ async function listCloudDirectorySchemas(credentials) {
 }
 
 // src/service/db_utils.ts
+function sqlInFilter(columnName, values) {
+  if (!values || values.length === 0)
+    return "";
+  const escaped = values.map((v) => `'${v.replace(/'/g, "''")}'`);
+  return `AND ${columnName} IN (${escaped.join(", ")})`;
+}
+function groupColumnRowsIntoTables(rows, buildResource) {
+  const tableMap = new Map;
+  for (const row of rows) {
+    const r = row;
+    const tableName = String(r.TABLE_NAME ?? r.table_name ?? "");
+    const columnName = String(r.COLUMN_NAME ?? r.column_name ?? "");
+    const dataType = String(r.DATA_TYPE ?? r.data_type ?? "").toLowerCase();
+    if (!tableName)
+      continue;
+    if (!tableMap.has(tableName))
+      tableMap.set(tableName, []);
+    tableMap.get(tableName).push({ name: columnName, type: dataType });
+  }
+  const tables = [];
+  for (const [tableName, columns] of tableMap) {
+    tables.push({ resource: buildResource(tableName), columns });
+  }
+  return tables;
+}
 function createBigQueryClient(connection) {
   if (!connection.bigqueryConnection) {
     throw new Error("BigQuery connection is required");
@@ -221728,17 +221757,18 @@ function createBigQueryClient(connection) {
     projectId: connection.bigqueryConnection.defaultProjectId || ""
   };
   if (connection.bigqueryConnection.serviceAccountKeyJson) {
+    let credentials;
     try {
-      const credentials = JSON.parse(connection.bigqueryConnection.serviceAccountKeyJson);
-      config.credentials = credentials;
-      if (!config.projectId && credentials.project_id) {
-        config.projectId = credentials.project_id;
-      }
-      if (!config.projectId) {
-        throw new Error("BigQuery project ID is required. Either set the defaultProjectId in the connection configuration or the project_id in the service account key JSON.");
-      }
-    } catch (error) {
-      logger.warn("Failed to parse service account key JSON, using default credentials", { error });
+      credentials = JSON.parse(connection.bigqueryConnection.serviceAccountKeyJson);
+    } catch (parseError) {
+      throw new Error(`Failed to parse BigQuery service account key JSON: ${parseError.message}`);
+    }
+    config.credentials = credentials;
+    if (!config.projectId && credentials.project_id) {
+      config.projectId = credentials.project_id;
+    }
+    if (!config.projectId) {
+      throw new Error("BigQuery project ID is required. Either set the defaultProjectId in the connection configuration or the project_id in the service account key JSON.");
     }
   } else if (Object.keys(connection.bigqueryConnection).length === 0 && process.env.GOOGLE_APPLICATION_CREDENTIALS) {
     config.keyFilename = process.env.GOOGLE_APPLICATION_CREDENTIALS || "";
@@ -221761,238 +221791,264 @@ function getCloudCredentialsFromAttachedDatabases(attachedDatabases, storageType
   }
   return null;
 }
-async function getSchemasForConnection(connection, malloyConnection) {
-  if (connection.type === "bigquery") {
-    if (!connection.bigqueryConnection) {
-      throw new Error("BigQuery connection is required");
-    }
-    try {
-      const bigquery = createBigQueryClient(connection);
-      const [datasets] = await bigquery.getDatasets();
-      const schemas = await Promise.all(datasets.map(async (dataset) => {
-        const [metadata] = await dataset.getMetadata();
-        return {
-          name: dataset.id,
-          isHidden: false,
-          isDefault: false,
-          description: metadata?.description
-        };
-      }));
-      return schemas;
-    } catch (error) {
-      console.error(`Error getting schemas for BigQuery connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for BigQuery connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "postgres") {
-    if (!connection.postgresConnection) {
-      throw new Error("Postgres connection is required");
-    }
-    try {
-      const result = await malloyConnection.runSQL("SELECT schema_name as row FROM information_schema.schemata ORDER BY schema_name");
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const schemaName = row;
-        return {
-          name: schemaName,
-          isHidden: [
-            "information_schema",
-            "pg_catalog",
-            "pg_toast"
-          ].includes(schemaName),
-          isDefault: schemaName === "public"
-        };
-      });
-    } catch (error) {
-      console.error(`Error getting schemas for Postgres connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for Postgres connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "mysql") {
-    if (!connection.mysqlConnection) {
-      throw new Error("Mysql connection is required");
-    }
-    try {
-      return [
-        {
-          name: connection.mysqlConnection.database || "mysql",
-          isHidden: false,
-          isDefault: true
-        }
-      ];
-    } catch (error) {
-      console.error(`Error getting schemas for MySQL connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for MySQL connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "snowflake") {
-    if (!connection.snowflakeConnection) {
-      throw new Error("Snowflake connection is required");
-    }
-    try {
-      const result = await malloyConnection.runSQL("SHOW SCHEMAS");
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        const databaseName = String(typedRow.database_name ?? typedRow.DATABASE_NAME ?? "");
-        const name = String(typedRow.name ?? typedRow.NAME ?? "");
-        const owner = String(typedRow.owner ?? typedRow.OWNER ?? "");
-        const isDefaultVal = typedRow.is_default ?? typedRow.isDefault ?? typedRow.IS_DEFAULT;
-        return {
-          name: `${databaseName}.${name}`,
-          isHidden: ["SNOWFLAKE", ""].includes(owner),
-          isDefault: isDefaultVal === "Y"
-        };
-      });
-    } catch (error) {
-      console.error(`Error getting schemas for Snowflake connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for Snowflake connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "trino") {
-    if (!connection.trinoConnection) {
-      throw new Error("Trino connection is required");
+async function getSchemasForBigQuery(connection) {
+  if (!connection.bigqueryConnection) {
+    throw new Error("BigQuery connection is required");
+  }
+  try {
+    const bigquery = createBigQueryClient(connection);
+    const [datasets] = await bigquery.getDatasets();
+    return await Promise.all(datasets.map(async (dataset) => {
+      const [metadata] = await dataset.getMetadata();
+      return {
+        name: dataset.id,
+        isHidden: false,
+        isDefault: false,
+        description: metadata?.description
+      };
+    }));
+  } catch (error) {
+    logger.error(`Error getting schemas for BigQuery connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for BigQuery connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForPostgres(connection, malloyConnection) {
+  if (!connection.postgresConnection) {
+    throw new Error("Postgres connection is required");
+  }
+  try {
+    const result = await malloyConnection.runSQL("SELECT schema_name FROM information_schema.schemata ORDER BY schema_name");
+    const rows = standardizeRunSQLResult2(result);
+    return rows.map((row) => {
+      const typedRow = row;
+      const schemaName = String(typedRow.schema_name ?? typedRow.SCHEMA_NAME ?? "");
+      return {
+        name: schemaName,
+        isHidden: ["information_schema", "pg_catalog", "pg_toast"].includes(schemaName),
+        isDefault: schemaName === "public"
+      };
+    });
+  } catch (error) {
+    logger.error(`Error getting schemas for Postgres connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for Postgres connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForMySQL(connection) {
+  if (!connection.mysqlConnection) {
+    throw new Error("Mysql connection is required");
+  }
+  return [
+    {
+      name: connection.mysqlConnection.database || "mysql",
+      isHidden: false,
+      isDefault: true
     }
-    try {
-      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 = standardizeRunSQLResult2(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 = standardizeRunSQLResult2(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;
-      }
+  ];
+}
+async function getSchemasForSnowflake(connection, malloyConnection) {
+  if (!connection.snowflakeConnection) {
+    throw new Error("Snowflake connection is required");
+  }
+  try {
+    const database = connection.snowflakeConnection.database;
+    const schema = connection.snowflakeConnection.schema;
+    const filters = [];
+    if (database) {
+      filters.push(`CATALOG_NAME = '${database}'`);
+    }
+    if (schema) {
+      filters.push(`SCHEMA_NAME = '${schema}'`);
+    }
+    const whereClause = filters.length > 0 ? `WHERE ${filters.join(" AND ")}` : "";
+    const result = await malloyConnection.runSQL(`SELECT CATALOG_NAME, SCHEMA_NAME, SCHEMA_OWNER FROM ${database ? `${database}.` : ""}INFORMATION_SCHEMA.SCHEMATA ${whereClause} ORDER BY SCHEMA_NAME`);
+    const rows = standardizeRunSQLResult2(result);
+    return rows.map((row) => {
+      const typedRow = row;
+      const catalogName = String(typedRow.CATALOG_NAME ?? typedRow.catalog_name ?? "");
+      const schemaName = String(typedRow.SCHEMA_NAME ?? typedRow.schema_name ?? "");
+      const owner = String(typedRow.SCHEMA_OWNER ?? typedRow.schema_owner ?? "");
+      return {
+        name: `${catalogName}.${schemaName}`,
+        isHidden: ["SNOWFLAKE", ""].includes(owner) || schemaName === "INFORMATION_SCHEMA",
+        isDefault: schema ? schemaName === schema : false
+      };
+    });
+  } catch (error) {
+    logger.error(`Error getting schemas for Snowflake connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for Snowflake connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForTrino(connection, malloyConnection) {
+  if (!connection.trinoConnection) {
+    throw new Error("Trino connection is required");
+  }
+  try {
+    const configuredSchema = connection.trinoConnection.schema;
+    let allRows = [];
+    if (connection.trinoConnection.catalog) {
+      const catalog = connection.trinoConnection.catalog;
+      const result = await malloyConnection.runSQL(`SELECT schema_name FROM ${catalog}.information_schema.schemata ORDER BY schema_name`);
       const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
+      allRows = rows.map((row) => {
+        const r = row;
         return {
-          name: typedRow.Schema,
-          isHidden: ["information_schema", "performance_schema"].includes(typedRow.Schema),
-          isDefault: typedRow.Schema === connection.trinoConnection?.schema
+          catalog,
+          schema: String(r.schema_name ?? r.Schema ?? "")
         };
       });
-    } catch (error) {
-      console.error(`Error getting schemas for Trino connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for Trino connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "duckdb") {
-    if (!connection.duckdbConnection) {
-      throw new Error("DuckDB connection is required");
-    }
-    try {
-      const result = await malloyConnection.runSQL("SELECT DISTINCT schema_name,catalog_name FROM information_schema.schemata ORDER BY catalog_name,schema_name", { rowLimit: 1000 });
-      const rows = standardizeRunSQLResult2(result);
-      const schemas = rows.map((row) => {
-        const typedRow = row;
-        const schemaName = typedRow.schema_name;
-        const catalogName = typedRow.catalog_name;
-        return {
-          name: `${catalogName}.${schemaName}`,
-          isHidden: [
-            "information_schema",
-            "performance_schema",
-            "",
-            "SNOWFLAKE",
-            "information_schema",
-            "pg_catalog",
-            "pg_toast"
-          ].includes(schemaName) || ["md_information_schema", "system"].includes(catalogName),
-          isDefault: catalogName === "main"
-        };
+    } else {
+      const catalogsResult = await malloyConnection.runSQL(`SHOW CATALOGS`);
+      const catalogNames = standardizeRunSQLResult2(catalogsResult).map((row) => {
+        const r = row;
+        return String(r.Catalog ?? r.catalog ?? "");
       });
-      const attachedDatabases = connection.duckdbConnection.attachedDatabases || [];
-      const cloudDatabases = attachedDatabases.filter((attachedDb) => (attachedDb.type === "gcs" || attachedDb.type === "s3") && (attachedDb.gcsConnection || attachedDb.s3Connection));
-      const cloudDbPromises = cloudDatabases.map(async (attachedDb) => {
-        const dbType = attachedDb.type;
-        const credentials = dbType === "gcs" ? gcsConnectionToCredentials(attachedDb.gcsConnection) : s3ConnectionToCredentials(attachedDb.s3Connection);
+      for (const catalog of catalogNames) {
         try {
-          return await listCloudDirectorySchemas(credentials);
-        } catch (cloudError) {
-          logger.warn(`Failed to list ${dbType.toUpperCase()} directory schemas for ${attachedDb.name}`, { error: cloudError });
-          return [];
-        }
-      });
-      const cloudSchemaArrays = await Promise.all(cloudDbPromises);
-      for (const cloudSchemas of cloudSchemaArrays) {
-        schemas.push(...cloudSchemas);
-      }
-      const azureDatabases = attachedDatabases.filter((attachedDb) => attachedDb.type === "azure" && attachedDb.azureConnection);
-      for (const attachedDb of azureDatabases) {
-        if (attachedDb.name) {
-          schemas.push({
-            name: attachedDb.name,
-            isHidden: false,
-            isDefault: false
-          });
+          const result = await malloyConnection.runSQL(`SELECT schema_name FROM ${catalog}.information_schema.schemata ORDER BY schema_name`);
+          const rows = standardizeRunSQLResult2(result);
+          for (const row of rows) {
+            const r = row;
+            allRows.push({
+              catalog,
+              schema: String(r.schema_name ?? r.Schema ?? "")
+            });
+          }
+        } catch (catalogError) {
+          logger.warn(`Failed to list schemas for Trino catalog ${catalog}`, { error: catalogError });
         }
       }
-      return schemas;
-    } catch (error) {
-      console.error(`Error getting schemas for DuckDB connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for DuckDB connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "motherduck") {
-    if (!connection.motherduckConnection) {
-      throw new Error("MotherDuck connection is required");
     }
-    try {
-      const result = await malloyConnection.runSQL("SELECT DISTINCT schema_name as row FROM information_schema.schemata ORDER BY schema_name", { rowLimit: 1000 });
-      const rows = standardizeRunSQLResult2(result);
-      console.log(rows);
-      return rows.map((row) => {
-        const typedRow = row;
-        return {
-          name: typedRow.row,
-          isHidden: [
-            "information_schema",
-            "performance_schema",
-            ""
-          ].includes(typedRow.row),
-          isDefault: false
-        };
-      });
-    } catch (error) {
-      console.error(`Error getting schemas for MotherDuck connection ${connection.name}:`, error);
-      throw new Error(`Failed to get schemas for MotherDuck connection ${connection.name}: ${error.message}`);
+    return allRows.map(({ catalog, schema }) => {
+      const name = connection.trinoConnection?.catalog ? schema : `${catalog}.${schema}`;
+      return {
+        name,
+        isHidden: ["information_schema", "performance_schema"].includes(schema),
+        isDefault: configuredSchema ? schema === configuredSchema : false
+      };
+    });
+  } catch (error) {
+    logger.error(`Error getting schemas for Trino connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for Trino connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForDuckDB(connection, malloyConnection) {
+  if (!connection.duckdbConnection) {
+    throw new Error("DuckDB connection is required");
+  }
+  try {
+    const result = await malloyConnection.runSQL("SELECT DISTINCT schema_name,catalog_name FROM information_schema.schemata ORDER BY catalog_name,schema_name", { rowLimit: 1000 });
+    const rows = standardizeRunSQLResult2(result);
+    const schemas = rows.map((row) => {
+      const typedRow = row;
+      const schemaName = String(typedRow.schema_name ?? "");
+      const catalogName = String(typedRow.catalog_name ?? "");
+      return {
+        name: `${catalogName}.${schemaName}`,
+        isHidden: [
+          "information_schema",
+          "performance_schema",
+          "pg_catalog",
+          "pg_toast",
+          ""
+        ].includes(schemaName) || ["md_information_schema", "system"].includes(catalogName),
+        isDefault: catalogName === "main"
+      };
+    });
+    const attachedDatabases = connection.duckdbConnection.attachedDatabases || [];
+    const cloudDatabases = attachedDatabases.filter((attachedDb) => (attachedDb.type === "gcs" || attachedDb.type === "s3") && (attachedDb.gcsConnection || attachedDb.s3Connection));
+    const cloudDbPromises = cloudDatabases.map(async (attachedDb) => {
+      const dbType = attachedDb.type;
+      const credentials = dbType === "gcs" ? gcsConnectionToCredentials(attachedDb.gcsConnection) : s3ConnectionToCredentials(attachedDb.s3Connection);
+      try {
+        return await listCloudDirectorySchemas(credentials);
+      } catch (cloudError) {
+        logger.warn(`Failed to list ${dbType.toUpperCase()} directory schemas for ${attachedDb.name}`, { error: cloudError });
+        return [];
+      }
+    });
+    const cloudSchemaArrays = await Promise.all(cloudDbPromises);
+    for (const cloudSchemas of cloudSchemaArrays) {
+      schemas.push(...cloudSchemas);
     }
-  } else if (connection.type === "ducklake") {
-    try {
-      const catalogName = connection.name;
-      const result = await malloyConnection.runSQL(`SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '${catalogName}' ORDER BY schema_name`, { rowLimit: 1000 });
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        const schemaName = typedRow.schema_name;
-        const shouldShow = schemaName === "main" || schemaName === "public";
-        return {
-          name: schemaName,
-          isHidden: !shouldShow,
+    const azureDatabases = attachedDatabases.filter((attachedDb) => attachedDb.type === "azure" && attachedDb.azureConnection);
+    for (const attachedDb of azureDatabases) {
+      if (attachedDb.name) {
+        schemas.push({
+          name: attachedDb.name,
+          isHidden: false,
           isDefault: false
-        };
-      });
-    } catch (error) {
-      logger.error(`Error getting schemas for DuckLake connection ${connection.name}`, { error });
-      throw new Error(`Failed to get schemas for DuckLake connection ${connection.name}: ${error.message}`);
+        });
+      }
     }
-  } else {
-    throw new Error(`Unsupported connection type: ${connection.type}`);
+    return schemas;
+  } catch (error) {
+    logger.error(`Error getting schemas for DuckDB connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for DuckDB connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForMotherDuck(connection, malloyConnection) {
+  if (!connection.motherduckConnection) {
+    throw new Error("MotherDuck connection is required");
+  }
+  try {
+    const database = connection.motherduckConnection.database;
+    const whereClause = database ? `WHERE catalog_name = '${database}'` : "";
+    const result = await malloyConnection.runSQL(`SELECT DISTINCT schema_name FROM information_schema.schemata ${whereClause} ORDER BY schema_name`);
+    const rows = standardizeRunSQLResult2(result);
+    return rows.map((row) => {
+      const typedRow = row;
+      const schemaName = String(typedRow.schema_name ?? typedRow.SCHEMA_NAME ?? "");
+      return {
+        name: schemaName,
+        isHidden: ["information_schema", "performance_schema", ""].includes(schemaName),
+        isDefault: schemaName === "main"
+      };
+    });
+  } catch (error) {
+    logger.error(`Error getting schemas for MotherDuck connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for MotherDuck connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForDuckLake(connection, malloyConnection) {
+  try {
+    const catalogName = connection.name;
+    const result = await malloyConnection.runSQL(`SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '${catalogName}' ORDER BY schema_name`, { rowLimit: 1000 });
+    const rows = standardizeRunSQLResult2(result);
+    return rows.map((row) => {
+      const typedRow = row;
+      const schemaName = typedRow.schema_name;
+      const shouldShow = schemaName === "main" || schemaName === "public";
+      return {
+        name: schemaName,
+        isHidden: !shouldShow,
+        isDefault: false
+      };
+    });
+  } catch (error) {
+    logger.error(`Error getting schemas for DuckLake connection ${connection.name}`, { error });
+    throw new Error(`Failed to get schemas for DuckLake connection ${connection.name}: ${error.message}`);
+  }
+}
+async function getSchemasForConnection(connection, malloyConnection) {
+  switch (connection.type) {
+    case "bigquery":
+      return getSchemasForBigQuery(connection);
+    case "postgres":
+      return getSchemasForPostgres(connection, malloyConnection);
+    case "mysql":
+      return getSchemasForMySQL(connection);
+    case "snowflake":
+      return getSchemasForSnowflake(connection, malloyConnection);
+    case "trino":
+      return getSchemasForTrino(connection, malloyConnection);
+    case "duckdb":
+      return getSchemasForDuckDB(connection, malloyConnection);
+    case "motherduck":
+      return getSchemasForMotherDuck(connection, malloyConnection);
+    case "ducklake":
+      return getSchemasForDuckLake(connection, malloyConnection);
+    default:
+      throw new Error(`Unsupported connection type: ${connection.type}`);
   }
 }
 function getFileType2(key) {
@@ -222155,281 +222211,217 @@ async function describeAzureFile(malloyConnection, fileUri, azureConnection) {
     throw new Error(`Failed to describe Azure file: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-async function getTablesForSchema(connection, schemaName, malloyConnection, fetchTableSchema = true) {
-  if (connection.type === "duckdb") {
-    const attachedDbs = connection.duckdbConnection?.attachedDatabases || [];
-    const azureDb = attachedDbs.find((db) => db.type === "azure" && db.name === schemaName && db.azureConnection);
-    if (azureDb) {
-      const azureConn = azureDb.azureConnection;
-      const fileUrl = azureConn.authType === "sas_token" ? azureConn.sasUrl : azureConn.fileUrl;
-      if (fileUrl) {
-        return await describeAzureFile(malloyConnection, fileUrl, azureConn);
+async function listTablesForSchema(connection, schemaName, malloyConnection, tableNames) {
+  switch (connection.type) {
+    case "bigquery":
+      return listTablesForBigQuery(connection, schemaName, malloyConnection, tableNames);
+    case "mysql":
+      return listTablesForMySQL(connection, schemaName, malloyConnection, tableNames);
+    case "postgres":
+      return listTablesForPostgres(connection, schemaName, malloyConnection, tableNames);
+    case "snowflake":
+      return listTablesForSnowflake(connection, schemaName, malloyConnection, tableNames);
+    case "trino":
+      return listTablesForTrino(connection, schemaName, malloyConnection, tableNames);
+    case "duckdb":
+      return listTablesForDuckDB(connection, schemaName, malloyConnection, tableNames);
+    case "motherduck":
+      return listTablesForMotherDuck(connection, schemaName, malloyConnection, tableNames);
+    case "ducklake":
+      return listTablesForDuckLake(connection, schemaName, malloyConnection, tableNames);
+    default:
+      throw new Error(`Unsupported connection type: ${connection.type}`);
+  }
+}
+async function listTablesForBigQuery(connection, schemaName, malloyConnection, tableNames) {
+  try {
+    const bigquery = createBigQueryClient(connection);
+    const dataset = bigquery.dataset(schemaName);
+    const [tables] = await dataset.getTables();
+    let names = tables.map((table) => table.id).filter((id) => id !== undefined);
+    if (tableNames) {
+      const allowed = new Set(tableNames);
+      names = names.filter((id) => allowed.has(id));
+    }
+    const results = await Promise.all(names.map(async (tableName) => {
+      const tablePath = `${schemaName}.${tableName}`;
+      try {
+        const source = await malloyConnection.fetchTableSchema(tableName, tablePath);
+        const columns = source?.fields?.map((field) => ({
+          name: field.name,
+          type: field.type
+        })) || [];
+        return { resource: tablePath, columns };
+      } catch (error) {
+        logger.warn(`Failed to get schema for table ${tableName}`, {
+          error: extractErrorDataFromError(error),
+          schemaName,
+          tableName
+        });
+        return { resource: tablePath, columns: [] };
       }
+    }));
+    return results;
+  } catch (error) {
+    logger.error(`Error getting tables for BigQuery schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for BigQuery schema ${schemaName} in connection ${connection.name}: ${error.message}`);
+  }
+}
+async function listTablesForMySQL(connection, schemaName, malloyConnection, tableNames) {
+  if (!connection.mysqlConnection) {
+    throw new Error("Mysql connection is required");
+  }
+  try {
+    const result = await malloyConnection.runSQL(`SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE FROM information_schema.columns WHERE table_schema = '${schemaName}' ${sqlInFilter("TABLE_NAME", tableNames)} ORDER BY TABLE_NAME, ORDINAL_POSITION`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${schemaName}.${t}`);
+  } catch (error) {
+    logger.error(`Error getting tables for MySQL schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for MySQL schema ${schemaName} in connection ${connection.name}: ${error.message}`);
+  }
+}
+async function listTablesForPostgres(connection, schemaName, malloyConnection, tableNames) {
+  if (!connection.postgresConnection) {
+    throw new Error("Postgres connection is required");
+  }
+  try {
+    const result = await malloyConnection.runSQL(`SELECT table_name, column_name, data_type FROM information_schema.columns WHERE table_schema = '${schemaName}' ${sqlInFilter("table_name", tableNames)} ORDER BY table_name, ordinal_position`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${schemaName}.${t}`);
+  } catch (error) {
+    logger.error(`Error getting tables for Postgres schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for Postgres schema ${schemaName} in connection ${connection.name}: ${error.message}`);
+  }
+}
+async function listTablesForSnowflake(connection, schemaName, malloyConnection, tableNames) {
+  if (!connection.snowflakeConnection) {
+    throw new Error("Snowflake connection is required");
+  }
+  try {
+    const parts = schemaName.split(".");
+    let databaseName;
+    let schemaOnly;
+    if (parts.length >= 2) {
+      databaseName = parts[0];
+      schemaOnly = parts[1];
+    } else {
+      databaseName = connection.snowflakeConnection.database ?? "";
+      schemaOnly = parts[0];
+    }
+    if (!databaseName) {
+      throw new Error(`Cannot resolve database for schema "${schemaName}": provide DATABASE.SCHEMA or configure a database on the connection`);
     }
+    const qualifiedSchema = `${databaseName}.${schemaOnly}`;
+    const result = await malloyConnection.runSQL(`SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE FROM ${databaseName}.INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${schemaOnly}' ${sqlInFilter("TABLE_NAME", tableNames)} ORDER BY TABLE_NAME, ORDINAL_POSITION`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${qualifiedSchema}.${t}`);
+  } catch (error) {
+    logger.error(`Error getting tables for Snowflake schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for Snowflake schema ${schemaName} in connection ${connection.name}: ${error.message}`);
   }
-  if (connection.type === "duckdb" && (schemaName.startsWith("abfss://") || schemaName.startsWith("https://") || schemaName.startsWith("az://"))) {
-    return await describeAzureFile(malloyConnection, schemaName);
+}
+async function listTablesForTrino(connection, schemaName, malloyConnection, tableNames) {
+  if (!connection.trinoConnection) {
+    throw new Error("Trino connection is required");
+  }
+  try {
+    let catalogPrefix;
+    let schemaOnly;
+    let resourcePrefix;
+    if (connection.trinoConnection.catalog) {
+      catalogPrefix = `${connection.trinoConnection.catalog}.`;
+      schemaOnly = schemaName;
+      resourcePrefix = `${connection.trinoConnection.catalog}.${schemaName}`;
+    } else {
+      const dotIdx = schemaName.indexOf(".");
+      if (dotIdx > 0) {
+        catalogPrefix = `${schemaName.substring(0, dotIdx)}.`;
+        schemaOnly = schemaName.substring(dotIdx + 1);
+      } else {
+        catalogPrefix = "";
+        schemaOnly = schemaName;
+      }
+      resourcePrefix = schemaName;
+    }
+    const result = await malloyConnection.runSQL(`SELECT table_name, column_name, data_type FROM ${catalogPrefix}information_schema.columns WHERE table_schema = '${schemaOnly}' ${sqlInFilter("table_name", tableNames)} ORDER BY table_name, ordinal_position`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${resourcePrefix}.${t}`);
+  } catch (error) {
+    logger.error(`Error getting tables for Trino schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for Trino schema ${schemaName} in connection ${connection.name}: ${error.message}`);
+  }
+}
+async function listTablesForDuckDB(connection, schemaName, malloyConnection, tableNames) {
+  if (!connection.duckdbConnection) {
+    throw new Error("DuckDB connection is required");
+  }
+  const attachedDbs = connection.duckdbConnection.attachedDatabases || [];
+  const azureDb = attachedDbs.find((db) => db.type === "azure" && db.name === schemaName && db.azureConnection);
+  if (azureDb) {
+    const azureConn = azureDb.azureConnection;
+    const fileUrl = azureConn.authType === "sas_token" ? azureConn.sasUrl : azureConn.fileUrl;
+    if (fileUrl) {
+      return describeAzureFile(malloyConnection, fileUrl, azureConn);
+    }
+  }
+  if (schemaName.startsWith("abfss://") || schemaName.startsWith("https://") || schemaName.startsWith("az://")) {
+    return describeAzureFile(malloyConnection, schemaName);
   }
   const parsedUri = parseCloudUri(schemaName);
-  if (parsedUri && connection.type === "duckdb") {
+  if (parsedUri) {
     const {
       type: cloudType,
       bucket: bucketName,
       path: directoryPath
     } = parsedUri;
-    const attachedDatabases = connection.duckdbConnection?.attachedDatabases || [];
-    const credentials = getCloudCredentialsFromAttachedDatabases(attachedDatabases, cloudType);
+    const credentials = getCloudCredentialsFromAttachedDatabases(attachedDbs, cloudType);
     if (!credentials) {
       throw new Error(`${cloudType.toUpperCase()} credentials not found in attached databases`);
     }
     const fileKeys = await listDataFilesInDirectory(credentials, bucketName, directoryPath);
-    return await getCloudTablesWithColumns(malloyConnection, credentials, bucketName, fileKeys);
-  } else if (connection.type === "ducklake") {
-    if (schemaName.split(".").length == 2) {
-      schemaName = `${connection.name}.${schemaName}`;
-    } else if (schemaName.split(".").length === 1) {
-      schemaName = `${connection.name}.${schemaName}`;
-    }
+    return getCloudTablesWithColumns(malloyConnection, credentials, bucketName, fileKeys);
+  }
+  const dotIdx = schemaName.indexOf(".");
+  if (dotIdx < 0) {
+    throw new Error(`DuckDB schema name must be qualified as "catalog.schema", got "${schemaName}"`);
+  }
+  const catalogName = schemaName.substring(0, dotIdx);
+  const actualSchemaName = schemaName.substring(dotIdx + 1);
+  try {
+    const result = await malloyConnection.runSQL(`SELECT table_name, column_name, data_type FROM information_schema.columns WHERE table_schema = '${actualSchemaName}' AND table_catalog = '${catalogName}' ${sqlInFilter("table_name", tableNames)} ORDER BY table_name, ordinal_position`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${schemaName}.${t}`);
+  } catch (error) {
+    logger.error(`Error getting tables for DuckDB schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for DuckDB schema ${schemaName} in connection ${connection.name}: ${error.message}`);
   }
-  const tableNames = await listTablesForSchema(connection, schemaName, malloyConnection);
-  const tableSourcePromises = tableNames.map(async (tableName) => {
-    try {
-      let tablePath;
-      if (connection.type === "trino") {
-        if (connection.trinoConnection?.catalog) {
-          tablePath = `${connection.trinoConnection?.catalog}.${schemaName}.${tableName}`;
-        } else {
-          tablePath = `${schemaName}.${tableName}`;
-        }
-      } else if (connection.type === "ducklake") {
-        tablePath = `${schemaName}.${tableName}`;
-      } else {
-        tablePath = `${schemaName}.${tableName}`;
-      }
-      logger.info(`Processing table: ${tableName} in schema: ${schemaName}`, { tablePath, connectionType: connection.type });
-      let tableSource;
-      if (fetchTableSchema) {
-        tableSource = await getConnectionTableSource(malloyConnection, tableName, tablePath);
-      }
-      return {
-        resource: tablePath,
-        columns: tableSource?.columns || []
-      };
-    } catch (error) {
-      logger.warn(`Failed to get schema for table ${tableName}`, {
-        error: extractErrorDataFromError(error),
-        schemaName,
-        tableName
-      });
-      return {
-        resource: `${schemaName}.${tableName}`,
-        columns: []
-      };
-    }
-  });
-  const tableResults = await Promise.all(tableSourcePromises);
-  return tableResults;
 }
-async function getConnectionTableSource(malloyConnection, tableKey, tablePath) {
+async function listTablesForMotherDuck(connection, schemaName, malloyConnection, tableNames) {
+  if (!connection.motherduckConnection) {
+    throw new Error("MotherDuck connection is required");
+  }
   try {
-    logger.info(`Attempting to fetch table schema for: ${tablePath}`, {
-      tableKey,
-      tablePath
-    });
-    const source = await malloyConnection.fetchTableSchema(tableKey, tablePath);
-    if (source === undefined) {
-      throw new ConnectionError(`Table ${tablePath} not found: ${JSON.stringify(source)}`);
-    }
-    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,
-        type: field.type
-      };
-    });
-    logger.debug(`Successfully fetched schema for ${tablePath}`, {
-      fieldCount: fields.length
-    });
-    return {
-      source: JSON.stringify(source),
-      resource: tablePath,
-      columns: fields
-    };
+    const result = await malloyConnection.runSQL(`SELECT table_name, column_name, data_type FROM information_schema.columns WHERE table_schema = '${schemaName}' ${sqlInFilter("table_name", tableNames)} ORDER BY table_name, ordinal_position`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${schemaName}.${t}`);
   } catch (error) {
-    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);
+    logger.error(`Error getting tables for MotherDuck schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for MotherDuck schema ${schemaName} in connection ${connection.name}: ${error.message}`);
   }
 }
-async function listTablesForSchema(connection, schemaName, malloyConnection) {
-  if (connection.type === "bigquery") {
-    try {
-      const bigquery = createBigQueryClient(connection);
-      const dataset = bigquery.dataset(schemaName);
-      const [tables] = await dataset.getTables();
-      return tables.map((table) => table.id).filter((id) => id !== undefined);
-    } catch (error) {
-      logger.error(`Error getting tables for BigQuery schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for BigQuery schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "mysql") {
-    if (!connection.mysqlConnection) {
-      throw new Error("Mysql connection is required");
-    }
-    try {
-      const result = await malloyConnection.runSQL(`SELECT TABLE_NAME FROM information_schema.tables WHERE table_schema = '${schemaName}' AND table_type = 'BASE TABLE'`);
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        return typedRow.TABLE_NAME;
-      });
-    } catch (error) {
-      logger.error(`Error getting tables for MySQL schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for MySQL schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "postgres") {
-    if (!connection.postgresConnection) {
-      throw new Error("Postgres connection is required");
-    }
-    try {
-      const result = await malloyConnection.runSQL(`SELECT table_name as row FROM information_schema.tables WHERE table_schema = '${schemaName}' ORDER BY table_name`);
-      const rows = standardizeRunSQLResult2(result);
-      return rows;
-    } catch (error) {
-      logger.error(`Error getting tables for Postgres schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for Postgres schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "snowflake") {
-    if (!connection.snowflakeConnection) {
-      throw new Error("Snowflake connection is required");
-    }
-    try {
-      const tablesResult = await malloyConnection.runSQL(`SHOW TABLES IN SCHEMA ${schemaName} LIMIT 1000`);
-      const viewsResult = await malloyConnection.runSQL(`SHOW VIEWS IN SCHEMA ${schemaName} LIMIT 1000`);
-      const tableRows = standardizeRunSQLResult2(tablesResult);
-      const viewRows = standardizeRunSQLResult2(viewsResult);
-      logger.debug("Snowflake Tables Listed", { tableRows });
-      logger.debug("Snowflake Views Listed", { viewRows });
-      const rows = [...tableRows, ...viewRows];
-      return rows.map((row) => {
-        const typedRow = row;
-        const name = typedRow.name ?? typedRow.NAME;
-        return typeof name === "string" ? name : String(name);
-      }).filter((id) => id.length > 0);
-    } catch (error) {
-      logger.error(`Error getting tables for Snowflake schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for Snowflake schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "trino") {
-    if (!connection.trinoConnection) {
-      throw new Error("Trino connection is required");
-    }
-    try {
-      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 = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        return typedRow.Table;
-      });
-    } catch (error) {
-      logger.error(`Error getting tables for Trino schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for Trino schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "duckdb") {
-    if (!connection.duckdbConnection) {
-      throw new Error("DuckDB connection is required");
-    }
-    const parsedUri = parseCloudUri(schemaName);
-    if (parsedUri) {
-      const {
-        type: cloudType,
-        bucket: bucketName,
-        path: directoryPath
-      } = parsedUri;
-      const attachedDatabases = connection.duckdbConnection.attachedDatabases || [];
-      const credentials = getCloudCredentialsFromAttachedDatabases(attachedDatabases, cloudType);
-      if (!credentials) {
-        throw new Error(`${cloudType.toUpperCase()} credentials not found in attached databases`);
-      }
-      try {
-        const fileKeys = await listDataFilesInDirectory(credentials, bucketName, directoryPath);
-        return fileKeys.map((key) => {
-          const lastSlash = key.lastIndexOf("/");
-          return lastSlash > 0 ? key.substring(lastSlash + 1) : key;
-        });
-      } catch (error) {
-        logger.error(`Error listing ${cloudType.toUpperCase()} objects in ${schemaName}`, {
-          error
-        });
-        throw new Error(`Failed to list files in ${schemaName}: ${error.message}`);
-      }
-    }
-    const catalogName = schemaName.split(".")[0];
-    const actualSchemaName = schemaName.split(".")[1];
-    try {
-      const result = await malloyConnection.runSQL(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${actualSchemaName}' and table_catalog = '${catalogName}' ORDER BY table_name`, { rowLimit: 1000 });
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        return typedRow.table_name;
-      });
-    } catch (error) {
-      logger.error(`Error getting tables for DuckDB schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for DuckDB schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "motherduck") {
-    if (!connection.motherduckConnection) {
-      throw new Error("MotherDuck connection is required");
-    }
-    try {
-      const result = await malloyConnection.runSQL(`SELECT table_name as row FROM information_schema.tables WHERE table_schema = '${schemaName}' ORDER BY table_name`, { rowLimit: 1000 });
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        return typedRow.row;
-      });
-    } catch (error) {
-      logger.error(`Error getting tables for MotherDuck schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for MotherDuck schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else if (connection.type === "ducklake") {
-    const catalogName = schemaName.split(".")[0];
-    const actualSchemaName = schemaName.split(".")[1];
-    console.error("catalogName", catalogName);
-    console.error("actualSchemaName", actualSchemaName);
-    try {
-      const result = await malloyConnection.runSQL(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${actualSchemaName}' AND table_catalog = '${catalogName}' ORDER BY table_name`, { rowLimit: 1000 });
-      const rows = standardizeRunSQLResult2(result);
-      return rows.map((row) => {
-        const typedRow = row;
-        return typedRow.table_name;
-      });
-    } catch (error) {
-      logger.error(`Error getting tables for DuckLake schema ${schemaName} in connection ${connection.name}`, { error });
-      throw new Error(`Failed to get tables for DuckLake schema ${schemaName} in connection ${connection.name}: ${error.message}`);
-    }
-  } else {
-    throw new Error(`Unsupported connection type: ${connection.type}`);
+async function listTablesForDuckLake(connection, schemaName, malloyConnection, tableNames) {
+  if (!schemaName.includes(".")) {
+    schemaName = `${connection.name}.${schemaName}`;
+  }
+  const catalogName = schemaName.split(".")[0];
+  const actualSchemaName = schemaName.split(".")[1];
+  try {
+    const result = await malloyConnection.runSQL(`SELECT table_name, column_name, data_type FROM information_schema.columns WHERE table_schema = '${actualSchemaName}' AND table_catalog = '${catalogName}' ${sqlInFilter("table_name", tableNames)} ORDER BY table_name, ordinal_position`);
+    const rows = standardizeRunSQLResult2(result);
+    return groupColumnRowsIntoTables(rows, (t) => `${schemaName}.${t}`);
+  } catch (error) {
+    logger.error(`Error getting tables for DuckLake schema ${schemaName} in connection ${connection.name}`, { error });
+    throw new Error(`Failed to get tables for DuckLake schema ${schemaName} in connection ${connection.name}: ${error.message}`);
   }
 }
 function extractErrorDataFromError(error) {
@@ -222455,23 +222447,6 @@ var AZURE_DATA_EXTENSIONS = [
   ".jsonl",
   ".ndjson"
 ];
-function parseFetchTableSchemaQueryParam(raw) {
-  if (raw === undefined || raw === null) {
-    return true;
-  }
-  const v = Array.isArray(raw) ? raw[0] : raw;
-  if (v === "" || v === undefined) {
-    return true;
-  }
-  if (typeof v === "boolean") {
-    return v;
-  }
-  const s = String(v).trim().toLowerCase();
-  if (s === "false" || s === "0") {
-    return false;
-  }
-  return true;
-}
 function validateAzureUrl(url2, fieldName) {
   if (!AZURE_SUPPORTED_SCHEMES.some((s) => url2.startsWith(s))) {
     throw new BadRequestError(`Azure ${fieldName} must use one of: ${AZURE_SUPPORTED_SCHEMES.join(", ")}`);
@@ -222535,6 +222510,30 @@ class ConnectionController {
       return project.getMalloyConnection(connectionName);
     }
   }
+  async fetchTable(malloyConnection, tableKey, tablePath) {
+    try {
+      const source = await malloyConnection.fetchTableSchema(tableKey, tablePath);
+      if (!source) {
+        throw new ConnectionError(`Table ${tablePath} not found`);
+      }
+      return {
+        source: JSON.stringify(source),
+        resource: tablePath,
+        columns: (source.fields || []).map((f) => ({
+          name: f.name,
+          type: f.type
+        }))
+      };
+    } catch (error) {
+      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);
+    }
+  }
   async getConnection(projectName, connectionName) {
     if (!projectName || !connectionName) {
       throw new BadRequestError("Connection payload is required");
@@ -222552,11 +222551,11 @@ class ConnectionController {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
     return getSchemasForConnection(connection, malloyConnection);
   }
-  async listTables(projectName, connectionName, schemaName, fetchTableSchema = true) {
+  async listTables(projectName, connectionName, schemaName, tableNames) {
     const project = await this.projectStore.getProject(projectName, false);
     const connection = project.getApiConnection(connectionName);
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
-    return getTablesForSchema(connection, schemaName, malloyConnection, fetchTableSchema);
+    return listTablesForSchema(connection, schemaName, malloyConnection, tableNames);
   }
   async getConnectionSqlSource(projectName, connectionName, sqlStatement) {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
@@ -222571,10 +222570,6 @@ class ConnectionController {
       throw new ConnectionError(error.message);
     }
   }
-  async getConnectionTableSource(projectName, connectionName, tableKey, tablePath) {
-    const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
-    return getConnectionTableSource(malloyConnection, tableKey, tablePath);
-  }
   async getTable(projectName, connectionName, schemaName, tablePath) {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
     const project = await this.projectStore.getProject(projectName, false);
@@ -222599,12 +222594,8 @@ class ConnectionController {
           const queryString = urlParts[1] ? `?${urlParts[1]}` : "";
           const dirPath = basePath.substring(0, basePath.lastIndexOf("/") + 1);
           const fullFileUrl = `${dirPath}${fileName}${queryString}`;
-          const tableSource2 = await getConnectionTableSource(malloyConnection, fileName, fullFileUrl);
-          return {
-            resource: tablePath,
-            columns: tableSource2.columns,
-            source: tableSource2.source
-          };
+          const table = await this.fetchTable(malloyConnection, fileName, fullFileUrl);
+          return { ...table, resource: tablePath };
         }
       }
     }
@@ -222612,12 +222603,7 @@ class ConnectionController {
     if (!tableKey) {
       throw new Error(`Invalid tablePath: ${tablePath}`);
     }
-    const tableSource = await getConnectionTableSource(malloyConnection, tableKey, tablePath);
-    return {
-      resource: tablePath,
-      columns: tableSource.columns,
-      source: tableSource.source
-    };
+    return this.fetchTable(malloyConnection, tableKey, tablePath);
   }
   async getConnectionQueryData(projectName, connectionName, sqlStatement, options) {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
@@ -230423,7 +230409,7 @@ class Project {
     return this;
   }
   static async create(projectName, projectPath, connections) {
-    if (!(await fs6.promises.stat(projectPath)).isDirectory()) {
+    if (!(await fs6.promises.stat(projectPath))?.isDirectory()) {
       throw new ProjectNotFoundError(`Project path ${projectPath} not found`);
     }
     logger.info(`Creating project with connection configuration`);
@@ -230575,7 +230561,7 @@ ${source}` : source;
   }
   async addPackage(packageName) {
     const packagePath = path7.join(this.projectPath, packageName);
-    if (!await fs6.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs6.promises.stat(packagePath)).isDirectory()) {
+    if (!await fs6.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs6.promises.stat(packagePath))?.isDirectory()) {
       throw new PackageNotFoundError(`Package ${packageName} not found`);
     }
     logger.info(`Adding package ${packageName} to project ${this.projectName}`, {
@@ -231070,18 +231056,7 @@ class ProjectStore {
   }
   async cleanupAndCreatePublisherPath() {
     const reInit = process.env.INITIALIZE_STORAGE === "true";
-    try {
-      const stats = await fs7.promises.stat(this.serverRootPath);
-      if (!stats.isDirectory()) {
-        throw new Error(`Server root path ${this.serverRootPath} exists but is not a directory`);
-      }
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        await fs7.promises.mkdir(this.serverRootPath, { recursive: true });
-      } else {
-        throw error;
-      }
-    }
+    await fs7.promises.mkdir(this.serverRootPath, { recursive: true });
     if (reInit) {
       const uploadDocsPath2 = path8.join(this.serverRootPath, PUBLISHER_DATA_DIR);
       logger.info(`Reinitialization mode: Cleaning up upload documents path ${uploadDocsPath2}`);
@@ -231491,7 +231466,7 @@ class ProjectStore {
     if (projectPath.endsWith(".zip")) {
       projectPath = await this.unzipProject(projectPath);
     }
-    const projectDirExists = (await fs7.promises.stat(projectPath)).isDirectory();
+    const projectDirExists = (await fs7.promises.stat(projectPath))?.isDirectory() ?? false;
     if (projectDirExists) {
       await fs7.promises.rm(absoluteTargetPath, {
         recursive: true,
@@ -235629,6 +235604,13 @@ function initializeMcpServer(projectStore) {
 
 // src/server.ts
 var __filename = "/home/runner/work/publisher/publisher/packages/server/src/server.ts";
+function normalizeQueryArray(value) {
+  if (value === undefined || value === null)
+    return;
+  if (Array.isArray(value))
+    return value.map(String);
+  return [String(value)];
+}
 function parseArgs() {
   const args = process.argv.slice(2);
   for (let i = 0;i < args.length; i++) {
@@ -235922,7 +235904,7 @@ app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/schema
 app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/schemas/:schemaName/tables`, async (req, res) => {
   logger.info("req.params", { params: req.params });
   try {
-    const results = await connectionController.listTables(req.params.projectName, req.params.connectionName, req.params.schemaName, parseFetchTableSchemaQueryParam(req.query.fetchTableSchema));
+    const results = await connectionController.listTables(req.params.projectName, req.params.connectionName, req.params.schemaName, normalizeQueryArray(req.query.tableNames));
     res.status(200).json(results);
   } catch (error) {
     logger.error(error);
@@ -235959,15 +235941,6 @@ app.post(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/sqlSo
     res.status(status).json(json2);
   }
 });
-app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/tableSource`, async (req, res) => {
-  try {
-    res.status(200).json(await connectionController.getConnectionTableSource(req.params.projectName, req.params.connectionName, req.query.tableKey, req.query.tablePath));
-  } catch (error) {
-    logger.error(error);
-    const { json: json2, status } = internalErrorToHttpError(error);
-    res.status(status).json(json2);
-  }
-});
 app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/queryData`, async (req, res) => {
   try {
     res.status(200).json(await connectionController.getConnectionQueryData(req.params.projectName, req.params.connectionName, req.query.sqlStatement, req.query.options));