graphql_rails 0.1.0 → 0.2.0

data/lib/graphiti/controller/controller_function.rb

@@ -1,41 +0,0 @@
-# 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

@@ -1,40 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,81 +0,0 @@
-# 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/graphiti/router.rb

@@ -1,65 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# 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