update: database loading improved (#34)

Author: mslaursen

fastapi_forge/__main__.py

@@ -28,23 +28,23 @@ def main() -> None:
     help="Generate a project using a custom configuration from a YAML file.",
 )
 @click.option(
-    "--db-url",
-    help="PostgreSQL connection URL (e.g., postgresql://user:password@host:port/dbname)",
+    "--conn-string",
+    help="PostgreSQL connection string (e.g., postgresql://user:password@host:port/dbname)",
 )
 def start(
     use_example: bool = False,
     no_ui: bool = False,
     from_yaml: str | None = None,
-    db_url: str | None = None,
+    conn_string: str | None = None,
 ) -> None:
     """Start the FastAPI Forge server and generate a new project."""
-    option_count = sum([use_example, bool(from_yaml), bool(db_url)])
+    option_count = sum([use_example, bool(from_yaml), bool(conn_string)])
     if option_count > 1:
-        msg = "Only one of '--use-example', '--from-yaml', or '--db-url' can be used."
+        msg = "Only one of '--use-example', '--from-yaml', or '--conn-string' can be used."
         raise click.UsageError(msg)
 
     if no_ui and option_count < 1:
-        msg = "Option '--no-ui' requires one of '--use-example', '--from-yaml', or '--db-url' to be set."
+        msg = "Option '--no-ui' requires one of '--use-example', '--from-yaml', or '--conn-string' to be set."
         raise click.UsageError(msg)
 
     project_spec = None
@@ -53,16 +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()
-    elif db_url:
-        project_spec = ProjectLoader.load_project_from_db(
-            connection_string=db_url,
+        project_spec = ProjectLoader(project_path=yaml_path).load()
+    elif conn_string:
+        project_spec = ProjectLoader.load_from_conn_string(
+            conn_string=conn_string,
         )
     elif use_example:
         base_path = Path(__file__).parent / "example-projects"
         path = base_path / "game_zone.yaml"
 
-        project_spec = ProjectLoader(project_path=path).load_project()
+        project_spec = ProjectLoader(project_path=path).load()
 
     init(project_spec=project_spec, no_ui=no_ui)
 

fastapi_forge/dtos.py

@@ -11,7 +11,11 @@
 
 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.string_utils import (
+    camel_to_snake,
+    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)]
@@ -65,11 +69,13 @@ 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_value_repr = (
+            None if not self.values else f"{enum_repr}.{self.values[0].name}"
+        )
         enum_registry.register(
             self.name,
             TypeInfo(
-                sqlalchemy_type=f"Enum({enum_repr})",
+                sqlalchemy_type=f'Enum({enum_repr}, name="{camel_to_snake(self.name)}")',
                 sqlalchemy_prefix=True,
                 python_type=enum_repr,
                 faker_field_value=enum_value_repr,
@@ -147,9 +153,6 @@ def _validate_type(self) -> Self:
             )
             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")
@@ -422,44 +425,6 @@ def _validate_models(self) -> Self:
 
         return self
 
-    @model_validator(mode="after")
-    def _validate_circular_references(self) -> Self:
-        relationship_graph = {}
-
-        model_names = {model.name for model in self.models}
-
-        for model in self.models:
-            relationship_graph[model.name] = [
-                rel.target_model
-                for rel in model.relationships
-                if rel.target_model in model_names
-            ]
-
-        visited = set()
-        path = set()
-
-        def has_cycle(node):
-            if node in visited:
-                return False
-            visited.add(node)
-            path.add(node)
-
-            for neighbor in relationship_graph.get(node, []):
-                if neighbor in path or has_cycle(neighbor):
-                    return True
-
-            path.remove(node)
-            return False
-
-        for model_name in relationship_graph:
-            if has_cycle(model_name):
-                raise ValueError(
-                    f"Circular reference detected involving model '{model_name}'. "
-                    "Remove bidirectional relationships between models.",
-                )
-
-        return self
-
     def get_auth_model(self) -> Model | None:
         if not self.use_builtin_auth:
             return None

fastapi_forge/enums.py

@@ -16,7 +16,13 @@ class FieldDataTypeEnum(StrEnum):
     @lru_cache
     def get_type_mappings(cls) -> dict[str, list[str]]:
         return {
-            cls.STRING: ["character varying", "text", "varchar", "char"],
+            cls.STRING: [
+                "character varying",
+                "text",
+                "varchar",
+                "char",
+                "user-defined",
+            ],
             cls.INTEGER: [
                 "integer",
                 "int",

fastapi_forge/jinja.py

@@ -4,7 +4,6 @@
 
 from fastapi_forge.dtos import (
     CustomEnum,
-    CustomEnumValue,
     Model,
     ModelField,
 )
@@ -26,7 +25,7 @@
 
 
 {% set unique_relationships = model.relationships | unique(attribute='target') %}
-{% for relation in unique_relationships -%}
+{% for relation in unique_relationships if relation.target != model.name_cc -%}
 from src.models.{{ relation.target_model }}_models import {{ relation.target }}
 {% endfor %}
 
@@ -43,7 +42,7 @@ class {{ model.name_cc }}(Base):
     {% endfor %}
 
     {% for relation in model.relationships -%}
-    {{ relation | generate_relationship }}
+    {{ relation | generate_relationship(model.name_cc == relation.target) }}
     {% endfor %}
 """
 
@@ -182,8 +181,10 @@ async def get_{{ model.name }}(
 import pytest
 from tests import factories
 from src.daos import AllDAOs
+from src import enums
 from httpx import AsyncClient
 from datetime import datetime, timezone,  timedelta
+from uuid import uuid4
 
 
 from typing import Any
@@ -200,11 +201,11 @@ async def test_post_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> Non
     {%- endfor %}
 
     input_json = {
-        {%- for field in model.fields  if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key) -%}
-        {%- if not field.primary_key and field.name.endswith('_id') -%}
+        {%- for field in model.fields  if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key or not field.type_info.test_value) -%}
+        {%- if not field.primary_key and field.name.endswith('_id') and field.metadata.is_foreign_key -%}
         "{{ field.name }}": str({{ field.name | replace('_id', '.id') }}),
         {%- elif not field.primary_key %}
-        "{{ field.name }}": {{ field.type_info.test_value }}{{ field.type_info.test_func }},
+        "{{ field.name }}": {{ field.type_info.test_value }}{{ field.type_info.test_func if field.type_info.test_func else '' }},
         {%- endif %}
         {%- endfor %}
     }
@@ -216,11 +217,19 @@ async def test_post_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> Non
     db_{{ model.name }} = await daos.{{ model.name }}.filter_first(id=response_data["id"])
 
     assert db_{{ model.name }} is not None
-    {%- for field in model.fields  if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key) %}
-    {%- if not field.primary_key and field.name.endswith('_id') %}
-    assert db_{{ model.name }}.{{ field.name }} == UUID(input_json["{{ field.name }}"])
+    {%- for field in model.fields if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key or not field.type_info.test_value) %}
+    {%- if not field.primary_key and field.metadata.is_foreign_key %}
+        {%- if field.type_info.encapsulate_assert %}
+    assert db_{{ model.name }}.{{ field.name }} == {{ field.type_info.encapsulate_assert }}(input_json["{{ field.name }}"])
+        {%- else %}
+    assert db_{{ model.name }}.{{ field.name }} == input_json["{{ field.name }}"]
+        {%- endif %}
     {%- elif not field.primary_key %}
-    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func }} == input_json["{{ field.name }}"]
+        {%- if field.type_info.encapsulate_assert %}
+    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func if field.type_info.test_func else '' }} == {{ field.type_info.encapsulate_assert }}(input_json["{{ field.name }}"])
+        {%- else %}
+    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func if field.type_info.test_func else '' }} == input_json["{{ field.name }}"]
+        {%- endif %}
     {%- endif %}
     {%- endfor %}
 """
@@ -278,7 +287,7 @@ async def test_get_{{ model.name }}_by_id(client: AsyncClient,) -> None:
     {%- if not field.primary_key and field.name.endswith('_id') %}
     assert response_data["{{ field.name }}"] == str({{ model.name }}.{{ field.name }})
     {%- elif not field.primary_key %}
-    assert response_data["{{ field.name }}"] == {{ model.name }}.{{ field.name }}{{ field.type_info.test_func }}
+    assert response_data["{{ field.name }}"] == {{ model.name }}.{{ field.name }}{{ field.type_info.test_func if field.type_info.test_func else '' }}
     {%- endif %}
     {%- endfor %}
 """
@@ -287,8 +296,10 @@ async def test_get_{{ model.name }}_by_id(client: AsyncClient,) -> None:
 import pytest
 from tests import factories
 from src.daos import AllDAOs
+from src import enums
 from httpx import AsyncClient
 from datetime import datetime, timezone,  timedelta
+from uuid import uuid4
 
 
 from typing import Any
@@ -306,11 +317,11 @@ async def test_patch_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> No
     {{ model.name }} = await factories.{{ model.name_cc }}Factory.create()
 
     input_json = {
-        {%- for field in model.fields  if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key) -%}
-        {%- if not field.primary_key and field.name.endswith('_id') -%}
+        {%- for field in model.fields  if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key or not field.type_info.test_value) -%}
+        {%- if not field.primary_key and field.name.endswith('_id') and field.metadata.is_foreign_key -%}
         "{{ field.name }}": str({{ field.name | replace('_id', '.id') }}),
         {% elif not field.primary_key %}
-        "{{ field.name }}": {{ field.type_info.test_value }}{{ field.type_info.test_func }},
+        "{{ field.name }}": {{ field.type_info.test_value }}{{ field.type_info.test_func if field.type_info.test_func else '' }},
         {%- endif %}
         {%- endfor %}
     }
@@ -321,11 +332,19 @@ async def test_patch_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> No
     db_{{ model.name }} = await daos.{{ model.name }}.filter_first(id={{ model.name }}.id)
 
     assert db_{{ model.name }} is not None
-    {%- for field in model.fields  if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key) %}
-    {%- if not field.primary_key and field.name.endswith('_id') %}
+    {%- for field in model.fields if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key or not field.type_info.test_value) %}
+    {%- if not field.primary_key and field.metadata.is_foreign_key %}
+        {%- if field.type_info.encapsulate_assert %}
+    assert db_{{ model.name }}.{{ field.name }} == {{ field.type_info.encapsulate_assert }}(input_json["{{ field.name }}"])
+        {%- else %}
     assert db_{{ model.name }}.{{ field.name }} == UUID(input_json["{{ field.name }}"])
+        {%- endif %}
     {%- elif not field.primary_key %}
-    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func }} == input_json["{{ field.name }}"]
+        {%- if field.type_info.encapsulate_assert %}
+    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func if field.type_info.test_func else '' }} == {{ field.type_info.encapsulate_assert }}(input_json["{{ field.name }}"])
+        {%- else %}
+    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func if field.type_info.test_func else '' }} == input_json["{{ field.name }}"]
+        {%- endif %}
     {%- endif %}
     {%- endfor %}
 
@@ -454,8 +473,8 @@ def render_custom_enums_to_enums(custom_enums: list[CustomEnum]) -> str:
     enum0 = CustomEnum(
         name="MyEnum0",
         values=[
-            CustomEnumValue(name="FoO", value="foo"),
-            CustomEnumValue(name="BAR", value="bar"),
+            # CustomEnumValue(name="FoO", value="foo"),
+            # CustomEnumValue(name="BAR", value="bar"),
         ],
     )
 
@@ -480,4 +499,4 @@ def render_custom_enums_to_enums(custom_enums: list[CustomEnum]) -> str:
             ),
         ],
     )
-    print(render_model_to_model(model))
+    print(render_model_to_post_test(model))

fastapi_forge/jinja_utils.py

@@ -58,16 +58,18 @@ def generate_field(
     return _gen_field(field=field, target=target)
 
 
-def generate_relationship(relation: ModelRelationship) -> str:
+def generate_relationship(
+    relation: ModelRelationship, is_self_reference: bool = False
+) -> str:
     args = []
-    args.append(f'"{relation.target}"')
     args.append(f"foreign_keys=[{relation.field_name}]")
     if relation.back_populates:
         args.append(f'back_populates="{relation.back_populates}"')
     args.append("uselist=False")
 
+    target_repr = relation.target if not is_self_reference else f'"{relation.target}"'
     return f"""
-    {relation.field_name_no_id}: Mapped[{relation.target}] = relationship(
+    {relation.field_name_no_id}: Mapped[{target_repr}] = relationship(
         {",\n        ".join(args)}
     )
     """.strip()