@malloy-publisher/server 0.0.123 → 0.0.125

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@malloy-publisher/server",
   "description": "Malloy Publisher Server",
-  "version": "0.0.123",
+  "version": "0.0.125",
   "main": "dist/server.js",
   "bin": {
     "malloy-publisher": "dist/server.js"
@@ -23,15 +23,15 @@
   },
   "dependencies": {
     "@google-cloud/storage": "^7.16.0",
-    "@malloydata/db-bigquery": "^0.0.310",
-    "@malloydata/db-duckdb": "^0.0.310",
-    "@malloydata/db-mysql": "^0.0.310",
-    "@malloydata/db-postgres": "^0.0.310",
-    "@malloydata/db-snowflake": "^0.0.310",
-    "@malloydata/db-trino": "^0.0.310",
-    "@malloydata/malloy": "^0.0.310",
-    "@malloydata/malloy-sql": "^0.0.310",
-    "@malloydata/render": "^0.0.310",
+    "@malloydata/db-bigquery": "^0.0.318",
+    "@malloydata/db-duckdb": "^0.0.318",
+    "@malloydata/db-mysql": "^0.0.318",
+    "@malloydata/db-postgres": "^0.0.318",
+    "@malloydata/db-snowflake": "^0.0.318",
+    "@malloydata/db-trino": "^0.0.318",
+    "@malloydata/malloy": "^0.0.318",
+    "@malloydata/malloy-sql": "^0.0.318",
+    "@malloydata/render": "^0.0.318",
     "@modelcontextprotocol/sdk": "^1.13.2",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-node": "^0.57.0",

package/src/controller/connection.controller.ts

@@ -40,9 +40,7 @@ export class ConnectionController {
       if (connection.type === "duckdb") {
          const packages = await project.listPackages();
          if (packages.length === 0) {
-            throw new ConnectionError(
-               "No packages found for DuckDB connection",
-            );
+            return project.getMalloyConnection(connectionName);
          }
          // For now, use the first package's DuckDB connection
          const packageName = packages[0].name;
@@ -165,6 +163,7 @@ export class ConnectionController {
       return {
          resource: tablePath,
          columns: tableSource.columns,
+         source: tableSource.source,
       };
    }
 

package/src/service/connection.ts

@@ -301,6 +301,7 @@ async function attachPostgres(
       if (config.databaseName) parts.push(`dbname=${config.databaseName}`);
       if (config.userName) parts.push(`user=${config.userName}`);
       if (config.password) parts.push(`password=${config.password}`);
+      if (process.env.PGSSLMODE === "no-verify") parts.push(`sslmode=disable`);
       attachString = parts.join(" ");
    }
 
@@ -309,42 +310,6 @@ async function attachPostgres(
    logger.info(`Successfully attached PostgreSQL database: ${attachedDb.name}`);
 }
 
-async function attachMotherDuck(
-   connection: DuckDBConnection,
-   attachedDb: AttachedDatabase,
-): Promise<void> {
-   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");
-
-   // Set token if provided
-   if (config.accessToken) {
-      const escapedToken = escapeSQL(config.accessToken);
-      await connection.runSQL(`SET motherduck_token = '${escapedToken}';`);
-   }
-
-   const connectionString = `md:${config.database}`;
-   logger.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);
-   logger.info(`Successfully attached MotherDuck database: ${attachedDb.name}`);
-}
-
 // Main attachment function
 async function attachDatabasesToDuckDB(
    duckdbConnection: DuckDBConnection,
@@ -354,7 +319,6 @@ async function attachDatabasesToDuckDB(
       bigquery: attachBigQuery,
       snowflake: attachSnowflake,
       postgres: attachPostgres,
-      motherduck: attachMotherDuck,
    };
 
    for (const attachedDb of attachedDatabases) {
@@ -595,6 +559,37 @@ export async function createProjectConnections(
             break;
          }
 
+         case "motherduck": {
+            if (!connection.motherduckConnection) {
+               throw new Error(
+                  "MotherDuck connection configuration is missing.",
+               );
+            }
+
+            if (!connection.motherduckConnection.accessToken) {
+               throw new Error("MotherDuck access token is required.");
+            }
+
+            let databasePath = `md:`;
+            // Build the MotherDuck database path
+            if (connection.motherduckConnection.database) {
+               databasePath = `md:${connection.motherduckConnection.database}?attach_mode=single`;
+            }
+
+            // Create MotherDuck connection using DuckDBConnectionOptions interface
+            const motherduckConnection = new DuckDBConnection({
+               name: connection.name,
+               databasePath: databasePath,
+               motherDuckToken: connection.motherduckConnection.accessToken,
+               workingDirectory: projectPath,
+            });
+
+            connectionMap.set(connection.name, motherduckConnection);
+            connection.attributes =
+               getConnectionAttributes(motherduckConnection);
+            break;
+         }
+
          default: {
             throw new Error(`Unsupported connection type: ${connection.type}`);
          }
@@ -737,12 +732,6 @@ export async function testConnectionConfig(
 
       // Use createProjectConnections to create the connection, then test it
       // TODO: Test duckdb connections?
-      if (connectionConfig.type === "duckdb") {
-         return {
-            status: "ok",
-            errorMessage: "",
-         };
-      }
 
       const { malloyConnections } = await createProjectConnections(
          [connectionConfig], // Pass the single connection config

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}:`,
@@ -251,6 +260,39 @@ export async function getSchemasForConnection(
             `Failed to get schemas for DuckDB connection ${connection.name}: ${(error as Error).message}`,
          );
       }
+   } else if (connection.type === "motherduck") {
+      if (!connection.motherduckConnection) {
+         throw new Error("MotherDuck connection is required");
+      }
+      try {
+         // Use MotherDuck's INFORMATION_SCHEMA.SCHEMATA to list schemas
+         const result = await malloyConnection.runSQL(
+            "SELECT DISTINCT schema_name as row FROM information_schema.schemata ORDER BY schema_name",
+            { rowLimit: 1000 },
+         );
+         const rows = standardizeRunSQLResult(result);
+         console.log(rows);
+         return rows.map((row: unknown) => {
+            const typedRow = row as { row: string };
+            return {
+               name: typedRow.row,
+               isHidden: [
+                  "information_schema",
+                  "performance_schema",
+                  "",
+               ].includes(typedRow.row),
+               isDefault: false,
+            };
+         });
+      } catch (error) {
+         console.error(
+            `Error getting schemas for MotherDuck connection ${connection.name}:`,
+            error,
+         );
+         throw new Error(
+            `Failed to get schemas for MotherDuck connection ${connection.name}: ${(error as Error).message}`,
+         );
+      }
    } else {
       throw new Error(`Unsupported connection type: ${connection.type}`);
    }
@@ -500,8 +542,30 @@ export async function listTablesForSchema(
             `Failed to get tables for DuckDB schema ${schemaName} in connection ${connection.name}: ${(error as Error).message}`,
          );
       }
+   } else if (connection.type === "motherduck") {
+      if (!connection.motherduckConnection) {
+         throw new Error("MotherDuck connection is required");
+      }
+      try {
+         const result = await malloyConnection.runSQL(
+            `SELECT table_name as row FROM information_schema.tables WHERE table_schema = '${schemaName}' ORDER BY table_name`,
+            { rowLimit: 1000 },
+         );
+         const rows = standardizeRunSQLResult(result);
+         return rows.map((row: unknown) => {
+            const typedRow = row as { row: string };
+            return typedRow.row;
+         });
+      } catch (error) {
+         logger.error(
+            `Error getting tables for MotherDuck schema ${schemaName} in connection ${connection.name}`,
+            { error },
+         );
+         throw new Error(
+            `Failed to get tables for MotherDuck schema ${schemaName} in connection ${connection.name}: ${(error as Error).message}`,
+         );
+      }
    } else {
-      // TODO(jjs) - implement
-      return [];
+      throw new Error(`Unsupported connection type: ${connection.type}`);
    }
 }