graphql_rails 0.1.0

data/lib/graphql_rails/controller/action_path_parser.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require_relative 'request'
+
+module GraphqlRails
+  class Controller
+    # graphql resolver which redirects actions to appropriate controller and controller action
+    class ActionPathParser
+      # accepts path of given format "controller_name#action"
+      def initialize(action_path, **options)
+        @action_path = action_path
+        @module_name = options[:module] || ''
+      end
+
+      def return_type
+        return_type = action.return_type || default_type
+
+        if action.can_return_nil?
+          return_type
+        else
+          return_type.to_non_null_type
+        end
+      end
+
+      def arguments
+        action.attributes.values
+      end
+
+      def controller
+        @controller ||= "#{namespaced_controller_name}_controller".classify.constantize
+      end
+
+      def action_name
+        @action_name ||= action_path.split('#').last
+      end
+
+      private
+
+      attr_reader :action_path, :module_name
+
+      def action
+        controller.controller_configuration.action(action_name)
+      end
+
+      def namespaced_controller_name
+        [module_name, controller_name].reject(&:empty?).join('/')
+      end
+
+      def controller_name
+        @controller_name ||= action_path.split('#').first
+      end
+
+      def action_model
+        model_path = namespaced_controller_name.singularize.classify.split('::')
+        model_name = model_path.pop
+
+        while model_path.any?
+          begin
+            return [model_path, model_name].join('::').constantize
+          rescue NameError => err
+            raise unless err.message.match?(/uninitialized constant/)
+            model_path.pop
+          end
+        end
+
+        model_name.constantize
+      end
+
+      def default_type
+        action_model.graphql.graphql_type
+      end
+    end
+  end
+end

data/lib/graphql_rails/controller/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'graphql_rails/attribute'
+require 'graphql_rails/controller/action_configuration'
+
+module GraphqlRails
+  class Controller
+    # stores all graphql_rails contoller specific config
+    class Configuration
+      attr_reader :before_actions
+
+      def initialize(controller)
+        @controller = controller
+        @before_actions = Set.new
+        @action_by_name = {}
+      end
+
+      def add_before_action(name)
+        before_actions << name
+      end
+
+      def action(method_name)
+        @action_by_name[method_name.to_s] ||= ActionConfiguration.new
+      end
+
+      private
+
+      attr_reader :controller
+    end
+  end
+end

data/lib/graphql_rails/controller/controller_function.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/controller/action_path_parser'
+require_relative 'request'
+
+module GraphqlRails
+  class Controller
+    # graphql resolver which redirects actions to appropriate controller and controller action
+    class ControllerFunction < GraphQL::Function
+      # accepts path of given format "controller_name#action"
+      attr_reader :type
+
+      def initialize(controller, action_name, return_type)
+        @controller = controller
+        @action_name = action_name
+        @type = return_type
+      end
+
+      def self.build(action_path, **options)
+        action_parser = ActionPathParser.new(action_path, **options)
+
+        action_function = Class.new(self) do
+          action_parser.arguments.each do |action_attribute|
+            argument(action_attribute.field_name, action_attribute.graphql_field_type)
+          end
+        end
+
+        action_function.new(action_parser.controller, action_parser.action_name, action_parser.return_type)
+      end
+
+      def call(object, inputs, ctx)
+        request = Request.new(object, inputs, ctx)
+        controller.new(request).call(action_name)
+      end
+
+      private
+
+      attr_reader :controller, :action_name
+    end
+  end
+end

data/lib/graphql_rails/controller/request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../errors/execution_error'
+
+module GraphqlRails
+  class Controller
+    # Contains all info related with single request to controller
+    class Request
+      attr_accessor :object_to_return
+      attr_reader :errors
+
+      def initialize(graphql_object, inputs, context)
+        @graphql_object = graphql_object
+        @inputs = inputs
+        @context = context
+      end
+
+      def errors=(new_errors)
+        @errors = new_errors
+
+        new_errors.each do |error|
+          error_message = error.is_a?(String) ? error : error.message
+          context.add_error(ExecutionError.new(error_message))
+        end
+      end
+
+      def no_object_to_return?
+        !defined?(@object_to_return)
+      end
+
+      def params
+        inputs.to_h
+      end
+
+      private
+
+      attr_reader :graphql_object, :inputs, :context
+    end
+  end
+end

data/lib/graphql_rails/errors/execution_error.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # base class which is returned in case something bad happens. Contains all error rendering tructure
+  class ExecutionError < GraphQL::ExecutionError
+    def to_h
+      super.except('locations').merge('type' => type, 'http_status_code' => http_status_code)
+    end
+
+    def type
+      'system_error'
+    end
+
+    def http_status_code
+      500
+    end
+  end
+end

data/lib/graphql_rails/errors/validation_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  # GrapqhQL error that is raised when invalid data is given
+  class ValidationError < ExecutionError
+    attr_reader :short_message, :field
+
+    def initialize(short_message, field)
+      super([field.presence, short_message].compact.join(' '))
+      @short_message = short_message
+      @field = field
+    end
+
+    def type
+      'validation_error'
+    end
+
+    def http_status_code
+      422
+    end
+
+    def to_h
+      super.merge('field' => field, 'short_message' => short_message)
+    end
+  end
+end

data/lib/graphql_rails/model.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'model/configuration'
+
+module GraphqlRails
+  # this module allows to convert any ruby class in to grapql type object
+  #
+  # usage:
+  # class YourModel
+  #   include GraphqlRails::Model
+  #
+  #   graphql do
+  #     attribute :id
+  #     attribute :title
+  #   end
+  # end
+  #
+  # YourModel.new.grapql_type # => type with [:id, :title] attributes
+  module Model
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # static methods for GraphqlRails::Model
+    module ClassMethods
+      def graphql
+        @graphql ||= Model::Configuration.new(self)
+        yield(@graphql) if block_given?
+        @graphql
+      end
+    end
+  end
+end

data/lib/graphql_rails/model/configuration.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/attribute'
+
+module GraphqlRails
+  module Model
+    # stores information about model specific config, like attributes and types
+    class Configuration
+      attr_reader :attributes
+
+      def initialize(model_class)
+        @model_class = model_class
+        @attributes = {}
+      end
+
+      def attribute(attribute_name, type: nil, hidden: false)
+        attributes[attribute_name.to_s] = Attribute.new(attribute_name, type, hidden: hidden)
+      end
+
+      def include_model_attributes(except: [])
+        except = Array(except).map(&:to_s)
+
+        if defined?(Mongoid) && model_class < Mongoid::Document
+          assign_default_mongoid_attributes(except: except)
+        elsif defined?(ActiveRecord) && model_class < ActiveRecord::Base
+          assign_default_active_record_attributes(except: except)
+        end
+      end
+
+      def graphql_type
+        @graphql_type ||= generate_graphql_type(graphql_type_name, visible_attributes)
+      end
+
+      private
+
+      attr_reader :model_class
+
+      def visible_attributes
+        attributes.reject { |_name, attribute| attribute.hidden? }
+      end
+
+      def graphql_type_name
+        model_class.name.split('::').last
+      end
+
+      def generate_graphql_type(type_name, attributes)
+        GraphQL::ObjectType.define do
+          name(type_name)
+          description("Generated programmatically from model: #{type_name}")
+
+          attributes.each_value do |attribute|
+            field(attribute.field_name, attribute.graphql_field_type, property: attribute.name.to_sym)
+          end
+        end
+      end
+
+      def assign_default_mongoid_attributes(except: [])
+        allowed_fields = model_class.fields.except('_type', '_id', *except)
+
+        attribute('id', type: 'id')
+
+        allowed_fields.each_value do |field|
+          attribute(field.name, type: field.type.to_s.split('::').last)
+        end
+      end
+
+      def assign_default_active_record_attributes(except: [])
+        allowed_fields = model_class.columns.index_by(&:name).except('type', *except)
+
+        allowed_fields.each_value do |field|
+          field_type = field.cast_type.class.to_s.downcase.split('::').last
+          field_type = 'string' if field_type.ends_with?('string')
+          field_type = 'date' if field_type.include?('date')
+          field_type = 'time' if field_type.include?('time')
+
+          attribute(field.name, type: field_type.to_s.split('::').last)
+        end
+      end
+    end
+  end
+end

data/lib/graphql_rails/router.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+
+require_relative 'router/schema_builder'
+require_relative 'router/mutation_action'
+require_relative 'router/query_action'
+require_relative 'router/resource_actions_builder'
+
+module GraphqlRails
+  # graphql router that mimics Rails.application.routes
+  class Router
+    def self.draw(&block)
+      router = new
+      router.instance_eval(&block)
+      router.graphql_schema
+    end
+
+    attr_reader :actions, :namespace_name
+
+    def initialize(module_name: '')
+      @module_name = module_name
+      @actions ||= Set.new
+    end
+
+    def scope(**options, &block)
+      full_module_name = [module_name, options[:module]].reject(&:empty?).join('/')
+      scoped_router = self.class.new(module_name: full_module_name)
+      scoped_router.instance_eval(&block)
+      actions.merge(scoped_router.actions)
+    end
+
+    def resources(name, **options, &block)
+      builder_options = default_action_options.merge(options)
+      actions_builder = ResourceActionsBuilder.new(name, **builder_options)
+      actions_builder.instance_eval(&block) if block
+      actions.merge(actions_builder.actions)
+    end
+
+    def query(name, **options)
+      actions << build_action(QueryAction, name, **options)
+    end
+
+    def mutation(name, **options)
+      actions << build_action(MutationAction, name, **options)
+    end
+
+    def graphql_schema
+      SchemaBuilder.new(queries: actions.select(&:query?), mutations: actions.select(&:mutation?)).call
+    end
+
+    private
+
+    attr_reader :module_name
+
+    def build_action(action_builder, name, **options)
+      action_options = default_action_options.merge(options)
+      action_builder.new(name, action_options)
+    end
+
+    def default_action_options
+      { module: module_name }
+    end
+  end
+end

data/lib/graphql_rails/router/action.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../controller/controller_function'
+
+module GraphqlRails
+  class Router
+    # Generic class for any type graphql action. Should not be used directly
+    class Action
+      attr_reader :name, :controller_action_path
+
+      def initialize(name, to:, **options)
+        @name = name.to_s.camelize(:lower)
+        @controller_action_path = [options[:module].to_s, to].reject(&:empty?).join('/')
+      end
+
+      def options
+        { function: Controller::ControllerFunction.build(controller_action_path) }
+      end
+    end
+  end
+end

data/lib/graphql_rails/router/mutation_action.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module GraphqlRails
+  class Router
+    # stores mutation type graphql action info
+    class MutationAction < Action
+      def query?
+        false
+      end
+
+      def mutation?
+        true
+      end
+    end
+  end
+end