import isFinite from "../polyfills/isFinite.mjs"; import isInteger from "../polyfills/isInteger.mjs"; import inspect from "../jsutils/inspect.mjs"; import isObjectLike from "../jsutils/isObjectLike.mjs"; import { Kind } from "../language/kinds.mjs"; import { print } from "../language/printer.mjs"; import { GraphQLError } from "../error/GraphQLError.mjs"; import { GraphQLScalarType } from "./definition.mjs"; // As per the GraphQL Spec, Integers are only treated as valid when a valid // 32-bit signed integer, providing the broadest support across platforms. // // n.b. JavaScript's integers are safe between -(2^53 - 1) and 2^53 - 1 because // they are internally represented as IEEE 754 doubles. var MAX_INT = 2147483647; var MIN_INT = -2147483648; function serializeInt(outputValue) { var coercedValue = serializeObject(outputValue); if (typeof coercedValue === 'boolean') { return coercedValue ? 1 : 0; } var num = coercedValue; if (typeof coercedValue === 'string' && coercedValue !== '') { num = Number(coercedValue); } if (!isInteger(num)) { throw new GraphQLError("Int cannot represent non-integer value: ".concat(inspect(coercedValue))); } if (num > MAX_INT || num < MIN_INT) { throw new GraphQLError('Int cannot represent non 32-bit signed integer value: ' + inspect(coercedValue)); } return num; } function coerceInt(inputValue) { if (!isInteger(inputValue)) { throw new GraphQLError("Int cannot represent non-integer value: ".concat(inspect(inputValue))); } if (inputValue > MAX_INT || inputValue < MIN_INT) { throw new GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(inputValue)); } return inputValue; } export var GraphQLInt = new GraphQLScalarType({ name: 'Int', description: 'The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.', serialize: serializeInt, parseValue: coerceInt, parseLiteral: function parseLiteral(valueNode) { if (valueNode.kind !== Kind.INT) { throw new GraphQLError("Int cannot represent non-integer value: ".concat(print(valueNode)), valueNode); } var num = parseInt(valueNode.value, 10); if (num > MAX_INT || num < MIN_INT) { throw new GraphQLError("Int cannot represent non 32-bit signed integer value: ".concat(valueNode.value), valueNode); } return num; } }); function serializeFloat(outputValue) { var coercedValue = serializeObject(outputValue); if (typeof coercedValue === 'boolean') { return coercedValue ? 1 : 0; } var num = coercedValue; if (typeof coercedValue === 'string' && coercedValue !== '') { num = Number(coercedValue); } if (!isFinite(num)) { throw new GraphQLError("Float cannot represent non numeric value: ".concat(inspect(coercedValue))); } return num; } function coerceFloat(inputValue) { if (!isFinite(inputValue)) { throw new GraphQLError("Float cannot represent non numeric value: ".concat(inspect(inputValue))); } return inputValue; } export var GraphQLFloat = new GraphQLScalarType({ 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).', serialize: serializeFloat, parseValue: coerceFloat, parseLiteral: function parseLiteral(valueNode) { if (valueNode.kind !== Kind.FLOAT && valueNode.kind !== Kind.INT) { throw new GraphQLError("Float cannot represent non numeric value: ".concat(print(valueNode)), valueNode); } return parseFloat(valueNode.value); } }); // Support serializing objects with custom valueOf() or toJSON() functions - // a common way to represent a complex value which can be represented as // a string (ex: MongoDB id objects). function serializeObject(outputValue) { if (isObjectLike(outputValue)) { if (typeof outputValue.valueOf === 'function') { var valueOfResult = outputValue.valueOf(); if (!isObjectLike(valueOfResult)) { return valueOfResult; } } if (typeof outputValue.toJSON === 'function') { // $FlowFixMe[incompatible-use] return outputValue.toJSON(); } } return outputValue; } function serializeString(outputValue) { var coercedValue = serializeObject(outputValue); // Serialize string, boolean and number values to a string, but do not // attempt to coerce object, function, symbol, or other types as strings. if (typeof coercedValue === 'string') { return coercedValue; } if (typeof coercedValue === 'boolean') { return coercedValue ? 'true' : 'false'; } if (isFinite(coercedValue)) { return coercedValue.toString(); } throw new GraphQLError("String cannot represent value: ".concat(inspect(outputValue))); } function coerceString(inputValue) { if (typeof inputValue !== 'string') { throw new GraphQLError("String cannot represent a non string value: ".concat(inspect(inputValue))); } return inputValue; } export var GraphQLString = new GraphQLScalarType({ name: 'String', description: 'The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.', serialize: serializeString, parseValue: coerceString, parseLiteral: function parseLiteral(valueNode) { if (valueNode.kind !== Kind.STRING) { throw new GraphQLError("String cannot represent a non string value: ".concat(print(valueNode)), valueNode); } return valueNode.value; } }); function serializeBoolean(outputValue) { var coercedValue = serializeObject(outputValue); if (typeof coercedValue === 'boolean') { return coercedValue; } if (isFinite(coercedValue)) { return coercedValue !== 0; } throw new GraphQLError("Boolean cannot represent a non boolean value: ".concat(inspect(coercedValue))); } function coerceBoolean(inputValue) { if (typeof inputValue !== 'boolean') { throw new GraphQLError("Boolean cannot represent a non boolean value: ".concat(inspect(inputValue))); } return inputValue; } export var GraphQLBoolean = new GraphQLScalarType({ name: 'Boolean', description: 'The `Boolean` scalar type represents `true` or `false`.', serialize: serializeBoolean, parseValue: coerceBoolean, parseLiteral: function parseLiteral(valueNode) { if (valueNode.kind !== Kind.BOOLEAN) { throw new GraphQLError("Boolean cannot represent a non boolean value: ".concat(print(valueNode)), valueNode); } return valueNode.value; } }); function serializeID(outputValue) { var coercedValue = serializeObject(outputValue); if (typeof coercedValue === 'string') { return coercedValue; } if (isInteger(coercedValue)) { return String(coercedValue); } throw new GraphQLError("ID cannot represent value: ".concat(inspect(outputValue))); } function coerceID(inputValue) { if (typeof inputValue === 'string') { return inputValue; } if (isInteger(inputValue)) { return inputValue.toString(); } throw new GraphQLError("ID cannot represent value: ".concat(inspect(inputValue))); } export var GraphQLID = new GraphQLScalarType({ name: 'ID', description: 'The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.', serialize: serializeID, parseValue: coerceID, parseLiteral: function parseLiteral(valueNode) { if (valueNode.kind !== Kind.STRING && valueNode.kind !== Kind.INT) { throw new GraphQLError('ID cannot represent a non-string and non-integer value: ' + print(valueNode), valueNode); } return valueNode.value; } }); export var specifiedScalarTypes = Object.freeze([GraphQLString, GraphQLInt, GraphQLFloat, GraphQLBoolean, GraphQLID]); export function isSpecifiedScalarType(type) { return specifiedScalarTypes.some(function (_ref) { var name = _ref.name; return type.name === name; }); }