Port reorderInputTypeDependencies to RequestLoader

Author: wravery

include/RequestLoader.h

@@ -97,6 +97,7 @@ class RequestLoader
 	void collectFragments() noexcept;
 	void collectVariables() noexcept;
 	void collectInputTypes(const RequestSchemaType& variableType) noexcept;
+	void reorderInputTypeDependencies() noexcept;
 	void collectEnums(const RequestSchemaType& variableType) noexcept;
 	void collectEnums(const ResponseField& responseField) noexcept;
 

src/RequestLoader.cpp

@@ -68,6 +68,9 @@ RequestLoader::RequestLoader(RequestOptions&& requestOptions, const SchemaLoader
 		collectEnums(variable.type);
 	}
 
+	// Handle nested input types by fully declaring the dependencies first.
+	reorderInputTypeDependencies();
+
 	for (const auto& responseField : _responseType.fields)
 	{
 		collectEnums(responseField);
@@ -774,6 +777,86 @@ void RequestLoader::collectInputTypes(const RequestSchemaType& variableType) noe
 	}
 }
 
+void RequestLoader::reorderInputTypeDependencies() noexcept
+{
+	if (_referencedInputTypes.empty())
+	{
+		return;
+	}
+
+	// Build the dependency list for each input type.
+	struct InputTypeDependencies
+	{
+		RequestSchemaType type;
+		std::string_view name;
+		std::unordered_set<std::string_view> dependencies;
+	};
+
+	std::vector<InputTypeDependencies> inputTypes(_referencedInputTypes.size());
+
+	std::transform(_referencedInputTypes.cbegin(),
+		_referencedInputTypes.cend(),
+		inputTypes.begin(),
+		[](const RequestSchemaType& type) noexcept {
+			InputTypeDependencies result { type, type->name() };
+			const auto& fields = type->inputFields();
+
+			std::for_each(fields.begin(),
+				fields.end(),
+				[&result](const std::shared_ptr<const schema::InputValue>& field) noexcept {
+					const auto fieldType = field->type().lock();
+
+					if (fieldType->kind() == introspection::TypeKind::INPUT_OBJECT)
+					{
+						result.dependencies.insert(fieldType->name());
+					}
+				});
+
+			return result;
+		});
+
+	std::unordered_set<std::string_view> handled;
+	auto itr = inputTypes.begin();
+
+	while (itr != inputTypes.end())
+	{
+		// Put all of the input types without unhandled dependencies at the front.
+		const auto itrDependent = std::stable_partition(itr,
+			inputTypes.end(),
+			[&handled](const InputTypeDependencies& entry) noexcept {
+				return std::find_if(entry.dependencies.cbegin(),
+						   entry.dependencies.cend(),
+						   [&handled](std::string_view dependency) noexcept {
+							   return handled.find(dependency) == handled.cend();
+						   })
+					== entry.dependencies.cend();
+			});
+
+		if (itrDependent != inputTypes.end())
+		{
+			std::for_each(itr,
+				itrDependent,
+				[&handled](const InputTypeDependencies& entry) noexcept {
+					handled.insert(entry.name);
+				});
+		}
+
+		itr = itrDependent;
+	}
+
+	if (!handled.empty())
+	{
+		std::transform(inputTypes.begin(),
+			inputTypes.end(),
+			_referencedInputTypes.begin(),
+			[](InputTypeDependencies& entry) noexcept {
+				auto result = std::move(entry.type);
+
+				return result;
+			});
+	}
+}
+
 void RequestLoader::collectEnums(const RequestSchemaType& variableType) noexcept
 {
 	// Enums may be referenced in any variable input type or in the response itself.
@@ -816,7 +899,8 @@ void RequestLoader::collectEnums(const ResponseField& responseField) noexcept
 		{
 			if (responseField.children)
 			{
-				for (const auto& responseType : std::get<ResponseUnionOptions>(*responseField.children))
+				for (const auto& responseType :
+					std::get<ResponseUnionOptions>(*responseField.children))
 				{
 					for (const auto& field : responseType.fields)
 					{

src/SchemaLoader.cpp

@@ -500,18 +500,16 @@ void SchemaLoader::fixupInputFieldList(InputFieldList& fields)
 void SchemaLoader::reorderInputTypeDependencies()
 {
 	// Build the dependency list for each input type.
-	for (auto& entry : _inputTypes)
-	{
-		fixupInputFieldList(entry.fields);
-
-		for (auto& field : entry.fields)
-		{
-			if (field.fieldType == InputFieldType::Input)
-			{
-				entry.dependencies.insert(field.type);
-			}
-		}
-	}
+	std::for_each(_inputTypes.begin(), _inputTypes.end(), [](InputType& entry) noexcept {
+		std::for_each(entry.fields.cbegin(),
+			entry.fields.cend(),
+			[&entry](const InputField& field) noexcept {
+				if (field.fieldType == InputFieldType::Input)
+				{
+					entry.dependencies.insert(field.type);
+				}
+			});
+	});
 
 	std::unordered_set<std::string_view> handled;
 	auto itr = _inputTypes.begin();
@@ -521,16 +519,14 @@ void SchemaLoader::reorderInputTypeDependencies()
 		// Put all of the input types without unhandled dependencies at the front.
 		const auto itrDependent = std::stable_partition(itr,
 			_inputTypes.end(),
-			[&handled](const InputType& entry) noexcept
-		{
-			return std::find_if(entry.dependencies.cbegin(),
-				entry.dependencies.cend(),
-				[&handled](std::string_view dependency) noexcept
-			{
-				return handled.find(dependency) == handled.cend();
-			})
-				== entry.dependencies.cend();
-		});
+			[&handled](const InputType& entry) noexcept {
+				return std::find_if(entry.dependencies.cbegin(),
+						   entry.dependencies.cend(),
+						   [&handled](std::string_view dependency) noexcept {
+							   return handled.find(dependency) == handled.cend();
+						   })
+					== entry.dependencies.cend();
+			});
 
 		// Check to make sure we made progress.
 		if (itrDependent == itr)
@@ -544,8 +540,7 @@ void SchemaLoader::reorderInputTypeDependencies()
 
 		if (itrDependent != _inputTypes.end())
 		{
-			std::for_each(itr, itrDependent, [&handled](const InputType& entry) noexcept
-			{
+			std::for_each(itr, itrDependent, [&handled](const InputType& entry) noexcept {
 				handled.insert(entry.type);
 			});
 		}