mirumee__ariadne-24

The user wants to add support for `parse_value` and `parse_literal` to `add_resolve_functions_to_schema` (likely `add_resolve_functions_to_scalar` based on the problem description) in Ariadne.
Currently, only `serialize` is supported.

I need to find where `add_resolve_functions_to_schema` or `add_resolve_functions_to_scalar` is defined and update it to handle `parse_value` and `parse_literal`.

Wait, the problem statement says `add_resolve_functions_to_schema` should support Scalars parse_value and parse_literal, and then it mentions `add_resolve_functions_to_scalar`. I should check both.

Let's start by searching for these functions in the codebase.

{
  "command": "grep -rn --include=\"*.py\" \"add_resolve_functions\" /workspace/ariadne"
}

{
  "status": "ok",
  "stdout": "/workspace/ariadne/executable_schema.py:6:from .resolvers import add_resolve_functions_to_schema\n/workspace/ariadne/executable_schema.py:13:    add_resolve_functions_to_schema(schema, resolvers)\n/workspace/ariadne/__init__.py:3:from .resolvers import add_resolve_functions_to_schema, default_resolver, resolve_to\n/workspace/ariadne/__init__.py:6:    \"add_resolve_functions_to_schema\",\n/workspace/ariadne/resolvers.py:22:def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n/workspace/ariadne/resolvers.py:25:            add_resolve_functions_to_object(type_name, type_object, resolvers)\n/workspace/ariadne/resolvers.py:30:def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):\n",
  "stderr": "",
  "exit_code": 0
}

The grep results show `add_resolve_functions_to_schema` in `ariadne/resolvers.py`. I didn't see `add_resolve_functions_to_scalar` in the grep results, maybe it's called something else or I missed it. Wait, the problem statement says `add_resolve_functions_to_scalar`. Let me search for `scalar` and `resolve` in `ariadne/resolvers.py`.

{
  "command": "grep -rn --include=\"*.py\" \"scalar\" /workspace/ariadne/resolvers.py"
}

{
  "status": "ok",
  "stdout": "27:            add_resolve_function_to_scalar(type_name, type_object, resolvers)\n37:def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n",
  "stderr": "",
  "exit_code": 0
}

Ah, it's `add_resolve_function_to_scalar` (singular `function` instead of `functions`).

Let's read `ariadne/resolvers.py`.

{
  "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`:

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

Actually, it's taking `obj: GraphQLObjectType` as a type hint, but it's called when `type_object` is `GraphQLScalarType`. And it only handles `serialize`.

It should be:
1. Fixing the type hint for `obj` to `GraphQLScalarType`.
2. Supporting `parse_value` and `parse_literal` from the `resolvers` dict.

If `resolvers[name]` is a dictionary, it should be able to contain `serialize`, `parse_value`, and `parse_literal`.

Current implementation:
```python
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
If `resolvers.get(name)` returns a dict, then `obj.serialize` becomes that dict, which is wrong.

Wait, if `resolvers` is:
```python
resolvers = {
    'Scalar': {
        'serialize': lambda val: str(val),
        'parse_value': lambda val: int(val),
        'parse_literal': lambda val: int(val.value),
    }
}
```
Then `resolvers.get('Scalar')` is the dict. And `obj.serialize` becomes the dict.

But wait, 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 `type_resolver` is expected to be a dict mapping field names to resolvers.

For scalars, it seems it was expected to be:
`resolvers = {'Scalar': serialize_callable}`

But the problem description says:
- `type_defs = {'Scalar': {'serialize': callable}}`
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

Wait, the problem says `type_defs`, but it probably means `resolvers`.

Let's re-read:
"Our `add_resolve_functions_to_scalar` utility could support following use-cases:
Code below results in one-way only scalar:
- `type_defs = {'Scalar': {'serialize': callable}}`
And this code results in two-way scalar:
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`"

So it seems Ariadne wants to support a dict of functions for each scalar.

Current implementation:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
If `resolvers.get(name)` is `{'serialize': ...}`, then `obj.serialize` is set to that dict. That's definitely not right for `graphql-core`.

Wait, is it possible that the current implementation expects `resolvers[name]` to be the serializer itself?
Yes, if `resolvers = {'Scalar': my_serialize_func}`, then it works.

But the user wants to support a dict.

If `resolvers[name]` is a dict, we should use its keys to set `serialize`, `parse_value`, and `parse_literal`.
If `resolvers[name]` is a callable, we should probably treat it as the `serialize` function (to maintain backward compatibility, if any). Actually, the problem says:
`type_defs = {'Scalar': {'serialize': callable}}`
This implies that `resolvers[name]` is expected to be a dict.

Let's look at `add_resolve_functions_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
```
It currently doesn't check if `resolvers.get(name)` is a dict.

If I change it to:
```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:
        # Backward compatibility: if it's just a callable, treat it as serializer
        obj.serialize = scalar_resolvers if scalar_resolvers else obj.serialize
```
Wait, if `scalar_resolvers` is `None` because `resolvers.get(name)` is `None` (defaulting to `{}`), then `isinstance({}, dict)` is true.
If `resolvers = {'Scalar': my_serialize_func}`, then `scalar_resolvers` is `my_serialize_func`, and `isinstance` is false.

Wait, `obj.serialize` is a property of `GraphQLScalarType`.

Let's check what `GraphQLScalarType` has.
In `graphql-core`, `GraphQLScalarType` has `serialize`, `parse_value`, and `parse_literal`.

Wait, is `obj` actually a `GraphQLScalarType`?
In `add_resolve_functions_to_schema`:
```python
        if isinstance(type_object, GraphQLScalarType):
            add_resolve_function_to_scalar(type_name, type_object, resolvers)
```
Yes, it is. The type hint `GraphQLObjectType` in `add_resolve_function_to_scalar` is wrong.

Let's see if there are existing tests for scalars.

{
  "command": "find tests -name \"*scalar*\""
}

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

No tests with "scalar" in the name. Let's search for "Scalar" in all tests.

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

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

Wait, `grep -rn "Scalar" tests/` failed? Maybe there are no tests using scalars.
Let me check `tests/` content.

{
  "command": "ls -R tests/"
}

{
  "status": "ok",
  "stdout": "tests/:\n__init__.py\ntest_modularization.py\ntest_mutations.py\ntest_queries.py\n",
  "stderr": "",
  "exit_code": 0
}

Okay, very few tests.

Let's try to reproduce the issue first.
I'll create a reproduction script. I need to use `ariadne` and `graphql-core`.

```python
from graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType, GraphQLString, GraphQLField, GraphQLNonNull
from ariadne import make_executable_schema, add_resolve_functions_to_schema
from ariadne.resolvers import add_resolve_function_to_scalar

# Mock a schema
# In a real scenario, we'd use make_executable_schema
# but I can just build one manually or use a simple type_defs

type_defs = """
    type Query {
        scalar: MyScalar
    }
    scalar MyScalar
"""
from ariadne import make_executable_schema

schema = make_executable_schema(type_defs)
resolvers = {
    'MyScalar': {
        'serialize': lambda v: f"serialized({v})",
        'parse_value': lambda v: f"parsed_value({v})",
        'parse_literal': lambda v: f"parsed_literal({v})",
    }
}

add_resolve_functions_to_schema(schema, resolvers)

my_scalar = schema.get_type('MyScalar')
print(f"Serialize: {my_scalar.serialize('foo')}")
# This should fail or not work as expected currently.
```

Let's see how it behaves currently.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ntype_defs = \"\"\"\n    type Query {\n        scalar: MyScalar\n    }\n    scalar MyScalar\n\"\"\"\n\nschema = make_executable_schema(type_defs)\nresolvers = {\n    'MyScalar': {\n        'serialize': lambda v: f\"serialized({v})\",\n        'parse_value': lambda v: f\"parsed_value({v})\",\n        'parse_literal': lambda v: f\"parsed_literal({v})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nmy_scalar = schema.get_type('MyScalar')\nprint(f\"Serialize: {my_scalar.serialize('foo')}\")\ntry:\n    print(f\"Parse Value: {my_scalar.parse_value('foo')}\")\nexcept Exception as e:\n    print(f\"Parse Value Error: {e}\")\ntry:\n    # parse_literal takes an AST node, but let's just see if it's callable\n    print(f\"Parse Literal: {my_scalar.parse_literal('foo')}\")\nexcept Exception as e:\n    print(f\"Parse Literal Error: {e}\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 11, in <module>\nTypeError: make_executable_schema() missing 1 required positional argument: 'resolvers'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 11, in <module>\nTypeError: make_executable_schema() missing 1 required positional argument: 'resolvers'\n",
    "exit_code": 1
  }
}

Ah, `make_executable_schema` requires `resolvers`.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ntype_defs = \"\"\"\n    type Query {\n        scalar: MyScalar\n    }\n    scalar MyScalar\n\"\"\"\n\nschema = make_executable_schema(type_defs, resolvers={})\nresolvers = {\n    'MyScalar': {\n        'serialize': lambda v: f\"serialized({v})\",\n        'parse_value': lambda v: f\"parsed_value({v})\",\n        'parse_literal': lambda v: f\"parsed_literal({v})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nmy_scalar = schema.get_type('MyScalar')\nprint(f\"Scalar type: {type(my_scalar)}\")\ntry:\n    print(f\"Serialize: {my_scalar.serialize('foo')}\")\nexcept Exception as e:\n    print(f\"Serialize Error: {e}\")\ntry:\n    print(f\"Parse Value: {my_scalar.parse_value('foo')}\")\nexcept Exception as e:\n    print(f\"Parse Value Error: {e}\")\ntry:\n    print(f\"Parse Literal: {my_scalar.parse_literal('foo')}\")\nexcept Exception as e:\n    print(f\"Parse Literal Error: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Scalar type: <class 'graphql.type.definition.GraphQLScalarType'>\nSerialize Error: 'dict' object is not callable\nParse Value: False\nParse Literal: False\n",
  "stderr": "",
  "exit_code": 0
}

As expected:
1. `my_scalar.serialize` is now the dict `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`, so calling it raises `TypeError: 'dict' object is not callable`.
2. `my_scalar.parse_value` and `my_scalar.parse_literal` are the defaults from `GraphQLScalarType`, which return `False` or similar (actually `GraphQLScalarType`'s default `parse_value` is `None` or some default implementation, let's check). Wait, the output said `Parse Value: False`.

Wait, `GraphQLScalarType` defaults for `parse_value` and `parse_literal` are actually slightly different in `graphql-core`.

The point is that `serialize` is broken and the others are not updated.

Now I will apply the fix in `ariadne/resolvers.py`.

I need to:
1. Change `GraphQLObjectType` to `GraphQLScalarType` in `add_resolve_function_to_scalar` type hint.
2. Handle the case where `resolvers.get(name)` is either a dict or a callable.

Wait, if `resolvers.get(name)` is a callable, it should probably be used as the `serialize` function for backward compatibility.

Let's see:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if scalar_resolvers is None:
        return

    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:
        # Backward compatibility: if it's just a callable, treat it as serialize
        obj.serialize = scalar_resolvers
```

Wait, what if `obj.serialize` is not available? `GraphQLScalarType` usually has it.

Let's double check the original implementation:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
If `resolvers.get(name)` is `None` (because `name` is not in `resolvers`), it uses `obj.serialize`.

My proposed implementation:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if scalar_resolvers is None:
        return

    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:
        obj.serialize = scalar_resolvers
```
This looks correct and maintains backward compatibility for when `resolvers[name]` is just a function.

Wait, let's see if there's any other place where scalars are handled. I already checked `ariadne/resolvers.py`.
`add_resolve_functions_to_schema` calls `add_resolve_function_to_scalar`.

Let's check if `GraphQLScalarType` is imported in `ariadne/resolvers.py`.
Yes, it is: `from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema`.

Wait, 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
```
The type hint says `GraphQLObjectType` but it's called with a `GraphQLScalarType`. That's a bug too.

Let's prepare the `edit_file` call.

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

New code:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name)
    if scalar_resolvers is None:
        return

    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:
        obj.serialize = scalar_resolvers
```

Wait, let me verify if `obj.serialize`, `obj.parse_value`, `obj.parse_literal` exist on `GraphQLScalarType` instances. Yes, they do.

Let's refine the implementation to be as compact as possible but clear.

```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
```

One more thing: if `resolvers.get(name)` is a dict, but it's an empty dict, it should probably not change anything.
`scalar_resolvers.get('serialize', obj.serialize)` will return `obj.serialize` if 'serialize' is missing. This is correct.

What if `resolvers` is:
```python
resolvers = {
    'MyScalar': {
        'serialize': None
    }
}
```
Then `obj.serialize` becomes `None`. Is that allowed? Yes, you might want to disable serialization.

Wait, let's check if I should use `getattr(obj, 'serialize', None)` instead of `obj.serialize` if I'm not sure they exist. But they should exist on `GraphQLScalarType`.

Actually, `GraphQLScalarType` in `graphql-core` has these as attributes.

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 Planck",
  "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 Planck"
}

{
  "status": "error",
  "error_type": "FileEditError",
  "error_message": "Failed to replace: old_string not found. Ensure you're not escaping content incorrectly and check whitespace, indentation, and context."
}

Ah, I added " Planck" to the strings for some reason. My bad. Let's try again without " Planck".

Wait, I should also check for any trailing whitespace or something.
Original:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
(Line 37-39)

Let me read the file again to be sure about the characters.

{
  "end_line": 39,
  "filepath": "ariadne/resolvers.py",
  "start_line": 37
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "content": "def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):\n    serializer = resolvers.get(name, obj.serialize)\n    obj.serialize = serializer",
  "start_line": 37,
  "end_line": 39,
  "total_lines": 39,
  "is_truncated": false
}

Okay, let's try the `edit_file` again.

{
  "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 to verify the fix.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ntype_defs = \"\"\"\n    type Query {\n        scalar: MyScalar\n    }\n    scalar MyScalar\n\"\"\"\n\nschema = make_executable_schema(type_defs, resolvers={})\nresolvers = {\n    'MyScalar': {\n        'serialize': lambda v: f\"serialized({v})\",\n        'parse_value': lambda v: f\"parsed_value({v})\",\n        'parse_literal': lambda v: f\"parsed_literal({v})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, resolvers)\n\nmy_scalar = schema.get_type('MyScalar')\nprint(f\"Scalar type: {type(my_scalar)}\")\ntry:\n    print(f\"Serialize: {my_scalar.serialize('foo')}\")\nexcept Exception as e:\n    print(f\"Serialize Error: {e}\")\ntry:\n    print(f\"Parse Value: {my_scalar.parse_value('foo')}\")\nexcept Exception as e:\n    print(f\"Parse Value Error: {e}\")\ntry:\n    print(f\"Parse Literal: {my_scalar.parse_literal('foo')}\")\nexcept Exception as e:\n    print(f\"Parse Literal Error: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Scalar type: <class 'graphql.type.definition.GraphQLScalarType'>\nSerialize: serialized(foo)\nParse Value: parsed_value(foo)\nParse Literal: parsed_literal(foo)\n",
  "stderr": "",
  "exit_code": 0
}

Great! It works.

Now let's test the backward compatibility cases:
1. `resolvers[name]` is a callable (should be used as `serialize`).
2. `resolvers[name]` is missing.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ndef test_scalar(serialize_func, parse_val_func, parse_lit_func, resolvers_config, name='MyScalar'):\n    type_defs = \"\"\"\n        type Query {\n            scalar: MyScalar\n        }\n        scalar MyScalar\n    \"\"\"\n    schema = make_executable_schema(type_defs, resolvers={})\n    \n    add_resolve_functions_to_schema(schema, resolvers_config)\n    my_scalar = schema.get_type(name)\n    \n    # Note: In graphql-core, GraphQLScalarType might have default implementations\n    # We want to check if our functions were assigned.\n    \n    # This is slightly tricky because we don't know the default.\n    # But we can check if the function is the one we passed.\n    \n    if serialize_func and my_scalar.serialize != serialize_func:\n        print(f\"Serialize Fail\")\n        return False\n    if parse_val_func and my_scalar.parse_value != parse_val_func:\n        print(f\"Parse Value Fail\")\n        return False\n    if parse_lit_func and my_scalar.parse_literal != parse_lit_func:\n        print(f\"Parse Literal Fail\")\n        return False\n    \n    print(\"Success\")\n    return True\n\n# Case 1: Full dict\ns = lambda v: f\"s({v})\"\npv = lambda v: f\"pv({v})\"\npl = lambda v: f\"pl({v})\"\ntest_scalar(s, pv, pl, {'MyScalar': {'serialize': s, 'parse_value': pv, 'parse_literal': pl}})\n\n# Case 2: Partial dict (only serialize)\ntest_scalar(s, None, None, {'MyScalar': {'serialize': s}})\n\n# Case 3: Callable (backward compatibility)\ntest_scalar(s, None, None, {'MyScalar': s})\n\n# Case 4: Missing\ntest_scalar(None, None, None, {})\nPY\n"
}

{
  "status": "ok",
  "stdout": "Success\nSuccess\nSuccess\nSuccess\n",
  "stderr": "",
  "exit_code": 0
}

Wait, in Case 2, `test_scalar(s, None, None, {'MyScalar': {'serialize': s}})`:
`pv` is `None`, so it doesn't check `my_scalar.parse_value`.
I should check if it's STILL the default value.

Let's refine the test script to be more rigorous.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ndef get_default_scalar():\n    # Use a fresh schema to get default scalar behavior\n    schema = make_executable_schema(\"scalar MyScalar\", resolvers={})\n    return schema.get_type('MyScalar')\n\ndef run_test(resolvers_config, name='MyScalar'):\n    type_defs = \"\"\"\n        type Query {\n            scalar: MyScalar\n        }\n        scalar MyScalar\n    \"\"\"\n    schema = make_executable_schema(type_defs, resolvers={})\n    default_scalar = get_default_scalar()\n    \n    add_resolve_functions_to_schema(schema, resolvers_config)\n    my_scalar = schema.get_type(name)\n    \n    return {\n        'serialize': my_scalar.serialize,\n        'parse_value': my_scalar.parse_value,\n        'parse_literal': my_scalar.parse_literal,\n        'default': default_scalar\n    }\n\n# Functions\ns = lambda v: f\"s({v})\"\npv = lambda v: f\"pv({v})\"\npl = lambda v: f\"pl({v})\"\n\n# Case 1: Full dict\nres = run_test({'MyScalar': {'serialize': s, 'parse_value': pv, 'parse_literal': pl}})\nassert res['serialize'] == s\nassert res['parse_value'] == pv\nassert res['parse_literal'] == pl\n\n# Case 2: Partial dict (only serialize)\nres = run_test({'MyScalar': {'serialize': s}})\nassert res['serialize'] == s\nassert res['parse_value'] == res['default'].parse_value\nassert res['parse_literal'] == res['default'].parse_literal\n\n# Case 3: Callable (backward compatibility)\nres = run_test({'MyScalar': s})\nassert res['serialize'] == s\nassert res['parse_value'] == res['default'].parse_value\nassert res['parse_literal'] == res['default'].parse_literal\n\n# Case 4: Missing\nres = run_test({})\nassert res['serialize'] == res['default'].serialize\nassert res['parse_value'] == res['default'].parse_value\nassert res['parse_literal'] == res['default'].parse_literal\n\nprint(\"All tests passed!\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 35, in <module>\n  File \"<stdin>\", line 17, in run_test\n  File \"<stdin>\", line 6, in get_default_scalar\n  File \"/workspace/ariadne/executable_schema.py\", line 12, in make_executable_schema\n    schema = build_schema_from_type_definitions(type_defs)\n  File \"/workspace/ariadne/build_schema.py\", line 27, in build_schema_from_type_definitions\n    return build_ast_schema(document)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/utils/build_ast_schema.py\", line 124, in build_ast_schema\n    raise Exception(\"Must provide schema definition with query type.\")\nException: Must provide schema definition with query type.\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 35, in <module>\n  File \"<stdin>\", line 17, in run_test\n  File \"<stdin>\", line 6, in get_default_scalar\n  File \"/workspace/ariadne/executable_schema.py\", line 12, in make_executable_schema\n    schema = build_schema_from_type_definitions(type_defs)\n  File \"/workspace/ariadne/build_schema.py\", line 27, in build_schema_from_type_definitions\n    return build_ast_schema(document)\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/utils/build_ast_schema.py\", line 124, in build_ast_schema\n    raise Exception(\"Must provide schema definition with query type.\")\nException: Must provide schema definition with query type.\n",
    "exit_code": 1
  }
}

The `get_default_scalar` failed because `make_executable_schema("scalar MyScalar", resolvers={})` is missing a query type.

Let's fix the test script.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ndef get_default_scalar():\n    schema = make_executable_schema(\"type Query { q: String } scalar MyScalar\", resolvers={})\n    return schema.get_type('MyScalar')\n\ndef run_test(resolvers_config, name='MyScalar'):\n    type_defs = \"\"\"\n        type Query {\n            scalar: MyScalar\n        }\n        scalar MyScalar\n    \"\"\"\n    schema = make_executable_schema(type_defs, resolvers={})\n    default_scalar = get_default_scalar()\n    \n    add_resolve_functions_to_schema(schema, resolvers_config)\n    my_scalar = schema.get_type(name)\n    \n    return {\n        'serialize': my_scalar.serialize,\n        'parse_value': my_scalar.parse_value,\n        'parse_literal': my_scalar.parse_literal,\n        'default': default_scalar\n    }\n\n# Functions\ns = lambda v: f\"s({v})\"\npv = lambda v: f\"pv({v})\"\npl = lambda v: f\"pl({v})\"\n\n# Case 1: Full dict\nres = run_test({'MyScalar': {'serialize': s, 'parse_value': pv, 'parse_literal': pl}})\nassert res['serialize'] == s\nassert res['parse_value'] == pv\nassert res['parse_literal'] == pl\n\n# Case 2: Partial dict (only serialize)\nres = run_test({'MyScalar': {'serialize': s}})\nassert res['serialize'] == s\nassert res['parse_value'] == res['default'].parse_value\nassert res['parse_literal'] == res['default'].parse_literal\n\n# Case 3: Callable (backward compatibility)\nres = run_test({'MyScalar': s})\nassert res['serialize'] == s\nassert res['parse_value'] == res['default'].parse_value\nassert res['parse_literal'] == res['default'].parse_literal\n\n# Case 4: Missing\nres = run_test({})\nassert res['serialize'] == res['default'].serialize\nassert res['parse_value'] == res['default'].parse_value\nassert res['parse_literal'] == res['default'].parse_literal\n\nprint(\"All tests passed!\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "All tests passed!\n",
  "stderr": "",
  "exit_code": 0
}

All tests passed. I think I am done.
I'll do a final check of `git status --short && git diff` then submit.

{
  "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..a506a29 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
}

The diff looks correct. No untracked files. Type hint fixed. Logic for `parse_value` and `parse_literal` added. Backward compatibility maintained.

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

I have successfully implemented the requested feature. I updated `add_resolve_function_to_scalar` to support a dictionary of resolver functions for scalars, enabling `serialize`, `parse_value`, and `parse_literal` to be customized. I also corrected the type hint for the `obj` parameter from `GraphQLObjectType` to `GraphQLScalarType`.

The `add_resolve_function_to_scalar` utility in `ariadne/resolvers.py` 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 resolver functions for a scalar and a single callable for backward compatibility, while also correcting the type hint for the scalar object.