Flag string values from JSON as potential enum values

Author: wravery

GraphQLResponse.cpp

@@ -80,12 +80,14 @@ Value::Value(Value&& other) noexcept
 	, _map(std::move(other._map))
 	, _list(std::move(other._list))
 	, _string(std::move(other._string))
+	, _from_json(other._from_json)
 	, _scalar(std::move(other._scalar))
 	, _boolean(other._boolean)
 	, _int(other._int)
 	, _float(other._float)
 {
 	const_cast<Type&>(other._type) = Type::Null;
+	other._from_json = false;
 	other._boolean = false;
 	other._int = 0;
 	other._float = 0.0;
@@ -131,6 +133,8 @@ Value& Value::operator=(Value&& rhs) noexcept
 	_map = std::move(rhs._map);
 	_list = std::move(rhs._list);
 	_string = std::move(rhs._string);
+	_from_json = rhs._from_json;
+	rhs._from_json = false;
 	_scalar = std::move(rhs._scalar);
 	_boolean = rhs._boolean;
 	rhs._boolean = false;
@@ -186,11 +190,24 @@ bool Value::operator!=(const Value& rhs) const noexcept
 	return !(*this == rhs);
 }
 
-Type Value::type() const
+Type Value::type() const  noexcept
 {
 	return _type;
 }
 
+Value&& Value::from_json() noexcept
+{
+	_from_json = true;
+
+	return std::move(*this);
+}
+
+bool Value::maybe_enum() const noexcept
+{
+	return _type == Type::EnumValue
+		|| (_from_json && _type == Type::String);
+}
+
 void Value::reserve(size_t count)
 {
 	switch (_type)

JSONResponse.cpp

@@ -185,7 +185,7 @@ struct ResponseHandler
 
 	bool String(const Ch* str, rapidjson::SizeType /*length*/, bool /*copy*/)
 	{
-		setValue(Value(std::string(str)));
+		setValue(Value(std::string(str)).from_json());
 		return true;
 	}
 

SchemaGenerator.cpp

@@ -1623,7 +1623,7 @@ template <>
 			sourceFile << R"cpp(
 	};
 
-	if (value.type() != response::Type::EnumValue)
+	if (!value.maybe_enum())
 	{
 		throw service::schema_exception({ "not a valid )cpp" << enumType.type << R"cpp( value" });
 	}

include/graphqlservice/GraphQLResponse.h

@@ -61,7 +61,12 @@ struct Value
 	bool operator!=(const Value& rhs) const noexcept;
 
 	// Check the Type
-	Type type() const;
+	Type type() const noexcept;
+
+	// JSON doesn't distinguish between Type::String and Type::EnumValue, so if this value comes
+	// from JSON and it's a string we need to track the fact that it can be interpreted as either.
+	Value&& from_json() noexcept;
+	bool maybe_enum() const noexcept;
 
 	// Valid for Type::Map or Type::List
 	void reserve(size_t count);
@@ -102,6 +107,7 @@ struct Value
 
 	// Type::String or Type::EnumValue
 	std::unique_ptr<StringType> _string;
+	bool _from_json = false;
 
 	// Type::Boolean
 	BooleanType _boolean = false;

samples/IntrospectionSchema.cpp

@@ -27,7 +27,7 @@ introspection::__TypeKind ModifiedArgument<introspection::__TypeKind>::convert(c
 		{ "NON_NULL", introspection::__TypeKind::NON_NULL }
 	};
 
-	if (value.type() != response::Type::EnumValue)
+	if (!value.maybe_enum())
 	{
 		throw service::schema_exception({ "not a valid __TypeKind value" });
 	}
@@ -89,7 +89,7 @@ introspection::__DirectiveLocation ModifiedArgument<introspection::__DirectiveLo
 		{ "INPUT_FIELD_DEFINITION", introspection::__DirectiveLocation::INPUT_FIELD_DEFINITION }
 	};
 
-	if (value.type() != response::Type::EnumValue)
+	if (!value.maybe_enum())
 	{
 		throw service::schema_exception({ "not a valid __DirectiveLocation value" });
 	}

samples/TodaySchema.cpp

@@ -25,7 +25,7 @@ today::TaskState ModifiedArgument<today::TaskState>::convert(const response::Val
 		{ "Unassigned", today::TaskState::Unassigned }
 	};
 
-	if (value.type() != response::Type::EnumValue)
+	if (!value.maybe_enum())
 	{
 		throw service::schema_exception({ "not a valid TaskState value" });
 	}

tests.cpp

@@ -1242,6 +1242,50 @@ TEST(ArgumentsCase, TaskStateEnum)
 	EXPECT_EQ(today::TaskState::Started, actual) << "should parse the enum";
 }
 
+TEST(ArgumentsCase, TaskStateEnumFromString)
+{
+	response::Value response(response::Type::Map);
+	response::Value status("Started");
+	response.emplace_back("status", std::move(status));
+	today::TaskState actual = static_cast<today::TaskState>(-1);
+	bool caughtException = false;
+	std::string exceptionWhat;
+
+	try
+	{
+		actual = service::ModifiedArgument<today::TaskState>::require("status", response);
+	}
+	catch (const service::schema_exception& ex)
+	{
+		caughtException = true;
+		exceptionWhat = response::toJSON(response::Value(ex.getErrors()));
+	}
+
+	EXPECT_NE(today::TaskState::Started, actual) << "should not parse the enum from a known string value";
+	ASSERT_TRUE(caughtException);
+	EXPECT_EQ(R"js([{"message":"Invalid argument: status message: not a valid TaskState value"}])js", exceptionWhat) << "exception should match";
+}
+
+TEST(ArgumentsCase, TaskStateEnumFromJSONString)
+{
+	response::Value response(response::Type::Map);
+	response::Value status("Started");
+	response.emplace_back("status", status.from_json());
+	today::TaskState actual = static_cast<today::TaskState>(-1);
+
+
+	try
+	{
+		actual = service::ModifiedArgument<today::TaskState>::require("status", response);
+	}
+	catch (const service::schema_exception& ex)
+	{
+		FAIL() << response::toJSON(response::Value(ex.getErrors()));
+	}
+
+	EXPECT_EQ(today::TaskState::Started, actual) << "should parse the enum";
+}
+
 TEST(PegtlCase, ParseKitchenSinkQuery)
 {
 	memory_input<> input(R"gql(