graphql

TypesSource
Search for an npm package
import { inspect } from '../jsutils/inspect.mjs';
import { isObjectLike } from '../jsutils/isObjectLike.mjs';
import { GraphQLError } from '../error/GraphQLError.mjs';
import { Kind } from '../language/kinds.mjs';
import { print } from '../language/printer.mjs';
import { GraphQLScalarType } from './definition.mjs';
/**
* Maximum possible Int value as per GraphQL Spec (32-bit signed integer).
* n.b. This differs from JavaScript's numbers that are IEEE 754 doubles safe up-to 2^53 - 1
* */
export const GRAPHQL_MAX_INT = 2147483647;
/**
* Minimum possible Int value as per GraphQL Spec (32-bit signed integer).
* n.b. This differs from JavaScript's numbers that are IEEE 754 doubles safe starting at -(2^53 - 1)
* */
export const GRAPHQL_MIN_INT = -2147483648;
export const 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(outputValue) {
const coercedValue = serializeObject(outputValue);
if (typeof coercedValue === 'boolean') {
return coercedValue ? 1 : 0;
}
let num = coercedValue;
if (typeof coercedValue === 'string' && coercedValue !== '') {
num = Number(coercedValue);
}
if (typeof num !== 'number' || !Number.isInteger(num)) {
throw new GraphQLError(
`Int cannot represent non-integer value: ${inspect(coercedValue)}`,
);
}
if (num > GRAPHQL_MAX_INT || num < GRAPHQL_MIN_INT) {
throw new GraphQLError(
'Int cannot represent non 32-bit signed integer value: ' +
inspect(coercedValue),
);
}
return num;
},
parseValue(inputValue) {
if (typeof inputValue !== 'number' || !Number.isInteger(inputValue)) {
throw new GraphQLError(
`Int cannot represent non-integer value: ${inspect(inputValue)}`,
);
}
if (inputValue > GRAPHQL_MAX_INT || inputValue < GRAPHQL_MIN_INT) {
throw new GraphQLError(
`Int cannot represent non 32-bit signed integer value: ${inputValue}`,
);
}
return inputValue;
},
parseLiteral(valueNode) {
if (valueNode.kind !== Kind.INT) {
throw new GraphQLError(
`Int cannot represent non-integer value: ${print(valueNode)}`,
{
nodes: valueNode,
},
);
}
const num = parseInt(valueNode.value, 10);
if (num > GRAPHQL_MAX_INT || num < GRAPHQL_MIN_INT) {
throw new GraphQLError(
`Int cannot represent non 32-bit signed integer value: ${valueNode.value}`,
{
nodes: valueNode,
},
);
}
return num;
},
});
export const 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(outputValue) {
const coercedValue = serializeObject(outputValue);
if (typeof coercedValue === 'boolean') {
return coercedValue ? 1 : 0;
}
let num = coercedValue;
if (typeof coercedValue === 'string' && coercedValue !== '') {
num = Number(coercedValue);
}
if (typeof num !== 'number' || !Number.isFinite(num)) {
throw new GraphQLError(
`Float cannot represent non numeric value: ${inspect(coercedValue)}`,
);
}
return num;
},
parseValue(inputValue) {
if (typeof inputValue !== 'number' || !Number.isFinite(inputValue)) {
throw new GraphQLError(
`Float cannot represent non numeric value: ${inspect(inputValue)}`,
);
}
return inputValue;
},
parseLiteral(valueNode) {
if (valueNode.kind !== Kind.FLOAT && valueNode.kind !== Kind.INT) {
throw new GraphQLError(
`Float cannot represent non numeric value: ${print(valueNode)}`,
valueNode,
);
}
return parseFloat(valueNode.value);
},
});
export const 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(outputValue) {
const 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 (typeof coercedValue === 'number' && Number.isFinite(coercedValue)) {
return coercedValue.toString();
}
throw new GraphQLError(
`String cannot represent value: ${inspect(outputValue)}`,
);
},
parseValue(inputValue) {
if (typeof inputValue !== 'string') {
throw new GraphQLError(
`String cannot represent a non string value: ${inspect(inputValue)}`,
);
}
return inputValue;
},
parseLiteral(valueNode) {
if (valueNode.kind !== Kind.STRING) {
throw new GraphQLError(
`String cannot represent a non string value: ${print(valueNode)}`,
{
nodes: valueNode,
},
);
}
return valueNode.value;
},
});
export const GraphQLBoolean = new GraphQLScalarType({
name: 'Boolean',
description: 'The `Boolean` scalar type represents `true` or `false`.',
serialize(outputValue) {
const coercedValue = serializeObject(outputValue);
if (typeof coercedValue === 'boolean') {
return coercedValue;
}
if (Number.isFinite(coercedValue)) {
return coercedValue !== 0;
}
throw new GraphQLError(
`Boolean cannot represent a non boolean value: ${inspect(coercedValue)}`,
);
},
parseValue(inputValue) {
if (typeof inputValue !== 'boolean') {
throw new GraphQLError(
`Boolean cannot represent a non boolean value: ${inspect(inputValue)}`,
);
}
return inputValue;
},
parseLiteral(valueNode) {
if (valueNode.kind !== Kind.BOOLEAN) {
throw new GraphQLError(
`Boolean cannot represent a non boolean value: ${print(valueNode)}`,
{
nodes: valueNode,
},
);
}
return valueNode.value;
},
});
export const 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(outputValue) {
const coercedValue = serializeObject(outputValue);
if (typeof coercedValue === 'string') {
return coercedValue;
}
if (Number.isInteger(coercedValue)) {
return String(coercedValue);
}
throw new GraphQLError(
`ID cannot represent value: ${inspect(outputValue)}`,
);
},
parseValue(inputValue) {
if (typeof inputValue === 'string') {
return inputValue;
}
if (typeof inputValue === 'number' && Number.isInteger(inputValue)) {
return inputValue.toString();
}
throw new GraphQLError(`ID cannot represent value: ${inspect(inputValue)}`);
},
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),
{
nodes: valueNode,
},
);
}
return valueNode.value;
},
});
export const specifiedScalarTypes = Object.freeze([
GraphQLString,
GraphQLInt,
GraphQLFloat,
GraphQLBoolean,
GraphQLID,
]);
export function isSpecifiedScalarType(type) {
return specifiedScalarTypes.some(({ name }) => type.name === name);
} // 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') {
const valueOfResult = outputValue.valueOf();
if (!isObjectLike(valueOfResult)) {
return valueOfResult;
}
}
if (typeof outputValue.toJSON === 'function') {
return outputValue.toJSON();
}
}
return outputValue;
}