avoid code duplication

- Separate TLS and non-TLS branches to handle different connection types
- Each branch now fully handles client creation, query execution, and cleanup
- Follows the same pattern used in pg_executor.rs

backend/Cargo.lock

@@ -15269,6 +15269,7 @@ dependencies = [
  "pg_escape",
  "pin-project",
  "postgres-native-tls 0.5.0",
+ "postgres-native-tls 0.5.1",
  "prometheus",
  "quick_cache",
  "rand 0.9.0",

backend/windmill-api/Cargo.toml

@@ -94,6 +94,7 @@ tempfile.workspace = true
 tokio-util.workspace = true
 tokio-tar.workspace = true
 tokio-postgres.workspace = true
+postgres-native-tls.workspace = true
 hmac.workspace = true
 cookie.workspace = true
 sha2.workspace = true

backend/windmill-api/src/settings.rs

@@ -700,24 +700,49 @@ async fn setup_ducklake_catalog_db_inner(
         dbname = dbname,
         sslmode = ssl_mode
     );
+    let (client, join_handle) = if ssl_mode == "require" {
+        use native_tls::TlsConnector;
+        use postgres_native_tls::MakeTlsConnector;
+
+        let mut connector = TlsConnector::builder();
+        connector.danger_accept_invalid_certs(true);
+        connector.danger_accept_invalid_hostnames(true);
+
+        let (client, connection) = tokio::time::timeout(
+            std::time::Duration::from_secs(20),
+            tokio_postgres::connect(
+                &conn_str,
+                MakeTlsConnector::new(connector.build().map_err(to_anyhow)?),
+            ),
+        )
+        .await
+        .map_err(|e| error::Error::ExecutionErr(format!("timeout: {}", e.to_string())))?
+        .map_err(|e| error::Error::ExecutionErr(format!("error: {}", e.to_string())))?;
+
+        let join_handle = tokio::spawn(async move { connection.await });
+        (client, join_handle)
+    } else {
+        let (client, connection) = tokio::time::timeout(
+            std::time::Duration::from_secs(20),
+            tokio_postgres::connect(&conn_str, tokio_postgres::NoTls),
+        )
+        .await
+        .map_err(|e| error::Error::ExecutionErr(format!("timeout: {}", e.to_string())))?
+        .map_err(|e| error::Error::ExecutionErr(format!("error: {}", e.to_string())))?;
+
+        let join_handle = tokio::spawn(async move { connection.await });
+        (client, join_handle)
+    };
 
-    let (client, connection) = tokio::time::timeout(
-        std::time::Duration::from_secs(20),
-        tokio_postgres::connect(&conn_str, tokio_postgres::NoTls),
-    )
-    .await
-    .map_err(|e| error::Error::ExecutionErr(format!("timeout: {}", e.to_string())))?
-    .map_err(|e| error::Error::ExecutionErr(format!("error: {}", e.to_string())))?;
-    let join_handle = tokio::spawn(async move { connection.await });
     logs.db_connect = "OK".to_string();
 
     client
         .batch_execute(&format!(
             "GRANT CONNECT ON DATABASE \"{dbname}\" TO ducklake_user;
-            GRANT USAGE ON SCHEMA public TO ducklake_user;
-            GRANT CREATE ON SCHEMA public TO ducklake_user;
-            ALTER DEFAULT PRIVILEGES IN SCHEMA public 
-                GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO ducklake_user;"
+             GRANT USAGE ON SCHEMA public TO ducklake_user;
+             GRANT CREATE ON SCHEMA public TO ducklake_user;
+             ALTER DEFAULT PRIVILEGES IN SCHEMA public
+                 GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO ducklake_user;"
         ))
         .await
         .map_err(|e| {