graphql-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8386088857c27bbcdea43d4891771e8bea89e8f7
+  data.tar.gz: 2bedc9fc92d44483612f9253df2dfde7ce2f8973
+SHA512:
+  metadata.gz: df543107f1fa308fb2228f7951b70ac28c263f0aea93024d121dfcf093d75e515b146bd71655fc0e6e23beb548924d28c7700284833c3f8725b4c573c8c2eec7
+  data.tar.gz: 06057d2317334ed33e8a16e4f7f35e9b6f8209c2f8207ae03c57421a1f28a3b076879f2fd924e74ac76828caf07b6c875b1feae2b8de7efd32d5545cc12f05b2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016 James Reggio <james.reggio@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/app/controllers/graphql/rails/schema_controller.rb

@@ -0,0 +1,59 @@
+module GraphQL
+  module Rails
+    class SchemaController < ActionController::Base
+      include ControllerExtensions
+      rescue_from Exception, :with => :internal_error
+      rescue_from GraphQL::ParseError, :with => :invalid_query
+      rescue_from JSON::ParserError, :with => :invalid_variables
+
+      def execute
+        query_string = params[:query]
+        query_variables = to_hash(params[:variables])
+        render json: Schema.instance.execute(
+          query_string,
+          variables: query_variables,
+          context: context,
+          debug: true
+        )
+      end
+
+      private
+
+      def context
+        @context ||= {}
+      end
+
+      def to_hash(param)
+        if param.blank?
+          {}
+        elsif param.is_a?(String)
+          JSON.parse(param)
+        else
+          param
+        end
+      end
+
+      def render_error(status, message)
+        render json: {
+          :errors => [{:message => message}],
+        }, :status => status
+      end
+
+      def invalid_request(message)
+        render_error 400, message
+      end
+
+      def invalid_query
+        invalid_request 'Unable to parse query'
+      end
+
+      def invalid_variables
+        invalid_request 'Unable to parse variables'
+      end
+
+      def internal_error
+        render_error 500, 'Internal error'
+      end
+    end
+  end
+end

data/config/initializers/graphiql.rb

@@ -0,0 +1 @@
+GraphiQL::Rails.config.csrf = true

data/config/routes.rb

@@ -0,0 +1,12 @@
+module GraphQL
+  module Rails
+    Engine.routes.draw do
+      if Rails.config.graphiql
+        # Empty :graphql_path will cause GraphiQL to use its own URL.
+        mount GraphiQL::Rails::Engine => '/', :graphql_path => ''
+      end
+
+      post '/' => 'schema#execute'
+    end
+  end
+end

data/lib/graphql/rails.rb

@@ -0,0 +1,16 @@
+require 'rails'
+require 'graphql'
+require 'graphql/relay'
+require 'graphiql/rails'
+
+require 'graphql/rails/version'
+require 'graphql/rails/dsl'
+require 'graphql/rails/engine'
+require 'graphql/rails/config'
+require 'graphql/rails/config'
+require 'graphql/rails/types'
+require 'graphql/rails/node_identification'
+require 'graphql/rails/controller_extensions'
+require 'graphql/rails/schema'
+require 'graphql/rails/callbacks'
+require 'graphql/rails/operations'

data/lib/graphql/rails/callbacks.rb

@@ -0,0 +1,49 @@
+module GraphQL
+  module Rails
+    class Operations
+      module Callbacks
+        extend ActiveSupport::Concern
+        include ActiveSupport::Callbacks
+
+        included do
+          define_callbacks :perform_operation
+        end
+
+        module ClassMethods
+          [:before, :after, :around].each do |callback|
+            define_method "#{callback}_operation" do |*names, &blk|
+              insert_callbacks(names, blk) do |name, options|
+                set_callback(:perform_operation, callback, name, options)
+              end
+            end
+            alias_method :"#{callback}_filter", :"#{callback}_operation"
+          end
+
+          private
+
+          def normalize_callback_options(options)
+            normalize_callback_option(options, :only, :if)
+            normalize_callback_option(options, :except, :unless)
+          end
+
+          def normalize_callback_option(options, from, to)
+            return unless options[from]
+            check = -> do
+              Array(options[from]).find { |operation| name == operation }
+            end
+            options[to] = Array(options[to]) + [check]
+          end
+
+          def insert_callbacks(callbacks, block = nil)
+            options = callbacks.extract_options!
+            normalize_callback_options(options)
+            callbacks.push(block) if block
+            callbacks.each do |callback|
+              yield callback, options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/config.rb

@@ -0,0 +1,28 @@
+module GraphQL
+  module Rails
+    extend self
+
+    def configure
+      yield config
+    end
+
+    def config
+      @config ||= OpenStruct.new({
+        # Should the GraphiQL web interface be served?
+        :graphiql => ::Rails.env.development?,
+
+        # Should names be converted to lowerCamelCase per GraphQL convention?
+        # For example, should :get_user_tasks become 'getUserTasks'?
+        :camel_case => true,
+
+        # Should object IDs be globally unique?
+        # This is necessary to conform to the Relay Global Object ID spec.
+        :global_ids => true,
+
+        # Should the following extensions be loaded?
+        :mongoid => defined?(::Mongoid),
+        :cancan => defined?(::CanCan),
+      })
+    end
+  end
+end

data/lib/graphql/rails/controller_extensions.rb

@@ -0,0 +1,23 @@
+module GraphQL
+  module Rails
+    module ControllerExtensions
+      extend self
+
+      def add(&block)
+        callbacks.push block
+      end
+
+      def included(base)
+        callbacks.each do |callback|
+          base.class_eval(&callback)
+        end
+      end
+
+      private
+
+      def callbacks
+        @callbacks ||= []
+      end
+    end
+  end
+end

data/lib/graphql/rails/dsl.rb

@@ -0,0 +1,18 @@
+module GraphQL
+  module Rails
+    class DSL < BasicObject
+      def run(&block)
+        @self = eval('self', block.binding)
+        instance_eval(&block)
+      end
+
+      def method_missing(method, *args, &block)
+        begin
+          @self.send(method, *args, &block)
+        rescue
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/engine.rb

@@ -0,0 +1,68 @@
+# Inflections must be added before the namespace is isolated, because the
+# namespace's route prefix is calculated and cached at that time.
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.acronym 'GraphQL'
+end
+
+module GraphQL
+  module Rails
+    mattr_accessor :logger
+
+    class Engine < ::Rails::Engine
+      isolate_namespace GraphQL::Rails
+
+      initializer 'graphql-rails.autoload', :before => :set_autoload_paths do |app|
+        # Even though we aren't using symbolic autoloading of operations, they
+        # must be included in autoload_paths in order to be unloaded during
+        # reload operations.
+        @graph_path = app.root.join('app', 'graph')
+        app.config.autoload_paths += [
+          @graph_path.join('types'),
+          @graph_path.join('operations'),
+        ]
+      end
+
+      initializer 'graphql-rails.logger', :after => :initialize_logger do |app|
+        logger = ::Rails.logger.clone
+        logger.class_eval do
+          def exception(e)
+            begin
+              error "#{e.class.name} (#{e.message}):"
+              error "  #{e.backtrace.join("\n  ")}"
+            rescue
+            end
+          end
+        end
+        Rails.logger = logger
+        Rails.logger.debug 'Initialized logger'
+      end
+
+      initializer 'graphql-rails.extensions', :after => :load_config_initializers do |app|
+        # These depend upon a loaded Rails app, so we load them dynamically.
+        extensions = File.join(File.dirname(__FILE__), 'extensions', '*.rb')
+        Dir[extensions].each do |file|
+          require file
+        end
+      end
+
+      initializer 'graphql-rails.prepare', :before => :add_to_prepare_blocks do
+        # The block executes in the context of the reloader, so we have to
+        # preserve a reference to the engine instance.
+        engine = self
+        config.to_prepare_blocks.push -> do
+          engine.reload!
+        end
+      end
+
+      def reload!
+        Types.clear
+        Schema.clear
+        Rails.logger.debug 'Loading operations'
+        Dir[@graph_path.join('operations', '**', '*.rb')].each do |file|
+          Rails.logger.debug "Loading file: #{file}"
+          require_dependency file
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/extensions/cancan.rb

@@ -0,0 +1,50 @@
+module GraphQL
+  module Rails
+    if Rails.config.cancan
+      Rails.logger.debug 'Loading CanCan extensions'
+
+      Operations.class_eval do
+        extend Forwardable
+        def_delegators :current_ability, :can?, :cannot?
+
+        def self.check_authorization(options = {})
+          self.after_filter(options.slice(:only, :except)) do |instance|
+            next if instance.instance_variable_defined?(:@authorized)
+            next if options[:if] && !instance.send(options[:if])
+            next if options[:unless] && instance.send(options[:unless])
+            raise 'This operation failed to perform an authorization check'
+          end
+        end
+
+        def skip_authorization_check(*args)
+          self.before_filter(*args) do |instance|
+            instance.instance_variable_set(:@authorized, true)
+          end
+        end
+
+        def authorize!(*args)
+          begin
+            @authorized = true
+            current_ability.authorize!(*args)
+          rescue CanCan::AccessDenied
+            raise 'You are not authorized to perform this operation'
+          end
+        end
+
+        def current_ability
+          @current_ability ||= ::Ability.new(current_user)
+        end
+
+        def current_user
+          ctx[:current_user]
+        end
+      end
+
+      ControllerExtensions.add do
+        before_filter do
+          context[:current_user] = current_user
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/extensions/mongoid.rb

@@ -0,0 +1,96 @@
+module GraphQL
+  module Rails
+    if Rails.config.mongoid
+      Rails.logger.debug 'Loading Mongoid extensions'
+
+      GraphQL::Relay::BaseConnection.register_connection_implementation(
+        ::Mongoid::Relations::Targets::Enumerable,
+        GraphQL::Relay::RelationConnection
+      )
+
+      module Mongoid
+        extend self
+
+        NAMESPACE = 'MG'
+
+        def clear
+          @types = nil
+        end
+
+        def resolve(type)
+          types[type] || build_type(type)
+        end
+
+        def lookup(type_name, id)
+          return if Types.use_namespaces? && !type_name.starts_with?(NAMESPACE)
+          types.each_pair do |type, graph_type|
+            return type.find(id) if graph_type.name == type_name
+          end
+          nil
+        end
+
+        private
+
+        def types
+          @types ||= {
+            ::Mongoid::Boolean => GraphQL::BOOLEAN_TYPE,
+            BSON::ObjectId => GraphQL::STRING_TYPE,
+          }
+        end
+
+        def build_type(type)
+          return nil unless type.included_modules.include?(::Mongoid::Document)
+          Rails.logger.debug "Building Mongoid::Document type: #{type.name}"
+
+          # TODO: Support parent types/interfaces.
+          type_name = to_name(type)
+          types[type] = GraphQL::ObjectType.define do
+            name type_name
+
+            if Rails.config.global_ids
+              interfaces [NodeIdentification.interface]
+              global_id_field :id
+            end
+
+            type.fields.each_value do |field_value|
+              field field_value.name do
+                type -> { Types.resolve(field_value.type) }
+                description field_value.label unless field_value.label.blank?
+              end
+            end
+
+            type.relations.each_value do |relationship|
+              # TODO: Add polymorphic support.
+              if relationship.polymorphic?
+                Rails.logger.warn(
+                  "Skipping polymorphic relationship: #{relationship.name}"
+                )
+                next
+              end
+
+              if relationship.many?
+                connection relationship.name do
+                  type -> { Types.resolve(relationship.klass).connection_type }
+                end
+              else
+                field relationship.name do
+                  type -> { Types.resolve(relationship.klass) }
+                end
+              end
+            end
+          end
+        end
+
+        def to_name(type)
+          if Types.use_namespaces?
+            NAMESPACE + type.name
+          else
+            type.name
+          end
+        end
+      end
+
+      Types.add_extension Mongoid
+    end
+  end
+end

data/lib/graphql/rails/node_identification.rb

@@ -0,0 +1,13 @@
+module GraphQL
+  module Rails
+    NodeIdentification = GraphQL::Relay::GlobalNodeIdentification.define do
+      object_from_id -> (id, ctx) do
+        Types.lookup(*NodeIdentification.from_global_id(id))
+      end
+
+      type_from_object -> (obj) do
+        Types.resolve(obj.class)
+      end
+    end
+  end
+end

data/lib/graphql/rails/operations.rb

@@ -0,0 +1,100 @@
+module GraphQL
+  module Rails
+    class Operations
+      extend Forwardable
+      include Callbacks
+
+      def initialize(options = {})
+        @options = OpenStruct.new(options)
+        self.class.instance_eval do
+          def_delegators :@options, *options.keys
+        end
+      end
+
+      def self.query(hash, &block)
+        hash = extract_pair(hash)
+        Rails.logger.debug "Adding query: #{to_name(hash[:name])}"
+
+        definition = QueryDefinition.new(self)
+        definition.run(&block)
+        definition.run do
+          name hash[:name]
+          type hash[:type]
+        end
+        Schema.add_query definition.field
+      end
+
+      # TODO: Implement mutations and subscriptions.
+      # TODO: Implement model functions (only, exclude, rename, etc.)
+
+      private
+
+      def self.extract_pair(hash)
+        unless hash.length == 1
+          raise 'Hash must contain a single :name => Type pair.'
+        end
+        {name: hash.keys.first, type: hash.values.first}
+      end
+
+      # TODO: Ensure consistent naming convention around everything.
+      def self.to_name(symbol)
+        if Rails.config.camel_case
+          symbol.to_s.camelize(:lower)
+        else
+          symbol.to_s
+        end
+      end
+
+      class QueryDefinition < DSL
+        attr_reader :field
+
+        def initialize(klass)
+          @klass = klass
+          @field = ::GraphQL::Field.new
+        end
+
+        def name(name)
+          @name = name
+          @field.name = to_name(name)
+        end
+
+        def type(type)
+          @type = type
+          @field.type = Types.resolve(type)
+        end
+
+        def description(description)
+          @field.description = description
+        end
+
+        def argument(name, type, required = false)
+          argument = ::GraphQL::Argument.new
+          argument.name = to_name(name)
+          argument.type = Types.resolve(type, required == :required)
+          @field.arguments[argument.name] = argument
+        end
+
+        def resolve(&block)
+          field.resolve = -> (obj, args, ctx) do
+            instance = @klass.new({
+              op: :query, name: @name, type: @type,
+              obj: obj, args: args, ctx: ctx
+            })
+
+            begin
+              instance.run_callbacks(:perform_operation) do
+                instance.instance_eval(&block)
+              end
+            rescue => e
+              ::GraphQL::ExecutionError.new(e.message)
+            rescue ::Exception => e
+              Rails.logger.error "Unexpected exception during query: #{@name}"
+              Rails.logger.exception e
+              ::GraphQL::ExecutionError.new('Internal error')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/schema.rb

@@ -0,0 +1,44 @@
+module GraphQL
+  module Rails
+    module Schema
+      extend self
+
+      def clear
+        @schema = nil
+        @fields = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      TYPES = [:query, :mutation, :subscription]
+
+      TYPES.each do |type|
+        define_method "add_#{type.to_s}" do |field|
+          @schema = nil # Invalidate cached schema.
+          @fields[type].push field
+        end
+      end
+
+      def instance
+        # TODO: Support max_depth and types.
+        # TODO: Sweep available options and expose in config.
+        @schema ||= GraphQL::Schema.new begin
+          TYPES.reduce({}) do |schema, type|
+            fields = @fields[type]
+            unless fields.empty?
+              schema[type] = GraphQL::ObjectType.define do
+                name type.to_s.capitalize
+                description "Root #{type.to_s} for this schema"
+                fields.each do |value|
+                  field value.name, field: value
+                end
+                if Rails.config.global_ids && type == :query
+                  field :node, field: NodeIdentification.field
+                end
+              end
+            end
+            schema
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/types.rb

@@ -0,0 +1,92 @@
+module GraphQL
+  module Rails
+    module Types
+      extend self
+
+      def clear
+        @types = nil
+        extensions.each do |extension|
+          extension.clear
+        end
+      end
+
+      # Resolve an arbitrary type to a GraphQL type.
+      def resolve(type, required = false)
+        if type.nil?
+          raise 'Cannot resolve nil type.'
+        elsif required
+          resolve(type).to_non_null_type
+        elsif type.is_a?(GraphQL::BaseType)
+          type
+        elsif type.is_a?(Array)
+          unless type.length == 1
+            raise 'Lists must be specified with single-element arrays.'
+          end
+          resolve(type.first).to_list_type
+        elsif types.include?(type)
+          resolve(types[type])
+        else
+          resolve(try_extensions(:resolve, type) || begin
+            # TODO: Remove this hack.
+            Rails.logger.warn "Unable to resolve type: #{type.name}"
+            String
+          end)
+        end
+      end
+
+      # Lookup an arbitrary object from its GraphQL type name and ID.
+      def lookup(type_name, id)
+        try_extensions(:lookup, type_name, id)
+      end
+
+      # Should extensions namespace their type names?
+      # This is necessary if multiple extensions are loaded, so as to avoid
+      # collisions in the shared type namespace.
+      def use_namespaces?
+        extensions.count > 1
+      end
+
+      # Add an extension to the type system.
+      # Generally, each ORM will have its own extension.
+      def add_extension(extension)
+        extensions.push extension
+      end
+
+      private
+
+      # Default mapping of built-in scalar types to GraphQL types.
+      def types
+        @types ||= {
+          String => GraphQL::STRING_TYPE,
+          Boolean => GraphQL::BOOLEAN_TYPE,
+
+          Fixnum => GraphQL::INT_TYPE,
+          Integer => GraphQL::INT_TYPE,
+          Float => GraphQL::FLOAT_TYPE,
+
+          Date => GraphQL::STRING_TYPE,
+          Time => GraphQL::STRING_TYPE,
+          DateTime => GraphQL::STRING_TYPE,
+
+          Array => GraphQL::STRING_TYPE,
+          Object => GraphQL::STRING_TYPE,
+          Hash => GraphQL::STRING_TYPE,
+        }
+      end
+
+      def extensions
+        @extensions ||= []
+      end
+
+      # Try a function on each extension, and return the result from
+      # the first extension that returns a non-nil value.
+      def try_extensions(method, *args, &block)
+        extensions.each do |extension|
+          result = extension.send(method, *args, &block)
+          return result unless result.nil?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/graphql/rails/version.rb

@@ -0,0 +1,5 @@
+module GraphQL
+  module Rails
+    VERSION = '0.0.1'
+  end
+end

data/lib/tasks/graphql_rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :graphql_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: graphql-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- James Reggio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: graphql-relay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: graphiql-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: |
+  Zero-configuration GraphQL + Relay support for Rails.
+
+  - Adds a route to process GraphQL operations.
+  - Provides a visual editor (GraphiQL) for development.
+  - Allows you to specify GraphQL queries and mutations as though they were controller actions.
+  - Automatically maps Mongoid models to GraphQL types.
+  - Seamlessly integrates with CanCan.
+email:
+- james.reggio@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/controllers/graphql/rails/schema_controller.rb
+- config/initializers/graphiql.rb
+- config/routes.rb
+- lib/graphql/rails/callbacks.rb
+- lib/graphql/rails/config.rb
+- lib/graphql/rails/controller_extensions.rb
+- lib/graphql/rails/dsl.rb
+- lib/graphql/rails/engine.rb
+- lib/graphql/rails/extensions/cancan.rb
+- lib/graphql/rails/extensions/mongoid.rb
+- lib/graphql/rails/node_identification.rb
+- lib/graphql/rails/operations.rb
+- lib/graphql/rails/schema.rb
+- lib/graphql/rails/types.rb
+- lib/graphql/rails/version.rb
+- lib/graphql/rails.rb
+- lib/tasks/graphql_rails_tasks.rake
+- LICENSE
+homepage: https://github.com/jamesreggio/graphql-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14.1
+signing_key: 
+specification_version: 4
+summary: Zero-configuration GraphQL + Relay support for Rails
+test_files: []