ikan Uploader :
Directory : /proc/self/root/home/saurabh/.npm/_npx/249ca9fcd30c476a/node_modules/graphql/execution/
Upload File : |
| Current File : //proc/self/root/home/saurabh/.npm/_npx/249ca9fcd30c476a/node_modules/graphql/execution/values.mjs |
import find from "../polyfills/find.mjs";
import keyMap from "../jsutils/keyMap.mjs";
import inspect from "../jsutils/inspect.mjs";
import printPathArray from "../jsutils/printPathArray.mjs";
import { GraphQLError } from "../error/GraphQLError.mjs";
import { Kind } from "../language/kinds.mjs";
import { print } from "../language/printer.mjs";
import { isInputType, isNonNullType } from "../type/definition.mjs";
import { typeFromAST } from "../utilities/typeFromAST.mjs";
import { valueFromAST } from "../utilities/valueFromAST.mjs";
import { coerceInputValue } from "../utilities/coerceInputValue.mjs";
/**
* Prepares an object map of variableValues of the correct type based on the
* provided variable definitions and arbitrary input. If the input cannot be
* parsed to match the variable definitions, a GraphQLError will be thrown.
*
* Note: The returned value is a plain Object with a prototype, since it is
* exposed to user code. Care should be taken to not pull values from the
* Object prototype.
*
* @internal
*/
export function getVariableValues(schema, varDefNodes, inputs, options) {
var errors = [];
var maxErrors = options === null || options === void 0 ? void 0 : options.maxErrors;
try {
var coerced = coerceVariableValues(schema, varDefNodes, inputs, function (error) {
if (maxErrors != null && errors.length >= maxErrors) {
throw new GraphQLError('Too many errors processing variables, error limit reached. Execution aborted.');
}
errors.push(error);
});
if (errors.length === 0) {
return {
coerced: coerced
};
}
} catch (error) {
errors.push(error);
}
return {
errors: errors
};
}
function coerceVariableValues(schema, varDefNodes, inputs, onError) {
var coercedValues = {};
var _loop = function _loop(_i2) {
var varDefNode = varDefNodes[_i2];
var varName = varDefNode.variable.name.value;
var varType = typeFromAST(schema, varDefNode.type);
if (!isInputType(varType)) {
// Must use input types for variables. This should be caught during
// validation, however is checked again here for safety.
var varTypeStr = print(varDefNode.type);
onError(new GraphQLError("Variable \"$".concat(varName, "\" expected value of type \"").concat(varTypeStr, "\" which cannot be used as an input type."), varDefNode.type));
return "continue";
}
if (!hasOwnProperty(inputs, varName)) {
if (varDefNode.defaultValue) {
coercedValues[varName] = valueFromAST(varDefNode.defaultValue, varType);
} else if (isNonNullType(varType)) {
var _varTypeStr = inspect(varType);
onError(new GraphQLError("Variable \"$".concat(varName, "\" of required type \"").concat(_varTypeStr, "\" was not provided."), varDefNode));
}
return "continue";
}
var value = inputs[varName];
if (value === null && isNonNullType(varType)) {
var _varTypeStr2 = inspect(varType);
onError(new GraphQLError("Variable \"$".concat(varName, "\" of non-null type \"").concat(_varTypeStr2, "\" must not be null."), varDefNode));
return "continue";
}
coercedValues[varName] = coerceInputValue(value, varType, function (path, invalidValue, error) {
var prefix = "Variable \"$".concat(varName, "\" got invalid value ") + inspect(invalidValue);
if (path.length > 0) {
prefix += " at \"".concat(varName).concat(printPathArray(path), "\"");
}
onError(new GraphQLError(prefix + '; ' + error.message, varDefNode, undefined, undefined, undefined, error.originalError));
});
};
for (var _i2 = 0; _i2 < varDefNodes.length; _i2++) {
var _ret = _loop(_i2);
if (_ret === "continue") continue;
}
return coercedValues;
}
/**
* Prepares an object map of argument values given a list of argument
* definitions and list of argument AST nodes.
*
* Note: The returned value is a plain Object with a prototype, since it is
* exposed to user code. Care should be taken to not pull values from the
* Object prototype.
*
* @internal
*/
export function getArgumentValues(def, node, variableValues) {
var _node$arguments;
var coercedValues = {}; // istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2203')
var argumentNodes = (_node$arguments = node.arguments) !== null && _node$arguments !== void 0 ? _node$arguments : [];
var argNodeMap = keyMap(argumentNodes, function (arg) {
return arg.name.value;
});
for (var _i4 = 0, _def$args2 = def.args; _i4 < _def$args2.length; _i4++) {
var argDef = _def$args2[_i4];
var name = argDef.name;
var argType = argDef.type;
var argumentNode = argNodeMap[name];
if (!argumentNode) {
if (argDef.defaultValue !== undefined) {
coercedValues[name] = argDef.defaultValue;
} else if (isNonNullType(argType)) {
throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + 'was not provided.', node);
}
continue;
}
var valueNode = argumentNode.value;
var isNull = valueNode.kind === Kind.NULL;
if (valueNode.kind === Kind.VARIABLE) {
var variableName = valueNode.name.value;
if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
if (argDef.defaultValue !== undefined) {
coercedValues[name] = argDef.defaultValue;
} else if (isNonNullType(argType)) {
throw new GraphQLError("Argument \"".concat(name, "\" of required type \"").concat(inspect(argType), "\" ") + "was provided the variable \"$".concat(variableName, "\" which was not provided a runtime value."), valueNode);
}
continue;
}
isNull = variableValues[variableName] == null;
}
if (isNull && isNonNullType(argType)) {
throw new GraphQLError("Argument \"".concat(name, "\" of non-null type \"").concat(inspect(argType), "\" ") + 'must not be null.', valueNode);
}
var coercedValue = valueFromAST(valueNode, argType, variableValues);
if (coercedValue === undefined) {
// Note: ValuesOfCorrectTypeRule validation should catch this before
// execution. This is a runtime check to ensure execution does not
// continue with an invalid argument value.
throw new GraphQLError("Argument \"".concat(name, "\" has invalid value ").concat(print(valueNode), "."), valueNode);
}
coercedValues[name] = coercedValue;
}
return coercedValues;
}
/**
* Prepares an object map of argument values given a directive definition
* and a AST node which may contain directives. Optionally also accepts a map
* of variable values.
*
* If the directive does not exist on the node, returns undefined.
*
* Note: The returned value is a plain Object with a prototype, since it is
* exposed to user code. Care should be taken to not pull values from the
* Object prototype.
*/
export function getDirectiveValues(directiveDef, node, variableValues) {
var directiveNode = node.directives && find(node.directives, function (directive) {
return directive.name.value === directiveDef.name;
});
if (directiveNode) {
return getArgumentValues(directiveDef, directiveNode, variableValues);
}
}
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
Kontol Shell Bypass