rails-graphql 1.0.0.beta → 1.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f87cbf32964de3c167e807e029be76418ab377ac1510027ebcc14e7a7bed8bb
-  data.tar.gz: 56174d0ec5e0b681531b534c2c549bb24c994d8b9ea3c08afffd18c139400dc8
+  metadata.gz: 3c29232c14870c44aeab62fba29beda42f8f99a8047bf83f717149e6fc2e5d7c
+  data.tar.gz: 196468f3151958620774998650fe7a5f70e0b3204fdb5a028b31c634d21a9cb0
 SHA512:
-  metadata.gz: '098a9f12e0a9ced37206a4abe195e6d01d52aa9d7c0a0870f7cfe3b583859cbe7a097fdbc113802691ab3e34179391406aecfce2358c6bd9806b63a24d53e0af'
-  data.tar.gz: 1160b336ff4af0306aebf0779dcee046d5d13772ff41bc56e1ad0a3087eaba4a9988f08144076720f8868f0873e6a6dc0cff80470abd958fb6dfb593a32b252d
+  metadata.gz: a17d0f98a0473afd6d221d98b967068ae9d97da363e44e92817729e23a204510768c72bed50a858816e9d7eeda8b0fcdefe83c56d9782e8abe06d71bea6e0f75
+  data.tar.gz: c4258dfce30c7aedba8a3f2c1a9a6c20b0eca30ae520888efac8dfeb3f5267654d74e2992b9794bdb892a2f84d8f1be68d6d71e637ebaa48ee780d3b019ccf25

data/ext/gql_parser.c

@@ -3,22 +3,7 @@
 
 #include "ruby.h"
 #include "shared.h"
-
-#define GQL_SAFE_PUSH_AND_NEXT(source, scanner, action) ({ \
-  GQL_SAFE_PUSH(source, action);                           \
-  gql_next_lexeme_no_comments(scanner);                    \
-})
-#define GQL_ASSIGN_TOKEN_AND_NEXT(source, scanner) (GQL_ASSIGN_VALUE_AND_NEXT(source, scanner, gql_scanner_to_token(scanner)))
-#define GQL_ASSIGN_VALUE_AND_NEXT(source, scanner, value) ({ \
-  source = value;                                            \
-  gql_next_lexeme_no_comments(scanner);                      \
-})
-#define GQL_BUILD_PARSE_OUTER_TOKEN(type, size, pieces, scanner, mem) ({            \
-  gql_token_start_from_mem(GQL_BUILD_PARSE_TOKEN(type, size, pieces, scanner), mem); \
-})
-#define GQL_BUILD_PARSE_TOKEN(type, size, pieces, scanner) ({                    \
-  gql_set_token_type(gql_as_token(rb_ary_new4(size, pieces), scanner, 0), type); \
-})
+#include "gql_parser.h"
 
 // EXECUTION DOCUMENT [OPERATION*, FRAGMENT*]
 VALUE gql_parse_execution(VALUE self, VALUE document);

data/ext/gql_parser.h

@@ -0,0 +1,21 @@
+#include "ruby.h"
+
+#define GQL_SAFE_PUSH_AND_NEXT(source, scanner, action) ({ \
+  GQL_SAFE_PUSH(source, action);                           \
+  gql_next_lexeme_no_comments(scanner);                    \
+})
+#define GQL_ASSIGN_TOKEN_AND_NEXT(source, scanner) (GQL_ASSIGN_VALUE_AND_NEXT(source, scanner, gql_scanner_to_token(scanner)))
+#define GQL_ASSIGN_VALUE_AND_NEXT(source, scanner, value) ({ \
+  source = value;                                            \
+  gql_next_lexeme_no_comments(scanner);                      \
+})
+#define GQL_BUILD_PARSE_OUTER_TOKEN(type, size, pieces, scanner, mem) ({            \
+  gql_token_start_from_mem(GQL_BUILD_PARSE_TOKEN(type, size, pieces, scanner), mem); \
+})
+#define GQL_BUILD_PARSE_TOKEN(type, size, pieces, scanner) ({                    \
+  gql_set_token_type(gql_as_token(rb_ary_new4(size, pieces), scanner, 0), type); \
+})
+
+VALUE GQLParser;
+VALUE QLGParserToken;
+VALUE gql_eParserError;

data/ext/shared.c

@@ -1,11 +1,6 @@
 #include "ruby.h"
-
 #include "shared.h"
 
-VALUE GQLParser = Qnil;
-VALUE QLGParserToken = Qnil;
-VALUE gql_eParserError = Qnil;
-
 const char *GQL_VALUE_KEYWORDS[] = {
   "true",
   "false",

data/ext/shared.h

@@ -141,13 +141,13 @@ struct gql_scanner
   enum gql_lexeme lexeme;
 };
 
-VALUE GQLParser;
-VALUE QLGParserToken;
-VALUE gql_eParserError;
+extern VALUE GQLParser;
+extern VALUE QLGParserToken;
+extern VALUE gql_eParserError;
 
-const char *GQL_VALUE_KEYWORDS[3];
-const char *GQL_EXECUTION_KEYWORDS[5];
-const char *GQL_DEFINITION_KEYWORDS[12];
+extern const char *GQL_VALUE_KEYWORDS[3];
+extern const char *GQL_EXECUTION_KEYWORDS[5];
+extern const char *GQL_DEFINITION_KEYWORDS[12];
 
 void gql_debug_print(const char *message);
 struct gql_scanner gql_new_scanner(VALUE source);

data/lib/generators/graphql/channel_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module GraphQL
+  module Generators
+    class ChannelGenerator < Rails::Generators::Base # :nodoc:
+      include Rails::GraphQL::BaseGenerator
+
+      desc 'Add a new action cable channel that operates with GraphQL'
+
+      argument :name, type: :string, optional: true,
+        default: "GraphQLChannel",
+        desc: 'The name for the channel'
+
+      def create_channel_file
+        template 'channel.erb', "app/channels/#{channel_name.underscore}.rb"
+      end
+
+      private
+
+        def channel_name
+          @channel_name ||= options.fetch(:name, 'GraphQLChannel').classify
+        end
+    end
+  end
+end

data/lib/generators/graphql/controller_generator.rb

@@ -8,15 +8,20 @@ module GraphQL
       include Rails::GraphQL::BaseGenerator
 
       desc 'Add a new controller that operates with GraphQL'
-      argument :name, type: :string, optional: true
+
+      argument :name, type: :string, optional: true,
+        default: "GraphQLController",
+        desc: 'The name for the controller'
 
       def create_controller_file
         template 'controller.erb', "app/controllers/#{controller_name.underscore}.rb"
       end
 
-      def controller_name
-        @controller_name ||= (options[:name].presence&.classify || 'GraphQL') + 'Controller'
-      end
+      private
+
+        def controller_name
+          @controller_name ||= options.fetch(:name, 'GraphQLController').classify
+        end
     end
   end
 end

data/lib/generators/graphql/install_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+module GraphQL
+  module Generators
+    class InstallGenerator < Rails::Generators::Base # :nodoc:
+      include Rails::GraphQL::BaseGenerator
+
+      desc 'Add an initial setup to your application'
+
+      argument :schema, type: :string, optional: true,
+        default: "#{APP_MODULE_NAME}Schema",
+        desc: 'A name for the schema'
+
+      class_option :skip_routes, type: :boolean,
+        default: false,
+        desc: 'Add some initial routes'
+
+      class_option :skip_keeps, type: :boolean,
+        default: false,
+        desc: 'Skip .keep files'
+
+      def create_config_file
+        template 'config.rb', 'config/initializers/graphql.rb'
+      end
+
+      def create_schema
+        invoke 'graphql:schema'
+      end
+
+      def create_keep_files
+        return if options[:skip_keeps]
+
+        %w[
+          directives fields sources enums inputs interfaces object
+          scalars unions queries mutations subscriptions
+        ].each { |folder| create_file("#{options[:directory]}/#{folder}/.keep") }
+      end
+
+      def add_routes
+        return if options[:skip_routes]
+        route('get  "/graphql/describe", to: "graphql/base#describe"')
+        route('get  "/graphiql",         to: "graphql/base#graphiql"')
+        route('post "/graphql",          to: "graphql/base#execute"')
+      end
+    end
+  end
+end

data/lib/generators/graphql/schema_generator.rb

@@ -8,15 +8,20 @@ module GraphQL
       include Rails::GraphQL::BaseGenerator
 
       desc 'Add a new GraphQL schema'
-      argument :name, type: :string, optional: true
+
+      argument :schema, type: :string, optional: true,
+        default: "#{APP_MODULE_NAME}Schema",
+        desc: 'A name for the schema'
 
       def create_schema_file
         template 'schema.erb', "#{options[:directory]}/#{schema_name.underscore}.rb"
       end
 
-      def schema_name
-        @schema_name ||= options[:name].presence || "#{app_module_name}Schema"
-      end
+      private
+
+        def schema_name
+          @schema_name ||= options.fetch(:schema, "#{APP_MODULE_NAME}Schema")
+        end
     end
   end
 end

data/lib/generators/graphql/templates/channel.erb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= channel_name %> < ApplicationCable::Channel
+  include GraphQL::Channel
+end
+<% end -%>

data/lib/generators/graphql/templates/config.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+Rails::GraphQL.configure do |config|
+  # This helps to keep track of when things were cached and registered. Cached
+  # objects with mismatching versions need to be upgraded or simply reloaded.
+  # An excellent way to use this is to set it to the commit hash. TypePap will
+  # always use only the first 8 characters for simplicity.
+  # config.version = nil
+
+  # The instance responsible for caching all the information generated by
+  # requests and all the other components. Manually setting this property
+  # means that the object in it complies with `ActiveSupport::Cache::Store`.
+  # This will map automatically to `Rails.cache` if kept as `nil`. This can
+  # also be set per Schema.
+  # config.cache = nil
+
+  # This is the prefix key of all the cache entries for the GraphQL cached
+  # things.
+  # config.cache_prefix = 'graphql/'
+
+  # This is very similar to `ActiveRecord` verbose logs, which simply show the
+  # path of the file that started a GraphQL request.
+  # config.verbose_logs = true
+
+  # The list of parameters to omit from the logger when running a GraphQL
+  # request. Those values are displayed better in the internal runtime logger
+  # controller.
+  # config.omit_parameters = %w[query operationName operation_name variables graphql]
+
+  # Identical to the one available on a Rails application, but exclusive for
+  # GraphQL operations. The list of parameters to display as filtered in the
+  # logs. When it is nil, it will use the same as the Rails application.
+  # config.filter_parameters = nil
+
+  # The suffix that is added automatically to all the Input type objects. This
+  # prevents situations like `PointInputInput`. If your inputs have a
+  # different suffix, change this value to it.
+  # config.auto_suffix_input_objects = 'Input'
+
+  # Introspection is enabled by default. It is recommended to only use
+  # introspection during development and tests, never in production.
+  # This can also be set per schema level.
+  config.enable_introspection = !Rails.env.production?
+
+  # Define the names of the schema/operations types. The single "_" is a
+  # suggestion. In an application that has a Subscription object, it will
+  # prevent the conflict. Plus, it is easy to spot that it is something
+  # internal. This can also be set per Schema.
+  # config.schema_type_names = {
+  #   query: '_Query',
+  #   mutation: '_Mutation',
+  #   subscription: '_Subscription',
+  # }
+
+  # For performance purposes, this gem implements a
+  # {JsonCollector}[rdoc-ref:Rails::GraphQL::Collectors::JsonCollector].
+  # You can disable this option if you prefer to use the standard
+  # hash-to-string serialization provided by `ActiveSupport`.
+  # This can also be set per Schema.
+  # config.enable_string_collector = true
+
+  # Set what is de default expected output type of GraphQL requests. String
+  # combined with the previous setting has the best performance. On the
+  # console, it will automatically shift to Hash. This can also be set per
+  # Schema.
+  # config.default_response_format = :string
+
+  # Specifies if the results of operations should be encoded with
+  # +ActiveSupport::JSON#encode+ instead of the default +JSON#generate+.
+  # See also https://github.com/rails/rails/blob/master/activesupport/lib/active_support/json/encoding.rb
+  # config.encode_with_active_support = false
+
+  # Enable the ability of a callback to inject arguments dynamically into the
+  # calling method.
+  # config.callback_inject_arguments = true
+
+  # Enable the ability of a callback to inject named arguments dynamically
+  # into the calling method.
+  # config.callback_inject_named_arguments = true
+
+  # When importing fields from modules or other objects, a warning is
+  # displayed for any given element that was not able to be correctly
+  # imported. You can silence such warnings by changing this option.
+  # config.silence_import_warnings = false
+
+  # Enable the ability to define the description of any object, field, or
+  # argument using I18n. It is recommended for multi-language documentation.
+  config.enable_i18n_descriptions = true
+
+  # The method that should be used to parse literal input values when they are
+  # provided as Hash. `JSON.parse` only supports keys wrapped in quotes. You
+  # can use `Psych.method(:safe_load)` to support keys without quotes, which
+  # behaves closer to YAML. The received value is ensured to be wrapped in
+  # "{}". If that produces unexpected results, you can assign a proc and then
+  # parse the value in any other way.
+  # config.literal_input_parser = Psych.method(:safe_load)
+end

data/lib/generators/graphql/templates/controller.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing do -%>
 class <%= controller_name %> < ApplicationController
   include GraphQL::Controller

data/lib/generators/graphql/templates/schema.erb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module GraphQL
-  <% module_namespacing do -%>
-  class <%= schema_name %> < Schema
+  <%- module_namespacing do -%>
+  class <%= schema_name %> < GraphQL::Schema
   end
-  <% end -%>
+  <%- end -%>
 end

data/lib/rails/graphql/alternative/field_set.rb

@@ -15,22 +15,34 @@ module Rails
         self.field_type = Field::OutputField
         self.valid_field_types = Type::Object.valid_field_types
 
+        def self.i18n_scope
+          :query
+        end
+
         def self.inspect
           +"#<#{self.class.name} @fields=#{fields.inspect}>"
         end
       end
 
+      # = GraphQL Alternative Query Set
+      #
+      # Exact the same as a +FieldSet+
+      QuerySet = FieldSet
+
       # = GraphQL Alternative Mutation Set
       #
       # Same as a +FieldSet+ but for mutation fields
       MutationSet = Class.new(FieldSet)
       MutationSet.field_type = Field::MutationField
+      MutationSet.redefine_singleton_method(:i18n_scope) { :mutation }
+
 
       # = GraphQL Alternative Subscription Set
       #
       # Same as a +FieldSet+ but for subscription fields
       SubscriptionSet = Class.new(FieldSet)
       SubscriptionSet.field_type = Field::SubscriptionField
+      SubscriptionSet.redefine_singleton_method(:i18n_scope) { :subscription }
     end
   end
 end

data/lib/rails/graphql/alternative/query.rb

@@ -15,9 +15,9 @@ module Rails
       self.abstract = true
 
       class << self
-        delegate :gql_name, :to_sym, :desc, :argument, :ref_argument, :id_argument,
-          :use, :internal?, :disabled?, :enabled?, :disable!, :enable!, :rename!,
-          :authorize, :on, :description=, :description, to: :field
+        delegate :gql_name, :to_sym, :desc, :arguments, :argument, :ref_argument, :id_argument,
+          :use, :internal?, :disabled?, :enabled?, :disable!, :enable!, :rename!, :authorize,
+          :on, :description=, :description, to: :field
 
         # Returns the type of the field class
         def type_field_class
@@ -49,7 +49,7 @@ module Rails
           end
 
           # Create a new field for the class
-          def define_field(field_name = nil, type = :any, **xargs, &blcok)
+          def define_field(field_name = nil, type = :any, **xargs, &block)
             field_name ||= anonymous? ? '_anonymous' : begin
               type_module = type_field_class.to_s.classify.pluralize
               user_name = name.split(+"#{type_module}::")[1]
@@ -58,12 +58,12 @@ module Rails
             end
 
             # Save the generated field ensuring the owner
-            @field = field_class.new(field_name, type, **xargs, owner: self, &blcok)
+            @field = field_class.new(field_name, type, **xargs, owner: self, &block)
           end
 
           # Import the field from a given source
-          def import_field(other_field, **xargs, &blcok)
-            @field = other_field.to_proxy(**xargs, owner: self, &blcok)
+          def import_field(other_field, **xargs, &block)
+            @field = other_field.to_proxy(**xargs, owner: self, &block)
           end
 
           # Change the return type of the field
@@ -85,9 +85,14 @@ module Rails
           def field_class
             return @field.class if defined?(@field)
             list = Helpers::WithSchemaFields::TYPE_FIELD_CLASS
-            GraphQL::Field.const_get(list[type_field_class])
+            GraphQL::Field.const_get(list[type_field_class], false)
           end
       end
     end
+
+    # = GraphQL Alternative Field
+    #
+    # Just an alias, since query fields are the same as output fields
+    Alternative.const_set(:Field, Alternative::Query)
   end
 end

data/lib/rails/graphql/alternative/subscription.rb

@@ -10,7 +10,8 @@ module Rails
       self.abstract = true
 
       class << self
-        delegate :scope, :trigger, to: :@field, allow_nil: true
+        delegate :scope, :trigger_for, :trigger, :unsubscribe_from, :unsubscribe,
+          to: :@field, allow_nil: true
       end
     end
   end

data/lib/rails/graphql/alternative.rb

@@ -10,6 +10,10 @@ module Rails
       autoload :Mutation
       autoload :Subscription
 
+      autoload_at "#{__dir__}/alternative/query" do
+        autoload :Field
+      end
+
       autoload_at "#{__dir__}/alternative/field_set" do
         autoload :FieldSet
         autoload :MutationSet

data/lib/rails/graphql/argument.rb

@@ -43,19 +43,21 @@ module Rails
 
       def initialize(
         name,
-        type,
+        type = nil,
         owner:,
         null: true,
         full: false,
         array: false,
         nullable: true,
         default: nil,
-        desc: nil
+        desc: nil,
+        description: nil
       )
         @owner = owner
         @name = name.to_s.underscore.to_sym
         @gql_name = @name.to_s.camelize(:lower)
 
+        type = (name == :id ? :id : :string) if type.nil?
         if type.is_a?(Module) && type < GraphQL::Type
           @type_klass = type
           @type = type.name
@@ -69,7 +71,7 @@ module Rails
 
         @default = default
         @default = deserialize(@default) if @default.is_a?(::GQLParser::Token)
-        self.description = desc
+        self.description = desc || description
       end
 
       def initialize_copy(*)

data/lib/rails/graphql/callback.rb

@@ -4,7 +4,7 @@ module Rails
   module GraphQL
     # = Rails GraphQL Callback
     #
-    # An extra powerfull proc that can handle way more situations than the
+    # An extra powerful proc that can handle way more situations than the
     # original block caller
     class Callback
       EXCLUSIVE_ARGUMENT = :exclusive_callback
@@ -51,7 +51,7 @@ module Rails
       # This does the whole checking and preparation in order to really execute
       # the callback method
       def call(event, *args, _callback_context: nil, **xargs)
-        return unless event.name === event_name && can_run?(event)
+        return unless event.event_name === event_name && can_run?(event)
 
         block.is_a?(Symbol) \
           ? call_symbol(event, *args, **xargs) \
@@ -66,10 +66,9 @@ module Rails
 
       # Get a described source location for the callback
       def source_location
-        block.is_a?(Proc) ? block.source_location : [
-          +"(symbolized-callback/#{target.inspect})",
-          block,
-        ]
+        block.is_a?(Proc) ? block.source_location : begin
+          [+"(symbolized-callback/#{target.inspect})", block]
+        end
       end
 
       # This basically allows the class to be passed as +&block+
@@ -84,7 +83,8 @@ module Rails
         # Find the proper owner of the symbol based callback
         def owner
           @owner ||= target.all_owners.find do |item|
-            item.is_a?(Class) ? item.method_defined?(block) : item.respond_to?(block)
+            item.is_a?(Class) && item.included_modules.include?(Helpers::Instantiable) &&
+              item.method_defined?(block)
           end || target
         end
 
@@ -98,7 +98,8 @@ module Rails
         end
 
         # Call the callback block as a symbol
-        # TODO: Maybe black calling non-public events
+        # TODO: Maybe block calling non-public events
+        # TODO: This is the only reason why directives needs an owner
         def call_symbol(event, *args, **xargs)
           event.on_instance(owner) do |instance|
             block = instance.method(@block)
@@ -110,6 +111,7 @@ module Rails
         # Call the callback block as a proc
         def call_proc(event, context = nil, *args, **xargs)
           args, xargs = collect_parameters(event, [args, xargs])
+          args << event unless inject_arguments? || (block.arity - 1) == args.size
           (context || event).instance_exec(*args, **xargs, &block)
         end
 

data/lib/rails/graphql/collectors/hash_collector.rb

@@ -31,6 +31,11 @@ module Rails
           @data.is_a?(::Array) ? @data << value : @data[key.to_s] = value
         end
 
+        # Check if a given +key+ has already been added to the current data
+        def key?(key)
+          !@data.is_a?(::Array) && @data.key?(key)
+        end
+
         alias safe_add add
 
         # Serialize is a helper to call the correct method on types before add
@@ -45,13 +50,19 @@ module Rails
           @data = {}
         end
 
-        # Append to the responsa data all the errors that happened during the
+        # Append to the response all the errors that happened during the
         # request process
         def append_errors(errors)
           return if errors.empty?
           @data['errors'] = errors.as_json
         end
 
+        # Append to the response anything added to the extensions
+        def append_extensions(extensions)
+          return if extensions.empty?
+          @data['extensions'] = extensions.as_json
+        end
+
         # Return the generated object
         def to_h
           @data

data/lib/rails/graphql/collectors/json_collector.rb

@@ -12,6 +12,9 @@ module Rails
         def initialize(request)
           @request = request
 
+          @current_keys = Set.new
+          @stack_keys = []
+
           @current_value = StringIO.new
           @stack_value = []
 
@@ -32,6 +35,7 @@ module Rails
           pop_size = array && !plain ? 2 : 1
           @current_value = @stack_value.pop(pop_size).first
           @current_array = @stack_array.pop(pop_size).first
+          @current_keys = @stack_keys.pop
           raise
         end
 
@@ -42,10 +46,17 @@ module Rails
           add('errors', errors.to_json)
         end
 
+        # Append to the response anything added to the extensions
+        def append_extensions(extensions)
+          return if extensions.empty?
+          add('extensions', extensions.to_json)
+        end
+
         # Add the given +value+ to the given +key+. Ensure to encode the value
         # before calling this function.
         def add(key, value)
           (@current_value << ',') if @current_value.pos > 0
+          @current_keys << key
 
           if @current_array
             @current_value << value
@@ -54,6 +65,11 @@ module Rails
           end
         end
 
+        # Check if the given +key+ has been added already
+        def key?(key)
+          @current_keys.include?(key)
+        end
+
         # Same as +add+ but this always encode the +value+ beforehand.
         def safe_add(key, value)
           add(key, value.nil? ? 'null' : value.to_json)
@@ -69,7 +85,9 @@ module Rails
           return unless @stack_array.last === :complex
           (@stack_value.last << ',') if @stack_value.last.pos > 0
           @stack_value.last << to_s
+
           @current_value = StringIO.new
+          @current_keys = Set.new
         end
 
         # Get the current result
@@ -90,6 +108,7 @@ module Rails
           def start_stack(as_array = false, plain_array = false)
             @stack_value << @current_value
             @stack_array << @current_array
+            @stack_keys << @current_keys
 
             if as_array && !plain_array
               @stack_value << StringIO.new
@@ -99,6 +118,7 @@ module Rails
 
             @current_value = StringIO.new
             @current_array = as_array
+            @current_keys = Set.new
           end
 
           # Finalize a stack and set the result on the given +key+.
@@ -111,6 +131,7 @@ module Rails
             result = to_s
             @current_value = @stack_value.pop
             @current_array = @stack_array.pop
+            @current_keys = @stack_keys.pop
             add(key, result)
           end
       end