npm - @malloy-publisher/server - Versions diffs - 0.0.167 → 0.0.168 - Mend

@malloy-publisher/server 0.0.167 → 0.0.168

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

package/.eslintrc.json +9 -1
package/dist/app/api-doc.yaml +36 -1
package/dist/app/assets/HomePage-D2tUw_9U.js +1 -0
package/dist/app/assets/{MainPage-C9Fr5IN8.js → MainPage-DBQW76L7.js} +2 -2
package/dist/app/assets/{ModelPage-BkU6HAHA.js → ModelPage-BnfOKuhQ.js} +1 -1
package/dist/app/assets/PackagePage-zPhE-rDg.js +1 -0
package/dist/app/assets/ProjectPage-BpSTvuW6.js +1 -0
package/dist/app/assets/RouteError-Cp9-yCK5.js +1 -0
package/dist/app/assets/{WorkbookPage-D3rUQZj6.js → WorkbookPage-FD_gmxeE.js} +1 -1
package/dist/app/assets/{index-BLxl0XLH.js → index-D5QBYuLK.js} +150 -150
package/dist/app/assets/{index-lhDwptrQ.js → index-DNCvL_5f.js} +1 -1
package/dist/app/assets/{index-hkABoiMV.js → index-x9S1fsYn.js} +1 -1
package/dist/app/assets/{index.umd-BkXQ-YAe.js → index.umd-CTYdFEHH.js} +1 -1
package/dist/app/index.html +1 -1
package/dist/server.js +261 -27
package/package.json +1 -1
package/src/controller/connection.controller.ts +22 -2
package/src/server.ts +5 -1
package/src/service/connection.spec.ts +105 -0
package/src/service/connection.ts +293 -17
package/src/service/db_utils.ts +85 -4
package/src/service/project.ts +20 -3
package/tests/harness/mcp_test_setup.ts +166 -26
package/tests/unit/duckdb/attached_databases.test.ts +61 -3
package/tests/unit/ducklake/ducklake.test.ts +950 -0
package/dist/app/assets/HomePage-D76UaGFV.js +0 -1
package/dist/app/assets/PackagePage-BhE9Wi7b.js +0 -1
package/dist/app/assets/ProjectPage-BatZLVap.js +0 -1
package/dist/app/assets/RouteError-Bo5zJ8Xa.js +0 -1

package/dist/app/index.html CHANGED Viewed

@@ -12,7 +12,7 @@
          href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap"
       />
       <title>Malloy Publisher</title>
-     <script type="module" crossorigin src="/assets/index-BLxl0XLH.js"></script>
+     <script type="module" crossorigin src="/assets/index-D5QBYuLK.js"></script>
      <link rel="stylesheet" crossorigin href="/assets/index-CMlGQMcl.css">
    </head>
    <body>

package/dist/server.js CHANGED Viewed

@@ -219260,35 +219260,95 @@ async function attachSnowflake(connection, attachedDb) {
   await connection.runSQL(attachCommand);
   logger.info(`Successfully attached Snowflake database: ${attachedDb.name}`);
 }
+function buildPgConnectionString(pg) {
+  if (pg.connectionString) {
+    return pg.connectionString;
+  }
+  const parts = [];
+  if (pg.host)
+    parts.push(`host=${pg.host}`);
+  if (pg.port)
+    parts.push(`port=${pg.port}`);
+  if (pg.databaseName)
+    parts.push(`dbname=${pg.databaseName}`);
+  if (pg.userName)
+    parts.push(`user=${pg.userName}`);
+  if (pg.password)
+    parts.push(`password=${pg.password}`);
+  const pgSSLMode = process.env.PGSSLMODE;
+  if (pgSSLMode) {
+    const mapping = {
+      "no-verify": "disable",
+      disable: "disable",
+      allow: "allow",
+      prefer: "prefer",
+      require: "require",
+      "verify-ca": "verify-ca",
+      "verify-full": "verify-full"
+    };
+    const sslmode = mapping[pgSSLMode.toLowerCase()];
+    if (sslmode)
+      parts.push(`sslmode=${sslmode}`);
+  }
+  return parts.join(" ");
+}
 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}`);
-    if (process.env.PGSSLMODE === "no-verify")
-      parts.push(`sslmode=disable`);
-    attachString = parts.join(" ");
-  }
-  const attachCommand = `ATTACH '${attachString}' AS ${attachedDb.name} (TYPE postgres, READ_ONLY);`;
+  const attachString = buildPgConnectionString(config);
+  const attachCommand = `ATTACH '${escapeSQL(attachString)}' AS ${attachedDb.name} (TYPE postgres, READ_ONLY);`;
   await connection.runSQL(attachCommand);
   logger.info(`Successfully attached PostgreSQL database: ${attachedDb.name}`);
 }
+async function attachDuckLake(connection, dbName, ducklakeConfig) {
+  await installAndLoadExtension(connection, "ducklake");
+  await installAndLoadExtension(connection, "postgres");
+  await installAndLoadExtension(connection, "aws");
+  await installAndLoadExtension(connection, "httpfs");
+  if (!ducklakeConfig.catalog?.postgresConnection) {
+    throw new Error(`PostgreSQL connection configuration is required for DuckLake catalog: ${dbName}`);
+  }
+  if (!ducklakeConfig.storage?.bucketUrl) {
+    throw new Error(`Storage bucketUrl is required for DuckLake: ${dbName}`);
+  }
+  const hasS3 = !!ducklakeConfig.storage.s3Connection;
+  const hasGCS = !!ducklakeConfig.storage.gcsConnection;
+  if (hasS3) {
+    await attachCloudStorage(connection, {
+      name: `${dbName}_storage`,
+      type: "s3",
+      s3Connection: ducklakeConfig.storage.s3Connection
+    });
+  } else if (hasGCS) {
+    await attachCloudStorage(connection, {
+      name: `${dbName}_storage`,
+      type: "gcs",
+      gcsConnection: ducklakeConfig.storage.gcsConnection
+    });
+  }
+  const pg = ducklakeConfig.catalog.postgresConnection;
+  const pgConnString = buildPgConnectionString(pg);
+  logger.info(`pgConnString: ${pgConnString}`);
+  const escapedPgConnString = escapeSQL(pgConnString);
+  logger.info(`Final escaped connection string: ${escapedPgConnString}`);
+  const escapedBucketUrl = escapeSQL(ducklakeConfig.storage.bucketUrl);
+  logger.info(`escapedBucketUrl: ${escapedBucketUrl}`);
+  const attachCommand = `ATTACH OR REPLACE 'ducklake:postgres:${escapedPgConnString}' AS ${dbName} (DATA_PATH '${escapedBucketUrl}', OVERRIDE_DATA_PATH true, READ_ONLY true);`;
+  logger.info(`Attaching DuckLake database using command: ${attachCommand}`);
+  try {
+    await connection.runSQL(attachCommand);
+    logger.info(`Successfully attached DuckLake database in READ_ONLY mode: ${dbName}`);
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("already exists") || error.message.includes("already attached"))) {
+      logger.info(`DuckLake database ${dbName} is already attached, skipping`);
+    } else {
+      throw error;
+    }
+  }
+}
 async function attachCloudStorage(connection, attachedDb) {
   const isGCS = attachedDb.type === "gcs";
   const isS3 = attachedDb.type === "s3";
@@ -219374,10 +219434,23 @@ async function attachCloudStorage(connection, attachedDb) {
          `;
     }
   }
+  if (await doesSecretExistInDuckDB(connection, secretName)) {
+    await connection.runSQL(`DETACH ${attachedDb.name};`).catch(() => {});
+  }
   await connection.runSQL(createSecretCommand);
   logger.info(`Created ${storageType} secret: ${secretName}`);
   logger.info(`${storageType} connection configured for: ${attachedDb.name}`);
 }
+async function doesSecretExistInDuckDB(connection, secretName) {
+  const escapedSecretName = escapeSQL(secretName);
+  const result = await connection.runSQL(`
+     SELECT COUNT(*) AS count
+     FROM duckdb_secrets()
+     WHERE name = '${escapedSecretName}';
+   `);
+  const rows = result.rows;
+  return Number(rows?.[0]?.count ?? 0) > 0;
+}
 async function attachDatabasesToDuckDB(duckdbConnection, attachedDatabases) {
   const attachHandlers = {
     bigquery: attachBigQuery,
@@ -219407,7 +219480,53 @@ async function attachDatabasesToDuckDB(duckdbConnection, attachedDatabases) {
     }
   }
 }
-async function createProjectConnections(connections = [], projectPath = "") {
+class DuckLakeConnection extends import_db_duckdb.DuckDBConnection {
+  connectionName;
+  constructor(connectionName, databasePath, workingDirectory) {
+    super(connectionName, databasePath, workingDirectory);
+    if (!databasePath.endsWith("_ducklake.duckdb")) {
+      throw new Error(`DuckLakeConnection should only be used for DuckLake connections. ` + `Expected database path ending with '_ducklake.duckdb', got: ${databasePath}`);
+    }
+    this.connectionName = connectionName;
+  }
+  async fetchTableSchema(tableKey, tablePath) {
+    const parts = tablePath.split(".");
+    if (!tablePath.startsWith(this.connectionName) && (parts.length === 1 || parts.length === 2)) {
+      const prefixedPath = `${this.connectionName}.${tablePath}`;
+      logger.debug("Prefixing DuckLake table path", {
+        original: tablePath,
+        prefixed: prefixedPath,
+        connectionName: this.connectionName
+      });
+      const result2 = await super.fetchTableSchema(tableKey, prefixedPath);
+      if (!result2) {
+        throw new Error(`Table ${prefixedPath} not found in connection ${this.connectionName}`);
+      }
+      return result2;
+    }
+    const result = await super.fetchTableSchema(tableKey, tablePath);
+    if (!result) {
+      throw new Error(`Table ${tablePath} not found in connection ${this.connectionName}`);
+    }
+    return result;
+  }
+}
+async function deleteDuckLakeConnectionFile(connectionName, projectPath) {
+  const ducklakePath = import_path.default.join(projectPath, `${connectionName}_ducklake.duckdb`);
+  try {
+    await import_promises.default.access(ducklakePath);
+    await import_promises.default.rm(ducklakePath);
+    logger.info(`Removed DuckLake connection file ${connectionName}_ducklake.duckdb from ${projectPath}`);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      logger.debug(`DuckLake connection file ${connectionName}_ducklake.duckdb does not exist, skipping deletion`);
+    } else {
+      logger.error(`Failed to remove DuckLake connection file ${connectionName}_ducklake.duckdb from ${projectPath}`, { error });
+    }
+  }
+}
+async function createProjectConnections(connections = [], projectPath = "", isUpdateConnectionRequest = false) {
   const connectionMap = new Map;
   const processedConnections = new Set;
   const apiConnections = [];
@@ -219577,6 +219696,18 @@ async function createProjectConnections(connections = [], projectPath = "") {
         connection.attributes = getConnectionAttributes(motherduckConnection);
         break;
       }
+      case "ducklake": {
+        if (!connection.ducklakeConnection) {
+          throw new Error("DuckLake connection configuration is missing.");
+        }
+        const ducklakeDuckdbConnection = new DuckLakeConnection(connection.name, import_path.default.join(projectPath, `${connection.name}_ducklake.duckdb`), projectPath);
+        if (isUpdateConnectionRequest || !await isDatabaseAttached(ducklakeDuckdbConnection, connection.name)) {
+          await attachDuckLake(ducklakeDuckdbConnection, connection.name, connection.ducklakeConnection);
+        }
+        connectionMap.set(connection.name, ducklakeDuckdbConnection);
+        connection.attributes = getConnectionAttributes(ducklakeDuckdbConnection);
+        break;
+      }
       default: {
         throw new Error(`Unsupported connection type: ${connection.type}`);
       }
@@ -219656,17 +219787,27 @@ ${failedAttachments.join(`
   }
 }
 async function testConnectionConfig(connectionConfig) {
+  let malloyConnections = null;
   try {
     if (!connectionConfig.name) {
       throw new Error("Connection name is required");
     }
-    const { malloyConnections } = await createProjectConnections([connectionConfig]);
+    const result = await createProjectConnections([connectionConfig]);
+    malloyConnections = result.malloyConnections;
     const connection = malloyConnections.get(connectionConfig.name);
     if (!connection) {
       throw new Error(`Failed to create connection: ${connectionConfig.name}`);
     }
     if (connectionConfig.type === "duckdb") {
       await testDuckDBConnection(connection, connectionConfig);
+    } else if (connectionConfig.type === "ducklake") {
+      const duckConn = connection;
+      const attached = await isDatabaseAttached(duckConn, connectionConfig.name);
+      if (!attached) {
+        throw new Error(`DuckLake connection test failed: Error attaching database '${connectionConfig.name}'`);
+      }
+      await duckConn.runSQL(`SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '${connectionConfig.name}' LIMIT 1`);
+      logger.info(`DuckLake connection test passed: ${connectionConfig.name}`);
     } else {
       await connection.test();
     }
@@ -219684,6 +219825,22 @@ async function testConnectionConfig(connectionConfig) {
       status: "failed",
       errorMessage: error.message
     };
+  } finally {
+    if (malloyConnections) {
+      for (const [connName, conn] of malloyConnections) {
+        try {
+          if (conn && typeof conn.close === "function") {
+            await conn.close();
+          }
+        } catch (closeError) {
+          logger.warn(`Error closing connection ${connName} during test cleanup`, { error: closeError });
+        } finally {
+          if (connectionConfig.type === "ducklake") {
+            await deleteDuckLakeConnectionFile(connName, process.cwd());
+          }
+        }
+      }
+    }
   }
 }
@@ -220246,6 +220403,25 @@ async function getSchemasForConnection(connection, malloyConnection) {
       console.error(`Error getting schemas for MotherDuck connection ${connection.name}:`, error);
       throw new Error(`Failed to get schemas for MotherDuck connection ${connection.name}: ${error.message}`);
     }
+  } else if (connection.type === "ducklake") {
+    try {
+      const catalogName = connection.name;
+      const result = await malloyConnection.runSQL(`SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '${catalogName}' ORDER BY schema_name`, { rowLimit: 1000 });
+      const rows = standardizeRunSQLResult2(result);
+      return rows.map((row) => {
+        const typedRow = row;
+        const schemaName = typedRow.schema_name;
+        const shouldShow = schemaName === "main" || schemaName === "public";
+        return {
+          name: schemaName,
+          isHidden: !shouldShow,
+          isDefault: false
+        };
+      });
+    } catch (error) {
+      logger.error(`Error getting schemas for DuckLake connection ${connection.name}`, { error });
+      throw new Error(`Failed to get schemas for DuckLake connection ${connection.name}: ${error.message}`);
+    }
   } else {
     throw new Error(`Unsupported connection type: ${connection.type}`);
   }
@@ -220265,6 +220441,12 @@ async function getTablesForSchema(connection, schemaName, malloyConnection) {
     }
     const fileKeys = await listDataFilesInDirectory(credentials, bucketName, directoryPath);
     return await getCloudTablesWithColumns(malloyConnection, credentials, bucketName, fileKeys);
+  } else if (connection.type === "ducklake") {
+    if (schemaName.split(".").length == 2) {
+      schemaName = `${connection.name}.${schemaName}`;
+    } else if (schemaName.split(".").length === 1) {
+      schemaName = `${connection.name}.${schemaName}`;
+    }
   }
   const tableNames = await listTablesForSchema(connection, schemaName, malloyConnection);
   const tableSourcePromises = tableNames.map(async (tableName) => {
@@ -220276,6 +220458,8 @@ async function getTablesForSchema(connection, schemaName, malloyConnection) {
         } else {
           tablePath = `${schemaName}.${tableName}`;
         }
+      } else if (connection.type === "ducklake") {
+        tablePath = `${schemaName}.${tableName}`;
       } else {
         tablePath = `${schemaName}.${tableName}`;
       }
@@ -220287,7 +220471,7 @@ async function getTablesForSchema(connection, schemaName, malloyConnection) {
       };
     } catch (error) {
       logger.warn(`Failed to get schema for table ${tableName}`, {
-        error,
+        error: extractErrorDataFromError(error),
         schemaName,
         tableName
       });
@@ -220476,10 +220660,39 @@ async function listTablesForSchema(connection, schemaName, malloyConnection) {
       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.message}`);
     }
+  } else if (connection.type === "ducklake") {
+    const catalogName = schemaName.split(".")[0];
+    const actualSchemaName = schemaName.split(".")[1];
+    console.error("catalogName", catalogName);
+    console.error("actualSchemaName", actualSchemaName);
+    try {
+      const result = await malloyConnection.runSQL(`SELECT table_name FROM information_schema.tables WHERE table_schema = '${actualSchemaName}' AND table_catalog = '${catalogName}' ORDER BY table_name`, { rowLimit: 1000 });
+      const rows = standardizeRunSQLResult2(result);
+      return rows.map((row) => {
+        const typedRow = row;
+        return typedRow.table_name;
+      });
+    } catch (error) {
+      logger.error(`Error getting tables for DuckLake schema ${schemaName} in connection ${connection.name}`, { error });
+      throw new Error(`Failed to get tables for DuckLake schema ${schemaName} in connection ${connection.name}: ${error.message}`);
+    }
   } else {
     throw new Error(`Unsupported connection type: ${connection.type}`);
   }
 }
+function extractErrorDataFromError(error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorData = {
+    error: errorMessage
+  };
+  if (error instanceof Error && logger.level === "debug") {
+    errorData.stack = error.stack;
+  }
+  if (error && typeof error === "object" && "task" in error) {
+    errorData.task = error.task;
+  }
+  return errorData;
+}
 // src/controller/connection.controller.ts
 class ConnectionController {
@@ -220547,9 +220760,21 @@ class ConnectionController {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
     return getConnectionTableSource(malloyConnection, tableKey, tablePath);
   }
-  async getTable(projectName, connectionName, _schemaName, tablePath) {
+  async getTable(projectName, connectionName, schemaName, tablePath) {
     const malloyConnection = await this.getMalloyConnection(projectName, connectionName);
-    const tableSource = await getConnectionTableSource(malloyConnection, tablePath.split(".").pop(), tablePath);
+    const connection = await this.getConnection(projectName, connectionName);
+    if (connection.type === "ducklake") {
+      if (tablePath.split(".").length === 1) {
+        tablePath = `${connectionName}.${schemaName}.${tablePath}`;
+      } else if (tablePath.split(".").length === 2 && !tablePath.startsWith(connectionName)) {
+        tablePath = `${connectionName}.${tablePath}`;
+      }
+    }
+    const tableKey = tablePath.split(".").pop();
+    if (!tableKey) {
+      throw new Error(`Invalid tablePath: ${tablePath}`);
+    }
+    const tableSource = await getConnectionTableSource(malloyConnection, tableKey, tablePath);
     return {
       resource: tablePath,
       columns: tableSource.columns,
@@ -228339,7 +228564,8 @@ class Project {
     }
     if (payload.connections) {
       logger.info(`Updating ${payload.connections.length} connections for project ${this.projectName}`);
-      const { malloyConnections, apiConnections } = await createProjectConnections(payload.connections, this.projectPath);
+      const isUpdateConnectionRequest = true;
+      const { malloyConnections, apiConnections } = await createProjectConnections(payload.connections, this.projectPath, isUpdateConnectionRequest);
       this.malloyConnections = malloyConnections;
       this.apiConnections = apiConnections;
       logger.info(`Successfully updated connections for project ${this.projectName}`, {
@@ -228609,8 +228835,11 @@ ${source}` : source;
     this.malloyConnections.get(connectionName)?.close();
     const isDeleted = this.malloyConnections.delete(connectionName);
     const index = this.apiConnections.findIndex((conn) => conn.name === connectionName);
-    if (this.apiConnections[index]?.type === "duckdb") {
+    const connectionType = this.apiConnections[index]?.type;
+    if (connectionType === "duckdb") {
       await this.deleteDuckDBConnection(connectionName);
+    } else if (connectionType === "ducklake") {
+      await this.deleteDuckLakeConnection(connectionName);
     }
     if (index !== -1) {
       this.apiConnections.splice(index, 1);
@@ -228653,6 +228882,10 @@ ${source}` : source;
       logger.error(`Failed to remove DuckDB connection file ${connectionName} from project ${this.projectName}`, { error });
     });
   }
+  async deleteDuckLakeConnection(connectionName) {
+    await deleteDuckLakeConnectionFile(connectionName, this.projectPath);
+    logger.info(`Removed DuckLake connection ${connectionName} from project ${this.projectName}`);
+  }
 }
 async function extractPreamble(modelPath) {
   try {
@@ -233541,6 +233774,7 @@ var databaseController = new DatabaseController(projectStore);
 var queryController = new QueryController(projectStore);
 var compileController = new CompileController(projectStore);
 var mcpApp = import_express.default();
+registerHealthEndpoints(mcpApp);
 mcpApp.use(MCP_ENDPOINT, import_express.default.json());
 mcpApp.use(MCP_ENDPOINT, import_cors.default());
 mcpApp.all(MCP_ENDPOINT, async (req, res) => {

package/package.json CHANGED Viewed

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

package/src/controller/connection.controller.ts CHANGED Viewed

@@ -155,17 +155,37 @@ export class ConnectionController {
    public async getTable(
       projectName: string,
       connectionName: string,
-      _schemaName: string,
+      schemaName: string,
       tablePath: string,
    ): Promise<ApiTable> {
       const malloyConnection = await this.getMalloyConnection(
          projectName,
          connectionName,
       );
+      const connection = await this.getConnection(projectName, connectionName);
+      if (connection.type === "ducklake") {
+         if (tablePath.split(".").length === 1) {
+            // tablePath is just the table name, construct full path
+            tablePath = `${connectionName}.${schemaName}.${tablePath}`;
+         } else if (
+            tablePath.split(".").length === 2 &&
+            !tablePath.startsWith(connectionName)
+         ) {
+            // tablePath is schemaName.tableName but missing connection prefix
+            tablePath = `${connectionName}.${tablePath}`;
+         }
+         // If tablePath already has 3+ parts or starts with connection name, use as-is
+      }
+      const tableKey = tablePath.split(".").pop();
+      if (!tableKey) {
+         throw new Error(`Invalid tablePath: ${tablePath}`);
+      }
       const tableSource = await getConnectionTableSource(
          malloyConnection,
-         tablePath.split(".").pop()!, // tableKey is the table name
+         tableKey, // tableKey is the table name
          tablePath,
       );

package/src/server.ts CHANGED Viewed

@@ -131,6 +131,9 @@ const compileController = new CompileController(projectStore);
 export const mcpApp = express();
+// Register health endpoints on mcpApp (for E2E tests)
+registerHealthEndpoints(mcpApp);
 mcpApp.use(MCP_ENDPOINT, express.json());
 mcpApp.use(MCP_ENDPOINT, cors());
@@ -253,7 +256,8 @@ app.use(
 );
 app.use(bodyParser.json());
-// Register health check endpoints
+// Register health check endpoints on main app:
+// - Required for production/Kubernetes monitoring (main server on PUBLISHER_PORT)
 registerHealthEndpoints(app);
 // Register Prometheus metrics endpoint

package/src/service/connection.spec.ts CHANGED Viewed

@@ -975,6 +975,111 @@ describe("connection integration tests", () => {
       });
       describe("error handling", () => {
+         describe("DuckLake connection type", () => {
+            it(
+               "should create DuckLake connection",
+               async () => {
+                  if (!hasPostgresCredentials() || !hasS3Credentials()) {
+                     console.log(
+                        "Skipping: PostgreSQL and S3 credentials not configured",
+                     );
+                     return;
+                  }
+                  const { malloyConnections } = await createProjectConnections(
+                     [
+                        {
+                           name: "ducklake_test",
+                           type: "ducklake",
+                           ducklakeConnection: {
+                              catalog: {
+                                 postgresConnection: {
+                                    host: process.env.POSTGRES_TEST_HOST,
+                                    port: parseInt(
+                                       process.env.POSTGRES_TEST_PORT || "5432",
+                                    ),
+                                    userName: process.env.POSTGRES_TEST_USER!,
+                                    password:
+                                       process.env.POSTGRES_TEST_PASSWORD!,
+                                    databaseName:
+                                       process.env.POSTGRES_TEST_DATABASE,
+                                 },
+                              },
+                              storage: {
+                                 bucketUrl:
+                                    process.env.S3_TEST_BUCKET_URL ||
+                                    "s3://test-bucket",
+                                 s3Connection: {
+                                    accessKeyId:
+                                       process.env.S3_TEST_ACCESS_KEY_ID!,
+                                    secretAccessKey:
+                                       process.env.S3_TEST_SECRET_ACCESS_KEY!,
+                                 },
+                              },
+                           },
+                        },
+                     ],
+                     testProjectPath,
+                  );
+                  const connection = malloyConnections.get(
+                     "ducklake_test",
+                  ) as DuckDBConnection;
+                  createdConnections.push(connection);
+                  expect(connection).toBeDefined();
+                  // Verify DuckLake database is attached
+                  const databases = await connection.runSQL("SHOW DATABASES");
+                  const dbNames = databases.rows.map(
+                     (row) => Object.values(row)[0],
+                  );
+                  expect(dbNames).toContain("ducklake_test");
+               },
+               { timeout: 30000 },
+            );
+            it("should throw error if DuckLake catalog connection is missing", async () => {
+               await expect(
+                  createProjectConnections(
+                     [
+                        {
+                           name: "ducklake_no_catalog",
+                           type: "ducklake",
+                           ducklakeConnection: {
+                              storage: {
+                                 bucketUrl: "s3://test-bucket",
+                                 s3Connection: {
+                                    accessKeyId: "test",
+                                    secretAccessKey: "test",
+                                 },
+                              },
+                           },
+                        } as ApiConnection,
+                     ],
+                     testProjectPath,
+                  ),
+               ).rejects.toThrow(
+                  /PostgreSQL connection configuration is required/,
+               );
+            });
+            it("should throw error if DuckLake connection config is missing", async () => {
+               await expect(
+                  createProjectConnections(
+                     [
+                        {
+                           name: "ducklake_missing_config",
+                           type: "ducklake",
+                        },
+                     ],
+                     testProjectPath,
+                  ),
+               ).rejects.toThrow(
+                  /DuckLake connection configuration is missing/,
+               );
+            });
+         });
          it("should throw error if DuckDB connection name conflicts with attached database", async () => {
             await expect(
                createProjectConnections(