How can I handle long Int with GraphQL?

user_7844349 0
Viewed 29001

As you know that GraphQL has no data type like long int. So, whenever the number is something big like 10000000000, it throws an error like this: Int cannot represent non 32-bit signed integer value: 1000000000000

For that I know two solutions:

  1. Use scalars.
import { GraphQLScalarType } from 'graphql';
import { makeExecutableSchema } from '@graphql-tools/schema';

const myCustomScalarType = new GraphQLScalarType({
  name: 'MyCustomScalar',
  description: 'Description of my custom scalar type',
  serialize(value) {
    let result;
    return result;
  },
  parseValue(value) {
    let result;
    return result;
  },
  parseLiteral(ast) {
    switch (ast.kind) {
    }
  }
});

const schemaString = `

scalar MyCustomScalar

type Foo {
  aField: MyCustomScalar
}

type Query {
  foo: Foo
}

`;

const resolverFunctions = {
  MyCustomScalar: myCustomScalarType
};

const jsSchema = makeExecutableSchema({
  typeDefs: schemaString,
  resolvers: resolverFunctions,
});
  1. Use apollo-type-bigint package.

Both of those solutions convert the big int to string, and I'd rather not use string (I prefer a number type).

graphql node.js bigint javascript
4 Answers

Correct, there's no concept like bigInt in graphQL.

You can try one of these:

  1. Set type as Float instead of Int - it will handle all large int values and also send them as number [below are technically options, although you stated you don't like string solutions]
  2. Set type as String, as you described
  3. Give (an npm-provided data type, like) BigInt, as you described. It will handle big int, but will convert your values into string

npm BigInt dependency with Graphql v16 support:

user_86029400

Graphql has introduced Scalars. I am using Java and so I can provide some solution in Java. You can achieve the same by following the below steps.

in your .graphqls file please define scalar

scalar Long

type Movie{
movieId: String
movieName: String
producer: String
director: String
demoId : Long
}

Now you have to register this scalar in your wiring.

return RuntimeWiring.newRuntimeWiring().type("Query", typeWiring -> typeWiring
                .dataFetcher("allMovies", allMoviesDataFetcher).dataFetcher("movie", movieDataFetcher)
                .dataFetcher("getMovie", getMovieDataFetcher)).scalar(ExtendedScalars.GraphQLLong).build();

Now you have to define the Scalar configuration for Long as below.


@Configuration
public class LongScalarConfiguration {
     @Bean
        public GraphQLScalarType longScalar() {
            return GraphQLScalarType.newScalar()
                .name("Long")
                .description("Java 8 Long as scalar.")
                .coercing(new Coercing<Long, String>() {
                    @Override
                    public String serialize(final Object dataFetcherResult) {
                        if (dataFetcherResult instanceof Long) {
                            return dataFetcherResult.toString();
                        } else {
                            throw new CoercingSerializeException("Expected a Long object.");
                        }
                    }

                    @Override
                    public Long parseValue(final Object input) {
                        try {
                            if (input instanceof String) {
                                return new Long((String) input);
                            } else {
                                throw new CoercingParseValueException("Expected a String");
                            }
                        } catch (Exception e) {
                            throw new CoercingParseValueException(String.format("Not a valid Long: '%s'.", input), e
                            );
                        }
                    }

                    @Override
                    public Long parseLiteral(final Object input) {
                        if (input instanceof StringValue) {
                            try {
                                return new Long(((StringValue) input).getValue());
                            } catch (Exception e) {
                                throw new CoercingParseLiteralException(e);
                            }
                        } else {
                            throw new CoercingParseLiteralException("Expected a StringValue.");
                        }
                    }
                }).build();
        }

}

It should solve your problem. Please give it a try for Java related application.

user_61649870

I would recommend using graphql-bigint package in this case. This implementation gives you 53-bit integers. Any integer-like number above 52bit will have it's lower values truncated. So if you need it above 52bit, using strings would be safer.

user_58625070

There is not BigInt in graphql/apollo but you can make your custom scalar to support this.

const typeDef = gql`
  scalar BigInt
  type Mutation {
    .....
  }
`

If you are using typescript you can add the declare, or omit it if js.

declare global {
  interface BigInt {
    toJSON: () => number;
    fromJSON: () => BigInt;
  }
}

BigInt.prototype.toJSON = function () {
  const int = Number.parseInt(this.toString());
  return int ?? this.toString();
};

BigInt.prototype.fromJSON = function () {
  return BigInt(this.toString());
};
user_81453320
Related