graphql_rails 0.1.0 → 0.2.0

data/lib/graphql_rails/controller/action_configuration.rb

@@ -38,8 +38,7 @@ module GraphqlRails
 
       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)
+        attributes[field_name] = Attribute.new(field_name, type)
       end
     end
   end

data/lib/graphql_rails/controller/controller_function.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'graphql_rails/controller/action_path_parser'
+require 'graphql_rails/controller/action'
 require_relative 'request'
+require_relative 'action'
 
 module GraphqlRails
   class Controller
@@ -16,16 +17,16 @@ module GraphqlRails
         @type = return_type
       end
 
-      def self.build(action_path, **options)
-        action_parser = ActionPathParser.new(action_path, **options)
+      def self.from_route(route)
+        action = Action.new(route)
 
         action_function = Class.new(self) do
-          action_parser.arguments.each do |action_attribute|
-            argument(action_attribute.field_name, action_attribute.graphql_field_type)
+          action.arguments.each do |attribute|
+            argument(attribute.field_name, attribute.graphql_field_type)
           end
         end
 
-        action_function.new(action_parser.controller, action_parser.action_name, action_parser.return_type)
+        action_function.new(action.controller, action.name, action.return_type)
       end
 
       def call(object, inputs, ctx)

data/lib/graphql_rails/controller/request.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../errors/execution_error'
+require 'graphql_rails/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
+      attr_reader :errors, :context
 
       def initialize(graphql_object, inputs, context)
         @graphql_object = graphql_object
@@ -34,7 +34,7 @@ module GraphqlRails
 
       private
 
-      attr_reader :graphql_object, :inputs, :context
+      attr_reader :graphql_object, :inputs
     end
   end
 end

data/lib/graphql_rails/model.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'model/configuration'
+require 'graphql_rails/model/configuration'
 
 module GraphqlRails
   # this module allows to convert any ruby class in to grapql type object

data/lib/graphql_rails/model/configuration.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'graphql_rails/attribute'
+require 'graphql_rails/model/graphql_type_builder'
 
 module GraphqlRails
   module Model
@@ -13,68 +14,31 @@ module GraphqlRails
         @attributes = {}
       end
 
-      def attribute(attribute_name, type: nil, hidden: false)
-        attributes[attribute_name.to_s] = Attribute.new(attribute_name, type, hidden: hidden)
+      def name(type_name = nil)
+        @name ||= type_name
       end
 
-      def include_model_attributes(except: [])
-        except = Array(except).map(&:to_s)
+      def description(description = nil)
+        @description ||= description
+      end
 
-        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
+      def attribute(attribute_name, type: nil, hidden: false, property: attribute_name)
+        attributes[attribute_name.to_s] = Attribute.new(attribute_name, type, hidden: hidden, property: property)
       end
 
       def graphql_type
-        @graphql_type ||= generate_graphql_type(graphql_type_name, visible_attributes)
+        @graphql_type ||= begin
+         type_name = name || name_by_class_name
+         GrapqhlTypeBuilder.new(name: type_name, description: description, attributes: attributes).call
+       end
       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
+      def name_by_class_name
+        @name_by_class_name ||= model_class.name.split('::').last
       end
     end
   end

data/lib/graphql_rails/model/graphql_type_builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module GraphqlRails
+  module Model
+    # stores information about model specific config, like attributes and types
+    class GrapqhlTypeBuilder
+      def initialize(name:, description: nil, attributes:)
+        @name = name
+        @attributes = attributes
+        @description = description
+      end
+
+      def call
+        type_name = name
+        type_description = description
+        type_attributes = visible_attributes
+
+        GraphQL::ObjectType.define do
+          name(type_name)
+          description(type_description)
+
+          type_attributes.each_value do |attribute|
+            field(attribute.field_name, attribute.graphql_field_type, property: attribute.property.to_sym)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :model_configuration, :attributes, :name, :description
+
+      def visible_attributes
+        attributes.reject { |_name, attribute| attribute.hidden? }
+      end
+    end
+  end
+end

data/lib/graphql_rails/router.rb

@@ -2,64 +2,81 @@
 
 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'
+require 'graphql_rails/router/schema_builder'
+require 'graphql_rails/router/mutation_route'
+require 'graphql_rails/router/query_route'
+require 'graphql_rails/router/resource_routes_builder'
 
 module GraphqlRails
   # graphql router that mimics Rails.application.routes
   class Router
+    RAW_ACTION_NAMES = %i[rescue_from query_analyzer instrument].freeze
+
     def self.draw(&block)
       router = new
       router.instance_eval(&block)
       router.graphql_schema
     end
 
-    attr_reader :actions, :namespace_name
+    attr_reader :routes, :namespace_name, :raw_graphql_actions
 
     def initialize(module_name: '')
       @module_name = module_name
-      @actions ||= Set.new
+      @routes ||= Set.new
+      @raw_graphql_actions ||= []
     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)
+      routes.merge(scoped_router.routes)
     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)
+      builder_options = default_route_options.merge(options)
+      routes_builder = ResourceRoutesBuilder.new(name, **builder_options)
+      routes_builder.instance_eval(&block) if block
+      routes.merge(routes_builder.routes)
     end
 
     def query(name, **options)
-      actions << build_action(QueryAction, name, **options)
+      routes << build_route(QueryRoute, name, **options)
     end
 
     def mutation(name, **options)
-      actions << build_action(MutationAction, name, **options)
+      routes << build_route(MutationRoute, name, **options)
+    end
+
+    RAW_ACTION_NAMES.each do |action_name|
+      define_method(action_name) do |*args, &block|
+        add_raw_action(action_name, *args, &block)
+      end
     end
 
     def graphql_schema
-      SchemaBuilder.new(queries: actions.select(&:query?), mutations: actions.select(&:mutation?)).call
+      SchemaBuilder.new(
+        queries: routes.select(&:query?),
+        mutations: routes.select(&:mutation?),
+        raw_actions: raw_graphql_actions
+      ).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)
+    def add_raw_action(name, *args, &block)
+      raw_graphql_actions << { name: name, args: args, block: block }
+    end
+
+    def build_route(route_builder, name, **options)
+      route_options = default_route_options.merge(options)
+      route_builder.new(name, route_options)
     end
 
-    def default_action_options
-      { module: module_name }
+    def default_route_options
+      { module: module_name, on: :member }
     end
   end
 end

data/lib/graphql_rails/router/{mutation_action.rb → mutation_route.rb}

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

data/lib/graphql_rails/router/{query_action.rb → query_route.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'action'
+require_relative 'route'
 
 module GraphqlRails
   class Router
     # stores query type graphql action info
-    class QueryAction < Action
+    class QueryRoute < Route
       def query?
         true
       end

data/lib/graphql_rails/router/resource_routes_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'query_route'
+require_relative 'mutation_route'
+
+module GraphqlRails
+  class Router
+    # Generates graphql routes based on resource name and options
+    class ResourceRoutesBuilder
+      AVAILABLE_ROUTES = %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_ROUTES)
+      end
+
+      def routes
+        @routes ||= initial_routes
+      end
+
+      def query(*args)
+        routes << build_query(*args)
+      end
+
+      def mutation(*args)
+        routes << build_mutation(*args)
+      end
+
+      private
+
+      attr_reader :autogenerated_action_names, :name, :options
+
+      def initial_routes
+        routes = initial_query_routes
+        routes << build_mutation(:create, on: :member) if autogenerated_action_names.include?(:create)
+        routes << build_mutation(:update, on: :member) if autogenerated_action_names.include?(:update)
+        routes << build_mutation(:destroy, on: :member) if autogenerated_action_names.include?(:destroy)
+        routes
+      end
+
+      def initial_query_routes
+        routes = Set.new
+
+        if autogenerated_action_names.include?(:show)
+          routes << build_route(QueryRoute, 'show', to: "#{name}#show", prefix: '', on: :member)
+        end
+
+        if autogenerated_action_names.include?(:index)
+          routes << build_route(QueryRoute, 'index', to: "#{name}#index", prefix: '', on: :collection)
+        end
+
+        routes
+      end
+
+      def build_mutation(*args)
+        build_route(MutationRoute, *args)
+      end
+
+      def build_query(*args)
+        build_route(QueryRoute, *args)
+      end
+
+      def build_route(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_routes = Array(only || available) & available
+        only_routes = alowed_routes.map(&:to_sym) - Array(except).map(&:to_sym)
+        Set.new(only_routes)
+      end
+
+      def resource_name(type)
+        type.to_sym == :member ? name.singularize : name
+      end
+    end
+  end
+end

data/lib/graphql_rails/router/route.rb

@@ -0,0 +1,40 @@
+# 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 Route
+      attr_reader :name, :module_name, :on
+
+      def initialize(name, to:, on:, **options)
+        @name = name.to_s.camelize(:lower)
+        @module_name = options[:module].to_s
+        @relative_path = to
+        @on = on.to_sym
+      end
+
+      def path
+        return relative_path if module_name.empty?
+        [module_name, relative_path].join('/')
+      end
+
+      def collection?
+        on == :collection
+      end
+
+      def member?
+        on == :member
+      end
+
+      def options
+        { function: Controller::ControllerFunction.build(path) }
+      end
+
+      private
+
+      attr_reader :relative_path
+    end
+  end
+end