Use property to alias ForeignKey fields instead of Pydantic alias

docs/docs/guides/response/config-pydantic.md

@@ -9,17 +9,16 @@ There are many customizations available for a **Django Ninja `Schema`**, via the
  when using Django models, as Pydantic's model class is called Model by default, and conflicts with
  Django's Model class.
 
-## Example Camel Case mode
+## Automatic Camel Case Aliases
 
-One interesting `Config` attribute is [`alias_generator`](https://pydantic-docs.helpmanual.io/usage/model_config/#alias-generator).
+One useful `Config` attribute is [`alias_generator`](https://pydantic-docs.helpmanual.io/usage/model_config/#alias-generator).
+We can use it to automatically generate aliases for field names with a given function. This is mostly commonly used to create
+an API that uses camelCase for its property names.
 Using Pydantic's example in **Django Ninja** can look something like:
 
-```python hl_lines="12 13"
+```python hl_lines="9 10"
 from ninja import Schema
-
-
-def to_camel(string: str) -> str:
- return ''.join(word.capitalize() for word in string.split('_'))
+from pydantic.alias_generators import to_camel
 
 
 class CamelModelSchema(Schema):
@@ -33,15 +32,18 @@ class CamelModelSchema(Schema):
 !!! note
  When overriding the schema's `Config`, it is necessary to inherit from the base `Config` class. 
 
-Keep in mind that when you want modify output for field names (like cammel case) - you need to set as well `populate_by_name` and `by_alias`
+To alias `ModelSchema`'s field names, you'll also need to set `populate_by_name` on the `Schema` config and 
+enable `by_alias` in all endpoints using the model.
 
-```python hl_lines="6 9"
+```python hl_lines="4 11"
 class UserSchema(ModelSchema):
- class Config:
- model = User
- model_fields = ["id", "email"]
+ class Config(Schema.Config):
  alias_generator = to_camel
  populate_by_name = True # !!!!!! <--------
+
+ class Meta:
+ model = User
+ model_fields = ["id", "email", "created_date"]
 
 
 @api.get("/users", response=list[UserSchema], by_alias=True) # !!!!!! <-------- by_alias
@@ -55,13 +57,15 @@ results:
 ```JSON
 [
  {
- "Id": 1,
- "Email": "[email protected]"
+ "id": 1,
+ "email": "[email protected]",
+ "createdDate": "2011-08-24"
  },
  {
- "Id": 2,
- "Email": "[email protected]"
- }
+ "id": 2,
+ "email": "[email protected]",
+ "createdDate": "2012-03-06"
+ },
  ...
 ]
 

ninja/orm/factory.py

@@ -6,7 +6,7 @@
 from pydantic import create_model as create_pydantic_model
 
 from ninja.errors import ConfigError
-from ninja.orm.fields import get_schema_field
+from ninja.orm.fields import get_field_property_accessors, get_schema_field
 from ninja.schema import Schema
 
 # MAYBE:
@@ -62,12 +62,13 @@ def create_schema(
 
  definitions = {}
  for fld in model_fields_list:
- python_type, field_info = get_schema_field(
+ # types: ignore
+ field_name, python_type, field_info = get_schema_field(
  fld,
  depth=depth,
  optional=optional_fields and (fld.name in optional_fields),
  )
- definitions[fld.name] = (python_type, field_info)
+ definitions[field_name] = (python_type, field_info)
 
  if custom_fields:
  for fld_name, python_type, field_info in custom_fields:
@@ -96,6 +97,13 @@ def create_schema(
  # **field_definitions: Any,
  self.schemas[key] = schema
  self.schema_names.add(name)
+
+ if depth == 0:
+ for fld in model_fields_list:
+ if fld.is_relation:
+ field_name, prop = get_field_property_accessors(fld)
+ setattr(schema, field_name, prop)
+
  return schema
 
  def get_key(

ninja/orm/fields.py

@@ -1,11 +1,22 @@
 import datetime
 from decimal import Decimal
-from typing import Any, Callable, Dict, List, Tuple, Type, TypeVar, Union, no_type_check
+from typing import (
+ Any,
+ Callable,
+ Dict,
+ List,
+ Tuple,
+ Type,
+ TypeVar,
+ Union,
+ cast,
+ no_type_check,
+)
 from uuid import UUID
 
 from django.db.models import ManyToManyField
 from django.db.models.fields import Field as DjangoField
-from pydantic import IPvAnyAddress
+from pydantic import BaseModel, IPvAnyAddress
 from pydantic.fields import FieldInfo
 from pydantic_core import PydanticUndefined, core_schema
 
@@ -106,8 +117,9 @@ def _validate(cls, v: Any, _):
 @no_type_check
 def get_schema_field(
  field: DjangoField, *, depth: int = 0, optional: bool = False
-) -> Tuple:
+) -> Tuple[str, Type, FieldInfo]:
  "Returns pydantic field from django's model field"
+ name = field.name
  alias = None
  default = ...
  default_factory = None
@@ -118,14 +130,15 @@ def get_schema_field(
 
  if field.is_relation:
  if depth > 0:
- return get_related_field_schema(field, depth=depth)
+ python_type, field_info = get_related_field_schema(field, depth=depth)
+ return name, python_type, field_info
 
  internal_type = field.related_model._meta.pk.get_internal_type()
 
  if not field.concrete and field.auto_created or field.null:
  default = None
 
- alias = getattr(field, "get_attname", None) and field.get_attname()
+ name = getattr(field, "get_attname", None) and field.get_attname()
 
  pk_type = TYPES.get(internal_type, int)
  if field.one_to_many or field.many_to_many:
@@ -165,6 +178,7 @@ def get_schema_field(
  title = title_if_lower(field.verbose_name)
 
  return (
+ name,
  python_type,
  FieldInfo(
  default=default,
@@ -180,7 +194,9 @@ def get_schema_field(
 
 
 @no_type_check
-def get_related_field_schema(field: DjangoField, *, depth: int) -> Tuple[OpenAPISchema]:
+def get_related_field_schema(
+ field: DjangoField, *, depth: int
+) -> Tuple[OpenAPISchema, FieldInfo]:
  from ninja.orm import create_schema
 
  model = field.related_model
@@ -199,3 +215,18 @@ def get_related_field_schema(field: DjangoField, *, depth: int) -> Tuple[OpenAPI
  title=title_if_lower(field.verbose_name),
  ),
  )
+
+
+def get_field_property_accessors(field: DjangoField) -> Tuple[str, property]:
+ attribute_name = cast(
+ str, getattr(field, "get_attname", None) and field.get_attname()
+ )
+ property_name: str = field.name
+
+ def getter(self: BaseModel) -> Any:
+ return getattr(self, attribute_name)
+
+ def setter(self: BaseModel, value: Any) -> None:
+ setattr(self, attribute_name, value)
+
+ return property_name, property(getter, setter)

tests/test_alias.py

@@ -1,4 +1,10 @@
-from ninja import Field, NinjaAPI, Schema
+import datetime
+
+from django.db import models
+from pydantic import ConfigDict
+from pydantic.alias_generators import to_camel
+
+from ninja import Field, ModelSchema, NinjaAPI, Schema
 
 
 class SchemaWithAlias(Schema):
@@ -35,3 +41,80 @@ def test_alias():
 # @api.post("/path", response=SchemaWithAlias)
 # def alias_operation(request, payload: SchemaWithAlias):
 # return {"bar": payload.foo}
+
+
+def test_alias_foreignkey_schema():
+ class Author(models.Model):
+ id = models.AutoField(primary_key=True)
+ name = models.CharField(max_length=50)
+
+ class Meta:
+ app_label = "tests"
+
+ class Book(models.Model):
+ id = models.AutoField(primary_key=True)
+ name = models.CharField(max_length=100)
+ author = models.ForeignKey(Author, on_delete=models.CASCADE)
+ published_date = models.DateField(default=datetime.date.today())
+
+ class Meta:
+ app_label = "tests"
+
+ class BookSchema(ModelSchema):
+ model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+ class Meta:
+ model = Book
+ fields = "__all__"
+
+ assert BookSchema.json_schema() == {
+ "properties": {
+ "authorId": {"title": "Author", "type": "integer"},
+ "id": {"anyOf": [{"type": "integer"}, {"type": "null"}], "title": "Id"},
+ "name": {"maxLength": 100, "title": "Name", "type": "string"},
+ "publishedDate": {
+ "default": "2024-03-22",
+ "format": "date",
+ "title": "Published Date",
+ "type": "string",
+ },
+ },
+ "required": ["name", "authorId"],
+ "title": "BookSchema",
+ "type": "object",
+ }
+
+
+def test_alias_foreignkey_property():
+ class Author(models.Model):
+ id = models.AutoField(primary_key=True)
+ name = models.CharField(max_length=50)
+
+ class Meta:
+ app_label = "tests"
+
+ class Book(models.Model):
+ id = models.AutoField(primary_key=True)
+ name = models.CharField(max_length=100)
+ author = models.ForeignKey(Author, on_delete=models.CASCADE)
+ published_date = models.DateField(default=datetime.date.today())
+
+ class Meta:
+ app_label = "tests"
+
+ class BookSchema(ModelSchema):
+ class Config(Schema.Config):
+ alias_generator = to_camel
+ populate_by_name = True
+
+ class Meta:
+ model = Book
+ fields = "__all__"
+
+ author_test = Author(name="J. R. R. Tolkien", id=1)
+ model_test = Book(author=author_test, name="The Hobbit", id=1)
+ schema_test = BookSchema.from_orm(model_test)
+
+ schema_test.author = 2
+ assert schema_test.author == 2
+ assert schema_test.author_id == 2