{

auto result = std::move(_argumentValue);

return result;

{

if (value.is_type<peg::variable_value>())

{

visitVariable(value);

}

else if (value.is_type<peg::integer_value>())

{

visitIntValue(value);

}

else if (value.is_type<peg::float_value>())

{

visitFloatValue(value);

}

else if (value.is_type<peg::string_value>())

{

visitStringValue(value);

}

else if (value.is_type<peg::true_keyword>() || value.is_type<peg::false_keyword>())

{

visitBooleanValue(value);

}

else if (value.is_type<peg::null_keyword>())

{

visitNullValue(value);

}

else if (value.is_type<peg::enum_value>())

{

visitEnumValue(value);

}

else if (value.is_type<peg::list_value>())

{

visitListValue(value);

}

else if (value.is_type<peg::object_value>())

{

visitObjectValue(value);

}

{

ValidateArgumentVariable value { variable.string_view().substr(1) };

auto position = variable.begin();

_argumentValue.value = std::make_unique<ValidateArgumentValue>(std::move(value));

_argumentValue.position = { position.line, position.column };

{

int value { std::atoi(intValue.string().c_str()) };

auto position = intValue.begin();

_argumentValue.value = std::make_unique<ValidateArgumentValue>(value);

_argumentValue.position = { position.line, position.column };

{

double value { std::atof(floatValue.string().c_str()) };

auto position = floatValue.begin();

_argumentValue.value = std::make_unique<ValidateArgumentValue>(value);

_argumentValue.position = { position.line, position.column };

{

std::string_view value { stringValue.unescaped_view() };

auto position = stringValue.begin();

_argumentValue.value = std::make_unique<ValidateArgumentValue>(value);

_argumentValue.position = { position.line, position.column };

{

bool value { booleanValue.is_type<peg::true_keyword>() };

auto position = booleanValue.begin();

_argumentValue.value = std::make_unique<ValidateArgumentValue>(value);

_argumentValue.position = { position.line, position.column };

{

auto position = nullValue.begin();

_argumentValue.value.reset();

_argumentValue.position = { position.line, position.column };

{

ValidateArgumentEnumValue value { enumValue.string_view() };

auto position = enumValue.begin();

_argumentValue.value = std::make_unique<ValidateArgumentValue>(std::move(value));

_argumentValue.position = { position.line, position.column };

{

ValidateArgumentList value;

auto position = listValue.begin();

value.values.reserve(listValue.children.size());

for (const auto& child : listValue.children)

{

ValidateArgumentValueVisitor visitor(_errors);

visitor.visit(*child);

value.values.emplace_back(visitor.getArgumentValue());

}

_argumentValue.value = std::make_unique<ValidateArgumentValue>(std::move(value));

_argumentValue.position = { position.line, position.column };

{

ValidateArgumentMap value;

auto position = objectValue.begin();

for (const auto& field : objectValue.children)

{

auto name = field->children.front()->string_view();

if (value.values.find(name) != value.values.end())

{

// https://spec.graphql.org/October2021/#sec-Input-Object-Field-Uniqueness

auto fieldPosition = field->begin();

auto message = std::format("Conflicting input field name: {}", name);

_errors.push_back({ std::move(message), { fieldPosition.line, fieldPosition.column } });

continue;

}

ValidateArgumentValueVisitor visitor(_errors);

visitor.visit(*field->children.back());

value.values[std::move(name)] = visitor.getArgumentValue();

}

_argumentValue.value = std::make_unique<ValidateArgumentValue>(std::move(value));

_argumentValue.position = { position.line, position.column };

std::string_view fieldName, ValidateFieldArguments&& arguments)

: returnType(std::move(returnType))

, objectType(std::move(objectType))

, fieldName(fieldName)

, arguments(std::move(arguments))

{

const std::shared_ptr<schema::Schema>& schema, const ValidateTypes& types)

: _schema(schema)

, _types(types)

{

{

if (typeName.is_type<peg::nonnull_type>())

{

visitNonNullType(typeName);

}

else if (typeName.is_type<peg::list_type>())

{

visitListType(typeName);

}

else if (typeName.is_type<peg::named_type>())

{

visitNamedType(typeName);

}

{

auto name = namedType.string_view();

auto itrType = _types.find(name);

if (itrType == _types.end())

{

return;

}

switch (itrType->second->get().kind())

{

case introspection::TypeKind::SCALAR:

case introspection::TypeKind::ENUM:

case introspection::TypeKind::INPUT_OBJECT:

_isInputType = true;

_variableType = getValidateType(_schema->LookupType(name));

break;

default:

break;

}

{

ValidateVariableTypeVisitor visitor(_schema, _types);

visitor.visit(*listType.children.front());

_isInputType = visitor.isInputType();

_variableType = getValidateType(

_schema->WrapType(introspection::TypeKind::LIST, getSharedType(visitor.getType())));

{

ValidateVariableTypeVisitor visitor(_schema, _types);

visitor.visit(*nonNullType.children.front());

_isInputType = visitor.isInputType();

_variableType = getValidateType(

_schema->WrapType(introspection::TypeKind::NON_NULL, getSharedType(visitor.getType())));

{

auto result = std::move(_variableType);

return result;

: _schema(schema)

{

const auto& queryType = _schema->queryType();

const auto& mutationType = _schema->mutationType();

const auto& subscriptionType = _schema->subscriptionType();

_operationTypes.reserve(3);

if (mutationType)

{

_operationTypes[strMutation] = getValidateType(mutationType);

}

if (queryType)

{

_operationTypes[strQuery] = getValidateType(queryType);

}

if (subscriptionType)

{

_operationTypes[strSubscription] = getValidateType(subscriptionType);

}

const auto& types = _schema->types();

_types.reserve(types.size());

for (const auto& entry : types)

{

const auto name = entry.first;

const auto kind = entry.second->kind();

if (!isScalarType(kind))

{

auto matchingTypes = std::move(_matchingTypes[name]);

if (kind == introspection::TypeKind::OBJECT)

{

matchingTypes.emplace(name);

}

else

{

const auto& possibleTypes = entry.second->possibleTypes();

if (kind == introspection::TypeKind::INTERFACE)

{

matchingTypes.reserve(possibleTypes.size() + 1);

matchingTypes.emplace(name);

}

else

{

matchingTypes.reserve(possibleTypes.size());

}

for (const auto& possibleType : possibleTypes)

{

const auto spType = possibleType.lock();

if (spType)

{

matchingTypes.emplace(spType->name());

}

}

}

if (!matchingTypes.empty())

{

_matchingTypes[name] = std::move(matchingTypes);

}

}

else if (kind == introspection::TypeKind::ENUM)

{

const auto& enumValues = entry.second->enumValues();

internal::string_view_set values;

values.reserve(enumValues.size());

for (const auto& value : enumValues)

{

if (value)

{

values.emplace(value->name());

}

}

if (!enumValues.empty())

{

_enumValues[name] = std::move(values);

}

}

else if (kind == introspection::TypeKind::SCALAR)

{

_scalarTypes.emplace(name);

}

_types[name] = getValidateType(entry.second);

}

const auto& directives = _schema->directives();

_directives.reserve(directives.size());

for (const auto& directive : directives)

{

const auto name = directive->name();

const auto& locations = directive->locations();

const auto& args = directive->args();

ValidateDirective validateDirective;

validateDirective.isRepeatable = directive->isRepeatable();

for (const auto location : locations)

{

validateDirective.locations.emplace(location);

}

validateDirective.arguments = getArguments(args);

_directives[name] = std::move(validateDirective);

}

{

// Visit all of the fragment definitions and check for duplicates.

peg::for_each_child<peg::fragment_definition>(root,

[this](const peg::ast_node& fragmentDefinition) {

const auto& fragmentName = fragmentDefinition.children.front();

const auto inserted =

_fragmentDefinitions.emplace(fragmentName->string_view(), fragmentDefinition);

if (!inserted.second)

{

// https://spec.graphql.org/October2021/#sec-Fragment-Name-Uniqueness

auto position = fragmentDefinition.begin();

auto error = std::format("Duplicate fragment name: {}", inserted.first->first);

_errors.push_back({ std::move(error), { position.line, position.column } });

}

});

// Visit all of the operation definitions and check for duplicates.

peg::for_each_child<peg::operation_definition>(root,

[this](const peg::ast_node& operationDefinition) {

std::string_view operationName;

peg::on_first_child<peg::operation_name>(operationDefinition,

[&operationName](const peg::ast_node& child) {

operationName = child.string_view();

});

const auto inserted = _operationDefinitions.emplace(operationName, operationDefinition);

if (!inserted.second)

{

// https://spec.graphql.org/October2021/#sec-Operation-Name-Uniqueness

auto position = operationDefinition.begin();

auto error = std::format("Duplicate operation name: {}", inserted.first->first);

_errors.push_back({ std::move(error), { position.line, position.column } });

}

});

// Check for lone anonymous operations.

if (_operationDefinitions.size() > 1)

{

auto itr = std::find_if(_operationDefinitions.begin(),

_operationDefinitions.end(),

[](const auto& entry) noexcept {

return entry.first.empty();

});

if (itr != _operationDefinitions.end())

{

// https://spec.graphql.org/October2021/#sec-Lone-Anonymous-Operation

auto position = itr->second.get().begin();

_errors.push_back(

{ "Anonymous operation not alone", { position.line, position.column } });

}

}

// Visit the executable definitions recursively.

for (const auto& child : root.children)

{

if (child->is_type<peg::fragment_definition>())

{

visitFragmentDefinition(*child);

}

else if (child->is_type<peg::operation_definition>())

{

visitOperationDefinition(*child);

}

else

{

// https://spec.graphql.org/October2021/#sec-Executable-Definitions

auto position = child->begin();

_errors.push_back({ "Unexpected type definition", { position.line, position.column } });

}

}

if (!_fragmentDefinitions.empty())

{

// https://spec.graphql.org/October2021/#sec-Fragments-Must-Be-Used

auto unreferencedFragments = std::move(_fragmentDefinitions);

for (const auto& name : _referencedFragments)

{

unreferencedFragments.erase(name);

}

std::ranges::transform(unreferencedFragments,

std::back_inserter(_errors),

[](const auto& fragmentDefinition) noexcept {

auto position = fragmentDefinition.second.get().begin();

auto message =

std::format("Unused fragment definition name: {}", fragmentDefinition.first);

return schema_error { std::move(message), { position.line, position.column } };

});

}

{

auto errors = std::move(_errors);

// Reset all of the state for this query, but keep the Introspection schema information.

_fragmentDefinitions.clear();

_operationDefinitions.clear();

_referencedFragments.clear();

_fragmentCycles.clear();

return errors;

{

peg::on_first_child<peg::directives>(fragmentDefinition, [this](const peg::ast_node& child) {

visitDirectives(introspection::DirectiveLocation::FRAGMENT_DEFINITION, child);

});

const auto name = fragmentDefinition.children.front()->string_view();

const auto& selection = *fragmentDefinition.children.back();

const auto& typeCondition = fragmentDefinition.children[1];

auto innerType = typeCondition->children.front()->string_view();

auto itrType = _types.find(innerType);

if (itrType == _types.end() || isScalarType(itrType->second->get().kind()))

{

// https://spec.graphql.org/October2021/#sec-Fragment-Spread-Type-Existence

// https://spec.graphql.org/October2021/#sec-Fragments-On-Composite-Types

auto position = typeCondition->begin();

auto message = std::format("{} target type on fragment definition: {} name: {}",

(itrType == _types.end() ? "Undefined" : "Scalar"),

name,

innerType);

_errors.push_back({ std::move(message), { position.line, position.column } });

return;

}

_fragmentStack.emplace(name);

_scopedType = itrType->second;

visitSelection(selection);

_scopedType.reset();

_fragmentStack.clear();

_selectionFields.clear();

{

auto operationType = strQuery;

peg::on_first_child<peg::operation_type>(operationDefinition,

[&operationType](const peg::ast_node& child) {

operationType = child.string_view();

});

std::string_view operationName;

peg::on_first_child<peg::operation_name>(operationDefinition,

[&operationName](const peg::ast_node& child) {

operationName = child.string_view();

});

_operationVariables = std::make_optional<VariableTypes>();

peg::for_each_child<

peg::variable>(operationDefinition, [this, operationName](const peg::ast_node& variable) {

std::string_view variableName;

ValidateArgument variableArgument;

for (const auto& child : variable.children)

{

if (child->is_type<peg::variable_name>())

{

// Skip the $ prefix

variableName = child->string_view().substr(1);

if (_operationVariables->find(variableName) != _operationVariables->end())

{

// https://spec.graphql.org/October2021/#sec-Variable-Uniqueness

auto position = child->begin();

auto message = "Conflicting variable"s;

if (!operationName.empty())

{

message += std::format(" operation: {}", operationName);

}

message += std::format(" name: {}", variableName);

_errors.push_back({ std::move(message), { position.line, position.column } });

return;

}

}

else if (child->is_type<peg::named_type>() || child->is_type<peg::list_type>()

|| child->is_type<peg::nonnull_type>())

{

ValidateVariableTypeVisitor visitor(_schema, _types);

visitor.visit(*child);

if (!visitor.isInputType())

{

// https://spec.graphql.org/October2021/#sec-Variables-Are-Input-Types

auto position = child->begin();

auto message = "Invalid variable type"s;

if (!operationName.empty())

{

message += std::format(" operation: {}", operationName);

}

message += std::format(" name: {}", variableName);

_errors.push_back({ std::move(message), { position.line, position.column } });

return;

}

variableArgument.type = visitor.getType();

}

else if (child->is_type<peg::default_value>())

{

ValidateArgumentValueVisitor visitor(_errors);

visitor.visit(*child->children.back());

auto argument = visitor.getArgumentValue();

if (!validateInputValue(false, argument, variableArgument.type))

{

// https://spec.graphql.org/October2021/#sec-Values-of-Correct-Type

auto position = child->begin();

auto message = "Incompatible variable default value"s;

if (!operationName.empty())

{

message += std::format(" operation: {}", operationName);

}

message += std::format(" name: {}", variableName);

_errors.push_back({ std::move(message), { position.line, position.column } });

return;

}

variableArgument.defaultValue = true;

variableArgument.nonNullDefaultValue = argument.value != nullptr;

}

}

_variableDefinitions.emplace(variableName, variable);

_operationVariables->emplace(variableName, std::move(variableArgument));

});

peg::on_first_child<peg::directives>(operationDefinition,

[this, &operationType](const peg::ast_node& child) {

auto location = introspection::DirectiveLocation::QUERY;

if (operationType == strMutation)

{

location = introspection::DirectiveLocation::MUTATION;

}

else if (operationType == strSubscription)

{

location = introspection::DirectiveLocation::SUBSCRIPTION;

}

visitDirectives(location, child);

});

auto itrType = _operationTypes.find(operationType);

if (itrType == _operationTypes.end())

{

auto position = operationDefinition.begin();

auto error = std::format("Unsupported operation type: {}", operationType);

_errors.push_back({ std::move(error), { position.line, position.column } });

return;

}

_scopedType = itrType->second;

_introspectionFieldCount = 0;

_fieldCount = 0;

const auto& selection = *operationDefinition.children.back();

visitSelection(selection);

if (operationType == strSubscription)

{

if (_fieldCount > 1)

{

// https://spec.graphql.org/October2021/#sec-Single-root-field

auto position = operationDefinition.begin();

auto error = "Subscription with more than one root field"s;

if (!operationName.empty())

{

error += std::format(" name: {}", operationName);

}

_errors.push_back({ std::move(error), { position.line, position.column } });

}

if (_introspectionFieldCount != 0)

{

// https://spec.graphql.org/October2021/#sec-Single-root-field

auto position = operationDefinition.begin();

auto error = "Subscription with Introspection root field"s;

if (!operationName.empty())

{

error += std::format(" name: {}", operationName);

}

_errors.push_back({ std::move(error), { position.line, position.column } });

}

}

_scopedType.reset();

_fragmentStack.clear();

_selectionFields.clear();

for (const auto& variable : _variableDefinitions)

{

if (_referencedVariables.find(variable.first) == _referencedVariables.end())

{

// https://spec.graphql.org/October2021/#sec-All-Variables-Used

auto position = variable.second.get().begin();

auto error = std::format("Unused variable name: {}", variable.first);

_errors.push_back({ std::move(error), { position.line, position.column } });

}

}

_operationVariables.reset();

_variableDefinitions.clear();

_referencedVariables.clear();

{

for (const auto& child : selection.children)

{

if (child->is_type<peg::field>())

{

visitField(*child);

}

else if (child->is_type<peg::fragment_spread>())

{

visitFragmentSpread(*child);

}

else if (child->is_type<peg::inline_fragment>())

{

visitInlineFragment(*child);

}

}

const std::vector<std::shared_ptr<const schema::InputValue>>& args)

{

ValidateTypeFieldArguments result;

for (const auto& arg : args)

{

if (!arg)

{

continue;

}

ValidateArgument argument;

argument.defaultValue = !arg->defaultValue().empty();

argument.nonNullDefaultValue =

argument.defaultValue && arg->defaultValue() != R"gql(null)gql"sv;

argument.type = getValidateType(arg->type().lock());

result[arg->name()] = std::move(argument);

}

return result;

{

switch (kind)

{

case introspection::TypeKind::OBJECT:

case introspection::TypeKind::INTERFACE:

case introspection::TypeKind::UNION:

return false;

default:

return true;

}

{

if (name == _scopedType->get().name())

{

return true;

}

const auto itrScoped = _matchingTypes.find(_scopedType->get().name());

const auto itrNamed = _matchingTypes.find(name);

if (itrScoped != _matchingTypes.end() && itrNamed != _matchingTypes.end())

{

const auto itrMatch = std::find_if(itrScoped->second.begin(),

itrScoped->second.end(),

[itrNamed](std::string_view matchingType) noexcept {

return itrNamed->second.find(matchingType) != itrNamed->second.end();

});

return itrMatch != itrScoped->second.end();

}

return false;

bool hasNonNullDefaultValue, const ValidateArgumentValuePtr& argument, const ValidateType& type)

{

if (!type)

{

_errors.push_back({ "Unknown input type", argument.position });

return false;

}

if (argument.value && std::holds_alternative<ValidateArgumentVariable>(argument.value->data))

{

if (_operationVariables)

{

const auto& variable = std::get<ValidateArgumentVariable>(argument.value->data);

auto itrVariable = _operationVariables->find(variable.name);

if (itrVariable == _operationVariables->end())

{

// https://spec.graphql.org/October2021/#sec-All-Variable-Uses-Defined

auto message = std::format("Undefined variable name: {}", variable.name);

_errors.push_back({ std::move(message), argument.position });

return false;

}

_referencedVariables.emplace(variable.name);

return validateVariableType(

hasNonNullDefaultValue || itrVariable->second.nonNullDefaultValue,

itrVariable->second.type,

argument.position,

type);

}

else

{

// In fragment definitions, variables can hold any type. It's only when we are

// transitively visiting them through an operation definition that they are assigned a

// type, and the type may not be exactly the same in all operations definitions which

// reference the fragment.

return true;

}

}

const auto kind = type->get().kind();

if (!argument.value)

{

// The null literal matches any nullable type and does not match a non-nullable type.

if (kind == introspection::TypeKind::NON_NULL && !hasNonNullDefaultValue)

{

_errors.push_back({ "Expected Non-Null value", argument.position });

return false;

}

return true;

}

switch (kind)

{

case introspection::TypeKind::NON_NULL:

{

// Unwrap and check the next one.

const auto ofType = getValidateType(type->get().ofType().lock());

if (!ofType)

{

_errors.push_back({ "Unknown Non-Null type", argument.position });

return false;

}

return validateInputValue(hasNonNullDefaultValue, argument, ofType);

}

case introspection::TypeKind::LIST:

{

if (!std::holds_alternative<ValidateArgumentList>(argument.value->data))

{

_errors.push_back({ "Expected List value", argument.position });

return false;

}

const auto ofType = getValidateType(type->get().ofType().lock());

if (!ofType)

{

_errors.push_back({ "Unknown List type", argument.position });

return false;

}

// Check every value against the target type.

for (const auto& value : std::get<ValidateArgumentList>(argument.value->data).values)