Add validators to inputs (#688)

Dreamsorcerer · web-flow · commit 52c8ae483429 · 2023-04-22T20:35:03.000+01:00
diff --git a/admin-js/src/App.js b/admin-js/src/App.js
@@ -12,7 +12,8 @@ import {
     ReferenceManyField,
     SelectInput,
     TextField, TextInput,
-    WithRecord, required
+    WithRecord,
+    email, maxLength, maxValue, minLength, minValue, regex, required
 } from "react-admin";
 import VisibilityOffIcon from "@mui/icons-material/VisibilityOff";
 
@@ -33,6 +34,7 @@ const STATE = JSON.parse(_body.dataset.state);
 // Create a mapping of components, so we can reference them by name later.
 const COMPONENTS = {BooleanField, DateField, NumberField, ReferenceField, ReferenceManyField, TextField,
                     BooleanInput, DateInput, NumberInput, ReferenceInput, TextInput};
+const VALIDATORS = {email, maxLength, maxValue, minLength, minValue, regex, required};
 
 /** Make an authenticated API request and return the response object. */
 function apiRequest(url, options) {
@@ -162,7 +164,16 @@ function createInputs(resource, name, perm_type, permissions) {
             const C = COMPONENTS[state["type"]];
             if (C === undefined)
                 throw Error(`Unknown component '${state["type"]}'`);
-            const c = <C source={field} {...state["props"]} />;
+
+            let validators = [];
+            if (perm_type !== "view") {
+                for (let validator of state["validators"]) {
+                    if (validator[0] === "regex")
+                        validator[1] = new RegExp(validator[1]);
+                    validators.push(VALIDATORS[validator[0]](...validator.slice(1)))
+                }
+            }
+            const c = <C source={field} validate={validators} {...state["props"]} />;
             if (perm_type === "edit")
                 // Don't render if filters disallow editing this field.
                 components.push(<WithRecord source={field} render={
diff --git a/aiohttp_admin/backends/sqlalchemy.py b/aiohttp_admin/backends/sqlalchemy.py
@@ -1,5 +1,6 @@
 import asyncio
 import logging
+import operator
 from typing import Any, Iterator, Type, Union
 
 import sqlalchemy as sa
@@ -57,7 +58,9 @@ def __init__(self, db: AsyncEngine, model_or_table: Union[sa.Table, Type[Declara
             if c.computed is None:
                 # TODO: Allow custom props (e.g. disabled, multiline, rows etc.)
                 show = c is not table.autoincrement_column
-                self.inputs[c.name] = {"type": inp, "props": props, "show_create": show}
+                validators = self._get_validators(table, c)
+                self.inputs[c.name] = {"type": inp, "props": props, "show_create": show,
+                                       "validators": validators}
 
         if not isinstance(model_or_table, sa.Table):
             # Append fields to represent ORM relationships.
@@ -187,3 +190,52 @@ async def delete_many(self, params: DeleteManyParams) -> list[Union[str, int]]:
         if ids:
             return ids
         raise web.HTTPNotFound()
+
+    def _get_validators(
+        self, table: sa.Table, c: sa.Column[object]
+    ) -> list[tuple[Union[str, int], ...]]:
+        validators: list[tuple[Union[str, int], ...]] = []
+        if c.default is None and c.server_default is None and not c.nullable:
+            validators.append(("required",))
+        max_length = getattr(c.type, "length", None)
+        if max_length:
+            validators.append(("maxLength", max_length))
+
+        for constr in table.constraints:
+            if not isinstance(constr, sa.CheckConstraint):
+                continue
+            if isinstance(constr.sqltext, sa.BinaryExpression):
+                left = constr.sqltext.left
+                right = constr.sqltext.right
+                op = constr.sqltext.operator
+                if left.expression is c:
+                    if not isinstance(right, sa.BindParameter) or right.value is None:
+                        continue
+                    if op is operator.ge:  # type: ignore[comparison-overlap]
+                        validators.append(("minValue", right.value))
+                    elif op is operator.gt:  # type: ignore[comparison-overlap]
+                        validators.append(("minValue", right.value + 1))
+                    elif op is operator.le:  # type: ignore[comparison-overlap]
+                        validators.append(("maxValue", right.value))
+                    elif op is operator.lt:  # type: ignore[comparison-overlap]
+                        validators.append(("maxValue", right.value - 1))
+                elif isinstance(left, sa.Function):
+                    if left.name == "char_length":
+                        if next(iter(left.clauses)) is not c:
+                            continue
+                        if not isinstance(right, sa.BindParameter) or right.value is None:
+                            continue
+                        if op is operator.ge:  # type: ignore[comparison-overlap]
+                            validators.append(("minLength", right.value))
+                        elif op is operator.gt:  # type: ignore[comparison-overlap]
+                            validators.append(("minLength", right.value + 1))
+            elif isinstance(constr.sqltext, sa.Function):
+                if constr.sqltext.name in ("regexp", "regexp_like"):
+                    clauses = tuple(constr.sqltext.clauses)
+                    if clauses[0] is not c or not isinstance(clauses[1], sa.BindParameter):
+                        continue
+                    if clauses[1].value is None:
+                        continue
+                    validators.append(("regex", clauses[1].value))
+
+        return validators
diff --git a/aiohttp_admin/routes.py b/aiohttp_admin/routes.py
@@ -7,6 +7,8 @@
 from . import views
 from .types import Schema
 
+_VALIDATORS = ("email", "maxLength", "maxValue", "minLength", "minValue", "regex", "required")
+
 
 def setup_resources(admin: web.Application, schema: Schema) -> None:
     admin["resources"] = []
@@ -31,7 +33,14 @@ def setup_resources(admin: web.Application, schema: Schema) -> None:
             if k not in omit_fields:
                 v["props"]["alwaysOn"] = "alwaysOn"  # Always display filter
 
-        state = {"fields": m.fields, "inputs": m.inputs, "list_omit": tuple(omit_fields),
+        inputs = m.inputs.copy()  # Don't modify the resource.
+        for name, validators in r.get("validators", {}).items():
+            if not all(v[0] in _VALIDATORS for v in validators):
+                raise ValueError(f"First value in validators must be one of {_VALIDATORS}")
+            inputs[name] = inputs[name].copy()
+            inputs[name]["validators"] = tuple(inputs[name]["validators"]) + tuple(validators)
+
+        state = {"fields": m.fields, "inputs": inputs, "list_omit": tuple(omit_fields),
                  "repr": repr_field, "label": r.get("label"), "icon": r.get("icon"),
                  "bulk_update": r.get("bulk_update", {})}
         admin["state"]["resources"][m.name] = state
diff --git a/aiohttp_admin/types.py b/aiohttp_admin/types.py
@@ -1,5 +1,5 @@
 from collections.abc import Collection
-from typing import Any, Awaitable, Callable, Optional, Sequence, TypedDict
+from typing import Any, Awaitable, Callable, Optional, Sequence, TypedDict, Union
 
 
 class FieldState(TypedDict):
@@ -10,6 +10,9 @@ class FieldState(TypedDict):
 class InputState(FieldState):
     # Whether to show this input in the create form.
     show_create: bool
+    # Validators to add to the input. Each validator is the name of the validator
+    # function, followed by arguments for that function. e.g. ("minValue", 5)
+    validators: Sequence[Sequence[Union[str, int]]]
 
 
 class _IdentityDict(TypedDict, total=False):
@@ -66,6 +69,8 @@ class _Resource(TypedDict, total=False):
     # Format: {"Button Label": {"field_to_update": "value_to_set"}}
     # e.g. {"Reset Views": {"views": 0}}
     bulk_update: dict[str, dict[str, Any]]
+    # Custom validators to add to inputs.
+    validators: dict[str, Sequence[Sequence[Union[str, int]]]]
 
 
 class Resource(_Resource):
diff --git a/examples/validators.py b/examples/validators.py
@@ -0,0 +1,64 @@
+"""Minimal example with simple database models.
+
+When running this file, admin will be accessible at /admin.
+"""
+
+import sqlalchemy as sa
+from aiohttp import web
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+import aiohttp_admin
+from aiohttp_admin.backends.sqlalchemy import SAResource
+
+
+class Base(DeclarativeBase):
+    """Base model."""
+
+
+class User(Base):
+    __tablename__ = "user"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    username: Mapped[str] = mapped_column(sa.String(32))
+    email: Mapped[str | None]
+    note: Mapped[str | None]
+    votes: Mapped[int] = mapped_column()
+
+    __table_args__ = (sa.CheckConstraint(sa.func.char_length(username) >= 3),
+                      sa.CheckConstraint(votes >= 1), sa.CheckConstraint(votes < 5))
+
+
+async def check_credentials(username: str, password: str) -> bool:
+    return username == "admin" and password == "admin"
+
+
+async def create_app() -> web.Application:
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    session = async_sessionmaker(engine, expire_on_commit=False)
+
+    # Create some sample data
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    async with session.begin() as sess:
+        sess.add(User(username="Foo", votes=4))
+        sess.add(User(username="Spam", votes=1, note="Second user"))
+
+    app = web.Application()
+
+    # This is the setup required for aiohttp-admin.
+    schema: aiohttp_admin.Schema = {
+        "security": {
+            "check_credentials": check_credentials,
+            "secure": False
+        },
+        "resources": ({"model": SAResource(engine, User),
+                       "validators": {"username": (("regex", r"^[A-Z][a-z]+$"),),
+                                      "email": (("email",),)}},)
+    }
+    aiohttp_admin.setup(app, schema)
+
+    return app
+
+if __name__ == "__main__":
+    web.run_app(create_app())
diff --git a/tests/test_admin.py b/tests/test_admin.py
@@ -19,6 +19,28 @@ def test_path() -> None:
     assert str(admin.router["index"].url_for()) == "/another/admin"
 
 
+def test_validators() -> None:
+    dummy = DummyResource(
+        "dummy", {"id": {"type": "NumberField", "props": {}}},
+        {"id": {"type": "NumberInput", "props": {}, "show_create": True,
+         "validators": (("required",),)}}, "id")
+    app = web.Application()
+    schema: aiohttp_admin.Schema = {"security": {"check_credentials": check_credentials},
+                                    "resources": ({"model": dummy,
+                                                   "validators": {"id": (("minValue", 3),)}},)}
+    admin = aiohttp_admin.setup(app, schema)
+    validators = admin["state"]["resources"]["dummy"]["inputs"]["id"]["validators"]
+    # TODO(Pydantic2): Should be int 3 in both lines.
+    assert validators == (("required",), ("minValue", "3"))
+    assert ("minValue", "3") not in dummy.inputs["id"]["validators"]
+
+    # Invalid validator
+    schema = {"security": {"check_credentials": check_credentials},
+              "resources": ({"model": dummy, "validators": {"id": (("bad", 3),)}},)}
+    with pytest.raises(ValueError, match="validators must be one of"):
+        aiohttp_admin.setup(app, schema)
+
+
 def test_re() -> None:
     test_re = DummyResource("testre", {"id": {"type": "NumberField", "props": {}},
                                        "value": {"type": "TextField", "props": {}}}, {}, "id")
@@ -57,8 +79,9 @@ def test_display() -> None:
     model = DummyResource(
         "test",
         {"id": {"type": "TextField", "props": {}}, "foo": {"type": "TextField", "props": {}}},
-        {"id": {"type": "TextInput", "props": {}, "show_create": False},
-         "foo": {"type": "TextInput", "props": {}, "show_create": True}},
+        {"id": {"type": "TextInput", "props": {}, "show_create": False,
+         "validators": (("required",),)},
+         "foo": {"type": "TextInput", "props": {}, "show_create": True, "validators": ()}},
         "id")
     schema: aiohttp_admin.Schema = {"security": {"check_credentials": check_credentials},
                                     "resources": ({"model": model, "display": ("foo",)},)}
diff --git a/tests/test_backends_sqlalchemy.py b/tests/test_backends_sqlalchemy.py
@@ -1,5 +1,5 @@
 import json
-from typing import Awaitable, Callable, Type
+from typing import Awaitable, Callable, Type, Union
 
 import pytest
 import sqlalchemy as sa
@@ -30,8 +30,10 @@ class TestModel(base):  # type: ignore[misc,valid-type]
     }
     # Autoincremented PK should not be in create form
     assert r.inputs == {
-        "id": {"type": "NumberInput", "show_create": False, "props": {}},
-        "num": {"type": "TextInput", "show_create": True, "props": {}}
+        "id": {"type": "NumberInput", "show_create": False, "props": {},
+               "validators": [("required",)]},
+        "num": {"type": "TextInput", "show_create": True, "props": {},
+                "validators": [("required",)]}
     }
 
 
@@ -49,8 +51,10 @@ def test_table(mock_engine: AsyncEngine) -> None:
     }
     # Autoincremented PK should not be in create form
     assert r.inputs == {
-        "id": {"type": "NumberInput", "show_create": False, "props": {}},
-        "num": {"type": "TextInput", "show_create": True, "props": {}}
+        "id": {"type": "NumberInput", "show_create": False, "props": {},
+               "validators": [("required",)]},
+        "num": {"type": "TextInput", "show_create": True, "props": {},
+                "validators": [("maxLength", 30)]}
     }
 
 
@@ -69,7 +73,8 @@ class TestChildModel(base):  # type: ignore[misc,valid-type]
     assert r.fields == {"id": {"type": "ReferenceField", "props": {"reference": "dummy"}}}
     # PK with FK constraint should be shown in create form.
     assert r.inputs == {"id": {
-        "type": "ReferenceInput", "show_create": True, "props": {"reference": "dummy"}}}
+        "type": "ReferenceInput", "show_create": True, "props": {"reference": "dummy"},
+        "validators": [("required",)]}}
 
 
 def test_relationship(base: Type[DeclarativeBase], mock_engine: AsyncEngine) -> None:
@@ -92,6 +97,47 @@ class TestOne(base):  # type: ignore[misc,valid-type]
     assert "ones" not in r.inputs
 
 
+def test_check_constraints(base: Type[DeclarativeBase], mock_engine: AsyncEngine) -> None:
+    class TestCC(base):  # type: ignore[misc,valid-type]
+        __tablename__ = "test"
+        pk: Mapped[int] = mapped_column(primary_key=True)
+        default: Mapped[int] = mapped_column(default=5)
+        server_default: Mapped[int] = mapped_column(server_default="4")
+        nullable: Mapped[Union[int, None]]
+        not_nullable: Mapped[int]
+        max_length: Mapped[str] = mapped_column(sa.String(16))
+        gt: Mapped[int] = mapped_column()
+        gte: Mapped[int] = mapped_column()
+        lt: Mapped[int] = mapped_column()
+        lte: Mapped[Union[int, None]] = mapped_column()
+        min_length: Mapped[str] = mapped_column()
+        min_length_gt: Mapped[str] = mapped_column()
+        regex: Mapped[str] = mapped_column()
+
+        __table_args__ = (sa.CheckConstraint(gt > 3), sa.CheckConstraint(gte >= 3),
+                          sa.CheckConstraint(lt < 3), sa.CheckConstraint(lte <= 3),
+                          sa.CheckConstraint(sa.func.char_length(min_length) >= 5),
+                          sa.CheckConstraint(sa.func.char_length(min_length_gt) > 5),
+                          sa.CheckConstraint(sa.func.regexp(regex, r"abc.*")))
+
+    r = SAResource(mock_engine, TestCC)
+
+    f = r.inputs
+    assert f["pk"]["validators"] == [("required",)]
+    assert f["default"]["validators"] == []
+    assert f["server_default"]["validators"] == []
+    assert f["nullable"]["validators"] == []
+    assert f["not_nullable"]["validators"] == [("required",)]
+    assert f["max_length"]["validators"] == [("required",), ("maxLength", 16)]
+    assert f["gt"]["validators"] == [("required",), ("minValue", 4)]
+    assert f["gte"]["validators"] == [("required",), ("minValue", 3)]
+    assert f["lt"]["validators"] == [("required",), ("maxValue", 2)]
+    assert f["lte"]["validators"] == [("maxValue", 3)]
+    assert f["min_length"]["validators"] == [("required",), ("minLength", 5)]
+    assert f["min_length_gt"]["validators"] == [("required",), ("minLength", 6)]
+    assert f["regex"]["validators"] == [("required",), ("regex", "abc.*")]
+
+
 async def test_nonid_pk(base: Type[DeclarativeBase], mock_engine: AsyncEngine) -> None:
     class TestModel(base):  # type: ignore[misc,valid-type]
         __tablename__ = "test"
@@ -106,8 +152,10 @@ class TestModel(base):  # type: ignore[misc,valid-type]
         "other": {"type": "TextField", "props": {}}
     }
     assert r.inputs == {
-        "num": {"type": "NumberInput", "show_create": False, "props": {}},
-        "other": {"type": "TextInput", "show_create": True, "props": {}}
+        "num": {"type": "NumberInput", "show_create": False, "props": {},
+                "validators": [("required",)]},
+        "other": {"type": "TextInput", "show_create": True, "props": {},
+                  "validators": [("required",)]}
     }
 
 
diff --git a/tests/test_views.py b/tests/test_views.py
@@ -31,7 +31,7 @@ async def test_admin_view(admin_client: TestClient) -> None:
     assert r["list_omit"] == []
     assert r["fields"] == {"id": {"type": "NumberField", "props": {"alwaysOn": "alwaysOn"}}}
     assert r["inputs"] == {"id": {"type": "NumberInput", "props": {"alwaysOn": "alwaysOn"},
-                                  "show_create": False}}
+                                  "show_create": False, "validators": [["required"]]}}
     assert r["repr"] == "id"
     assert state["urls"] == {"token": "/admin/token", "logout": "/admin/logout"}
 
