mirumee__ariadne-24

The user wants to extend `add_resolve_functions_to_schema` (or possibly `add_resolve_functions_to_scalar` as mentioned in the problem statement, but the prompt says `add_resolve_functions_to_schema` in the first sentence) to support `parse_value` and `parse_literal` for Scalars.
Currently, it only supports `serialize`.

Let's look for `add_resolve_functions_to_schema` and `add_resolve_functions_to_scalar` in the codebase.

{
  "command": "grep -rn --include=\"*.py\" \"add_resolve_functions_to_schema\" . && grep -rn --include=\"*.py\" \"add_resolve_functions_to_scalar\" ."
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "./ariadne/executable_schema.py:6:from .resolvers import add_resolve_functions_to_schema\n./ariadne/executable_schema.py:13:    add_resolve_functions_to_schema(schema, resolvers)\n./ariadne/__init__.py:3:from .resolvers import add_resolve_functions_to_schema, default_resolver, resolve_to\n./ariadne/__init__.py:6:    \"add_resolve_functions_to_schema\",\n./ariadne/resolvers.py:22:def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n",
  "details": {
    "stdout": "./ariadne/executable_schema.py:6:from .resolvers import add_resolve_functions_to_schema\n./ariadne/executable_schema.py:13:    add_resolve_functions_to_schema(schema, resolvers)\n./ariadne/__init__.py:3:from .resolvers import add_resolve_functions_to_schema, default_resolver, resolve_to\n./ariadne/__init__.py:6:    \"add_resolve_functions_to_schema\",\n./ariadne/resolvers.py:22:def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n",
    "stderr": "",
    "exit_code": 1
  }
}

The search for `add_resolve_functions_to_scalar` didn't return anything. The problem description says: "Our `add_resolve_functions_to_scalar` utility could support following use-cases", but maybe they meant `add_resolve_functions_to_schema` or maybe it's a internal function call.

Let's examine `ariadne/resolvers.py` to see how `add_resolve_functions_to_schema` is implemented.

{
  "filepath": "ariadne/resolvers.py"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "content": "from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema\nfrom graphql.execution.base import ResolveInfo\n\n\ndef resolve_parent_field(parent, name: str):\n    if isinstance(parent, dict):\n        return parent.get(name)\n    return getattr(parent, name, None)\n\n\ndef default_resolver(parent, info: ResolveInfo):\n    return resolve_parent_field(parent, info.field_name)\n\n\ndef resolve_to(name: str):\n    def resolver(parent, *_):\n        return resolve_parent_field(parent, name)\n\n    return resolver\n\n\ndef add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n    for type_name, type_object in schema.get_type_map().items():\n        if isinstance(type_object, GraphQLObjectType):\n            add_resolve_functions_to_object(type_name, type_object, resolvers)\n        if isinstance(type_object, GraphQLScalarType):\n            add_resolve_function_to_scalar(type_name, type_object, resolvers)\n\n\ndef add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):\n    type_resolver = resolvers.get(name, {})\n    for field_name, field_object in obj.fields.items():\n        field_resolver = type_resolver.get(field_name, default_resolver)\n        field_object.resolver = field_resolver\n\n\ndef add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n    serializer = resolvers.get(name, obj.serialize)\n    obj.serialize = serializer",
  "start_line": 1,
  "end_line": 39,
  "total_lines": 39,
  "is_truncated": false
}

Wait, I see `add_resolve_function_to_scalar` (singular `function`) in `ariadne/resolvers.py`.

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

Wait, the type hint says `obj: GraphQLObjectType`, but it's only called when `isinstance(type_object, GraphQLScalarType)`. That's a type hint bug.

Also, the implementation currently only handles `serialize`. It should also handle `parse_value` and `parse_literal`.

Let's verify the `graphql-core` (which `ariadne` uses) `GraphQLScalarType` properties. Typically they have `serialize`, `parse_value`, and `parse_literal`.

The loop in `add_resolve_functions_to_schema` is:
```python
    for type_name, type_object in schema.get_type_map().items():
        if isinstance(type_object, GraphQLObjectType):
            add_resolve_functions_to_object(type_name, type_object, resolvers)
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_function_to_scalar(type_name, type_object, resolvers)
```

And `add_resolve_function_to_scalar`:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

Wait, `resolvers.get(name, obj.serialize)` will return the value associated with `name` in the `resolvers` dict, OR `obj.serialize` if `name` is not found.
But the problem statement says:
- `type_defs = {'Scalar': {'serialize': callable}}`
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

This means `resolvers.get(name)` should return a DICT of functions, not a single function.

Let's look at `add_resolve_functions_to_object`:
```python
def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):
    type_resolver = resolvers.get(name, {})
    for field_name, field_object in obj.fields.items():
        field_resolver = type_resolver.get(field_name, default_resolver)
        field_object.resolver = field_resolver
```
Here `resolvers.get(name, {})` returns a dict (or an empty dict).

Now look at `add_resolve_function_to_scalar` again:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
If `resolvers` is `{'MyScalar': {'serialize': my_ser}}`, then `resolvers.get('MyScalar', obj.serialize)` returns `{'serialize': my_ser}`.
Then `obj.serialize = {'serialize': my_ser}`, which is definitely WRONG. `obj.serialize` should be a callable.

So the current implementation of `add_resolve_function_to_scalar` is likely broken for the case where `resolvers[name]` is a dict, AND it doesn't support `parse_value` and `parse_literal`.

Actually, if the user provided `resolvers = {'MyScalar': my_ser}`, then `resolvers.get('MyScalar', obj.serialize)` would return `my_ser`, and `obj.serialize = my_ser` would work. But the problem statement says they want to support:
`type_defs = {'Scalar': {'serialize': callable}}`

Wait, the problem statement says `type_defs`, but I think it means the `resolvers` dictionary passed to `add_resolve_functions_to_schema`.

Let's try to reproduce the bug.
I'll create a reproduction script. I need to know how to create a `GraphQLSchema` and a `GraphQLScalarType` using `graphql-core`.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, build_schema\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\n# Create a simple schema with a custom scalar\nschema_str = \"type Query { test: String } scalar MyScalar\"\nschema = build_schema(schema_str)\n\n# Define scalars\nmy_scalar_type = schema.get_type(\"MyScalar\")\nprint(f\"Type: {my_scalar_type}\")\n\n# These are the resolvers we want to add\nresolvers = {\n    'MyScalar': {\n        'serialize': lambda val: f\"serialized {val}\",\n        'parse_value': lambda val: f\"parsed_value {val}\",\n        'parse_literal': lambda val: f\"parsed_literal {val}\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Serialize: {my_scalar_type.serialize}\")\nprint(f\"Parse Value: {my_scalar_type.parse_value}\")\nprint(f\"Parse Literal: {my_scalar_type.parse_literal}\")\n\n# Check if they are the ones we provided\ndef test_serialize(val):\n    return f\"serialized {val}\"\n\n# The current implementation probably set my_scalar_type.serialize to the dict {'serialize': ...}\n# or didn't change it if the dict was not what it expected.\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nImportError: cannot import name 'build_schema' from 'graphql' (/opt/py37/lib/python3.7/site-packages/graphql/__init__.py)\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 1, in <module>\nImportError: cannot import name 'build_schema' from 'graphql' (/opt/py37/lib/python3.7/site-packages/graphql/__init__.py)\n",
    "exit_code": 1
  }
}

Ah, `build_schema` is in `graphql` but maybe not in the version installed? Or maybe I should use `ariadne.build_schema` if it exists.
Wait, `ariadne/build_schema.py` exists.

Let's see how `ariadne` builds schemas.

{
  "filepath": "ariadne/build_schema.py"
}

{
  "status": "ok",
  "filepath": "ariadne/build_schema.py",
  "content": "from typing import List, Union\n\nfrom graphql import GraphQLSchema, parse\nfrom graphql.language.ast import (\n    Document,\n    ObjectTypeDefinition,\n    OperationTypeDefinition,\n    Name,\n    NamedType,\n    SchemaDefinition,\n)\nfrom graphql.utils.build_ast_schema import build_ast_schema\n\n\ndef build_schema_from_type_definitions(\n    type_defs: Union[str, List[str]]\n) -> GraphQLSchema:\n    if isinstance(type_defs, list):\n        type_defs = concatenate_type_defs(type_defs)\n\n    document = parse(type_defs)\n\n    if not document_has_schema(document):\n        schema_definition = build_default_schema(document)\n        document.definitions.append(schema_definition)\n\n    return build_ast_schema(document)\n\n\ndef concatenate_type_defs(type_defs: List[str]) -> str:\n    resolved_type_defs = []\n    for type_def in type_defs:\n        resolved_type_defs.append(type_def.strip())\n    return \"\\n\\n\".join(resolved_type_defs)\n\n\ndef build_default_schema(document: Document) -> SchemaDefinition:\n    defined_types = [\n        td.name.value\n        for td in document.definitions\n        if isinstance(td, ObjectTypeDefinition)\n    ]\n    operations = []\n    if \"Query\" in defined_types:\n        operations.append(\n            OperationTypeDefinition(\"query\", type=NamedType(name=Name(\"Query\")))\n        )\n    if \"Mutation\" in defined_types:\n        operations.append(\n            OperationTypeDefinition(\"mutation\", type=NamedType(name=Name(\"Mutation\")))\n        )\n    if \"Subscription\" in defined_types:\n        operations.append(\n            OperationTypeDefinition(\n                \"subscription\", type=NamedType(name=Name(\"Subscription\"))\n            )\n        )\n    return SchemaDefinition(operation_types=operations, directives=[])\n\n\ndef document_has_schema(document: Document) -> bool:\n    return any(isinstance(td, SchemaDefinition) for td in document.definitions)",
  "start_line": 1,
  "end_line": 62,
  "total_lines": 62,
  "is_truncated": false
}

Okay, `build_schema_from_type_definitions` seems to be the way to go.

Let's try the reproduction script again.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType\nfrom ariadne.build_schema import build_schema_from_type_definitions\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\n# Create a simple schema with a custom scalar\ntype_defs = \"type Query { test: MyScalar } scalar MyScalar\"\nschema = build_schema_from_type_definitions(type_defs)\n\n# Define scalars\nmy_scalar_type = schema.get_type(\"MyScalar\")\nprint(f\"Type: {my_scalar_type}\")\n\n# These are the resolvers we want to add\nresolvers = {\n    'MyScalar': {\n        'serialize': lambda val: f\"serialized {val}\",\n        'parse_value': lambda val: f\"parsed_value {val}\",\n        'parse_literal': lambda val: f\"parsed_literal {val}\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Serialize: {my_scalar_type.serialize}\")\nprint(f\"Parse Value: {my_scalar_type.parse_value}\")\nprint(f\"Parse Literal: {my_scalar_type.parse_literal}\")\n\n# Test the serialize function\ntry:\n    res = my_scalar_type.serialize(\"test\")\n    print(f\"Serialized result: {res}\")\nexcept Exception as e:\n    print(f\"Serialize failed: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Type: MyScalar\nSerialize: {'serialize': <function <lambda> at 0x7647e97d8560>, 'parse_value': <function <lambda> at 0x7647e97d83b0>, 'parse_literal': <function <lambda> at 0x7647e869c170>}\nParse Value: <function _false at 0x7647e86e90e0>\nParse Literal: <function _false at 0x7647e86e90e0>\nSerialize failed: 'dict' object is not callable\n",
  "stderr": "",
  "exit_code": 0
}

Okay, the reproduction script confirms the issue.
1. `my_scalar_type.serialize` became the dictionary `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`.
2. `parse_value` and `parse_literal` remain unchanged (they are `<function _false ...>` likely the default for `GraphQLScalarType`).

So `add_resolve_function_to_scalar` is indeed incorrectly implemented:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
It should check if `resolvers.get(name)` is a dict, and if so, set `serialize`, `parse_value`, and `parse_literal` from that dict.

Wait, let's look at `add_resolve_functions_to_object` for inspiration:
```python
def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):
    type_resolver = resolvers.get(name, {})
    for field_name, field_object in obj.fields.items():
        field_resolver = type_resolver.get(field_name, default_resolver)
        field_object.resolver = field_resolver
```
It gets a dict for the type, then for each field in the object, it looks for a resolver in that dict.

For scalars, it's simpler. The ariadne utility `add_resolve_functions_to_schema` iterates over all types. If it's a scalar, it calls `add_resolve_function_to_scalar`.

If we want to support:
- `resolvers = {'MyScalar': my_serialize_fn}` (backward compatibility? The problem statement didn't explicitly mention this, but it's good to keep if it worked)
- `resolvers = {'MyScalar': {'serialize': ser, 'parse_value': pv, 'parse_literal': pl}}`

The problem statement says:
- `type_defs = {'Scalar': {'serialize': callable}}` (one-way)
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}` (two-way)

So it seems the intention is that `resolvers['Scalar']` should be a dictionary of scalar methods.

Let's modify `add_resolve_function_to_scalar` in `ariadne/resolvers.py`.

I should also fix the type hint from `GraphQLObjectType` to `GraphQLScalarType`.

Current implementation:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```

Proposed implementation:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name, {})
    if not isinstance(scalar_resolvers, dict):
        # Fallback for when a single callable is provided instead of a dict
        # though the problem statement implies a dict.
        # Let's check if we should support this. 
        # If we want to support the old behavior, we could do:
        # obj.serialize = scalar_resolvers if callable(scalar_resolvers) else obj.serialize
        # But the problem statement says Scalar: {'serialize': callable}.
        # So it's more likely that scalars are always handled as dicts in the resolvers map.
        pass

    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
```

Wait, if `resolvers.get(name)` returns something that is NOT a dict, should we still try to use it as `serialize`?
The original code did: `serializer = resolvers.get(name, obj.serialize)`. This worked if `resolvers[name]` was a callable.

If we want to maintain that, we can do:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    elif scalar_resolvers:
        obj.serialize = scalar_resolvers
```

However, looking at `add_resolve_functions_to_object`, it does `type_resolver = resolvers.get(name, {})` and expects a dict.

If I look at the problem statement again:
- `type_defs = {'Scalar': {'serialize': callable}}`
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

It explicitly suggests using a dictionary.

Let's refine the proposed change for `add_resolve_function_to_scalar`:

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name, {})
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    else:
        # For backward compatibility, if it's not a dict, maybe it's the serialize function
        obj.serialize = scalar_resolvers if scalar_resolvers else obj.serialize
```

Actually, the original code was:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
Wait, if `resolvers.get(name)` is NOT in `resolvers`, it returns `obj.serialize`. Then `obj.serialize = obj.serialize`. No effect.
If `resolvers.get(name)` is present, it's assigned to `obj.serialize`.

If we want to support `resolvers[name]` being a dict OR a callable:

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    elif scalar_resolvers:
        obj.serialize = scalar_resolvers
```

But maybe I should stick to the most minimal change and strictly follow the problem statement.
The problem statement explicitly shows `type_defs = {'Scalar': {'serialize': callable}}`.

Let's see if there are any other places `add_resolve_function_to_scalar` is called. Only in `add_resolve_functions_to_schema`.

I'll also check if `GraphQLScalarType` really has `serialize`, `parse_value` and `parse_literal`.
Yes, that's a standard for `graphql-js` and `graphql-core`.

Let's check the imports in `ariadne/resolvers.py`.
It has `from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema`.

The current `add_resolve_function_to_scalar` has `obj: GraphQLObjectType`. This is definitely a bug.

Let's check the `add_resolve_functions_to_object` again.
```python
def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):
    type_resolver = resolvers.get(name, {})
    for field_name, field_object in obj.fields.items():
        field_resolver = type_resolver.get(field_name, default_resolver)
        field_object.resolver = field_resolver
```
It uses `resolvers.get(name, {})` so it always has a dict.

Let's do the same for scalar.

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name, {})
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    elif scalar_resolvers:
        obj.serialize = scalar_resolvers
```

Wait, if `resolvers.get(name, {})` is called, and the user provided `resolvers = {'MyScalar': my_ser}`, then `scalar_resolvers` will be `my_ser`.
Then `isinstance(my_ser, dict)` will be False.
Then `elif scalar_resolvers:` will be True.
Then `obj.serialize = my_ser`.
This preserves the behavior of the original code (mostly).

Actually, if `resolvers = {}`, `scalars_resolvers` is `{}`. `isinstance({}, dict)` is True.
`obj.serialize = {}.get("serialize", obj.serialize)` -> `obj.serialize`.
`obj.parse_value = {}.get("parse_value", obj.parse_value)` -> `obj.parse_value`.
`obj.parse_literal = {}.get("parse_literal", obj.parse_literal)` -> `obj.parse_literal`.
Everything stays as it was.

One thing: `obj.serialize = scalar_resolvers.get("serialize", obj.serialize)` will set `obj.serialize` to `None` if the user provides `{'serialize': None}`. Is that desired? Probably yes.

Let's refine the implementation one more time.

```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    elif scalar_resolvers:
        obj.serialize = scalar_resolvers
```

Wait, if the user didn't provide anything for `name`, `scalar_resolvers` is `None`.
Then nothing changes. Correct.

If the user provided `resolvers = {'MyScalar': my_ser}`, `scalar_resolvers` is `my_ser`.
`isinstance(my_ser, dict)` is False.
`elif my_ser:` is True.
`obj.serialize = my_ser`. Correct.

If the user provided `resolvers = {'MyScalar': {'serialize': ser}}`, `scalar_resolvers` is `{'serialize': ser}`.
`isinstance(..., dict)` is True.
`obj.serialize` becomes `ser`.
`obj.parse_value` remains `obj.parse_value`.
`obj.parse_literal` remains `obj.parse_literal`. Correct.

If the user provided `resolvers = {'MyScalar': {'serialize': ser, 'parse_value': pv, 'parse_literal': pl}}`.
All three get updated. Correct.

Let's check if I should change `add_resolve_function_to_scalar` to `add_resolve_functions_to_scalar` (plural) for consistency with `add_resolve_functions_to_object`.
The problem statement says "Our `add_resolve_functions_to_scalar` utility could support...".
But currently it's `add_resolve_function_to_scalar` (singular).

Wait, the `add_resolve_functions_to_schema` call is:
```python
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_function_to_scalar(type_name, type_object, resolvers)
```
If I rename it, I must rename it in both places.

Let's see what's best. The user said `add_resolve_functions_to_scalar` (plural) in the problem description.

Let's check if there are any unit tests for this in the repo.

{
  "command": "grep -rn \"add_resolve_function_to_scalar\" tests/"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

No tests for this function in `tests/`. Let's check for `add_resolve_functions_to_schema`.

{
  "command": "grep -rn \"add_resolve_functions_to_schema\" tests/"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "",
  "details": {
    "stdout": "",
    "stderr": "",
    "exit_code": 1
  }
}

That's surprising. Let's search for any tests that use `resolvers`.

{
  "command": "grep -rn \"resolvers\" tests/ | head -n 20"
}

{
  "status": "ok",
  "stdout": "tests/test_modularization.py:23:resolvers = {\"Query\": {\"user\": lambda *_: {\"username\": \"Bob\"}}}\ntests/test_modularization.py:25:overriding_resolvers = {\"Query\": {\"user\": lambda *_: {\"firstName\": \"Bob\"}}}\ntests/test_modularization.py:30:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_modularization.py:39:    schema = make_executable_schema(type_defs, overriding_resolvers)\ntests/test_modularization.py:48:    schema = make_executable_schema(type_defs, overriding_resolvers)\ntests/test_queries.py:16:    resolvers = {\"Query\": {\"test\": lambda *_: \"success\"}}\ntests/test_queries.py:18:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:34:    resolvers = {\ntests/test_queries.py:39:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:57:    resolvers = {\"Query\": {\"test\": lambda *_: {\"node\": \"custom\"}}}\ntests/test_queries.py:59:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:77:    resolvers = {\"Query\": {\"test\": lambda *_: Mock(node=\"custom\")}}\ntests/test_queries.py:79:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:97:    resolvers = {\ntests/test_queries.py:102:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:109:def test_query_custom_type_merged_custom_default_resolvers():\ntests/test_queries.py:121:    resolvers = {\ntests/test_queries.py:126:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:144:    resolvers = {\"Query\": {\"test\": resolve_test}}\ntests/test_queries.py:146:    schema = make_executable_schema(type_defs, resolvers)\n",
  "stderr": "",
  "exit_code": 0
}

They use `make_executable_schema`. Let's see where that is. It's probably in `ariadne/executable_schema.py`.

{
  "filepath": "ariadne/executable_schema.py"
}

{
  "status": "ok",
  "filepath": "ariadne/executable_schema.py",
  "content": "from typing import List, Union\n\nfrom graphql import GraphQLSchema\n\nfrom .build_schema import build_schema_from_type_definitions\nfrom .resolvers import add_resolve_functions_to_schema\n\n\ndef make_executable_schema(\n    type_defs: Union[str, List[str]], resolvers: dict\n) -> GraphQLSchema:\n    schema = build_schema_from_type_definitions(type_defs)\n    add_resolve_functions_to_schema(schema, resolvers)\n    return schema",
  "start_line": 1,
  "end_line": 14,
  "total_lines": 14,
  "is_truncated": false
}

Yes, `make_executable_schema` calls `add_resolve_functions_to_schema`.

Now I will apply the fix. I'll also rename `add_resolve_function_to_scalar` to `add_resolve_functions_to_scalar` for consistency and to match the problem description.

In `ariadne/resolvers.py`:

```python
<<<<
def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):
    for type_name, type_object in schema.get_type_map().items():
        if isinstance(type_object, GraphQLObjectType):
            add_resolve_functions_to_object(type_name, type_object, resolvers)
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_function_to_scalar(type_name, type_object, resolvers)
====
def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):
    for type_name, type_object in schema.get_type_map().items():
        if isinstance(type_object, GraphQLObjectType):
            add_resolve_functions_to_object(type_name, type_object, resolvers)
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_functions_to_scalar(type_name, type_object, resolvers)
>>>>
```

And:

```python
<<<<
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
====
def add_resolve_functions_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get("serialize", obj.serialize)
        obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)
        obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)
    elif scalar_resolvers:
        obj.serialize = scalar_resolvers
>>>>
```

Let's check for any other occurrences of `add_resolve_function_to_scalar`.

{
  "command": "grep -rn \"add_resolve_function_to_scalar\" ariadne/"
}

{
  "status": "ok",
  "stdout": "ariadne/resolvers.py:27:            add_resolve_function_to_scalar(type_name, type_object, resolvers)\nariadne/resolvers.py:37:def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n",
  "stderr": "grep: ariadne/__pycache__/resolvers.cpython-37.pyc: binary file matches\n",
  "exit_code": 0
}

Okay, just those two locations in `ariadne/resolvers.py`.

Let's perform the edits. I'll do them in two `edit_file` calls to be safe.
First, rename the function call in `add_resolve_functions_to_schema`.

{
  "filepath": "ariadne/resolvers.py",
  "new_string": "        if isinstance(type_object, GraphQLScalarType):\n            add_resolve_functions_to_scalar(type_name, type_object, resolvers)",
  "old_string": "        if isinstance(type_object, GraphQLScalarType):\n            add_resolve_function_to_scalar(type_name, type_object, resolvers)"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -24,7 +24,7 @@\n         if isinstance(type_object, GraphQLObjectType):\n             add_resolve_functions_to_object(type_name, type_object, resolvers)\n         if isinstance(type_object, GraphQLScalarType):\n-            add_resolve_function_to_scalar(type_name, type_object, resolvers)\n+            add_resolve_functions_to_scalar(type_name, type_object, resolvers)\n \n \n def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):\n",
  "is_truncated": false
}

Now, modify the implementation of `add_resolve_functions_to_scalar`.

{
  "filepath": "ariadne/resolvers.py",
  "new_string": "def add_resolve_functions_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n    scalar_resolvers = resolvers.get(name)\n    if isinstance(scalar_resolvers, dict):\n        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n    elif scalar_resolvers:\n        obj.serialize = scalar_resolvers",
  "old_string": "def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n    serializer = resolvers.get(name, obj.serialize)\n    obj.serialize = serializer"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -34,6 +34,11 @@\n         field_object.resolver = field_resolver\n \n \n-def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n-    serializer = resolvers.get(name, obj.serialize)\n-    obj.serialize = serializer\n+def add_resolve_functions_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n+    scalar_resolvers = resolvers.get(name)\n+    if isinstance(scalar_resolvers, dict):\n+        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n+        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n+        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n+    elif scalar_resolvers:\n+        obj.serialize = scalar_resolvers\n",
  "is_truncated": false
}

Now let's verify the fix with the reproduction script. I'll expand it to test all cases: one-way, two-way, no-way, and backward compatibility.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType\nfrom ariadne.build_schema import build_schema_from_type_definitions\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef test_scalar_resolvers(test_name, resolvers_map, expected_serialize, expected_pv, expected_pl):\n    print(f\"Running test: {test_name}\")\n    type_defs = \"type Query { test: MyScalar } scalar MyScalar\"\n    schema = build_schema_from_type_definitions(type_defs)\n    my_scalar_type = schema.get_type(\"MyScalar\")\n    \n    initial_serialize = my_scalar_type.serialize\n    initial_pv = my_scalar_type.parse_value\n    initial_pl = my_scalar_type.parse_literal\n\n    add_resolve_functions_to_schema(schema, resolvers_map)\n\n    assert my_scalar_type.serialize == expected_serialize\n    assert my_scalar_type.parse_value == expected_pv\n    assert my_scalar_type.parse_literal == expected_pl\n    print(f\"PASSED: {test_name}\")\n\n# 1. Two-way scalar\nser = lambda v: f\"ser {v}\"\npv = lambda v: f\"pv {v}\"\npl = lambda v: f\"pl {v}\"\nresolvers_2way = {'MyScalar': {'serialize': ser, 'parse_value': pv, 'parse_literal': pl}}\n\n# To get the initial values for comparison\ntype_defs = \"type Query { test: MyScalar } scalar MyScalar\"\nschema = build_schema_from_type_definitions(type_defs)\nmy_scalar_type = schema.get_type(\"MyScalar\")\ninitial_ser = my_scalar_type.serialize\ninitial_pv = my_scalar_type.parse_value\ninitial_pl = my_scalar_type.parse_literal\n\ntest_scalar_resolvers(\"Two-way\", resolvers_2way, ser, pv, pl)\n\n# 2. One-way scalar (only serialize)\nresolvers_1way = {'MyScalar': {'serialize': ser}}\ntest_scalar_resolvers(\"One-way\", resolvers_1way, ser, initial_pv, initial_pl)\n\n# 3. No resolvers\nresolvers_none = {}\ntest_scalar_resolvers(\"None\", resolvers_none, initial_ser, initial_pv, initial_pl)\n\n# 4. Backward compatibility: single callable (should be serialize)\nresolvers_compat = {'MyScalar': ser}\ntest_scalar_resolvers(\"Compat\", resolvers_compat, ser, initial_pv, initial_pl)\n\n# 5. Only parse_value\nresolvers_pv = {'MyScalar': {'parse_value': pv}}\ntest_scalar_resolvers(\"Only PV\", resolvers_pv, initial_ser, pv, initial_pl)\n\n# 6. Only parse_literal\nresolvers_pl = {'MyScalar': {'parse_literal': pl}}\ntest_scalar_resolvers(\"Only PL\", resolvers_pl, initial_ser, initial_pv, pl)\n\nprint(\"All custom tests passed!\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Running test: Two-way\nPASSED: Two-way\nRunning test: One-way\nPASSED: One-way\nRunning test: None\nPASSED: None\nRunning test: Compat\nPASSED: Compat\nRunning test: Only PV\nPASSED: Only PV\nRunning test: Only PL\nPASSED: Only PL\nAll custom tests passed!\n",
  "stderr": "",
  "exit_code": 0
}

Perfect. Now I should make sure I didn't break any existing tests. Since I didn't find any tests specifically for `add_resolve_functions_to_schema`, I'll run all tests in `tests/`.

{
  "command": "pytest tests/ -q --tb=short --no-header"
}

{
  "status": "ok",
  "stdout": "................                                                         [100%]\n16 passed in 0.07s\n",
  "stderr": "",
  "exit_code": 0
}

Everything looks good. I'll double check my diff and ensure no untracked files were left.

{
  "command": "git status --short && git diff"
}

{
  "status": "ok",
  "stdout": " M ariadne/resolvers.py\ndiff --git a/ariadne/resolvers.py b/ariadne/resolvers.py\nindex 388e3ad..93803e3 100644\n--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -24,7 +24,7 @@ def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n         if isinstance(type_object, GraphQLObjectType):\n             add_resolve_functions_to_object(type_name, type_object, resolvers)\n         if isinstance(type_object, GraphQLScalarType):\n-            add_resolve_function_to_scalar(type_name, type_object, resolvers)\n+            add_resolve_functions_to_scalar(type_name, type_object, resolvers)\n \n \n def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):\n@@ -34,6 +34,11 @@ def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers\n         field_object.resolver = field_resolver\n \n \n-def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n-    serializer = resolvers.get(name, obj.serialize)\n-    obj.serialize = serializer\n+def add_resolve_functions_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n+    scalar_resolvers = resolvers.get(name)\n+    if isinstance(scalar_resolvers, dict):\n+        obj.serialize = scalar_resolvers.get(\"serialize\", obj.serialize)\n+        obj.parse_value = scalar_resolvers.get(\"parse_value\", obj.parse_value)\n+        obj.parse_literal = scalar_resolvers.get(\"parse_literal\", obj.parse_literal)\n+    elif scalar_resolvers:\n+        obj.serialize = scalar_resolvers\n",
  "stderr": "",
  "exit_code": 0
}

The diff looks clean. No untracked files.

{
  "status": "ok",
  "patch_size": 1495,
  "files_changed": 1
}

I have successfully expanded `add_resolve_functions_to_schema` to support `parse_value` and `parse_literal` for scalars by updating the `add_resolve_functions_to_scalar` helper in `ariadne/resolvers.py`. I also corrected a type hint and renamed the helper function for consistency.

The `add_resolve_functions_to_schema` utility was updated to support custom `parse_value` and `parse_literal` functions for scalars, in addition to the existing `serialize` support. The implementation now correctly handles both a dictionary of scalar resolver functions and a single callable for backward compatibility.