Add comprehensive version-specific feature checks with exclusive_as_number flag

Author: koxudaxi

src/datamodel_code_generator/parser/jsonschema.py

@@ -31,6 +31,7 @@
     JsonSchemaVersion,
     ReadOnlyWriteOnlyModelType,
     SchemaParseError,
+    VersionMode,
     YamlValue,
     load_data,
     load_data_from_path,
@@ -779,8 +780,6 @@ def schema_paths(self) -> list[tuple[str, list[str]]]:
         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]
@@ -2935,6 +2934,9 @@ def parse_array_fields(  # noqa: PLR0912
         singular_name: bool = True,  # noqa: FBT001, FBT002
     ) -> DataModelFieldBase:
         """Parse array schema into a data model field with list type."""
+        # Strict mode: check for version-specific array features
+        self._check_array_version_features(obj, path)
+
         if self.force_optional_for_required_fields:
             required: bool = False
             nullable: Optional[bool] = None  # noqa: UP045
@@ -3645,9 +3647,111 @@ def parse_raw_obj(
         if isinstance(raw, dict) and "x-python-import" in raw:
             self._handle_python_import(name, path)
             return
+
+        # Strict mode: check for version-specific features before validation
+        self._check_version_specific_features(raw, path)
+
         obj = self._validate_schema_object(raw, path)
         self.parse_obj(name, obj, path)
 
+    def _check_version_specific_features(
+        self,
+        raw: dict[str, YamlValue] | YamlValue,
+        path: list[str],
+    ) -> None:
+        """Check for version-specific features and warn in Strict mode.
+
+        This method checks the raw schema data before Pydantic validation
+        to detect features that may not be valid for the declared version.
+        """
+        version_mode = getattr(self.config, "schema_version_mode", None)
+        if version_mode != VersionMode.Strict:
+            return
+
+        # Check boolean schemas (Draft 6+)
+        if isinstance(raw, bool):
+            if not self.schema_features.boolean_schemas:
+                version_name = "Draft 4" if self.schema_features.id_field == "id" else "this version"
+                warn(
+                    f"Boolean schemas are not supported in {version_name}. Schema path: {'/'.join(path)}",
+                    stacklevel=3,
+                )
+            return
+
+        if not isinstance(raw, dict):
+            return
+
+        # Check null in type array (Draft 2020-12 / OpenAPI 3.1+)
+        type_value = raw.get("type")
+        if isinstance(type_value, list) and "null" in type_value and not self.schema_features.null_in_type_array:
+            warn(
+                'null in type array (e.g., type: ["string", "null"]) is not supported '
+                f"in this schema version. Use nullable: true instead. Schema path: {'/'.join(path)}",
+                stacklevel=3,
+            )
+
+        # Check exclusive min/max format (Draft 4 uses boolean, Draft 6+ uses number)
+        exclusive_min = raw.get("exclusiveMinimum")
+        exclusive_max = raw.get("exclusiveMaximum")
+        if self.schema_features.exclusive_as_number:
+            # Draft 6+: should be numeric, not boolean
+            if isinstance(exclusive_min, bool):
+                warn(
+                    f"exclusiveMinimum as boolean is Draft 4 style, but schema version uses numeric style. "
+                    f"Schema path: {'/'.join(path)}",
+                    stacklevel=3,
+                )
+            if isinstance(exclusive_max, bool):
+                warn(
+                    f"exclusiveMaximum as boolean is Draft 4 style, but schema version uses numeric style. "
+                    f"Schema path: {'/'.join(path)}",
+                    stacklevel=3,
+                )
+        else:
+            # Draft 4: should be boolean, not numeric
+            if exclusive_min is not None and not isinstance(exclusive_min, bool):
+                warn(
+                    f"exclusiveMinimum as number is Draft 6+ style, but schema version is Draft 4. "
+                    f"Schema path: {'/'.join(path)}",
+                    stacklevel=3,
+                )
+            if exclusive_max is not None and not isinstance(exclusive_max, bool):
+                warn(
+                    f"exclusiveMaximum as number is Draft 6+ style, but schema version is Draft 4. "
+                    f"Schema path: {'/'.join(path)}",
+                    stacklevel=3,
+                )
+
+    def _check_array_version_features(
+        self,
+        obj: JsonSchemaObject,
+        path: list[str],
+    ) -> None:
+        """Check for version-specific array features and warn in Strict mode.
+
+        Warns when prefixItems is used in versions that don't support it,
+        or when items as array (tuple style) is used in Draft 2020-12+.
+        """
+        version_mode = getattr(self.config, "schema_version_mode", None)
+        if version_mode != VersionMode.Strict:
+            return
+
+        # Check prefixItems usage (Draft 2020-12+ only)
+        if obj.prefixItems is not None and not self.schema_features.prefix_items:
+            warn(
+                f"prefixItems is not supported in this schema version. "
+                f"Use items as array for tuple validation. Schema path: {'/'.join(path)}",
+                stacklevel=4,
+            )
+
+        # Check items as array usage (deprecated in Draft 2020-12)
+        if isinstance(obj.items, list) and self.schema_features.prefix_items:
+            warn(
+                f"items as array (tuple validation) is deprecated in Draft 2020-12. "
+                f"Use prefixItems instead. Schema path: {'/'.join(path)}",
+                stacklevel=4,
+            )
+
     def _handle_python_import(
         self,
         name: str,

src/datamodel_code_generator/parser/openapi.py

@@ -27,7 +27,7 @@
     load_data,
     snooper_to_methods,
 )
-from datamodel_code_generator.enums import OpenAPIVersion
+from datamodel_code_generator.enums import OpenAPIVersion, VersionMode
 from datamodel_code_generator.parser.base import get_special_path
 from datamodel_code_generator.parser.jsonschema import (
     JsonSchemaObject,
@@ -248,8 +248,6 @@ def get_data_type(self, obj: JsonSchemaObject) -> DataType:
         - 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

src/datamodel_code_generator/parser/schema_version.py

@@ -30,6 +30,7 @@ class JsonSchemaFeatures:
         boolean_schemas: Draft 6+ allows boolean values as schemas.
         id_field: The field name for schema ID ("id" for Draft 4, "$id" for Draft 6+).
         definitions_key: The key for definitions ("definitions" or "$defs").
+        exclusive_as_number: Draft 6+ uses numeric exclusiveMin/Max (Draft 4 uses boolean).
     """
 
     null_in_type_array: bool
@@ -38,6 +39,7 @@ class JsonSchemaFeatures:
     boolean_schemas: bool
     id_field: str
     definitions_key: str
+    exclusive_as_number: bool
 
     @classmethod
     def from_version(cls, version: JsonSchemaVersion) -> JsonSchemaFeatures:
@@ -51,6 +53,7 @@ def from_version(cls, version: JsonSchemaVersion) -> JsonSchemaFeatures:
                     boolean_schemas=False,
                     id_field="id",
                     definitions_key="definitions",
+                    exclusive_as_number=False,
                 )
             case JsonSchemaVersion.Draft6 | JsonSchemaVersion.Draft7:
                 return cls(
@@ -60,6 +63,7 @@ def from_version(cls, version: JsonSchemaVersion) -> JsonSchemaFeatures:
                     boolean_schemas=True,
                     id_field="$id",
                     definitions_key="definitions",
+                    exclusive_as_number=True,
                 )
             case JsonSchemaVersion.Draft201909:
                 return cls(
@@ -69,6 +73,7 @@ def from_version(cls, version: JsonSchemaVersion) -> JsonSchemaFeatures:
                     boolean_schemas=True,
                     id_field="$id",
                     definitions_key="$defs",
+                    exclusive_as_number=True,
                 )
             case _:
                 return cls(
@@ -78,6 +83,7 @@ def from_version(cls, version: JsonSchemaVersion) -> JsonSchemaFeatures:
                     boolean_schemas=True,
                     id_field="$id",
                     definitions_key="$defs",
+                    exclusive_as_number=True,
                 )
 
 
@@ -100,13 +106,16 @@ def from_openapi_version(cls, version: OpenAPIVersion) -> OpenAPISchemaFeatures:
         """Create OpenAPISchemaFeatures from an OpenAPI version."""
         match version:
             case OpenAPIVersion.V30:
+                # OpenAPI 3.0 schema dialect inherits JSON Schema Draft 4 semantics
+                # where exclusiveMinimum/Maximum are boolean values
                 return cls(
                     null_in_type_array=False,
                     defs_not_definitions=False,
                     prefix_items=False,
                     boolean_schemas=False,
                     id_field="$id",
                     definitions_key="definitions",
+                    exclusive_as_number=False,
                     nullable_keyword=True,
                     discriminator_support=True,
                 )
@@ -118,6 +127,7 @@ def from_openapi_version(cls, version: OpenAPIVersion) -> OpenAPISchemaFeatures:
                     boolean_schemas=True,
                     id_field="$id",
                     definitions_key="$defs",
+                    exclusive_as_number=True,
                     nullable_keyword=False,
                     discriminator_support=True,
                 )
@@ -158,6 +168,10 @@ def detect_jsonschema_version(data: dict[str, Any]) -> JsonSchemaVersion:
             if pattern in schema_url:
                 return version
 
+    # Heuristic detection based on keywords
+    # $defs was introduced in Draft 2019-09, but Draft 2020-12 also uses it.
+    # Since 2020-12 is a superset of 2019-09, default to 2020-12 when $defs is present
+    # to avoid false warnings in Strict mode for features valid in both versions.
     if "$defs" in data:
         return JsonSchemaVersion.Draft202012
     if "definitions" in data: