schemathesis 4.2.2__py3-none-any.whl → 4.3.0__py3-none-any.whl

schemathesis/config/__init__.py

@@ -19,7 +19,13 @@ from schemathesis.config._error import ConfigError
 from schemathesis.config._generation import GenerationConfig
 from schemathesis.config._health_check import HealthCheck
 from schemathesis.config._output import OutputConfig, SanitizationConfig, TruncationConfig
-from schemathesis.config._phases import CoveragePhaseConfig, PhaseConfig, PhasesConfig, StatefulPhaseConfig
+from schemathesis.config._phases import (
+    CoveragePhaseConfig,
+    InferenceAlgorithm,
+    PhaseConfig,
+    PhasesConfig,
+    StatefulPhaseConfig,
+)
 from schemathesis.config._projects import ProjectConfig, ProjectsConfig, SchemathesisWarning, get_workers_count
 from schemathesis.config._report import DEFAULT_REPORT_DIRECTORY, ReportConfig, ReportFormat, ReportsConfig
 
@@ -44,6 +50,7 @@ __all__ = [
     "PhasesConfig",
     "CoveragePhaseConfig",
     "StatefulPhaseConfig",
+    "InferenceAlgorithm",
     "ProjectsConfig",
     "ProjectConfig",
     "get_workers_count",

schemathesis/config/_phases.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from enum import Enum
 from typing import Any
 
 from schemathesis.config._checks import ChecksConfig
@@ -125,9 +126,14 @@ class CoveragePhaseConfig(DiffBase):
         )
 
 
+class InferenceAlgorithm(str, Enum):
+    LOCATION_HEADERS = "location-headers"
+    DEPENDENCY_ANALYSIS = "dependency-analysis"
+
+
 @dataclass(repr=False)
 class InferenceConfig(DiffBase):
-    algorithms: list[str]
+    algorithms: list[InferenceAlgorithm]
 
     __slots__ = ("algorithms",)
 
@@ -136,12 +142,14 @@ class InferenceConfig(DiffBase):
         *,
         algorithms: list[str] | None = None,
     ) -> None:
-        self.algorithms = algorithms if algorithms is not None else ["location-headers"]
+        self.algorithms = (
+            [InferenceAlgorithm(a) for a in algorithms] if algorithms is not None else list(InferenceAlgorithm)
+        )
 
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> InferenceConfig:
         return cls(
-            algorithms=data.get("algorithms", ["location-headers"]),
+            algorithms=data.get("algorithms", list(InferenceAlgorithm)),
         )
 
     @property
@@ -149,6 +157,9 @@ class InferenceConfig(DiffBase):
         """Inference is enabled if any algorithms are configured."""
         return bool(self.algorithms)
 
+    def is_algorithm_enabled(self, algorithm: InferenceAlgorithm) -> bool:
+        return algorithm in self.algorithms
+
 
 @dataclass(repr=False)
 class StatefulPhaseConfig(DiffBase):

schemathesis/config/schema.json

@@ -325,7 +325,8 @@
               "items": {
                 "type": "string",
                 "enum": [
-                  "location-headers"
+                  "location-headers",
+                  "dependency-analysis"
                 ]
               },
               "uniqueItems": true

schemathesis/core/jsonschema/bundler.py

@@ -97,8 +97,9 @@ class Bundler:
 
                         result = {key: _bundle_recursive(value) for key, value in current.items() if key != "$ref"}
                         # Recursive references need `$ref` to be in them, which is only possible with `dict`
-                        assert isinstance(cloned, dict)
-                        result.update(cloned)
+                        bundled_clone = _bundle_recursive(cloned)
+                        assert isinstance(bundled_clone, dict)
+                        result.update(bundled_clone)
                         return result
                     elif resolved_uri not in visited:
                         # Bundle only new schemas

schemathesis/core/transforms.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, List, Mapping, TypeVar, Union, overload
+from typing import Any, Callable, Dict, Iterator, List, Mapping, TypeVar, Union, overload
 
 T = TypeVar("T")
 
@@ -106,6 +106,18 @@ class Unresolvable: ...
 UNRESOLVABLE = Unresolvable()
 
 
+def encode_pointer(pointer: str) -> str:
+    return pointer.replace("~", "~0").replace("/", "~1")
+
+
+def decode_pointer(value: str) -> str:
+    return value.replace("~1", "/").replace("~0", "~")
+
+
+def iter_decoded_pointer_segments(pointer: str) -> Iterator[str]:
+    return map(decode_pointer, pointer.split("/")[1:])
+
+
 def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | float | None | Unresolvable:
     """Implementation is adapted from Rust's `serde-json` crate.
 
@@ -116,12 +128,8 @@ def resolve_pointer(document: Any, pointer: str) -> dict | list | str | int | fl
     if not pointer.startswith("/"):
         return UNRESOLVABLE
 
-    def replace(value: str) -> str:
-        return value.replace("~1", "/").replace("~0", "~")
-
-    tokens = map(replace, pointer.split("/")[1:])
     target = document
-    for token in tokens:
+    for token in iter_decoded_pointer_segments(pointer):
         if isinstance(target, dict):
             target = target.get(token, UNRESOLVABLE)
             if target is UNRESOLVABLE:

schemathesis/engine/context.py

@@ -4,12 +4,13 @@ import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any
 
-from schemathesis.config import ProjectConfig
+from schemathesis.config import InferenceAlgorithm, ProjectConfig
 from schemathesis.core import NOT_SET, NotSet
 from schemathesis.engine.control import ExecutionControl
 from schemathesis.engine.observations import Observations
 from schemathesis.generation.case import Case
 from schemathesis.schemas import APIOperation, BaseSchema
+from schemathesis.specs.openapi.stateful import dependencies
 
 if TYPE_CHECKING:
     import threading
@@ -85,9 +86,10 @@ class EngineContext:
 
     def inject_links(self) -> int:
         """Inject inferred OpenAPI links into API operations based on collected observations."""
+        from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
         injected = 0
         if self.observations is not None and self.observations.location_headers:
-            from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
             from schemathesis.specs.openapi.stateful.inference import LinkInferencer
 
             assert isinstance(self.schema, BaseOpenAPISchema)
@@ -96,6 +98,24 @@ class EngineContext:
             inferencer = LinkInferencer.from_schema(self.schema)
             for operation, entries in self.observations.location_headers.items():
                 injected += inferencer.inject_links(operation.responses, entries)
+        if (
+            isinstance(self.schema, BaseOpenAPISchema)
+            and self.schema.config.phases.stateful.enabled
+            and self.schema.config.phases.stateful.inference.is_algorithm_enabled(
+                InferenceAlgorithm.DEPENDENCY_ANALYSIS
+            )
+        ):
+            graph = dependencies.analyze(self.schema)
+            for response_links in graph.iter_links():
+                operation = self.schema.get_operation_by_reference(response_links.producer_operation_ref)
+                response = operation.responses.get(response_links.status_code)
+                links = response.definition.setdefault(self.schema.adapter.links_keyword, {})
+
+                for link_name, definition in response_links.links.items():
+                    # Find unique name if collision exists
+                    final_name = _resolve_link_name_collision(link_name, links)
+                    links[final_name] = definition.to_openapi()
+                    injected += 1
 
         return injected
 
@@ -151,3 +171,16 @@ class EngineContext:
             kwargs["proxies"] = {"all": proxy}
         self._transport_kwargs_cache[key] = kwargs
         return kwargs
+
+
+def _resolve_link_name_collision(proposed_name: str, existing_links: dict[str, Any]) -> str:
+    if proposed_name not in existing_links:
+        return proposed_name
+
+    # Name collision - find next available suffix
+    suffix = 0
+    while True:
+        candidate = f"{proposed_name}_{suffix}"
+        if candidate not in existing_links:
+            return candidate
+        suffix += 1

schemathesis/generation/hypothesis/__init__.py

@@ -90,7 +90,9 @@ def setup() -> None:
             url, resolved = resolver.resolve(ref)
             resolver.push_scope(url)
             try:
-                return merged([s, _resolve_all_refs(deepclone(resolved), resolver=resolver)])  # type: ignore
+                return merged(
+                    [_resolve_all_refs(s, resolver=resolver), _resolve_all_refs(deepclone(resolved), resolver=resolver)]
+                )  # type: ignore
             finally:
                 resolver.pop_scope()
 

schemathesis/specs/openapi/adapter/parameters.py

@@ -324,7 +324,7 @@ def iter_parameters_v2(
                 _, param = maybe_resolve(param, resolver, "")
                 if param.get("in") == ParameterLocation.BODY:
                     if "$ref" in param["schema"]:
-                        resource_name = _get_resource_name(param["schema"]["$ref"])
+                        resource_name = resource_name_from_ref(param["schema"]["$ref"])
             for media_type in body_media_types:
                 yield OpenApiBody.from_definition(
                     definition=parameter,
@@ -375,7 +375,7 @@ def iter_parameters_v3(
             if isinstance(schema, dict):
                 content = dict(content)
                 if "$ref" in schema:
-                    resource_name = _get_resource_name(schema["$ref"])
+                    resource_name = resource_name_from_ref(schema["$ref"])
                 try:
                     to_bundle = cast(dict[str, Any], schema)
                     bundled = bundler.bundle(to_bundle, resolver, inline_recursive=True)
@@ -391,7 +391,7 @@ def iter_parameters_v3(
             )
 
 
-def _get_resource_name(reference: str) -> str:
+def resource_name_from_ref(reference: str) -> str:
     return reference.rsplit("/", maxsplit=1)[1]
 
 

schemathesis/specs/openapi/adapter/protocol.py

@@ -10,6 +10,7 @@ if TYPE_CHECKING:
     from schemathesis.core.jsonschema.types import JsonSchema
 
 IterResponseExamples = Callable[[Mapping[str, Any], str], Iterator[tuple[str, object]]]
+ExtractRawResponseSchema = Callable[[Mapping[str, Any]], Union["JsonSchema", None]]
 ExtractResponseSchema = Callable[[Mapping[str, Any], "RefResolver", str, str], Union["JsonSchema", None]]
 ExtractHeaderSchema = Callable[[Mapping[str, Any], "RefResolver", str, str], "JsonSchema"]
 ExtractParameterSchema = Callable[[Mapping[str, Any]], "JsonSchema"]
@@ -41,6 +42,7 @@ class SpecificationAdapter(Protocol):
     # Function to extract schema from parameter definition
     extract_parameter_schema: ExtractParameterSchema
     # Function to extract response schema from specification
+    extract_raw_response_schema: ExtractRawResponseSchema
     extract_response_schema: ExtractResponseSchema
     # Function to extract header schema from specification
     extract_header_schema: ExtractHeaderSchema

schemathesis/specs/openapi/adapter/responses.py

@@ -48,6 +48,10 @@ class OpenApiResponse:
         assert not isinstance(self._schema, NotSet)
         return self._schema
 
+    def get_raw_schema(self) -> JsonSchema | None:
+        """Raw and unresolved response schema."""
+        return self.adapter.extract_raw_response_schema(self.definition)
+
     @property
     def validator(self) -> Validator | None:
         """JSON Schema validator for this response."""
@@ -118,6 +122,9 @@ class OpenApiResponses:
     def items(self) -> ItemsView[str, OpenApiResponse]:
         return self._inner.items()
 
+    def get(self, key: str) -> OpenApiResponse | None:
+        return self._inner.get(key)
+
     def add(self, status_code: str, definition: dict[str, Any]) -> OpenApiResponse:
         instance = OpenApiResponse(
             status_code=status_code,
@@ -153,12 +160,16 @@ class OpenApiResponses:
         # The default response has the lowest priority
         return responses.get("default")
 
-    def iter_examples(self) -> Iterator[tuple[str, object]]:
-        """Iterate over all examples for all responses."""
+    def iter_successful_responses(self) -> Iterator[OpenApiResponse]:
+        """Iterate over all response definitions for successful responses."""
         for response in self._inner.values():
-            # Check only 2xx responses
             if response.status_code.startswith("2"):
-                yield from response.iter_examples()
+                yield response
+
+    def iter_examples(self) -> Iterator[tuple[str, object]]:
+        """Iterate over all examples for all responses."""
+        for response in self.iter_successful_responses():
+            yield from response.iter_examples()
 
 
 def _iter_resolved_responses(
@@ -178,20 +189,31 @@ def _iter_resolved_responses(
 def extract_response_schema_v2(
     response: Mapping[str, Any], resolver: RefResolver, scope: str, nullable_keyword: str
 ) -> JsonSchema | None:
-    schema = response.get("schema")
+    schema = extract_raw_response_schema_v2(response)
     if schema is not None:
         return _prepare_schema(schema, resolver, scope, nullable_keyword)
     return None
 
 
+def extract_raw_response_schema_v2(response: Mapping[str, Any]) -> JsonSchema | None:
+    return response.get("schema")
+
+
 def extract_response_schema_v3(
     response: Mapping[str, Any], resolver: RefResolver, scope: str, nullable_keyword: str
 ) -> JsonSchema | None:
+    schema = extract_raw_response_schema_v3(response)
+    if schema is not None:
+        return _prepare_schema(schema, resolver, scope, nullable_keyword)
+    return None
+
+
+def extract_raw_response_schema_v3(response: Mapping[str, Any]) -> JsonSchema | None:
     options = iter(response.get("content", {}).values())
     media_type = next(options, None)
     # "schema" is an optional key in the `MediaType` object
-    if media_type and "schema" in media_type:
-        return _prepare_schema(media_type["schema"], resolver, scope, nullable_keyword)
+    if media_type is not None:
+        return media_type.get("schema")
     return None
 
 

schemathesis/specs/openapi/adapter/v2.py

@@ -5,6 +5,7 @@ from schemathesis.specs.openapi.adapter.protocol import (
     BuildPathParameter,
     ExtractHeaderSchema,
     ExtractParameterSchema,
+    ExtractRawResponseSchema,
     ExtractResponseSchema,
     ExtractSecurityParameters,
     IterParameters,
@@ -18,6 +19,7 @@ example_keyword = "x-example"
 examples_container_keyword = "x-examples"
 
 extract_parameter_schema: ExtractParameterSchema = parameters.extract_parameter_schema_v2
+extract_raw_response_schema: ExtractRawResponseSchema = responses.extract_raw_response_schema_v2
 extract_response_schema: ExtractResponseSchema = responses.extract_response_schema_v2
 extract_header_schema: ExtractHeaderSchema = responses.extract_header_schema_v2
 iter_parameters: IterParameters = parameters.iter_parameters_v2

schemathesis/specs/openapi/adapter/v3_0.py

@@ -5,6 +5,7 @@ from schemathesis.specs.openapi.adapter.protocol import (
     BuildPathParameter,
     ExtractHeaderSchema,
     ExtractParameterSchema,
+    ExtractRawResponseSchema,
     ExtractResponseSchema,
     ExtractSecurityParameters,
     IterParameters,
@@ -18,6 +19,7 @@ example_keyword = "example"
 examples_container_keyword = "examples"
 
 extract_parameter_schema: ExtractParameterSchema = parameters.extract_parameter_schema_v3
+extract_raw_response_schema: ExtractRawResponseSchema = responses.extract_raw_response_schema_v3
 extract_response_schema: ExtractResponseSchema = responses.extract_response_schema_v3
 extract_header_schema: ExtractHeaderSchema = responses.extract_header_schema_v3
 iter_parameters: IterParameters = parameters.iter_parameters_v3

schemathesis/specs/openapi/adapter/v3_1.py

@@ -5,6 +5,7 @@ from schemathesis.specs.openapi.adapter.protocol import (
     BuildPathParameter,
     ExtractHeaderSchema,
     ExtractParameterSchema,
+    ExtractRawResponseSchema,
     ExtractResponseSchema,
     ExtractSecurityParameters,
     IterParameters,
@@ -18,6 +19,7 @@ example_keyword = "example"
 examples_container_keyword = "examples"
 
 extract_parameter_schema: ExtractParameterSchema = parameters.extract_parameter_schema_v3
+extract_raw_response_schema: ExtractRawResponseSchema = responses.extract_raw_response_schema_v3
 extract_response_schema: ExtractResponseSchema = responses.extract_response_schema_v3
 extract_header_schema: ExtractHeaderSchema = responses.extract_header_schema_v3
 iter_parameters: IterParameters = parameters.iter_parameters_v3

schemathesis/specs/openapi/stateful/dependencies/__init__.py

@@ -0,0 +1,88 @@
+"""Dependency detection between API operations for stateful testing.
+
+Infers which operations must run before others by tracking resource creation and consumption across API operations.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from schemathesis.core.compat import RefResolutionError
+from schemathesis.core.result import Ok
+from schemathesis.specs.openapi.stateful.dependencies.inputs import extract_inputs, update_input_field_bindings
+from schemathesis.specs.openapi.stateful.dependencies.models import (
+    CanonicalizationCache,
+    Cardinality,
+    DefinitionSource,
+    DependencyGraph,
+    InputSlot,
+    OperationMap,
+    OperationNode,
+    OutputSlot,
+    ResourceDefinition,
+    ResourceMap,
+)
+from schemathesis.specs.openapi.stateful.dependencies.outputs import extract_outputs
+
+if TYPE_CHECKING:
+    from schemathesis.specs.openapi.schemas import BaseOpenAPISchema
+
+__all__ = [
+    "analyze",
+    "DependencyGraph",
+    "InputSlot",
+    "OutputSlot",
+    "Cardinality",
+    "ResourceDefinition",
+    "DefinitionSource",
+]
+
+
+def analyze(schema: BaseOpenAPISchema) -> DependencyGraph:
+    """Build a dependency graph by inferring resource producers and consumers from API operations."""
+    operations: OperationMap = {}
+    resources: ResourceMap = {}
+    # Track resources that got upgraded (e.g., from parameter inference to schema definition)
+    # to propagate better field information to existing input slots
+    updated_resources: set[str] = set()
+    # Cache for expensive canonicalize() calls - same schemas are often processed multiple times
+    canonicalization_cache: CanonicalizationCache = {}
+
+    for result in schema.get_all_operations():
+        if isinstance(result, Ok):
+            operation = result.ok()
+            try:
+                inputs = extract_inputs(
+                    operation=operation,
+                    resources=resources,
+                    updated_resources=updated_resources,
+                    resolver=schema.resolver,
+                    canonicalization_cache=canonicalization_cache,
+                )
+                outputs = extract_outputs(
+                    operation=operation,
+                    resources=resources,
+                    updated_resources=updated_resources,
+                    resolver=schema.resolver,
+                    canonicalization_cache=canonicalization_cache,
+                )
+                operations[operation.label] = OperationNode(
+                    method=operation.method,
+                    path=operation.path,
+                    inputs=list(inputs),
+                    outputs=list(outputs),
+                )
+            except RefResolutionError:
+                # Skip operations with unresolvable $refs (e.g., unavailable external references or references with typos)
+                # These won't participate in dependency detection
+                continue
+
+    # Update input slots with improved resource definitions discovered during extraction
+    #
+    # Example:
+    #   - `DELETE /users/{userId}` initially inferred `User.fields=["userId"]`
+    #   - then `POST /users` response revealed `User.fields=["id", "email"]`
+    for resource in updated_resources:
+        update_input_field_bindings(resource, operations)
+
+    return DependencyGraph(operations=operations, resources=resources)

schemathesis/specs/openapi/stateful/dependencies/inputs.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Iterator
+
+from schemathesis.core.parameters import ParameterLocation
+from schemathesis.specs.openapi.stateful.dependencies import naming
+from schemathesis.specs.openapi.stateful.dependencies.models import (
+    CanonicalizationCache,
+    DefinitionSource,
+    InputSlot,
+    OperationMap,
+    ResourceDefinition,
+    ResourceMap,
+)
+from schemathesis.specs.openapi.stateful.dependencies.resources import extract_resources_from_responses
+
+if TYPE_CHECKING:
+    from schemathesis.core.compat import RefResolver
+    from schemathesis.specs.openapi.schemas import APIOperation
+
+
+def extract_inputs(
+    *,
+    operation: APIOperation,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    canonicalization_cache: CanonicalizationCache,
+) -> Iterator[InputSlot]:
+    """Extract resource dependencies for an API operation from its input parameters.
+
+    Connects each parameter (e.g., `userId`) to its resource definition (`User`),
+    creating placeholder resources if not yet discovered from their schemas.
+    """
+    # Note: Currently limited to path parameters. Query / header / body will be supported in future releases.
+    for param in operation.path_parameters:
+        input_slot = _resolve_parameter_dependency(
+            parameter_name=param.name,
+            parameter_location=param.location,
+            operation=operation,
+            resources=resources,
+            updated_resources=updated_resources,
+            resolver=resolver,
+            canonicalization_cache=canonicalization_cache,
+        )
+        if input_slot is not None:
+            yield input_slot
+
+
+def _resolve_parameter_dependency(
+    *,
+    parameter_name: str,
+    parameter_location: ParameterLocation,
+    operation: APIOperation,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    canonicalization_cache: CanonicalizationCache,
+) -> InputSlot | None:
+    """Connect a parameter to its resource definition, creating placeholder if needed.
+
+    Strategy:
+    1. Infer resource name from parameter (`userId` -> `User`)
+    2. Use existing resource if high-quality definition exists
+    3. Try discovering from operation's response schemas
+    4. Fall back to creating placeholder with a single field
+    """
+    resource_name = naming.from_parameter(parameter=parameter_name, path=operation.path)
+
+    if resource_name is None:
+        return None
+
+    resource = resources.get(resource_name)
+
+    # Upgrade low-quality resource definitions (e.g., from parameter inference)
+    # by searching this operation's responses for actual schema
+    if resource is None or resource.source < DefinitionSource.SCHEMA_WITH_PROPERTIES:
+        resource = _find_resource_in_responses(
+            operation=operation,
+            resource_name=resource_name,
+            resources=resources,
+            updated_resources=updated_resources,
+            resolver=resolver,
+            canonicalization_cache=canonicalization_cache,
+        )
+        if resource is not None:
+            resources[resource_name] = resource
+
+    # Determine resource and its field
+    if resource is None:
+        # No schema found - create placeholder resource with inferred field
+        #
+        # Example: `DELETE /users/{userId}` with no response body -> `User` resource with "userId" field
+        #
+        # Later operations with schemas will upgrade this placeholder
+        if resource_name in resources:
+            # Resource exists but was empty - update with parameter field
+            resources[resource_name].fields = [parameter_name]
+            resources[resource_name].source = DefinitionSource.PARAMETER_INFERENCE
+            updated_resources.add(resource_name)
+            resource = resources[resource_name]
+        else:
+            resource = ResourceDefinition.inferred_from_parameter(
+                name=resource_name,
+                parameter_name=parameter_name,
+            )
+            resources[resource_name] = resource
+        field = parameter_name
+    else:
+        # Match parameter to resource field (`userId` → `id`, `Id` → `ChannelId`, etc.)
+        field = (
+            naming.find_matching_field(
+                parameter=parameter_name,
+                resource=resource_name,
+                fields=resource.fields,
+            )
+            or "id"
+        )
+
+    return InputSlot(
+        resource=resource,
+        resource_field=field,
+        parameter_name=parameter_name,
+        parameter_location=parameter_location,
+    )
+
+
+def _find_resource_in_responses(
+    *,
+    operation: APIOperation,
+    resource_name: str,
+    resources: ResourceMap,
+    updated_resources: set[str],
+    resolver: RefResolver,
+    canonicalization_cache: CanonicalizationCache,
+) -> ResourceDefinition | None:
+    """Search operation's successful responses for a specific resource definition.
+
+    Used when a parameter references a resource not yet discovered. Scans this
+    operation's response schemas hoping to find the resource definition.
+    """
+    for _, extracted in extract_resources_from_responses(
+        operation=operation,
+        resources=resources,
+        updated_resources=updated_resources,
+        resolver=resolver,
+        canonicalization_cache=canonicalization_cache,
+    ):
+        if extracted.resource.name == resource_name:
+            return extracted.resource
+
+    return None
+
+
+def update_input_field_bindings(resource_name: str, operations: OperationMap) -> None:
+    """Update input slots field bindings after resource definition was upgraded.
+
+    When a resource's fields change (e.g., `User` upgraded from `["userId"]` to `["id", "email"]`),
+    existing input slots may reference stale field names. This re-evaluates field matching
+    for all operations using this resource.
+
+    Example:
+        `DELETE /users/{userId}` created `InputSlot(resource_field="userId")`
+        `POST /users` revealed actual fields `["id", "email"]`
+        This updates DELETE's `InputSlot` to use `resource_field="id"`
+
+    """
+    # Re-evaluate field matching for all operations referencing this resource
+    for operation in operations.values():
+        for input_slot in operation.inputs:
+            # Skip inputs not using this resource
+            if input_slot.resource.name != resource_name:
+                continue
+
+            # Re-match parameter to upgraded resource fields
+            new_field = naming.find_matching_field(
+                parameter=input_slot.parameter_name,
+                resource=resource_name,
+                fields=input_slot.resource.fields,
+            )
+            if new_field is not None:
+                input_slot.resource_field = new_field