graphql_devise 0.10.1 → 0.11.0

data/lib/graphql_devise/mount_method/option_sanitizers/class_checker.rb

@@ -0,0 +1,26 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionSanitizers
+      class ClassChecker
+        def initialize(klass)
+          @klass_array = Array(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 @klass_array.any? { |klass| value.ancestors.include?(klass) }
+            raise GraphqlDevise::InvalidMountOptionsError,
+                  "`#{key}` option has an invalid value. #{@klass_array.join(', ')} or descendants expected. Got #{value}."
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/graphql_devise/mount_method/option_sanitizers/hash_checker.rb

@@ -0,0 +1,24 @@
+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
+
+          value.each { |internal_key, klass| ClassChecker.new(@element_type_array).call!(klass, "#{key} -> #{internal_key}") }
+
+          value
+        end
+      end
+    end
+  end
+end

data/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

data/lib/graphql_devise/mount_method/option_validators/provided_operations_validator.rb

@@ -0,0 +1,24 @@
+require_relative 'supported_operations_validator'
+
+module GraphqlDevise
+  module MountMethod
+    module OptionValidators
+      class ProvidedOperationsValidator
+        def initialize(options:, supported_operations:)
+          @options              = options
+          @supported_operations = supported_operations
+        end
+
+        def validate!
+          supported_keys = @supported_operations.keys
+
+          [
+            SupportedOperationsValidator.new(provided_operations: @options.skip, key: :skip, supported_operations: supported_keys),
+            SupportedOperationsValidator.new(provided_operations: @options.only, key: :only, supported_operations: supported_keys),
+            SupportedOperationsValidator.new(provided_operations: @options.operations.keys, key: :operations, supported_operations: supported_keys)
+          ].each(&:validate!)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_devise/mount_method/option_validators/skip_only_validator.rb

@@ -0,0 +1,20 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionValidators
+      class SkipOnlyValidator
+        def initialize(options:)
+          @options = options
+        end
+
+        def validate!
+          if [@options.skip, @options.only].all?(&:present?)
+            raise(
+              GraphqlDevise::InvalidMountOptionsError,
+              "Can't specify both `skip` and `only` options when mounting the route."
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_devise/mount_method/option_validators/supported_operations_validator.rb

@@ -0,0 +1,24 @@
+module GraphqlDevise
+  module MountMethod
+    module OptionValidators
+      class SupportedOperationsValidator
+        def initialize(provided_operations: [], supported_operations: [], key:)
+          @provided_operations  = provided_operations
+          @supported_operations = supported_operations
+          @key                  = key
+        end
+
+        def validate!
+          unsupported_operations = @provided_operations - @supported_operations
+
+          if unsupported_operations.present?
+            raise(
+              GraphqlDevise::InvalidMountOptionsError,
+              "#{@key} option contains unsupported operations: \"#{unsupported_operations.join(', ')}\". Check for typos."
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_devise/mount_method/options_validator.rb

@@ -0,0 +1,16 @@
+require_relative 'option_validators/skip_only_validator'
+require_relative 'option_validators/provided_operations_validator'
+
+module GraphqlDevise
+  module MountMethod
+    class OptionsValidator
+      def initialize(validators = [])
+        @validators = validators
+      end
+
+      def validate!
+        @validators.each(&:validate!)
+      end
+    end
+  end
+end

data/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

data/lib/graphql_devise/rails/routes.rb

@@ -1,111 +1,83 @@
 module ActionDispatch::Routing
   class Mapper
-    def mount_graphql_devise_for(resource, opts = {})
-      custom_operations    = opts.fetch(:operations, {})
-      skipped_operations   = opts.fetch(:skip, [])
-      only_operations      = opts.fetch(:only, [])
-      additional_mutations = opts.fetch(:additional_mutations, {})
-      additional_queries   = opts.fetch(:additional_queries, {})
-
-      if [skipped_operations, only_operations].all?(&:any?)
-        raise GraphqlDevise::Error, "Can't specify both `skip` and `only` options when mounting the route."
-      end
-
-      default_mutations = {
-        login:               GraphqlDevise::Mutations::Login,
-        logout:              GraphqlDevise::Mutations::Logout,
-        sign_up:             GraphqlDevise::Mutations::SignUp,
-        update_password:     GraphqlDevise::Mutations::UpdatePassword,
-        send_password_reset: GraphqlDevise::Mutations::SendPasswordReset,
-        resend_confirmation: GraphqlDevise::Mutations::ResendConfirmation
-      }.freeze
-      default_queries = {
-        confirm_account:      GraphqlDevise::Resolvers::ConfirmAccount,
-        check_password_token: GraphqlDevise::Resolvers::CheckPasswordToken
-      }
-      supported_operations = default_mutations.keys + default_queries.keys
-
-      unless skipped_operations.all? { |skipped| supported_operations.include?(skipped) }
-        raise GraphqlDevise::Error, 'Trying to skip a non supported operation. Check for typos.'
-      end
-      unless only_operations.all? { |only| supported_operations.include?(only) }
-        raise GraphqlDevise::Error, 'One of the `only` operations is not supported. Check for typos.'
-      end
-
-      path         = opts.fetch(:at, '/graphql_auth')
-      mapping_name = resource.underscore.tr('/', '_').to_sym
+    DEVISE_OPERATIONS = [
+      :sessions,
+      :registrations,
+      :passwords,
+      :confirmations,
+      :omniauth_callbacks,
+      :unlocks,
+      :invitations
+    ].freeze
+
+    def mount_graphql_devise_for(resource, options = {})
+      default_operations = GraphqlDevise::DefaultOperations::MUTATIONS.merge(GraphqlDevise::DefaultOperations::QUERIES)
+
+      # clean_options responds to all keys defined in GraphqlDevise::MountMethod::SUPPORTED_OPTIONS
+      clean_options = GraphqlDevise::MountMethod::OptionSanitizer.new(options).call!
+
+      GraphqlDevise::MountMethod::OptionsValidator.new(
+        [
+          GraphqlDevise::MountMethod::OptionValidators::SkipOnlyValidator.new(options: clean_options),
+          GraphqlDevise::MountMethod::OptionValidators::ProvidedOperationsValidator.new(
+            options: clean_options, supported_operations: default_operations
+          )
+        ]
+      ).validate!
+
+      authenticatable_type = clean_options.authenticatable_type.presence ||
+                             "Types::#{resource}Type".safe_constantize ||
+                             GraphqlDevise::Types::AuthenticatableType
 
       devise_for(
         resource.pluralize.underscore.tr('/', '_').to_sym,
         module:     :devise,
         class_name: resource,
-        skip:       [:sessions, :registrations, :passwords, :confirmations, :omniauth_callbacks, :unlocks, :invitations]
+        skip:       DEVISE_OPERATIONS
       )
 
-      authenticatable_type = opts[:authenticatable_type] ||
-                             "Types::#{resource}Type".safe_constantize ||
-                             GraphqlDevise::Types::AuthenticatableType
-
-      used_mutations = if only_operations.present?
-        default_mutations.slice(*only_operations)
-      else
-        default_mutations.except(*skipped_operations)
-      end
-      used_mutations.each do |action, mutation|
-        used_mutation = if custom_operations[action].present?
-          custom_operations[action]
-        else
-          new_mutation = Class.new(mutation)
-          new_mutation.graphql_name("#{resource.gsub('::', '')}#{action.to_s.camelize(:upper)}")
-          new_mutation.field(:authenticatable, authenticatable_type, null: true)
-
-          new_mutation
-        end
-        used_mutation.instance_variable_set(:@resource_name, mapping_name)
-
-        GraphqlDevise::Types::MutationType.field("#{mapping_name}_#{action}", mutation: used_mutation)
-      end
-      additional_mutations.each do |action, mutation|
+      prepared_mutations = GraphqlDevise::MountMethod::OperationPreparer.new(
+        resource:              resource,
+        custom:                clean_options.operations,
+        additional_operations: clean_options.additional_mutations,
+        preparer:              GraphqlDevise::MountMethod::OperationPreparers::MutationFieldSetter.new(authenticatable_type),
+        selected_operations:   GraphqlDevise::MountMethod::OperationSanitizer.call(
+          default: GraphqlDevise::DefaultOperations::MUTATIONS, only: clean_options.only, skipped: clean_options.skip
+        )
+      ).call
+
+      prepared_mutations.each do |action, mutation|
         GraphqlDevise::Types::MutationType.field(action, mutation: mutation)
       end
 
-      if (used_mutations.present? || additional_mutations.present?) &&
-         (Gem::Version.new(GraphQL::VERSION) <= Gem::Version.new('1.10.0') || GraphqlDevise::Schema.mutation.nil?)
+      if prepared_mutations.present? &&
+         (Gem::Version.new(GraphQL::VERSION) < Gem::Version.new('1.10.0') || GraphqlDevise::Schema.mutation.nil?)
         GraphqlDevise::Schema.mutation(GraphqlDevise::Types::MutationType)
       end
 
-      used_queries = if only_operations.present?
-        default_queries.slice(*only_operations)
-      else
-        default_queries.except(*skipped_operations)
-      end
-      used_queries.each do |action, query|
-        used_query = if custom_operations[action].present?
-          custom_operations[action]
-        else
-          new_query = Class.new(query)
-          new_query.graphql_name("#{resource.gsub('::', '')}#{action.to_s.camelize(:upper)}")
-          new_query.type(authenticatable_type, null: true)
-
-          new_query
-        end
-        used_query.instance_variable_set(:@resource_name, mapping_name)
-
-        GraphqlDevise::Types::QueryType.field("#{mapping_name}_#{action}", resolver: used_query)
-      end
-      additional_queries.each do |action, resolver|
+      prepared_queries = GraphqlDevise::MountMethod::OperationPreparer.new(
+        resource:              resource,
+        custom:                clean_options.operations,
+        additional_operations: clean_options.additional_queries,
+        preparer:              GraphqlDevise::MountMethod::OperationPreparers::ResolverTypeSetter.new(authenticatable_type),
+        selected_operations:   GraphqlDevise::MountMethod::OperationSanitizer.call(
+          default: GraphqlDevise::DefaultOperations::QUERIES, only: clean_options.only, skipped: clean_options.skip
+        )
+      ).call
+
+      prepared_queries.each do |action, resolver|
         GraphqlDevise::Types::QueryType.field(action, resolver: resolver)
       end
 
-      if (used_queries.blank? || additional_queries.present?) && GraphqlDevise::Types::QueryType.fields.blank?
+      if prepared_queries.blank? && GraphqlDevise::Types::QueryType.fields.blank?
         GraphqlDevise::Types::QueryType.field(:dummy, resolver: GraphqlDevise::Resolvers::Dummy)
       end
 
       Devise.mailer.helper(GraphqlDevise::MailerHelper)
 
-      devise_scope mapping_name do
-        post path, to: 'graphql_devise/graphql#auth'
-        get  path, to: 'graphql_devise/graphql#auth'
+      devise_scope resource.underscore.tr('/', '_').to_sym do
+        post clean_options.at, to: 'graphql_devise/graphql#auth'
+        get  clean_options.at, to: 'graphql_devise/graphql#auth'
       end
     end
   end

data/lib/graphql_devise/version.rb

@@ -1,3 +1,3 @@
 module GraphqlDevise
-  VERSION = '0.10.1'.freeze
+  VERSION = '0.11.0'.freeze
 end

data/spec/services/mount_method/operation_preparer_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparer do
+  describe '#call' do
+    subject(:prepared_operations) do
+      described_class.new(
+        resource:              resource,
+        selected_operations:   selected,
+        preparer:              preparer,
+        custom:                custom,
+        additional_operations: additional
+      ).call
+    end
+
+    let(:logout_class) { Class.new(GraphQL::Schema::Resolver) }
+    let(:resource)     { 'User' }
+    let(:selected)     { { login: double(:login_default), logout: logout_class } }
+    let(:preparer)     { double(:preparer, call: logout_class) }
+    let(:custom)       { { login: double(:custom_login, graphql_name: nil) } }
+    let(:additional)   { { user_additional: double(:user_additional) } }
+
+    it 'is expected to return all provided operation keys' do
+      expect(prepared_operations.keys).to contain_exactly(
+        :user_login,
+        :user_logout,
+        :user_additional
+      )
+    end
+  end
+end

data/spec/services/mount_method/operation_preparers/custom_operation_preparer_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe GraphqlDevise::MountMethod::OperationPreparers::CustomOperationPreparer do
+  describe '#call' do
+    subject(:prepared) { described_class.new(selected_keys: selected_keys, custom_operations: operations, mapping_name: mapping_name).call }
+
+    let(:login_operation)  { double(:confirm_operation, graphql_name: nil) }
+    let(:logout_operation) { double(:sign_up_operation, graphql_name: nil) }
+    let(:mapping_name)     { 'user' }
+    let(:operations)       { { login: login_operation, logout: logout_operation, invalid: double(:invalid) } }
+    let(:selected_keys)    { [:login, :logout, :sign_up, :confirm] }
+
+    it 'returns only those operations with no custom operation provided' do
+      expect(prepared.keys).to contain_exactly(:user_login, :user_logout)
+    end
+
+    it 'prepares custom operations' do
+      expect(login_operation).to receive(:graphql_name).with('UserLogin')
+      expect(logout_operation).to receive(:graphql_name).with('UserLogout')
+
+      prepared
+
+      expect(login_operation.instance_variable_get(:@resource_name)).to eq(:user)
+      expect(logout_operation.instance_variable_get(:@resource_name)).to eq(:user)
+    end
+
+    context 'when no selected keys are provided' do
+      let(:selected_keys) { [] }
+
+      it 'returns no operations' do
+        expect(prepared).to eq({})
+      end
+    end
+
+    context 'when no custom operations are provided' do
+      let(:operations) { {} }
+
+      it 'returns no operations' do
+        expect(prepared).to eq({})
+      end
+    end
+  end
+end