Implement flag-based behavior control for schema version

Author: koxudaxi

src/datamodel_code_generator/_types/parser_config_dicts.py

@@ -27,6 +27,7 @@
         ReuseScope,
         StrictTypes,
         TargetPydanticVersion,
+        VersionMode,
     )
     from datamodel_code_generator.format import DateClassType, DatetimeClassType, Formatter, PythonVersion
     from datamodel_code_generator.model.base import DataModel, DataModelFieldBase
@@ -170,6 +171,7 @@ class GraphQLParserConfigDict(ParserConfigDict, closed=True):
 
 class JSONSchemaParserConfigDict(ParserConfigDict):
     jsonschema_version: NotRequired[JsonSchemaVersion | None]
+    schema_version_mode: NotRequired[VersionMode | None]
 
 
 class OpenAPIParserConfigDict(JSONSchemaParserConfigDict, closed=True):

src/datamodel_code_generator/config.py

@@ -356,6 +356,7 @@ class JSONSchemaParserConfig(ParserConfig):
     """Configuration model for JsonSchemaParser.__init__()."""
 
     jsonschema_version: JsonSchemaVersion | None = None
+    schema_version_mode: VersionMode | None = None
 
 
 class OpenAPIParserConfig(JSONSchemaParserConfig):

src/datamodel_code_generator/parser/jsonschema.py

@@ -773,8 +773,34 @@ def _get_type_with_mappings(self, type_: str, format_: str | None = None) -> Typ
 
     @cached_property
     def schema_paths(self) -> list[tuple[str, list[str]]]:
-        """Get schema paths for definitions and defs."""
-        return [(s, s.lstrip("#/").split("/")) for s in self.SCHEMA_PATHS]
+        """Get schema paths for definitions and defs.
+
+        For JsonSchema, uses schema_features.definitions_key to determine
+        the primary path, with fallback to the alternative in Lenient mode.
+        OpenAPI subclass uses its own SCHEMA_PATHS (#/components/schemas).
+        """
+        from datamodel_code_generator.enums import VersionMode  # noqa: PLC0415
+
+        # OpenAPI and other subclasses use their own SCHEMA_PATHS
+        if self.SCHEMA_PATHS != ["#/definitions", "#/$defs"]:
+            return [(s, s.lstrip("#/").split("/")) for s in self.SCHEMA_PATHS]
+
+        # JsonSchema: use definitions_key from schema_features
+        primary_key = self.schema_features.definitions_key
+        primary_path = f"#/{primary_key}"
+        fallback_key = "$defs" if primary_key == "definitions" else "definitions"
+        fallback_path = f"#/{fallback_key}"
+
+        # Strict mode: only use version-specific path
+        version_mode = getattr(self.config, "schema_version_mode", None)
+        if version_mode == VersionMode.Strict:
+            return [(str(primary_path), [str(primary_key)])]
+
+        # Lenient mode (default): check both paths, primary first
+        return [
+            (str(primary_path), [str(primary_key)]),
+            (str(fallback_path), [str(fallback_key)]),
+        ]
 
     @cached_property
     def schema_features(self) -> JsonSchemaFeatures:

src/datamodel_code_generator/parser/openapi.py

@@ -242,14 +242,31 @@ def get_ref_model(self, ref: str) -> dict[str, Any]:
         return get_model_by_path(ref_body, ref_path.split("/")[1:])
 
     def get_data_type(self, obj: JsonSchemaObject) -> DataType:
-        """Get data type from JSON schema object, handling OpenAPI nullable semantics."""
-        # OpenAPI 3.0 uses `nullable: true` flag for null support (nullable_keyword=True)
-        # OpenAPI 3.1 uses `type: ["string", "null"]` instead (nullable_keyword=False)
-        # https://swagger.io/docs/specification/data-models/data-types/#null
-        # When strict_nullable is enabled, convert nullable flag to type array for
-        # consistent handling regardless of OpenAPI version
-        if obj.nullable and self.strict_nullable and isinstance(obj.type, str):
-            obj.type = [obj.type, "null"]
+        """Get data type from JSON schema object, handling OpenAPI nullable semantics.
+
+        Uses schema_features.nullable_keyword to handle version differences:
+        - OpenAPI 3.0: nullable: true is valid, convert to type array when strict_nullable
+        - OpenAPI 3.1: nullable is deprecated, use type: ["string", "null"] instead
+        """
+        from datamodel_code_generator.enums import VersionMode  # noqa: PLC0415
+
+        if obj.nullable:
+            if self.schema_features.nullable_keyword:
+                # OpenAPI 3.0: nullable: true is the standard way
+                if self.strict_nullable and isinstance(obj.type, str):
+                    obj.type = [obj.type, "null"]
+            else:
+                # OpenAPI 3.1+: nullable is deprecated, still process but warn in Strict mode
+                version_mode = getattr(self.config, "schema_version_mode", None)
+                if version_mode == VersionMode.Strict:
+                    warn(
+                        'nullable keyword is deprecated in OpenAPI 3.1, use type: ["string", "null"] instead',
+                        DeprecationWarning,
+                        stacklevel=2,
+                    )
+                # Still convert to type array for compatibility
+                if self.strict_nullable and isinstance(obj.type, str):
+                    obj.type = [obj.type, "null"]
 
         return super().get_data_type(obj)
 

tests/parser/test_schema_version.py

@@ -495,3 +495,133 @@ def test_cli_schema_version_mode() -> None:
         schema_version_mode=VersionMode.Lenient,
     )
     assert result is not None
+
+
+def test_schema_paths_lenient_mode_draft7() -> None:
+    """Test schema_paths returns both paths in Lenient mode for Draft 7."""
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+
+    parser = JsonSchemaParser("", jsonschema_version=JsonSchemaVersion.Draft7)
+    paths = parser.schema_paths
+    assert paths == snapshot([
+        ("#/definitions", ["definitions"]),
+        ("#/$defs", ["$defs"]),
+    ])
+
+
+def test_schema_paths_lenient_mode_2020_12() -> None:
+    """Test schema_paths returns $defs first in Lenient mode for 2020-12."""
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+
+    parser = JsonSchemaParser("", jsonschema_version=JsonSchemaVersion.Draft202012)
+    paths = parser.schema_paths
+    assert paths == snapshot([
+        ("#/$defs", ["$defs"]),
+        ("#/definitions", ["definitions"]),
+    ])
+
+
+def test_schema_paths_strict_mode_draft7() -> None:
+    """Test schema_paths returns only definitions in Strict mode for Draft 7."""
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+
+    parser = JsonSchemaParser(
+        "",
+        jsonschema_version=JsonSchemaVersion.Draft7,
+        schema_version_mode=VersionMode.Strict,
+    )
+    paths = parser.schema_paths
+    assert paths == snapshot([("#/definitions", ["definitions"])])
+
+
+def test_schema_paths_strict_mode_2020_12() -> None:
+    """Test schema_paths returns only $defs in Strict mode for 2020-12."""
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaParser
+
+    parser = JsonSchemaParser(
+        "",
+        jsonschema_version=JsonSchemaVersion.Draft202012,
+        schema_version_mode=VersionMode.Strict,
+    )
+    paths = parser.schema_paths
+    assert paths == snapshot([("#/$defs", ["$defs"])])
+
+
+def test_openapi_schema_paths_unchanged() -> None:
+    """Test that OpenAPI schema_paths uses SCHEMA_PATHS regardless of version mode."""
+    from datamodel_code_generator.parser.openapi import OpenAPIParser
+
+    parser = OpenAPIParser(
+        "",
+        openapi_version=OpenAPIVersion.V31,
+        schema_version_mode=VersionMode.Strict,
+    )
+    paths = parser.schema_paths
+    assert paths == snapshot([("#/components/schemas", ["components", "schemas"])])
+
+
+def test_nullable_keyword_openapi_31_strict_warning() -> None:
+    """Test that nullable keyword emits warning in OpenAPI 3.1 Strict mode."""
+    import warnings
+
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaObject
+    from datamodel_code_generator.parser.openapi import OpenAPIParser
+
+    parser = OpenAPIParser(
+        "",
+        openapi_version=OpenAPIVersion.V31,
+        schema_version_mode=VersionMode.Strict,
+        strict_nullable=True,
+    )
+    obj = JsonSchemaObject(type="string", nullable=True)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        parser.get_data_type(obj)
+        assert len(w) == 1
+        assert issubclass(w[0].category, DeprecationWarning)
+        assert "nullable keyword is deprecated" in str(w[0].message)
+
+
+def test_nullable_keyword_openapi_30_no_warning() -> None:
+    """Test that nullable keyword does NOT emit warning in OpenAPI 3.0."""
+    import warnings
+
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaObject
+    from datamodel_code_generator.parser.openapi import OpenAPIParser
+
+    parser = OpenAPIParser(
+        "",
+        openapi_version=OpenAPIVersion.V30,
+        schema_version_mode=VersionMode.Strict,
+        strict_nullable=True,
+    )
+    obj = JsonSchemaObject(type="string", nullable=True)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        parser.get_data_type(obj)
+        deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+        assert len(deprecation_warnings) == 0
+
+
+def test_nullable_keyword_openapi_31_lenient_no_warning() -> None:
+    """Test that nullable keyword does NOT emit warning in OpenAPI 3.1 Lenient mode."""
+    import warnings
+
+    from datamodel_code_generator.parser.jsonschema import JsonSchemaObject
+    from datamodel_code_generator.parser.openapi import OpenAPIParser
+
+    parser = OpenAPIParser(
+        "",
+        openapi_version=OpenAPIVersion.V31,
+        schema_version_mode=VersionMode.Lenient,
+        strict_nullable=True,
+    )
+    obj = JsonSchemaObject(type="string", nullable=True)
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        parser.get_data_type(obj)
+        deprecation_warnings = [x for x in w if issubclass(x.category, DeprecationWarning)]
+        assert len(deprecation_warnings) == 0