mirumee__ariadne-24

The user wants to add support for `parse_value` and `parse_literal` to `add_resolve_functions_to_schema` (which likely calls `add_resolve_functions_to_scalar` or similar) in Ariadne.
Currently, only `serialize` is supported for Scalars.

Let's start by exploring the codebase to find `add_resolve_functions_to_schema` and how Scalars are handled.

{
  "command": "grep -rn --include=\"*.py\" -e \"add_resolve_functions_to_schema\" -e \"Scalar\" | head -n 20"
}

{
  "status": "ok",
  "stdout": "ariadne/executable_schema.py:6:from .resolvers import add_resolve_functions_to_schema\nariadne/executable_schema.py:13:    add_resolve_functions_to_schema(schema, resolvers)\nariadne/__init__.py:3:from .resolvers import add_resolve_functions_to_schema, default_resolver, resolve_to\nariadne/__init__.py:6:    \"add_resolve_functions_to_schema\",\nariadne/resolvers.py:1:from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema\nariadne/resolvers.py:22:def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\nariadne/resolvers.py:26:        if isinstance(type_object, GraphQLScalarType):\n",
  "stderr": "",
  "exit_code": 0
}

Okay, the relevant function `add_resolve_functions_to_schema` is in `ariadne/resolvers.py`.
Let's read `ariadne/resolvers.py` to see how it handles `GraphQLScalarType`.

{
  "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, look at `add_resolve_function_to_scalar` 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
```
First, the type hint says `obj: GraphQLObjectType` but it is called when `isinstance(type_object, GraphQLScalarType)`. That's a type hint bug.
Second, it only handles `serialize`.

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

Wait, in `add_resolve_functions_to_schema`, the `resolvers` dict is passed.
In `add_resolve_function_to_scalar`, it does:
`serializer = resolvers.get(name, obj.serialize)`

If `resolvers` is `{'Scalar': {'serialize': callable}}`, then `resolvers.get('Scalar', obj.serialize)` will return the dict `{'serialize': callable}`.
Then `obj.serialize` is set to that dict! That's definitely wrong. `obj.serialize` should be a callable.

Wait, let's re-read `add_resolve_function_to_scalar` more carefully.
```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 `{'Scalar': some_callable}`, then it works. But the problem statement suggests a dictionary for the scalar: `{'Scalar': {'serialize': callable}}`.

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, {})` is called, and then it looks up `field_name` in that result.

So for `add_resolve_function_to_scalar`, it should probably be doing something similar if it wants to support a dict of functions (`serialize`, `parse_value`, `parse_literal`).

Let's double check how `GraphQLScalarType` is defined in `graphql-core` (which Ariadne uses).
Usually, `GraphQLScalarType` has `serialize`, `parse_value`, and `parse_literal`.

Wait, if `resolvers` is `{'Scalar': some_callable}`, then `serializer` becomes `some_callable`. This is currently how it works.
But if the user provides `{'Scalar': {'serialize': callable}}`, the current code sets `obj.serialize` to `{'serialize': callable}`, which is wrong.

Let's see how others use Ariadne's scalar resolvers.
The problem description says:
`type_defs = {'Scalar': {'serialize': callable}}`
Actually, they called the argument `type_defs`, but in `add_resolve_functions_to_schema(schema, resolvers)`, it's the `resolvers` argument.

Let's try to reproduce this. I'll create a small script that uses `add_resolve_functions_to_schema` with a scalar.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField, GraphQLString\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\n# Define a simple schema\nscalar_type = GraphQLScalarType(\"MyScalar\")\nobject_type = GraphQLObjectType(\"Query\", fields={\"test\": GraphQLField(scalar_type)})\nschema = GraphQLSchema(query=object_type)\n\n# Define resolvers\nresolvers = {\n    \"MyScalar\": {\n        \"serialize\": lambda value: f\"serialized({value})\",\n        \"parse_value\": lambda value: f\"parsed_value({value})\",\n        \"parse_literal\": lambda value: f\"parsed_literal({value})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Scalar serialize: {scalar_type.serialize}\")\nprint(f\"Scalar parse_value: {scalar_type.parse_value}\")\nprint(f\"Scalar parse_literal: {scalar_type.parse_literal}\")\n\n# Check if they are as expected\nexpected_serialize = resolvers[\"MyScalar\"][\"serialize\"]\nassert scalar_type.serialize == expected_serialize, f\"Expected {expected_serialize}, got {scalar_type.serialize}\"\n\nprint(\"Success!\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 5, in <module>\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 125, in __init__\n    ).format(self)\nAssertionError: MyScalar must provide \"serialize\" function. If this custom Scalar is also used as an input type, ensure \"parse_value\" and \"parse_literal\" functions are also provided.\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 5, in <module>\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 125, in __init__\n    ).format(self)\nAssertionError: MyScalar must provide \"serialize\" function. If this custom Scalar is also used as an input type, ensure \"parse_value\" and \"parse_literal\" functions are also provided.\n",
    "exit_code": 1
  }
}

Ah, `GraphQLScalarType` requires `serialize` at initialization if it's a custom scalar.
Wait, maybe it depends on the version of `graphql-core`.
In Ariadne, `make_executable_schema` usually handles the creation of the schema.

Wait, if I use `GraphQLScalarType("MyScalar")` without providing `serialize`, it fails.
I should probably provide a default `serialize` when creating the `GraphQLScalarType`.

Actually, in Ariadne's `resolvers.py`, `add_resolve_function_to_scalar` takes an existing `obj` (which is a `GraphQLScalarType`) and modifies its attributes.

Let's try to fix the reproduction script by providing a dummy serialize:

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField, GraphQLString\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef dummy_serialize(value):\n    return value\n\n# Define a simple schema\nscalar_type = GraphQLScalarType(\"MyScalar\", serialize=dummy_serialize)\nobject_type = GraphQLObjectType(\"Query\", fields={\"test\": GraphQLField(scalar_type)})\nschema = GraphQLSchema(query=object_type)\n\n# Define resolvers\nresolvers = {\n    \"MyScalar\": {\n        \"serialize\": lambda value: f\"serialized({value})\",\n        \"parse_value\": lambda value: f\"parsed_value({value})\",\n        \"parse_literal\": lambda value: f\"parsed_literal({value})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nprint(f\"Scalar serialize: {scalar_type.serialize}\")\nprint(f\"Scalar parse_value: {scalar_type.parse_value}\")\nprint(f\"Scalar parse_literal: {scalar_type.parse_literal}\")\n\n# Check if they are as expected\nexpected_serialize = resolvers[\"MyScalar\"][\"serialize\"]\nassert scalar_type.serialize == expected_serialize, f\"Expected {expected_serialize}, got {scalar_type.serialize}\"\n\nprint(\"Success!\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 29, in <module>\nAssertionError: Expected <function <lambda> at 0x7a91f029e440>, got {'serialize': <function <lambda> at 0x7a91f029e440>, 'parse_value': <function <lambda> at 0x7a91ef1c63b0>, 'parse_literal': <function <lambda> at 0x7a91ef1c6440>}\n",
  "details": {
    "stdout": "Scalar serialize: {'serialize': <function <lambda> at 0x7a91f029e440>, 'parse_value': <function <lambda> at 0x7a91ef1c63b0>, 'parse_literal': <function <lambda> at 0x7a91ef1c6440>}\nScalar parse_value: <function none_func at 0x7a91ef4e84d0>\nScalar parse_literal: <function none_func at 0x7a91ef4e84d0>\n",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 29, in <module>\nAssertionError: Expected <function <lambda> at 0x7a91f029e440>, got {'serialize': <function <lambda> at 0x7a91f029e440>, 'parse_value': <function <lambda> at 0x7a91ef1c63b0>, 'parse_literal': <function <lambda> at 0x7a91ef1c6440>}\n",
    "exit_code": 1
  }
}

Exactly. `scalar_type.serialize` was set to the whole `resolvers["MyScalar"]` dictionary.
And `parse_value` and `parse_literal` remained as they were (probably default `none_func`).

Now I need to fix `add_resolve_function_to_scalar` in `ariadne/resolvers.py`.

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

It should be:
1. Check if `resolvers.get(name)` is a dictionary.
2. If it is, it should extract `serialize`, `parse_value`, and `parse_literal` and set them on `obj`.
3. If it's not a dictionary (e.g. it's a callable), it should probably be treated as the `serialize` function (to maintain backward compatibility if that was intended, though the problem says we want to support the dict syntax).

Wait, if `resolvers.get(name)` is a callable, it's probably the serializer.
If it's a dict, we want to support `serialize`, `parse_value`, and `parse_literal`.

Let's look at `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
```
This always expects `resolvers.get(name, {})` to be a dictionary of field resolvers.

For scalars, it seems `add_resolve_function_to_scalar` is simpler.
If the user provides `resolvers = {"MyScalar": some_callable}`, then `some_callable` is the serializer.
If the user provides `resolvers = {"MyScalar": {"serialize": s, "parse_value": v, "parse_literal": l}}`, then we should set all three.

Let's see if `GraphQLScalarType` allows setting these attributes after initialization.
In the reproduction script, `scalar_type.serialize` was updated. Let's check if `parse_value` and `parse_literal` can also be updated.

Yes, in `graphql-core`, they are just attributes on the `GraphQLScalarType` instance.

Wait, I should also fix the type hint `obj: GraphQLObjectType` to `obj: GraphQLScalarType`.

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)
    elif scalar_resolvers is not None:
        obj.serialize = scalar_resolvers
```

Wait, if `scalar_resolvers` is not a dict and not None, it should be the serializer. This maintains backward compatibility if someone was passing `{"MyScalar": some_callable}`.

Let's verify this logic.

If `resolvers = {"MyScalar": some_callable}`:
`scalar_resolvers = some_callable`
`isinstance(scalar_resolvers, dict)` is False.
`scalar_resolvers is not None` is True.
`obj.serialize = some_callable`.
Correct.

If `resolvers = {"MyScalar": {"serialize": s}}`:
`scalar_resolvers = {"serialize": s}`
`isinstance(scalar_resolvers, dict)` is True.
`obj.serialize = scalar_resolvers.get("serialize", obj.serialize)` which is `s`.
`obj.parse_value = scalar_resolvers.get("parse_value", obj.parse_value)` which is `obj.parse_value`.
`obj.parse_literal = scalar_resolvers.get("parse_literal", obj.parse_literal)` which is `obj.parse_literal`.
Correct.

If `resolvers = {"MyScalar": {"serialize": s, "parse_value": v, "parse_literal": l}}`:
All three are updated.
Correct.

If `resolvers = {}`:
`scalar_resolvers = None`.
Nothing happens.
Correct.

Let's double check if `GraphQLScalarType` really has `serialize`, `parse_value`, and `parse_literal` as attributes that can be set.
The reproduction script showed `scalar_type.serialize` can be set.

One detail: The problem statement says:
- `type_defs = {'Scalar': {'serialize': callable}}`
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

These aren't `type_defs` but the `resolvers` argument.

Let's check if there are any other places where scalars are handled.
`ariadne/resolvers.py` is the main place for `add_resolve_functions_to_schema`.

Wait, let's look at `ariadne/executable_schema.py` to see how `add_resolve_functions_to_schema` is used.

{
  "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, it's just a wrapper.

Wait, what if the user uses `make_executable_schema(type_defs, resolvers)`?
Then `resolvers` is passed to `add_resolve_functions_to_schema`.

One more thing: I should check if I need to import `GraphQLScalarType` in `ariadne/resolvers.py`.
It is already imported: `from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema`.

Let's refine the implementation of `add_resolve_function_to_scalar` and also fix the type hint.

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

Modified:
```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 is not None:
        obj.serialize = scalar_resolvers
```

Wait, let's check if `GraphQLScalarType` attributes are actually named `serialize`, `parse_value`, and `parse_literal`.
Looking at `graphql-core` (the library Ariadne uses), `GraphQLScalarType` does have these.

Let's test this with a full reproduction script. I'll create a script that tests all cases:
1. Scalar resolver is a callable (backward compatibility).
2. Scalar resolver is a dict with only `serialize`.
3. Scalar resolver is a dict with all three.
4. Scalar resolver is a dict with only `parse_value` and `parse_literal`.
5. Scalar resolver is not provided.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField, GraphQLString\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef dummy_serialize(value): return \"dummy_ser\"\ndef dummy_parse_value(value): return \"dummy_pv\"\ndef dummy_parse_literal(value): return \"dummy_pl\"\n\ndef test_scalar_resolvers(resolvers_config, scenario_name):\n    print(f\"Testing {scenario_name}...\", end=\" \")\n    \n    scalar_type = GraphQLScalarType(\"MyScalar\", serialize=dummy_serialize, parse_value=dummy_parse_value, parse_literal=dummy_parse_literal)\n    object_type = GraphQLObjectType(\"Query\", fields={\"test\": GraphQLField(scalar_type)})\n    schema = GraphQLSchema(query=object_type)\n\n    add_resolve_functions_to_schema(schema, resolvers_config)\n\n    # This is a bit tricky because we are comparing functions.\n    # For simplicity, we'll just check if they are not the dummy ones if they were provided in resolvers_config.\n    \n    # Let's use a more robust way to check.\n    # Create specific functions for each test.\n    pass\n\n# Better test script\ndef run_test(scenario_name, resolvers_config, expected_changes):\n    print(f\"Testing {scenario_name}...\", end=\" \")\n    \n    # Use fresh dummies for each run\n    def d_ser(v): return \"ser\"\n    def d_pv(v): return \"pv\"\n    def d_pl(v): return \"pl\"\n    \n    scalar_type = GraphQLScalarType(\"MyScalar\", serialize=d_ser, parse_value=d_pv, parse_literal=d_pl)\n    object_type = GraphQLObjectType(\"Query\", fields={\"test\": GraphQLField(scalar_type)})\n    schema = GraphQLSchema(query=object_type)\n    \n    add_resolve_functions_to_schema(schema, resolvers_config)\n    \n    for attr, expected in expected_changes.items():\n        actual = getattr(scalar_type, attr)\n        if expected is None:\n            # should remain dummy\n            assert actual == d_ser if attr == \"serialize\" else (d_pv if attr == \"parse_value\" else d_pl)\n        else:\n            # should be the one from resolvers_config\n            # Need to handle the case where resolvers_config['MyScalar'] is a callable (serialize)\n            if isinstance(resolvers_config.get(\"MyScalar\"), dict):\n                assert actual == resolvers_config[\"MyScalar\"][attr]\n            else:\n                # If a callable was provided, only serialize should change\n                if attr == \"serialize\":\n                    assert actual == resolvers_config[\"MyScalar\"]\n                else:\n                    # Others should remain dummy\n                    assert actual == (d_pv if attr == \"parse_value\" else d_pl)\n    print(\"PASSED\")\n\n# 1. Scalar resolver is a callable (backward compatibility)\ndef ser1(v): return \"ser1\"\nrun_test(\"callable_resolver\", {\"MyScalar\": ser1}, {\"serialize\": ser1, \"parse_value\": None, \"parse_literal\": None})\n\n# 2. Scalar resolver is a dict with only serialize\ndef ser2(v): return \"ser2\"\nrun_test(\"dict_serialize_only\", {\"MyScalar\": {\"serialize\": ser2}}, {\"serialize\": ser2, \"parse_value\": None, \"parse_literal\": None})\n\n# 3. Scalar resolver is a dict with all three\ndef ser3(v): return \"ser3\"\ndef pv3(v): return \"pv3\"\ndef pl3(v): return \"pl3\"\nrun_test(\"dict_all_three\", {\"MyScalar\": {\"serialize\": ser3, \"parse_value\": pv3, \"parse_literal\": pl3}}, {\"serialize\": ser3, \"parse_value\": pv3, \"parse_literal\": pl3})\n\n# 4. Scalar resolver is a dict with only parse_value and parse_literal\ndef pv4(v): return \"pv4\"\ndef pl4(v): return \"pl4\"\nrun_test(\"dict_parse_only\", {\"MyScalar\": {\"parse_value\": pv4, \"parse_literal\": pl4}}, {\"serialize\": None, \"parse_value\": pv4, \"parse_literal\": pl4})\n\n# 5. Scalar resolver is not provided\nrun_test(\"no_resolver\", {}, {\"serialize\": None, \"parse_value\": None, \"parse_literal\": None})\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 64, in <module>\n  File \"<stdin>\", line 48, in run_test\nAssertionError\n",
  "details": {
    "stdout": "Testing callable_resolver... PASSED\nTesting dict_serialize_only... ",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 64, in <module>\n  File \"<stdin>\", line 48, in run_test\nAssertionError\n",
    "exit_code": 1
  }
}

Failed at `dict_serialize_only`. This is expected because the current code in `ariadne/resolvers.py` is still the old version.

Now let's apply the fix.

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

Wait, I noticed a bug in the current `add_resolve_function_to_scalar` signature: `obj: GraphQLObjectType`. It should be `GraphQLScalarType`.

Let's apply the fix.

{
  "filepath": "ariadne/resolvers.py",
  "new_string": "def add_resolve_function_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 is not None:\n        obj.serialize = scalar_resolvers\n",
  "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\n"
}

{
  "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_function_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 is not None:\n+        obj.serialize = scalar_resolvers\n",
  "is_truncated": false
}

Now let's run the reproduction script again.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLField, GraphQLString\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef dummy_serialize(value): return \"dummy_ser\"\ndef dummy_parse_value(value): return \"dummy_pv\"\ndef dummy_parse_literal(value): return \"dummy_pl\"\n\ndef run_test(scenario_name, resolvers_config, expected_changes):\n    print(f\"Testing {scenario_name}...\", end=\" \")\n    \n    # Use fresh dummies for each run\n    def d_ser(v): return \"ser\"\n    def d_pv(v): return \"pv\"\n    def d_pl(v): return \"pl\"\n    \n    scalar_type = GraphQLScalarType(\"MyScalar\", serialize=d_ser, parse_value=d_pv, parse_literal=d_pl)\n    object_type = GraphQLObjectType(\"Query\", fields={\"test\": GraphQLField(scalar_type)})\n    schema = GraphQLSchema(query=object_type)\n    \n    add_resolve_functions_to_schema(schema, resolvers_config)\n    \n    for attr, expected in expected_changes.items():\n        actual = getattr(scalar_type, attr)\n        if expected is None:\n            # should remain dummy\n            assert actual == d_ser if attr == \"serialize\" else (d_pv if attr == \"parse_value\" else d_pl)\n        else:\n            # should be the one from resolvers_config\n            if isinstance(resolvers_config.get(\"MyScalar\"), dict):\n                assert actual == resolvers_config[\"MyScalar\"][attr]\n            else:\n                # If a callable was provided, only serialize should change\n                if attr == \"serialize\":\n                    assert actual == resolvers_config[\"MyScalar\"]\n                else:\n                    # Others should remain dummy\n                    assert actual == (d_pv if attr == \"parse_value\" else d_pl)\n    print(\"PASSED\")\n\n# 1. Scalar resolver is a callable (backward compatibility)\ndef ser1(v): return \"ser1\"\nrun_test(\"callable_resolver\", {\"MyScalar\": ser1}, {\"serialize\": ser1, \"parse_value\": None, \"parse_literal\": None})\n\n# 2. Scalar resolver is a dict with only serialize\ndef ser2(v): return \"ser2\"\nrun_test(\"dict_serialize_only\", {\"MyScalar\": {\"serialize\": ser2}}, {\"serialize\": ser2, \"parse_value\": None, \"parse_literal\": None})\n\n# 3. Scalar resolver is a dict with all three\ndef ser3(v): return \"ser3\"\ndef pv3(v): return \"pv3\"\ndef pl3(v): return \"pl3\"\nrun_test(\"dict_all_three\", {\"MyScalar\": {\"serialize\": ser3, \"parse_value\": pv3, \"parse_literal\": pl3}}, {\"serialize\": ser3, \"parse_value\": pv3, \"parse_literal\": pl3})\n\n# 4. Scalar resolver is a dict with only parse_value and parse_literal\ndef pv4(v): return \"pv4\"\ndef pl4(v): return \"pl4\"\nrun_test(\"dict_parse_only\", {\"MyScalar\": {\"parse_value\": pv4, \"parse_literal\": pl4}}, {\"serialize\": None, \"parse_value\": pv4, \"parse_literal\": pl4})\n\n# 5. Scalar resolver is not provided\nrun_test(\"no_resolver\", {}, {\"serialize\": None, \"parse_value\": None, \"parse_literal\": None})\nPY\n"
}

{
  "status": "ok",
  "stdout": "Testing callable_resolver... PASSED\nTesting dict_serialize_only... PASSED\nTesting dict_all_three... PASSED\nTesting dict_parse_only... PASSED\nTesting no_resolver... PASSED\n",
  "stderr": "",
  "exit_code": 0
}

Great! The fix works and it covers all the scenarios including backward compatibility.

Now let's check if there are any other existing tests for scalars that I should run to ensure no regressions.
I'll search for tests that use `GraphQLScalarType` or `add_resolve_functions_to_schema`.

{
  "command": "grep -rn --include=\"*_test.py\" \"Scalar\" tests/ | head -n 20"
}

{
  "status": "ok",
  "stdout": "",
  "stderr": "",
  "exit_code": 0
}

Wait, `tests/` is the directory. Let's search again, maybe in `tests/` subdirectories.
Actually, I can just run all tests.

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

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

All tests passed.
Let me double check if there are any other files I should have modified.
The problem statement mentioned:
"Our `add_resolve_functions_to_scalar` utility could support following use-cases"
But `add_resolve_functions_to_scalar` (singular) is what I modified.
The public API is `add_resolve_functions_to_schema` (plural), which calls `add_resolve_function_to_scalar` (singular).

The current structure of `ariadne/resolvers.py` is:
- `add_resolve_functions_to_schema` calls `add_resolve_functions_to_object` and `add_resolve_function_to_scalar`.

Wait, `add_resolve_function_to_scalar` is not exported in `__init__.py`. Only `add_resolve_functions_to_schema` is.
Let's check `ariadne/__init__.py`.

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

{
  "status": "ok",
  "filepath": "ariadne/__init__.py",
  "content": "from .build_schema import build_schema_from_type_definitions\nfrom .executable_schema import make_executable_schema\nfrom .resolvers import add_resolve_functions_to_schema, default_resolver, resolve_to\n\n__all__ = [\n    \"add_resolve_functions_to_schema\",\n    \"build_schema_from_type_definitions\",\n    \"default_resolver\",\n    \"make_executable_schema\",\n    \"resolve_to\",\n]",
  "start_line": 1,
  "end_line": 11,
  "total_lines": 11,
  "is_truncated": false
}

Yes, only `add_resolve_functions_to_schema` is exported.

I'm confident with the fix.
One last check: `git status --short && git diff`.

{
  "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..4fe192a 100644\n--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\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_function_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 is not None:\n+        obj.serialize = scalar_resolvers\n",
  "stderr": "",
  "exit_code": 0
}

Everything looks correct.
I'll submit the patch.

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

I have implemented the support for `parse_value` and `parse_literal` in `add_resolve_function_to_scalar` within `ariadne/resolvers.py`, and fixed a type hint bug. Verified with a comprehensive reproduction script and all existing tests.

I updated `add_resolve_function_to_scalar` in `ariadne/resolvers.py` to support a dictionary of resolver functions for `GraphQLScalarType`, allowing for the configuration of `serialize`, `parse_value`, and `parse_literal` while maintaining backward compatibility for callable serializers. I also corrected the type hint for the `obj` parameter from `GraphQLObjectType` to `GraphQLScalarType`.