@malloy-publisher/server 0.0.121 → 0.0.123

package/dist/server.js

@@ -131921,138 +131921,209 @@ function validateAndBuildTrinoConfig(trinoConfig) {
     throw new Error(`Invalid Trino connection: expected "http://server:port" (no password) or "https://server:port" (with username and password).`);
   }
 }
+async function installAndLoadExtension(connection, extensionName, fromCommunity = false) {
+  try {
+    const installCommand = fromCommunity ? `FORCE INSTALL '${extensionName}' FROM community;` : `INSTALL ${extensionName};`;
+    await connection.runSQL(installCommand);
+    logger2.info(`${extensionName} extension installed`);
+  } catch (error) {
+    logger2.info(`${extensionName} extension already installed or install skipped`, { error });
+  }
+  await connection.runSQL(`LOAD ${extensionName};`);
+  logger2.info(`${extensionName} extension loaded`);
+}
+async function isDatabaseAttached(connection, dbName) {
+  try {
+    const existingDatabases = await connection.runSQL("SHOW DATABASES");
+    const rows = Array.isArray(existingDatabases) ? existingDatabases : existingDatabases.rows || [];
+    logger2.debug(`Existing databases:`, rows);
+    return rows.some((row) => Object.values(row).some((value) => typeof value === "string" && value === dbName));
+  } catch (error) {
+    logger2.warn(`Failed to check existing databases:`, error);
+    return false;
+  }
+}
+function sanitizeSecretName(name) {
+  return `secret_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+}
+function escapeSQL(value) {
+  return value.replace(/'/g, "''");
+}
+function handleAlreadyAttachedError(error, dbName) {
+  if (error instanceof Error && error.message.includes("already exists")) {
+    logger2.info(`Database ${dbName} is already attached, skipping`);
+  } else {
+    throw error;
+  }
+}
+async function attachBigQuery(connection, attachedDb) {
+  if (!attachedDb.bigqueryConnection) {
+    throw new Error(`BigQuery connection configuration missing for: ${attachedDb.name}`);
+  }
+  const config = attachedDb.bigqueryConnection;
+  let projectId = config.defaultProjectId;
+  let serviceAccountJson;
+  if (config.serviceAccountKeyJson) {
+    const keyData = JSON.parse(config.serviceAccountKeyJson);
+    const requiredFields = [
+      "type",
+      "project_id",
+      "private_key",
+      "client_email"
+    ];
+    for (const field of requiredFields) {
+      if (!keyData[field]) {
+        throw new Error(`Invalid service account key: missing "${field}" field`);
+      }
+    }
+    if (keyData.type !== "service_account") {
+      throw new Error('Invalid service account key: incorrect "type" field');
+    }
+    projectId = keyData.project_id || config.defaultProjectId;
+    serviceAccountJson = config.serviceAccountKeyJson;
+    logger2.info(`Using service account: ${keyData.client_email}`);
+  }
+  if (!projectId || !serviceAccountJson) {
+    throw new Error(`BigQuery project_id and service account key required for: ${attachedDb.name}`);
+  }
+  await installAndLoadExtension(connection, "bigquery", true);
+  const secretName = sanitizeSecretName(`bigquery_${attachedDb.name}`);
+  const escapedJson = escapeSQL(serviceAccountJson);
+  const createSecretCommand = `
+      CREATE OR REPLACE SECRET ${secretName} (
+         TYPE BIGQUERY,
+         SCOPE 'bq://${projectId}',
+         SERVICE_ACCOUNT_JSON '${escapedJson}'
+      );
+   `;
+  await connection.runSQL(createSecretCommand);
+  logger2.info(`Created BigQuery secret: ${secretName} for project: ${projectId}`);
+  const attachCommand = `ATTACH 'project=${projectId}' AS ${attachedDb.name} (TYPE bigquery, READ_ONLY);`;
+  await connection.runSQL(attachCommand);
+  logger2.info(`Successfully attached BigQuery database: ${attachedDb.name}`);
+}
+async function attachSnowflake(connection, attachedDb) {
+  if (!attachedDb.snowflakeConnection) {
+    throw new Error(`Snowflake connection configuration missing for: ${attachedDb.name}`);
+  }
+  const config = attachedDb.snowflakeConnection;
+  const requiredFields = {
+    account: config.account,
+    username: config.username,
+    password: config.password
+  };
+  for (const [field, value] of Object.entries(requiredFields)) {
+    if (!value) {
+      throw new Error(`Snowflake ${field} is required for: ${attachedDb.name}`);
+    }
+  }
+  await installAndLoadExtension(connection, "snowflake", true);
+  try {
+    const version = await connection.runSQL("SELECT snowflake_version();");
+    logger2.info(`Snowflake ADBC driver verified with version:`, version.rows);
+  } catch (error) {
+    throw new Error(`Snowflake ADBC driver verification failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const params = {
+    account: escapeSQL(config.account || ""),
+    user: escapeSQL(config.username || ""),
+    password: escapeSQL(config.password || ""),
+    database: config.database ? escapeSQL(config.database) : undefined,
+    warehouse: config.warehouse ? escapeSQL(config.warehouse) : undefined,
+    schema: config.schema ? escapeSQL(config.schema) : undefined,
+    role: config.role ? escapeSQL(config.role) : undefined
+  };
+  const attachParts = [
+    `account=${params.account}`,
+    `user=${params.user}`,
+    `password=${params.password}`
+  ];
+  if (params.database)
+    attachParts.push(`database=${params.database}`);
+  if (params.warehouse)
+    attachParts.push(`warehouse=${params.warehouse}`);
+  const secretString = `CREATE OR REPLACE SECRET ${attachedDb.name}_secret (
+      TYPE snowflake,
+      ACCOUNT '${params.account}',
+      USER '${params.user}',
+      PASSWORD '${params.password}',
+      DATABASE '${params.database}',
+      WAREHOUSE '${params.warehouse}'
+   );`;
+  await connection.runSQL(secretString);
+  const testresult = await connection.runSQL(`SELECT * FROM snowflake_scan('SELECT 1', '${attachedDb.name}_secret');`);
+  logger2.info(`Testing Snowflake connection:`, testresult.rows);
+  const attachCommand = `ATTACH '${attachedDb.name}' AS ${attachedDb.name} (TYPE snowflake, SECRET ${attachedDb.name}_secret, READ_ONLY);`;
+  await connection.runSQL(attachCommand);
+  logger2.info(`Successfully attached Snowflake database: ${attachedDb.name}`);
+}
+async function attachPostgres(connection, attachedDb) {
+  if (!attachedDb.postgresConnection) {
+    throw new Error(`PostgreSQL connection configuration missing for: ${attachedDb.name}`);
+  }
+  await installAndLoadExtension(connection, "postgres");
+  const config = attachedDb.postgresConnection;
+  let attachString;
+  if (config.connectionString) {
+    attachString = config.connectionString;
+  } else {
+    const parts = [];
+    if (config.host)
+      parts.push(`host=${config.host}`);
+    if (config.port)
+      parts.push(`port=${config.port}`);
+    if (config.databaseName)
+      parts.push(`dbname=${config.databaseName}`);
+    if (config.userName)
+      parts.push(`user=${config.userName}`);
+    if (config.password)
+      parts.push(`password=${config.password}`);
+    attachString = parts.join(" ");
+  }
+  const attachCommand = `ATTACH '${attachString}' AS ${attachedDb.name} (TYPE postgres, READ_ONLY);`;
+  await connection.runSQL(attachCommand);
+  logger2.info(`Successfully attached PostgreSQL database: ${attachedDb.name}`);
+}
+async function attachMotherDuck(connection, attachedDb) {
+  if (!attachedDb.motherDuckConnection) {
+    throw new Error(`MotherDuck connection configuration missing for: ${attachedDb.name}`);
+  }
+  const config = attachedDb.motherDuckConnection;
+  if (!config.database) {
+    throw new Error(`MotherDuck database name is required for: ${attachedDb.name}`);
+  }
+  await installAndLoadExtension(connection, "motherduck");
+  if (config.accessToken) {
+    const escapedToken = escapeSQL(config.accessToken);
+    await connection.runSQL(`SET motherduck_token = '${escapedToken}';`);
+  }
+  const connectionString = `md:${config.database}`;
+  logger2.info(`Connecting to MotherDuck database: ${config.database} as ${attachedDb.name}`);
+  const attachCommand = `ATTACH '${connectionString}' AS ${attachedDb.name} (TYPE motherduck, READ_ONLY);`;
+  await connection.runSQL(attachCommand);
+  logger2.info(`Successfully attached MotherDuck database: ${attachedDb.name}`);
+}
 async function attachDatabasesToDuckDB(duckdbConnection, attachedDatabases) {
+  const attachHandlers = {
+    bigquery: attachBigQuery,
+    snowflake: attachSnowflake,
+    postgres: attachPostgres,
+    motherduck: attachMotherDuck
+  };
   for (const attachedDb of attachedDatabases) {
     try {
+      if (await isDatabaseAttached(duckdbConnection, attachedDb.name || "")) {
+        logger2.info(`Database ${attachedDb.name} is already attached, skipping`);
+        continue;
+      }
+      const handler = attachHandlers[attachedDb.type];
+      if (!handler) {
+        throw new Error(`Unsupported database type: ${attachedDb.type}`);
+      }
       try {
-        const checkQuery = `SHOW DATABASES`;
-        const existingDatabases = await duckdbConnection.runSQL(checkQuery);
-        const rows = Array.isArray(existingDatabases) ? existingDatabases : existingDatabases.rows || [];
-        logger2.debug(`Existing databases:`, rows);
-        const isAlreadyAttached = rows.some((row) => {
-          return Object.values(row).some((value) => typeof value === "string" && value === attachedDb.name);
-        });
-        if (isAlreadyAttached) {
-          logger2.info(`Database ${attachedDb.name} is already attached, skipping`);
-          continue;
-        }
-      } catch (error) {
-        logger2.warn(`Failed to check existing databases, proceeding with attachment:`, error);
-      }
-      switch (attachedDb.type) {
-        case "bigquery": {
-          if (!attachedDb.bigqueryConnection) {
-            throw new Error(`BigQuery connection configuration is missing for attached database: ${attachedDb.name}`);
-          }
-          await duckdbConnection.runSQL("INSTALL bigquery FROM community;");
-          await duckdbConnection.runSQL("LOAD bigquery;");
-          const bigqueryConfig = attachedDb.bigqueryConnection;
-          const attachParams = new URLSearchParams;
-          if (!bigqueryConfig.defaultProjectId) {
-            throw new Error(`BigQuery defaultProjectId is required for attached database: ${attachedDb.name}`);
-          }
-          attachParams.set("project", bigqueryConfig.defaultProjectId);
-          if (bigqueryConfig.serviceAccountKeyJson) {
-            const serviceAccountKeyPath = import_path2.default.join(TEMP_DIR_PATH, `duckdb-${attachedDb.name}-${v4_default()}-service-account-key.json`);
-            await import_promises.default.writeFile(serviceAccountKeyPath, bigqueryConfig.serviceAccountKeyJson);
-            attachParams.set("service_account_key", serviceAccountKeyPath);
-          }
-          const attachCommand = `ATTACH '${attachParams.toString()}' AS ${attachedDb.name} (TYPE bigquery, READ_ONLY);`;
-          try {
-            await duckdbConnection.runSQL(attachCommand);
-            logger2.info(`Successfully attached BigQuery database: ${attachedDb.name}`);
-          } catch (attachError) {
-            if (attachError instanceof Error && attachError.message && attachError.message.includes("already exists")) {
-              logger2.info(`BigQuery database ${attachedDb.name} is already attached, skipping`);
-            } else {
-              throw attachError;
-            }
-          }
-          break;
-        }
-        case "snowflake": {
-          if (!attachedDb.snowflakeConnection) {
-            throw new Error(`Snowflake connection configuration is missing for attached database: ${attachedDb.name}`);
-          }
-          await duckdbConnection.runSQL("INSTALL snowflake FROM community;");
-          await duckdbConnection.runSQL("LOAD snowflake;");
-          const snowflakeConfig = attachedDb.snowflakeConnection;
-          const attachParams = new URLSearchParams;
-          if (snowflakeConfig.account) {
-            attachParams.set("account", snowflakeConfig.account);
-          }
-          if (snowflakeConfig.username) {
-            attachParams.set("username", snowflakeConfig.username);
-          }
-          if (snowflakeConfig.password) {
-            attachParams.set("password", snowflakeConfig.password);
-          }
-          if (snowflakeConfig.database) {
-            attachParams.set("database", snowflakeConfig.database);
-          }
-          if (snowflakeConfig.warehouse) {
-            attachParams.set("warehouse", snowflakeConfig.warehouse);
-          }
-          if (snowflakeConfig.role) {
-            attachParams.set("role", snowflakeConfig.role);
-          }
-          const attachCommand = `ATTACH '${attachParams.toString()}' AS ${attachedDb.name} (TYPE snowflake, READ_ONLY);`;
-          try {
-            await duckdbConnection.runSQL(attachCommand);
-            logger2.info(`Successfully attached Snowflake database: ${attachedDb.name}`);
-          } catch (attachError) {
-            if (attachError instanceof Error && attachError.message && attachError.message.includes("already exists")) {
-              logger2.info(`Snowflake database ${attachedDb.name} is already attached, skipping`);
-            } else {
-              throw attachError;
-            }
-          }
-          break;
-        }
-        case "postgres": {
-          if (!attachedDb.postgresConnection) {
-            throw new Error(`PostgreSQL connection configuration is missing for attached database: ${attachedDb.name}`);
-          }
-          await duckdbConnection.runSQL("INSTALL postgres FROM community;");
-          await duckdbConnection.runSQL("LOAD postgres;");
-          const postgresConfig = attachedDb.postgresConnection;
-          let attachString;
-          if (postgresConfig.connectionString) {
-            attachString = postgresConfig.connectionString;
-          } else {
-            const params = new URLSearchParams;
-            if (postgresConfig.host) {
-              params.set("host", postgresConfig.host);
-            }
-            if (postgresConfig.port) {
-              params.set("port", postgresConfig.port.toString());
-            }
-            if (postgresConfig.databaseName) {
-              params.set("dbname", postgresConfig.databaseName);
-            }
-            if (postgresConfig.userName) {
-              params.set("user", postgresConfig.userName);
-            }
-            if (postgresConfig.password) {
-              params.set("password", postgresConfig.password);
-            }
-            attachString = params.toString();
-          }
-          const attachCommand = `ATTACH '${attachString}' AS ${attachedDb.name} (TYPE postgres, READ_ONLY);`;
-          try {
-            await duckdbConnection.runSQL(attachCommand);
-            logger2.info(`Successfully attached PostgreSQL database: ${attachedDb.name}`);
-          } catch (attachError) {
-            if (attachError instanceof Error && attachError.message && attachError.message.includes("already exists")) {
-              logger2.info(`PostgreSQL database ${attachedDb.name} is already attached, skipping`);
-            } else {
-              throw attachError;
-            }
-          }
-          break;
-        }
-        default:
-          throw new Error(`Unsupported attached database type: ${attachedDb.type}`);
+        await handler(duckdbConnection, attachedDb);
+      } catch (attachError) {
+        handleAlreadyAttachedError(attachError, attachedDb.name || "");
       }
     } catch (error) {
       logger2.error(`Failed to attach database ${attachedDb.name}:`, error);
@@ -132060,7 +132131,7 @@ async function attachDatabasesToDuckDB(duckdbConnection, attachedDatabases) {
     }
   }
 }
-async function createProjectConnections(connections = []) {
+async function createProjectConnections(connections = [], projectPath = "") {
   const connectionMap = new Map;
   const processedConnections = new Set;
   const apiConnections = [];
@@ -132177,6 +132248,15 @@ async function createProjectConnections(connections = []) {
         break;
       }
       case "duckdb": {
+        if (!connection.duckdbConnection) {
+          throw new Error("DuckDB connection configuration is missing.");
+        }
+        const duckdbConnection = new import_db_duckdb.DuckDBConnection(connection.name, ":memory:", projectPath);
+        if (connection.duckdbConnection.attachedDatabases && Array.isArray(connection.duckdbConnection.attachedDatabases) && connection.duckdbConnection.attachedDatabases.length > 0) {
+          await attachDatabasesToDuckDB(duckdbConnection, connection.duckdbConnection.attachedDatabases);
+        }
+        connectionMap.set(connection.name, duckdbConnection);
+        connection.attributes = getConnectionAttributes(duckdbConnection);
         break;
       }
       default: {
@@ -132255,6 +132335,12 @@ async function testConnectionConfig(connectionConfig) {
     if (!connectionConfig.name) {
       throw new Error("Connection name is required");
     }
+    if (connectionConfig.type === "duckdb") {
+      return {
+        status: "ok",
+        errorMessage: ""
+      };
+    }
     const { malloyConnections } = await createProjectConnections([connectionConfig]);
     const connection = malloyConnections.get(connectionConfig.name);
     if (!connection) {
@@ -132409,20 +132495,24 @@ async function getSchemasForConnection(connection, malloyConnection) {
       throw new Error("DuckDB connection is required");
     }
     try {
-      const result = await malloyConnection.runSQL("SELECT DISTINCT schema_name FROM information_schema.schemata ORDER BY schema_name");
+      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 = standardizeRunSQLResult(result);
-      const hasAttachedDatabases = connection.duckdbConnection?.attachedDatabases && Array.isArray(connection.duckdbConnection.attachedDatabases) && connection.duckdbConnection.attachedDatabases.length > 0;
       return rows.map((row) => {
         const typedRow = row;
-        let schemaName = typedRow.schema_name;
-        if (hasAttachedDatabases && schemaName !== "main") {
-          const attachedDbName = connection.duckdbConnection.attachedDatabases[0].name;
-          schemaName = `${attachedDbName}.${schemaName}`;
-        }
+        const schemaName = typedRow.schema_name;
+        const catalogName = typedRow.catalog_name;
         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) || ["md_information_schema", "system"].includes(catalogName),
+          isDefault: catalogName === "main"
         };
       });
     } catch (error) {
@@ -132469,7 +132559,13 @@ async function getConnectionTableSource(malloyConnection, tableKey, tablePath) {
     if (source === undefined) {
       throw new ConnectionError(`Table ${tablePath} not found`);
     }
+    if (!source || typeof source !== "object") {
+      throw new ConnectionError(`Invalid table source returned for ${tablePath}`);
+    }
     const malloyFields = source.fields;
+    if (!malloyFields || !Array.isArray(malloyFields)) {
+      throw new ConnectionError(`Table ${tablePath} has no fields or invalid field structure`);
+    }
     const fields = malloyFields.map((field) => {
       return {
         name: field.name,
@@ -132562,15 +132658,9 @@ async function listTablesForSchema(connection, schemaName, malloyConnection) {
       throw new Error("DuckDB connection is required");
     }
     try {
-      const hasAttachedDatabases = connection.duckdbConnection?.attachedDatabases && Array.isArray(connection.duckdbConnection.attachedDatabases) && connection.duckdbConnection.attachedDatabases.length > 0;
-      let actualSchemaName = schemaName;
-      if (hasAttachedDatabases && schemaName.includes(".")) {
-        const attachedDbName = connection.duckdbConnection.attachedDatabases[0].name;
-        if (schemaName.startsWith(`${attachedDbName}.`)) {
-          actualSchemaName = schemaName.substring(attachedDbName.length + 1);
-        }
-      }
-      const result = await malloyConnection.runSQL(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${actualSchemaName}' ORDER BY table_name`);
+      const catalogName = schemaName.split(".")[0];
+      schemaName = schemaName.split(".")[1];
+      const result = await malloyConnection.runSQL(`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);
       return rows.map((row) => {
         const typedRow = row;
@@ -132646,6 +132736,14 @@ class ConnectionController {
     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 tableSource = await getConnectionTableSource(malloyConnection, tablePath.split(".").pop(), tablePath);
+    return {
+      resource: tablePath,
+      columns: tableSource.columns
+    };
+  }
   async getConnectionQueryData(projectName, connectionName, sqlStatement, options) {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
     let runSQLOptions = {};
@@ -139333,7 +139431,7 @@ class Project {
     }
     if (payload.connections) {
       logger2.info(`Updating ${payload.connections.length} connections for project ${this.projectName}`);
-      const { malloyConnections, apiConnections } = await createProjectConnections(payload.connections);
+      const { malloyConnections, apiConnections } = await createProjectConnections(payload.connections, this.projectPath);
       this.malloyConnections = malloyConnections;
       this.apiConnections = apiConnections;
       logger2.info(`Successfully updated connections for project ${this.projectName}`, {
@@ -139349,7 +139447,7 @@ class Project {
       throw new ProjectNotFoundError(`Project path ${projectPath} not found`);
     }
     logger2.info(`Creating project with connection configuration`);
-    const { malloyConnections, apiConnections } = await createProjectConnections(connections);
+    const { malloyConnections, apiConnections } = await createProjectConnections(connections, projectPath);
     logger2.info(`Loaded ${malloyConnections.size + apiConnections.length} connections for project ${projectName}`, {
       malloyConnections,
       apiConnections
@@ -143863,7 +143961,7 @@ var executeQueryShape = {
   queryName: exports_external.string().optional().describe("Named query or view")
 };
 function registerExecuteQueryTool(mcpServer, projectStore) {
-  mcpServer.tool("malloy_executeQuery", "Executes a Malloy query (either ad-hoc or a named query/view defined in a model) against the specified model and returns the results as JSON.", executeQueryShape, async (params) => {
+  mcpServer.tool("malloy/executeQuery", "Executes a Malloy query (either ad-hoc or a named query/view defined in a model) against the specified model and returns the results as JSON.", executeQueryShape, async (params) => {
     const {
       projectName,
       packageName,
@@ -144263,6 +144361,18 @@ app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/schema
     res.status(status).json(json2);
   }
 });
+app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/schemas/:schemaName/tables/:tablePath`, async (req, res) => {
+  logger2.info("req.params", { params: req.params });
+  try {
+    const results = await connectionController.getTable(req.params.projectName, req.params.connectionName, req.params.schemaName, req.params.tablePath);
+    logger2.info("results", { results });
+    res.status(200).json(results);
+  } catch (error) {
+    logger2.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
 app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/sqlSource`, async (req, res) => {
   try {
     res.status(200).json(await connectionController.getConnectionSqlSource(req.params.projectName, req.params.connectionName, req.query.sqlStatement));
@@ -144299,7 +144409,7 @@ app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/queryD
     res.status(status).json(json2);
   }
 });
-app.post(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/queryData`, async (req, res) => {
+app.post(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/sqlQuery`, async (req, res) => {
   try {
     res.status(200).json(await connectionController.getConnectionQueryData(req.params.projectName, req.params.connectionName, req.body.sqlStatement, req.query.options));
   } catch (error) {
@@ -144317,7 +144427,7 @@ app.get(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/tempor
     res.status(status).json(json2);
   }
 });
-app.post(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/temporaryTable`, async (req, res) => {
+app.post(`${API_PREFIX2}/projects/:projectName/connections/:connectionName/sqlTemporaryTable`, async (req, res) => {
   try {
     res.status(200).json(await connectionController.getConnectionTemporaryTable(req.params.projectName, req.params.connectionName, req.body.sqlStatement));
   } catch (error) {

package/package.json

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

package/src/controller/connection.controller.ts

@@ -145,6 +145,29 @@ export class ConnectionController {
       return getConnectionTableSource(malloyConnection, tableKey, tablePath);
    }
 
+   public async getTable(
+      projectName: string,
+      connectionName: string,
+      _schemaName: string,
+      tablePath: string,
+   ): Promise<ApiTable> {
+      const malloyConnection = await this.getMalloyConnection(
+         projectName,
+         connectionName,
+      );
+
+      const tableSource = await getConnectionTableSource(
+         malloyConnection,
+         tablePath.split(".").pop()!, // tableKey is the table name
+         tablePath,
+      );
+
+      return {
+         resource: tablePath,
+         columns: tableSource.columns,
+      };
+   }
+
    public async getConnectionQueryData(
       projectName: string,
       connectionName: string,

package/src/mcp/tools/execute_query_tool.ts

@@ -36,7 +36,7 @@ export function registerExecuteQueryTool(
    projectStore: ProjectStore,
 ): void {
    mcpServer.tool(
-      "malloy_executeQuery",
+      "malloy/executeQuery",
       "Executes a Malloy query (either ad-hoc or a named query/view defined in a model) against the specified model and returns the results as JSON.",
       executeQueryShape,
       /** Handles requests for the malloy/executeQuery tool */

package/src/server.ts

@@ -363,6 +363,27 @@ app.get(
    },
 );
 
+app.get(
+   `${API_PREFIX}/projects/:projectName/connections/:connectionName/schemas/:schemaName/tables/:tablePath`,
+   async (req, res) => {
+      logger.info("req.params", { params: req.params });
+      try {
+         const results = await connectionController.getTable(
+            req.params.projectName,
+            req.params.connectionName,
+            req.params.schemaName,
+            req.params.tablePath,
+         );
+         logger.info("results", { results });
+         res.status(200).json(results);
+      } catch (error) {
+         logger.error(error);
+         const { json, status } = internalErrorToHttpError(error as Error);
+         res.status(status).json(json);
+      }
+   },
+);
+
 /**
  * @deprecated Use /projects/:projectName/connections/:connectionName/sqlSource POST method instead
  */
@@ -448,7 +469,7 @@ app.get(
 );
 
 app.post(
-   `${API_PREFIX}/projects/:projectName/connections/:connectionName/queryData`,
+   `${API_PREFIX}/projects/:projectName/connections/:connectionName/sqlQuery`,
    async (req, res) => {
       try {
          res.status(200).json(
@@ -490,7 +511,7 @@ app.get(
 );
 
 app.post(
-   `${API_PREFIX}/projects/:projectName/connections/:connectionName/temporaryTable`,
+   `${API_PREFIX}/projects/:projectName/connections/:connectionName/sqlTemporaryTable`,
    async (req, res) => {
       try {
          res.status(200).json(