mirumee__ariadne-24

The user wants to add support for `parse_value` and `parse_literal` to `add_resolve_functions_to_schema` in `ariadne`.
Currently, it seems only `serialize` is supported for Scalars.

I need to find where `add_resolve_functions_to_schema` (or the mentioned `add_resolve_functions_to_scalar` - the problem statement mentions both) is defined and update it to handle `parse_value` and `parse_literal`.

Wait, the problem says:
`add_resolve_functions_to_schema` should support Scalars parse_value and parse_literal.
Then it says:
Our `add_resolve_functions_to_scalar` utility could support following use-cases:

Let's search for these functions in the codebase.

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

{
  "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:22:def add_resolve_functions_to_schema(schema: GraphQLSchema, resolvers: dict):\n",
  "stderr": "",
  "exit_code": 0
}

Okay, `add_resolve_functions_to_schema` is in `ariadne/resolvers.py`.
The problem also mentioned `add_resolve_functions_to_scalar`. Let's check if that exists.

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

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

It seems `add_resolve_functions_to_scalar` is not in the codebase, or maybe it was a slip of the tongue by the user and they meant `add_resolve_functions_to_schema` or a helper function inside it.

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
}

Found it! `add_resolve_function_to_scalar` is on line 35. Oh wait, line 35 says:
`def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):`
But it's called with `GraphQLScalarType` in `add_resolve_functions_to_schema` on line 26:
`if isinstance(type_object, GraphQLScalarType): add_resolve_function_to_scalar(type_name, type_object, resolvers)`

And inside `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
```
It's only taking the serializer. The type hint for `obj` is also wrong (it says `GraphQLObjectType` but it should be `GraphQLScalarType`).

Wait, look at this part:
`serializer = resolvers.get(name, obj.serialize)`
If `resolvers[name]` is a dictionary (as implied by the problem statement), `resolvers.get(name, obj.serialize)` will return that dictionary if `name` is in `resolvers`.
But then it does `obj.serialize = serializer`, which would assign a dictionary to `obj.serialize` if `resolvers[name]` is a dict. That seems wrong.

Let's check the problem statement again.
`type_defs = {'Scalar': {'serialize': callable}}`
`type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

So if `resolvers` is `{'Scalar': {'serialize': ..., 'parse_value': ..., 'parse_literal': ...}}`, then `add_resolve_functions_to_schema` should assign these functions to the scalar type.

Let's 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 `{'Scalar': some_function}`, then `serializer` becomes `some_function`.
If `resolvers` is `{'Scalar': {'serialize': some_function}}`, then `serializer` becomes `{'serialize': some_function}`.
Then `obj.serialize` becomes a dictionary. That's definitely not right for `graphql-core`'s `GraphQLScalarType`.

Actually, looking 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.

It seems `add_resolve_function_to_scalar` is far too simple and probably bugged/incomplete.

If `resolvers[name]` is a callable, it should probably be the serializer.
If `resolvers[name]` is a dict, it should contain `serialize`, `parse_value`, and `parse_literal`.

Wait, let's see how `graphql-core` defines `GraphQLScalarType`. Usually it has `serialize`, `parse_value`, and `parse_literal`.

Let's try to reproduce this. I'll write a test case.

{
  "content": "\nfrom graphql import build_schema, GraphQLSchema, GraphQLScalarType, graphQLSchema\nfrom ariadne.resolvers import add_resolve_functions_to_schema\nfrom ariadne import make_executable_schema # wait, maybe not needed\n\ndef test_scalar_resolvers():\n    type_defs = \"\"\"\n        scalar Date\n        type Query {\n            date: Date\n        }\n    \"\"\"\n    schema = build_schema(type_defs)\n    \n    def serialize(value):\n        return f\"Serialized: {value}\"\n    \n    def parse_value(value):\n        return f\"Parsed Value: {value}\"\n    \n    def parse_literal(node):\n        return f\"Parsed Literal: {node.value}\"\n\n    # Case 1: only serialize\n    resolvers = {\n        'Date': {\n            'serialize': serialize\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    assert date_type.serialize == serialize\n    assert date_type.parse_value is None or date_type.parse_value == GraphQLScalarType.parse_value\n    \n    # Case 2: all three\n    resolvers = {\n        'Date': {\n            'serialize': serialize,\n            'parse_value': parse_value,\n            'parse_literal': parse_literal\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    assert date_type.serialize == serialize\n    assert date_type.parse_value == parse_value\n    assert date_type.parse_literal == parse_literal\n\nif __name__ == \"__main__\":\n    try:\n        test_scalar_resolvers()\n        print(\"Tests passed!\")\n    except Exception as e:\n        import traceback\n        traceback.print_exc()\n        exit(1)\n",
  "filepath": "/tmp/repro.py"
}

{
  "status": "error",
  "error_type": "FileWriteError",
  "error_message": "Path traversal detected: '/tmp/repro.py' escapes workspace root."
}

Ah, I should use `/tmp/repro.py` but maybe I should just run it via `python3 - <<'PY'`. The instructions say: "Never leave reproduction or scratch files inside /workspace — run reproductions inline via python3 - <<'PY' or inside /tmp/repro.py in a single run_command."
Wait, it says "inside /tmp/repro.py in a single run_command". But my `write_file` failed because it's not in `/workspace`.
I should use `run_command` to write to `/tmp/repro.py` using `printf` or `cat` or just use a here-doc.

Actually, let's just use `python3 - <<'PY'`.

{
  "command": "python3 - <<'PY'\nfrom graphql import build_schema, GraphQLSchema, GraphQLScalarType\nfrom ariadne.resolvers import add_resolve_functions_to_schema\n\ndef test_scalar_resolvers():\n    type_defs = \"\"\"\n        scalar Date\n        type Query {\n            date: Date\n        }\n    \"\"\"\n    schema = build_schema(type_defs)\n    \n    def serialize(value):\n        return f\"Serialized: {value}\"\n    \n    def parse_value(value):\n        return f\"Parsed Value: {value}\"\n    \n    def parse_literal(node):\n        return f\"Parsed Literal: {node.value}\"\n\n    # Case 1: only serialize\n    resolvers = {\n        'Date': {\n            'serialize': serialize\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 1: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value}, parse_literal={date_type.parse_literal}\")\n    \n    # Case 2: all three\n    resolvers = {\n        'Date': {\n            'serialize': serialize,\n            'parse_value': parse_value,\n            'parse_literal': parse_literal\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 2: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value == parse_value}, parse_literal={date_type.parse_literal == parse_literal}\")\n\nif __name__ == \"__main__\":\n    try:\n        test_scalar_resolvers()\n    except Exception as e:\n        import traceback\n        traceback.print_exc()\n        exit(1)\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 likely in `ariadne.build_schema` or I should use the `graphql` library correctly.
Actually, `ariadne` has `build_schema` in `ariadne/build_schema.py`? No, that's likely the ariadne implementation.
Wait, `graphql-core` (which is the `graphql` package) has `build_schema` in `graphql.build_schema`? No, in newer versions it's `graphql.build_schema` if it's a top level export.
Wait, `ariadne` usually provides its own `make_executable_schema`.

Let's check the imports in `ariadne/resolvers.py`.
`from graphql import GraphQLObjectType, GraphQLScalarType, GraphQLSchema`
So `graphql` is indeed `graphql-core`.

Let's check where `build_schema` is in `graphql-core`.
Actually, I can just use `ariadne`'s `make_executable_schema` if I want, but I need a schema to pass to `add_resolve_functions_to_schema`.

Let's see how `ariadne` creates schemas.

{
  "command": "grep -rn --include=\"*.py\" \"make_executable_schema\""
}

{
  "status": "ok",
  "stdout": "ariadne/executable_schema.py:9:def make_executable_schema(\nariadne/__init__.py:2:from .executable_schema import make_executable_schema\nariadne/__init__.py:9:    \"make_executable_schema\",\ntests/test_modularization.py:3:from ariadne import make_executable_schema\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:6:from ariadne import make_executable_schema, resolve_to\ntests/test_queries.py:18:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:39:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:59:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:79:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:102:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:126:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:146:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:170:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:193:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_queries.py:216:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_mutations.py:3:from ariadne import make_executable_schema\ntests/test_mutations.py:19:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_mutations.py:47:    schema = make_executable_schema(type_defs, resolvers)\ntests/test_mutations.py:79:    schema = make_executable_schema(type_defs, resolvers)\n",
  "stderr": "",
  "exit_code": 0
}

Let's use `make_executable_schema`.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema\nfrom ariadne.resolvers import add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ndef test_scalar_resolvers():\n    type_defs = \"\"\"\n        scalar Date\n        type Query {\n            date: Date\n        }\n    \"\"\"\n    schema = make_executable_schema(type_defs)\n    \n    def serialize(value):\n        return f\"Serialized: {value}\"\n    \n    def parse_value(value):\n        return f\"Parsed Value: {value}\"\n    \n    def parse_literal(node):\n        return f\"Parsed Literal: {node.value}\"\n\n    # Case 1: only serialize\n    resolvers = {\n        'Date': {\n            'serialize': serialize\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 1: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value}, parse_literal={date_type.parse_literal}\")\n    \n    # Case 2: all three\n    resolvers = {\n        'Date': {\n            'serialize': serialize,\n            'parse_value': parse_value,\n            'parse_literal': parse_literal\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 2: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value == parse_value}, parse_literal={date_type.parse_literal == parse_literal}\")\n\nif __name__ == \"__main__\":\n    try:\n        test_scalar_resolvers()\n    except Exception as e:\n        import traceback\n        traceback.print_exc()\n        exit(1)\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 47, in <module>\n  File \"<stdin>\", line 12, in test_scalar_resolvers\nTypeError: make_executable_schema() missing 1 required positional argument: 'resolvers'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"<stdin>\", line 47, in <module>\n  File \"<stdin>\", line 12, in test_scalar_resolvers\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\nfrom ariadne.resolvers import add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ndef test_scalar_resolvers():\n    type_defs = \"\"\"\n        scalar Date\n        type Query {\n            date: Date\n        }\n    \"\"\"\n    schema = make_executable_schema(type_defs, {})\n    \n    def serialize(value):\n        return f\"Serialized: {value}\"\n    \n    def parse_value(value):\n        return f\"Parsed Value: {value}\"\n    \n    def parse_literal(node):\n        return f\"Parsed Literal: {node.value}\"\n\n    # Case 1: only serialize\n    resolvers = {\n        'Date': {\n            'serialize': serialize\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 1: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value}, parse_literal={date_type.parse_literal}\")\n    \n    # Case 2: all three\n    resolvers = {\n        'Date': {\n            'serialize': serialize,\n            'parse_value': parse_value,\n            'parse_literal': parse_literal\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 2: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value == parse_value}, parse_literal={date_type.parse_literal == parse_literal}\")\n\nif __name__ == \"__main__\":\n    try:\n        test_scalar_resolvers()\n    except Exception as e:\n        import traceback\n        traceback.print_exc()\n        exit(1)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Case 1: serialize=False, parse_value=<function _false at 0x7bc6b9bc6b00>, parse_literal=<function _false at 0x7bc6b9bc6b00>\nCase 2: serialize=False, parse_value=False, parse_literal=False\n",
  "stderr": "",
  "exit_code": 0
}

Wait, why did Case 1 and Case 2 in my last run return `serialize=False`?

Let's look at `ariadne/resolvers.py` again.
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
Wait! I see a BIG bug 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 `obj: GraphQLObjectType`, but it is called when `isinstance(type_object, GraphQLScalarType)` in `add_resolve_functions_to_schema`.

Also, `resolvers.get(name, obj.serialize)` will be the dictionary `{'serialize': serialize}` if `resolvers` is `{'Date': {'serialize': serialize}}`.
So `obj.serialize` becomes `{'serialize': serialize}`, which is a dictionary, not a callable. That's why `date_type.serialize == serialize` is `False`.

The `add_resolve_functions_to_object` function does this:
```python
def add_resolve_functions_to_object(name: str, obj: GraphQLObjectType, resolvers: dict):
    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
```
It first gets the resolver map for the type, then looks up the specific field.

`add_resolve_function_to_scalar` should do something similar:
1. Get the resolver map for the scalar: `scalar_resolvers = resolvers.get(name, {})`
2. Update `serialize`, `parse_value`, and `parse_literal` if they provide.

Let's re-examine `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
```

It's completely wrong. It sets `obj.serialize` to the whole dictionary mapping for that scalar if it exists.

Actually, looking at the problem statement:
- `type_defs = {'Scalar': {'serialize': callable}}`
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

So `resolvers` is a dict where keys are type names and values are dicts of resolver functions.

Correct implementation should be:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name, {})
    if 'serialize' in scalar_resolvers:
        obj.serialize = scalar_resolvers['serialize']
    if 'parse_value' in scalar_resolvers:
        obj.parse_value = scalar_resolvers['parse_value']
    if 'parse_literal' in scalar_resolvers:
        obj.parse_literal = scalar_resolvers['parse_literal']
```

Wait, let me check the existing code for `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
```

Yes, this is clearly broken in multiple ways.
1. Type hint is `GraphQLObjectType` instead of `GraphQLScalarType`.
2. It doesn't look into the nested dictionary.
3. It doesn't support `parse_value` or `parse_literal`.

Let's verify my reproduction script results.
`Case 1: serialize=False, ...`
In Case 1:
`resolvers = {'Date': {'serialize': serialize}}`
`name = 'Date'`
`resolvers.get('Date', obj.serialize)` returns `{'serialize': serialize}`.
`obj.serialize` is now `{'serialize': serialize}`.
`date_type.serialize == serialize` is `{'serialize': serialize} == serialize` which is `False`. Correct.

Case 2:
`resolvers = {'Date': {'serialize': serialize, 'parse_value': parse_value, 'parse_literal': parse_literal}}`
`obj.serialize` becomes the whole dict.
`date_type.serialize == serialize` is `False`.
`date_type.parse_value` remains the default (which is probably `_false` or `None` in the `graphql` library).
So `date_type.parse_value == parse_value` is `False`. Correct.

So the fix is to implement the missing lookups for `parse_value` and `parse_literal` and fix the `serialize` lookup.

Let's double check `GraphQLScalarType` attributes.
Usually they have `serialize`, `parseValue`, and `parseLiteral`.
Wait, let me check the `graphql-core` (python) naming.
In `graphql-core`, they are indeed `serialize`, `parse_value`, and `parse_literal`.

Let me check if I can find where `GraphQLScalarType` is defined or used in the repo to be sure about the attribute names.

Actually, I can just check with a small script.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLScalarType\ns = GraphQLScalarType()\nprint(f\"serialize: {hasattr(s, 'serialize')}\")\nprint(f\"parse_value: {hasattr(s, 'parse_value')}\")\nprint(f\"parse_literal: {hasattr(s, 'parse_literal')}\")\nPY\n"
}

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

My bad.

{
  "command": "python3 - <<'PY'\nfrom graphql import GraphQLScalarType\ns = GraphQLScalarType(name='TestScalar')\nprint(f\"serialize: {hasattr(s, 'serialize')}\")\nprint(f\"parse_value: {hasattr(s, 'parse_value')}\")\nprint(f\"parse_literal: {hasattr(s, 'parse_literal')}\")\nPY\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"<stdin>\", line 2, in <module>\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 125, in __init__\n    ).format(self)\nAssertionError: TestScalar 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 2, in <module>\n  File \"/opt/py37/lib/python3.7/site-packages/graphql/type/definition.py\", line 125, in __init__\n    ).format(self)\nAssertionError: TestScalar 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
  }
}

Okay, so they are attributes that can be set.

Let's look at `ariadne/resolvers.py` again.

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

Wait, `obj` is passed as `type_object` when `isinstance(type_object, GraphQLScalarType)` in `add_resolve_functions_to_schema`.

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

The bug in `add_resolve_function_to_scalar` is that it's using the whole `resolvers.get(name)` as the serializer.

Let's fix `add_resolve_function_to_scalar` to support `serialize`, `parse_value`, and `parse_literal`.

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

Actually, wait. In `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
```
It uses `resolvers.get(name, {})`.

If I use the same pattern for scalars:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):
    scalar_resolvers = resolvers.get(name, {})
    # Since scalars don't have fields, we just check for certain keys in scalar_resolvers
    if 'serialize' in scalar_resolvers:
        obj.serialize = scalar_resolvers['serialize']
    if 'parse_value' in scalar_resolvers:
        obj.parse_value = scalar_resolvers['parse_value']
    if 'parse_literal' in scalar_resolvers:
        obj.parse_literal = scalar_resolvers['parse_literal']
```

But what if `resolvers[name]` is not a dict? The code in `add_resolve_functions_to_object` assumes `resolvers[name]` is a dict if it's provided (or defaults to `{}`).

Wait, let's 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
```
It seems the original author thought `resolvers[name]` might be the serializer itself?
The problem statement says:
- `type_defs = {'Scalar': {'serialize': callable}}`
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}`

So it's always a dict.

Let me apply the fix.

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

{
  "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 'serialize' in scalar_resolvers:\n        obj.serialize = scalar_resolvers['serialize']\n    if 'parse_value' in scalar_resolvers:\n        obj.parse_value = scalar_resolvers['parse_value']\n    if 'parse_literal' in scalar_resolvers:\n        obj.parse_literal = scalar_resolvers['parse_literal']",
  "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_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n+    scalar_resolvers = resolvers.get(name, {})\n+    if 'serialize' in scalar_resolvers:\n+        obj.serialize = scalar_resolvers['serialize']\n+    if 'parse_value' in scalar_resolvers:\n+        obj.parse_value = scalar_resolvers['parse_value']\n+    if 'parse_literal' in scalar_resolvers:\n+        obj.parse_literal = scalar_resolvers['parse_literal']\n",
  "is_truncated": false
}

Now let's run the reproduction script again to verify.

{
  "command": "python3 - <<'PY'\nfrom ariadne import make_executable_schema\nfrom ariadne.resolvers import add_resolve_functions_to_schema\nfrom graphql import GraphQLScalarType\n\ndef test_scalar_resolvers():\n    type_defs = \"\"\"\n        scalar Date\n        type Query {\n            date: Date\n        }\n    \"\"\"\n    schema = make_executable_schema(type_defs, {})\n    \n    def serialize(value):\n        return f\"Serialized: {value}\"\n    \n    def parse_value(value):\n        return f\"Parsed Value: {value}\"\n    \n    def parse_literal(node):\n        return f\"Parsed Literal: {node.value}\"\n\n    # Case 1: only serialize\n    resolvers = {\n        'Date': {\n            'serialize': serialize\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 1: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value}, parse_literal={date_type.parse_literal}\")\n    \n    # Case 2: all three\n    # Note: we must re-create schema or rely on the fact that add_resolve_functions_to_schema modifies it in place.\n    # Since it modifies in place, let's use a new resolvers dict for the same schema.\n    resolvers = {\n        'Date': {\n            'serialize': serialize,\n            'parse_value': parse_value,\n            'parse_literal': parse_literal\n        }\n    }\n    add_resolve_functions_to_schema(schema, resolvers)\n    date_type = schema.get_type('Date')\n    print(f\"Case 2: serialize={date_type.serialize == serialize}, parse_value={date_type.parse_value == parse_value}, parse_literal={date_type.parse_literal == parse_literal}\")\n\nif __name__ == \"__main__\":\n    try:\n        test_scalar_resolvers()\n    except Exception as e:\n        import traceback\n        traceback.print_exc()\n        exit(1)\nPY\n"
}

{
  "status": "ok",
  "stdout": "Case 1: serialize=True, parse_value=<function _false at 0x7c58dc759b00>, parse_literal=<function _false at 0x7c58dc759b00>\nCase 2: serialize=True, parse_value=True, parse_literal=True\n",
  "stderr": "",
  "exit_code": 0
}

The tests pass now. `Case 1: serialize=True` and `Case 2: serialize=True, parse_value=True, parse_literal=True`.

Now I should check if there are any existing tests for scalars in the repository that I might have broken, or if there are any other relevant files.

The `tests/` directory has some tests. I'll search for "scalar".

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

{
  "status": "ok",
  "stdout": "tests/test_queries.py:9:def test_query_default_scalar():\ntests/test_queries.py:25:def test_query_custom_scalar():\ntests/test_queries.py:27:        scalar Date\ntests/test_mutations.py:6:def test_mutation_return_default_scalar():\n",
  "stderr": "",
  "exit_code": 0
}

Let's run the tests.

{
  "command": "pytest tests/test_queries.py tests/test_mutations.py -q --tb=short --no-header"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": ".F...........                                                            [100%]\n=================================== FAILURES ===================================\n___________________________ test_query_custom_scalar ___________________________\ntests/test_queries.py:39: in test_query_custom_scalar\n    schema = make_executable_schema(type_defs, resolvers)\nariadne/executable_schema.py:13: in make_executable_schema\n    add_resolve_functions_to_schema(schema, resolvers)\nariadne/resolvers.py:27: in add_resolve_functions_to_schema\n    add_resolve_function_to_scalar(type_name, type_object, resolvers)\nariadne/resolvers.py:39: in add_resolve_function_to_scalar\n    if 'serialize' in scalar_resolvers:\nE   TypeError: argument of type 'function' is not iterable\n=========================== short test summary info ============================\nFAILED tests/test_queries.py::test_query_custom_scalar - TypeError: argument ...\n1 failed, 12 passed in 0.09s\n",
  "details": {
    "stdout": ".F...........                                                            [100%]\n=================================== FAILURES ===================================\n___________________________ test_query_custom_scalar ___________________________\ntests/test_queries.py:39: in test_query_custom_scalar\n    schema = make_executable_schema(type_defs, resolvers)\nariadne/executable_schema.py:13: in make_executable_schema\n    add_resolve_functions_to_schema(schema, resolvers)\nariadne/resolvers.py:27: in add_resolve_functions_to_schema\n    add_resolve_function_to_scalar(type_name, type_object, resolvers)\nariadne/resolvers.py:39: in add_resolve_function_to_scalar\n    if 'serialize' in scalar_resolvers:\nE   TypeError: argument of type 'function' is not iterable\n=========================== short test summary info ============================\nFAILED tests/test_queries.py::test_query_custom_scalar - TypeError: argument ...\n1 failed, 12 passed in 0.09s\n",
    "stderr": "",
    "exit_code": 1
  }
}

Aha! `test_query_custom_scalar` failed.

```
TypeError: argument of type 'function' is not iterable
```

This means `scalar_resolvers = resolvers.get(name, {})` returned a function instead of a dict.
This implies that some existing code in `ariadne` allows `resolvers[name]` to be a function (the serializer itself) instead of a dictionary of resolvers.

Let's look at `tests/test_queries.py` to see how `resolvers` is defined in `test_query_custom_scalar`.

{
  "end_line": 50,
  "filepath": "tests/test_queries.py",
  "start_line": 25
}

{
  "status": "ok",
  "filepath": "tests/test_queries.py",
  "content": "def test_query_custom_scalar():\n    type_defs = \"\"\"\n        scalar Date\n\n        type Query {\n            test: Date\n        }\n    \"\"\"\n\n    resolvers = {\n        \"Query\": {\"test\": lambda *_: date.today()},\n        \"Date\": lambda date: date.strftime(\"%Y-%m-%d\"),\n    }\n\n    schema = make_executable_schema(type_defs, resolvers)\n\n    result = graphql(schema, \"{ test }\")\n    assert result.errors is None\n    assert result.data == {\"test\": date.today().strftime(\"%Y-%m-%d\")}\n\n\ndef test_query_custom_type_default_resolver():\n    type_defs = \"\"\"\n        type Query {\n            test: Custom\n        }",
  "start_line": 25,
  "end_line": 50,
  "total_lines": 220,
  "is_truncated": false
}