mirumee__ariadne-24

The user wants to add support for `parse_value` and `parse_literal` in `add_resolve_functions_to_schema` (or maybe they meant `add_resolve_functions_to_scalar` or `make_executable_schema` via resolve functions). The problem statement mentions `add_resolve_functions_to_schema` and then mentions `add_resolve_functions_to_scalar`. Let's check the code to find these functions.

The goal is to allow custom scalars to not only serialize (Python -> JSON) but also parse values (JSON -> Python) and parse literals (AST -> Python).

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

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

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

Okay, `add_resolve_functions_to_schema` is in `ariadne/resolvers.py`.
Wait, the problem statement mentions `add_resolve_functions_to_scalar`. Let me search for that specifically.

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

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

It seems `add_resolve_functions_to_scalar` doesn't exist. The user probably meant the logic inside `add_resolve_functions_to_schema` that handles scalars.

Let's read `ariadne/resolvers.py` and `ariadne/executable_schema.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
}

Ah, I found it. It's `add_resolve_function_to_scalar` (singular `function`).
Wait, look at `add_resolve_function_to_scalar` implementation:

```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 typed as `GraphQLObjectType` but it's called when `type_object` is `GraphQLScalarType`. That's a type hint error. Also it only currently handles `serialize`.

It should also handle `parse_value` and `parse_literal`.

Let's check `graphql-core` (which ariadne uses) `GraphQLScalarType` properties.
Usually, `GraphQLScalarType` has `serialize`, `parse_value`, and `parse_literal`.

Let's verify what `GraphQLScalarType` takes.

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

So `resolvers` in `add_resolve_functions_to_schema` can be a dict where keys are type names and values are either a callable (for object resolvers, though the current code does `type_resolver = resolvers.get(name, {})` so it expects a dict for objects) or another dict.

Wait, `add_resolve_functions_to_object` does:
```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
```
If `resolvers[name]` is a callable, `.get()` on it will fail if it's not a dict. But in `add_resolve_functions_to_schema`, it calls `add_resolve_functions_to_object` and `add_resolve_function_to_scalar`.

If `resolvers = {"User": lambda p, i: p.user}`, then `resolvers.get("User", {})` returns the lambda, and `type_resolver.get(field_name)` will fail because the lambda is not a dict.

BUT, the current code for scalars is:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
If `resolvers["Scalar"]` is a callable, `serializer` becomes that callable.
If `resolvers["Scalar"]` is a dict, `serializer` becomes that dict.
Then `obj.serialize = serializer` sets the `serialize` property of the scalar to that dict! That can't be right if it's a dict.

Wait, if the user provides `{'Scalar': {'serialize': lambda x: x}}`, then `resolvers.get('Scalar', obj.serialize)` returns `{'serialize': lambda x: x}`, and `obj.serialize` becomes that dict. This is definitely wrong if they intended to provide multiple scalar functions.

Looking at the problem statement:
- `type_defs = {'Scalar': {'serialize': callable}}`
Actually, they used `type_defs` but the variable in the code is `resolvers`.

If `resolvers = {'Scalar': {'serialize': some_func}}`, then `add_resolve_function_to_scalar` does `obj.serialize = {'serialize': some_func}`. This is probably NOT what was intended.

Actually, let's see how `GraphQLScalarType` is handled in `graphql-core`.
`GraphQLScalarType` is initialized with `serialize`, `parse_value`, and `parse_literal`.
If `add_resolve_function_to_scalar` wants to support these, it should check if `resolvers.get(name)` is a dict.

If `resolvers.get(name)` is a callable, it should probably be used as the `serialize` function.
If `resolvers.get(name)` is a dict, it should use the values of `serialize`, `parse_value`, and `parse_literal` keys if they exist.

Wait, let's look at the current implementation of `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[name]` is a callable, `obj.serialize` becomes that callable.
If `resolvers[name]` is a dict, `obj.serialize` becomes that dict. This is wrong.

The problem statement says:
"Code below results in one-way only scalar:
- `type_defs = {'Scalar': {'serialize': callable}}`"
Actually, if this "results in one-way only scalar", it means the current implementation is actually BUGGY or does something I'm not seeing.

Wait, if `resolvers = {'Scalar': {'serialize': callable}}`, and the current code does `obj.serialize = {'serialize': callable}`, then when `graphql-core` tries to serialize, it calls the dict instead of the callable, which will raise a `TypeError`.

Maybe the user is saying that they CURRENTLY only support `serialize` (if passed as a callable directly) but they WANT to support a dict for scalars.

Let's test this. I'll create a reproduction script. I need to know how to use `ariadne` to build a schema.
`ariadne.executable_schema` uses `add_resolve_functions_to_schema`.

{
  "command": "cat <<'PY' > /tmp/repro.py\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLSchema, GraphQLScalarType\n\n# Mocking the schema building process\ntype_defs = \"\"\"\n    scalar MyScalar\n    type Query {\n        foo: MyScalar\n    }\n\"\"\"\n\nschema = make_executable_schema(type_defs)\nscalars = {\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, scalars)\n\n# Test serialization\nscalar_type = schema.get_type('MyScalar')\nprint(f\"Type: {type(scalar_type)}\")\nprint(f\"Serialize func: {scalar_type.serialize}\")\n\ntry:\n    print(f\"Serialization result: {scalar_type.serialize('test', None)}\")\nexcept Exception as e:\n    print(f\"Serialization failed: {e}\")\n\nPY\npython3 /tmp/repro.py\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "Traceback (most recent call last):\n  File \"/tmp/repro.py\", line 12, in <module>\n    schema = make_executable_schema(type_defs)\nTypeError: make_executable_schema() missing 1 required positional argument: 'resolvers'\n",
  "details": {
    "stdout": "",
    "stderr": "Traceback (most recent call last):\n  File \"/tmp/repro.py\", line 12, in <module>\n    schema = make_executable_schema(type_defs)\nTypeError: make_executable_schema() missing 1 required positional argument: 'resolvers'\n",
    "exit_code": 1
  }
}

My mistake, `make_executable_schema` requires `resolvers`.

{
  "command": "cat <<'PY' > /tmp/repro.py\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLSchema, GraphQLScalarType\n\ntype_defs = \"\"\"\n    scalar MyScalar\n    type Query {\n        foo: MyScalar\n    }\n\"\"\"\n\nresolvers = {\n    'Query': {\n        'foo': lambda [parent, info]: \"test value\"\n    }\n}\n\nschema = make_executable_schema(type_defs, resolvers)\n\nscalar_resolvers = {\n    'MyScalar': {\n        'serialize': lambda v, parent, info: f\"serialized({v})\",\n        'parse_value': lambda v: f\"parsed_value({v})\",\n        'parse_literal': lambda v, ast: f\"parsed_literal({v})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, scalar_resolvers)\n\nscalar_type = schema.get_type('MyScalar')\nprint(f\"Serialize func: {scalar_type.serialize}\")\n\ntry:\n    # GraphQLScalarType.serialize(value, parent, info)\n    print(f\"Serialization result: {scalar_type.serialize('test', None, None)}\")\nexcept Exception as e:\n    print(f\"Serialization failed: {e}\")\nPY\npython3 /tmp/repro.py\n"
}

{
  "status": "error",
  "error_type": "CommandError",
  "error_message": "  File \"/tmp/repro.py\", line 13\n    'foo': lambda [parent, info]: \"test value\"\n                  ^\nSyntaxError: invalid syntax\n",
  "details": {
    "stdout": "",
    "stderr": "  File \"/tmp/repro.py\", line 13\n    'foo': lambda [parent, info]: \"test value\"\n                  ^\nSyntaxError: invalid syntax\n",
    "exit_code": 1
  }
}

Python lambda doesn't support destructuring in arguments like that. I should use `lambda parent, info: "test value"`.

Corrected reproduction script:

{
  "command": "cat <<'PY' > /tmp/repro.py\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLSchema, GraphQLScalarType\n\ntype_defs = \"\"\"\n    scalar MyScalar\n    type Query {\n        foo: MyScalar\n    }\n\"\"\"\n\nresolvers = {\n    'Query': {\n        'foo': lambda parent, info: \"test value\"\n    }\n}\n\nschema = make_executable_schema(type_defs, resolvers)\n\nscalar_resolvers = {\n    'MyScalar': {\n        'serialize': lambda v, parent, info: f\"serialized({v})\",\n        'parse_value': lambda v: f\"parsed_value({v})\",\n        'parse_literal': lambda v, ast: f\"parsed_literal({v})\",\n    }\n}\n\nadd_resolve_functions_to_schema(schema, scalar_resolvers)\n\nscalar_type = schema.get_type('MyScalar')\nprint(f\"Serialize func: {scalar_type.serialize}\")\n\ntry:\n    # GraphQLScalarType.serialize(value, parent, info)\n    print(f\"Serialization result: {scalar_type.serialize('test', None, None)}\")\nexcept Exception as e:\n    print(f\"Serialization failed: {e}\")\n\nprint(f\"Parse value func: {scalar_type.parse_value}\")\ntry:\n    print(f\"Parse value result: {scalar_type.parse_value('test')}\")\nexcept Exception as e:\n    print(f\"Parse value failed: {e}\")\n\nprint(f\"Parse literal func: {scalar_type.parse_literal}\")\ntry:\n    # parse_literal receives the AST node. We just pass None for now.\n    print(f\"Parse literal result: {scalar_type.parse_literal(None)}\")\nexcept Exception as e:\n    print(f\"Parse literal failed: {e}\")\nPY\npython3 /tmp/repro.py\n"
}

{
  "status": "ok",
  "stdout": "Serialize func: {'serialize': <function <lambda> at 0x78ace4f57200>, 'parse_value': <function <lambda> at 0x78ace4f57320>, 'parse_literal': <function <lambda> at 0x78ace3e56ef0>}\nSerialization failed: 'dict' object is not callable\nParse value func: <function _false at 0x78ace3ec1b00>\nParse value result: False\nParse literal func: <function _false at 0x78ace3ec1b00>\nParse literal result: False\n",
  "stderr": "",
  "exit_code": 0
}

Confirmed!
1. `scalar_type.serialize` became the whole dict `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`.
2. `scalar_type.parse_value` and `scalar_type.parse_literal` remained the default (which seems to be a function called `_false` in `graphql-core` that returns `False`).

So `add_resolve_function_to_scalar` currently just does:
```python
def add_resolve_function_to_scalar(name: str, obj: GraphQLObjectType, resolvers: dict):
    serializer = resolvers.get(name, obj.serialize)
    obj.serialize = serializer
```
And it should be updated to handle both a callable (for `serialize`) and a dict (for `serialize`, `parse_value`, `parse_literal`).

Let's fix `ariadne/resolvers.py`. I should also fix the type hint for `obj` in `add_resolve_function_to_scalar`. It should be `GraphQLScalarType`.

Wait, let's check `ariadne/resolvers.py` imports. It has `GraphQLScalarType`.

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

I will 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)
    elif callable(scalar_resolvers):
        obj.serialize = scalar_resolvers
```

Wait, if `scalar_resolvers` is `None` (meaning `resolvers.get(name)` returns None), then `isinstance(None, dict)` is False and `callable(None)` is False. Nothing changes, which is correct.

Let's double check the logic if `resolvers[name]` is a callable.
The user said:
- `type_defs = {'Scalar': {'serialize': callable}}` -> one-way only (currently)
- `type_defs = {'Scalar': {'serialize': callable, 'parse_value': callable, 'parse_literal': callable}}` -> two-way (requested)

But they also implied that just providing `serialize` might be enough.

Wait, 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)
    elif callable(scalar_resolvers):
        obj.serialize = scalar_resolvers
```
This covers:
1. `resolvers['MyScalar'] = some_func` -> `obj.serialize = some_func`. (Shorthand for serialize)
2. `resolvers['MyScalar'] = {'serialize': f1, 'parse_value': f2, 'parse_literal': f3}` -> all three are set.
3. `resolvers['MyScalar'] = {'parse_value': f2}` -> only `parse_value` is set.

This looks correct and covers all requested use cases.

Let's verify that `GraphQLScalarType` has `serialize`, `parse_value`, and `parse_literal` attributes. Yes, it does in `graphql-core`.

Checking `ariadne/resolvers.py` again.

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

Wait, `GraphQLScalarType` is imported.

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 callable(scalar_resolvers):\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"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -34,6 +34,12 @@\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 callable(scalar_resolvers):\n+        obj.serialize = scalar_resolvers\n+\n",
  "is_truncated": false
}

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

{
  "command": "python3 /tmp/repro.py"
}

{
  "status": "ok",
  "stdout": "Serialize func: {'serialize': <function <lambda> at 0x71c682095200>, 'parse_value': <function <lambda> at 0x71c682095320>, 'parse_literal': <function <lambda> at 0x71c680f94ef0>}\nSerialization failed: 'dict' object is not callable\nParse value func: <function _false at 0x71c680fffb00>\nParse value result: False\nParse literal func: <function _false at 0x71c680fffb00>\nParse literal result: False\n",
  "stderr": "",
  "exit_code": 0
}

Wait! The output is exactly the same as before!
Wait, look at the output:
`Serialize func: {'serialize': <function <lambda> at 0x71c682095200>, 'parse_value': <function <lambda> at 0x71c682095320>, 'parse_literal': <function <lambda> at 0x71c680f94ef0>}`
`Serialization failed: 'dict' object is not callable`

This means `scalar_type.serialize` is STILL the dict.
Why?

Ah, I see. In my reproduction script I did:
```python
scalar_resolvers = {
    'MyScalar': {
        'serialize': lambda v, parent, info: f"serialized({v})",
        'parse_value': lambda v: f"parsed_value({v})",
        'parse_literal': lambda v, ast: f"parsed_literal({v})",
    }
}

add_resolve_functions_to_schema(schema, scalar_resolvers)
```

And `add_resolve_functions_to_schema` does:
```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)
```

Everything looks right. Why didn't it work?

Wait! I suspect I might have edited the file but something is wrong.
Let me check the file content of `ariadne/resolvers.py`.

{
  "filepath": "ariadne/resolvers.py",
  "start_line": 30
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "content": "def 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: 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 callable(scalar_resolvers):\n        obj.serialize = scalar_resolvers\n",
  "start_line": 30,
  "end_line": 45,
  "total_lines": 45,
  "is_truncated": false
}

The file is correctly edited.
Why did the repro script fail?

Wait, I might have misread the output of the repro script.
`Serialize func: {'serialize': <function <lambda> ...}`
YES, `scalar_type.serialize` is still the dict.
But wait, `scalar_type` is `scalar_type = schema.get_type('MyScalar')`.

Is it possible that `schema.get_type_map().items()` does not contain `MyScalar`?
No, it should.

Wait, I know! In `make_executable_schema`, if I pass `resolvers` there, it calls `add_resolve_functions_to_schema` inside it.
Let's check `ariadne/executable_schema.py`.

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

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

`make_executable_schema` calls `add_resolve_functions_to_schema(schema, resolvers)`.

In my repro script:
```python
resolvers = {
    'Query': {
        'foo': lambda parent, info: "test value"
    }
}

schema = make_executable_schema(type_defs, resolvers)

scalar_resolvers = {
    'MyScalar': {
        'serialize': lambda v, parent, info: f"serialized({v})",
        'parse_value': lambda v: f"parsed_value({v})",
        'parse_literal': lambda v, ast: f"parsed_literal({v})",
    }
}

add_resolve_functions_to_schema(schema, scalar_resolvers)
```

Wait! I'm calling `add_resolve_functions_to_schema` TWICE.
The first time (inside `make_executable_schema`), `resolvers` only has `Query`.
The second time, `scalar_resolvers` only has `MyScalar`.

Wait, the `add_resolve_function_to_scalar` should have been called the second time.

Let me look at the `Serialize func` output again:
`Serialize func: {'serialize': <function <lambda> at 0x71c682095200>, 'parse_value': <function <lambda> at 0x71c682095320>, 'parse_literal': <function <lambda> at 0x71c680f94ef0>}`

This IS the `scalar_resolvers['MyScalar']` dict!
But my code is:
```python
    if isinstance(scalar_resolvers, dict):
        obj.serialize = scalar_resolvers.get('serialize', obj.serialize)
```

If `scalar_resolvers` is `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`, then `scalar_resolvers.get('serialize', obj.serialize)` should return the lambda function, NOT the whole dict.

Wait... Unless `scalar_resolvers` is NOT what I think it is.

Wait! I see it!
In my repro script:
```python
scalar_resolvers = {
    'MyScalar': {
        'serialize': lambda v, parent, info: f"serialized({v})",
        'parse_value': lambda v: f"parsed_value({v})",
        'parse_literal': lambda v, ast: f"parsed_literal({v})",
    }
}
```
Inside `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)
```
And `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 callable(scalar_resolvers):
        obj.serialize = scalar_resolvers
```

When `type_name` is `'MyScalar'`, `resolvers.get('MyScalar')` should return the dict `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`.
Then `scalar_resolvers.get('serialize', obj.serialize)` should return the lambda.

Why is `scalar_type.serialize` showing as the whole dict?

Wait... I might be running an old version of the code? No, I just edited it.

Wait! I just realized something.
I'm using `python3 /tmp/repro.py`.

Could it be that `GraphQLScalarType` in `graphql-core` does NOT allow setting `serialize`, `parse_value`, `parse_literal` as properties?
No, they are usually just attributes on the instance.

Wait! Let's look at the output again.
`Serialize func: {'serialize': <function <lambda> at 0x71c682095200>, 'parse_value': <function <lambda> at 0x71c682095320>, 'parse_literal': <function <lambda> at 0x71c680f94ef0>}`

Is it possible that `add_resolve_function_to_scalar` is NOT being called for `MyScalar`?
If it wasn't called, `scalar_type.serialize` should be the default.
But the default for `GraphQLScalarType` is not that dict.

Hold on... I think I know what's happening.
I am calling `add_resolve_functions_to_schema` and it iterates over `schema.get_type_map().items()`.

Let's print `type_name` inside `add_resolve_functions_to_schema` to see what's happening.

Actually, let me just simplify the repro script and print everything.

{
  "command": "cat <<'PY' > /tmp/repro.py\nfrom ariadne import make_executable_schema, add_resolve_functions_to_schema\nfrom graphql import GraphQLSchema, GraphQLScalarType, GraphQLObjectType\n\ntype_defs = \"\"\"\n    scalar MyScalar\n    type Query {\n        foo: MyScalar\n    }\n\"\"\"\n\nresolvers = {\n    'Query': {\n        'foo': lambda parent, info: \"test value\"\n    }\n}\n\nschema = make_executable_schema(type_defs, resolvers)\n\n# Let's see what types are in the schema\nprint(\"Types in schema:\", schema.get_type_map().keys())\n\nscalar_resolvers = {\n    'MyScalar': {\n        'serialize': lambda v, parent, info: f\"serialized({v})\",\n        'parse_value': lambda v: f\"parsed_value({v})\",\n        'parse_literal': lambda v, ast: f\"parsed_literal({v})\",\n    }\n}\n\nprint(\"Applying scalar resolvers...\")\nadd_resolve_functions_to_schema(schema, scalar_resolvers)\n\nscalar_type = schema.get_type('MyScalar')\nprint(f\"Scalar type: {scalar_type}\")\nprint(f\"Serialize func: {scalar_type.serialize}\")\n\ntry:\n    print(f\"Serialization result: {scalar_type.serialize('test', None, None)}\")\nexcept Exception as e:\n    print(f\"Serialization failed: {e}\")\n\nprint(f\"Parse value func: {scalar_type.parse_value}\")\ntry:\n    print(f\"Parse value result: {scalar_type.parse_value('test')}\")\nexcept Exception as e:\n    print(f\"Parse value failed: {e}\")\n\nprint(f\"Parse literal func: {scalar_type.parse_literal}\")\ntry:\n    print(f\"Parse literal result: {scalar_type.parse_literal(None)}\")\nexcept Exception as e:\n    print(f\"Parse literal failed: {e}\")\nPY\npython3 /tmp/repro.py\n"
}

{
  "status": "ok",
  "stdout": "Types in schema: odict_keys(['Query', 'MyScalar', '__Schema', '__Type', '__TypeKind', 'String', 'Boolean', '__Field', '__InputValue', '__EnumValue', '__Directive', '__DirectiveLocation'])\nApplying scalar resolvers...\nScalar type: MyScalar\nSerialize func: {'serialize': <function <lambda> at 0x73187b334200>, 'parse_value': <function <lambda> at 0x73187b334320>, 'parse_literal': <function <lambda> at 0x73187a235ef0>}\nSerialization failed: 'dict' object is not callable\nParse value func: <function _false at 0x73187a29fb00>\nParse value result: False\nParse literal func: <function _false at 0x73187a29fb00>\nParse literal result: False\n",
  "stderr": "",
  "exit_code": 0
}

This is insane. It's STILL happening.
Symmetry:
`Serialize func` is the dict.
`Parse value func` is `_false`.
`Parse literal func` is `_false`.

Wait... ONLY `serialize` is being set to the dict.
`parse_value` and `parse_literal` are NOT being set!

This means:
```python
        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)
```
is NOT being executed as expected, OR `scalar_resolvers` is not what I think it is.

Wait! If `obj.serialize` is the dict, and it was set by `obj.serialize = scalar_resolvers.get('serialize', obj.serialize)`, it means `scalar_resolvers.get('serialize', obj.serialize)` returned the dict.

But `scalar_resolvers` IS the dict `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`.
So `scalar_resolvers.get('serialize', ...)` should return the lambda.

Unless... I am not editing the file I think I am editing?
No, `read_file` showed the change.

Could it be a caching issue? No, Python doesn't cache modules like that in a script.

Wait! I HAVE AN IDEA.
What if `add_resolve_function_to_scalar` is being called with `resolvers` as the `scalar_resolvers` dict, but something is weird?

Let's look at the code again.
```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)
```

If `type_name` is `'MyScalar'`, `resolvers.get('MyScalar')` is called.
`resolvers` is `{'MyScalar': {'serialize': ..., 'parse_value': ..., 'parse_literal': ...}}`.
So `scalar_resolvers` is `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`.

SUDDEN REALIZATION:
I am calling `add_resolve_functions_to_schema` TWICE.
The first time is `make_executable_schema(type_defs, resolvers)`.
Wait, in `make_executable_schema`:
```python
def make_executable_schema(
    type_defs: Union[str, List[str]], resolvers: dict
) -> GraphQLSchema:
    schema = build_schema_from_type_definitions(type_defs)
    add_resolve_functions_to_schema(schema, resolvers)
    return schema
```
The `resolvers` passed to `make_executable_schema` only had `Query`.

The second time:
```python
scalar_resolvers = {
    'MyScalar': {
        'serialize': lambda v, parent, info: f"serialized({v})",
        'parse_value': lambda v: f"parsed_value({v})",
        'parse_literal': lambda v, ast: f"parsed_literal({v})",
    }
}
add_resolve_functions_to_schema(schema, scalar_resolvers)
```
In the second call, `resolvers` is `scalar_resolvers`.
`type_name` is `'MyScalar'`.
`resolvers.get('MyScalar')` returns the dict.

Then why the heck is `obj.serialize` becoming the dict AND `obj.parse_value` remaining `_false`?

If `obj.serialize = scalar_resolvers.get('serialize', obj.serialize)` set `obj.serialize` to the dict, it must mean `scalar_resolvers.get('serialize', obj.serialize)` returned the dict.
Which means `scalar_resolvers` was NOT the dict I think it was, but rather something that when `.get('serialize')` is called, returns itself? No, that's not possible for a dict.

WAIT! I know what's happening!
I'm looking at the `Serialize func` output:
`Serialize func: {'serialize': <function <lambda> at 0x73187b334200>, 'parse_value': <function <lambda> at 0x73187b334320>, 'parse_literal': <function <lambda> at 0x73187a235ef0>}`

This is EXACTLY the `scalar_resolvers['MyScalar']` dict.

If `obj.serialize` is this dict, and it was set by `obj.serialize = scalar_resolvers.get('serialize', obj.serialize)`, then `scalar_resolvers.get('serialize', obj.serialize)` must have returned the dict.

If `scalar_resolvers` is the dict `{'serialize': ..., 'parse_value': ..., 'parse_literal': ...}`, then `.get('serialize')` returns the lambda.

The only way `scalar_resolvers.get('serialize', obj.serialize)` returns the dict is if:
1. `scalar_resolvers` is NOT the dict `{'serialize': ...}` but instead something else.
2. `obj.serialize` was already the dict, and `.get('serialize')` returned `None`.

BUT `scalar_resolvers` IS `resolvers.get(name)`.

WAIT! I THINK I FOUND THE BUG IN MY HEAD.
What if `add_resolve_function_to_scalar` is NOT the function being called?
But it is! I just read the file.

Let's add print statements to `ariadne/resolvers.py` to see what's happening!

{
  "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    print(f\"DEBUG: name={name}, scalar_resolvers={scalar_resolvers}\")\n    if isinstance(scalar_resolvers, dict):\n        print(f\"DEBUG: is dict. serialize={scalar_resolvers.get('serialize')}\")\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 callable(scalar_resolvers):\n        print(f\"DEBUG: is callable\")\n        obj.serialize = scalar_resolvers\n",
  "old_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 callable(scalar_resolvers):\n        obj.serialize = scalar_resolvers\n"
}

{
  "status": "ok",
  "filepath": "ariadne/resolvers.py",
  "occurrences": 1,
  "strategy": "exact",
  "diff": "--- a/ariadne/resolvers.py\n+++ b/ariadne/resolvers.py\n@@ -36,10 +36,13 @@\n \n def add_resolve_function_to_scalar(name: str, obj: GraphQLScalarType, resolvers: dict):\n     scalar_resolvers = resolvers.get(name)\n+    print(f\"DEBUG: name={name}, scalar_resolvers={scalar_resolvers}\")\n     if isinstance(scalar_resolvers, dict):\n+        print(f\"DEBUG: is dict. serialize={scalar_resolvers.get('serialize')}\")\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 callable(scalar_resolvers):\n+        print(f\"DEBUG: is callable\")\n         obj.serialize = scalar_resolvers\n \n",
  "is_truncated": false
}