graphql 1.9.0 → 2.1.1

data/lib/generators/graphql/relay.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module Graphql
+  module Generators
+    module Relay
+      def install_relay
+        # Add Node, `node(id:)`, and `nodes(ids:)`
+        template("node_type.erb", "#{options[:directory]}/types/node_type.rb")
+        in_root do
+          fields = <<-RUBY
+    field :node, Types::NodeType, null: true, description: "Fetches an object given its ID." do
+      argument :id, ID, required: true, description: "ID of the object."
+    end
+
+    def node(id:)
+      context.schema.object_from_id(id, context)
+    end
+
+    field :nodes, [Types::NodeType, null: true], null: true, description: "Fetches a list of objects given a list of IDs." do
+      argument :ids, [ID], required: true, description: "IDs of the objects."
+    end
+
+    def nodes(ids:)
+      ids.map { |id| context.schema.object_from_id(id, context) }
+    end
+
+    RUBY
+          inject_into_file "#{options[:directory]}/types/query_type.rb", fields, after: /class .*QueryType\s*<\s*[^\s]+?\n/m, force: false
+        end
+
+        # Add connections and edges
+        template("base_connection.erb", "#{options[:directory]}/types/base_connection.rb")
+        template("base_edge.erb", "#{options[:directory]}/types/base_edge.rb")
+        connectionable_type_files = {
+          "#{options[:directory]}/types/base_object.rb" => /class .*BaseObject\s*<\s*[^\s]+?\n/m,
+          "#{options[:directory]}/types/base_union.rb" =>  /class .*BaseUnion\s*<\s*[^\s]+?\n/m,
+          "#{options[:directory]}/types/base_interface.rb" => /include GraphQL::Schema::Interface\n/m,
+        }
+        in_root do
+          connectionable_type_files.each do |type_class_file, sentinel|
+            inject_into_file type_class_file, "    connection_type_class(Types::BaseConnection)\n", after: sentinel, force: false
+            inject_into_file type_class_file, "    edge_type_class(Types::BaseEdge)\n", after: sentinel, force: false
+          end
+        end
+
+        # Add object ID hooks & connection plugin
+        schema_code = <<-RUBY
+
+  # Relay-style Object Identification:
+
+  # Return a string UUID for `object`
+  def self.id_from_object(object, type_definition, query_ctx)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    object.to_gid_param
+  end
+
+  # Given a string UUID, find the object
+  def self.object_from_id(global_id, query_ctx)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    GlobalID.find(global_id)
+  end
+RUBY
+        inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false
+      end
+    end
+  end
+end

data/lib/generators/graphql/relay_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/base'
+require_relative 'core'
+require_relative 'relay'
+
+module Graphql
+  module Generators
+    class RelayGenerator < Rails::Generators::Base
+      include Core
+      include Relay
+
+      desc "Add base types and fields for Relay-style nodes and connections"
+      source_root File.expand_path('../templates', __FILE__)
+
+      def install_relay
+        super
+      end
+    end
+  end
+end

data/lib/generators/graphql/scalar_generator.rb

@@ -12,8 +12,10 @@ module Graphql
       desc "Create a GraphQL::ScalarType with the given name"
       source_root File.expand_path('../templates', __FILE__)
 
-      def create_type_file
-        template "scalar.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
+      private
+
+      def graphql_type
+        "scalar"
       end
     end
   end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseArgument < GraphQL::Schema::Argument
+  end
+end
+<% end -%>

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseConnection < Types::BaseObject
+    # add `nodes` and `pageInfo` fields, as well as `edge_type(...)` and `node_nullable(...)` overrides
+    include GraphQL::Types::Relay::ConnectionBehaviors
+  end
+end
+<% end -%>

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseEdge < Types::BaseObject
+    # add `node` and `cursor` fields, as well as `node_type(...)` override
+    include GraphQL::Types::Relay::EdgeBehaviors
+  end
+end
+<% end -%>

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

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseEnum < GraphQL::Schema::Enum
   end
 end
+<% end -%>

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseField < GraphQL::Schema::Field
+    argument_class Types::BaseArgument
+  end
+end
+<% end -%>

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

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseInputObject < GraphQL::Schema::InputObject
+    argument_class Types::BaseArgument
   end
 end
+<% end -%>

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

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   module BaseInterface
     include GraphQL::Schema::Interface
+
+    field_class Types::BaseField
   end
 end
+<% end -%>

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

@@ -1,4 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseObject < GraphQL::Schema::Object
+    field_class Types::BaseField
   end
 end
+<% end -%>

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

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseScalar < GraphQL::Schema::Scalar
   end
 end
+<% end -%>

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

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   class BaseUnion < GraphQL::Schema::Union
   end
 end
+<% end -%>

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

@@ -1,5 +1,11 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseEnum
+  class <%= ruby_class_name %> < Types::BaseEnum
+    description "<%= human_name %> enum"
+
 <% prepared_values.each do |v| %>    value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
 <% end %>  end
 end
+<% end -%>

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

@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
+  # If accessing from outside this domain, nullify the session
+  # This allows for outside API access while preventing CSRF attacks,
+  # but you'll have to authenticate your user separately
+  # protect_from_forgery with: :null_session
+
   def execute
-    variables = ensure_hash(params[:variables])
+    variables = prepare_variables(params[:variables])
     query = params[:query]
     operation_name = params[:operationName]
     context = {
@@ -9,28 +17,30 @@ class GraphqlController < ApplicationController
     }
     result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
     render json: result
-  rescue => e
+  rescue StandardError => e
     raise e unless Rails.env.development?
-    handle_error_in_development e
+    handle_error_in_development(e)
   end
 
   private
 
-  # Handle form data, JSON body, or a blank value
-  def ensure_hash(ambiguous_param)
-    case ambiguous_param
+  # Handle variables in form data, JSON body, or a blank value
+  def prepare_variables(variables_param)
+    case variables_param
     when String
-      if ambiguous_param.present?
-        ensure_hash(JSON.parse(ambiguous_param))
+      if variables_param.present?
+        JSON.parse(variables_param) || {}
       else
         {}
       end
-    when Hash, ActionController::Parameters
-      ambiguous_param
+    when Hash
+      variables_param
+    when ActionController::Parameters
+      variables_param.to_unsafe_hash # GraphQL-Ruby will validate name and type of incoming variables.
     when nil
       {}
     else
-      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+      raise ArgumentError, "Unexpected parameter: #{variables_param}"
     end
   end
 
@@ -38,6 +48,7 @@ class GraphqlController < ApplicationController
     logger.error e.message
     logger.error e.backtrace.join("\n")
 
-    render json: { error: { message: e.message, backtrace: e.backtrace }, data: {} }, status: 500
+    render json: { errors: [{ message: e.message, backtrace: e.backtrace }], data: {} }, status: 500
   end
 end
+<% end -%>

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= ruby_class_name %> < Types::BaseInputObject
+<% normalized_fields.each do |f| %>    <%= f.to_input_argument %>
+<% end %>  end
+end
+<% end -%>

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

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
-  module <%= type_ruby_name.split('::')[-1] %>
+  module <%= ruby_class_name %>
     include Types::BaseInterface
-<% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+<% normalized_fields.each do |f| %>    <%= f.to_object_field %>
 <% end %>  end
 end
+<% end -%>

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader
     # Define `initialize` to store grouping arguments, eg
@@ -15,3 +18,4 @@ module Loaders
     end
   end
 end
+<% end -%>

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

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Mutations
-  class <%= mutation_name %> < GraphQL::Schema::RelayClassicMutation
+  class <%= class_name %> < BaseMutation
     # TODO: define return fields
     # field :post, Types::PostType, null: false
 
@@ -12,3 +15,4 @@ module Mutations
     # end
   end
 end
+<% end -%>

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %>Create < BaseMutation
+    description "Creates a new <%= file_name %>"
+
+    field :<%= file_name %>, Types::<%= options[:namespaced_types] ? 'Objects::' : '' %><%= class_name %>Type, null: false
+
+    argument :<%= file_name %>_input, Types::<%= options[:namespaced_types] ? 'Inputs::' : '' %><%= class_name %>InputType, required: true
+
+    def resolve(<%= file_name %>_input:)
+      <%= singular_table_name %> = ::<%= orm_class.build(class_name, "**#{file_name}_input") %>
+      raise GraphQL::ExecutionError.new "Error creating <%= file_name %>", extensions: <%= singular_table_name %>.errors.to_hash unless <%= orm_instance.save %>
+
+      { <%= file_name %>: <%= singular_table_name %> }
+    end
+  end
+end
+<% end -%>

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %>Delete < BaseMutation
+    description "Deletes a <%= file_name %> by ID"
+
+    field :<%= file_name %>, Types::<%= options[:namespaced_types] ? 'Objects::' : '' %><%= class_name %>Type, null: false
+
+    argument :id, ID, required: true
+
+    def resolve(id:)
+      <%= singular_table_name %> = ::<%= orm_class.find(class_name, "id") %>
+      raise GraphQL::ExecutionError.new "Error deleting <%= file_name %>", extensions: <%= singular_table_name %>.errors.to_hash unless <%= orm_instance.destroy %>
+
+      { <%= file_name %>: <%= singular_table_name %> }
+    end
+  end
+end
+<% end -%>

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %>Update < BaseMutation
+    description "Updates a <%= file_name %> by id"
+
+    field :<%= file_name %>, Types::<%= options[:namespaced_types] ? 'Objects::' : '' %><%= class_name %>Type, null: false
+
+    argument :id, ID, required: true
+    argument :<%= file_name %>_input, Types::<%= options[:namespaced_types] ? 'Inputs::' : '' %><%= class_name %>InputType, required: true
+
+    def resolve(id:, <%= file_name %>_input:)
+      <%= singular_table_name %> = ::<%= orm_class.find(class_name, "id") %>
+      raise GraphQL::ExecutionError.new "Error updating <%= file_name %>", extensions: <%= singular_table_name %>.errors.to_hash unless <%= orm_instance.update("**#{file_name}_input") %>
+
+      { <%= file_name %>: <%= singular_table_name %> }
+    end
+  end
+end
+<% end -%>

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  module NodeType
+    include Types::BaseInterface
+    # Add the `id` field
+    include GraphQL::Types::Relay::NodeBehaviors
+  end
+end
+<% end -%>

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

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
-<% if options.node %>    implements GraphQL::Relay::Node.interface
-<% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+  class <%= ruby_class_name %> < Types::BaseObject
+<% if options.node %>    implements GraphQL::Types::Relay::Node
+<% end %><% normalized_fields.each do |f| %>    <%= f.to_object_field %>
 <% end %>  end
 end
+<% end -%>

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

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject
     # Add root-level fields here.
@@ -9,7 +12,6 @@ module Types
     def test_field
       "Hello World!"
     end
-<% if options[:relay] %>
-    field :node, field: GraphQL::Relay::Node.field
-<% end %>  end
+  end
 end
+<% end -%>

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

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
+  class <%= ruby_class_name %> < Types::BaseScalar
     def self.coerce_input(input_value, context)
       # Override this to prepare a client-provided GraphQL value for your Ruby code
       input_value
@@ -11,3 +14,4 @@ module Types
     end
   end
 end
+<% end -%>

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

@@ -1,32 +1,32 @@
-class <%= schema_name %> < GraphQL::Schema
-<% if options[:relay] %>
-  # Relay Object Identification:
+# frozen_string_literal: true
 
-  # Return a string UUID for `object`
-  def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+<% module_namespacing_when_supported do -%>
+class <%= schema_name %> < GraphQL::Schema
+  query(Types::QueryType)
+<% if options[:batch] %>
+  # GraphQL::Batch setup:
+  use GraphQL::Batch
+<% else %>
+  # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
+  use GraphQL::Dataloader
+<% end %>
+  # GraphQL-Ruby calls this when something goes wrong while running a query:
+  def self.type_error(err, context)
+    # if err.is_a?(GraphQL::InvalidNullError)
+    #   # report to your bug tracker here
+    #   return nil
+    # end
+    super
   end
 
-  # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
+  # Union and Interface Resolution
+  def self.resolve_type(abstract_type, obj, ctx)
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
+    raise(GraphQL::RequiredImplementationMissingError)
   end
 
-  # Object Resolution
-  def self.resolve_type(type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct type for `obj`
-    raise(NotImplementedError)
-  end
-<% end %><% if options[:batch] %>
-  # GraphQL::Batch setup:
-  use GraphQL::Batch
-<% end %>end
+  # Stop validating when it encounters this many errors:
+  validate_max_errors(100)
+end
+<% end -%>

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

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
-<% if possible_types.any? %>    possible_types [<%= normalized_possible_types.join(", ") %>]
+  class <%= ruby_class_name %> < Types::BaseUnion
+<% if custom_fields.any? %>    possible_types <%= normalized_possible_types.join(", ") %>
 <% end %>  end
 end
+<% end -%>

data/lib/generators/graphql/type_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/base'
 require 'graphql'
 require 'active_support'
@@ -7,14 +8,28 @@ require_relative 'core'
 
 module Graphql
   module Generators
-    class TypeGeneratorBase < Rails::Generators::Base
+    class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      argument :type_name,
-        type: :string,
-        required: true,
-        banner: "TypeName",
-        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      argument :custom_fields,
+                type: :array,
+                default: [],
+                banner: "name:type name:type ...",
+                desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      
+      attr_accessor :graphql_type
+
+      def create_type_file
+        template "#{graphql_type}.erb", "#{options[:directory]}/types#{subdirectory}/#{type_file_name}.rb"
+      end
 
       # Take a type expression in any combination of GraphQL or Ruby styles
       # and return it in a specified output style
@@ -60,12 +75,12 @@ module Graphql
 
       # @return [String] The user-provided type name, normalized to Ruby code
       def type_ruby_name
-        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+        @type_ruby_name ||= self.class.normalize_type_expression(name, mode: :ruby)[0]
       end
 
       # @return [String] The user-provided type name, as a GraphQL name
       def type_graphql_name
-        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+        @type_graphql_name ||= self.class.normalize_type_expression(name, mode: :graphql)[0]
       end
 
       # @return [String] The user-provided type name, as a file name (without extension)
@@ -82,6 +97,24 @@ module Graphql
         }
       end
 
+      def ruby_class_name
+        class_prefix = 
+          if options[:namespaced_types]
+            "#{graphql_type.pluralize.camelize}::"
+          else
+            ""
+          end
+        @ruby_class_name || class_prefix + type_ruby_name.sub(/^Types::/, "")
+      end
+
+      def subdirectory
+        if options[:namespaced_types]
+          "/#{graphql_type.pluralize}"
+        else
+          ""
+        end
+      end
+
       class NormalizedField
         def initialize(name, type_expr, null)
           @name = name
@@ -89,8 +122,12 @@ module Graphql
           @null = null
         end
 
-        def to_ruby
-          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        def to_object_field
+          "field :#{@name}, #{@type_expr}#{@null ? '' : ', null: false'}"
+        end
+
+        def to_input_argument
+          "argument :#{@name}, #{@type_expr}, required: false"
         end
       end
     end

data/lib/generators/graphql/union_generator.rb

@@ -19,14 +19,14 @@ module Graphql
         banner: "type type ...",
         desc: "Possible types for this union (expressed as Ruby or GraphQL)"
 
-      def create_type_file
-        template "union.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
-      end
-
       private
 
+      def graphql_type
+        "union"
+      end
+
       def normalized_possible_types
-        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
+        custom_fields.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
       end
     end
   end