chore: regenerate samples with enum validation

Author: wravery

samples/learn/schema/StarWarsSharedTypes.cpp

@@ -50,7 +50,14 @@ service::AwaitableResolver Result<learn::Episode>::convert(service::AwaitableSca
 	return ModifiedResult<learn::Episode>::resolve(std::move(result), std::move(params),
 		[](learn::Episode value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesEpisode[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesEpisode.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for Episode)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesEpisode[idx] } } } };
 		});
 }
 

samples/proxy/schema/ProxySharedTypes.cpp

@@ -50,7 +50,14 @@ service::AwaitableResolver Result<proxy::OperationType>::convert(service::Awaita
 	return ModifiedResult<proxy::OperationType>::resolve(std::move(result), std::move(params),
 		[](proxy::OperationType value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesOperationType[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesOperationType.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for OperationType)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesOperationType[idx] } } } };
 		});
 }
 

samples/today/nointrospection/TodaySharedTypes.cpp

@@ -50,7 +50,14 @@ service::AwaitableResolver Result<today::TaskState>::convert(service::AwaitableS
 	return ModifiedResult<today::TaskState>::resolve(std::move(result), std::move(params),
 		[](today::TaskState value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesTaskState[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesTaskState.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for TaskState)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesTaskState[idx] } } } };
 		});
 }
 

samples/today/schema/TodaySharedTypes.cpp

@@ -50,7 +50,14 @@ service::AwaitableResolver Result<today::TaskState>::convert(service::AwaitableS
 	return ModifiedResult<today::TaskState>::resolve(std::move(result), std::move(params),
 		[](today::TaskState value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesTaskState[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesTaskState.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for TaskState)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesTaskState[idx] } } } };
 		});
 }
 

samples/validation/schema/ValidationSharedTypes.cpp

@@ -50,7 +50,14 @@ service::AwaitableResolver Result<validation::DogCommand>::convert(service::Awai
 	return ModifiedResult<validation::DogCommand>::resolve(std::move(result), std::move(params),
 		[](validation::DogCommand value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesDogCommand[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesDogCommand.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for DogCommand)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesDogCommand[idx] } } } };
 		});
 }
 
@@ -102,7 +109,14 @@ service::AwaitableResolver Result<validation::CatCommand>::convert(service::Awai
 	return ModifiedResult<validation::CatCommand>::resolve(std::move(result), std::move(params),
 		[](validation::CatCommand value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesCatCommand[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesCatCommand.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for CatCommand)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesCatCommand[idx] } } } };
 		});
 }
 

src/SchemaGenerator.cpp

@@ -1692,12 +1692,14 @@ service::AwaitableResolver Result<)cpp"
 				   << R"cpp(::)cpp" << enumType.cppType << R"cpp( value, const ResolverParams&)
 		{
 			const size_t idx = static_cast<size_t>(value);
+
 			if (idx >= s_names)cpp"
 					   << enumType.cppType << R"cpp(.size())
 			{
 				throw service::schema_exception { { R"ex(Enum value out of range for )cpp"
 					   << enumType.type << R"cpp()ex" } };
 			}
+
 			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_names)cpp"
 				   << enumType.cppType << R"cpp([idx] } } } };
 		});

src/introspection/IntrospectionSharedTypes.cpp

@@ -50,7 +50,14 @@ service::AwaitableResolver Result<introspection::TypeKind>::convert(service::Awa
 	return ModifiedResult<introspection::TypeKind>::resolve(std::move(result), std::move(params),
 		[](introspection::TypeKind value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesTypeKind[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesTypeKind.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for __TypeKind)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesTypeKind[idx] } } } };
 		});
 }
 
@@ -102,7 +109,14 @@ service::AwaitableResolver Result<introspection::DirectiveLocation>::convert(ser
 	return ModifiedResult<introspection::DirectiveLocation>::resolve(std::move(result), std::move(params),
 		[](introspection::DirectiveLocation value, const ResolverParams&)
 		{
-			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesDirectiveLocation[static_cast<std::size_t>(value)] } } } };
+			const size_t idx = static_cast<size_t>(value);
+
+			if (idx >= s_namesDirectiveLocation.size())
+			{
+				throw service::schema_exception { { R"ex(Enum value out of range for __DirectiveLocation)ex" } };
+			}
+
+			return ResolverResult { { response::ValueToken::EnumValue { std::string { s_namesDirectiveLocation[idx] } } } };
 		});
 }