rails-graphql 0.1.0

data/lib/rails/graphql/introspection.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # Module related to some methods regarding the introspection of a schema
+    module Introspection
+      module ClassMethods # :nodoc: all
+        def inherited(subclass)
+          super if defined? super
+
+          subclass.query_fields do
+            field(:__schema, '__Schema', null: false) do
+              resolve { schema }
+            end
+
+            field(:__type, '__Type') do
+              argument(:name, :string, null: false)
+              resolve { schema.find_type(argument(:name)) }
+            end
+          end
+        end
+      end
+
+      def self.extended(other) # :nodoc:
+        other.extend(Introspection::ClassMethods)
+      end
+
+      # When register is called, add introspection fields?
+      def register!(*)
+        super if defined? super
+        return unless introspection?
+
+        Helpers::WithSchemaFields::SCHEMA_FIELD_TYPES.each do |type, name|
+          GraphQL.type_map.register_alias(name, namespace: namespace) do
+            result = public_send("#{type}_type")
+            type.eql?(:query) || result.fields.present? ? result : nil
+          end
+        end
+      end
+
+      # Check if the schema has introspection enabled
+      def introspection?
+        true
+      end
+
+      # Remove introspection fields and disable introspection
+      def disable_introspection!
+        disable_fields(:query, :__schema, :__type)
+        redefine_singleton_method(:introspection?) { false }
+      end
+    end
+  end
+end

data/lib/rails/graphql/native.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Native # :nodoc:
+      extend FFI::Library
+
+      VERSION = GQLAst::VERSION
+
+      dl_name = "graphqlparser.#{RbConfig::MAKEFILE_CONFIG['DLEXT']}"
+      dl_path = Pathname.new(__dir__)
+
+      begin
+        ffi_lib(dl_path.join("../../#{dl_name}").to_s)
+      rescue LoadError
+        ffi_lib(dl_path.join("../../../../ext/#{dl_name}").to_s)
+      end
+
+      require_relative 'native/location'
+      require_relative 'native/visitor'
+      require_relative 'native/pointers'
+      require_relative 'native/functions'
+
+      attach_function :graphql_parse_string, %i[pointer pointer], :pointer
+
+      attach_function :to_json, :graphql_ast_to_json, [:pointer], :string
+
+      attach_function :free_node, :graphql_node_free, [:pointer], :void
+
+      attach_function :graphql_node_get_location, [:pointer, Location], :void
+
+      attach_function :visit, :graphql_node_visit, [:pointer, Visitor, :pointer], :void
+
+      # Parse the given GraphQL +content+ string returning the node pointer.
+      # The +dup+ here is important to be able to free the memory of the nodes
+      # partially. It will raise an exception if +content+ is invalid.
+      def self.parse(content)
+        error = Native::ParseError.new
+        content = FFI::MemoryPointer.from_string(content)
+        result = graphql_parse_string(content, error)
+        return result if error.empty?
+        raise GraphQL::ParseError, error.to_s
+      end
+
+      # Return a {+Location+}[rdoc-ref:Rails::GraphQL::Native::Location] class
+      # with the location information of the given +node+.
+      def self.get_location(node)
+        Native::Location.new.tap do |result|
+          graphql_node_get_location(node, result)
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/native/functions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Native # :nodoc:
+      def self.attach_operation(method_name, function_name, result: :string)
+        attach_function(method_name, function_name, [:pointer], result)
+      end
+
+      attach_operation :operation_type, :GraphQLAstOperationDefinition_get_operation
+      attach_operation :node_name,      :GraphQLAstName_get_value
+
+      attach_operation :get_int_value,    :GraphQLAstIntValue_get_value
+      attach_operation :get_float_value,  :GraphQLAstFloatValue_get_value
+      attach_operation :get_string_value, :GraphQLAstStringValue_get_value
+      attach_operation :get_enum_value,   :GraphQLAstEnumValue_get_value
+
+      with_options(result: :pointer) do
+        attach_operation :default_value, :GraphQLAstVariableDefinition_get_default_value
+        attach_operation :type_name,     :GraphQLAstNamedType_get_name
+
+        attach_operation :argument_name,  :GraphQLAstArgument_get_name
+        attach_operation :argument_value, :GraphQLAstArgument_get_value
+
+        attach_operation :ofield_name,  :GraphQLAstObjectField_get_name
+        attach_operation :ofield_value, :GraphQLAstObjectField_get_value
+
+        attach_operation :variable_name, :GraphQLAstVariable_get_name
+      end
+
+      with_options(result: :int) do
+        attach_operation :list_size, :GraphQLAstListValue_get_values_size
+
+        attach_operation :get_boolean_value, :GraphQLAstBooleanValue_get_value
+      end
+    end
+  end
+end

data/lib/rails/graphql/native/location.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Native # :nodoc:
+      class Location < FFI::Struct # :nodoc:
+        layout(
+          beginLine: :uint,
+          beginColumn: :uint,
+          endLine: :uint,
+          endColumn: :uint,
+        )
+
+        def begin_line
+          self[:beginLine]
+        end
+
+        def begin_column
+          self[:beginColumn]
+        end
+
+        def end_line
+          self[:endLine]
+        end
+
+        def end_column
+          self[:endColumn]
+        end
+
+        def to_errors
+          [
+            { 'line' => begin_line, 'column' => begin_column },
+            { 'line' => end_line,   'column' => end_column },
+          ]
+        end
+
+        private :[], :[]=
+      end
+    end
+  end
+end

data/lib/rails/graphql/native/pointers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Native # :nodoc:
+      # This helps to make sure that any parser error is correctly initialized
+      # and easy to ready. It also release the error using GC.
+      class ParseError < FFI::MemoryPointer
+        def initialize(*)
+          super(:pointer)
+        end
+
+        def to_s
+          empty? ? '' : read_pointer.read_string
+        end
+
+        def empty?
+          read_pointer.null?
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/native/visitor.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Native # :nodoc:
+      class Visitor < FFI::Struct # :nodoc:
+        CALLBACK_LAYOUT = %i[pointer pointer].freeze
+
+        MACROS = %w[
+          document operation_definition variable_definition selection_set field argument
+          fragment_spread inline_fragment fragment_definition variable int_value float_value
+          string_value boolean_value null_value enum_value list_value object_value object_field
+          directive named_type list_type non_null_type name schema_definition
+          operation_type_definition scalar_type_definition object_type_definition
+          field_definition input_value_definition interface_type_definition
+          union_type_definition enum_type_definition enum_value_definition
+          input_object_type_definition type_extension_definition directive_definition
+        ].freeze
+
+        AUTO_NESTED = %w[document object_value list_type non_null_type].freeze
+
+        ArgumentObject  = Struct.new(:name, :value, :variable)
+        DirectiveObject = Struct.new(:name, :arguments)
+        FieldObject     = Struct.new(:name, :alias, :arguments, :directives, :selection)
+        FragmentObject  = Struct.new(:name, :type, :directives, :selection)
+        OperationObject = Struct.new(:name, :kind, :variables, :directives, :selection)
+        SpreadObject    = Struct.new(:name, :type, :inline, :directives, :selection)
+        VariableObject  = Struct.new(:name, :type, :null, :array, :nullable, :default)
+
+        macros = MACROS.map do |key|
+          [
+            [    "visit_#{key}", callback(CALLBACK_LAYOUT, :bool)],
+            ["end_visit_#{key}", callback(CALLBACK_LAYOUT, :void)],
+          ]
+        end.flatten(1).to_h
+        layout(macros)
+
+        @@callbacks = Visitor.new
+        @@instances = Concurrent::Map.new
+
+        MACROS.each do |key|
+          @@callbacks["visit_#{key}".to_sym] = ->(node, ref) do
+            Visitor.ref_send(key, node, ref)
+          end
+
+          @@callbacks["end_visit_#{key}".to_sym] = ->(node, ref) do
+            Visitor.ref_send(key, node, ref, prefix: 'end')
+          end
+        end
+
+        def self.ref_send(key, node, ref, prefix: nil)
+          instance = @@instances[ref.read_string]
+          method_name = [prefix, 'visit', key].compact.join('_')
+
+          catch :override do
+            instance.try(method_name, node)
+            prefix.nil? && instance.visit_nested?(key)
+          end
+        end
+
+        delegate_missing_to('Rails::GraphQL::Native')
+
+        attr_reader :stack, :block
+
+        def initialize
+          @data = FFI::MemoryPointer.from_string(SecureRandom.uuid)
+          @stack = []
+          @visit = nil
+          @block = nil
+          @error = nil
+
+          @@instances[uuid] = self
+        end
+
+        # Remove the instance for the set of instances
+        def terminate
+          @@instances.delete(uuid)
+        end
+
+        # Get the uuid from the string pointer
+        def uuid
+          @data.read_string
+        end
+
+        # Check if it should go deeper into the node
+        def visit_nested?(key)
+          @error.nil? && (AUTO_NESTED.include?(key) || @visit&.include?(key))
+        end
+
+        # Return the last object on the stack being visited
+        def object
+          stack.last
+        end
+
+        # Send the extra needed arguments to the original visitor
+        def visit(node)
+          Native.visit(node, @@callbacks, @data)
+        end
+
+        # Catches if an exception happens inside the block, because visitors on
+        # the C lib does not pop such expections
+        def safe_call_block(*args)
+          block.call(*args)
+        rescue Exception => err
+          @error ||= err
+        end
+
+        # Pre caller for calling the visitor on nodes
+        def dispatch(visitors, nodes, &block)
+          @visit = visitors
+          @block = block
+
+          nodes.each(&method(:visit))
+          raise @error unless @error.nil?
+        ensure
+          @error = @block = @visit = nil
+        end
+
+        # ENTRY POINTS
+
+        DEFINITION_VISITORS = %w[operation_definition fragment_definition].freeze
+        def collect_definitions(*nodes, &block)
+          dispatch(DEFINITION_VISITORS, nodes, &block)
+        end
+
+        DIRECTIVES_VISITORS = %w[directive].freeze
+        def collect_directives(*nodes, &block)
+          dispatch(DIRECTIVES_VISITORS, nodes, &block)
+        end
+
+        ARGUMENTS_VISITORS = %w[argument].freeze
+        def collect_arguments(*nodes, &block)
+          dispatch(ARGUMENTS_VISITORS, nodes, &block)
+        end
+
+        VARIABLES_VISITORS = %w[variable_definition].freeze
+        def collect_variables(*nodes, &block)
+          dispatch(VARIABLES_VISITORS, nodes, &block)
+        end
+
+        FIELDS_VISITORS = %w[field fragment_spread inline_fragment].freeze
+        def collect_fields(*nodes, &block)
+          dispatch(FIELDS_VISITORS, nodes, &block)
+        end
+
+        # MAIN VISITORS
+
+        # Add an operation object to the stack
+        def visit_operation_definition(node)
+          stack << OperationObject.new.tap { |obj| obj.kind = operation_type(node) }
+        end
+
+        # Add a fragment object to the stack
+        def visit_fragment_definition(_)
+          stack << FragmentObject.new
+        end
+
+        # Add a field object to the stack
+        def visit_field(_)
+          stack << FieldObject.new
+        end
+
+        # Add a spread object to the stack
+        def visit_fragment_spread(_)
+          stack << SpreadObject.new
+        end
+
+        # Add a spread object to the stack
+        def visit_inline_fragment(_)
+          stack << SpreadObject.new.tap { |obj| obj.inline = true }
+        end
+
+        # BLOCK DISPATCHER VISITORS
+
+        # Send the operation object to the set block
+        def end_visit_operation_definition(node)
+          safe_call_block(:operation, node, stack.pop)
+        end
+
+        # Send the fragment object to the set block
+        def end_visit_fragment_definition(node)
+          safe_call_block(:fragment, node, stack.pop)
+        end
+
+        # Send the directive object to the set block
+        def end_visit_directive(_)
+          return unless @visit&.include?('directive')
+
+          safe_call_block(stack.pop)
+        end
+
+        # Send the argument object to the set block
+        def end_visit_argument(_)
+          return unless @visit&.include?('argument')
+
+          stack[-2][:value] = stack.pop if stack.size > 1
+          safe_call_block(stack.pop)
+        end
+
+        # Send the variable object to the set block
+        def end_visit_variable_definition(node)
+          return unless @visit&.include?('variable_definition')
+
+          stack[-2][:default] = stack.pop unless default_value(node).null?
+          safe_call_block(stack.pop, node)
+        end
+
+        # Send the field object to the set block
+        def end_visit_field(node)
+          safe_call_block(:field, node, stack.pop)
+        end
+
+        # Send the spread object to the set block
+        def end_visit_fragment_spread(node)
+          safe_call_block(:spread, node, stack.pop)
+        end
+
+        # Send the spread object to the set block
+        def end_visit_inline_fragment(node)
+          safe_call_block(:spread, node, stack.pop)
+        end
+
+        # SECONDARY VISITORS
+
+        # Add a variable definition to the current object
+        def visit_variable_definition(node)
+          if @visit&.include?('variable_definition')
+            stack << VariableObject.new.tap do |obj|
+              obj.null = true
+              obj.array = false
+              obj.nullable = true
+            end
+          else
+            (object[:variables] ||= []) << node
+          end
+        end
+
+        # Add a directive to the current object
+        def visit_directive(node)
+          if @visit&.include?('directive')
+            stack << DirectiveObject.new
+          else
+            (object[:directives] ||= []) << node
+          end
+        end
+
+        # Add a selection set to the current object
+        def visit_selection_set(node)
+          throw(:override, true) if object.nil?
+          object[:selection] = node
+        end
+
+        # SHARED VISITORS
+
+        # Set a name into the object
+        def visit_name(node)
+          object[:alias] = object[:name] unless object[:name].nil?
+          object[:name] = node_name(node)
+        end
+
+        # Get the type of the object
+        def visit_named_type(node)
+          object[:type] = node_name(type_name(node))
+        end
+
+        # Set the object as an array
+        def visit_list_type(_)
+          object[:array] = true
+        end
+
+        # Set the object as non null or non nullable
+        def visit_non_null_type(_)
+          object[object[:array] ? :nullable : :null] = false
+        end
+
+        # Get an argument information with its given written value
+        def visit_argument(node)
+          if @visit&.include?('argument')
+            stack << ArgumentObject.new
+          elsif @visit&.include?('field')
+            (object[:arguments] ||= []) << node
+          else
+            visit(argument_value(node))
+            arg_name = node_name(argument_name(node))
+            (stack[-2][:arguments] ||= {})[arg_name] = stack.pop
+          end
+        end
+
+        # Add a variable to the stack
+        def visit_variable(node)
+          if @visit&.include?('argument')
+            object[:variable] = variable_name(node)
+          elsif @visit&.include?('variable_definition')
+            object[:name] = visit_name(variable_name(node))
+          else
+            stack << variable_name(node)
+          end
+        end
+
+        # Add a integer value to the stack
+        def visit_int_value(node)
+          stack << get_int_value(node)
+        end
+
+        # Add a float value to the stack
+        def visit_float_value(node)
+          stack << get_float_value(node)
+        end
+
+        # Add a string value to the stack
+        def visit_string_value(node)
+          stack << get_string_value(node)
+        end
+
+        # Add a boolean value to the stack
+        def visit_boolean_value(node)
+          stack << get_boolean_value(node).eql?(1)
+        end
+
+        # Add a nil value to the stack
+        def visit_null_value(*)
+          stack << nil
+        end
+
+        # Add a enum string-like value to the stack
+        def visit_enum_value(node)
+          stack << get_enum_value(node)
+        end
+
+        # Add a hash value to the stack
+        def visit_object_value(*)
+          stack << {}
+        end
+
+        # Add a hash key value pair to a hash on the stack
+        def visit_object_field(node)
+          visit(ofield_value(node))
+          key = node_name(ofield_name(node))
+          stack[-2][key] = stack.pop
+        end
+
+        # At the end of a list, change the stack based on the size of the list
+        def end_visit_list_value(node)
+          stack << size.zero? ? [] : stack.slice!(-list_size(node)..-1)
+        end
+      end
+    end
+  end
+end