@malloy-publisher/server 0.0.122 → 0.0.124

package/src/service/db_utils.ts

@@ -80,11 +80,20 @@ export async function getSchemasForConnection(
          const bigquery = createBigQueryClient(connection);
          const [datasets] = await bigquery.getDatasets();
 
-         return datasets.map((dataset) => ({
-            name: dataset.id,
-            isHidden: false,
-            isDefault: false,
-         }));
+         const schemas = await Promise.all(
+            datasets.map(async (dataset) => {
+               const [metadata] = await dataset.getMetadata();
+               return {
+                  name: dataset.id,
+                  isHidden: false,
+                  isDefault: false,
+                  // Include description from dataset metadata if available
+                  description: (metadata as { description?: string })
+                     ?.description,
+               };
+            }),
+         );
+         return schemas;
       } catch (error) {
          console.error(
             `Error getting schemas for BigQuery connection ${connection.name}:`,
@@ -213,35 +222,33 @@ export async function getSchemasForConnection(
          // Use DuckDB's INFORMATION_SCHEMA.SCHEMATA to list schemas
          // Use DISTINCT to avoid duplicates from attached databases
          const result = await malloyConnection.runSQL(
-            "SELECT DISTINCT schema_name FROM information_schema.schemata ORDER BY schema_name",
+            "SELECT DISTINCT schema_name,catalog_name FROM information_schema.schemata ORDER BY catalog_name,schema_name",
+            { rowLimit: 1000 },
          );
 
          const rows = standardizeRunSQLResult(result);
 
-         // Check if this DuckDB connection has attached databases
-         const hasAttachedDatabases =
-            connection.duckdbConnection?.attachedDatabases &&
-            Array.isArray(connection.duckdbConnection.attachedDatabases) &&
-            connection.duckdbConnection.attachedDatabases.length > 0;
-
          return rows.map((row: unknown) => {
             const typedRow = row as Record<string, unknown>;
-            let schemaName = typedRow.schema_name as string;
-
-            // If we have attached databases and this is not the main schema, prepend the attached database name
-            if (hasAttachedDatabases && schemaName !== "main") {
-               const attachedDbName = (
-                  connection.duckdbConnection!.attachedDatabases as Array<{
-                     name: string;
-                  }>
-               )[0].name;
-               schemaName = `${attachedDbName}.${schemaName}`;
-            }
+            const schemaName = typedRow.schema_name as string;
+            const catalogName = typedRow.catalog_name as string;
 
             return {
-               name: schemaName,
-               isHidden: false,
-               isDefault: typedRow.schema_name === "main",
+               name: `${catalogName}.${schemaName}`,
+               isHidden:
+                  [
+                     "information_schema",
+                     "performance_schema",
+                     "",
+                     "SNOWFLAKE",
+                     "information_schema",
+                     "pg_catalog",
+                     "pg_toast",
+                  ].includes(schemaName as string) ||
+                  ["md_information_schema", "system"].includes(
+                     catalogName as string,
+                  ),
+               isDefault: catalogName === "main",
             };
          });
       } catch (error) {
@@ -481,33 +488,11 @@ export async function listTablesForSchema(
          throw new Error("DuckDB connection is required");
       }
       try {
-         // Check if this DuckDB connection has attached databases and if the schema name is prepended
-         const hasAttachedDatabases =
-            connection.duckdbConnection?.attachedDatabases &&
-            Array.isArray(connection.duckdbConnection.attachedDatabases) &&
-            connection.duckdbConnection.attachedDatabases.length > 0;
-
-         let actualSchemaName = schemaName;
-
-         // If we have attached databases and the schema name is prepended, extract the actual schema name
-         if (hasAttachedDatabases && schemaName.includes(".")) {
-            const attachedDbName = (
-               connection.duckdbConnection!.attachedDatabases as Array<{
-                  name: string;
-               }>
-            )[0].name;
-            if (schemaName.startsWith(`${attachedDbName}.`)) {
-               actualSchemaName = schemaName.substring(
-                  attachedDbName.length + 1,
-               );
-            }
-         }
-
-         // Use DuckDB's INFORMATION_SCHEMA.TABLES to list tables in the specified schema
-         // This follows the DuckDB documentation for listing tables
-         // For DuckDB, we'll use string interpolation to avoid parameter binding issues
+         const catalogName = schemaName.split(".")[0];
+         schemaName = schemaName.split(".")[1];
          const result = await malloyConnection.runSQL(
-            `SELECT table_name FROM information_schema.tables WHERE table_schema = '${actualSchemaName}' ORDER BY table_name`,
+            `SELECT table_name FROM information_schema.tables WHERE table_schema = '${schemaName}' and table_catalog = '${catalogName}' ORDER BY table_name`,
+            { rowLimit: 1000 },
          );
 
          const rows = standardizeRunSQLResult(result);

package/src/service/project.ts

@@ -71,7 +71,10 @@ export class Project {
 
          // Reload connections with full config
          const { malloyConnections, apiConnections } =
-            await createProjectConnections(payload.connections);
+            await createProjectConnections(
+               payload.connections,
+               this.projectPath,
+            );
 
          // Update the project's connection maps
          this.malloyConnections = malloyConnections;
@@ -103,7 +106,7 @@ export class Project {
 
       logger.info(`Creating project with connection configuration`);
       const { malloyConnections, apiConnections } =
-         await createProjectConnections(connections);
+         await createProjectConnections(connections, projectPath);
 
       logger.info(
          `Loaded ${malloyConnections.size + apiConnections.length} connections for project ${projectName}`,

package/tests/integration/mcp/mcp_transport.integration.spec.ts

@@ -1,18 +1,18 @@
-import { describe, it, expect, beforeAll, afterAll } from "bun:test";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import {
    ErrorCode,
-   Request,
    Notification,
+   Request,
    Result,
 } from "@modelcontextprotocol/sdk/types.js";
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
 import { URL } from "url";
 
 // --- Import E2E Test Setup ---
 import {
+   cleanupE2ETestEnvironment,
    McpE2ETestEnvironment,
    setupE2ETestEnvironment,
-   cleanupE2ETestEnvironment,
 } from "../../harness/mcp_test_setup";
 
 // --- Test Suite ---
@@ -42,7 +42,7 @@ describe("MCP Transport Tests (E2E Integration)", () => {
             expect(result).toHaveProperty("resources");
             expect(Array.isArray(result.resources)).toBe(true);
          },
-         { timeout: 10000 },
+         { timeout: 15000 },
       );
 
       it("should receive InvalidParams error when calling a known method with invalid params", async () => {