Distinguish AwaitableScalar from AwaitableObject

Author: wravery

doc/resolvers.md

@@ -73,7 +73,7 @@ service::AwaitableResolver resolveId(service::ResolverParams&& params);
 ```
 In this example, the `resolveId` method invokes `getId`:
 ```cpp
-virtual service::FieldResult<response::IdType> getId(service::FieldParams&& params) const override;
+virtual service::AwaitableScalar<response::IdType> getId(service::FieldParams&& params) const override;
 ```
 
 There are a couple of interesting quirks in this example:

include/graphqlservice/GraphQLService.h

@@ -295,19 +295,25 @@ struct FieldParams : SelectionSetParams
 // Field accessors may return either a result of T, an awaitable of T, or a std::future<T>, so at
 // runtime the implementer may choose to return by value or defer/parallelize expensive operations
 // by returning an async future or an awaitable coroutine.
+//
+// If the overhead of conversion to response::Value is too expensive, scalar type field accessors
+// can store and return a std::shared_ptr<const response::Value> directly. However, be careful using
+// this mechanism, because there's no validation that the response::Value you return matches the
+// GraphQL type of this field. It will be inserted directly into the response document without
+// modification.
 template <typename T>
-class FieldResult
+class AwaitableScalar
 {
 public:
 	template <typename U>
-	FieldResult(U&& value)
+	AwaitableScalar(U&& value)
 		: _value { std::forward<U>(value) }
 	{
 	}
 
 	struct promise_type
 	{
-		FieldResult<T> get_return_object() noexcept
+		AwaitableScalar<T> get_return_object() noexcept
 		{
 			return { _promise.get_future() };
 		}
@@ -421,6 +427,108 @@ class FieldResult
 	std::variant<T, std::future<T>, std::shared_ptr<const response::Value>> _value;
 };
 
+// Field accessors may return either a result of T, an awaitable of T, or a std::future<T>, so at
+// runtime the implementer may choose to return by value or defer/parallelize expensive operations
+// by returning an async future or an awaitable coroutine.
+template <typename T>
+class AwaitableObject
+{
+public:
+	template <typename U>
+	AwaitableObject(U&& value)
+		: _value { std::forward<U>(value) }
+	{
+	}
+
+	struct promise_type
+	{
+		AwaitableObject<T> get_return_object() noexcept
+		{
+			return { _promise.get_future() };
+		}
+
+		coro::suspend_never initial_suspend() const noexcept
+		{
+			return {};
+		}
+
+		coro::suspend_never final_suspend() const noexcept
+		{
+			return {};
+		}
+
+		void return_value(const T& value) noexcept(std::is_nothrow_copy_constructible_v<T>)
+		{
+			_promise.set_value(value);
+		}
+
+		void return_value(T&& value) noexcept(std::is_nothrow_move_constructible_v<T>)
+		{
+			_promise.set_value(std::move(value));
+		}
+
+		void unhandled_exception() noexcept
+		{
+			_promise.set_exception(std::current_exception());
+		}
+
+	private:
+		std::promise<T> _promise;
+	};
+
+	bool await_ready() const noexcept
+	{
+		return std::visit(
+			[](const auto& value) noexcept {
+				using value_type = std::decay_t<decltype(value)>;
+
+				if constexpr (std::is_same_v<value_type, T>)
+				{
+					return true;
+				}
+				else if constexpr (std::is_same_v<value_type, std::future<T>>)
+				{
+					using namespace std::literals;
+
+					return value.wait_for(0s) != std::future_status::timeout;
+				}
+			},
+			_value);
+	}
+
+	void await_suspend(coro::coroutine_handle<> h) const
+	{
+		std::thread(
+			[this](coro::coroutine_handle<> h) noexcept {
+				std::get<std::future<T>>(_value).wait();
+				h.resume();
+			},
+			std::move(h))
+			.detach();
+	}
+
+	T await_resume()
+	{
+		return std::visit(
+			[](auto&& value) -> T {
+				using value_type = std::decay_t<decltype(value)>;
+
+				if constexpr (std::is_same_v<value_type, T>)
+				{
+					return T { std::move(value) };
+				}
+				else if constexpr (std::is_same_v<value_type, std::future<T>>)
+				{
+					return value.get();
+				}
+			},
+			std::move(_value));
+	}
+
+private:
+	std::variant<T, std::future<T>> _value;
+};
+
 // Fragments are referenced by name and have a single type condition (except for inline
 // fragments, where the type condition is common but optional). They contain a set of fields
 // (with optional aliases and sub-selections) and potentially references to other fragments.
@@ -708,7 +816,8 @@ struct ModifiedResult
 				std::vector<typename ResultTraits<U, Other...>::type>,
 				typename std::conditional_t<std::is_base_of_v<Object, U>, std::shared_ptr<U>, U>>>;
 
-		using future_type = FieldResult<type>;
+		using future_type = typename std::conditional_t<std::is_base_of_v<Object, U>,
+			AwaitableObject<type>, AwaitableScalar<type>>;
 	};
 
 	template <typename U>
@@ -718,7 +827,7 @@ struct ModifiedResult
 			typename std::conditional_t<std::is_base_of_v<Object, U>, std::shared_ptr<U>, U>;
 
 		using future_type = typename std::conditional_t<std::is_base_of_v<Object, U>,
-			FieldResult<std::shared_ptr<Object>>, FieldResult<type>>;
+			AwaitableObject<std::shared_ptr<Object>>, AwaitableScalar<type>>;
 	};
 
 	// Convert a single value of the specified type to JSON.
@@ -730,20 +839,13 @@ struct ModifiedResult
 	static typename std::enable_if_t<TypeModifier::None == Modifier && sizeof...(Other) == 0
 			&& !std::is_same_v<Object, Type> && std::is_base_of_v<Object, Type>,
 		AwaitableResolver>
-	convert(FieldResult<typename ResultTraits<Type>::type> result, ResolverParams params)
+	convert(AwaitableObject<typename ResultTraits<Type>::type> result, ResolverParams params)
 	{
 		// Call through to the Object specialization with a static_pointer_cast for subclasses of
 		// Object.
 		static_assert(std::is_same_v<std::shared_ptr<Type>, typename ResultTraits<Type>::type>,
 			"this is the derived object type");
 
-		auto value = result.get_value();
-
-		if (value)
-		{
-			co_return ResolverResult { response::Value { std::shared_ptr { std::move(value) } } };
-		}
-
 		co_await params.launch;
 
 		auto awaitedResult = co_await ModifiedResult<Object>::convert(
@@ -772,13 +874,6 @@ struct ModifiedResult
 	convert(
 		typename ResultTraits<Type, Modifier, Other...>::future_type result, ResolverParams params)
 	{
-		auto value = result.get_value();
-
-		if (value)
-		{
-			co_return ResolverResult { response::Value { std::shared_ptr { std::move(value) } } };
-		}
-
 		co_await params.launch;
 
 		auto awaitedResult = co_await std::move(result);
@@ -806,11 +901,15 @@ struct ModifiedResult
 						  typename ResultTraits<Type, Modifier, Other...>::type>,
 			"this is the optional version");
 
-		auto value = result.get_value();
-
-		if (value)
+		if constexpr (!std::is_base_of_v<Object, Type>)
 		{
-			co_return ResolverResult { response::Value { std::shared_ptr { std::move(value) } } };
+			auto value = result.get_value();
+
+			if (value)
+			{
+				co_return ResolverResult { response::Value {
+					std::shared_ptr { std::move(value) } } };
+			}
 		}
 
 		co_await params.launch;
@@ -833,11 +932,15 @@ struct ModifiedResult
 	static typename std::enable_if_t<TypeModifier::List == Modifier, AwaitableResolver> convert(
 		typename ResultTraits<Type, Modifier, Other...>::future_type result, ResolverParams params)
 	{
-		auto value = result.get_value();
-
-		if (value)
+		if constexpr (!std::is_base_of_v<Object, Type>)
 		{
-			co_return ResolverResult { response::Value { std::shared_ptr { std::move(value) } } };
+			auto value = result.get_value();
+
+			if (value)
+			{
+				co_return ResolverResult { response::Value {
+					std::shared_ptr { std::move(value) } } };
+			}
 		}
 
 		std::vector<AwaitableResolver> children;
@@ -988,25 +1091,25 @@ using ObjectResult = ModifiedResult<Object>;
 // Export all of the built-in converters
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<int>::convert(
-	FieldResult<int> result, ResolverParams params);
+	AwaitableScalar<int> result, ResolverParams params);
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<double>::convert(
-	FieldResult<double> result, ResolverParams params);
+	AwaitableScalar<double> result, ResolverParams params);
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<std::string>::convert(
-	FieldResult<std::string> result, ResolverParams params);
+	AwaitableScalar<std::string> result, ResolverParams params);
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<bool>::convert(
-	FieldResult<bool> result, ResolverParams params);
+	AwaitableScalar<bool> result, ResolverParams params);
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<response::IdType>::convert(
-	FieldResult<response::IdType> result, ResolverParams params);
+	AwaitableScalar<response::IdType> result, ResolverParams params);
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<response::Value>::convert(
-	FieldResult<response::Value> result, ResolverParams params);
+	AwaitableScalar<response::Value> result, ResolverParams params);
 template <>
 GRAPHQLSERVICE_EXPORT AwaitableResolver ModifiedResult<Object>::convert(
-	FieldResult<std::shared_ptr<Object>> result, ResolverParams params);
+	AwaitableObject<std::shared_ptr<Object>> result, ResolverParams params);
 #endif // GRAPHQL_DLLEXPORTS
 
 // Subscription callbacks receive the response::Value representing the result of evaluating the

include/graphqlservice/introspection/DirectiveObject.h

@@ -28,11 +28,11 @@ class Directive
 	{
 		virtual ~Concept() = default;
 
-		virtual service::FieldResult<std::string> getName() const = 0;
-		virtual service::FieldResult<std::optional<std::string>> getDescription() const = 0;
-		virtual service::FieldResult<std::vector<DirectiveLocation>> getLocations() const = 0;
-		virtual service::FieldResult<std::vector<std::shared_ptr<InputValue>>> getArgs() const = 0;
-		virtual service::FieldResult<bool> getIsRepeatable() const = 0;
+		virtual service::AwaitableScalar<std::string> getName() const = 0;
+		virtual service::AwaitableScalar<std::optional<std::string>> getDescription() const = 0;
+		virtual service::AwaitableScalar<std::vector<DirectiveLocation>> getLocations() const = 0;
+		virtual service::AwaitableObject<std::vector<std::shared_ptr<InputValue>>> getArgs() const = 0;
+		virtual service::AwaitableScalar<bool> getIsRepeatable() const = 0;
 	};
 
 	template <class T>
@@ -44,27 +44,27 @@ class Directive
 		{
 		}
 
-		service::FieldResult<std::string> getName() const final
+		service::AwaitableScalar<std::string> getName() const final
 		{
 			return { _pimpl->getName() };
 		}
 
-		service::FieldResult<std::optional<std::string>> getDescription() const final
+		service::AwaitableScalar<std::optional<std::string>> getDescription() const final
 		{
 			return { _pimpl->getDescription() };
 		}
 
-		service::FieldResult<std::vector<DirectiveLocation>> getLocations() const final
+		service::AwaitableScalar<std::vector<DirectiveLocation>> getLocations() const final
 		{
 			return { _pimpl->getLocations() };
 		}
 
-		service::FieldResult<std::vector<std::shared_ptr<InputValue>>> getArgs() const final
+		service::AwaitableObject<std::vector<std::shared_ptr<InputValue>>> getArgs() const final
 		{
 			return { _pimpl->getArgs() };
 		}
 
-		service::FieldResult<bool> getIsRepeatable() const final
+		service::AwaitableScalar<bool> getIsRepeatable() const final
 		{
 			return { _pimpl->getIsRepeatable() };
 		}

include/graphqlservice/introspection/EnumValueObject.h

@@ -27,10 +27,10 @@ class EnumValue
 	{
 		virtual ~Concept() = default;
 
-		virtual service::FieldResult<std::string> getName() const = 0;
-		virtual service::FieldResult<std::optional<std::string>> getDescription() const = 0;
-		virtual service::FieldResult<bool> getIsDeprecated() const = 0;
-		virtual service::FieldResult<std::optional<std::string>> getDeprecationReason() const = 0;
+		virtual service::AwaitableScalar<std::string> getName() const = 0;
+		virtual service::AwaitableScalar<std::optional<std::string>> getDescription() const = 0;
+		virtual service::AwaitableScalar<bool> getIsDeprecated() const = 0;
+		virtual service::AwaitableScalar<std::optional<std::string>> getDeprecationReason() const = 0;
 	};
 
 	template <class T>
@@ -42,22 +42,22 @@ class EnumValue
 		{
 		}
 
-		service::FieldResult<std::string> getName() const final
+		service::AwaitableScalar<std::string> getName() const final
 		{
 			return { _pimpl->getName() };
 		}
 
-		service::FieldResult<std::optional<std::string>> getDescription() const final
+		service::AwaitableScalar<std::optional<std::string>> getDescription() const final
 		{
 			return { _pimpl->getDescription() };
 		}
 
-		service::FieldResult<bool> getIsDeprecated() const final
+		service::AwaitableScalar<bool> getIsDeprecated() const final
 		{
 			return { _pimpl->getIsDeprecated() };
 		}
 
-		service::FieldResult<std::optional<std::string>> getDeprecationReason() const final
+		service::AwaitableScalar<std::optional<std::string>> getDeprecationReason() const final
 		{
 			return { _pimpl->getDeprecationReason() };
 		}