graphql_rails 0.1.0

data/graphql_rails.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "graphql_rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = 'graphql_rails'
+  spec.version       = GraphqlRails::VERSION
+  spec.authors       = ['Povilas Jurčys']
+  spec.email         = ['bloomrain@gmail.com']
+
+  spec.summary       = %q{GrapQL server and client for rails}
+  spec.homepage      = 'https://github.com/povilasjurcys/graphql_rails'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'graphql', '~> 1'
+  spec.add_dependency 'activesupport', '~> 5'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/lib/graphiti.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'graphql_rails/version'
+require 'graphql_rails/model'
+require 'graphql_rails/router'
+require 'graphql_rails/controller'
+
+# wonders starts here
+module GraphqlRails
+end

data/lib/graphiti/attribute.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'graphql'
+
+module GraphqlRails
+  # contains info about single graphql attribute
+  class Attribute
+    attr_reader :name, :type
+
+    def initialize(name, type = nil, required: false, hidden: false)
+      @name = name.to_s
+      @type = parse_type(type || type_by_attribute_name)
+      @required = required
+      @hidden = hidden
+    end
+
+    def graphql_field_type
+      @graphql_field_type ||= required? ? type.to_non_null_type : type
+    end
+
+    def required?
+      @required
+    end
+
+    def hidden?
+      @hidden
+    end
+
+    def field_name
+      field =
+        if name.end_with?('?')
+          "is_#{name.remove(/\?\Z/)}"
+        else
+          name
+        end
+
+      field.camelize(:lower)
+    end
+
+    private
+
+    def type_by_attribute_name
+      case name
+      when 'id', /_id\Z/
+        GraphQL::ID_TYPE
+      when /\?\Z/
+        GraphQL::BOOLEAN_TYPE
+      else
+        GraphQL::STRING_TYPE
+      end
+    end
+
+    def parse_type(type)
+      if graphql_type?(type)
+        type
+      elsif type.is_a?(String) || type.is_a?(Symbol)
+        map_type_name_to_type(type.to_s.downcase)
+      else
+        raise "Unsupported type #{type.inspect} (class: #{type.class})"
+      end
+    end
+
+    def graphql_type?(type)
+      type.is_a?(GraphQL::BaseType) ||
+        type.is_a?(GraphQL::ObjectType) ||
+        (defined?(GraphQL::Schema::Member) && type.is_a?(Class) && type < GraphQL::Schema::Member)
+    end
+
+    def map_type_name_to_type(type_name)
+      case type_name
+      when 'id'
+        GraphQL::ID_TYPE
+      when 'int', 'integer'
+        GraphQL::INT_TYPE
+      when 'string', 'str', 'text', 'time', 'date'
+        GraphQL::STRING_TYPE
+      when 'bool', 'boolean', 'mongoid::boolean'
+        GraphQL::BOOLEAN_TYPE
+      when 'float', 'double', 'decimal'
+        GraphQL::FLOAT_TYPE
+      else
+        raise "Don't know how to parse type with name #{type_name.inspect}"
+      end
+    end
+  end
+end

data/lib/graphiti/controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require_relative 'controller/configuration'
+require_relative 'controller/request'
+
+module GraphqlRails
+  # base class for all graphql_rails controllers
+  class Controller
+    class << self
+      def before_action(action_name)
+        controller_configuration.add_before_action(action_name)
+      end
+
+      def action(method_name)
+        controller_configuration.action(method_name)
+      end
+
+      def controller_configuration
+        @controller_configuration ||= Controller::Configuration.new(self)
+      end
+    end
+
+    def initialize(graphql_request)
+      @graphql_request = graphql_request
+    end
+
+    def call(method_name)
+      self.class.controller_configuration.before_actions.each { |action_name| send(action_name) }
+
+      begin
+        response = public_send(method_name)
+        render response if graphql_request.no_object_to_return?
+      rescue StandardError => error
+        render error: error
+      end
+
+      graphql_request.object_to_return
+    end
+
+    protected
+
+    attr_reader :graphql_request
+
+    def render(object = nil, error: nil, errors: Array(error))
+      graphql_request.errors = errors
+      graphql_request.object_to_return = object
+    end
+
+    def params
+      @params = HashWithIndifferentAccess.new(graphql_request.params)
+    end
+  end
+end

data/lib/graphiti/controller/action_configuration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/filters'
+require 'graphql_rails/attribute'
+
+module GraphqlRails
+  class Controller
+    # stores all graphql_rails contoller specific config
+    class ActionConfiguration
+      attr_reader :attributes, :return_type
+
+      def initialize
+        @attributes = {}
+        @can_return_nil = false
+      end
+
+      def permit(*no_type_attributes, **typed_attributes)
+        no_type_attributes.each { |attribute| permit_attribute(attribute) }
+        typed_attributes.each { |attribute, type| permit_attribute(attribute, type) }
+        self
+      end
+
+      def can_return_nil
+        @can_return_nil = true
+        self
+      end
+
+      def returns(new_return_type)
+        @return_type = new_return_type
+        self
+      end
+
+      def can_return_nil?
+        @can_return_nil
+      end
+
+      private
+
+      def permit_attribute(name, type = nil)
+        field_name = name.to_s.remove(/!\Z/)
+        required = name.to_s.end_with?('!')
+        attributes[field_name] = Attribute.new(field_name, type, required: required)
+      end
+    end
+  end
+end

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