feat: support custom postgres enums (#30)

Author: mslaursen

fastapi_forge/__main__.py

@@ -53,15 +53,16 @@ def start(
         yaml_path = Path(from_yaml).expanduser().resolve()
         if not yaml_path.is_file():
             raise click.FileError(f"YAML file not found: {yaml_path}")
-        project_spec = ProjectLoader(project_path=yaml_path).load_project_input()
+        project_spec = ProjectLoader(project_path=yaml_path).load_project()
     elif db_url:
-        project_spec = ProjectLoader.load_project_spec_from_db(
+        project_spec = ProjectLoader.load_project_from_db(
             connection_string=db_url,
         )
     elif use_example:
         base_path = Path(__file__).parent / "example-projects"
         path = base_path / "game_zone.yaml"
-        project_spec = ProjectLoader(project_path=path).load_project_input()
+
+        project_spec = ProjectLoader(project_path=path).load_project()
 
     init(project_spec=project_spec, no_ui=no_ui)
 

fastapi_forge/constants.py

@@ -0,0 +1 @@
+TAB = "    "

fastapi_forge/dtos.py

@@ -9,19 +9,31 @@
     model_validator,
 )
 
-from fastapi_forge.data_type_registry import DataTypeInfo, registry
+from fastapi_forge.constants import TAB
 from fastapi_forge.enums import FieldDataTypeEnum, OnDeleteEnum
 from fastapi_forge.string_utils import camel_to_snake_hyphen, snake_to_camel
+from fastapi_forge.type_info_registry import TypeInfo, enum_registry, registry
 
 BoundedStr = Annotated[str, Field(..., min_length=1, max_length=100)]
 SnakeCaseStr = Annotated[BoundedStr, Field(..., pattern=r"^[a-z][a-z0-9_]*$")]
+PascalCaseStr = Annotated[
+    BoundedStr,
+    Field(..., pattern=r"^[A-Z][a-zA-Z0-9]*$"),
+]
 ModelName = SnakeCaseStr
 FieldName = SnakeCaseStr
 BackPopulates = Annotated[str, Field(..., pattern=r"^[a-z][a-z0-9_]*$")]
 ProjectName = Annotated[
     BoundedStr,
     Field(..., pattern=r"^[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?$"),
 ]
+EnumStr = Annotated[
+    BoundedStr,
+    Field(
+        ...,
+        pattern=r"^[a-zA-Z][a-zA-Z0-9_]*$",
+    ),
+]
 
 
 class _Base(BaseModel):
@@ -36,11 +48,67 @@ class ModelFieldMetadata(_Base):
     is_foreign_key: bool = False
 
 
+class CustomEnumValue(_Base):
+    """Represents a single name/value pair in a custom enum."""
+
+    name: EnumStr
+    value: BoundedStr
+
+
+class CustomEnum(_Base):
+    """Represents a custom PostgreSQL ENUM type."""
+
+    name: EnumStr
+    values: list[CustomEnumValue] = []
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        # dynamically register in the enum registry on instantiation
+        enum_repr = f"enums.{self.name}"
+        enum_value_repr = f"{enum_repr}.{self.values[0].name}"
+        enum_registry.register(
+            self.name,
+            TypeInfo(
+                sqlalchemy_type=f"Enum({enum_repr})",
+                sqlalchemy_prefix=True,
+                python_type=enum_repr,
+                faker_field_value=enum_value_repr,
+                value=enum_value_repr,
+                test_value=enum_value_repr,
+            ),
+        )
+
+    @model_validator(mode="after")
+    def _validate_enum(self) -> Self:
+        names = [v.name for v in self.values]
+
+        if len(names) != len(set(names)):
+            raise ValueError(f"Enum '{self.name}' has duplicate names.")
+        return self
+
+    @computed_field
+    @property
+    def class_definition(self) -> str:
+        """Returns a string representing the Python Enum class definition."""
+        lines: list[str] = []
+        lines.extend([f"class {self.name}(StrEnum):"])
+        lines.extend([f'{TAB}"""{self.name} Enum."""\n'])
+
+        value_lines: list[str] = []
+        for v in self.values:
+            value_repr = v.value if v.value == "auto()" else f'"{v.value}"'
+            value_lines.extend([f"{TAB}{v.name} = {value_repr}"])
+
+        lines.extend(value_lines)
+        return "\n".join(lines)
+
+
 class ModelField(_Base):
     """Represents a field in a model with validation and computed properties."""
 
     name: FieldName
     type: FieldDataTypeEnum
+    type_enum: EnumStr | None = None
     primary_key: bool = False
     nullable: bool = False
     unique: bool = False
@@ -58,9 +126,32 @@ def name_cc(self) -> str:
 
     @computed_field
     @property
-    def type_info(self) -> DataTypeInfo:
+    def type_info(self) -> TypeInfo:
+        if self.type_enum:
+            return enum_registry.get(self.type_enum)
         return registry.get(self.type)
 
+    @model_validator(mode="after")
+    def _validate_type(self) -> Self:
+        if self.type == FieldDataTypeEnum.Enum and self.type_enum is None:
+            msg = (
+                f"ModelField '{self.name}' has field type 'ENUM', "
+                "but is missing 'type_enum'."
+            )
+            raise ValueError(msg)
+
+        if self.type_enum and self.type != FieldDataTypeEnum.Enum:
+            msg = (
+                f"ModelField '{self.name}' has 'type_enum' set, "
+                "but is not field type 'ENUM'."
+            )
+            raise ValueError(msg)
+
+        # if self.type_enum and self.default_value:
+        #     self.default_value = f"enums.{self.type_enum.name}.{self.default_value}"
+
+        return self
+
     @model_validator(mode="after")
     def _validate(self) -> Self:
         """Validate field constraints."""
@@ -183,10 +274,10 @@ def _validate(self) -> Self:
         if sum(field.primary_key for field in self.fields) != 1:
             raise ValueError(f"Model '{self.name}' must have exactly one primary key.")
 
-        unque_relationships = [
+        unique_relationships = [
             relationship.field_name for relationship in self.relationships
         ]
-        if len(unque_relationships) != len(set(unque_relationships)):
+        if len(unique_relationships) != len(set(unique_relationships)):
             raise ValueError(
                 f"Model '{self.name}' contains duplicate relationship field names.",
             )
@@ -277,6 +368,7 @@ class ProjectSpec(_Base):
     use_rabbitmq: bool = False
     use_taskiq: bool = False
     models: list[Model] = []
+    custom_enums: list[CustomEnum] = []
 
     @model_validator(mode="after")
     def _validate_models(self) -> Self:
@@ -286,6 +378,11 @@ def _validate_models(self) -> Self:
             msg = "Model names must be unique."
             raise ValueError(msg)
 
+        enum_names = [enum.name for enum in self.custom_enums]
+        if len(enum_names) != len(set(enum_names)):
+            msg = "Enum names must be unique."
+            raise ValueError(msg)
+
         if self.use_alembic and not self.use_postgres:
             msg = "Cannot use Alembic if PostgreSQL is not enabled."
             raise ValueError(msg)
@@ -322,6 +419,7 @@ def _validate_models(self) -> Self:
                     "TaskIQ is enabled, but the following are missing and required "
                     f"for its operation: {', '.join(missing)}."
                 )
+
         return self
 
     @model_validator(mode="after")

fastapi_forge/enums.py

@@ -10,6 +10,7 @@ class FieldDataTypeEnum(StrEnum):
     DATETIME = "DateTime"
     UUID = "UUID"
     JSONB = "JSONB"
+    Enum = "Enum"
 
     @classmethod
     @lru_cache

fastapi_forge/example-projects/game_zone.yaml

@@ -7,6 +7,14 @@ project:
   use_rabbitmq: true
   use_taskiq: true
 
+  custom_enums:
+    - name: UserRole
+      values:
+        - name: ADMIN
+          value: auto()
+        - name: USER
+          value: auto()
+
   models:
     - name: auth_user
       fields:
@@ -19,6 +27,10 @@ project:
           index: true
         - name: password
           type: String
+        - name: role
+          type: Enum
+          type_enum: UserRole 
+          default_value: USER
         - name: created_at
           type: DateTime
           default_value: datetime.now(timezone.utc)

fastapi_forge/frontend/__init__.py

@@ -1,7 +1,9 @@
 from fastapi_forge.frontend.components.header import Header
-from fastapi_forge.frontend.components.model_create import ModelCreate
-from fastapi_forge.frontend.components.model_row import ModelRow
-from fastapi_forge.frontend.panels.model_panel import ModelPanel
+from fastapi_forge.frontend.components.item_create import ModelCreate, EnumCreate
+from fastapi_forge.frontend.components.item_row import ModelRow, EnumRow
+from fastapi_forge.frontend.panels.left_panel import LeftPanel
 from fastapi_forge.frontend.panels.model_editor_panel import ModelEditorPanel
+from fastapi_forge.frontend.panels.enum_editor_panel import EnumEditorPanel
 from fastapi_forge.frontend.panels.project_config_panel import ProjectConfigPanel
+from fastapi_forge.frontend.panels.item_editor_panel import ItemEditorPanel
 from fastapi_forge.frontend.main import init

fastapi_forge/frontend/components/item_create.py

@@ -0,0 +1,67 @@
+from collections.abc import Callable
+
+from nicegui import ui
+
+from fastapi_forge.frontend.state import state
+
+
+class _RowCreate(ui.row):
+    def __init__(
+        self,
+        *,
+        input_placeholder: str,
+        input_tooltip: str,
+        button_tooltip: str,
+        on_add_item: Callable[[str], None],
+    ):
+        super().__init__(wrap=False)
+        self.input_placeholder = input_placeholder
+        self.input_tooltip = input_tooltip
+        self.button_tooltip = button_tooltip
+        self.on_add_item = on_add_item
+
+        self._build()
+
+    def _build(self) -> None:
+        with self.classes("w-full flex items-center justify-between"):
+            self.item_input = (
+                ui.input(placeholder=self.input_placeholder)
+                .classes("self-center")
+                .tooltip(
+                    self.input_tooltip,
+                )
+            )
+            self.add_button = (
+                ui.button(icon="add", on_click=self._add_item)
+                .classes("self-center")
+                .tooltip(self.button_tooltip)
+            )
+
+    def _add_item(self) -> None:
+        if not self.item_input.value:
+            return
+        value: str = self.item_input.value
+        item_name = value.strip()
+        if item_name:
+            self.on_add_item(item_name)
+            self.item_input.value = ""
+
+
+class ModelCreate(_RowCreate):
+    def __init__(self):
+        super().__init__(
+            input_placeholder="Model name",
+            input_tooltip="Model names should be singular (e.g., 'user' instead of 'users').",
+            button_tooltip="Add Model",
+            on_add_item=state.add_model,
+        )
+
+
+class EnumCreate(_RowCreate):
+    def __init__(self):
+        super().__init__(
+            input_placeholder="Enum name",
+            input_tooltip="Enums can be used as data types for model fields.",
+            button_tooltip="Add Enum",
+            on_add_item=state.add_enum,
+        )