@malloy-publisher/server 0.0.114 → 0.0.116

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@malloy-publisher/server",
   "description": "Malloy Publisher Server",
-  "version": "0.0.114",
+  "version": "0.0.116",
   "main": "dist/server.js",
   "bin": {
     "malloy-publisher": "dist/server.js"
@@ -54,6 +54,7 @@
     "node-cron": "^3.0.3",
     "recursive-readdir": "^2.2.3",
     "simple-git": "^3.28.0",
+    "trino": "^1.1.1",
     "uuid": "^11.0.3"
   },
   "devDependencies": {

package/src/service/connection.ts

@@ -50,6 +50,40 @@ export async function readConnectionConfig(
    return convertConnectionsToApiConnections(connections);
 }
 
+function validateAndBuildTrinoConfig(
+   trinoConfig: components["schemas"]["TrinoConnection"],
+) {
+   if (!trinoConfig.server?.includes(trinoConfig.port?.toString() || "")) {
+      trinoConfig.server = `${trinoConfig.server}:${trinoConfig.port}`;
+   }
+
+   if (trinoConfig.server?.startsWith("http://")) {
+      return {
+         server: trinoConfig.server,
+         port: trinoConfig.port,
+         catalog: trinoConfig.catalog,
+         schema: trinoConfig.schema,
+         user: trinoConfig.user,
+      };
+   } else if (
+      trinoConfig.server?.startsWith("https://") &&
+      trinoConfig.password
+   ) {
+      return {
+         server: trinoConfig.server,
+         port: trinoConfig.port,
+         catalog: trinoConfig.catalog,
+         schema: trinoConfig.schema,
+         user: trinoConfig.user,
+         password: trinoConfig.password,
+      };
+   } else {
+      throw new Error(
+         `Invalid Trino connection: expected "http://server:port" (no password) or "https://server:port" (with username and password).`,
+      );
+   }
+}
+
 export async function createConnections(
    basePath: string,
    defaultConnections: ApiConnection[] = [],
@@ -201,6 +235,7 @@ export async function createConnections(
                   warehouse: connection.snowflakeConnection.warehouse,
                   database: connection.snowflakeConnection.database,
                   schema: connection.snowflakeConnection.schema,
+                  role: connection.snowflakeConnection.role,
                   timeout:
                      connection.snowflakeConnection.responseTimeoutMilliseconds,
                },
@@ -219,14 +254,10 @@ export async function createConnections(
             if (!connection.trinoConnection) {
                throw new Error("Trino connection configuration is missing.");
             }
-            const trinoConnectionOptions = {
-               server: connection.trinoConnection.server,
-               port: connection.trinoConnection.port,
-               catalog: connection.trinoConnection.catalog,
-               schema: connection.trinoConnection.schema,
-               user: connection.trinoConnection.user,
-               password: connection.trinoConnection.password,
-            };
+
+            const trinoConnectionOptions = validateAndBuildTrinoConfig(
+               connection.trinoConnection,
+            );
             const trinoConnection = new TrinoConnection(
                connection.name,
                {},
@@ -356,6 +387,7 @@ export async function testConnectionConfig(
                warehouse: snowflakeConfig.warehouse,
                database: snowflakeConfig.database,
                schema: snowflakeConfig.schema,
+               role: snowflakeConfig.role,
                timeout: snowflakeConfig.responseTimeoutMilliseconds,
             },
          };
@@ -460,18 +492,12 @@ export async function testConnectionConfig(
             !trinoConfig.user
          ) {
             throw new Error(
-               "Trino connection requires: server, port, catalog, schema, and user",
+               "Trino connection requires server, port, catalog, schema, and user",
             );
          }
 
-         const trinoConnectionOptions = {
-            server: trinoConfig.server,
-            port: trinoConfig.port,
-            catalog: trinoConfig.catalog,
-            schema: trinoConfig.schema,
-            user: trinoConfig.user,
-            password: trinoConfig.password,
-         };
+         const trinoConnectionOptions =
+            validateAndBuildTrinoConfig(trinoConfig);
          const trinoConnection = new TrinoConnection(
             "testConnection",
             {},
@@ -495,6 +521,52 @@ export async function testConnectionConfig(
          break;
       }
 
+      case "mysql": {
+         if (!connectionConfig.mysqlConnection) {
+            throw new Error("MySQL connection configuration is missing.");
+         }
+
+         if (
+            !connectionConfig.mysqlConnection.host ||
+            !connectionConfig.mysqlConnection.port ||
+            !connectionConfig.mysqlConnection.user ||
+            !connectionConfig.mysqlConnection.password ||
+            !connectionConfig.mysqlConnection.database
+         ) {
+            throw new Error(
+               "MySQL connection requires: host, port, user, password, and database",
+            );
+         }
+
+         const mysqlConfig = connectionConfig.mysqlConnection;
+         const mysqlConnectionOptions = {
+            host: mysqlConfig.host,
+            port: mysqlConfig.port,
+            user: mysqlConfig.user,
+            password: mysqlConfig.password,
+            database: mysqlConfig.database,
+         };
+         const mysqlConnection = new MySQLConnection(
+            "testConnection",
+            mysqlConnectionOptions,
+         );
+         try {
+            await mysqlConnection.test();
+            testResult = { status: "ok" };
+         } catch (error) {
+            if (error instanceof AxiosError) {
+               logAxiosError(error);
+            } else {
+               logger.error(error);
+            }
+            testResult = {
+               status: "failed",
+               errorMessage: (error as Error).message,
+            };
+         }
+         break;
+      }
+
       default:
          throw new BadRequestError(
             `Unsupported connection type: ${connectionConfig.type}`,

package/src/service/db_utils.ts

@@ -13,8 +13,11 @@ import {
    MysqlConnection,
    PostgresConnection,
    SnowflakeConnection,
+   TrinoConnection,
 } from "./model";
 
+import { BasicAuth, Trino } from "trino-client";
+
 type ApiSchemaName = components["schemas"]["SchemaName"];
 
 async function getPostgresConnection(
@@ -75,6 +78,7 @@ async function getSnowflakeConnection(
          password: apiSnowflakeConnection.password,
          database: apiSnowflakeConnection.database,
          warehouse: apiSnowflakeConnection.warehouse || undefined,
+         role: apiSnowflakeConnection.role || undefined,
       });
       connection.connect((err, conn) => {
          if (err) {
@@ -86,6 +90,24 @@ async function getSnowflakeConnection(
    });
 }
 
+function getTrinoClient(trinoConn: TrinoConnection) {
+   let auth: BasicAuth;
+   if (trinoConn.server?.startsWith("https://")) {
+      // HTTPS allows password authentication
+      auth = new BasicAuth(trinoConn?.user || "", trinoConn?.password || "");
+   } else {
+      // HTTP only allows username, no password for security
+      auth = new BasicAuth(trinoConn?.user || "");
+   }
+
+   return Trino.create({
+      server: trinoConn.server,
+      catalog: trinoConn.catalog,
+      schema: trinoConn.schema,
+      auth,
+   });
+}
+
 export async function getSchemasForConnection(
    connection: ApiConnection,
 ): Promise<ApiSchemaName[]> {
@@ -167,6 +189,27 @@ export async function getSchemasForConnection(
             }
          });
       }
+   } else if (connection.type === "trino") {
+      if (!connection.trinoConnection) {
+         throw new Error("Trino connection is required");
+      }
+      const client = getTrinoClient(connection.trinoConnection);
+      const result = await client.query(
+         `SHOW SCHEMAS FROM ${connection.trinoConnection.catalog}`,
+      );
+      const rows: string[] = [];
+      let next = await result.next();
+      while (!next.done) {
+         if (next.value.data) {
+            rows.push(...next.value.data.map((r: string[]) => r[0]));
+         }
+         next = await result.next();
+      }
+      return rows.map((r) => ({
+         name: r,
+         isHidden: false,
+         isDefault: r === connection.trinoConnection?.schema,
+      }));
    } else {
       throw new Error(`Unsupported connection type: ${connection.type}`);
    }
@@ -243,6 +286,24 @@ export async function getTablesForSchema(
             }
          });
       }
+   } else if (connection.type === "trino") {
+      if (!connection.trinoConnection) {
+         throw new Error("Trino connection is required");
+      }
+      const client = getTrinoClient(connection.trinoConnection);
+      const result = await client.query(
+         `SHOW TABLES FROM ${connection.trinoConnection.catalog}.${schemaName}`,
+      );
+
+      const rows: string[] = [];
+      let next = await result.next();
+      while (!next.done) {
+         if (next.value.data) {
+            rows.push(...next.value.data.map((r: string[]) => r[0]));
+         }
+         next = await result.next();
+      }
+      return rows;
    } else {
       // TODO(jjs) - implement
       return [];

package/src/service/model.ts

@@ -50,6 +50,7 @@ export type ApiConnection = components["schemas"]["Connection"];
 export type SnowflakeConnection = components["schemas"]["SnowflakeConnection"];
 export type PostgresConnection = components["schemas"]["PostgresConnection"];
 export type BigqueryConnection = components["schemas"]["BigqueryConnection"];
+export type TrinoConnection = components["schemas"]["TrinoConnection"];
 
 const MALLOY_VERSION = malloyPackage.version;
 

package/dist/app/assets/FormControlContext-Ccuzn_SP.js

@@ -1 +0,0 @@
-import{r as o}from"./index-BS_9W4Tt.js";const r=o.createContext(void 0);export{r as F};