semantic

backend/src/core/config_manager.py

@@ -25,6 +25,7 @@ from sqlalchemy.orm import Session
 from .config_models import AppConfig, Environment, GlobalSettings
 from .database import SessionLocal
 from ..models.config import AppConfigRecord
+from ..models.mapping import Environment as EnvironmentRecord
 from .logger import logger, configure_logger, belief_scope
 
 
@@ -146,6 +147,8 @@ class ConfigManager:
                             "settings": self.raw_payload.get("settings", {}),
                         }
                     )
+                    self._sync_environment_records(session, config)
+                    session.commit()
                     logger.reason(
                         "Database configuration validated successfully",
                         extra={
@@ -202,6 +205,60 @@ class ConfigManager:
                 session.close()
     # [/DEF:_load_config:Function]
 
+    # [DEF:_sync_environment_records:Function]
+    # @PURPOSE: Mirror configured environments into the relational environments table used by FK-backed domain models.
+    def _sync_environment_records(self, session: Session, config: AppConfig) -> None:
+        with belief_scope("ConfigManager._sync_environment_records"):
+            configured_envs = list(config.environments or [])
+            configured_ids = {
+                str(environment.id or "").strip()
+                for environment in configured_envs
+                if str(environment.id or "").strip()
+            }
+
+            persisted_records = session.query(EnvironmentRecord).all()
+            persisted_by_id = {str(record.id or "").strip(): record for record in persisted_records}
+
+            for environment in configured_envs:
+                normalized_id = str(environment.id or "").strip()
+                if not normalized_id:
+                    continue
+
+                display_name = str(environment.name or normalized_id).strip() or normalized_id
+                normalized_url = str(environment.url or "").strip()
+                credentials_id = str(environment.username or "").strip() or normalized_id
+
+                record = persisted_by_id.get(normalized_id)
+                if record is None:
+                    logger.reason(
+                        "Creating relational environment record from typed config",
+                        extra={"environment_id": normalized_id, "environment_name": display_name},
+                    )
+                    session.add(
+                        EnvironmentRecord(
+                            id=normalized_id,
+                            name=display_name,
+                            url=normalized_url,
+                            credentials_id=credentials_id,
+                        )
+                    )
+                    continue
+
+                record.name = display_name
+                record.url = normalized_url
+                record.credentials_id = credentials_id
+
+            for record in persisted_records:
+                normalized_id = str(record.id or "").strip()
+                if normalized_id and normalized_id not in configured_ids:
+                    logger.reason(
+                        "Removing stale relational environment record absent from typed config",
+                        extra={"environment_id": normalized_id},
+                    )
+                    session.delete(record)
+
+    # [/DEF:_sync_environment_records:Function]
+
     # [DEF:_save_config_to_db:Function]
     # @PURPOSE: Persist provided AppConfig into the global DB configuration record.
     def _save_config_to_db(self, config: AppConfig, session: Optional[Session] = None) -> None:
@@ -220,6 +277,8 @@ class ConfigManager:
                     logger.reason("Updating existing global app config record", extra={"record_id": record.id})
                     record.payload = payload
 
+                self._sync_environment_records(db, config)
+
                 db.commit()
                 logger.reason(
                     "Configuration persisted to database",