Use str IDs for API (#775)

Author: Dreamsorcerer

.mypy.ini

@@ -23,6 +23,10 @@ warn_return_any = True
 warn_unreachable = True
 warn_unused_ignores = True
 
+[mypy-aiohttp_admin.backends.sqlalchemy]
+# We use Any for several parameters, causing a few of these errors.
+disallow_any_decorated = False
+
 [mypy-tests.*]
 disallow_any_decorated = False
 disallow_untyped_calls = False

admin-js/src/App.js

@@ -105,7 +105,7 @@ function dataRequest(resource, endpoint, params) {
     for (const [k, v] of Object.entries(params)) {
         if (v === undefined)
             delete params[k];
-        if (typeof v === "object" && v !== null)
+        else if (typeof v === "object" && v !== null)
             params[k] = JSON.stringify(v);
     }
     const query = new URLSearchParams(params).toString();

aiohttp_admin/backends/abc.py

@@ -13,9 +13,7 @@
 from sqlalchemy.orm import DeclarativeBase, QueryableAttribute
 from sqlalchemy.sql.roles import ExpressionElementRole
 
-from .abc import (
-    AbstractAdminResource, CreateParams, DeleteManyParams, DeleteParams, GetListParams,
-    GetManyParams, GetOneParams, Record, UpdateManyParams, UpdateParams)
+from .abc import AbstractAdminResource, GetListParams, Meta, Record
 from ..types import FunctionState, comp, func, regex
 
 if sys.version_info >= (3, 10):
@@ -155,7 +153,8 @@ def create_filters(columns: sa.ColumnCollection[str, sa.Column[object]],
             for k, v in filters.items())
 
 
-class SAResource(AbstractAdminResource):
+# ID is based on PK, which we can't infer from types, so must use Any here.
+class SAResource(AbstractAdminResource[Any]):
     def __init__(self, db: AsyncEngine, model_or_table: Union[sa.Table, type[DeclarativeBase]]):
         if isinstance(model_or_table, sa.Table):
             table = model_or_table
@@ -168,12 +167,14 @@ def __init__(self, db: AsyncEngine, model_or_table: Union[sa.Table, type[Declara
         self.fields = {}
         self.inputs = {}
         self.omit_fields = set()
+        self._foreign_rows = set()
         record_type = {}
         for c in table.c.values():
             if c.foreign_keys:
                 field = "ReferenceField"
                 inp = "ReferenceInput"
                 key = next(iter(c.foreign_keys))  # TODO: Test composite foreign keys.
+                self._foreign_rows.add(c.name)
                 props: dict[str, Any] = {"reference": key.column.table.name,
                                          "target": key.column.name}
             else:
@@ -261,6 +262,7 @@ def __init__(self, db: AsyncEngine, model_or_table: Union[sa.Table, type[Declara
             # TODO: Test composite primary key
             raise NotImplementedError("Composite keys not supported yet.")
         self.primary_key = pk[0]
+        self._id_type = table.c[pk[0]].type.python_type
 
         super().__init__(record_type)
 
@@ -286,56 +288,57 @@ async def get_list(self, params: GetListParams) -> tuple[list[Record], int]:
         return entities, count
 
     @handle_errors
-    async def get_one(self, params: GetOneParams) -> Record:
+    async def get_one(self, record_id: Any, meta: Meta) -> Record:
         async with self._db.connect() as conn:
-            stmt = sa.select(self._table).where(self._table.c[self.primary_key] == params["id"])
+            stmt = sa.select(self._table).where(self._table.c[self.primary_key] == record_id)
             result = await conn.execute(stmt)
             return result.one()._asdict()
 
     @handle_errors
-    async def get_many(self, params: GetManyParams) -> list[Record]:
+    async def get_many(self, record_ids: Sequence[Any], meta: Meta) -> list[Record]:
         async with self._db.connect() as conn:
-            stmt = sa.select(self._table).where(self._table.c[self.primary_key].in_(params["ids"]))
+            stmt = sa.select(self._table).where(self._table.c[self.primary_key].in_(record_ids))
             result = await conn.execute(stmt)
             return [r._asdict() for r in result]
 
     @handle_errors
-    async def create(self, params: CreateParams) -> Record:
+    async def create(self, data: Record, meta: Meta) -> Record:
         async with self._db.begin() as conn:
-            stmt = sa.insert(self._table).values(params["data"]).returning(*self._table.c)
+            stmt = sa.insert(self._table).values(data).returning(*self._table.c)
             try:
                 row = await conn.execute(stmt)
             except sa.exc.IntegrityError:
-                logger.warning("IntegrityError (%s)", params["data"], exc_info=True)
+                logger.warning("IntegrityError (%s)", data, exc_info=True)
                 raise web.HTTPBadRequest(reason="Integrity error (element already exists?)")
             return row.one()._asdict()
 
     @handle_errors
-    async def update(self, params: UpdateParams) -> Record:
+    async def update(self, record_id: Any, data: Record, previous_data: Record,
+                     meta: Meta) -> Record:
         async with self._db.begin() as conn:
-            stmt = sa.update(self._table).where(self._table.c[self.primary_key] == params["id"])
-            stmt = stmt.values(params["data"]).returning(*self._table.c)
+            stmt = sa.update(self._table).where(self._table.c[self.primary_key] == record_id)
+            stmt = stmt.values(data).returning(*self._table.c)
             row = await conn.execute(stmt)
             return row.one()._asdict()
 
     @handle_errors
-    async def update_many(self, params: UpdateManyParams) -> list[Union[str, int]]:
+    async def update_many(self, record_ids: Sequence[Any], data: Record, meta: Meta) -> list[Any]:
         async with self._db.begin() as conn:
-            stmt = sa.update(self._table).where(self._table.c[self.primary_key].in_(params["ids"]))
-            stmt = stmt.values(params["data"]).returning(self._table.c[self.primary_key])
+            stmt = sa.update(self._table).where(self._table.c[self.primary_key].in_(record_ids))
+            stmt = stmt.values(data).returning(self._table.c[self.primary_key])
             return list(await conn.scalars(stmt))
 
     @handle_errors
-    async def delete(self, params: DeleteParams) -> Record:
+    async def delete(self, record_id: Any, previous_data: Record, meta: Meta) -> Record:
         async with self._db.begin() as conn:
-            stmt = sa.delete(self._table).where(self._table.c[self.primary_key] == params["id"])
+            stmt = sa.delete(self._table).where(self._table.c[self.primary_key] == record_id)
             row = await conn.execute(stmt.returning(*self._table.c))
             return row.one()._asdict()
 
     @handle_errors
-    async def delete_many(self, params: DeleteManyParams) -> list[Union[str, int]]:
+    async def delete_many(self, record_ids: Sequence[Any], meta: Meta) -> list[Any]:
         async with self._db.begin() as conn:
-            stmt = sa.delete(self._table).where(self._table.c[self.primary_key].in_(params["ids"]))
+            stmt = sa.delete(self._table).where(self._table.c[self.primary_key].in_(record_ids))
             r = await conn.scalars(stmt.returning(self._table.c[self.primary_key]))
             return list(r)
 

aiohttp_admin/backends/sqlalchemy.py

@@ -1,41 +1,41 @@
-from typing import Union
+from typing import Sequence
 
-from aiohttp_admin.backends.abc import (
-    AbstractAdminResource, CreateParams, DeleteManyParams, DeleteParams, GetListParams,
-    GetManyParams, GetOneParams, Record, UpdateManyParams, UpdateParams)
+from aiohttp_admin.backends.abc import AbstractAdminResource, GetListParams, Meta, Record
 from aiohttp_admin.types import ComponentState, InputState
 
 
-class DummyResource(AbstractAdminResource):
+class DummyResource(AbstractAdminResource[str]):
     def __init__(self, name: str, fields: dict[str, ComponentState],
                  inputs: dict[str, InputState], primary_key: str):
         self.name = name
         self.fields = fields
         self.inputs = inputs
         self.primary_key = primary_key
         self.omit_fields = set()
+        self._id_type = str
+        self._foreign_rows = set()
         super().__init__()
 
     async def get_list(self, params: GetListParams) -> tuple[list[Record], int]:  # pragma: no cover  # noqa: B950
         raise NotImplementedError()
 
-    async def get_one(self, params: GetOneParams) -> Record:  # pragma: no cover
+    async def get_one(self, record_id: str, meta: Meta) -> Record:  # pragma: no cover
         raise NotImplementedError()
 
-    async def get_many(self, params: GetManyParams) -> list[Record]:  # pragma: no cover
+    async def get_many(self, record_ids: Sequence[str], meta: Meta) -> list[Record]:  # pragma: no cover  # noqa: B950
         raise NotImplementedError()
 
-    async def update(self, params: UpdateParams) -> Record:  # pragma: no cover
+    async def update(self, record_id: str, data: Record, previous_data: Record, meta: Meta) -> Record:  # pragma: no cover  # noqa: B950
         raise NotImplementedError()
 
-    async def update_many(self, params: UpdateManyParams) -> list[Union[int, str]]:  # pragma: no cover  # noqa: B950
+    async def update_many(self, record_ids: Sequence[str], data: Record, meta: Meta) -> list[str]:  # pragma: no cover  # noqa: B950
         raise NotImplementedError()
 
-    async def create(self, params: CreateParams) -> Record:  # pragma: no cover
+    async def create(self, data: Record, meta: Meta) -> Record:  # pragma: no cover
         raise NotImplementedError()
 
-    async def delete(self, params: DeleteParams) -> Record:  # pragma: no cover
+    async def delete(self, record_id: str, previous_data: Record, meta: Meta) -> Record:  # pragma: no cover  # noqa: B950
         raise NotImplementedError()
 
-    async def delete_many(self, params: DeleteManyParams) -> list[Union[int, str]]:  # pragma: no cover  # noqa: B950
+    async def delete_many(self, record_ids: Sequence[str], meta: Meta) -> list[str]:  # pragma: no cover  # noqa: B950
         raise NotImplementedError()

tests/_resources.py

@@ -13,4 +13,4 @@ async def test_create_with_null(admin_client: TestClient, login: _Login) -> None
     p = {"data": json.dumps({"msg": None})}
     async with admin_client.post(url, params=p, headers=h) as resp:
         assert resp.status == 200, await resp.text()
-        assert await resp.json() == {"data": {"id": 4, "msg": None}}
+        assert await resp.json() == {"data": {"id": "4", "msg": None}}

tests/test_backends_abc.py

@@ -118,11 +118,11 @@ class TestModel(base):  # type: ignore[misc,valid-type]
     url = app["admin"].router["test_get_one"].url_for()
     async with admin_client.get(url, params={"id": 1}, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 1, "binary": "foo"}}
+        assert await resp.json() == {"data": {"id": "1", "binary": "foo"}}
 
     async with admin_client.get(url, params={"id": 2}, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 2, "binary": "\x01�\x02"}}
+        assert await resp.json() == {"data": {"id": "2", "binary": "\x01�\x02"}}
 
 
 def test_fk(base: type[DeclarativeBase], mock_engine: AsyncEngine) -> None:
@@ -146,6 +146,51 @@ class TestChildModel(base):  # type: ignore[misc,valid-type]
          "source": "id", "target": "id"}) | {"show_create": True}}
 
 
+async def test_fk_output(
+    base: DeclarativeBase, aiohttp_client: Callable[[web.Application], Awaitable[TestClient]],
+    login: _Login
+) -> None:
+    class TestModel(base):  # type: ignore[misc,valid-type]
+        __tablename__ = "test"
+        id: Mapped[int] = mapped_column(primary_key=True)
+
+    class TestModelParent(base):  # type: ignore[misc,valid-type]
+        __tablename__ = "parent"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        child_id: Mapped[int] = mapped_column(sa.ForeignKey(TestModel.id))
+
+    app = web.Application()
+    engine = create_async_engine("sqlite+aiosqlite:///:memory:")
+    db = async_sessionmaker(engine, expire_on_commit=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(base.metadata.create_all)
+    async with db.begin() as sess:
+        child = TestModel()
+        sess.add(child)
+    async with db.begin() as sess:
+        sess.add(TestModelParent(child_id=child.id))
+
+    schema: aiohttp_admin.Schema = {
+        "security": {
+            "check_credentials": check_credentials,
+            "secure": False
+        },
+        "resources": ({"model": SAResource(engine, TestModel)},
+                      {"model": SAResource(engine, TestModelParent)})
+    }
+    app["admin"] = aiohttp_admin.setup(app, schema)
+
+    admin_client = await aiohttp_client(app)
+    assert admin_client.app
+    h = await login(admin_client)
+
+    url = app["admin"].router["parent_get_one"].url_for()
+    async with admin_client.get(url, params={"id": 1}, headers=h) as resp:
+        assert resp.status == 200
+        # child_id must be converted to str ID.
+        assert await resp.json() == {"data": {"id": "1", "child_id": "1"}}
+
+
 def test_relationship(base: type[DeclarativeBase], mock_engine: AsyncEngine) -> None:
     class TestMany(base):  # type: ignore[misc,valid-type]
         __tablename__ = "many"
@@ -335,31 +380,31 @@ class TestModel(base):  # type: ignore[misc,valid-type]
          "sort": json.dumps({"field": "id", "order": "DESC"}), "filter": "{}"}
     async with admin_client.get(url, params=p, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": [{"id": 8, "num": 8, "other": "bar"},
-                                              {"id": 5, "num": 5, "other": "foo"}], "total": 2}
+        assert await resp.json() == {"data": [{"id": "8", "num": 8, "other": "bar"},
+                                              {"id": "5", "num": 5, "other": "foo"}], "total": 2}
 
     url = app["admin"].router["test_get_one"].url_for()
     async with admin_client.get(url, params={"id": 8}, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 8, "num": 8, "other": "bar"}}
+        assert await resp.json() == {"data": {"id": "8", "num": 8, "other": "bar"}}
 
     url = app["admin"].router["test_get_many"].url_for()
-    async with admin_client.get(url, params={"ids": "[5, 8]"}, headers=h) as resp:
+    async with admin_client.get(url, params={"ids": '["5", "8"]'}, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": [{"id": 5, "num": 5, "other": "foo"},
-                                              {"id": 8, "num": 8, "other": "bar"}]}
+        assert await resp.json() == {"data": [{"id": "5", "num": 5, "other": "foo"},
+                                              {"id": "8", "num": 8, "other": "bar"}]}
 
     url = app["admin"].router["test_create"].url_for()
     p = {"data": json.dumps({"num": 12, "other": "this"})}
     async with admin_client.post(url, params=p, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 12, "num": 12, "other": "this"}}
+        assert await resp.json() == {"data": {"id": "12", "num": 12, "other": "this"}}
 
     url = app["admin"].router["test_update"].url_for()
     p1 = {"id": 5, "data": json.dumps({"id": 5, "other": "that"}), "previousData": "{}"}
     async with admin_client.put(url, params=p1, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 5, "num": 5, "other": "that"}}
+        assert await resp.json() == {"data": {"id": "5", "num": 5, "other": "that"}}
 
 
 async def test_datetime(
@@ -396,14 +441,14 @@ class TestModel(base):  # type: ignore[misc,valid-type]
     url = app["admin"].router["test_get_one"].url_for()
     async with admin_client.get(url, params={"id": 1}, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 1, "date": "2023-04-23",
+        assert await resp.json() == {"data": {"id": "1", "date": "2023-04-23",
                                               "time": "2023-01-02 03:04:00"}}
 
     url = app["admin"].router["test_create"].url_for()
     p = {"data": json.dumps({"date": "2024-05-09", "time": "2020-11-12 03:04:05"})}
     async with admin_client.post(url, params=p, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 2, "date": "2024-05-09",
+        assert await resp.json() == {"data": {"id": "2", "date": "2024-05-09",
                                               "time": "2020-11-12 03:04:05"}}
 
 
@@ -473,11 +518,11 @@ class TestModel(base):  # type: ignore[misc,valid-type]
     p = {"data": json.dumps({"foo": True, "bar": 5})}
     async with admin_client.post(url, params=p, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 1, "foo": True, "bar": 5}}
+        assert await resp.json() == {"data": {"id": "1", "foo": True, "bar": 5}}
     p = {"data": json.dumps({"foo": None, "bar": -1})}
     async with admin_client.post(url, params=p, headers=h) as resp:
         assert resp.status == 200
-        assert await resp.json() == {"data": {"id": 2, "foo": None, "bar": -1}}
+        assert await resp.json() == {"data": {"id": "2", "foo": None, "bar": -1}}
 
     p = {"data": json.dumps({"foo": 5, "bar": "foo"})}
     async with admin_client.post(url, params=p, headers=h) as resp: