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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-rtk
-Version: 2.11.0
+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.0 → 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.0 → 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.0 → 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.0 → fastapi_rtk-2.11.2}/fastapi_rtk/backends/sqla/filters.py

@@ -42,6 +42,10 @@ __all__ = [
 ]
 
 
+# Oracle needs a length on the CAST target: CAST(x AS VARCHAR2) is ORA-00906.
+_TEXT_CAST_TYPE = sa_types.String().with_variant(sa_types.String(4000), "oracle")
+
+
 class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
     def _get_column(self, col_name: str) -> sqlalchemy.Column:
         """
@@ -143,6 +147,28 @@ class BaseFilter(AbstractBaseFilter[sqlalchemy.Select[Model]]):
 
 
 class BaseFilterTextContains(BaseFilter):
+    def _build_concat_expr(self, col_objs: list[sqlalchemy.ColumnElement]):
+        """
+        Concatenate columns as text, separated by a space.
+
+        Chains ``||`` instead of ``concat(*args)``: Oracle's CONCAT takes exactly two
+        arguments and other databases cap function-call args, which wide tables exceed.
+        ``coalesce`` keeps concat's NULL-as-empty.
+
+        Args:
+            col_objs (list[sqlalchemy.ColumnElement]): Columns to concatenate.
+
+        Returns:
+            sqlalchemy.ColumnElement | None: The concatenation, or None when col_objs is empty.
+        """
+        concat_expr = None
+        for col_obj in col_objs:
+            piece = sqlalchemy.func.coalesce(
+                sqlalchemy.cast(col_obj, _TEXT_CAST_TYPE), ""
+            )
+            concat_expr = piece if concat_expr is None else concat_expr + " " + piece
+        return concat_expr
+
     def _handle_relation_contains(self, col: str, value: str):
         sub_col = ""
         if "." in col:
@@ -168,16 +194,14 @@ class BaseFilterTextContains(BaseFilter):
         else:
             # If there is no sub-column, we filter all columns in the relation
             rel_cols = rel_interface.list_columns.keys()
-        concat = []
         rel_obj = rel_interface.obj
         rel_pks = rel_interface.get_pk_attrs()
-        for col_name in rel_cols:
-            col_obj = getattr(rel_obj, col_name)
-            concat.append(sqlalchemy.cast(col_obj, sa_types.String))
-            concat.append(" ")
+        concat_expr = self._build_concat_expr(
+            [getattr(rel_obj, col_name) for col_name in rel_cols]
+        )
         rel_statements = [
             sqlalchemy.select(getattr(rel_obj, pk)).filter(
-                sqlalchemy.func.concat(*concat).ilike("%" + value + "%")
+                concat_expr.ilike("%" + value + "%")
             )
             for pk in rel_pks
         ]
@@ -210,7 +234,7 @@ class BaseFilterTextContains(BaseFilter):
                     if any(value in keywords for keywords in true_keywords)
                     else False
                 )
-        return sqlalchemy.cast(self._cast_column(col), sa_types.String).ilike(
+        return sqlalchemy.cast(self._cast_column(col), _TEXT_CAST_TYPE).ilike(
             "%" + value + "%"
         )
 
@@ -491,9 +515,7 @@ class FilterGlobal(BaseFilterTextContains):
         filters = []
 
         for val in value:
-            # Chain || instead of concat(*args): some databases cap function-call args,
-            # which wide tables exceed. coalesce keeps concat's NULL-as-empty.
-            concat_expr = None
+            concat_cols = []
             rel_filter_arr = []
             for col in cols:
                 if (
@@ -503,13 +525,9 @@ class FilterGlobal(BaseFilterTextContains):
                 ):
                     rel_filter_arr.append(self._handle_text_contains(col, val))
                 elif col in self.datamodel.list_columns:
-                    piece = sqlalchemy.func.coalesce(
-                        sqlalchemy.cast(self._cast_column(col), sa_types.String), ""
-                    )
-                    concat_expr = (
-                        piece if concat_expr is None else concat_expr + " " + piece
-                    )
+                    concat_cols.append(self._cast_column(col))
             params = [*rel_filter_arr]
+            concat_expr = self._build_concat_expr(concat_cols)
             if concat_expr is not None:
                 val = val.strip().lower()
                 params.append(concat_expr.ilike("%" + val + "%"))

{fastapi_rtk-2.11.0 → fastapi_rtk-2.11.2}/fastapi_rtk/security/sqla/models.py

@@ -122,7 +122,9 @@ class Api(Model):
     id: Mapped[int] = mapped_column(
         sqlalchemy.Integer, sqlalchemy.Sequence(API_SEQUENCE), primary_key=True
     )
-    name: Mapped[str] = mapped_column(sqlalchemy.String, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(
+        sqlalchemy.String(256), unique=True, nullable=False
+    )
 
     permissions: Mapped[list[PermissionApi]] = relationship(
         PermissionApi, back_populates="api", cascade="all, delete-orphan"
@@ -143,7 +145,9 @@ class Permission(Model):
     id: Mapped[int] = mapped_column(
         sqlalchemy.Integer, sqlalchemy.Sequence(PERMISSION_SEQUENCE), primary_key=True
     )
-    name: Mapped[str] = mapped_column(sqlalchemy.String, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(
+        sqlalchemy.String(256), unique=True, nullable=False
+    )
 
     apis: Mapped[list[PermissionApi]] = relationship(
         PermissionApi, back_populates="permission", cascade="all, delete-orphan"
@@ -158,7 +162,9 @@ class Role(Model):
     id: Mapped[int] = mapped_column(
         sqlalchemy.Integer, sqlalchemy.Sequence(ROLE_SEQUENCE), primary_key=True
     )
-    name: Mapped[str] = mapped_column(sqlalchemy.String, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(
+        sqlalchemy.String(256), unique=True, nullable=False
+    )
 
     users: Mapped[list["User"]] = relationship(
         "User", secondary=assoc_user_role, back_populates="roles"

{fastapi_rtk-2.11.0 → 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"]