in src/RequestLoader.cpp [272:568]
void RequestLoader::addTypesToSchema()
{
if (!_schemaLoader.getScalarTypes().empty())
{
for (const auto& scalarType : _schemaLoader.getScalarTypes())
{
_schema->AddType(scalarType.type,
schema::ScalarType::Make(scalarType.type,
scalarType.description,
scalarType.specifiedByURL));
}
}
std::map<std::string_view, std::shared_ptr<schema::EnumType>> enumTypes;
if (!_schemaLoader.getEnumTypes().empty())
{
for (const auto& enumType : _schemaLoader.getEnumTypes())
{
const auto itr = enumTypes
.emplace(std::make_pair(enumType.type,
schema::EnumType::Make(enumType.type, enumType.description)))
.first;
_schema->AddType(enumType.type, itr->second);
}
}
std::map<std::string_view, std::shared_ptr<schema::InputObjectType>> inputTypes;
if (!_schemaLoader.getInputTypes().empty())
{
for (const auto& inputType : _schemaLoader.getInputTypes())
{
const auto itr =
inputTypes
.emplace(std::make_pair(inputType.type,
schema::InputObjectType::Make(inputType.type, inputType.description)))
.first;
_schema->AddType(inputType.type, itr->second);
}
}
std::map<std::string_view, std::shared_ptr<schema::UnionType>> unionTypes;
if (!_schemaLoader.getUnionTypes().empty())
{
for (const auto& unionType : _schemaLoader.getUnionTypes())
{
const auto itr =
unionTypes
.emplace(std::make_pair(unionType.type,
schema::UnionType::Make(unionType.type, unionType.description)))
.first;
_schema->AddType(unionType.type, itr->second);
}
}
std::map<std::string_view, std::shared_ptr<schema::InterfaceType>> interfaceTypes;
if (!_schemaLoader.getInterfaceTypes().empty())
{
for (const auto& interfaceType : _schemaLoader.getInterfaceTypes())
{
const auto itr =
interfaceTypes
.emplace(std::make_pair(interfaceType.type,
schema::InterfaceType::Make(interfaceType.type, interfaceType.description)))
.first;
_schema->AddType(interfaceType.type, itr->second);
}
}
std::map<std::string_view, std::shared_ptr<schema::ObjectType>> objectTypes;
if (!_schemaLoader.getObjectTypes().empty())
{
for (const auto& objectType : _schemaLoader.getObjectTypes())
{
const auto itr =
objectTypes
.emplace(std::make_pair(objectType.type,
schema::ObjectType::Make(objectType.type, objectType.description)))
.first;
_schema->AddType(objectType.type, itr->second);
}
}
for (const auto& enumType : _schemaLoader.getEnumTypes())
{
const auto itr = enumTypes.find(enumType.type);
if (itr != enumTypes.cend() && !enumType.values.empty())
{
std::vector<schema::EnumValueType> values(enumType.values.size());
std::transform(enumType.values.cbegin(),
enumType.values.cend(),
values.begin(),
[](const EnumValueType& value) noexcept {
return schema::EnumValueType {
value.value,
value.description,
value.deprecationReason,
};
});
itr->second->AddEnumValues(std::move(values));
}
}
for (const auto& inputType : _schemaLoader.getInputTypes())
{
const auto itr = inputTypes.find(inputType.type);
if (itr != inputTypes.cend() && !inputType.fields.empty())
{
std::vector<std::shared_ptr<const schema::InputValue>> fields(inputType.fields.size());
std::transform(inputType.fields.cbegin(),
inputType.fields.cend(),
fields.begin(),
[this](const InputField& field) noexcept {
return schema::InputValue::Make(field.name,
field.description,
getSchemaType(field.type, field.modifiers),
field.defaultValueString);
});
itr->second->AddInputValues(std::move(fields));
}
}
for (const auto& unionType : _schemaLoader.getUnionTypes())
{
const auto itr = unionTypes.find(unionType.type);
if (!unionType.options.empty())
{
std::vector<std::weak_ptr<const schema::BaseType>> options(unionType.options.size());
std::transform(unionType.options.cbegin(),
unionType.options.cend(),
options.begin(),
[this](std::string_view option) noexcept {
return _schema->LookupType(option);
});
itr->second->AddPossibleTypes(std::move(options));
}
}
for (const auto& interfaceType : _schemaLoader.getInterfaceTypes())
{
const auto itr = interfaceTypes.find(interfaceType.type);
if (!interfaceType.fields.empty())
{
std::vector<std::shared_ptr<const schema::Field>> fields(interfaceType.fields.size());
std::transform(interfaceType.fields.cbegin(),
interfaceType.fields.cend(),
fields.begin(),
[this](const OutputField& field) noexcept {
std::vector<std::shared_ptr<const schema::InputValue>> arguments(
field.arguments.size());
std::transform(field.arguments.cbegin(),
field.arguments.cend(),
arguments.begin(),
[this](const InputField& argument) noexcept {
return schema::InputValue::Make(argument.name,
argument.description,
getSchemaType(argument.type, argument.modifiers),
argument.defaultValueString);
});
return schema::Field::Make(field.name,
field.description,
field.deprecationReason,
getSchemaType(field.type, field.modifiers),
std::move(arguments));
});
itr->second->AddFields(std::move(fields));
}
}
for (const auto& objectType : _schemaLoader.getObjectTypes())
{
const auto itr = objectTypes.find(objectType.type);
if (!objectType.interfaces.empty())
{
std::vector<std::shared_ptr<const schema::InterfaceType>> interfaces(
objectType.interfaces.size());
std::transform(objectType.interfaces.cbegin(),
objectType.interfaces.cend(),
interfaces.begin(),
[&interfaceTypes](std::string_view interfaceName) noexcept {
return interfaceTypes[interfaceName];
});
itr->second->AddInterfaces(std::move(interfaces));
}
if (!objectType.fields.empty())
{
std::vector<std::shared_ptr<const schema::Field>> fields(objectType.fields.size());
std::transform(objectType.fields.cbegin(),
objectType.fields.cend(),
fields.begin(),
[this](const OutputField& field) noexcept {
std::vector<std::shared_ptr<const schema::InputValue>> arguments(
field.arguments.size());
std::transform(field.arguments.cbegin(),
field.arguments.cend(),
arguments.begin(),
[this](const InputField& argument) noexcept {
return schema::InputValue::Make(argument.name,
argument.description,
getSchemaType(argument.type, argument.modifiers),
argument.defaultValueString);
});
return schema::Field::Make(field.name,
field.description,
field.deprecationReason,
getSchemaType(field.type, field.modifiers),
std::move(arguments));
});
itr->second->AddFields(std::move(fields));
}
}
for (const auto& directive : _schemaLoader.getDirectives())
{
std::vector<introspection::DirectiveLocation> locations(directive.locations.size());
std::transform(directive.locations.cbegin(),
directive.locations.cend(),
locations.begin(),
[](std::string_view locationName) noexcept {
response::Value locationValue(response::Type::EnumValue);
locationValue.set<std::string>(std::string { locationName });
return service::ModifiedArgument<introspection::DirectiveLocation>::convert(
locationValue);
});
std::vector<std::shared_ptr<const schema::InputValue>> arguments(
directive.arguments.size());
std::transform(directive.arguments.cbegin(),
directive.arguments.cend(),
arguments.begin(),
[this](const InputField& argument) noexcept {
return schema::InputValue::Make(argument.name,
argument.description,
getSchemaType(argument.type, argument.modifiers),
argument.defaultValueString);
});
_schema->AddDirective(schema::Directive::Make(directive.name,
directive.description,
std::move(locations),
std::move(arguments),
directive.isRepeatable));
}
for (const auto& operationType : _schemaLoader.getOperationTypes())
{
const auto itr = objectTypes.find(operationType.type);
if (operationType.operation == service::strQuery)
{
_schema->AddQueryType(itr->second);
}
else if (operationType.operation == service::strMutation)
{
_schema->AddMutationType(itr->second);
}
else if (operationType.operation == service::strSubscription)
{
_schema->AddSubscriptionType(itr->second);
}
}
}