Custom scalar args broken as query variables after schema transform

[AndKiel]

Given:

• Custom ScalarType X with a class representing it internally
• Query or Mutation with an argument of ScalarType X
• Any schema transforms

When:

• Required argument of ScalarType X is passed as query variable ($argScalar) instead of inline value inside the query

Then:

• Weird stuff happens, see the reproduction and results

Minimalistic reproduction:

import { ApolloServer } from "apollo-server-express";
import { createTestClient } from "apollo-server-testing";
import { GraphQLScalarType, GraphQLSchema, Kind } from "graphql";
import { GraphQLResponse } from "graphql-extensions";
import { FilterRootFields, transformSchema } from "graphql-tools-fork";
import {
  Arg,
  buildSchemaSync,
  Query,
  Resolver
} from "type-graphql";

function createTestSchema(): GraphQLSchema {
  class MyCustomScalar {
    private readonly prefix = "Xxx-";

    constructor(private value: string) {}

    public encode(): string {
      return this.prefix + this.value;
    }

    public static parse(value: string): MyCustomScalar {
      if (typeof value === "string") return new MyCustomScalar(value.slice(4));
      console.log("-> inside .parse", typeof value, value);
      throw new Error("SOMETHING WENT WRONG! SHOULD NEVER HAPPEN!");
    }
  }

  const MyCustomScalarType = new GraphQLScalarType({
    name: "MyCustomScalar",
    parseValue: (value: string): MyCustomScalar => {
      console.log("-> inside .parseValue", typeof value, value);
      return MyCustomScalar.parse(value)
    },
    serialize: (value: MyCustomScalar): string => {
      console.log("-> inside .serialize");
      return value.encode()
    },
    parseLiteral: (ast): MyCustomScalar | undefined => {
      console.log("-> inside .parseLiteral");
      if (ast.kind === Kind.STRING) {
        return MyCustomScalar.parse(ast.value)
      }
      return undefined;
    }
  });

  @Resolver()
  class MyTestResolver {
    @Query()
    public queryWithScalarArg(@Arg("id") id: MyCustomScalar): MyCustomScalar {
      return id;
    }
  }

  return buildSchemaSync({
    resolvers: [MyTestResolver],
    scalarsMap: [
      {
        type: MyCustomScalar,
        scalar: MyCustomScalarType
      }
    ]
  });
}

function execute(schema: GraphQLSchema, query: string, variables?: { [name: string]: any }): Promise<GraphQLResponse> {
  const server = new ApolloServer({ schema });
  return createTestClient(server).query({ query, variables });
}

const schema = createTestSchema();
const transformedSchema = transformSchema(schema, [new FilterRootFields((_operation, _fieldName, _field) => true)]);

describe("schema transformation", () => {
  it("preserves custom scalars on arguments when variables are used", async () => {
    const scalarValue = "Xxx-scalarValue";
    const query = "query MyTestQuery($argScalar: MyCustomScalar!) { result: queryWithScalarArg(id: $argScalar) }";
    const variables = { argScalar: scalarValue };
    console.log("> executing query on original schema");
    const response = await execute(schema, query, variables);
    console.log("> executing query on transformed schema");
    const transformedResponse = await execute(transformedSchema, query, variables);

    expect(transformedResponse).toEqual(response);
    expect(transformedResponse.errors).toBeUndefined();
    expect(transformedResponse.data).toEqual({
      result: scalarValue
    });
  });
});

Expectation:

- Expected
+ Received

-   "data": Object {
-     "result": "Xxx-scalarValue",
-   },
-   "errors": undefined,
+   "data": null,
+   "errors": Array [
+     [GraphQLError: Variable "$argScalar" got invalid value { value: "scalarValue", prefix: "Xxx-" }; Expected type MyCustomScalar. SOMETHING WENT WRONG! SHOULD NEVER HAPPEN!],
+   ],

What is being logged:

    > executing query on original schema
    -> inside .parseValue string Xxx-scalarValue
    -> inside .serialize
    > executing query on transformed schema
    -> inside .parseValue string Xxx-scalarValue
    -> inside .parseValue object MyCustomScalar { value: 'scalarValue', prefix: 'Xxx-' }
    -> inside .parse object MyCustomScalar { value: 'scalarValue', prefix: 'Xxx-' }

[yaacovCR]

Thanks for great reproduction!

[yaacovCR]

My guess is that it is because I am passing an empty object to delegateToSchema rather than the args here:

https://github.com/yaacovCR/graphql-tools-fork/blob/master/src/stitching/resolvers.ts#L114

I did that because args are unchanged, but I forgot that any custom stuff needs to be reserialized. This should get better covered by tests if indeed the cause.

[AndKiel]

@yaacovCR, thanks, the fix is working, my tests are passing.
But I see that some graphql-tools-fork tests are failing due to incompatible types. Hopefully, nothing really broke and maybe the typings are incorrect.

[yaacovCR]

Saw that too, was not on my personal set up, I'm thinking it has to do with latest update to graphql. Will have to check later with a clean install with the latest updates of all packages

[yaacovCR]

graphql/graphql-js#2104

[yaacovCR]

Fixed.