gaard-api 0.2.0__tar.gz → 0.2.1__tar.gz

{gaard_api-0.2.0/src/gaard_api.egg-info → gaard_api-0.2.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: gaard-api
-Version: 0.2.0
+Version: 0.2.1
 Summary: GAARD backend web services providing admin interface
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: gaard-core==0.2.0
-Requires-Dist: gaard-connectors==0.2.0
-Requires-Dist: gaard-llm==0.2.0
+Requires-Dist: gaard-core==0.2.1
+Requires-Dist: gaard-connectors==0.2.1
+Requires-Dist: gaard-llm==0.2.1
 Requires-Dist: gaard-plugin-api<0.3.0,>=0.2.0
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.30.0

{gaard_api-0.2.0 → gaard_api-0.2.1}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gaard-api"
-version = "0.2.0"
+version = "0.2.1"
 description = "GAARD backend web services providing admin interface"
 readme = "README.md"
 requires-python = ">=3.11"
 
 dependencies = [
-    "gaard-core==0.2.0",
-    "gaard-connectors==0.2.0",
-    "gaard-llm==0.2.0",
+    "gaard-core==0.2.1",
+    "gaard-connectors==0.2.1",
+    "gaard-llm==0.2.1",
     "gaard-plugin-api>=0.2.0,<0.3.0",
     "fastapi>=0.111.0",
     "uvicorn[standard]>=0.30.0",

{gaard_api-0.2.0 → gaard_api-0.2.1}/src/gaard_api/admin/database.py

@@ -406,6 +406,15 @@ def ensure_data_query_audit_schema(engine: Engine) -> None:
                 )
             )
 
+    if "llm_sql_language" not in columns:
+        with engine.begin() as connection:
+            connection.execute(
+                text(
+                    "ALTER TABLE data_query_audit_logs "
+                    "ADD COLUMN llm_sql_language VARCHAR(50) DEFAULT ''"
+                )
+            )
+
     with engine.begin() as connection:
         for index in DataQueryAuditLog.__table__.indexes:
             index.create(bind=connection, checkfirst=True)

{gaard_api-0.2.0 → gaard_api-0.2.1}/src/gaard_api/admin/models.py

@@ -89,6 +89,7 @@ class DataQueryAuditLog(Base):
     question: Mapped[str] = mapped_column(Text)
     answer: Mapped[str] = mapped_column(Text)
     sql: Mapped[str] = mapped_column(Text)
+    llm_sql_language: Mapped[str] = mapped_column(String(50), default="")
     output_classification: Mapped[OutputClassification] = mapped_column(
         SAEnum(
             OutputClassification,

{gaard_api-0.2.0 → gaard_api-0.2.1}/src/gaard_api/admin/services.py

@@ -2,8 +2,10 @@ import json
 import re
 from dataclasses import dataclass
 from datetime import UTC, datetime, timedelta
+from pathlib import Path
 from typing import Any
 
+from sqlalchemy.engine import URL
 from sqlalchemy import delete, desc, select
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import Session
@@ -53,6 +55,137 @@ def validate_datasource_configuration(
     get_connector_registry().validate(database_type, database_url, sql_dialect)
 
 
+@dataclass(frozen=True)
+class NormalizedDatasourceConfiguration:
+    database_type: str
+    database_url: str
+    sql_dialect: str
+
+
+def normalize_datasource_configuration(
+    database_type: str,
+    connection_config: dict[str, Any] | None = None,
+    database_path: str | None = None,
+    database_url: str | None = None,
+    sql_dialect: str | None = None,
+) -> NormalizedDatasourceConfiguration:
+    registry = get_connector_registry()
+    normalized_url = (database_url or "").strip()
+    normalized_path = (database_path or "").strip()
+
+    if not normalized_url and connection_config:
+        normalized_url = build_sqlalchemy_url_from_connection_config(
+            database_type,
+            connection_config,
+        )
+
+    if not normalized_url and normalized_path:
+        normalized_url = build_sqlalchemy_url_from_path(database_type, normalized_path)
+
+    if not normalized_url:
+        raise ValueError("Datasource database path is required.")
+
+    if database_type:
+        definition = registry.get(database_type)
+    else:
+        definition = registry.detect_from_database_url(normalized_url)
+
+    resolved_dialect = (sql_dialect or "").strip() or definition.default_sql_dialect
+    registry.validate(definition.type_key, normalized_url, resolved_dialect)
+
+    return NormalizedDatasourceConfiguration(
+        database_type=definition.type_key,
+        database_url=normalized_url,
+        sql_dialect=resolved_dialect,
+    )
+
+
+def build_sqlalchemy_url_from_path(database_type: str, database_path: str) -> str:
+    if "://" in database_path:
+        return database_path
+
+    if database_type == "sqlite":
+        return str(URL.create("sqlite", database=str(Path(database_path).expanduser())))
+
+    raise ValueError(
+        "Only SQLite datasources can be created from a filesystem path. "
+        "Use a SQLAlchemy URL for this datasource type."
+    )
+
+
+def build_sqlalchemy_url_from_connection_config(
+    database_type: str,
+    connection_config: dict[str, Any],
+) -> str:
+    if database_type == "sqlite":
+        database_path = str(connection_config.get("database_path") or "").strip()
+        if not database_path:
+            raise ValueError("SQLite datasource requires a database path.")
+        return build_sqlalchemy_url_from_path(database_type, database_path)
+
+    if database_type == "postgresql":
+        return build_server_database_url(
+            drivername="postgresql+psycopg",
+            connection_config=connection_config,
+            default_port=5432,
+            query_keys=("sslmode",),
+        )
+
+    if database_type == "mysql":
+        return build_server_database_url(
+            drivername="mysql+pymysql",
+            connection_config=connection_config,
+            default_port=3306,
+            query_keys=("charset",),
+        )
+
+    raise ValueError(f"Datasource type {database_type!r} does not support generated URLs.")
+
+
+def build_server_database_url(
+    drivername: str,
+    connection_config: dict[str, Any],
+    default_port: int,
+    query_keys: tuple[str, ...],
+) -> str:
+    host = str(connection_config.get("host") or "").strip()
+    database = str(connection_config.get("database") or "").strip()
+    username = str(connection_config.get("username") or "").strip()
+    password = str(connection_config.get("password") or "")
+    port_value = connection_config.get("port") or default_port
+
+    if not host:
+        raise ValueError("Datasource host is required.")
+    if not database:
+        raise ValueError("Datasource database name is required.")
+    if not username:
+        raise ValueError("Datasource username is required.")
+
+    try:
+        port = int(port_value)
+    except (TypeError, ValueError) as exc:
+        raise ValueError("Datasource port must be a number.") from exc
+
+    query = {
+        key: str(connection_config.get(key)).strip()
+        for key in query_keys
+        if connection_config.get(key) not in (None, "")
+    }
+
+    return (
+        URL.create(
+            drivername=drivername,
+            username=username,
+            password=password or None,
+            host=host,
+            port=port,
+            database=database,
+            query=query,
+        )
+        .render_as_string(hide_password=False)
+    )
+
+
 def mask_database_url(database_url: str) -> str:
     if "://" not in database_url or "@" not in database_url:
         return database_url
@@ -280,6 +413,7 @@ def _record_data_query_audit(
         audit_metadata = dict(metadata)
         audit_metadata.pop("audit_type", None)
         audit_metadata.pop("output_classification", None)
+        llm_sql_language = str(audit_metadata.get("llm_sql_language") or "")
         log = DataQueryAuditLog(
             type=coerce_data_query_audit_type(audit_type),
             output_classification=coerce_output_classification(output_classification),
@@ -288,6 +422,7 @@ def _record_data_query_audit(
             question=request.question,
             answer=answer,
             sql=sql,
+            llm_sql_language=llm_sql_language,
             metadata_json=json_dumps(audit_metadata),
         )
         session.add(log)
@@ -1029,10 +1164,20 @@ def list_business_logic_suggestions(
     session: Session,
     connector_id: int,
 ) -> list[BusinessLogicSuggestion]:
+    return list_business_logic_suggestions_for_connectors(session, [connector_id])
+
+
+def list_business_logic_suggestions_for_connectors(
+    session: Session,
+    connector_ids: list[int],
+) -> list[BusinessLogicSuggestion]:
+    if not connector_ids:
+        return []
+
     return list(
         session.scalars(
             select(BusinessLogicSuggestion)
-            .where(BusinessLogicSuggestion.connector_id == connector_id)
+            .where(BusinessLogicSuggestion.connector_id.in_(connector_ids))
             .order_by(
                 BusinessLogicSuggestion.enabled.desc(),
                 desc(BusinessLogicSuggestion.updated_at),
@@ -1840,6 +1985,16 @@ def get_active_datasource_connector(session: Session) -> DatasourceConnector | N
     return session.scalar(select(DatasourceConnector).where(DatasourceConnector.active.is_(True)))
 
 
+def get_active_datasource_connectors(session: Session) -> list[DatasourceConnector]:
+    return list(
+        session.scalars(
+            select(DatasourceConnector)
+            .where(DatasourceConnector.active.is_(True))
+            .order_by(DatasourceConnector.name, DatasourceConnector.id)
+        )
+    )
+
+
 def get_active_datasource_connector_safe() -> DatasourceConnector | None:
     try:
         session = create_session()
@@ -1859,13 +2014,17 @@ def set_active_datasource_connector(
     connector: DatasourceConnector,
     actor: str,
 ) -> None:
-    for item in list_datasource_connectors(session):
-        if is_system_datasource_connector(item):
-            item.active = False
-            continue
+    if is_system_datasource_connector(connector):
+        connector.active = False
+        return
 
-        item.active = item.id == connector.id
-        item.updated_by = actor if item.id == connector.id else item.updated_by
+    if connector.connector_key != "default":
+        for item in list_datasource_connectors(session):
+            if item.connector_key == "default":
+                item.active = False
+
+    connector.active = True
+    connector.updated_by = actor
 
 
 def test_datasource_connection(connector: DatasourceConnector) -> None:
@@ -2085,7 +2244,6 @@ def get_datasource_schema_context_safe() -> (
         session = create_session()
     except SQLAlchemyError:
         return None
-
     try:
         connector = get_active_datasource_connector(session)
 
@@ -2104,3 +2262,45 @@ def get_datasource_schema_context_safe() -> (
         return None
     finally:
         session.close()
+
+
+def get_datasource_schema_contexts_safe(
+    datasource_ids: list[str] | None = None,
+) -> list[tuple[DatasourceConnector, DatasourceSchemaCache]]:
+    try:
+        session = create_session()
+    except SQLAlchemyError:
+        return []
+
+    try:
+        if datasource_ids:
+            connectors = [
+                connector
+                for datasource_id in datasource_ids
+                if (connector := get_datasource_connector_by_key(session, datasource_id))
+                is not None
+                and not is_system_datasource_connector(connector)
+            ]
+        else:
+            connectors = [
+                connector
+                for connector in get_active_datasource_connectors(session)
+                if not is_system_datasource_connector(connector)
+            ]
+
+        contexts: list[tuple[DatasourceConnector, DatasourceSchemaCache]] = []
+        for connector in connectors:
+            cache = get_datasource_schema_cache(session, connector.id)
+
+            if cache is None:
+                cache = introspect_datasource_connector(session, connector, "system")
+                session.commit()
+
+            contexts.append((connector, cache))
+
+        return contexts
+    except SQLAlchemyError:
+        session.rollback()
+        return []
+    finally:
+        session.close()

{gaard_api-0.2.0 → gaard_api-0.2.1}/src/gaard_api/admin-web/assets/main.js

@@ -44,6 +44,7 @@ var state = {
   schemaCache: null,
   businessLogic: [],
   businessLogicDatasource: null,
+  businessLogicDatasources: [],
   businessLogicEditorId: null,
   llmConfig: null,
   reasoningConfig: null,
@@ -145,6 +146,21 @@ function isMenuGroupActive(group) {
 function renderNavigation() {
   return getMenuGroups().map((group) => renderMenuGroup(group)).join("");
 }
+function renderSidebar() {
+  return `
+      <aside class="sidebar${state.mobileMenuOpen ? " menu-open" : ""}">
+        <div class="sidebar-header">
+          <div class="brand"><strong>GAARD Admin Console</strong><span>Community edition</span></div>
+          <button class="menu-toggle" id="mobile-menu-button" type="button" aria-label="${state.mobileMenuOpen ? "Close navigation" : "Open navigation"}" aria-expanded="${state.mobileMenuOpen}" aria-controls="admin-navigation">
+            <span></span><span></span><span></span>
+          </button>
+        </div>
+        <nav class="nav" id="admin-navigation">
+          ${renderNavigation()}
+        </nav>
+        <div class="sidebar-footer"><span>${escapeHtml(state.username)}</span><button id="logout-button">Sign out</button></div>
+      </aside>`;
+}
 function renderMenuGroup(group) {
   const isOpen = Boolean(state.openMenuGroups[group.key]);
   const isActive = isMenuGroupActive(group);
@@ -392,18 +408,7 @@ function renderShell() {
   const activeLabel = getSectionLabel(state.section);
   app.innerHTML = `
     <div class="app-shell">
-      <aside class="sidebar${state.mobileMenuOpen ? " menu-open" : ""}">
-        <div class="sidebar-header">
-          <div class="brand"><strong>GAARD Admin Console</strong><span>Community edition</span></div>
-          <button class="menu-toggle" id="mobile-menu-button" type="button" aria-label="${state.mobileMenuOpen ? "Close navigation" : "Open navigation"}" aria-expanded="${state.mobileMenuOpen}" aria-controls="admin-navigation">
-            <span></span><span></span><span></span>
-          </button>
-        </div>
-        <nav class="nav" id="admin-navigation">
-          ${renderNavigation()}
-        </nav>
-        <div class="sidebar-footer"><span>${escapeHtml(state.username)}</span><button id="logout-button">Sign out</button></div>
-      </aside>
+      ${renderSidebar()}
       <main class="main">
         <header class="topbar">
           <h1>${escapeHtml(activeLabel || "Admin")}</h1>
@@ -416,12 +421,16 @@ function renderShell() {
       </main>
     </div>
     ${renderOverviewWidgetModal()}`;
+  attachShellHandlers();
+  resizeExtensionFrames();
+}
+function attachShellHandlers() {
   document.querySelectorAll("[data-menu-group]").forEach((button) => {
     button.addEventListener("click", () => {
       const groupKey = button.dataset.menuGroup;
       if (!groupKey) return;
       state.openMenuGroups[groupKey] = !state.openMenuGroups[groupKey];
-      render();
+      updateSidebar();
     });
   });
   document.querySelectorAll("[data-section]").forEach((button) => {
@@ -437,12 +446,17 @@ function renderShell() {
   });
   document.querySelector("#mobile-menu-button")?.addEventListener("click", () => {
     state.mobileMenuOpen = !state.mobileMenuOpen;
-    render();
+    updateSidebar();
   });
   document.querySelector("#logout-button")?.addEventListener("click", logout);
   document.querySelector("#top-logout-button")?.addEventListener("click", logout);
   attachSectionHandlers();
-  resizeExtensionFrames();
+}
+function updateSidebar() {
+  const sidebarHost = document.querySelector(".app-shell > .sidebar");
+  if (!sidebarHost) return render();
+  sidebarHost.outerHTML = renderSidebar();
+  attachShellHandlers();
 }
 function renderSection() {
   if (state.section === "overview") return renderOverview();
@@ -991,7 +1005,7 @@ function renderDatasources() {
     <div class="split">
       <section class="panel">
         <div class="panel-header"><h2>Datasources</h2><button id="new-datasource">New</button></div>
-        <div class="panel-body list">${state.datasources.map((connector) => `<button data-datasource="${connector.id}" class="${selected?.id === connector.id ? "active" : ""}"><strong>${escapeHtml(connector.name)}</strong><br /><span>${escapeHtml(connector.database_type)} ${connector.active ? "active" : ""}</span></button>`).join("")}</div>
+        <div class="panel-body list datasource-list">${state.datasources.map((connector) => `<button data-datasource="${connector.id}" class="${selected?.id === connector.id ? "active" : ""}"><strong>${escapeHtml(connector.name)}</strong><br /><span>${escapeHtml(connector.database_type)} ${connector.active ? "active" : ""}</span></button>`).join("")}</div>
       </section>
       <section class="panel">
         <div class="panel-header"><h2>${selected ? escapeHtml(selected.name) : "New datasource"}</h2></div>
@@ -1008,12 +1022,11 @@ function renderDatasourceForm(connector) {
   const systemManaged = connector?.system_managed === true;
   const selectedTypeKey = connector?.database_type || state.datasourceTypes[0]?.type_key || "";
   const selectedType = getDatasourceType(selectedTypeKey);
-  const databaseUrlSchema = selectedType?.config_schema?.properties?.database_url;
   const selectedSqlDialect = connector?.sql_dialect || selectedType?.default_sql_dialect || "";
-  const databaseUrl = connector?.database_url || String(databaseUrlSchema?.default || "");
   const unavailableType = Boolean(selectedTypeKey && !selectedType);
   const disabled = systemManaged || unavailableType || !selectedType ? "disabled" : "";
   const connectorDescription = selectedType?.description || (unavailableType ? `Connector type '${selectedTypeKey}' is unavailable. Install or enable its plugin before editing this datasource.` : "No connector types are available. Install or enable a connector plugin.");
+  const connectionValues = datasourceConnectionConfigDefaults(selectedType, connector);
   return `
     <form id="datasource-form" class="form-grid">
       <input type="hidden" name="id" value="${escapeHtml(connector?.id || "")}" />
@@ -1022,15 +1035,18 @@ function renderDatasourceForm(connector) {
       <label>Name<input name="name" ${disabled} value="${escapeHtml(connector?.name || "")}" /></label>
       <div class="subgrid">
         <label>Connector type<select id="datasource-type" name="database_type" ${disabled}>${renderDatasourceTypeOptions(selectedTypeKey)}</select></label>
-        <label>SQL dialect<select id="datasource-sql-dialect" name="sql_dialect" ${disabled}>${renderSqlDialectOptions(selectedType, selectedSqlDialect)}</select></label>
+        <label>SQL dialect<input id="datasource-sql-dialect" readonly ${disabled} value="${escapeHtml(selectedSqlDialect)}" /></label>
       </div>
       <p id="datasource-type-description" class="muted">${escapeHtml(connectorDescription)}</p>
-      <label><span id="datasource-url-label">${escapeHtml(databaseUrlSchema?.title || "Database URL")}</span><input id="datasource-url" name="database_url" ${disabled} placeholder="${escapeHtml(databaseUrlSchema?.description || "")}" value="${escapeHtml(databaseUrl)}" /></label>
+      <div id="datasource-connection-fields" class="subgrid">
+        ${renderDatasourceConnectionFields(selectedType, connectionValues, disabled)}
+      </div>
       <label class="inline-check"><input name="active" type="checkbox" ${connector?.active ? "checked" : ""} ${disabled} /> Active datasource</label>
       <div class="button-row">
         <button type="button" id="test-datasource" ${disabled}>Test</button>
         <button type="button" id="introspect-datasource" ${connector ? "" : "disabled"}>Schema introspection</button>
         <button type="button" id="activate-datasource" ${connector && !connector.active && !systemManaged ? "" : "disabled"}>Activate</button>
+        ${connector && !systemManaged ? `<button type="button" class="danger" id="delete-datasource">Delete</button>` : ""}
         <button class="primary" type="submit" ${systemManaged ? "disabled" : ""}>${connector ? "Save" : "Create"}</button>
       </div>
     </form>`;
@@ -1065,28 +1081,84 @@ function renderSqlDialectOptions(datasourceType, selected) {
   }
   return dialects.map((value) => `<option value="${escapeHtml(value)}" ${selected === value ? "selected" : ""}>${escapeHtml(value)}</option>`).join("");
 }
+function datasourceConnectionConfigDefaults(datasourceType, connector = null) {
+  const values = {};
+  const properties = datasourceType?.config_schema?.properties || {};
+  const usesGeneratedFields = datasourceUsesGeneratedConnectionFields(datasourceType);
+  Object.entries(properties).forEach(([key, schema]) => {
+    if (key === "database_url" && usesGeneratedFields) return;
+    values[key] = schema?.default ?? "";
+  });
+  if (!connector?.database_url) return values;
+  if (!usesGeneratedFields) {
+    return { ...values, database_url: connector.database_url };
+  }
+  return { ...values, ...parseDatasourceUrl(connector.database_type, connector.database_url) };
+}
+function datasourceUsesGeneratedConnectionFields(datasourceType) {
+  const required = datasourceType?.config_schema?.required || [];
+  return required.some((key) => key !== "database_url");
+}
+function parseDatasourceUrl(databaseType, databaseUrl) {
+  if (!databaseUrl) return {};
+  if (databaseType === "sqlite") {
+    return { database_path: databaseUrl.replace(/^sqlite:\/\/\/?/, "") };
+  }
+  try {
+    const parsed = new URL(databaseUrl);
+    const query = Object.fromEntries(parsed.searchParams.entries());
+    return {
+      host: parsed.hostname || "",
+      port: parsed.port || "",
+      database: decodeURIComponent(parsed.pathname.replace(/^\//, "")),
+      username: decodeURIComponent(parsed.username || ""),
+      password: decodeURIComponent(parsed.password || ""),
+      ...query
+    };
+  } catch {
+    return {};
+  }
+}
+function renderDatasourceConnectionFields(datasourceType, values = {}, disabled = "") {
+  const properties = datasourceType?.config_schema?.properties || {};
+  const usesGeneratedFields = datasourceUsesGeneratedConnectionFields(datasourceType);
+  return Object.entries(properties)
+    .filter(([key]) => key !== "database_url" || !usesGeneratedFields)
+    .map(([key, schema]) => {
+      const type = schema?.format === "password" ? "password" : schema?.type === "integer" ? "number" : "text";
+      const value = values[key] ?? schema?.default ?? "";
+      const placeholder = schema?.description || "";
+      const inputName = key === "database_url" ? "database_url" : `connection_${key}`;
+      const dataAttribute = key === "database_url" ? "" : `data-connection-field="${escapeHtml(key)}"`;
+      return `<label>${escapeHtml(schema?.title || key)}<input ${dataAttribute} name="${escapeHtml(inputName)}" type="${type}" ${disabled} placeholder="${escapeHtml(placeholder)}" value="${escapeHtml(value)}" /></label>`;
+    })
+    .join("");
+}
+function collectDatasourceConnectionConfig(form) {
+  const config = {};
+  form.querySelectorAll("[data-connection-field]").forEach((input) => {
+    config[input.dataset.connectionField] = input.value;
+  });
+  return config;
+}
 function syncDatasourceTypeFields(event) {
   const typeKey = event.currentTarget.value;
   const datasourceType = getDatasourceType(typeKey);
   const sqlDialect = document.querySelector("#datasource-sql-dialect");
   const description = document.querySelector("#datasource-type-description");
-  const urlLabel = document.querySelector("#datasource-url-label");
-  const urlInput = document.querySelector("#datasource-url");
-  const databaseUrlSchema = datasourceType?.config_schema?.properties?.database_url;
+  const connectionFields = document.querySelector("#datasource-connection-fields");
   if (sqlDialect) {
-    sqlDialect.innerHTML = renderSqlDialectOptions(
-      datasourceType,
-      datasourceType?.default_sql_dialect || ""
-    );
+    sqlDialect.value = datasourceType?.default_sql_dialect || "";
   }
   if (description) {
     description.textContent = datasourceType?.description || "Connector type is unavailable.";
   }
-  if (urlLabel) {
-    urlLabel.textContent = databaseUrlSchema?.title || "Database URL";
-  }
-  if (urlInput) {
-    urlInput.placeholder = databaseUrlSchema?.description || "";
+  if (connectionFields) {
+    connectionFields.innerHTML = renderDatasourceConnectionFields(
+      datasourceType,
+      datasourceConnectionConfigDefaults(datasourceType),
+      ""
+    );
   }
 }
 function renderModeOptions(selected, values) {
@@ -1095,10 +1167,11 @@ function renderModeOptions(selected, values) {
 function renderDatasourceSchema() {
   const schema = state.datasourceSchema?.item;
   const rawTables = schema?.raw_schema?.tables || [];
+  const displayTables = [...rawTables].sort((a, b) => a.name.localeCompare(b.name));
   const tableSettings = schema?.table_settings?.tables || {};
   const draftTables = schema ? getDatasourceSchemaDraftTables(rawTables, tableSettings) : {};
-  const visibleTables = state.datasourceSchemaShowEnabledOnly ? rawTables.filter((table) => draftTables[table.name]?.selected !== false) : rawTables;
-  const selectedTable = schema ? getSelectedDatasourceSchemaObject(rawTables, visibleTables) : null;
+  const visibleTables = state.datasourceSchemaShowEnabledOnly ? displayTables.filter((table) => draftTables[table.name]?.selected !== false) : displayTables;
+  const selectedTable = schema ? getSelectedDatasourceSchemaObject(displayTables, visibleTables) : null;
   const selectedSettings = selectedTable ? draftTables[selectedTable.name] || {} : {};
   return `
     <section class="panel">
@@ -1149,11 +1222,15 @@ function getSelectedDatasourceSchemaObject(rawTables, visibleTables) {
 }
 function renderBusinessLogicSuggestions() {
   const datasource = state.businessLogicDatasource;
+  const datasources = state.businessLogicDatasources || (datasource ? [datasource] : []);
+  const datasourceLabel = datasources.length
+    ? datasources.map((item) => item.connector_key).join(", ")
+    : "no active datasource";
   return `
     <section class="panel">
       <div class="panel-header">
         <h2>Business logic suggestions</h2>
-        <span class="badge">${escapeHtml(datasource?.connector_key || "no active datasource")}</span>
+        <span class="badge">${escapeHtml(datasourceLabel)}</span>
       </div>
       <div class="table-wrap"><table>
         <thead><tr><th>Use</th><th>Status</th><th>Safety</th><th>Rule</th><th>Error</th><th>Confidence</th><th>Actions</th></tr></thead>
@@ -1173,7 +1250,7 @@ function renderBusinessLogicSuggestions() {
             </td>
           </tr>`).join("")}</tbody>
       </table></div>
-      ${state.businessLogic.length ? "" : `<div class="panel-body"><p class="muted">No suggestions for the active datasource.</p></div>`}
+      ${state.businessLogic.length ? "" : `<div class="panel-body"><p class="muted">No suggestions for the active datasources.</p></div>`}
     </section>
     ${renderBusinessLogicEditorModal()}`;
 }
@@ -1455,6 +1532,7 @@ function attachSectionHandlers() {
   document.querySelector("#test-datasource")?.addEventListener("click", testDatasource);
   document.querySelector("#introspect-datasource")?.addEventListener("click", introspectDatasource);
   document.querySelector("#activate-datasource")?.addEventListener("click", activateDatasource);
+  document.querySelector("#delete-datasource")?.addEventListener("click", deleteDatasource);
   document.querySelectorAll("[data-open-business-logic]").forEach((button) => {
     button.addEventListener("click", async () => {
       state.section = "business-logic";
@@ -1875,8 +1953,8 @@ async function saveDatasource(event) {
     connector_key: form.get("connector_key"),
     name: form.get("name"),
     database_type: form.get("database_type"),
-    database_url: form.get("database_url"),
-    sql_dialect: form.get("sql_dialect"),
+    connection_config: collectDatasourceConnectionConfig(event.currentTarget),
+    database_url: form.get("database_url") || null,
     active: form.get("active") === "on"
   };
   try {
@@ -1903,7 +1981,8 @@ async function testDatasource() {
         method: "POST",
         body: JSON.stringify({
           database_type: formData.get("database_type"),
-          database_url: formData.get("database_url")
+          connection_config: collectDatasourceConnectionConfig(form),
+          database_url: formData.get("database_url") || null
         })
       });
     } else {
@@ -1946,6 +2025,25 @@ async function activateDatasource() {
     render();
   }
 }
+async function deleteDatasource() {
+  const selected = getSelectedDatasource();
+  if (!selected || selected.system_managed) return;
+  if (!confirm(`Delete datasource "${selected.name}"?`)) return;
+  try {
+    await api(`/api/v1/admin/datasources/${selected.id}`, { method: "DELETE" });
+    state.selectedDatasourceId = null;
+    state.datasourceSchema = null;
+    state.datasourceSchemaLoading = false;
+    state.datasourceSchemaError = "";
+    state.datasourceSchemaSelectedObjectName = "";
+    state.datasourceSchemaDraftTables = null;
+    setMessage("success", "Datasource deleted.");
+    await loadDatasources();
+  } catch (error) {
+    setMessage("error", error.message);
+    render();
+  }
+}
 function syncDatasourceSchemaDraftFromForm() {
   const form = document.querySelector("#datasource-schema-form");
   const rawTables = state.datasourceSchema?.item?.raw_schema?.tables || [];
@@ -2169,6 +2267,7 @@ async function loadBusinessLogicSuggestions() {
   const result = await api("/api/v1/admin/business-logic-suggestions");
   state.businessLogic = result.items || [];
   state.businessLogicDatasource = result.datasource || null;
+  state.businessLogicDatasources = result.datasources || [];
   render();
 }
 async function loadLlmConfig() {