astFromValue - JavaScript BigInt support

src/jsutils/isInteger.ts

@@ -0,0 +1,7 @@
+export function isInteger(value: unknown): value is number | bigint {
+  const valueTypeOf = typeof value;
+  if (valueTypeOf === 'number') {
+    return Number.isInteger(value);
+  }
+  return valueTypeOf === 'bigint';
+}

src/jsutils/isNumeric.ts

@@ -0,0 +1,7 @@
+export function isNumeric(value: unknown): value is number | bigint {
+  const valueTypeOf = typeof value;
+  if (valueTypeOf === 'number') {
+    return Number.isFinite(value);
+  }
+  return valueTypeOf === 'bigint';
+}

src/type/scalars.ts

@@ -1,4 +1,6 @@
 import { inspect } from '../jsutils/inspect.js';
+import { isInteger } from '../jsutils/isInteger.js';
+import { isNumeric } from '../jsutils/isNumeric.js';
 import { isObjectLike } from '../jsutils/isObjectLike.js';
 
 import { GraphQLError } from '../error/GraphQLError.js';
@@ -38,7 +40,7 @@ export const GraphQLInt = new GraphQLScalarType<number>({
       num = Number(coercedValue);
     }
 
-    if (typeof num !== 'number' || !Number.isInteger(num)) {
+    if (!isInteger(num)) {
       throw new GraphQLError(
         `Int cannot represent non-integer value: ${inspect(coercedValue)}`,
       );
@@ -49,21 +51,22 @@ export const GraphQLInt = new GraphQLScalarType<number>({
           inspect(coercedValue),
       );
     }
-    return num;
+    return Number(num);
   },
 
   parseValue(inputValue) {
-    if (typeof inputValue !== 'number' || !Number.isInteger(inputValue)) {
+    if (!isInteger(inputValue)) {
       throw new GraphQLError(
         `Int cannot represent non-integer value: ${inspect(inputValue)}`,
       );
     }
-    if (inputValue > GRAPHQL_MAX_INT || inputValue < GRAPHQL_MIN_INT) {
+    const coercedVal = Number(inputValue);
+    if (coercedVal > GRAPHQL_MAX_INT || coercedVal < GRAPHQL_MIN_INT) {
       throw new GraphQLError(
         `Int cannot represent non 32-bit signed integer value: ${inputValue}`,
       );
     }
-    return inputValue;
+    return coercedVal;
   },
 
   parseLiteral(valueNode) {
@@ -84,7 +87,7 @@ export const GraphQLInt = new GraphQLScalarType<number>({
   },
 });
 
-export const GraphQLFloat = new GraphQLScalarType<number>({
+export const GraphQLFloat = new GraphQLScalarType<number | bigint>({
   name: 'Float',
   description:
     'The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).',
@@ -101,16 +104,17 @@ export const GraphQLFloat = new GraphQLScalarType<number>({
       num = Number(coercedValue);
     }
 
-    if (typeof num !== 'number' || !Number.isFinite(num)) {
+    if (!isNumeric(num)) {
       throw new GraphQLError(
         `Float cannot represent non numeric value: ${inspect(coercedValue)}`,
       );
     }
+
     return num;
   },
 
   parseValue(inputValue) {
-    if (typeof inputValue !== 'number' || !Number.isFinite(inputValue)) {
+    if (!isNumeric(inputValue)) {
       throw new GraphQLError(
         `Float cannot represent non numeric value: ${inspect(inputValue)}`,
       );
@@ -145,8 +149,8 @@ export const GraphQLString = new GraphQLScalarType<string>({
     if (typeof coercedValue === 'boolean') {
       return coercedValue ? 'true' : 'false';
     }
-    if (typeof coercedValue === 'number' && Number.isFinite(coercedValue)) {
-      return coercedValue.toString();
+    if (isNumeric(coercedValue)) {
+      return String(coercedValue);
     }
     throw new GraphQLError(
       `String cannot represent value: ${inspect(outputValue)}`,
@@ -183,8 +187,8 @@ export const GraphQLBoolean = new GraphQLScalarType<boolean>({
     if (typeof coercedValue === 'boolean') {
       return coercedValue;
     }
-    if (Number.isFinite(coercedValue)) {
-      return coercedValue !== 0;
+    if (isNumeric(coercedValue)) {
+      return Number(coercedValue) !== 0;
     }
     throw new GraphQLError(
       `Boolean cannot represent a non boolean value: ${inspect(coercedValue)}`,
@@ -222,7 +226,7 @@ export const GraphQLID = new GraphQLScalarType<string>({
     if (typeof coercedValue === 'string') {
       return coercedValue;
     }
-    if (Number.isInteger(coercedValue)) {
+    if (isInteger(coercedValue)) {
       return String(coercedValue);
     }
     throw new GraphQLError(
@@ -234,8 +238,8 @@ export const GraphQLID = new GraphQLScalarType<string>({
     if (typeof inputValue === 'string') {
       return inputValue;
     }
-    if (typeof inputValue === 'number' && Number.isInteger(inputValue)) {
-      return inputValue.toString();
+    if (isInteger(inputValue)) {
+      return String(inputValue);
     }
     throw new GraphQLError(`ID cannot represent value: ${inspect(inputValue)}`);
   },

src/utilities/__tests__/astFromValue-test.ts

@@ -41,11 +41,16 @@ describe('astFromValue', () => {
       value: false,
     });
 
-    expect(astFromValue(1, GraphQLBoolean)).to.deep.equal({
+    expect(astFromValue(1n, GraphQLBoolean)).to.deep.equal({
       kind: 'BooleanValue',
       value: true,
     });
 
+    expect(astFromValue(0n, GraphQLBoolean)).to.deep.equal({
+      kind: 'BooleanValue',
+      value: false,
+    });
+
     const NonNullBoolean = new GraphQLNonNull(GraphQLBoolean);
     expect(astFromValue(0, NonNullBoolean)).to.deep.equal({
       kind: 'BooleanValue',
@@ -69,6 +74,11 @@ describe('astFromValue', () => {
       value: '10000',
     });
 
+    expect(astFromValue(1n, GraphQLInt)).to.deep.equal({
+      kind: 'IntValue',
+      value: '1',
+    });
+
     // GraphQL spec does not allow coercing non-integer values to Int to avoid
     // accidental data loss.
     expect(() => astFromValue(123.5, GraphQLInt)).to.throw(
@@ -80,6 +90,16 @@ describe('astFromValue', () => {
       'Int cannot represent non 32-bit signed integer value: 1e+40',
     );
 
+    // Note: outside the bounds of 32bit signed int.
+    expect(() => astFromValue(9007199254740991, GraphQLInt)).to.throw(
+      'Int cannot represent non 32-bit signed integer value: 9007199254740991',
+    );
+
+    // Note: outside the bounds of 32bit signed int as BigInt.
+    expect(() => astFromValue(9007199254740991n, GraphQLInt)).to.throw(
+      'Int cannot represent non 32-bit signed integer value: 9007199254740991',
+    );
+
     expect(() => astFromValue(NaN, GraphQLInt)).to.throw(
       'Int cannot represent non-integer value: NaN',
     );
@@ -96,6 +116,11 @@ describe('astFromValue', () => {
       value: '123',
     });
 
+    expect(astFromValue(9007199254740993n, GraphQLFloat)).to.deep.equal({
+      kind: 'IntValue',
+      value: '9007199254740993',
+    });
+
     expect(astFromValue(123.5, GraphQLFloat)).to.deep.equal({
       kind: 'FloatValue',
       value: '123.5',
@@ -133,6 +158,11 @@ describe('astFromValue', () => {
       value: '123',
     });
 
+    expect(astFromValue(9007199254740993n, GraphQLString)).to.deep.equal({
+      kind: 'StringValue',
+      value: '9007199254740993',
+    });
+
     expect(astFromValue(false, GraphQLString)).to.deep.equal({
       kind: 'StringValue',
       value: 'false',
@@ -183,6 +213,11 @@ describe('astFromValue', () => {
       value: '01',
     });
 
+    expect(astFromValue(9007199254740993n, GraphQLID)).to.deep.equal({
+      kind: 'IntValue',
+      value: '9007199254740993',
+    });
+
     expect(() => astFromValue(false, GraphQLID)).to.throw(
       'ID cannot represent value: false',
     );

src/utilities/astFromValue.ts

@@ -118,6 +118,11 @@ export function astFromValue(
         : { kind: Kind.FLOAT, value: stringNum };
     }
 
+    if (typeof serialized === 'bigint') {
+      const stringNum = String(serialized);
+      return { kind: Kind.INT, value: stringNum };
+    }
+
     if (typeof serialized === 'string') {
       // Enum types use Enum literals.
       if (isEnumType(type)) {