@malloy-publisher/server 0.0.75 → 0.0.77

package/src/mcp/tools/execute_query_tool.ts

@@ -1,8 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-   McpError,
-   ErrorCode,
-} from "@modelcontextprotocol/sdk/types.js";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { ProjectStore } from "../../service/project_store";
 import { getModelForQuery } from "../handler_utils";
@@ -13,16 +10,23 @@ import { buildMalloyUri } from "../handler_utils";
 // Zod shape defining required/optional params for executeQuery
 const executeQueryShape = {
    // projectName is required; other fields mirror SDK expectations
-   projectName: z.string().describe("Project name"),
-   packageName: z.string().describe("Package containing the model"),
+   projectName: z
+      .string()
+      .describe(
+         "Project name. Project names are listed in the malloy resource list.",
+      ),
+   packageName: z
+      .string()
+      .describe(
+         "Package containing the model. Package names are listed in the malloy resource list.",
+      ),
    modelPath: z.string().describe("Path to the .malloy model file"),
    query: z.string().optional().describe("Ad-hoc Malloy query code"),
    sourceName: z.string().optional().describe("Source name for a view"),
    queryName: z.string().optional().describe("Named query or view"),
 };
 
-// Infer the type from the Zod shape for use in the handler
-type ExecuteQueryParams = z.infer<z.ZodObject<typeof executeQueryShape>>;
+// Type inference is handled automatically by the MCP server based on the executeQueryShape
 
 /**
  * Registers the malloy/executeQuery tool with the MCP server.
@@ -32,11 +36,11 @@ 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 */
-      async (params: ExecuteQueryParams) => {
+      async (params) => {
          // Destructure projectName as well
          const {
             projectName,

package/src/service/connection.ts

@@ -2,6 +2,7 @@ import { PostgresConnection } from "@malloydata/db-postgres";
 import { BigQueryConnection } from "@malloydata/db-bigquery";
 import { SnowflakeConnection } from "@malloydata/db-snowflake";
 import { TrinoConnection } from "@malloydata/db-trino";
+import { MySQLConnection } from "@malloydata/db-mysql";
 import { v4 as uuidv4 } from "uuid";
 import { Connection } from "@malloydata/malloy";
 import { components } from "../api";
@@ -20,6 +21,7 @@ export type InternalConnection = ApiConnection & {
    bigqueryConnection?: components["schemas"]["BigqueryConnection"];
    snowflakeConnection?: components["schemas"]["SnowflakeConnection"];
    trinoConnection?: components["schemas"]["TrinoConnection"];
+   mysqlConnection?: components["schemas"]["MysqlConnection"];
 };
 
 export async function readConnectionConfig(
@@ -82,6 +84,26 @@ export async function createConnections(basePath: string): Promise<{
                break;
             }
 
+            case "mysql": {
+               if (!connection.mysqlConnection) {
+                  throw "Invalid connection configuration.  No mysql connection.";
+               }
+               const config = {
+                  host: connection.mysqlConnection.host,
+                  port: connection.mysqlConnection.port,
+                  username: connection.mysqlConnection.user,
+                  password: connection.mysqlConnection.password,
+                  database: connection.mysqlConnection.database,
+               };
+               const mysqlConnection = new MySQLConnection(
+                  connection.name,
+                  config,
+               );
+               connectionMap.set(connection.name, mysqlConnection);
+               connection.attributes = getConnectionAttributes(mysqlConnection);
+               break;
+            }
+
             case "bigquery": {
                if (!connection.bigqueryConnection) {
                   throw "Invalid connection configuration.  No bigquery connection.";
@@ -209,10 +231,16 @@ export async function createConnections(basePath: string): Promise<{
 function getConnectionAttributes(
    connection: Connection,
 ): ApiConnectionAttributes {
+   let canStream = false;
+   try {
+      canStream = connection.canStream();
+   } catch {
+      // pass
+   }
    return {
       dialectName: connection.dialectName,
       isPool: connection.isPool(),
       canPersist: connection.canPersist(),
-      canStream: connection.canStream(),
+      canStream: canStream,
    };
 }

package/src/service/db_utils.ts

@@ -9,6 +9,7 @@ import {
    ApiConnection,
    PostgresConnection,
    SnowflakeConnection,
+   MysqlConnection,
 } from "./model";
 import { components } from "../api";
 
@@ -28,6 +29,21 @@ async function getPostgresConnection(
    });
 }
 
+async function getMysqlConnection(apiMysqlConnection: MysqlConnection) {
+   // Dynamically import mysql2/promise to avoid import issues if not needed
+   const mysql = await import("mysql2/promise");
+   return mysql.createPool({
+      host: apiMysqlConnection.host,
+      port: apiMysqlConnection.port,
+      user: apiMysqlConnection.user,
+      password: apiMysqlConnection.password,
+      database: apiMysqlConnection.database,
+      waitForConnections: true,
+      connectionLimit: 10,
+      queueLimit: 0,
+   });
+}
+
 function getBigqueryConnection(apiConnection: ApiConnection): BigQuery {
    if (!apiConnection.bigqueryConnection?.serviceAccountKeyJson) {
       // Use default credentials
@@ -74,22 +90,32 @@ export async function getSchemasForConnection(
       if (!connection.bigqueryConnection) {
          throw new Error("BigQuery connection is required");
       }
-      const bigquery = getBigqueryConnection(connection);
-      // Set the projectId if it's provided in the bigqueryConnection
-      const [datasets] = await bigquery.getDatasets({
-         ...(connection.bigqueryConnection.defaultProjectId
-            ? { projectId: connection.bigqueryConnection.defaultProjectId }
-            : {}),
-      });
-      return datasets
-         .filter((dataset) => dataset.id)
-         .map((dataset) => {
-            return {
-               name: dataset.id,
-               isHidden: false,
-               isDefault: false,
-            };
+      try {
+         const bigquery = getBigqueryConnection(connection);
+         // Set the projectId if it's provided in the bigqueryConnection
+         const [datasets] = await bigquery.getDatasets({
+            ...(connection.bigqueryConnection.defaultProjectId
+               ? { projectId: connection.bigqueryConnection.defaultProjectId }
+               : {}),
          });
+         return datasets
+            .filter((dataset) => dataset.id)
+            .map((dataset) => {
+               return {
+                  name: dataset.id,
+                  isHidden: false,
+                  isDefault: false,
+               };
+            });
+      } 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 as Error).message}`,
+         );
+      }
    } else if (connection.type === "postgres") {
       if (!connection.postgresConnection) {
          throw new Error("Postgres connection is required");
@@ -107,6 +133,17 @@ export async function getSchemasForConnection(
             isDefault: row.schema_name === "public",
          };
       });
+   } else if (connection.type === "mysql") {
+      if (!connection.mysqlConnection) {
+         throw new Error("Mysql connection is required");
+      }
+      return [
+         {
+            name: connection.mysqlConnection.database || "mysql",
+            isHidden: false,
+            isDefault: true,
+         },
+      ];
    } else if (connection.type === "snowflake") {
       if (!connection.snowflakeConnection) {
          throw new Error("Snowflake connection is required");
@@ -133,8 +170,8 @@ export async function getTablesForSchema(
    schemaName: string,
 ): Promise<string[]> {
    if (connection.type === "bigquery") {
-      const bigquery = getBigqueryConnection(connection);
       try {
+         const bigquery = getBigqueryConnection(connection);
          const options = connection.bigqueryConnection?.defaultProjectId
             ? {
                  projectId: connection.bigqueryConnection?.defaultProjectId,
@@ -151,11 +188,24 @@ export async function getTablesForSchema(
          const [tables] = await dataset.getTables();
          return tables.map((table) => table.id).filter((id) => id) as string[];
       } catch (error) {
-         console.error(`Error getting tables for schema ${schemaName}`, error);
-         throw new Error(`Error getting tables for schema ${schemaName}`, {
-            cause: error,
-         });
+         console.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 as Error).message}`,
+         );
+      }
+   } else if (connection.type === "mysql") {
+      if (!connection.mysqlConnection) {
+         throw new Error("Mysql connection is required");
       }
+      const pool = await getMysqlConnection(connection.mysqlConnection);
+      const [rows] = await pool.query(
+         "SELECT TABLE_NAME FROM information_schema.tables WHERE table_schema = ? AND table_type = 'BASE TABLE'",
+         [schemaName],
+      );
+      return (rows as { TABLE_NAME: string }[]).map((row) => row.TABLE_NAME);
    } else if (connection.type === "postgres") {
       if (!connection.postgresConnection) {
          throw new Error("Postgres connection is required");

package/src/service/model.ts

@@ -633,4 +633,15 @@ export class Model {
    public getModelType(): ModelType {
       return this.modelType;
    }
+
+   public async getFileText(packagePath: string): Promise<string> {
+      const fullPath = path.join(packagePath, this.modelPath);
+      try {
+         return await fs.readFile(fullPath, "utf8");
+      } catch {
+         throw new ModelNotFoundError(
+            `Model file not found: ${this.modelPath}`,
+         );
+      }
+   }
 }

package/src/service/package.spec.ts

@@ -47,7 +47,9 @@ describe("service/package", () => {
    it("should create a package instance", async () => {
       // Using 'as any' for simplified mock Map value in test
       const pkg = new Package(
+         "testProject",
          "testPackage",
+         testPackageDirectory,
          { name: "testPackage", description: "Test package" },
          [],
          new Map([
@@ -133,6 +135,7 @@ describe("service/package", () => {
             const packageInstance = new Package(
                "testProject",
                "testPackage",
+               testPackageDirectory,
                { name: "testPackage", description: "Test package" },
                [],
                new Map([

package/src/service/package.ts

@@ -37,6 +37,7 @@ export class Package {
    private databases: ApiDatabase[];
    private models: Map<string, Model> = new Map();
    private scheduler: Scheduler | undefined;
+   private packagePath: string;
    private static meter = metrics.getMeter("publisher");
    private static packageLoadHistogram = this.meter.createHistogram(
       "malloy_package_load_duration",
@@ -49,6 +50,7 @@ export class Package {
    constructor(
       projectName: string,
       packageName: string,
+      packagePath: string,
       packageMetadata: ApiPackage,
       databases: ApiDatabase[],
       models: Map<string, Model>,
@@ -56,6 +58,7 @@ export class Package {
    ) {
       this.projectName = projectName;
       this.packageName = packageName;
+      this.packagePath = packagePath;
       this.packageMetadata = packageMetadata;
       this.databases = databases;
       this.models = models;
@@ -106,6 +109,7 @@ export class Package {
          return new Package(
             projectName,
             packageName,
+            packagePath,
             packageConfig,
             databases,
             models,
@@ -143,6 +147,14 @@ export class Package {
       return this.models.get(modelPath);
    }
 
+   public async getModelFileText(modelPath: string): Promise<string> {
+      const model = this.getModel(modelPath);
+      if (!model) {
+         throw new Error(`Model not found: ${modelPath}`);
+      }
+      return await model.getFileText(this.packagePath);
+   }
+
    public async listModels(): Promise<ApiModel[]> {
       const values = await Promise.all(
          Array.from(this.models.keys())