Merge pull request #113 from wravery/master

Make fragment type conditions recognize union types

Author: wravery

cmake/version.txt

@@ -1 +1 @@
-3.2.3
+3.2.4

include/SchemaGenerator.h

@@ -200,6 +200,7 @@ struct ObjectType
 	std::string type;
 	std::string cppType;
 	std::vector<std::string> interfaces;
+	std::vector<std::string> unions;
 	OutputFieldList fields;
 	std::string description;
 };

samples/separate/AppointmentObject.cpp

@@ -17,6 +17,7 @@ namespace object {
 Appointment::Appointment()
 	: service::Object({
 		"Node",
+		"UnionType",
 		"Appointment"
 	}, {
 		{ "id", [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },

samples/separate/FolderObject.cpp

@@ -17,6 +17,7 @@ namespace object {
 Folder::Folder()
 	: service::Object({
 		"Node",
+		"UnionType",
 		"Folder"
 	}, {
 		{ "id", [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },

samples/separate/TaskObject.cpp

@@ -17,6 +17,7 @@ namespace object {
 Task::Task()
 	: service::Object({
 		"Node",
+		"UnionType",
 		"Task"
 	}, {
 		{ "id", [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },

samples/unified/TodaySchema.cpp

@@ -736,6 +736,7 @@ std::future<response::Value> Subscription::resolve_typename(service::ResolverPar
 Appointment::Appointment()
 	: service::Object({
 		"Node",
+		"UnionType",
 		"Appointment"
 	}, {
 		{ "id", [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
@@ -811,6 +812,7 @@ std::future<response::Value> Appointment::resolve_typename(service::ResolverPara
 Task::Task()
 	: service::Object({
 		"Node",
+		"UnionType",
 		"Task"
 	}, {
 		{ "id", [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
@@ -871,6 +873,7 @@ std::future<response::Value> Task::resolve_typename(service::ResolverParams&& pa
 Folder::Folder()
 	: service::Object({
 		"Node",
+		"UnionType",
 		"Folder"
 	}, {
 		{ "id", [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },

samples/validation/ValidationSchema.cpp

@@ -247,6 +247,8 @@ std::future<response::Value> Query::resolve_type(service::ResolverParams&& param
 Dog::Dog()
 	: service::Object({
 		"Pet",
+		"CatOrDog",
+		"DogOrHuman",
 		"Dog"
 	}, {
 		{ "name", [this](service::ResolverParams&& params) { return resolveName(std::move(params)); } },
@@ -354,6 +356,7 @@ std::future<response::Value> Dog::resolve_typename(service::ResolverParams&& par
 Alien::Alien()
 	: service::Object({
 		"Sentient",
+		"HumanOrAlien",
 		"Alien"
 	}, {
 		{ "name", [this](service::ResolverParams&& params) { return resolveName(std::move(params)); } },
@@ -399,6 +402,8 @@ std::future<response::Value> Alien::resolve_typename(service::ResolverParams&& p
 Human::Human()
 	: service::Object({
 		"Sentient",
+		"DogOrHuman",
+		"HumanOrAlien",
 		"Human"
 	}, {
 		{ "name", [this](service::ResolverParams&& params) { return resolveName(std::move(params)); } },
@@ -444,6 +449,7 @@ std::future<response::Value> Human::resolve_typename(service::ResolverParams&& p
 Cat::Cat()
 	: service::Object({
 		"Pet",
+		"CatOrDog",
 		"Cat"
 	}, {
 		{ "name", [this](service::ResolverParams&& params) { return resolveName(std::move(params)); } },

src/SchemaGenerator.cpp

@@ -520,6 +520,35 @@ void Generator::validateSchema()
 			}
 		}
 	}
+
+	// Validate the objects that are possible types for unions and add the unions to
+	// the list of matching types for the objects.
+	for (const auto& entry : _unionTypes)
+	{
+		for (const auto& objectName : entry.options)
+		{
+			auto itr = _objectNames.find(objectName);
+
+			if (itr == _objectNames.cend())
+			{
+				std::ostringstream error;
+				auto itrPosition = _typePositions.find(entry.type);
+
+				error << "Unknown type: " << objectName
+					  << " included by: " << entry.type;
+
+				if (itrPosition != _typePositions.cend())
+				{
+					error << " line: " << itrPosition->second.line
+						  << " column: " << itrPosition->second.column;
+				}
+
+				throw std::runtime_error(error.str());
+			}
+
+			_objectTypes[itr->second].unions.push_back(entry.type);
+		}
+	}
 }
 
 void Generator::fixupOutputFieldList(OutputFieldList& fields, const std::optional<std::unordered_set<std::string>>& interfaceFields, const std::optional<std::string_view>& accessor)
@@ -776,7 +805,8 @@ void Generator::visitObjectTypeDefinition(const peg::ast_node& objectTypeDefinit
 
 	auto cppName = getSafeCppName(name);
 
-	_objectTypes.push_back({ std::move(name), std::move(cppName), {}, {}, std::move(description) });
+	_objectTypes.push_back(
+		{ std::move(name), std::move(cppName), {}, {}, {}, std::move(description) });
 
 	visitObjectTypeExtension(objectTypeDefinition);
 }
@@ -2750,6 +2780,12 @@ void Generator::outputObjectImplementation(std::ostream& sourceFile, const Objec
 )cpp";
 	}
 
+	for (const auto& unionName : objectType.unions)
+	{
+		sourceFile << R"cpp(		")cpp" << unionName << R"cpp(",
+)cpp";
+	}
+
 	sourceFile << R"cpp(		")cpp" << objectType.type << R"cpp("
 	}, {
 )cpp";

test/TodayTests.cpp

@@ -1343,3 +1343,73 @@ TEST_F(TodayServiceCase, BlockingAsyncExpensive)
 		FAIL() << response::toJSON(ex.getErrors());
 	}
 }
+
+TEST_F(TodayServiceCase, QueryAppointmentsThroughUnionTypeFragment)
+{
+	auto query = R"({
+			appointments {
+				edges {
+					node {
+						...AppointmentUnionFragment
+					}
+				}
+			}
+		}
+
+		fragment AppointmentUnionFragment on UnionType {
+			...on Appointment {
+				appointmentId: id
+				subject
+				when
+				isNow
+			}
+		})"_graphql;
+	response::Value variables(response::Type::Map);
+	auto state = std::make_shared<today::RequestState>(20);
+	auto result = _service->resolve(state, query, "", std::move(variables)).get();
+	EXPECT_EQ(size_t(1), _getAppointmentsCount)
+		<< "today service lazy loads the appointments and caches the result";
+	EXPECT_GE(size_t(1), _getTasksCount)
+		<< "today service lazy loads the tasks and caches the result";
+	EXPECT_GE(size_t(1), _getUnreadCountsCount)
+		<< "today service lazy loads the unreadCounts and caches the result";
+	EXPECT_EQ(size_t(20), state->appointmentsRequestId)
+		<< "today service passed the same RequestState";
+	EXPECT_EQ(size_t(0), state->tasksRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->unreadCountsRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(1), state->loadAppointmentsCount) << "today service called the loader once";
+	EXPECT_EQ(size_t(0), state->loadTasksCount) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->loadUnreadCountsCount) << "today service did not call the loader";
+
+	try
+	{
+		ASSERT_TRUE(result.type() == response::Type::Map);
+		auto errorsItr = result.find("errors");
+		if (errorsItr != result.get<response::MapType>().cend())
+		{
+			FAIL() << response::toJSON(response::Value(errorsItr->second));
+		}
+		const auto data = service::ScalarArgument::require("data", result);
+
+		const auto appointments = service::ScalarArgument::require("appointments", data);
+		const auto appointmentEdges =
+			service::ScalarArgument::require<service::TypeModifier::List>("edges", appointments);
+		ASSERT_EQ(1, appointmentEdges.size()) << "appointments should have 1 entry";
+		ASSERT_TRUE(appointmentEdges[0].type() == response::Type::Map)
+			<< "appointment should be an object";
+		const auto appointmentNode = service::ScalarArgument::require("node", appointmentEdges[0]);
+		EXPECT_EQ(_fakeAppointmentId,
+			service::IdArgument::require("appointmentId", appointmentNode))
+			<< "id should match in base64 encoding";
+		EXPECT_EQ("Lunch?", service::StringArgument::require("subject", appointmentNode))
+			<< "subject should match";
+		EXPECT_EQ("tomorrow", service::StringArgument::require("when", appointmentNode))
+			<< "when should match";
+		EXPECT_FALSE(service::BooleanArgument::require("isNow", appointmentNode))
+			<< "isNow should match";
+	}
+	catch (service::schema_exception& ex)
+	{
+		FAIL() << response::toJSON(ex.getErrors());
+	}
+}