feat(sharetypes): reuse schema types in proxy client

Author: wravery

include/RequestLoader.h

@@ -84,30 +84,32 @@ struct [[nodiscard("unnecessary construction")]] RequestOptions
 	const std::string requestFilename;
 	const std::optional<std::string> operationName;
 	const bool noIntrospection = false;
+	const bool sharedTypes = false;
 };
 
 class SchemaLoader;
 
 class [[nodiscard("unnecessary construction")]] RequestLoader
 {
 public:
-	explicit RequestLoader(RequestOptions && requestOptions, const SchemaLoader& schemaLoader);
+	explicit RequestLoader(RequestOptions&& requestOptions, const SchemaLoader& schemaLoader);
 
 	[[nodiscard("unnecessary call")]] std::string_view getRequestFilename() const noexcept;
 	[[nodiscard("unnecessary call")]] const OperationList& getOperations() const noexcept;
 	[[nodiscard("unnecessary call")]] std::string_view getOperationDisplayName(
 		const Operation& operation) const noexcept;
-	[[nodiscard("unnecessary call")]] std::string getOperationNamespace(const Operation& operation)
-		const noexcept;
-	[[nodiscard("unnecessary call")]] std::string_view getOperationType(const Operation& operation)
-		const noexcept;
+	[[nodiscard("unnecessary call")]] std::string getOperationNamespace(
+		const Operation& operation) const noexcept;
+	[[nodiscard("unnecessary call")]] std::string_view getOperationType(
+		const Operation& operation) const noexcept;
 	[[nodiscard("unnecessary call")]] std::string_view getRequestText() const noexcept;
 
 	[[nodiscard("unnecessary call")]] const ResponseType& getResponseType(
 		const Operation& operation) const noexcept;
 	[[nodiscard("unnecessary call")]] const RequestVariableList& getVariables(
 		const Operation& operation) const noexcept;
 
+	[[nodiscard("unnecessary call")]] bool useSharedTypes() const noexcept;
 	[[nodiscard("unnecessary call")]] const RequestInputTypeList& getReferencedInputTypes(
 		const Operation& operation) const noexcept;
 	[[nodiscard("unnecessary call")]] const RequestSchemaTypeList& getReferencedEnums(
@@ -116,32 +118,30 @@ class [[nodiscard("unnecessary construction")]] RequestLoader
 	[[nodiscard("unnecessary call")]] std::string getInputCppType(
 		const RequestSchemaType& wrappedInputType) const noexcept;
 	[[nodiscard("unnecessary call")]] std::string getInputCppType(
-		const RequestSchemaType& inputType,
-		const TypeModifierStack& modifiers) const noexcept;
+		const RequestSchemaType& inputType, const TypeModifierStack& modifiers) const noexcept;
 	[[nodiscard("unnecessary call")]] static std::string getOutputCppType(
-		std::string_view outputCppType,
-		const TypeModifierStack& modifiers) noexcept;
+		std::string_view outputCppType, const TypeModifierStack& modifiers) noexcept;
 
 	[[nodiscard("unnecessary call")]] static std::pair<RequestSchemaType, TypeModifierStack>
-		unwrapSchemaType(RequestSchemaType && type) noexcept;
+	unwrapSchemaType(RequestSchemaType&& type) noexcept;
 
 private:
 	void buildSchema();
 	void addTypesToSchema();
-	[[nodiscard("unnecessary call")]] RequestSchemaType getSchemaType(std::string_view type,
-		const TypeModifierStack& modifiers) const noexcept;
+	[[nodiscard("unnecessary call")]] RequestSchemaType getSchemaType(
+		std::string_view type, const TypeModifierStack& modifiers) const noexcept;
 	void validateRequest() const;
 
 	[[nodiscard("unnecessary call")]] static std::string_view trimWhitespace(
 		std::string_view content) noexcept;
 
 	void findOperation();
 	void collectFragments() noexcept;
-	void collectVariables(Operation & operation) noexcept;
-	void collectInputTypes(Operation & operation, const RequestSchemaType& variableType) noexcept;
-	void reorderInputTypeDependencies(Operation & operation);
-	void collectEnums(Operation & operation, const RequestSchemaType& variableType) noexcept;
-	void collectEnums(Operation & operation, const ResponseField& responseField) noexcept;
+	void collectVariables(Operation& operation) noexcept;
+	void collectInputTypes(Operation& operation, const RequestSchemaType& variableType) noexcept;
+	void reorderInputTypeDependencies(Operation& operation);
+	void collectEnums(Operation& operation, const RequestSchemaType& variableType) noexcept;
+	void collectEnums(Operation& operation, const ResponseField& responseField) noexcept;
 
 	using FragmentDefinitionMap = std::map<std::string_view, const peg::ast_node*>;
 
@@ -150,8 +150,7 @@ class [[nodiscard("unnecessary construction")]] RequestLoader
 	{
 	public:
 		explicit SelectionVisitor(const SchemaLoader& schemaLoader,
-			const FragmentDefinitionMap& fragments,
-			const std::shared_ptr<schema::Schema>& schema,
+			const FragmentDefinitionMap& fragments, const std::shared_ptr<schema::Schema>& schema,
 			const RequestSchemaType& type);
 
 		void visit(const peg::ast_node& selection);
@@ -163,7 +162,7 @@ class [[nodiscard("unnecessary construction")]] RequestLoader
 		void visitFragmentSpread(const peg::ast_node& fragmentSpread);
 		void visitInlineFragment(const peg::ast_node& inlineFragment);
 
-		void mergeFragmentFields(ResponseFieldList && fragmentFields) noexcept;
+		void mergeFragmentFields(ResponseFieldList&& fragmentFields) noexcept;
 
 		const SchemaLoader& _schemaLoader;
 		const FragmentDefinitionMap& _fragments;

samples/proxy/client.cpp

@@ -5,7 +5,7 @@
 
 #include "schema/ProxySchema.h"
 #include "schema/QueryObject.h"
-#include "schema/ResultsObject.h"
+#include "schema/QueryResultsObject.h"
 
 #include "graphqlservice/JSONResponse.h"
 
@@ -151,9 +151,8 @@ class Query
 	explicit Query(std::string_view host, std::string_view port, std::string_view target,
 		int version) noexcept;
 
-	std::future<std::shared_ptr<proxy::object::Results>> getRelay(std::string&& queryArg,
-		std::optional<std::string>&& operationNameArg,
-		std::optional<std::string>&& variablesArg) const;
+	std::future<std::shared_ptr<proxy::object::QueryResults>> getRelay(
+		proxy::QueryInput&& inputArg) const;
 
 private:
 	const std::string m_host;
@@ -173,21 +172,22 @@ Query::Query(
 
 // Based on:
 // https://www.boost.org/doc/libs/1_82_0/libs/beast/example/http/client/awaitable/http_client_awaitable.cpp
-std::future<std::shared_ptr<proxy::object::Results>> Query::getRelay(std::string&& queryArg,
-	std::optional<std::string>&& operationNameArg, std::optional<std::string>&& variablesArg) const
+std::future<std::shared_ptr<proxy::object::QueryResults>> Query::getRelay(
+	proxy::QueryInput&& inputArg) const
 {
 	response::Value payload { response::Type::Map };
 
-	payload.emplace_back("query"s, response::Value { std::move(queryArg) });
+	payload.emplace_back("query"s, response::Value { std::move(inputArg.query) });
 
-	if (operationNameArg)
+	if (inputArg.operationName)
 	{
-		payload.emplace_back("operationName"s, response::Value { std::move(*operationNameArg) });
+		payload.emplace_back("operationName"s,
+			response::Value { std::move(*inputArg.operationName) });
 	}
 
-	if (variablesArg)
+	if (inputArg.variables)
 	{
-		payload.emplace_back("variables"s, response::Value { std::move(*variablesArg) });
+		payload.emplace_back("variables"s, response::Value { std::move(*inputArg.variables) });
 	}
 
 	std::string requestBody = response::toJSON(std::move(payload));
@@ -199,7 +199,8 @@ std::future<std::shared_ptr<proxy::object::Results>> Query::getRelay(std::string
 			const char* port,
 			const char* target,
 			int version,
-			std::string requestBody) -> net::awaitable<std::shared_ptr<proxy::object::Results>> {
+			std::string requestBody)
+			-> net::awaitable<std::shared_ptr<proxy::object::QueryResults>> {
 			// These objects perform our I/O. They use an executor with a default completion token
 			// of use_awaitable. This makes our code easy, but will use exceptions as the default
 			// error handling, i.e. if the connection drops, we might see an exception.
@@ -252,7 +253,7 @@ std::future<std::shared_ptr<proxy::object::Results>> Query::getRelay(std::string
 
 			auto [data, errors] = client::parseServiceResponse(response::parseJSON(res.body()));
 
-			co_return std::make_shared<proxy::object::Results>(
+			co_return std::make_shared<proxy::object::QueryResults>(
 				std::make_shared<Results>(std::move(data), std::move(errors)));
 		}(m_host.c_str(), m_port.c_str(), m_target.c_str(), m_version, std::move(requestBody)),
 		net::use_future);
@@ -279,15 +280,16 @@ int main(int argc, char** argv)
 		using namespace proxy::client::query::relayQuery;
 
 		auto query = GetRequestObject();
-		auto variables = serializeVariables(
-			{ input, ((argc > 1) ? std::make_optional(argv[1]) : std::nullopt) });
+		auto variables = serializeVariables({ QueryInput { OperationType::QUERY,
+			input,
+			((argc > 1) ? std::make_optional(argv[1]) : std::nullopt),
+			std::nullopt } });
 		auto launch = service::await_async { std::make_shared<service::await_worker_queue>() };
 		auto state = std::make_shared<AsyncIoWorker>();
 		auto serviceResponse = client::parseServiceResponse(
 			service->resolve({ query, GetOperationName(), std::move(variables), launch, state })
 				.get());
-		auto result =
-			proxy::client::query::relayQuery::parseResponse(std::move(serviceResponse.data));
+		auto result = parseResponse(std::move(serviceResponse.data));
 		auto errors = std::move(serviceResponse.errors);
 
 		if (result.relay.data)

samples/proxy/query/CMakeLists.txt

@@ -7,7 +7,8 @@ cmake_minimum_required(VERSION 3.28)
 include(${CMAKE_CURRENT_SOURCE_DIR}/../../../cmake/cppgraphqlgen-functions.cmake)
 
 if(GRAPHQL_UPDATE_SAMPLES AND GRAPHQL_BUILD_CLIENTGEN)
-  update_graphql_client_files(proxy ../schema/schema.graphql query.graphql Proxy proxy)
+  update_graphql_client_files(proxy ../schema/schema.graphql query.graphql Proxy proxy --shared-types)
 endif()
 
 add_graphql_client_target(proxy)
+target_link_libraries(proxy_client PRIVATE proxy_schema)

samples/proxy/query/ProxyClient.cpp

@@ -26,8 +26,8 @@ const std::string& GetRequestText() noexcept
 		# Copyright (c) Microsoft Corporation. All rights reserved.
 		# Licensed under the MIT License.
 		
-		query relayQuery($query: String!, $operationName: String, $variables: String) {
-		  relay(query: $query, operationName: $operationName, variables: $variables) {
+		query relayQuery($input: QueryInput!) {
+		  relay(input: $input) {
 		    data
 		    errors
 		  }
@@ -53,14 +53,70 @@ const peg::ast& GetRequestObject() noexcept
 
 } // namespace client
 } // namespace proxy
+
 namespace client {
 
 using namespace proxy;
 
 template <>
-graphql::proxy::client::query::relayQuery::Response::relay_Results Response<graphql::proxy::client::query::relayQuery::Response::relay_Results>::parse(response::Value&& response)
+response::Value Variable<OperationType>::serialize(OperationType&& value)
+{
+	static const std::array<std::string_view, 3> s_names = {
+		R"gql(QUERY)gql"sv,
+		R"gql(MUTATION)gql"sv,
+		R"gql(SUBSCRIPTION)gql"sv
+	};
+
+	response::Value result { response::Type::EnumValue };
+
+	result.set<std::string>(std::string { s_names[static_cast<std::size_t>(value)] });
+
+	return result;
+}
+
+template <>
+response::Value Variable<QueryInput>::serialize(QueryInput&& inputValue)
+{
+	response::Value result { response::Type::Map };
+
+	result.emplace_back(R"js(type)js"s, ModifiedVariable<OperationType>::serialize(std::move(inputValue.type)));
+	result.emplace_back(R"js(query)js"s, ModifiedVariable<std::string>::serialize(std::move(inputValue.query)));
+	result.emplace_back(R"js(operationName)js"s, ModifiedVariable<std::string>::serialize<TypeModifier::Nullable>(std::move(inputValue.operationName)));
+	result.emplace_back(R"js(variables)js"s, ModifiedVariable<std::string>::serialize<TypeModifier::Nullable>(std::move(inputValue.variables)));
+
+	return result;
+}
+
+template <>
+OperationType Response<OperationType>::parse(response::Value&& value)
+{
+	if (!value.maybe_enum())
+	{
+		throw std::logic_error { R"ex(not a valid OperationType value)ex" };
+	}
+
+	static const std::array<std::pair<std::string_view, OperationType>, 3> s_values = {
+		std::make_pair(R"gql(QUERY)gql"sv, OperationType::QUERY),
+		std::make_pair(R"gql(MUTATION)gql"sv, OperationType::MUTATION),
+		std::make_pair(R"gql(SUBSCRIPTION)gql"sv, OperationType::SUBSCRIPTION)
+	};
+
+	const auto result = internal::sorted_map_lookup<internal::shorter_or_less>(
+		s_values,
+		std::string_view { value.get<std::string>() });
+
+	if (!result)
+	{
+		throw std::logic_error { R"ex(not a valid OperationType value)ex" };
+	}
+
+	return *result;
+}
+
+template <>
+graphql::proxy::client::query::relayQuery::Response::relay_QueryResults Response<graphql::proxy::client::query::relayQuery::Response::relay_QueryResults>::parse(response::Value&& response)
 {
-	graphql::proxy::client::query::relayQuery::Response::relay_Results result;
+	graphql::proxy::client::query::relayQuery::Response::relay_QueryResults result;
 
 	if (response.type() == response::Type::Map)
 	{
@@ -101,9 +157,7 @@ response::Value serializeVariables(Variables&& variables)
 
 	response::Value result { response::Type::Map };
 
-	result.emplace_back(R"js(query)js"s, ModifiedVariable<std::string>::serialize(std::move(variables.query)));
-	result.emplace_back(R"js(operationName)js"s, ModifiedVariable<std::string>::serialize<TypeModifier::Nullable>(std::move(variables.operationName)));
-	result.emplace_back(R"js(variables)js"s, ModifiedVariable<std::string>::serialize<TypeModifier::Nullable>(std::move(variables.variables)));
+	result.emplace_back(R"js(input)js"s, ModifiedVariable<QueryInput>::serialize(std::move(variables.input)));
 
 	return result;
 }
@@ -122,7 +176,7 @@ Response parseResponse(response::Value&& response)
 		{
 			if (member.first == R"js(relay)js"sv)
 			{
-				result.relay = ModifiedResponse<query::relayQuery::Response::relay_Results>::parse(std::move(member.second));
+				result.relay = ModifiedResponse<query::relayQuery::Response::relay_QueryResults>::parse(std::move(member.second));
 				continue;
 			}
 		}

samples/proxy/query/ProxyClient.h

@@ -14,6 +14,8 @@
 
 #include "graphqlservice/internal/Version.h"
 
+#include "ProxySchema.h"
+
 #include <optional>
 #include <string>
 #include <vector>
@@ -29,8 +31,8 @@ namespace graphql::proxy {
 /// # Copyright (c) Microsoft Corporation. All rights reserved.
 /// # Licensed under the MIT License.
 /// 
-/// query relayQuery($query: String!, $operationName: String, $variables: String) {
-///   relay(query: $query, operationName: $operationName, variables: $variables) {
+/// query relayQuery($input: QueryInput!) {
+///   relay(input: $input) {
 ///     data
 ///     errors
 ///   }
@@ -52,24 +54,26 @@ using graphql::proxy::client::GetRequestObject;
 // Return the name of this operation in the shared request document.
 [[nodiscard("unnecessary call")]] const std::string& GetOperationName() noexcept;
 
+using graphql::proxy::OperationType;
+
+using graphql::proxy::QueryInput;
+
 struct [[nodiscard("unnecessary construction")]] Variables
 {
-	std::string query {};
-	std::optional<std::string> operationName {};
-	std::optional<std::string> variables {};
+	QueryInput input {};
 };
 
 [[nodiscard("unnecessary conversion")]] response::Value serializeVariables(Variables&& variables);
 
 struct [[nodiscard("unnecessary construction")]] Response
 {
-	struct [[nodiscard("unnecessary construction")]] relay_Results
+	struct [[nodiscard("unnecessary construction")]] relay_QueryResults
 	{
 		std::optional<std::string> data {};
 		std::optional<std::vector<std::optional<std::string>>> errors {};
 	};
 
-	relay_Results relay {};
+	relay_QueryResults relay {};
 };
 
 [[nodiscard("unnecessary conversion")]] Response parseResponse(response::Value&& response);

samples/proxy/query/ProxyClient.ixx

@@ -16,12 +16,24 @@ namespace client {
 using client::GetRequestText;
 using client::GetRequestObject;
 
+} // namespace client
+
+using proxy::OperationType;
+
+using proxy::QueryInput;
+
+namespace client {
+
 namespace query::relayQuery {
 
 using graphql::proxy::client::GetRequestText;
 using graphql::proxy::client::GetRequestObject;
 using relayQuery::GetOperationName;
 
+using graphql::proxy::OperationType;
+
+using graphql::proxy::QueryInput;
+
 using relayQuery::Variables;
 using relayQuery::serializeVariables;
 

samples/proxy/query/query.graphql

@@ -1,8 +1,8 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 
-query relayQuery($query: String!, $operationName: String, $variables: String) {
-  relay(query: $query, operationName: $operationName, variables: $variables) {
+query relayQuery($input: QueryInput!) {
+  relay(input: $input) {
     data
     errors
   }