DataTypeInfo

Author: mslaursen

fastapi_forge/enums.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
-from typing import Any
+from uuid import uuid4
 
 
 class HTTPMethod(StrEnum):
@@ -20,8 +20,8 @@ class FieldDataType(StrEnum):
     JSONB = "JSONB"
 
 
+# register a DataTypeInfo with a FieldDataType to make it easier to support types
 class DataTypeInfo:
-
     def __init__(
         self,
         pydantic_annotation: str,
@@ -31,7 +31,7 @@ def __init__(
         faker_generator: str,
         value: str,
         test_value: str,
-        test_func: str,
+        test_func: str = "",
     ):
         self.pydantic_annotation = pydantic_annotation
         self.sqlalchemy_type = sqlalchemy_type
@@ -67,27 +67,92 @@ def all(self) -> list[DataTypeInfo]:
 registry.register(
     FieldDataType.STRING,
     DataTypeInfo(
-        pydantic_annotation="",
+        pydantic_annotation="str",
         sqlalchemy_type="String",
         sqlalchemy_prefix=False,
         python_type="str",
         faker_generator="text",
         value="hello",
-        test_value='"world"',
+        test_value="'world'",
         test_func="",
     ),
 )
 
+registry.register(
+    FieldDataType.INTEGER,
+    DataTypeInfo(
+        pydantic_annotation="int",
+        sqlalchemy_type="Integer",
+        sqlalchemy_prefix=False,
+        python_type="int",
+        faker_generator="random_int",
+        value="1",
+        test_value="2",
+    ),
+)
+
+registry.register(
+    FieldDataType.FLOAT,
+    DataTypeInfo(
+        pydantic_annotation="float",
+        sqlalchemy_type="Float",
+        sqlalchemy_prefix=False,
+        python_type="float",
+        faker_generator="pyfloat",
+        value="1.0",
+        test_value="2.0",
+    ),
+)
+
+registry.register(
+    FieldDataType.BOOLEAN,
+    DataTypeInfo(
+        pydantic_annotation="bool",
+        sqlalchemy_type="Boolean",
+        sqlalchemy_prefix=False,
+        python_type="bool",
+        faker_generator="boolean",
+        value="True",
+        test_value="False",
+    ),
+)
+
 registry.register(
     FieldDataType.DATETIME,
     DataTypeInfo(
-        pydantic_annotation="",
+        pydantic_annotation="datetime",
         sqlalchemy_type="DateTime",
         sqlalchemy_prefix=False,
         python_type="datetime",
-        faker_generator="text",
+        faker_generator="date_time",
         value="datetime.now(timezone.utc)",
         test_value="datetime.now(timezone.utc)",
         test_func=".isoformat()",
     ),
 )
+
+registry.register(
+    FieldDataType.UUID,
+    DataTypeInfo(
+        pydantic_annotation="UUID",
+        sqlalchemy_type="UUID",
+        sqlalchemy_prefix=False,
+        python_type="UUID",
+        faker_generator="uuid4",
+        value=str(uuid4()),
+        test_value=str(uuid4()),
+    ),
+)
+
+registry.register(
+    FieldDataType.JSONB,
+    DataTypeInfo(
+        pydantic_annotation="dict[str, Any]",
+        sqlalchemy_type="JSONB",
+        sqlalchemy_prefix=True,
+        python_type="dict",
+        faker_generator="TODO",
+        value="{}",
+        test_value='{"key": "value"}',
+    ),
+)

fastapi_forge/jinja.py

@@ -5,7 +5,6 @@
 from fastapi_forge.dtos import (
     Model,
     ModelField,
-    ModelFieldMetadata,
     ModelMetadata,
     ModelRelationship,
 )
@@ -68,7 +67,7 @@ class {{ model.name_cc }}InputDTO(BaseModel):
     \"\"\"{{ model.name_cc }} input DTO.\"\"\"
 
     {% for field in model.fields_sorted if not (field.metadata.is_created_at_timestamp or field.metadata.is_updated_at_timestamp or field.primary_key) -%}
-    {{ field.name }}: {{ type_mapping[field.type] }}{% if field.nullable %} | None{% endif %}
+    {{ field.name }}: {{ field.type_info.python_type }}{% if field.nullable %} | None{% endif %}
     {% endfor %}
 
 
@@ -267,11 +266,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 %}
-    {%- if field.type == "DateTime" %}
-    assert response_data["{{ field.name }}"] == {{ model.name }}.{{ field.name }}.isoformat()
-    {%- else %}
-    assert response_data["{{ field.name }}"] == {{ model.name }}.{{ field.name }}
-    {%- endif %}
+    assert response_data["{{ field.name }}"] == {{ model.name }}.{{ field.name }}{{ field.type_info.test_func }}
     {%- endif %}
     {%- endfor %}
 """
@@ -301,11 +296,7 @@ async def test_patch_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> No
         {%- if not field.primary_key and field.name.endswith('_id') -%}
         "{{ field.name }}": str({{ field.name | replace('_id', '.id') }}),
         {% elif not field.primary_key %}
-        {%- if field.type == "DateTime" %}
-        "{{ field.name }}": {{ type_to_input_value_mapping[field.type] }}.isoformat(),
-        {%- else %}
-        "{{ field.name }}": {{ type_to_input_value_mapping[field.type] }},
-        {%- endif %}
+        "{{ field.name }}": {{ field.type_info.test_value }}{{ field.type_info.test_func }},
         {%- endif %}
         {%- endfor %}
     }
@@ -320,11 +311,7 @@ async def test_patch_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> No
     {%- if not field.primary_key and field.name.endswith('_id') %}
     assert db_{{ model.name }}.{{ field.name }} == UUID(input_json["{{ field.name }}"])
     {%- elif not field.primary_key %}
-    {%- if field.type == "DateTime" %}
-    assert db_{{ model.name }}.{{ field.name }}.isoformat() == input_json["{{ field.name }}"]
-    {%- else %}
-    assert db_{{ model.name }}.{{ field.name }} == input_json["{{ field.name }}"]
-    {%- endif %}
+    assert db_{{ model.name }}.{{ field.name }}{{ field.type_info.test_func }} == input_json["{{ field.name }}"]
     {%- endif %}
     {%- endfor %}
 
@@ -353,26 +340,6 @@ async def test_delete_{{ model.name }}(client: AsyncClient, daos: AllDAOs,) -> N
     assert db_{{ model.name }} is None
 """
 
-TYPE_MAPPING = {
-    "Integer": "int",
-    "Float": "float",
-    "String": "str",
-    "UUID": "UUID",
-    "DateTime": "datetime",
-    "JSONB": "dict[str, Any]",
-    "Boolean": "bool",
-}
-
-TYPE_TO_INPUT_VALUE_MAPPING = {
-    "Integer": "1",
-    "Float": "1.0",
-    "String": "'string'",
-    "UUID": "UUID('00000000-0000-0000-0000-000000000000')",
-    "DateTime": "datetime.now(timezone.utc)",
-    "JSONB": '{"json": "value"}',
-    "Boolean": "True",
-}
-
 
 def _render(model: Model, template_name: str, **kwargs: Any) -> str:
     template = env.from_string(template_name)
@@ -490,15 +457,15 @@ def render_model_to_delete_test(model: Model) -> str:
     ]
 
     render_funcs = [
-        # render_model_to_model,
-        # render_model_to_dto,
-        # render_model_to_dao,
-        # render_model_to_routers,
+        render_model_to_model,
+        render_model_to_dto,
+        render_model_to_dao,
+        render_model_to_routers,
         render_model_to_post_test,
-        # render_model_to_get_test,
-        # render_model_to_get_id_test,
-        # render_model_to_patch_test,
-        # render_model_to_delete_test,
+        render_model_to_get_test,
+        render_model_to_get_id_test,
+        render_model_to_patch_test,
+        render_model_to_delete_test,
     ]
 
     for fn in render_funcs:

fastapi_forge/jinja_utils.py

@@ -6,7 +6,6 @@ def _gen_field(
     field: ModelField,
     target: str | None = None,
 ) -> str:
-
     type_info = field.type_info
     args = [
         f"{'sa.' if type_info.sqlalchemy_prefix else ''}{type_info.sqlalchemy_type}"