feat: New feature, support custom read_fields.

Author: amisadmin

fastapi_amis_admin/crud/_sqlmodel.py

@@ -1,5 +1,4 @@
 import datetime
-import logging
 import re
 from enum import Enum
 from typing import (
@@ -19,6 +18,7 @@
 from fastapi import APIRouter, Body, Depends, Query
 from fastapi.encoders import DictIntStrAny, SetIntStr
 from pydantic import Extra, Json
+from pydantic.fields import ModelField
 from sqlalchemy import Column, Table, delete, func, insert
 from sqlalchemy.future import select
 from sqlalchemy.orm import InstrumentedAttribute, Session
@@ -42,6 +42,7 @@
     SQLModelField,
     SQLModelFieldParser,
     SQLModelListField,
+    SQLModelPropertyField,
     get_python_type_parse,
 )
 from .schema import BaseApiOut, ItemListSchema
@@ -228,11 +229,15 @@ def calc_filter_clause(self, data: Dict[str, Any]) -> List[BinaryExpression]:
 class SQLModelCrud(BaseCrud, SQLModelSelector):
     engine: SqlalchemyDatabase = None
     create_fields: List[SQLModelField] = []  # 新增数据字段
-    readonly_fields: List[SQLModelListField] = []  # 只读字段
-    """readonly fields, deprecated, not recommended, will be removed in version 0.4.0"""
-    update_fields: List[SQLModelListField] = []  # 可编辑字段
+    readonly_fields: List[SQLModelListField] = []
+    """readonly fields, priority is higher than update_fields.
+    readonly fields, deprecated, not recommended, will be removed in version 0.4.0"""
+    update_fields: List[SQLModelPropertyField] = []
+    """model update fields;support model property and relationship field."""
     update_exclude: Optional[Union[SetIntStr, DictIntStrAny]] = None
-    """update exclude fields, such as: {'id', 'key', 'name'} or {'id': True, 'category': {'id', 'name'}}"""
+    """update exclude fields, such as: {'id', 'key', 'name'} or {'id': True, 'category': {'id', 'name'}}."""
+    read_fields: List[SQLModelPropertyField] = []
+    """Model read fields; used in route_read, note the difference between readonly_fields and read_fields."""
 
     def __init__(
         self,
@@ -246,11 +251,11 @@ def __init__(
         self.db = get_engine_db(self.engine)
         SQLModelSelector.__init__(self, model, fields)
         BaseCrud.__init__(self, self.model, router)
-        if self.readonly_fields:
-            logging.warning(
-                "readonly fields, deprecated, not recommended, will be removed in version 0.4.0."
-                "Please replace them with update_fields and update_exclude."
-            )
+        # if self.readonly_fields:
+        #     logging.warning(
+        #         "readonly fields, deprecated, not recommended, will be removed in version 0.4.0."
+        #         "Please replace them with update_fields and update_exclude."
+        #     )
 
     def _create_schema_list(self) -> Type[SchemaListT]:
         if self.schema_list:
@@ -296,6 +301,15 @@ def _create_schema_filter(self) -> Type[SchemaFilterT]:
             set_none=True,
         )
 
+    def _create_schema_read(self) -> Type[SchemaReadT]:
+        if self.schema_read:
+            return self.schema_read
+        if not self.read_fields:
+            return super()._create_schema_read()
+        self.read_fields = self.parser.filter_insfield(self.read_fields, save_class=(ModelField,))
+        modelfields = [self.parser.get_modelfield(ins, deepcopy=True) for ins in self.read_fields]
+        return schema_create_by_modelfield(f"{self.schema_name_prefix}Read", modelfields, orm_mode=True)
+
     def _create_schema_update(self) -> Type[SchemaUpdateT]:
         if self.schema_update:
             return self.schema_update
@@ -340,7 +354,7 @@ def _fetch_item_scalars(self, session: Session, item_id: List[str]) -> List[Mode
         stmt = select(self.model).where(self.pk.in_(list(map(get_python_type_parse(self.pk), item_id))))
         return session.scalars(stmt).all()
 
-    def _read_items(self, session: Session, item_id: List[str]):
+    def _read_items(self, session: Session, item_id: List[str]) -> List[SchemaReadT]:
         items = self._fetch_item_scalars(session, item_id)
         return [self.read_item(obj) for obj in items]
 

fastapi_amis_admin/crud/parser.py

@@ -16,6 +16,7 @@
 SQLModelField = Union[str, InstrumentedAttribute]
 SqlField = Union[InstrumentedAttribute, Label]
 SQLModelListField = Union[Type[SQLModel], SQLModelField, SqlField]
+SQLModelPropertyField = Union[Type[SQLModel], SQLModelField, "PropertyField"]
 
 
 class SQLModelFieldParser:
@@ -161,8 +162,20 @@ def _get_label_modelfield(label: Label) -> ModelField:
 
 
 def LabelField(label: Label, field: FieldInfo) -> Label:
+    """Use for adding FieldInfo to sqlalchemy Label type"""
     modelfield = _get_label_modelfield(label)
     field.alias = label.key
     modelfield.field_info = field
     label.__ModelField__ = modelfield
     return label
+
+
+class PropertyField(ModelField):
+    """Use this to quickly initialize a ModelField, mainly used in schema_read and schema_update"""
+
+    def __init__(
+        self, *, name: str, type_: Type[Any], required: bool = False, field_info: Optional[FieldInfo] = None, **kwargs: Any
+    ) -> None:
+        kwargs.setdefault("class_validators", {})
+        kwargs.setdefault("model_config", BaseConfig)
+        super().__init__(name=name, type_=type_, required=required, field_info=field_info, **kwargs)

fastapi_amis_admin/crud/utils.py

@@ -4,6 +4,7 @@
 from fastapi.params import Path
 from pydantic import BaseConfig, BaseModel, Extra
 from pydantic.fields import ModelField
+from pydantic.main import ModelMetaclass
 from pydantic.utils import smart_deepcopy
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import AsyncEngine
@@ -50,6 +51,7 @@ def schema_create_by_modelfield(
     **kwargs,
 ) -> Type[BaseModel]:
     namespaces = namespaces or {}
+    namespaces["Config"] = type("Config", (BaseApiSchema.Config,), {"extra": extra, **kwargs})
     namespaces.update({"__fields__": {}, "__annotations__": {}})
     for modelfield in modelfields:
         if set_none:
@@ -61,7 +63,7 @@ def schema_create_by_modelfield(
                 modelfield.pre_validators.insert(0, validator_skip_blank)
         namespaces["__fields__"][modelfield.name] = modelfield
         namespaces["__annotations__"][modelfield.name] = modelfield.type_
-    return type(schema_name, (BaseApiSchema,), namespaces, extra=extra, **kwargs)  # type: ignore
+    return ModelMetaclass(schema_name, (BaseApiSchema,), namespaces)
 
 
 def parser_str_set_list(set_str: Union[int, str]) -> List[str]:

tests/models.py

@@ -70,3 +70,7 @@ class Article(PkModelMixin, CreateTimeModelMixin, table=True):
     user: Optional[User] = Relationship(back_populates="articles")
 
     tags: List[Tag] = Relationship(back_populates="articles", link_model=ArticleTagLink)
+
+    @property
+    def content_text(self):
+        return self.content.content if self.content else ""

tests/test_crud/test_SQLModelCrud_fields.py

@@ -4,10 +4,10 @@
 from starlette.requests import Request
 
 from fastapi_amis_admin.crud import SQLModelCrud
-from fastapi_amis_admin.crud.parser import LabelField
+from fastapi_amis_admin.crud.parser import LabelField, PropertyField
 from fastapi_amis_admin.models import Field
 from tests.conftest import async_db as db
-from tests.models import Article, User
+from tests.models import Article, Category, User
 
 
 async def test_pk_name(app: FastAPI, async_client: AsyncClient, fake_users):
@@ -244,3 +244,61 @@ async def get_select(self, request: Request) -> Select:
     assert items[0]["id"] == 2
     assert items[0]["user__username"] == "User_2"
     assert items[0]["pwd"] == "password_2"
+
+
+async def test_read_fields(app: FastAPI, async_client: AsyncClient, fake_articles):
+    class ArticleCrud(SQLModelCrud):
+        router_prefix = "/article"
+        read_fields = [
+            Article.title,
+            Article.description,
+            # Article.category,  # Relationship
+            # Article.user  # Relationship
+        ]
+
+    ins = ArticleCrud(Article, db.engine).register_crud()
+
+    app.include_router(ins.router)
+
+    # test schemas
+    assert "id" not in ins.schema_read.__fields__
+    assert "title" in ins.schema_read.__fields__
+    assert "description" in ins.schema_read.__fields__
+    # test api
+    res = await async_client.get("/article/item/1")
+    items = res.json()["data"]
+    print(items)
+    assert "id" not in items
+    assert items["title"] == "Article_1"
+    assert items["description"] == "Description_1"
+
+
+async def test_read_fields_relationship(app: FastAPI, async_client: AsyncClient, fake_articles):
+    class ArticleCrud(SQLModelCrud):
+        router_prefix = "/article"
+        read_fields = [
+            Article.title,
+            Article.description,
+            PropertyField(name="category", type_=Category),  # Relationship attribute
+            # Article.category,  # Relationship todo support
+            PropertyField(name="content_text", type_=str),  # property attribute
+        ]
+
+    ins = ArticleCrud(Article, db.engine).register_crud()
+
+    app.include_router(ins.router)
+
+    # test schemas
+    assert "id" not in ins.schema_read.__fields__
+    assert "title" in ins.schema_read.__fields__
+    assert "description" in ins.schema_read.__fields__
+    assert "category" in ins.schema_read.__fields__
+    # test api
+    res = await async_client.get("/article/item/1")
+    items = res.json()["data"]
+    print(items)
+    assert "id" not in items
+    assert "category" in items
+    assert items["category"]["name"] == "Category_1"
+    assert "content_text" in items
+    # assert items["user"]["username"] == "User_1"