fastapi-rtk 2.11.1__tar.gz → 2.11.2__tar.gz

{fastapi_rtk-2.11.1 → fastapi_rtk-2.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.11.1
+Version: 2.11.2
 Summary: A package that provides a set of tools to build a FastAPI application with a Class-Based CRUD API.
 Project-URL: Homepage, https://codeberg.org/datatactics/fastapi-rtk
 Project-URL: Issues, https://codeberg.org/datatactics/fastapi-rtk/issues

fastapi_rtk-2.11.2/fastapi_rtk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.11.2"

{fastapi_rtk-2.11.1 → fastapi_rtk-2.11.2}/fastapi_rtk/api/model_rest_api/_columns_mixin.py

@@ -47,6 +47,8 @@ from ...utils import (
 )
 from ._typed_base import _TypedModelRestApi
 
+_UNUSED_SCHEMA_KEYS = ("anyOf", "default", "$ref", "const")
+
 
 class ColumnsMixin(_TypedModelRestApi):
     """
@@ -546,6 +548,8 @@ class ColumnsMixin(_TypedModelRestApi):
                 [ColumnInfo | ColumnEnumInfo | ColumnRelationInfo | None], bool
             ],
         ] = False,
+        *,
+        mark_non_nullable_required: bool = False,
     ):
         """
         Generate the JSONForms schema for the API.
@@ -555,6 +559,7 @@ class ColumnsMixin(_TypedModelRestApi):
             info_columns (list[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo]): The list of columns to include in the JSONForms schema.
             use_enum (bool | Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool] | dict[str, bool | Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo], bool]], optional): A flag or a callable or a dictionary to determine whether to use enum instead of oneOf. Defaults to False.
             list_as_object (bool | Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo | None], bool] | dict[str, bool | Callable[[ColumnInfo | ColumnEnumInfo | ColumnRelationInfo | None], bool]], optional): A flag or a callable or a dictionary to determine whether to render a list column as a single `object` control instead of the per-item `array` table. The callable receives the column's `ColumnInfo` when available, else `None`. Defaults to False.
+            mark_non_nullable_required (bool, optional): Whether to also mark every non-nullable column present in `properties` as required, in addition to whatever pydantic already marked, excluding `password`-formatted properties, which are never sent back to the client and would force a retype on every edit, and `readOnly` properties, which cannot be filled at all. Defaults to False.
 
         Returns:
             dict[str, typing.Any]: The generated JSONForms schema.
@@ -594,8 +599,15 @@ class ColumnsMixin(_TypedModelRestApi):
                 )
                 if self.datamodel.is_files(key) or self.datamodel.is_images(key):
                     current_value = value.copy()
+                    for unused_key in _UNUSED_SCHEMA_KEYS:
+                        current_value.pop(unused_key, None)
+                    # JsonForms seeds an inserted row from this default, and a null row must fail so an empty slot cannot be submitted.
+                    current_value["default"] = None
                     value["type"] = "array"
                     value["items"] = current_value
+                    # The file keys belong on the leaf; nothing reads them off the array wrapper.
+                    value.pop("x-file-types", None)
+                    value.pop("contentMediaType", None)
             elif self.datamodel.is_boolean(key):
                 value["type"] = "boolean"
             elif self.datamodel.is_integer(key):
@@ -676,12 +688,15 @@ class ColumnsMixin(_TypedModelRestApi):
             # Check whether it is nullable
             if self.datamodel.is_nullable(key):
                 value["type"] = [value["type"], "null"]
+                # With setNull on, a cleared field writes a real null, which ajv checks against enum / oneOf regardless of the null type member.
+                if "enum" in value:
+                    value["enum"] = [None, *value["enum"]]
+                elif "oneOf" in value:
+                    value["oneOf"] = [{"const": None, "title": ""}, *value["oneOf"]]
 
             # Remove unused vars
-            value.pop("anyOf", None)
-            value.pop("default", None)
-            value.pop("$ref", None)
-            value.pop("const", None)
+            for unused_key in _UNUSED_SCHEMA_KEYS:
+                value.pop(unused_key, None)
 
             # Check whether the value should be a `secret`
             if key in g.sensitive_data.get(self.datamodel.obj.__name__, []):
@@ -689,4 +704,17 @@ class ColumnsMixin(_TypedModelRestApi):
 
             result["properties"][key] = value
 
+        if mark_non_nullable_required:
+            pydantic_required = result.get("required", [])
+            added_required = [
+                key
+                for key, value in result["properties"].items()
+                # A password is never sent back to the client and a readOnly field cannot be filled, so requiring either would fail the moment the form opens.
+                if key not in pydantic_required
+                and not self.datamodel.is_nullable(key)
+                and value.get("format") != "password"
+                and not value.get("readOnly")
+            ]
+            result["required"] = [*pydantic_required, *added_required]
+
         return result

{fastapi_rtk-2.11.1 → fastapi_rtk-2.11.2}/fastapi_rtk/api/model_rest_api/_info_mixin.py

@@ -194,6 +194,7 @@ class InfoMixin(_TypedModelRestApi):
                     schema.edit_columns,
                     self.edit_jsonforms_use_enum,
                     self.edit_jsonforms_list_as_object,
+                    mark_non_nullable_required=True,
                 )
             )
             schema.edit_uischema = self.edit_jsonforms_uischema

{fastapi_rtk-2.11.1 → fastapi_rtk-2.11.2}/fastapi_rtk/api/model_rest_api/_typed_base.py

@@ -204,6 +204,8 @@ class _TypedModelRestApi:
                     [ColumnInfo | ColumnEnumInfo | ColumnRelationInfo | None], bool
                 ],
             ] = False,
+            *,
+            mark_non_nullable_required: bool = False,
         ) -> dict[str, typing.Any]: ...
 
         def _get_datamodel_and_column(self, col: str) -> tuple[SQLAInterface, str]: ...

{fastapi_rtk-2.11.1 → fastapi_rtk-2.11.2}/tests/unit/api/model_rest_api/test_columns.py

@@ -6,11 +6,11 @@ Covers the prettify statics, label-column auto-generation,
 ``_get_datamodel_and_column``, and the ``_jsonforms_*`` schema helpers.
 """
 
+import enum
 import typing
 
 import pydantic
 import pytest
-
 from fastapi_rtk.api.model_rest_api import ModelRestApi
 from fastapi_rtk.backends.sqla.interface import SQLAInterface
 from fastapi_rtk.schemas import ColumnRelationInfo, RelInfo
@@ -121,7 +121,6 @@ class TestGetDatamodelAndColumn:
 @pytest.fixture
 def Country_cls():
     import sqlalchemy
-
     from fastapi_rtk.backends.sqla.model import Model
 
     if "tier12_country" in Model.metadata.tables:
@@ -140,7 +139,6 @@ def Country_cls():
 @pytest.fixture
 def WidgetWithCountry_cls(Country_cls):
     import sqlalchemy.orm
-
     from fastapi_rtk.backends.sqla.model import Model
 
     if "tier12_widget_country" in Model.metadata.tables:
@@ -289,7 +287,6 @@ class TestGenerateJsonformsSchemaRelationReadOnly:
     def m2m_api(self):
         import sqlalchemy
         import sqlalchemy.orm
-
         from fastapi_rtk.backends.sqla.model import Model
 
         assoc = sqlalchemy.Table(
@@ -362,7 +359,6 @@ class TestGenerateJsonformsSchemaListBranch:
     @pytest.fixture(scope="class")
     def list_api(self):
         import sqlalchemy
-
         from fastapi_rtk import (
             JSONBListColumn,
             ListColumn,
@@ -457,3 +453,345 @@ class TestGenerateJsonformsSchemaListBranch:
         result = list_api._generate_jsonforms_schema(schema, [], False)
         assert result["properties"]["tags"]["type"] == ["array", "null"]
         assert result["properties"]["tags"]["items"] == {"type": "string"}
+
+
+class TestGenerateJsonformsSchemaFileBranch:
+    """A multi-file / multi-image column's `items` sub-schema must be the
+    cleaned leaf schema (no `anyOf` leftover from the pydantic union), not a
+    copy taken before that cleanup runs. It also carries a deliberate
+    `default: null` so a freshly inserted row fails validation until a file
+    is picked."""
+
+    @pytest.fixture
+    def file_api(self, tmp_path, config_setter):
+        import sqlalchemy
+        from fastapi_rtk.backends.sqla.model import Model
+        from fastapi_rtk.types import FileColumn, ImageColumns
+
+        upload_folder = tmp_path / "uploads"
+        img_folder = tmp_path / "img_uploads"
+        upload_folder.mkdir()
+        img_folder.mkdir()
+        config_setter("UPLOAD_FOLDER", str(upload_folder))
+        config_setter("IMG_UPLOAD_FOLDER", str(img_folder))
+
+        class _TierFileModel(Model):
+            __tablename__ = "tier12_file_model"
+            __table_args__ = {"extend_existing": True}
+            id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+            document = sqlalchemy.Column(FileColumn(allowed_extensions=["txt", "pdf"]))
+            gallery = sqlalchemy.Column(ImageColumns(allowed_extensions=["png", "jpg"]))
+
+        class TierFileApi(ModelRestApi):
+            datamodel = SQLAInterface(_TierFileModel)
+
+        return TierFileApi()
+
+    @pytest.fixture
+    def file_schema_result(self, file_api):
+        schema = file_api.datamodel.generate_schema(
+            columns=["document", "gallery"],
+            with_id=False,
+            with_name=False,
+            with_property=False,
+            optional=True,
+            hide_sensitive_columns=False,
+            is_form_data=True,
+            name="TierFileFormData",
+        )
+        return file_api._generate_jsonforms_schema(schema, [])
+
+    def test_multi_image_items_is_the_cleaned_leaf_with_null_default(
+        self, file_api, file_schema_result
+    ):
+        from fastapi_rtk.setting import Setting
+
+        gallery = file_schema_result["properties"]["gallery"]
+        assert "anyOf" not in gallery["items"]
+        assert gallery["items"] == {
+            "title": file_api.label_columns["gallery"],
+            "type": "string",
+            "default": None,
+            "x-file-types": [".png", ".jpg"],
+            "contentMediaType": ",".join(Setting.IMG_MIME_TYPES),
+        }
+
+    def test_multi_image_does_not_duplicate_file_keys_on_the_array(
+        self, file_schema_result
+    ):
+        gallery = file_schema_result["properties"]["gallery"]
+        assert "x-file-types" not in gallery
+        assert "contentMediaType" not in gallery
+        assert "x-file-types" in gallery["items"]
+        assert "contentMediaType" in gallery["items"]
+
+    def test_multi_image_own_type_is_array_or_null(self, file_schema_result):
+        gallery = file_schema_result["properties"]["gallery"]
+        assert gallery["type"] == ["array", "null"]
+        assert "anyOf" not in gallery
+
+    def test_single_file_has_no_items_or_anyof(self, file_schema_result):
+        document = file_schema_result["properties"]["document"]
+        assert "anyOf" not in document
+        assert "items" not in document
+        assert document["type"] == ["string", "null"]
+
+
+class TestGenerateJsonformsSchemaNullableConstrainedValues:
+    """A nullable field with a constrained value set (enum / oneOf) must gain an
+    empty member alongside the ``null`` type, or AJV reports an option-mismatch
+    error the moment the frontend clears the field.
+    """
+
+    @pytest.fixture(scope="class")
+    def enum_api(self):
+        import sqlalchemy
+        from fastapi_rtk.backends.sqla.model import Model
+
+        class _TierStatus(enum.Enum):
+            ACTIVE = "active"
+            INACTIVE = "inactive"
+
+        class _TierEnumModel(Model):
+            __tablename__ = "tier12_enum_model"
+            __table_args__ = {"extend_existing": True}
+            id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+            status = sqlalchemy.Column(sqlalchemy.Enum(_TierStatus), nullable=True)
+            status_required = sqlalchemy.Column(
+                sqlalchemy.Enum(_TierStatus), nullable=False
+            )
+
+        class TierEnumApi(ModelRestApi):
+            datamodel = SQLAInterface(_TierEnumModel)
+
+        return TierEnumApi()
+
+    def test_nullable_enum_gets_null_type_and_member(self, enum_api):
+        schema = enum_api.add_obj_schema
+        result = enum_api._generate_jsonforms_schema(schema, [], False)
+        status = result["properties"]["status"]
+        assert status["type"] == ["string", "null"]
+        assert status["enum"][0] is None
+        assert set(status["enum"][1:]) == {"active", "inactive"}
+
+    def test_non_nullable_enum_has_no_null_member(self, enum_api):
+        schema = enum_api.add_obj_schema
+        result = enum_api._generate_jsonforms_schema(schema, [], False)
+        status_required = result["properties"]["status_required"]
+        assert None not in status_required["enum"]
+
+    def test_repeated_calls_do_not_grow_the_enum(self, enum_api):
+        """Regression: ``get_enum_value`` hands back the SQLAlchemy column's own
+        ``enums`` list, so mutating it in place would corrupt it for every later
+        request instead of just the current schema dict.
+        """
+        schema = enum_api.add_obj_schema
+        enum_api._generate_jsonforms_schema(schema, [], False)
+        result = enum_api._generate_jsonforms_schema(schema, [], False)
+        status = result["properties"]["status"]
+        assert status["enum"].count(None) == 1
+
+    @pytest.fixture
+    def relation_api(self, WidgetWithCountry_cls):
+        class TierRelationApi(ModelRestApi):
+            datamodel = SQLAInterface(WidgetWithCountry_cls)
+
+        return TierRelationApi()
+
+    def test_nullable_relation_with_use_enum_gets_null_member(self, relation_api):
+        schema = relation_api.add_obj_schema
+        info = [
+            ColumnRelationInfo(name="country", values=[RelInfo(id=1, value="Germany")])
+        ]
+        result = relation_api._generate_jsonforms_schema(schema, info, use_enum=True)
+        assert result["properties"]["country"]["enum"][0] is None
+
+    def test_nullable_relation_without_use_enum_gets_null_oneof_member(
+        self, relation_api
+    ):
+        schema = relation_api.add_obj_schema
+        info = [
+            ColumnRelationInfo(name="country", values=[RelInfo(id=1, value="Germany")])
+        ]
+        result = relation_api._generate_jsonforms_schema(schema, info, False)
+        assert result["properties"]["country"]["oneOf"][0] == {
+            "const": None,
+            "title": "",
+        }
+
+    @pytest.fixture(scope="class")
+    def m2m_relation_api(self):
+        import sqlalchemy
+        import sqlalchemy.orm
+        from fastapi_rtk.backends.sqla.model import Model
+
+        assoc = sqlalchemy.Table(
+            "tier12_nullable_m2m_assoc",
+            Model.metadata,
+            sqlalchemy.Column(
+                "widget_id",
+                sqlalchemy.ForeignKey("tier12_nullable_m2m_widget.id"),
+                primary_key=True,
+            ),
+            sqlalchemy.Column(
+                "tag_id",
+                sqlalchemy.ForeignKey("tier12_nullable_m2m_tag.id"),
+                primary_key=True,
+            ),
+            extend_existing=True,
+        )
+
+        class _NullableM2MTag(Model):
+            __tablename__ = "tier12_nullable_m2m_tag"
+            __table_args__ = {"extend_existing": True}
+            id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+            name = sqlalchemy.Column(sqlalchemy.String(50))
+
+        class _NullableM2MWidget(Model):
+            __tablename__ = "tier12_nullable_m2m_widget"
+            __table_args__ = {"extend_existing": True}
+            id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+            name = sqlalchemy.Column(sqlalchemy.String(50))
+            tags = sqlalchemy.orm.relationship(_NullableM2MTag, secondary=assoc)
+
+        class TierNullableM2MApi(ModelRestApi):
+            datamodel = SQLAInterface(_NullableM2MWidget)
+
+        return TierNullableM2MApi()
+
+    def test_nullable_to_many_relation_items_have_no_null_member(
+        self, m2m_relation_api
+    ):
+        schema = m2m_relation_api.add_obj_schema
+        info = [ColumnRelationInfo(name="tags", values=[RelInfo(id=1, value="a")])]
+        result = m2m_relation_api._generate_jsonforms_schema(schema, info, False)
+        tags = result["properties"]["tags"]
+        assert tags["type"] == ["array", "null"]
+        assert None not in [item.get("const") for item in tags["items"]["oneOf"]]
+
+
+class TestGenerateJsonformsSchemaMarkNonNullableRequired:
+    """``mark_non_nullable_required`` lets the EDIT schema report a missing
+    non-nullable value itself, instead of the frontend inventing that error.
+    """
+
+    @pytest.fixture(scope="class")
+    def enum_api(self):
+        import sqlalchemy
+        from fastapi_rtk.backends.sqla.model import Model
+
+        class _TierRequiredStatus(enum.Enum):
+            ACTIVE = "active"
+            INACTIVE = "inactive"
+
+        class _TierRequiredModel(Model):
+            __tablename__ = "tier12_required_model"
+            __table_args__ = {"extend_existing": True}
+            id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+            status = sqlalchemy.Column(
+                sqlalchemy.Enum(_TierRequiredStatus), nullable=True
+            )
+            status_required = sqlalchemy.Column(
+                sqlalchemy.Enum(_TierRequiredStatus), nullable=False
+            )
+
+        class TierRequiredApi(ModelRestApi):
+            datamodel = SQLAInterface(_TierRequiredModel)
+
+        return TierRequiredApi()
+
+    @pytest.fixture
+    def excluded_required_api(self, Widget_cls):
+        class TierExcludedRequiredApi(ModelRestApi):
+            datamodel = SQLAInterface(Widget_cls)
+            edit_columns = ["description", "quantity"]
+
+        return TierExcludedRequiredApi()
+
+    def test_default_leaves_required_as_pydantic_emitted(self, enum_api):
+        schema = enum_api.edit_obj_schema
+        result = enum_api._generate_jsonforms_schema(schema, [])
+        assert result.get("required", []) == schema.model_json_schema().get(
+            "required", []
+        )
+
+    def test_flag_marks_every_non_nullable_column_present_as_required(self, enum_api):
+        schema = enum_api.edit_obj_schema
+        result = enum_api._generate_jsonforms_schema(
+            schema, [], mark_non_nullable_required=True
+        )
+        assert "status_required" in result["required"]
+        assert "status" not in result["required"]
+
+    def test_flag_does_not_duplicate_an_already_required_column(self, enum_api):
+        schema = enum_api.add_obj_schema
+        result = enum_api._generate_jsonforms_schema(
+            schema, [], mark_non_nullable_required=True
+        )
+        assert result["required"].count("status_required") == 1
+
+    def test_flag_skips_non_nullable_column_absent_from_properties(
+        self, excluded_required_api
+    ):
+        schema = excluded_required_api.edit_obj_schema
+        result = excluded_required_api._generate_jsonforms_schema(
+            schema, [], mark_non_nullable_required=True
+        )
+        assert "name" not in result["properties"]
+        assert "name" not in result["required"]
+
+    def test_repeated_calls_with_flag_yield_identical_required(self, enum_api):
+        schema = enum_api.edit_obj_schema
+        first = enum_api._generate_jsonforms_schema(
+            schema, [], mark_non_nullable_required=True
+        )
+        second = enum_api._generate_jsonforms_schema(
+            schema, [], mark_non_nullable_required=True
+        )
+        assert first["required"] == second["required"]
+
+    def test_flag_skips_a_non_nullable_password_column(self, enum_api):
+        from fastapi_rtk.globals import g
+
+        model_name = enum_api.datamodel.obj.__name__
+        original = g.sensitive_data
+        g.sensitive_data = {**original, model_name: ["status_required"]}
+        try:
+            schema = enum_api.edit_obj_schema
+            result = enum_api._generate_jsonforms_schema(
+                schema, [], mark_non_nullable_required=True
+            )
+            assert result["properties"]["status_required"]["format"] == "password"
+            assert "status_required" not in result["required"]
+        finally:
+            g.sensitive_data = original
+
+    def test_flag_skips_a_non_nullable_readonly_relation(self, Country_cls):
+        import sqlalchemy
+        import sqlalchemy.orm
+        from fastapi_rtk.backends.sqla.model import Model
+
+        class TierWidgetRequiredCountry(Model):
+            __tablename__ = "tier12_widget_required_country"
+            __table_args__ = {"extend_existing": True}
+            id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
+            name = sqlalchemy.Column(sqlalchemy.String(50))
+            country_id = sqlalchemy.Column(
+                sqlalchemy.Integer,
+                sqlalchemy.ForeignKey("tier12_country.id"),
+                nullable=False,
+            )
+            country = sqlalchemy.orm.relationship(Country_cls)
+
+        class TierRequiredRelationApi(ModelRestApi):
+            datamodel = SQLAInterface(TierWidgetRequiredCountry)
+            edit_columns = ["name", "country"]
+
+        api = TierRequiredRelationApi()
+        schema = api.edit_obj_schema
+        info = [ColumnRelationInfo(name="country", values=[])]
+        result = api._generate_jsonforms_schema(
+            schema, info, mark_non_nullable_required=True
+        )
+        assert result["properties"]["country"]["readOnly"] is True
+        assert "country" not in result["required"]

fastapi_rtk-2.11.1/fastapi_rtk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.11.1"