Add mount method option sanitizer

Author: mcelicalderon

lib/graphql_devise.rb

@@ -23,6 +23,7 @@ class InvalidMountOptionsError < GraphqlDevise::Error; end
 require 'graphql_devise/user_error'
 require 'graphql_devise/detailed_user_error'
 
+require 'graphql_devise/mount_method/option_sanitizer'
 require 'graphql_devise/mount_method/options_validator'
 require 'graphql_devise/mount_method/queries_preparer'
 require 'graphql_devise/mount_method/mutations_preparer'

lib/graphql_devise/mount_method/option_sanitizer.rb

@@ -0,0 +1,18 @@
+require_relative 'supported_options'
+
+module GraphqlDevise
+  module MountMethod
+    class OptionSanitizer
+      def initialize(options = {}, supported_options = MountMethod::SUPPORTED_OPTIONS)
+        @options           = options
+        @supported_options = supported_options
+      end
+
+      def call!
+        @supported_options.each_with_object(Struct.new(*@supported_options.keys).new) do |(key, checker), result|
+          result[key] = checker.call!(@options[key], key)
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/option_sanitizers/array_checker.rb

@@ -0,0 +1,26 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionSanitizers
+      class ArrayChecker
+        def initialize(element_type)
+          @element_type  = element_type
+          @default_value = []
+        end
+
+        def call!(value, key)
+          return @default_value if value.blank?
+
+          unless value.instance_of?(Array)
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Array expected."
+          end
+
+          unless value.all? { |element| element.instance_of?(@element_type) }
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has invalid elements. #{@element_type} expected."
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/option_sanitizers/class_checker.rb

@@ -0,0 +1,25 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionSanitizers
+      class ClassChecker
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def call!(value, key)
+          return if value.nil?
+
+          unless value.instance_of?(Class)
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Class expected."
+          end
+
+          unless value.ancestors.include?(@klass)
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. #{@klass} expected. Got #{value}."
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/option_sanitizers/hash_checker.rb

@@ -0,0 +1,26 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionSanitizers
+      class HashChecker
+        def initialize(element_type_array)
+          @element_type_array = Array(element_type_array)
+          @default_value      = {}
+        end
+
+        def call!(value, key)
+          return @default_value if value.blank?
+
+          unless value.instance_of?(Hash)
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. Hash expected. Got #{value.class}."
+          end
+
+          unless value.all? { |_, element| element.instance_of?(Class) && @element_type_array.any? { |type| element.ancestors.include?(type) } }
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has invalid elements. [#{@element_type_array.join(', ')}] or descendants expected. Got #{value}."
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/option_sanitizers/string_checker.rb

@@ -0,0 +1,21 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionSanitizers
+      class StringChecker
+        def initialize(default_string = nil)
+          @default_string = default_string
+        end
+
+        def call!(value, key)
+          return @default_string if value.blank?
+
+          unless value.instance_of?(String)
+            raise GraphqlDevise::InvalidMountOptionsError, "`#{key}` option has an invalid value. String expected."
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

lib/graphql_devise/mount_method/supported_options.rb

@@ -0,0 +1,18 @@
+require_relative 'option_sanitizers/array_checker'
+require_relative 'option_sanitizers/hash_checker'
+require_relative 'option_sanitizers/string_checker'
+require_relative 'option_sanitizers/class_checker'
+
+module GraphqlDevise
+  module MountMethod
+    SUPPORTED_OPTIONS = {
+      at:                   OptionSanitizers::StringChecker.new('/graphql_auth'),
+      operations:           OptionSanitizers::HashChecker.new([GraphQL::Schema::Resolver, GraphQL::Schema::Mutation]),
+      only:                 OptionSanitizers::ArrayChecker.new(Symbol),
+      skip:                 OptionSanitizers::ArrayChecker.new(Symbol),
+      additional_queries:   OptionSanitizers::HashChecker.new(GraphQL::Schema::Resolver),
+      additional_mutations: OptionSanitizers::HashChecker.new(GraphQL::Schema::Mutation),
+      authenticatable_type: OptionSanitizers::ClassChecker.new(GraphQL::Schema::Member)
+    }.freeze
+  end
+end

lib/graphql_devise/rails/routes.rb

@@ -12,6 +12,7 @@ class Mapper
 
     def mount_graphql_devise_for(resource, options = {})
       default_operations = GraphqlDevise::DefaultOperations::MUTATIONS.merge(GraphqlDevise::DefaultOperations::QUERIES)
+      clean_options      = GraphqlDevise::MountMethod::OptionSanitizer.new(options).call!
 
       GraphqlDevise::MountMethod::OptionsValidator.new(
         [

spec/services/mount_method/mutations_preparer_spec.rb

@@ -14,13 +14,13 @@
     let(:class1)    { Class.new(GraphQL::Schema::Mutation) }
     let(:class2)    { GraphQL::Schema::Mutation }
     let(:auth_type) { GraphqlDevise::Types::AuthenticatableType }
-    let(:mutations) { { mutation_1: class1, mutation_2: class2 } }
+    let(:mutations) { { mutation1: class1, mutation2: class2 } }
 
     context 'when mutations is *NOT* empty' do
       it 'assign gql attibutes to mutations and changes keys using resource map' do
         result = subject
 
-        expect(result.keys).to contain_exactly(:user_mutation_1, :user_mutation_2)
+        expect(result.keys).to contain_exactly(:user_mutation1, :user_mutation2)
         expect(result.values.map(&:graphql_name)).to contain_exactly(
           'UserMutation1', 'UserMutation2'
         )

spec/services/mount_method/option_sanitizer_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OptionSanitizer do
+  subject(:clean_options) { described_class.new(options, supported_options).call! }
+
+  describe '#call!' do
+    let(:supported_options) do
+      {
+        my_string:     GraphqlDevise::MountMethod::OptionSanitizers::StringChecker.new('default string'),
+        hash_multiple: GraphqlDevise::MountMethod::OptionSanitizers::HashChecker.new([String, Numeric]),
+        array:         GraphqlDevise::MountMethod::OptionSanitizers::ArrayChecker.new(Symbol),
+        hash_single:   GraphqlDevise::MountMethod::OptionSanitizers::HashChecker.new(Float),
+        my_class:      GraphqlDevise::MountMethod::OptionSanitizers::ClassChecker.new(Numeric)
+      }
+    end
+
+    context 'when all options are provided and correct' do
+      let(:options) do
+        {
+          my_string:     'non default',
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          hash_single:   { first: Float, second: Float },
+          my_class:      Float
+        }
+      end
+
+      it 'returns a struct with clean options' do
+        expect(
+          my_string:     clean_options.my_string,
+          hash_multiple: clean_options.hash_multiple,
+          array:         clean_options.array,
+          hash_single:   clean_options.hash_single,
+          my_class:      clean_options.my_class
+        ).to match(
+          my_string:     'non default',
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          hash_single:   { first: Float, second: Float },
+          my_class:      Float
+        )
+      end
+    end
+
+    context 'when some options are provided but all correct' do
+      let(:options) do
+        {
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          my_class:      Float
+        }
+      end
+
+      it 'returns a struct with clean options and default values' do
+        expect(
+          my_string:     clean_options.my_string,
+          hash_multiple: clean_options.hash_multiple,
+          array:         clean_options.array,
+          hash_single:   clean_options.hash_single,
+          my_class:      clean_options.my_class
+        ).to match(
+          my_string:     'default string',
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         [:one, :two, :three],
+          hash_single:   {},
+          my_class:      Float
+        )
+      end
+    end
+
+    context 'when an option provided is invalid' do
+      let(:options) do
+        {
+          hash_multiple: { first: String, second: Float, third: Float },
+          array:         ['not symbol 1', 'not symbol 2'],
+          my_class:      Float
+        }
+      end
+
+      it 'raises an error' do
+        expect { clean_options }.to raise_error(GraphqlDevise::InvalidMountOptionsError, '`array` option has invalid elements. Symbol expected.')
+      end
+    end
+  end
+end