graphql_rails 0.1.0

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

data/lib/graphiti/router/query_action.rb

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

data/lib/graphiti/router/resource_actions_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'query_action'
+require_relative 'mutation_action'
+
+module GraphqlRails
+  class Router
+    # Generates graphql actions based on resource name and options
+    class ResourceActionsBuilder
+      AVAILABLE_ACTIONS = %i[show index create update destroy].freeze
+
+      def initialize(name, only: nil, except: [], **options)
+        @name = name.to_s
+
+        @options = options
+        @autogenerated_action_names = initial_action_names(only, except, AVAILABLE_ACTIONS)
+      end
+
+      def actions
+        @actions ||= initial_actions
+      end
+
+      def query(*args)
+        actions << build_query(*args)
+      end
+
+      def mutation(*args)
+        actions << build_mutation(*args)
+      end
+
+      private
+
+      attr_reader :autogenerated_action_names, :name, :options
+
+      def initial_actions
+        actions = initial_query_actions
+        actions << build_mutation(:create, on: :member) if autogenerated_action_names.include?(:create)
+        actions << build_mutation(:update, on: :member) if autogenerated_action_names.include?(:update)
+        actions << build_mutation(:destroy, on: :member) if autogenerated_action_names.include?(:destroy)
+        actions
+      end
+
+      def initial_query_actions
+        actions = Set.new
+
+        if autogenerated_action_names.include?(:show)
+          actions << build_action(QueryAction, 'show', to: "#{name}#show", prefix: '', on: :member)
+        end
+
+        if autogenerated_action_names.include?(:index)
+          actions << build_action(QueryAction, 'index', to: "#{name}#index", prefix: '', on: :collection)
+        end
+
+        actions
+      end
+
+      def build_mutation(*args)
+        build_action(MutationAction, *args)
+      end
+
+      def build_query(*args)
+        build_action(QueryAction, *args)
+      end
+
+      def build_action(builder, action, prefix: action, on: :member, **custom_options)
+        action_options = options.merge(custom_options)
+        action_name = [prefix, resource_name(on)].reject(&:empty?).join('_')
+        builder.new(action_name, to: "#{name}##{action}", **action_options)
+      end
+
+      def initial_action_names(only, except, available)
+        alowed_actions = Array(only || available) & available
+        only_actions = alowed_actions.map(&:to_sym) - Array(except).map(&:to_sym)
+        Set.new(only_actions)
+      end
+
+      def resource_name(type)
+        type.to_sym == :member ? name.singularize : name
+      end
+    end
+  end
+end

data/lib/graphiti/router/schema_builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  class Router
+    # builds GraphQL::Schema based on previously defined grahiti data
+    class SchemaBuilder
+      attr_reader :queries, :mutations
+
+      def initialize(queries:, mutations:)
+        @queries = queries
+        @mutations = mutations
+      end
+
+      def call
+        query_type = build_type('Query', queries)
+        mutation_type = build_type('Mutation', mutations)
+
+        GraphQL::Schema.define do
+          query(query_type)
+          mutation(mutation_type)
+        end
+      end
+
+      private
+
+      def build_type(type_name, actions)
+        GraphQL::ObjectType.define do
+          name type_name
+
+          actions.each do |action|
+            field action.name, action.options
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  VERSION = '0.1.0'
+end

data/lib/graphql_rails.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/graphql_rails/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/graphql_rails/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/graphql_rails/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