@malloy-publisher/server 0.0.75 → 0.0.76

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.75",
+   "version": "0.0.76",
    "main": "dist/server.js",
    "bin": {
       "malloy-publisher": "dist/server.js"
@@ -23,13 +23,14 @@
    "dependencies": {
       "@malloydata/db-bigquery": "^0.0.293",
       "@malloydata/db-duckdb": "^0.0.293",
+      "@malloydata/db-mysql": "^0.0.293",
       "@malloydata/db-postgres": "^0.0.293",
       "@malloydata/db-snowflake": "^0.0.293",
       "@malloydata/db-trino": "^0.0.293",
       "@malloydata/malloy": "^0.0.293",
       "@malloydata/malloy-sql": "^0.0.293",
       "@malloydata/render": "^0.0.293",
-      "@modelcontextprotocol/sdk": "^1.10.2",
+      "@modelcontextprotocol/sdk": "^1.13.2",
       "@opentelemetry/api": "^1.9.0",
       "@opentelemetry/auto-instrumentations-node": "^0.57.0",
       "@opentelemetry/sdk-metrics": "^2.0.0",
@@ -41,11 +42,11 @@
       "cors": "^2.8.5",
       "express": "^4.21.0",
       "globals": "^15.9.0",
+      "handlebars": "^4.7.8",
       "http-proxy-middleware": "^3.0.5",
       "morgan": "^1.10.0",
       "node-cron": "^3.0.3",
       "recursive-readdir": "^2.2.3",
-      "handlebars": "^4.7.8",
       "uuid": "^11.0.3"
    },
    "devDependencies": {

package/src/dto/connection.dto.spec.ts

@@ -7,10 +7,25 @@ import {
    ConnectionDto,
    PostgresConnectionDto,
    SnowflakeConnectionDto,
+   MysqlConnectionDto,
 } from "./connection.dto";
 
 describe("dto/connection", () => {
    describe("Connection Validation", () => {
+      it("should validate a valid MysqlConnection object", async () => {
+         const validData = {
+            host: "localhost",
+            port: 3306,
+            database: "testdb",
+            user: "user",
+            password: "pass",
+         };
+         const mysqlConnection = plainToInstance(MysqlConnectionDto, validData);
+
+         const errors = await validate(mysqlConnection);
+         expect(errors).toHaveLength(0);
+      });
+
       it("should validate a valid PostgresConnection object", async () => {
          const validData = {
             host: "localhost",

package/src/dto/connection.dto.ts

@@ -35,6 +35,28 @@ export class PostgresConnectionDto {
    connectionString?: string;
 }
 
+export class MysqlConnectionDto {
+   @IsOptional()
+   @IsString()
+   host?: string;
+
+   @IsOptional()
+   @IsNumber()
+   port?: number;
+
+   @IsOptional()
+   @IsString()
+   database?: string;
+
+   @IsOptional()
+   @IsString()
+   user?: string;
+
+   @IsOptional()
+   @IsString()
+   password?: string;
+}
+
 export class BigqueryConnectionDto {
    @IsOptional()
    @IsString()

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");