Add --read-only-write-only-model-type option for OpenAPI readOnly/writeOnly support (#2587)

* Add support for readOnly/writeOnly model generation strategy

* docs: update command help in README

🤖 Generated by GitHub Actions

* refactor: streamline readOnly/writeOnly resolution and model generation

* feat: enhance readOnly/writeOnly model handling and add related tests

* feat: implement readOnly/writeOnly model handling with Union type support and add related tests

* fix: improve deep copy handling in _copy_field method for DataModelFieldBase

* feat: update path parameter handling and add comprehensive tests for readOnly/writeOnly models

* feat: add readOnly/writeOnly model handling with allOf support and related tests

* feat: add test for readOnly/writeOnly with allOf in request-response mode and generate related model

* fix: improve reference resolution handling in _iter_fields_from_schema method

* fix: ensure field_key is not None before deduplicating fields in _collect_all_fields

* feat: enhance reference field iteration with visited tracking to prevent infinite recursion

* fix: handle unresolved references in allOf and skip None field keys during deduplication

* feat: update base model generation logic to support readOnly/writeOnly configurations and add related tests

* feat: implement readOnly/writeOnly flag resolution and update model generation logic

* fix: refactor source handling in field iteration to improve clarity and maintainability

* fix: simplify conditional logic in field iteration for improved readability

* refactor: streamline unique model name generation to avoid collisions

* feat: add deep copy functionality for DataModelFieldBase and enhance field iteration to include inherited fields

* refactor: remove redundant iter_all_fields method to simplify field iteration logic

* refactor: simplify readOnly and writeOnly resolution logic in JsonSchemaObject

* Refactor: simplify readOnly and writeOnly resolution logic in JsonSchemaObject

* Refactor: unify readOnly and writeOnly flag resolution logic and enhance field iteration

* Refactor: streamline field lookup logic in DataModel and TypedDict classes

* Add tests for readOnly/writeOnly detection in anyOf and oneOf compositions

* Refactor: remove duplicate inheritance in Parent class and enhance base class field resolution

* Add tests for readOnly/writeOnly behavior with shared base references and empty base classes

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: koxudaxi

README.md

@@ -541,6 +541,10 @@ OpenAPI-only options:
                         query parameters (Only OpenAPI)
   --openapi-scopes {schemas,paths,tags,parameters,webhooks} [{schemas,paths,tags,parameters,webhooks} ...]
                         Scopes of OpenAPI model generation (default: schemas)
+  --read-only-write-only-model-type {request-response,all}
+                        Model generation for readOnly/writeOnly fields: ''request-response'' =
+                        Request/Response models only (no base model), ''all'' = Base + Request
+                        + Response models.
   --strict-nullable     Treat default field as a non-nullable field (Only OpenAPI)
   --use-operation-id-as-name
                         use operation id of OpenAPI as class names of models

docs/index.md

@@ -533,6 +533,10 @@ OpenAPI-only options:
                         query parameters (Only OpenAPI)
   --openapi-scopes {schemas,paths,tags,parameters,webhooks} [{schemas,paths,tags,parameters,webhooks} ...]
                         Scopes of OpenAPI model generation (default: schemas)
+  --read-only-write-only-model-type {request-response,all}
+                        Model generation for readOnly/writeOnly fields: ''request-response'' =
+                        Request/Response models only (no base model), ''all'' = Base + Request
+                        + Response models.
   --strict-nullable     Treat default field as a non-nullable field (Only OpenAPI)
   --use-operation-id-as-name
                         use operation id of OpenAPI as class names of models

docs/openapi.md

@@ -210,3 +210,138 @@ class Api(BaseModel):
 class Apis(BaseModel):
     __root__: List[Api]
 ```
+
+## readOnly / writeOnly Properties
+
+OpenAPI 3.x supports `readOnly` and `writeOnly` property annotations:
+
+- **readOnly**: Property is only returned in responses (e.g., `id`, `created_at`)
+- **writeOnly**: Property is only sent in requests (e.g., `password`)
+
+### Option: `--read-only-write-only-model-type`
+
+This option generates separate Request/Response models based on these annotations.
+
+| Value | Description |
+|-------|-------------|
+| (not set) | Default. No special handling (backward compatible) |
+| `request-response` | Generate only Request/Response models (no base model) |
+| `all` | Generate base model + Request + Response models |
+
+### Example Schema
+
+```yaml
+openapi: "3.0.0"
+info:
+  title: User API
+  version: "1.0"
+paths: {}
+components:
+  schemas:
+    User:
+      type: object
+      required:
+        - id
+        - name
+      properties:
+        id:
+          type: integer
+          readOnly: true      # Server-generated, not in requests
+        name:
+          type: string
+        password:
+          type: string
+          writeOnly: true     # Client-only, not in responses
+        created_at:
+          type: string
+          format: date-time
+          readOnly: true
+```
+
+### Generated Output
+
+```bash
+$ datamodel-codegen --input user.yaml --input-file-type openapi \
+    --output-model-type pydantic_v2.BaseModel \
+    --read-only-write-only-model-type all
+```
+
+```python
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+# Request model: excludes readOnly fields (id, created_at)
+class UserRequest(BaseModel):
+    name: str
+    password: Optional[str] = None
+
+# Response model: excludes writeOnly fields (password)
+class UserResponse(BaseModel):
+    id: int
+    name: str
+    created_at: Optional[datetime] = None
+
+# Base model: contains all fields
+class User(BaseModel):
+    id: int
+    name: str
+    password: Optional[str] = None
+    created_at: Optional[datetime] = None
+```
+
+### Usage Patterns
+
+| Use Case | Recommended Option | Generated Models |
+|----------|-------------------|------------------|
+| API client validation | `request-response` | `UserRequest`, `UserResponse` |
+| Database ORM mapping | (not set) | `User` |
+| Both client & ORM | `all` | `User`, `UserRequest`, `UserResponse` |
+
+### Behavior with allOf Inheritance
+
+When using `allOf` with `$ref`, fields from all referenced schemas are flattened into Request/Response models:
+
+```yaml
+components:
+  schemas:
+    Timestamps:
+      type: object
+      properties:
+        created_at:
+          type: string
+          format: date-time
+          readOnly: true
+
+    User:
+      allOf:
+        - $ref: "#/components/schemas/Timestamps"
+        - type: object
+          properties:
+            name:
+              type: string
+```
+
+Generated `UserRequest` will exclude `created_at` (readOnly from Timestamps).
+
+### Collision Handling
+
+If a schema named `UserRequest` or `UserResponse` already exists, the generated model will be named `UserRequestModel` or `UserResponseModel` to avoid conflicts.
+
+### Supported Output Formats
+
+This option works with all output formats:
+
+- `pydantic.BaseModel` / `pydantic_v2.BaseModel`
+- `dataclasses.dataclass`
+- `typing.TypedDict`
+- `msgspec.Struct`
+
+### Supported $ref Types
+
+readOnly/writeOnly resolution works with local and file reference types:
+
+| Reference Type | Example | Support |
+|---------------|---------|---------|
+| Local | `#/components/schemas/User` | ✅ |
+| File | `./common.yaml#/User` | ✅ |

src/datamodel_code_generator/__init__.py

@@ -276,6 +276,17 @@ class GraphQLScope(Enum):
     Schema = "schema"
 
 
+class ReadOnlyWriteOnlyModelType(Enum):
+    """Model generation strategy for readOnly/writeOnly fields.
+
+    RequestResponse: Generate only Request/Response model variants (no base model).
+    All: Generate Base, Request, and Response models.
+    """
+
+    RequestResponse = "request-response"
+    All = "all"
+
+
 class Error(Exception):
     """Base exception for datamodel-code-generator errors."""
 
@@ -435,6 +446,7 @@ def generate(  # noqa: PLR0912, PLR0913, PLR0914, PLR0915
     dataclass_arguments: DataclassArguments | None = None,
     disable_future_imports: bool = False,
     type_mappings: list[str] | None = None,
+    read_only_write_only_model_type: ReadOnlyWriteOnlyModelType | None = None,
     all_exports_scope: AllExportsScope | None = None,
     all_exports_collision_strategy: AllExportsCollisionStrategy | None = None,
 ) -> None:
@@ -670,6 +682,7 @@ def get_header_and_first_line(csv_file: IO[str]) -> dict[str, Any]:
         parent_scoped_naming=parent_scoped_naming,
         dataclass_arguments=dataclass_arguments,
         type_mappings=type_mappings,
+        read_only_write_only_model_type=read_only_write_only_model_type,
         **kwargs,
     )
 
@@ -815,5 +828,6 @@ def infer_input_type(text: str) -> InputFileType:
     "InvalidClassNameError",
     "LiteralType",
     "PythonVersion",
+    "ReadOnlyWriteOnlyModelType",
     "generate",
 ]

src/datamodel_code_generator/__main__.py

@@ -30,6 +30,7 @@
     InputFileType,
     InvalidClassNameError,
     OpenAPIScope,
+    ReadOnlyWriteOnlyModelType,
     ReuseScope,
     enable_debug_message,
     generate,
@@ -448,6 +449,7 @@ def validate_all_exports_collision_strategy(cls, values: dict[str, Any]) -> dict
     parent_scoped_naming: bool = False
     disable_future_imports: bool = False
     type_mappings: Optional[list[str]] = None  # noqa: UP045
+    read_only_write_only_model_type: Optional[ReadOnlyWriteOnlyModelType] = None  # noqa: UP045
     all_exports_scope: Optional[AllExportsScope] = None  # noqa: UP045
     all_exports_collision_strategy: Optional[AllExportsCollisionStrategy] = None  # noqa: UP045
 
@@ -851,6 +853,7 @@ def main(args: Sequence[str] | None = None) -> Exit:  # noqa: PLR0911, PLR0912,
             dataclass_arguments=config.dataclass_arguments,
             disable_future_imports=config.disable_future_imports,
             type_mappings=config.type_mappings,
+            read_only_write_only_model_type=config.read_only_write_only_model_type,
             all_exports_scope=config.all_exports_scope,
             all_exports_collision_strategy=config.all_exports_collision_strategy,
         )

src/datamodel_code_generator/arguments.py

@@ -22,6 +22,7 @@
     DataModelType,
     InputFileType,
     OpenAPIScope,
+    ReadOnlyWriteOnlyModelType,
     ReuseScope,
 )
 from datamodel_code_generator.format import DatetimeClassType, Formatter, PythonVersion
@@ -653,6 +654,14 @@ def start_section(self, heading: str | None) -> None:
     action="store_true",
     default=None,
 )
+openapi_options.add_argument(
+    "--read-only-write-only-model-type",
+    help="Model generation for readOnly/writeOnly fields: "
+    "'request-response' = Request/Response models only (no base model), "
+    "'all' = Base + Request + Response models.",
+    choices=[e.value for e in ReadOnlyWriteOnlyModelType],
+    default=None,
+)
 
 # ======================================================================================
 # General options

src/datamodel_code_generator/model/base.py

@@ -17,6 +17,7 @@
 
 from jinja2 import Environment, FileSystemLoader, Template
 from pydantic import Field
+from typing_extensions import Self
 
 from datamodel_code_generator.imports import (
     IMPORT_ANNOTATED,
@@ -47,6 +48,7 @@
 ALL_MODEL: str = "#all#"
 
 ConstraintsBaseT = TypeVar("ConstraintsBaseT", bound="ConstraintsBase")
+DataModelFieldBaseT = TypeVar("DataModelFieldBaseT", bound="DataModelFieldBase")
 
 
 class ConstraintsBase(_BaseModel):
@@ -133,6 +135,8 @@ class Config:
     _pass_fields: ClassVar[set[str]] = {"parent", "data_type"}
     can_have_extra_keys: ClassVar[bool] = True
     type_has_null: Optional[bool] = None  # noqa: UP045
+    read_only: bool = False
+    write_only: bool = False
 
     if not TYPE_CHECKING:
         if not PYDANTIC_V2:
@@ -262,6 +266,15 @@ def fall_back_to_nullable(self) -> bool:
         """Check if optional fields should be nullable by default."""
         return True
 
+    def copy_deep(self) -> Self:
+        """Create a deep copy of this field to avoid mutating the original."""
+        copied = self.copy()
+        copied.parent = None
+        copied.data_type = self.data_type.copy()
+        if self.data_type.data_types:
+            copied.data_type.data_types = [dt.copy() for dt in self.data_type.data_types]
+        return copied
+
 
 @lru_cache
 def get_template(template_file_path: Path) -> Template:
@@ -434,6 +447,18 @@ def _validate_fields(self, fields: list[DataModelFieldBase]) -> list[DataModelFi
             unique_fields.append(field)
         return unique_fields
 
+    def iter_all_fields(self, visited: set[str] | None = None) -> Iterator[DataModelFieldBase]:
+        """Yield all fields including those from base classes (parent fields first)."""
+        if visited is None:
+            visited = set()
+        if self.reference.path in visited:  # pragma: no cover
+            return
+        visited.add(self.reference.path)
+        for base_class in self.base_classes:
+            if base_class.reference and isinstance(base_class.reference.source, DataModel):
+                yield from base_class.reference.source.iter_all_fields(visited)
+        yield from self.fields
+
     def set_base_class(self) -> None:
         """Set up the base class for this model."""
         base_class = self.custom_base_class or self.BASE_CLASS

src/datamodel_code_generator/model/typed_dict.py

@@ -95,17 +95,7 @@ def is_functional_syntax(self) -> bool:
     @property
     def all_fields(self) -> Iterator[DataModelFieldBase]:
         """Iterate over all fields including inherited ones."""
-        for base_class in self.base_classes:
-            if base_class.reference is None:  # pragma: no cover
-                continue
-            data_model = base_class.reference.source
-            if not isinstance(data_model, DataModel):  # pragma: no cover
-                continue
-
-            if isinstance(data_model, TypedDict):  # pragma: no cover
-                yield from data_model.all_fields
-
-        yield from self.fields
+        yield from self.iter_all_fields()
 
     def render(self, *, class_name: str | None = None) -> str:
         """Render TypedDict class with appropriate syntax."""

src/datamodel_code_generator/parser/base.py

@@ -25,6 +25,7 @@
     AllExportsCollisionStrategy,
     AllExportsScope,
     Error,
+    ReadOnlyWriteOnlyModelType,
     ReuseScope,
 )
 from datamodel_code_generator.format import (
@@ -325,28 +326,21 @@ def title_to_class_name(title: str) -> str:
 
 
 def _find_base_classes(model: DataModel) -> list[DataModel]:
+    """Get direct base class DataModels."""
     return [b.reference.source for b in model.base_classes if b.reference and isinstance(b.reference.source, DataModel)]
 
 
 def _find_field(original_name: str, models: list[DataModel]) -> DataModelFieldBase | None:
-    def _find_field_and_base_classes(
-        model_: DataModel,
-    ) -> tuple[DataModelFieldBase | None, list[DataModel]]:
-        for field_ in model_.fields:
-            if field_.original_name == original_name:
-                return field_, []
-        return None, _find_base_classes(model_)  # pragma: no cover
-
+    """Find a field by original_name in the models and their base classes."""
     for model in models:
-        field, base_models = _find_field_and_base_classes(model)
-        if field:
-            return field
-        models.extend(base_models)  # pragma: no cover  # noqa: B909
-
+        for field in model.iter_all_fields():  # pragma: no cover
+            if field.original_name == original_name:
+                return field
     return None  # pragma: no cover
 
 
 def _copy_data_types(data_types: list[DataType]) -> list[DataType]:
+    """Deep copy a list of DataType objects, preserving references."""
     copied_data_types: list[DataType] = []
     for data_type_ in data_types:
         if data_type_.reference:
@@ -477,6 +471,7 @@ def __init__(  # noqa: PLR0913, PLR0915
         parent_scoped_naming: bool = False,
         dataclass_arguments: DataclassArguments | None = None,
         type_mappings: list[str] | None = None,
+        read_only_write_only_model_type: ReadOnlyWriteOnlyModelType | None = None,
     ) -> None:
         """Initialize the Parser with configuration options."""
         self.keyword_only = keyword_only
@@ -605,6 +600,7 @@ def __init__(  # noqa: PLR0913, PLR0915
         self.default_field_extras: dict[str, Any] | None = default_field_extras
         self.formatters: list[Formatter] = formatters
         self.type_mappings: dict[tuple[str, str], str] = Parser._parse_type_mappings(type_mappings)
+        self.read_only_write_only_model_type: ReadOnlyWriteOnlyModelType | None = read_only_write_only_model_type
 
     @staticmethod
     def _parse_type_mappings(type_mappings: list[str] | None) -> dict[tuple[str, str], str]: