You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
190 lines
4.9 KiB
190 lines
4.9 KiB
'use strict'; |
|
|
|
Object.defineProperty(exports, '__esModule', { |
|
value: true, |
|
}); |
|
exports.astFromValue = astFromValue; |
|
|
|
var _inspect = require('../jsutils/inspect.js'); |
|
|
|
var _invariant = require('../jsutils/invariant.js'); |
|
|
|
var _isIterableObject = require('../jsutils/isIterableObject.js'); |
|
|
|
var _isObjectLike = require('../jsutils/isObjectLike.js'); |
|
|
|
var _kinds = require('../language/kinds.js'); |
|
|
|
var _definition = require('../type/definition.js'); |
|
|
|
var _scalars = require('../type/scalars.js'); |
|
|
|
/** |
|
* Produces a GraphQL Value AST given a JavaScript object. |
|
* Function will match JavaScript/JSON values to GraphQL AST schema format |
|
* by using suggested GraphQLInputType. For example: |
|
* |
|
* astFromValue("value", GraphQLString) |
|
* |
|
* A GraphQL type must be provided, which will be used to interpret different |
|
* JavaScript values. |
|
* |
|
* | JSON Value | GraphQL Value | |
|
* | ------------- | -------------------- | |
|
* | Object | Input Object | |
|
* | Array | List | |
|
* | Boolean | Boolean | |
|
* | String | String / Enum Value | |
|
* | Number | Int / Float | |
|
* | Unknown | Enum Value | |
|
* | null | NullValue | |
|
* |
|
*/ |
|
function astFromValue(value, type) { |
|
if ((0, _definition.isNonNullType)(type)) { |
|
const astValue = astFromValue(value, type.ofType); |
|
|
|
if ( |
|
(astValue === null || astValue === void 0 ? void 0 : astValue.kind) === |
|
_kinds.Kind.NULL |
|
) { |
|
return null; |
|
} |
|
|
|
return astValue; |
|
} // only explicit null, not undefined, NaN |
|
|
|
if (value === null) { |
|
return { |
|
kind: _kinds.Kind.NULL, |
|
}; |
|
} // undefined |
|
|
|
if (value === undefined) { |
|
return null; |
|
} // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but |
|
// the value is not an array, convert the value using the list's item type. |
|
|
|
if ((0, _definition.isListType)(type)) { |
|
const itemType = type.ofType; |
|
|
|
if ((0, _isIterableObject.isIterableObject)(value)) { |
|
const valuesNodes = []; |
|
|
|
for (const item of value) { |
|
const itemNode = astFromValue(item, itemType); |
|
|
|
if (itemNode != null) { |
|
valuesNodes.push(itemNode); |
|
} |
|
} |
|
|
|
return { |
|
kind: _kinds.Kind.LIST, |
|
values: valuesNodes, |
|
}; |
|
} |
|
|
|
return astFromValue(value, itemType); |
|
} // Populate the fields of the input object by creating ASTs from each value |
|
// in the JavaScript object according to the fields in the input type. |
|
|
|
if ((0, _definition.isInputObjectType)(type)) { |
|
if (!(0, _isObjectLike.isObjectLike)(value)) { |
|
return null; |
|
} |
|
|
|
const fieldNodes = []; |
|
|
|
for (const field of Object.values(type.getFields())) { |
|
const fieldValue = astFromValue(value[field.name], field.type); |
|
|
|
if (fieldValue) { |
|
fieldNodes.push({ |
|
kind: _kinds.Kind.OBJECT_FIELD, |
|
name: { |
|
kind: _kinds.Kind.NAME, |
|
value: field.name, |
|
}, |
|
value: fieldValue, |
|
}); |
|
} |
|
} |
|
|
|
return { |
|
kind: _kinds.Kind.OBJECT, |
|
fields: fieldNodes, |
|
}; |
|
} |
|
|
|
if ((0, _definition.isLeafType)(type)) { |
|
// Since value is an internally represented value, it must be serialized |
|
// to an externally represented value before converting into an AST. |
|
const serialized = type.serialize(value); |
|
|
|
if (serialized == null) { |
|
return null; |
|
} // Others serialize based on their corresponding JavaScript scalar types. |
|
|
|
if (typeof serialized === 'boolean') { |
|
return { |
|
kind: _kinds.Kind.BOOLEAN, |
|
value: serialized, |
|
}; |
|
} // JavaScript numbers can be Int or Float values. |
|
|
|
if (typeof serialized === 'number' && Number.isFinite(serialized)) { |
|
const stringNum = String(serialized); |
|
return integerStringRegExp.test(stringNum) |
|
? { |
|
kind: _kinds.Kind.INT, |
|
value: stringNum, |
|
} |
|
: { |
|
kind: _kinds.Kind.FLOAT, |
|
value: stringNum, |
|
}; |
|
} |
|
|
|
if (typeof serialized === 'string') { |
|
// Enum types use Enum literals. |
|
if ((0, _definition.isEnumType)(type)) { |
|
return { |
|
kind: _kinds.Kind.ENUM, |
|
value: serialized, |
|
}; |
|
} // ID types can use Int literals. |
|
|
|
if (type === _scalars.GraphQLID && integerStringRegExp.test(serialized)) { |
|
return { |
|
kind: _kinds.Kind.INT, |
|
value: serialized, |
|
}; |
|
} |
|
|
|
return { |
|
kind: _kinds.Kind.STRING, |
|
value: serialized, |
|
}; |
|
} |
|
|
|
throw new TypeError( |
|
`Cannot convert value to AST: ${(0, _inspect.inspect)(serialized)}.`, |
|
); |
|
} |
|
/* c8 ignore next 3 */ |
|
// Not reachable, all possible types have been considered. |
|
|
|
false || |
|
(0, _invariant.invariant)( |
|
false, |
|
'Unexpected input type: ' + (0, _inspect.inspect)(type), |
|
); |
|
} |
|
/** |
|
* IntValue: |
|
* - NegativeSign? 0 |
|
* - NegativeSign? NonZeroDigit ( Digit+ )? |
|
*/ |
|
|
|
const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
|
|
|