Not passing tests yet, but refactor is done

Author: wravery

include/Validation.h

@@ -6,12 +6,12 @@
 #ifndef VALIDATION_H
 #define VALIDATION_H
 
+#include "graphqlservice/GraphQLSchema.h"
 #include "graphqlservice/GraphQLService.h"
-#include "graphqlservice/IntrospectionSchema.h"
 
 namespace graphql::service {
 
-using ValidateType = response::Value;
+using ValidateType = std::shared_ptr<schema::BaseType>;
 
 struct ValidateArgument
 {
@@ -20,15 +20,15 @@ struct ValidateArgument
 	ValidateType type;
 };
 
-using ValidateTypeFieldArguments = std::map<std::string, ValidateArgument>;
+using ValidateTypeFieldArguments = std::map<std::string_view, ValidateArgument>;
 
 struct ValidateTypeField
 {
 	ValidateType returnType;
 	ValidateTypeFieldArguments arguments;
 };
 
-using ValidateDirectiveArguments = std::map<std::string, ValidateArgument>;
+using ValidateDirectiveArguments = std::map<std::string_view, ValidateArgument>;
 
 struct ValidateDirective
 {
@@ -40,14 +40,14 @@ struct ValidateArgumentVariable
 {
 	bool operator==(const ValidateArgumentVariable& other) const;
 
-	std::string name;
+	std::string_view name;
 };
 
 struct ValidateArgumentEnumValue
 {
 	bool operator==(const ValidateArgumentEnumValue& other) const;
 
-	std::string value;
+	std::string_view value;
 };
 
 struct ValidateArgumentValue;
@@ -71,7 +71,7 @@ struct ValidateArgumentMap
 {
 	bool operator==(const ValidateArgumentMap& other) const;
 
-	std::map<std::string, ValidateArgumentValuePtr> values;
+	std::map<std::string_view, ValidateArgumentValuePtr> values;
 };
 
 using ValidateArgumentVariant = std::variant<ValidateArgumentVariable, response::IntType,
@@ -118,29 +118,29 @@ class ValidateArgumentValueVisitor
 	std::vector<schema_error>& _errors;
 };
 
-using ValidateFieldArguments = std::map<std::string, ValidateArgumentValuePtr>;
+using ValidateFieldArguments = std::map<std::string_view, ValidateArgumentValuePtr>;
 
 struct ValidateField
 {
-	ValidateField(std::string&& returnType, std::optional<std::string>&& objectType,
-		const std::string& fieldName, ValidateFieldArguments&& arguments);
+	ValidateField(std::string_view returnType, std::optional<std::string_view> objectType,
+		std::string_view fieldName, ValidateFieldArguments&& arguments);
 
 	bool operator==(const ValidateField& other) const;
 
-	std::string returnType;
-	std::optional<std::string> objectType;
-	std::string fieldName;
+	std::string_view returnType;
+	std::optional<std::string_view> objectType;
+	std::string_view fieldName;
 	ValidateFieldArguments arguments;
 };
 
-using ValidateTypeKinds = std::map<std::string, introspection::TypeKind>;
+using ValidateTypeKinds = std::map<std::string_view, introspection::TypeKind>;
 
 // ValidateVariableTypeVisitor visits the AST and builds a ValidateType structure representing
 // a variable type in an operation definition as if it came from an Introspection query.
 class ValidateVariableTypeVisitor
 {
 public:
-	ValidateVariableTypeVisitor(const ValidateTypeKinds& typeKinds);
+	ValidateVariableTypeVisitor(const schema::Schema& schema, const ValidateTypeKinds& typeKinds);
 
 	void visit(const peg::ast_node& typeName);
 
@@ -152,6 +152,7 @@ class ValidateVariableTypeVisitor
 	void visitListType(const peg::ast_node& listType);
 	void visitNonNullType(const peg::ast_node& nonNullType);
 
+	const schema::Schema& _schema;
 	const ValidateTypeKinds& _typeKinds;
 
 	bool _isInputType = false;
@@ -163,37 +164,35 @@ class ValidateVariableTypeVisitor
 class ValidateExecutableVisitor
 {
 public:
-	ValidateExecutableVisitor(const Request& service);
+	ValidateExecutableVisitor(const std::shared_ptr<schema::Schema>& schema);
 
 	void visit(const peg::ast_node& root);
 
 	std::vector<schema_error> getStructuredErrors();
 
 private:
-	response::Value executeQuery(std::string_view query) const;
+	static ValidateTypeFieldArguments getArguments(const std::vector<std::shared_ptr<schema::InputValue>>& args);
 
-	static ValidateTypeFieldArguments getArguments(response::ListType&& argumentsMember);
-
-	using FieldTypes = std::map<std::string, ValidateTypeField>;
-	using TypeFields = std::map<std::string, FieldTypes>;
+	using FieldTypes = std::map<std::string_view, ValidateTypeField>;
+	using TypeFields = std::map<std::string_view, FieldTypes>;
 	using InputFieldTypes = ValidateTypeFieldArguments;
-	using InputTypeFields = std::map<std::string, InputFieldTypes>;
-	using EnumValues = std::map<std::string, std::set<std::string>>;
+	using InputTypeFields = std::map<std::string_view, InputFieldTypes>;
+	using EnumValues = std::map<std::string_view, std::set<std::string_view>>;
 
-	std::optional<introspection::TypeKind> getTypeKind(const std::string& name) const;
+	std::optional<introspection::TypeKind> getTypeKind(std::string_view name) const;
 	std::optional<introspection::TypeKind> getScopedTypeKind() const;
 	constexpr bool isScalarType(introspection::TypeKind kind);
 
-	bool matchesScopedType(const std::string& name) const;
+	bool matchesScopedType(std::string_view name) const;
 
 	TypeFields::const_iterator getScopedTypeFields();
-	InputTypeFields::const_iterator getInputTypeFields(const std::string& name);
+	InputTypeFields::const_iterator getInputTypeFields(std::string_view name);
 	static const ValidateType& getValidateFieldType(const FieldTypes::mapped_type& value);
 	static const ValidateType& getValidateFieldType(const InputFieldTypes::mapped_type& value);
 	template <class _FieldTypes>
-	static std::string getFieldType(const _FieldTypes& fields, const std::string& name);
+	static std::string_view getFieldType(const _FieldTypes& fields, std::string_view name);
 	template <class _FieldTypes>
-	static std::string getWrappedFieldType(const _FieldTypes& fields, const std::string& name);
+	static std::string getWrappedFieldType(const _FieldTypes& fields, std::string_view name);
 	static std::string getWrappedFieldType(const ValidateType& returnType);
 
 	void visitFragmentDefinition(const peg::ast_node& fragmentDefinition);
@@ -213,19 +212,19 @@ class ValidateExecutableVisitor
 	bool validateVariableType(bool isNonNull, const ValidateType& variableType,
 		const schema_location& position, const ValidateType& inputType);
 
-	const Request& _service;
+	const std::shared_ptr<schema::Schema> _schema;
 	std::vector<schema_error> _errors;
 
-	using OperationTypes = std::map<std::string_view, std::string>;
-	using Directives = std::map<std::string, ValidateDirective>;
-	using ExecutableNodes = std::map<std::string, const peg::ast_node&>;
-	using FragmentSet = std::unordered_set<std::string>;
-	using MatchingTypes = std::map<std::string, std::set<std::string>>;
-	using ScalarTypes = std::set<std::string>;
-	using VariableDefinitions = std::map<std::string, const peg::ast_node&>;
-	using VariableTypes = std::map<std::string, ValidateArgument>;
+	using OperationTypes = std::map<std::string_view, std::string_view>;
+	using Directives = std::map<std::string_view, ValidateDirective>;
+	using ExecutableNodes = std::map<std::string_view, const peg::ast_node&>;
+	using FragmentSet = std::unordered_set<std::string_view>;
+	using MatchingTypes = std::map<std::string_view, std::set<std::string_view>>;
+	using ScalarTypes = std::set<std::string_view>;
+	using VariableDefinitions = std::map<std::string_view, const peg::ast_node&>;
+	using VariableTypes = std::map<std::string_view, ValidateArgument>;
 	using OperationVariables = std::optional<VariableTypes>;
-	using VariableSet = std::set<std::string>;
+	using VariableSet = std::set<std::string_view>;
 
 	// These members store Introspection schema information which does not change between queries.
 	OperationTypes _operationTypes;
@@ -250,8 +249,8 @@ class ValidateExecutableVisitor
 	size_t _fieldCount = 0;
 	TypeFields _typeFields;
 	InputTypeFields _inputTypeFields;
-	std::string _scopedType;
-	std::map<std::string, ValidateField> _selectionFields;
+	std::string_view _scopedType;
+	std::map<std::string_view, ValidateField> _selectionFields;
 };
 
 } /* namespace graphql::service */

include/graphqlservice/GraphQLService.h

@@ -1035,7 +1035,7 @@ class Request : public std::enable_shared_from_this<Request>
 		const std::shared_ptr<RequestState>& state, const peg::ast_node& root,
 		const std::string& operationName, response::Value&& variables) const;
 
-	TypeMap _operations;
+	const TypeMap _operations;
 	std::unique_ptr<ValidateExecutableVisitor> _validation;
 	std::map<SubscriptionKey, std::shared_ptr<SubscriptionData>> _subscriptions;
 	std::unordered_map<SubscriptionName, std::set<SubscriptionKey>> _listeners;

src/GraphQLService.cpp

@@ -1759,7 +1759,7 @@ void SubscriptionDefinitionVisitor::visitInlineFragment(const peg::ast_node& inl
 
 Request::Request(TypeMap&& operationTypes, const std::shared_ptr<schema::Schema>& schema)
 	: _operations(std::move(operationTypes))
-	, _validation(std::make_unique<ValidateExecutableVisitor>(*this))
+	, _validation(std::make_unique<ValidateExecutableVisitor>(schema))
 {
 }