Implement missing relationship patterns (#713)

Dreamsorcerer · web-flow · commit 5f49c2c877ed · 2023-05-07T14:50:32.000+01:00
diff --git a/admin-js/src/App.js b/admin-js/src/App.js
@@ -11,7 +11,8 @@ import {
     BulkDeleteButton, BulkExportButton, BulkUpdateButton, CreateButton, ExportButton,
     FilterButton, SelectColumnsButton, TopToolbar,
     // Fields
-    BooleanField, DateField, NumberField, ReferenceField, ReferenceManyField, TextField,
+    BooleanField, DateField, NumberField, ReferenceField, ReferenceManyField,
+    ReferenceOneField, TextField,
     // Inputs
     BooleanInput, DateInput, DateTimeInput, NumberInput, SelectInput, TextInput,
     ReferenceInput as _ReferenceInput,
@@ -33,12 +34,24 @@ const ReferenceInput = (props) => {
     );
 };
 
+/** Display a single record in a Datagrid-like view (e.g. for ReferenceField). */
+const DatagridSingle = (props) => (
+    <WithRecord {...props} render={
+        (record) => <Datagrid {...props} data={[record]} bulkActionButtons={false} hover={false} rowClick={false} setSort={false} />
+    } />
+);
+
 
 const _body = document.querySelector("body");
 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, DateTimeInput, NumberInput, ReferenceInput, TextInput};
+const COMPONENTS = {
+    Datagrid, DatagridSingle,
+
+    BooleanField, DateField, NumberField, ReferenceField, ReferenceManyField,
+    ReferenceOneField, TextField,
+
+    BooleanInput, DateInput, DateTimeInput, NumberInput, ReferenceInput, TextInput};
 const VALIDATORS = {email, maxLength, maxValue, minLength, minValue, regex, required};
 
 /** Make an authenticated API request and return the response object. */
@@ -79,7 +92,8 @@ const dataProvider = {
     getList: (resource, params) => dataRequest(resource, "get_list", params),
     getMany: (resource, params) => dataRequest(resource, "get_many", params),
     getManyReference: (resource, params) => {
-        params["filter"][params["target"]] = params["id"];
+        // filter object is reused across requests, so clone it before modifying.
+        params["filter"] = {...params["filter"], [params["target"]]: params["id"]};
         return dataRequest(resource, "get_list", params);
     },
     getOne: (resource, params) => dataRequest(resource, "get_one", params),
@@ -131,14 +145,18 @@ function createFields(resource, name, permissions) {
                                              "display": Object.keys(state["props"]["children"])},
                                             name, permissions);
             delete state["props"]["children"];
-            c = <C source={field} {...state["props"]}><Datagrid>{child_fields}</Datagrid></C>;
+            c = <C source={field} {...state["props"]}>{child_fields}</C>;
         } else {
             c = <C source={field} {...state["props"]} />;
         }
-        // Show icon if user doesn't have permission to view this field (based on filters).
-        components.push(<WithRecord source={field} label={state["props"]["label"]} render={
-            (record) => hasPermission(`${name}.${field}.view`, permissions, record) ? c : <VisibilityOffIcon />
-        } />);
+        if (field === "_")
+            // Layout component, not related to a specific field.
+            components.push(c);
+        else
+            // Show icon if user doesn't have permission to view this field (based on filters).
+            components.push(<WithRecord source={field} label={state["props"]["label"]} render={
+                (record) => hasPermission(`${name}.${field}.view`, permissions, record) ? c : <VisibilityOffIcon />
+            } />);
     }
     return components;
 }
diff --git a/aiohttp_admin/backends/sqlalchemy.py b/aiohttp_admin/backends/sqlalchemy.py
@@ -134,7 +134,8 @@ def __init__(self, db: AsyncEngine, model_or_table: Union[sa.Table, type[Declara
                 field = "ReferenceField"
                 inp = "ReferenceInput"
                 key = next(iter(c.foreign_keys))  # TODO: Test composite foreign keys.
-                props: dict[str, object] = {"reference": key.column.table.name}
+                props: dict[str, object] = {"reference": key.column.table.name,
+                                            "source": c.name, "target": key.column.name}
             else:
                 field, inp = FIELD_TYPES.get(type(c.type), ("TextField", "TextInput"))
                 props = {}
@@ -157,18 +158,27 @@ def __init__(self, db: AsyncEngine, model_or_table: Union[sa.Table, type[Declara
             for name, relationship in mapper.relationships.items():
                 if len(relationship.local_remote_pairs) > 1:
                     raise NotImplementedError("Composite foreign keys not supported yet.")
-                pair = relationship.local_remote_pairs[0]
+                local, remote = relationship.local_remote_pairs[0]
+
+                props = {"reference": relationship.entity.persist_selectable.name,
+                         "label": name.title(), "source": local.name, "target": remote.name}
+                if local.foreign_keys:
+                    t = "ReferenceField"
+                elif relationship.uselist:
+                    t = "ReferenceManyField"
+                else:
+                    t = "ReferenceOneField"
+
                 children = {}
                 for c in relationship.target.c.values():
-                    if c is pair[1]:  # Skip the foreign key
+                    if c is remote:  # Skip the foreign key
                         continue
                     field, inp = FIELD_TYPES.get(type(c.type), ("TextField", "TextInput"))
                     children[c.name] = {"type": field, "props": {}}
+                container = "Datagrid" if t == "ReferenceManyField" else "DatagridSingle"
+                props["children"] = {"_": {"type": container, "props": {"children": children}}}
 
-                props = {"reference": relationship.entity.persist_selectable.name,
-                         "label": name.title(), "children": children,
-                         "source": pair[0].name, "target": pair[1].name}
-                self.fields[name] = {"type": "ReferenceManyField", "props": props}
+                self.fields[name] = {"type": t, "props": props}
 
         self._db = db
         self._table = table
diff --git a/aiohttp_admin/routes.py b/aiohttp_admin/routes.py
@@ -29,6 +29,8 @@ def setup_resources(admin: web.Application, schema: Schema) -> None:
                 raise ValueError(f"Display includes non-existent field {r['display']}")
 
         repr_field = r.get("repr", m.primary_key)
+        if repr_field not in m.fields:
+            raise ValueError(f"repr not a valid field name: {repr_field}")
 
         # Don't modify the resource.
         fields = copy.deepcopy(m.fields)
diff --git a/examples/_models.py b/examples/_models.py
@@ -4,7 +4,7 @@
 from enum import Enum
 
 import sqlalchemy as sa
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 
 class Currency(Enum):
@@ -33,21 +33,3 @@ class SimpleParent(Base):
                                     primary_key=True)
     date: Mapped[datetime]
     currency: Mapped[Currency] = mapped_column(default="USD")
-
-
-class Author(Base):
-    __tablename__ = "author"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    name: Mapped[str]
-    books: Mapped[list["Book"]] = relationship()
-
-
-class Book(Base):
-    __tablename__ = "book"
-
-    id: Mapped[int] = mapped_column(primary_key=True)
-    title: Mapped[str]
-    author_id: Mapped[int | None] = mapped_column(sa.ForeignKey(Author.id))
-
-    # author: Mapped[Author] = relationship(back_populates="books")
diff --git a/examples/relationships.py b/examples/relationships.py
@@ -1,16 +1,111 @@
 """Example that demonstrates use of various foreign key relationships.
 
+An example of each SQLAlchemy relationship is included.
+However, the many to many relationship requires the react-admin enterprise-edition
+(not currently supported by aiohttp-admin).
+https://docs.sqlalchemy.org/en/20/orm/basic_relationships.html
+
 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, relationship
 
 import aiohttp_admin
-from _models import Author, Base, Book
 from aiohttp_admin.backends.sqlalchemy import SAResource
 
 
+class Base(DeclarativeBase):
+    """Base model."""
+
+
+class OneToManyParent(Base):
+    __tablename__ = "onetomany_parent"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    children: Mapped[list["OneToManyChild"]] = relationship(back_populates="parent")
+
+
+class OneToManyChild(Base):
+    __tablename__ = "onetomany_child"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    parent_id: Mapped[int] = mapped_column(sa.ForeignKey(OneToManyParent.id))
+    parent: Mapped[OneToManyParent] = relationship(back_populates="children")
+
+
+class ManyToOneParent(Base):
+    __tablename__ = "manytoone_parent"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    child_id: Mapped[int | None] = mapped_column(sa.ForeignKey("manytoone_child.id"))
+    child: Mapped["ManyToOneChild | None"] = relationship(back_populates="parents")
+
+
+class ManyToOneChild(Base):
+    __tablename__ = "manytoone_child"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    parents: Mapped[list[ManyToOneParent]] = relationship(back_populates="child")
+
+
+class OneToOneParent(Base):
+    __tablename__ = "onetoone_parent"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    child: Mapped["OneToOneChild"] = relationship(back_populates="parent")
+
+
+class OneToOneChild(Base):
+    __tablename__ = "onetoone_child"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    parent_id: Mapped[int] = mapped_column(sa.ForeignKey(OneToOneParent.id))
+    parent: Mapped[OneToOneParent] = relationship(back_populates="child")
+
+
+association_table = sa.Table(
+    "association_table",
+    Base.metadata,
+    sa.Column("left_id", sa.ForeignKey("manytomany_left.id"), primary_key=True),
+    sa.Column("right_id", sa.ForeignKey("manytomany_right.id"), primary_key=True),
+)
+
+
+class ManyToManyParent(Base):
+    __tablename__ = "manytomany_left"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    children: Mapped[list["ManyToManyChild"]] = relationship(secondary=association_table,
+                                                             back_populates="parents")
+
+
+class ManyToManyChild(Base):
+    __tablename__ = "manytomany_right"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str]
+    value: Mapped[int]
+    parents: Mapped[list[ManyToManyParent]] = relationship(secondary=association_table,
+                                                           back_populates="children")
+
+
 async def check_credentials(username: str, password: str) -> bool:
     return username == "admin" and password == "admin"
 
@@ -23,13 +118,34 @@ async def create_app() -> web.Application:
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
     async with session.begin() as sess:
-        sess.add(Author(name="John Doe"))
-        author1 = Author(name="Jane Smith")
-        sess.add(author1)
+        sess.add(OneToManyParent(name="Foo", value=1))
+        onetomany_1 = OneToManyParent(name="Bar", value=2)
+        sess.add(onetomany_1)
+        manytoone_1 = ManyToOneChild(name="Child Foo", value=4)
+        sess.add(manytoone_1)
+        onetoone_1 = OneToOneParent(name="Foo", value=3)
+        sess.add(onetoone_1)
+        onetoone_2 = OneToOneParent(name="Bar", value=5)
+        sess.add(onetoone_2)
+        manytomany_p1 = ManyToManyParent(name="Foo", value=2)
+        manytomany_p2 = ManyToManyParent(name="Bar", value=3)
+        manytomany_c1 = ManyToManyChild(name="Foo Child", value=5)
+        manytomany_c2 = ManyToManyChild(name="Bar Child", value=6)
+        manytomany_p1.children.append(manytomany_c1)
+        manytomany_p1.children.append(manytomany_c2)
+        manytomany_p2.children.append(manytomany_c1)
+        manytomany_p2.children.append(manytomany_c2)
+        sess.add(manytomany_p1)
+        sess.add(manytomany_p2)
+        sess.add(manytomany_c1)
+        sess.add(manytomany_c2)
     async with session.begin() as sess:
-        sess.add(Book(author_id=author1.id, title="Book 1"))
-        sess.add(Book(author_id=author1.id, title="Book 2"))
-        sess.add(Book(author_id=author1.id, title="Another book"))
+        sess.add(OneToManyChild(name="Child Foo", value=1, parent_id=onetomany_1.id))
+        sess.add(OneToManyChild(name="Child Bar", value=5, parent_id=onetomany_1.id))
+        sess.add(ManyToOneParent(name="Foo", value=5, child_id=manytoone_1.id))
+        sess.add(ManyToOneParent(name="Bar", value=3))
+        sess.add(OneToOneChild(name="Child Foo", value=0, parent_id=onetoone_2.id))
+        sess.add(OneToOneChild(name="Child Bar", value=2, parent_id=onetoone_1.id))
 
     app = web.Application()
 
@@ -40,8 +156,14 @@ async def create_app() -> web.Application:
             "secure": False
         },
         "resources": (
-            {"model": SAResource(engine, Author), "repr": Author.name.name},
-            {"model": SAResource(engine, Book)}
+            {"model": SAResource(engine, OneToManyParent), "repr": "name"},
+            {"model": SAResource(engine, OneToManyChild)},
+            {"model": SAResource(engine, ManyToOneParent), "repr": "name"},
+            {"model": SAResource(engine, ManyToOneChild)},
+            {"model": SAResource(engine, OneToOneParent), "repr": "name"},
+            {"model": SAResource(engine, OneToOneChild)},
+            # {"model": SAResource(engine, ManyToManyParent)},
+            # {"model": SAResource(engine, ManyToManyChild)}
         )
     }
     aiohttp_admin.setup(app, schema)
diff --git a/tests/test_admin.py b/tests/test_admin.py
@@ -128,3 +128,14 @@ def test_extra_props() -> None:
                                                    "label": "Spam"}
     assert test_state["inputs"]["id"]["props"] == {"alwaysOn": "alwaysOn", "type": "email",
                                                    "multiline": True, "resettable": False}
+
+
+def test_invalid_repr() -> None:
+    app = web.Application()
+    model = DummyResource("test", {"id": {"type": "TextField", "props": {}},
+                                   "foo": {"type": "TextField", "props": {}}}, {}, "id")
+    schema: aiohttp_admin.Schema = {"security": {"check_credentials": check_credentials},
+                                    "resources": ({"model": model, "repr": "bar"},)}
+
+    with pytest.raises(ValueError, match=r"not a valid field name: bar"):
+        aiohttp_admin.setup(app, schema)
diff --git a/tests/test_backends_sqlalchemy.py b/tests/test_backends_sqlalchemy.py
