Custom scalars

The GraphQL specification includes default scalar types Int, Float, String, Boolean, and ID. Although these scalars cover the majority of use cases, some applications need to support other atomic data types (such as Date) or add validation to an existing type. To enable this, you can define custom scalar types.

Defining a custom scalar

To define a custom scalar, add it to your schema like so:

1scalar MyCustomScalar

You can now use MyCustomScalar in your schema anywhere you can use a default scalar (e.g., as the type of an object field, input type field, or argument).

However, Apollo Server still needs to know how to interact with values of this new scalar type.

Defining custom scalar logic

After you define a custom scalar type, you need to define how Apollo Server interacts with it. In particular, you need to define:

• How the scalar's value is represented in your backend

  • This is often the representation used by the driver for your backing data store.

• How the value's back-end representation is serialized to a JSON-compatible type

• How the JSON-compatible representation is deserialized to the back-end representation

You define these interactions in an instance of the GraphQLScalarType class.

For more information about the graphql library's type system, see the official documentation.

Example: The Date scalar

The following GraphQLScalarType object defines interactions for a custom scalar that represents a date (this is one of the most commonly implemented custom scalars). It assumes that our backend represents a date with the Date JavaScript object.

1const { GraphQLScalarType, Kind } = require('graphql');
2
3const dateScalar = new GraphQLScalarType({
4  name: 'Date',
5  description: 'Date custom scalar type',
6  serialize(value) {
7    return value.getTime(); // Convert outgoing Date to integer for JSON
8  },
9  parseValue(value) {
10    return new Date(value); // Convert incoming integer to Date
11  },
12  parseLiteral(ast) {
13    if (ast.kind === Kind.INT) {
14      return new Date(parseInt(ast.value, 10)); // Convert hard-coded AST string to integer and then to Date
15    }
16    return null; // Invalid hard-coded value (not an integer)
17  },
18});

This initialization defines the following methods:

• serialize

• parseValue

• parseLiteral

Together, these methods describe how Apollo Server interacts with the scalar in every scenario.

serialize

The serialize method converts the scalar's back-end representation to a JSON-compatible format so Apollo Server can include it in an operation response.

In the example above, the Date scalar is represented on the backend by the Date JavaScript object. When we send a Date scalar in a GraphQL response, we serialize it as the integer value returned by the getTime function of a JavaScript Date object.

Note that Apollo Client cannot automatically interpret custom scalars (see issue), so your client must define custom logic to deserialize this value as needed.

parseValue

The parseValue method converts the scalar's JSON value to its back-end representation before it's added to a resolver's args.

Apollo Server calls this method when the scalar is provided by a client as a GraphQL variable for an argument. (When a scalar is provided as a hard-coded argument in the operation string, parseLiteral is called instead.)

parseLiteral

When an incoming query string includes the scalar as a hard-coded argument value, that value is part of the query document's abstract syntax tree (AST). Apollo Server calls the parseLiteral method to convert the value's AST representation to the scalar's back-end representation.

In the example above, parseLiteral converts the AST value from a string to an integer, and then converts from integer to Date to match the result of parseValue.

Providing custom scalars to Apollo Server

After you define your GraphQLScalarType instance, you include it in the same resolver map that contains resolvers for your schema's other types and fields:

1const { ApolloServer, gql } = require('apollo-server');
2const {
3  ApolloServerPluginLandingPageLocalDefault,
4} = require('apollo-server-core');
5const { GraphQLScalarType, Kind } = require('graphql');
6
7const typeDefs = gql`
8  scalar Date
9
10  type Event {
11    id: ID!
12    date: Date!
13  }
14
15  type Query {
16    events: [Event!]
17  }
18`;
19
20const dateScalar = new GraphQLScalarType({
21  // See definition above
22});
23
24const resolvers = {
25  Date: dateScalar
26  // ...other resolver definitions...
27};
28
29const server = new ApolloServer({
30  typeDefs,
31  resolvers,
32  csrfPrevention: true,
33  cache: 'bounded',
34  plugins: [
35    ApolloServerPluginLandingPageLocalDefault({ embed: true }),
36  ],
37});

Example: Restricting integers to odd values

In this example, we create a custom scalar called Odd that can only contain odd integers:

1const { ApolloServer, gql, UserInputError } = require('apollo-server');
2const {
3  ApolloServerPluginLandingPageLocalDefault,
4} = require('apollo-server-core');
5const { GraphQLScalarType, Kind } = require('graphql');
6
7// Basic schema
8const typeDefs = gql`
9  scalar Odd
10
11  type Query {
12    # Echoes the provided odd integer
13    echoOdd(odd: Odd!): Odd!
14  }
15`;
16
17// Validation function for checking "oddness"
18function oddValue(value) {
19  if (typeof value === 'number' && Number.isInteger(value) && value % 2 !== 0) {
20    return value;
21  }
22  throw new UserInputError('Provided value is not an odd integer');
23}
24
25const resolvers = {
26  Odd: new GraphQLScalarType({
27    name: 'Odd',
28    description: 'Odd custom scalar type',
29    parseValue: oddValue,
30    serialize: oddValue,
31    parseLiteral(ast) {
32      if (ast.kind === Kind.INT) {
33        return oddValue(parseInt(ast.value, 10));
34      }
35      throw new UserInputError('Provided value is not an odd integer');
36    },
37  }),
38  Query: {
39    echoOdd(_, {odd}) {
40      return odd;
41    }
42  }
43};
44
45const server = new ApolloServer({
46  typeDefs,
47  resolvers,
48  csrfPrevention: true,
49  cache: 'bounded',
50  plugins: [
51    ApolloServerPluginLandingPageLocalDefault({ embed: true }),
52  ],
53});
54
55server.listen().then(({ url }) => {
56  console.log(`🚀 Server ready at ${url}`)
57});

Importing a third-party custom scalar

If another library defines a custom scalar, you can import it and use it just like any other symbol.

For example, the graphql-type-json package defines the GraphQLJSON object, which is an instance of GraphQLScalarType. You can use this object to define a JSON scalar that accepts any value that is valid JSON.

First, install the library:

1$ npm install graphql-type-json

Then require the GraphQLJSON object and add it to the resolver map as usual:

1const { ApolloServer, gql } = require('apollo-server');
2const {
3  ApolloServerPluginLandingPageLocalDefault,
4} = require('apollo-server-core');
5const GraphQLJSON = require('graphql-type-json');
6
7const typeDefs = gql`
8  scalar JSON
9
10  type MyObject {
11    myField: JSON
12  }
13
14  type Query {
15    objects: [MyObject]
16  }
17`;
18
19const resolvers = {
20  JSON: GraphQLJSON
21  // ...other resolvers...
22};
23
24const server = new ApolloServer({
25  typeDefs,
26  resolvers,
27  csrfPrevention: true,
28  cache: 'bounded',
29  plugins: [
30    ApolloServerPluginLandingPageLocalDefault({ embed: true }),
31  ],
32});
33
34server.listen().then(({ url }) => {
35  console.log(`🚀 Server ready at ${url}`)
36});