Fin

Author: mslaursen

fastapi_forge/frontend/components/model_row.py

@@ -36,13 +36,14 @@ def _build(self) -> None:
             )
             self.name_label.bind_visibility_from(self, "is_editing", lambda x: not x)
 
-            with ui.row().classes("gap-2"):
+            with ui.row().classes("flex-nowrap gap-2 min-w-fit"):
                 self.edit_button = (
                     ui.button(
                         icon="edit",
                     )
                     .on("click.stop", self._toggle_edit)
                     .bind_visibility_from(self, "is_editing", lambda x: not x)
+                    .classes("min-w-fit")
                 )
 
                 self.save_button = (
@@ -51,11 +52,14 @@ def _build(self) -> None:
                     )
                     .on("click.stop", self._save_model)
                     .bind_visibility_from(self, "is_editing")
+                    .classes("min-w-fit")
                 )
 
                 ui.button(
                     icon="delete",
-                ).on("click.stop", lambda: state.delete_model(self.model))
+                ).on("click.stop", lambda: state.delete_model(self.model)).classes(
+                    "min-w-fit"
+                )
 
     def _toggle_edit(self) -> None:
         self.is_editing = not self.is_editing

fastapi_forge/frontend/panels/project_config_panel.py

@@ -200,11 +200,41 @@ def _handle_builtin_auth_change(self, event: ValueChangeEventArguments) -> None:
                 state.render_models_fn()
             ui.notify("The 'auth_user' model has been deleted.", type="positive")
 
+    async def _warn_override(self) -> bool:
+        """Show a confirmation dialog if the project already exists."""
+        dialog = ui.dialog()
+        with dialog, ui.card().classes("w-full max-w-md p-6 text-center"):
+            ui.icon("warning", color="orange-500").classes("text-4xl self-center")
+            ui.markdown(
+                f"Project '{state.project_name}' already exists!\n\n"
+                "This will **permanently overwrite** the existing project directory.\n"
+                "Are you sure you want to continue?"
+            ).classes("text-center")
+
+            with ui.row().classes("w-full justify-center gap-4 mt-4"):
+                ui.button("Cancel", color="primary", on_click=dialog.close)
+                ui.button(
+                    "Overwrite", color="negative", on_click=lambda: dialog.submit(True)
+                )
+
+        return await dialog
+
     async def _create_project(self) -> None:
-        """Generate the project based on current state"""
+        """Generate the project based on the current state."""
+        project_path = Path(state.project_name)
+
+        if project_path.exists():
+            try:
+                override = await self._warn_override()
+                if not override:
+                    ui.notify("Project generation cancelled.", type="warning")
+                    return
+            except Exception as e:
+                ui.notify(f"Error displaying confirmation: {e}", type="negative")
+                return
+
         self.create_button.classes("hidden")
         self.loading_spinner.classes(remove="hidden")
-
         ongoing_notification = ui.notification("Generating project...")
 
         try:

fastapi_forge/frontend/state.py

@@ -10,18 +10,24 @@
     ProjectSpec,
 )
 from fastapi_forge.enums import FieldDataType
-from fastapi_forge.frontend import notifications as n
+from fastapi_forge.frontend.notifications import (
+    notify_model_exists,
+    notify_something_went_wrong,
+    notify_validation_error,
+)
 
 
 class ProjectState(BaseModel):
+    """Central state management for the project configuration."""
+
     models: list[Model] = []
     selected_model: Model | None = None
     selected_field: ModelField | None = None
     selected_relation: ModelRelationship | None = None
 
     render_models_fn: Callable | None = None
     render_model_editor_fn: Callable | None = None
-    select_model_fn: Callable | None = None
+    select_model_fn: Callable[[Model], None] | None = None
     deselect_model_fn: Callable | None = None
 
     project_name: str = ""
@@ -32,7 +38,7 @@ class ProjectState(BaseModel):
     use_rabbitmq: bool = False
 
     def initialize_from_project(self, project: ProjectSpec) -> None:
-        """Initialize the state from an existing project specification"""
+        """Initialize state from an existing project specification."""
         self.project_name = project.project_name
         self.use_postgres = project.use_postgres
         self.use_alembic = project.use_alembic
@@ -41,90 +47,62 @@ def initialize_from_project(self, project: ProjectSpec) -> None:
         self.use_rabbitmq = project.use_rabbitmq
         self.models = project.models.copy()
 
-        if self.render_models_fn:
-            self.render_models_fn()
+        self._trigger_ui_refresh()
 
     def add_model(self, model_name: str) -> None:
-        if self.render_models_fn is None:
-            n.notify_something_went_wrong()
+        """Add a new model to the project."""
+        if not self._validate_ui_callbacks():
             return
 
-        if any(model.name == model_name for model in self.models):
-            n.notify_model_exists(model_name)
+        if self._model_exists(model_name):
+            notify_model_exists(model_name)
             return
 
         try:
-            default_id_field = ModelField(
-                name="id",
-                type=FieldDataType.UUID,
-                primary_key=True,
-                nullable=False,
-                unique=True,
-                index=True,
-            )
-
-            new_model = Model(name=model_name, fields=[default_id_field])
-            self.models.append(new_model)
-
-            self.render_models_fn()
-
+            self.models.append(self._create_default_model(model_name))
+            self._trigger_ui_refresh()
         except ValidationError as exc:
-            n.notify_validation_error(exc)
+            notify_validation_error(exc)
 
     def delete_model(self, model: Model) -> None:
-        if (
-            model not in self.models
-            or self.deselect_model_fn is None
-            or self.render_models_fn is None
-        ):
-            ui.notify("Something went wrong...", type="warning")
+        """Remove a model from the project."""
+        if not self._validate_model_operation(model):
             return
 
         self.models.remove(model)
-        self.deselect_model_fn()
-        self.render_models_fn()
+        self._cleanup_relationships_for_deleted_model(model.name)
+        self._deselect_current_model()
+        self._trigger_ui_refresh()
 
     def update_model_name(self, model: Model, new_name: str) -> None:
+        """Rename an existing model."""
         if model.name == new_name:
             return
 
-        if any(m.name == new_name for m in self.models if m != model):
-            n.notify_model_exists(new_name)
+        if self._model_exists(new_name, exclude=model):
+            notify_model_exists(new_name)
             return
 
         old_name = model.name
         model.name = new_name
         self._update_relationships_for_rename(old_name, new_name)
 
-        if self.select_model_fn and model == self.selected_model:
+        if model == self.selected_model and self.select_model_fn:
             self.select_model_fn(model)
 
-        if self.render_models_fn:
-            self.render_models_fn()
-
-        self.render_model_editor_fn()
+        self._trigger_ui_refresh()
 
     def select_model(self, model: Model) -> None:
-        if self.selected_model == model:
+        """Set the currently selected model."""
+        if self.selected_model == model or not self._validate_ui_callbacks():
             return
-        # print("selecting")
 
-        if (
-            self.select_model_fn is None
-            or self.render_models_fn is None
-            or self.deselect_model_fn is None
-        ):
-            n.notify_something_went_wrong()
-            return
         self.selected_model = model
-        self.select_model_fn(model)
-
-        if model not in self.models:
-            self.deselect_model_fn()
-
-        self.render_models_fn()
+        self.select_model_fn(model)  # type: ignore
+        self._trigger_ui_refresh()
 
     def get_project_spec(self) -> ProjectSpec:
+        """Generate a ProjectSpec from the current state."""
         return ProjectSpec(
             project_name=self.project_name,
             use_postgres=self.use_postgres,
@@ -135,26 +113,70 @@ def get_project_spec(self) -> ProjectSpec:
             models=self.models,
         )
 
-    def _cleanup_relationships_for_deleted_model(
-        self,
-        deleted_model_name: str,
-    ) -> None:
+    def _create_default_model(self, name: str) -> Model:
+        """Create a new model with default fields."""
+        return Model(
+            name=name,
+            fields=[
+                ModelField(
+                    name="id",
+                    type=FieldDataType.UUID,
+                    primary_key=True,
+                    nullable=False,
+                    unique=True,
+                    index=True,
+                )
+            ],
+        )
+
+    def _cleanup_relationships_for_deleted_model(self, deleted_model_name: str) -> None:
+        """Remove relationships pointing to deleted models."""
         for model in self.models:
             model.relationships = [
                 rel
                 for rel in model.relationships
                 if rel.target_model != deleted_model_name
             ]
 
-    def _update_relationships_for_rename(
-        self,
-        old_name: str,
-        new_name: str,
-    ) -> None:
+    def _update_relationships_for_rename(self, old_name: str, new_name: str) -> None:
+        """Update relationships when a model is renamed."""
         for model in self.models:
             for relationship in model.relationships:
                 if relationship.target_model == old_name:
                     relationship.target_model = new_name
 
+    def _model_exists(self, name: str, exclude: Model | None = None) -> bool:
+        """Check if a model with the given name already exists."""
+        return any(model.name == name for model in self.models if model != exclude)
+
+    def _validate_ui_callbacks(self) -> bool:
+        """Verify required UI callbacks are set."""
+        if not all([self.render_models_fn, self.select_model_fn]):
+            notify_something_went_wrong()
+            return False
+        return True
+
+    def _validate_model_operation(self, model: Model) -> bool:
+        """Validate conditions for model operations."""
+        if model not in self.models or not all(
+            [self.deselect_model_fn, self.render_models_fn]
+        ):
+            ui.notify("Something went wrong...", type="warning")
+            return False
+        return True
+
+    def _deselect_current_model(self) -> None:
+        """Clear current model selection."""
+        if self.deselect_model_fn:
+            self.deselect_model_fn()
+        self.selected_model = None
+
+    def _trigger_ui_refresh(self) -> None:
+        """Refresh all relevant UI components."""
+        if self.render_models_fn:
+            self.render_models_fn()
+        if self.render_model_editor_fn:
+            self.render_model_editor_fn()
+
 
 state: ProjectState = ProjectState()

pyproject.toml

@@ -70,6 +70,7 @@ ignore = [
     "TD003",
     "FIX002",
     "PLR0913",
+    "PGH003",
     "S701",
 ]