graphql 0.16.0 → 2.0.15

data/lib/generators/graphql/orm_mutations_base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/named_base'
+require_relative 'core'
+
+module Graphql
+  module Generators
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class OrmMutationsBase < Rails::Generators::NamedBase
+      include Core
+      include Rails::Generators::ResourceHelpers
+
+      desc "Create a Relay Classic mutation by name"
+
+      class_option :orm, banner: "NAME", type: :string, required: true,
+                         desc: "ORM to generate the controller for"
+
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      def create_mutation_file
+        template "mutation_#{operation_type}.erb", File.join(options[:directory], "/mutations/", class_path, "#{file_name}_#{operation_type}.rb")
+
+        sentinel = /class .*MutationType\s*<\s*[^\s]+?\n/m
+        in_root do
+          path = "#{options[:directory]}/types/mutation_type.rb"
+          invoke "graphql:install:mutation_root" unless File.exist?(path)
+          inject_into_file "#{options[:directory]}/types/mutation_type.rb", "    field :#{file_name}_#{operation_type}, mutation: Mutations::#{class_name}#{operation_type.classify}\n", after: sentinel, verbose: false, force: false
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/relay.rb

@@ -0,0 +1,49 @@
+# 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 = "    # Add `node(id: ID!) and `nodes(ids: [ID!]!)`\n    include GraphQL::Types::Relay::HasNodeField\n    include GraphQL::Types::Relay::HasNodesField\n\n"
+          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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+
+module Graphql
+  module Generators
+    # Generate a scalar type by given name.
+    #
+    # ```
+    # rails g graphql:scalar Date
+    # ```
+    class ScalarGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::ScalarType with the given name"
+      source_root File.expand_path('../templates', __FILE__)
+
+      private
+
+      def graphql_type
+        "scalar"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+<% 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,8 @@
+<% 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,8 @@
+<% 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

@@ -0,0 +1,6 @@
+<% 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,7 @@
+<% 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

@@ -0,0 +1,7 @@
+<% 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

@@ -0,0 +1,9 @@
+<% 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

@@ -0,0 +1,7 @@
+<% 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

@@ -0,0 +1,6 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseScalar < GraphQL::Schema::Scalar
+  end
+end
+<% end -%>

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

@@ -0,0 +1,6 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseUnion < GraphQL::Schema::Union
+  end
+end
+<% end -%>

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  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

@@ -0,0 +1,52 @@
+<% 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 = prepare_variables(params[:variables])
+    query = params[:query]
+    operation_name = params[:operationName]
+    context = {
+      # Query context goes here, for example:
+      # current_user: current_user,
+    }
+    result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
+    render json: result
+  rescue StandardError => e
+    raise e unless Rails.env.development?
+    handle_error_in_development(e)
+  end
+
+  private
+
+  # Handle variables in form data, JSON body, or a blank value
+  def prepare_variables(variables_param)
+    case variables_param
+    when String
+      if variables_param.present?
+        JSON.parse(variables_param) || {}
+      else
+        {}
+      end
+    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: #{variables_param}"
+    end
+  end
+
+  def handle_error_in_development(e)
+    logger.error e.message
+    logger.error e.backtrace.join("\n")
+
+    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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  module <%= ruby_class_name %>
+    include Types::BaseInterface
+<% normalized_fields.each do |f| %>    <%= f.to_object_field %>
+<% end %>  end
+end
+<% end -%>

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

@@ -0,0 +1,19 @@
+<% module_namespacing_when_supported do -%>
+module Loaders
+  class <%= class_name %> < GraphQL::Batch::Loader
+    # Define `initialize` to store grouping arguments, eg
+    #
+    #     Loaders::<%= class_name %>.for(group).load(value)
+    #
+    # def initialize()
+    # end
+
+    # `keys` contains each key from `.load(key)`.
+    # Find the corresponding values, then
+    # call `fulfill(key, value)` or `fulfill(key, nil)`
+    # for each key.
+    def perform(keys)
+    end
+  end
+end
+<% end -%>

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

@@ -0,0 +1,16 @@
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %> < BaseMutation
+    # TODO: define return fields
+    # field :post, Types::PostType, null: false
+
+    # TODO: define arguments
+    # argument :name, String, required: true
+
+    # TODO: define resolve method
+    # def resolve(name:)
+    #   { post: ... }
+    # 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,9 @@
+<% 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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  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

@@ -0,0 +1,15 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class QueryType < Types::BaseObject
+    # Add root-level fields here.
+    # They will be entry points for queries on your schema.
+
+    # TODO: remove me
+    field :test_field, String, null: false,
+      description: "An example field added by the generator"
+    def test_field
+      "Hello World!"
+    end
+  end
+end
+<% end -%>

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  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
+    end
+
+    def self.coerce_result(ruby_value, context)
+      # Override this to serialize a Ruby value for the GraphQL response
+      ruby_value.to_s
+    end
+  end
+end
+<% end -%>

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

@@ -0,0 +1,30 @@
+<% 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
+
+  # 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
+
+  # Stop validating when it encounters this many errors:
+  validate_max_errors(100)
+end
+<% end -%>

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/base'
+require 'graphql'
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require_relative 'core'
+
+module Graphql
+  module Generators
+    class TypeGeneratorBase < Rails::Generators::NamedBase
+      include Core
+
+      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
+      # TODO: nullability / list with `mode: :graphql` doesn't work
+      # @param type_expresson [String]
+      # @param mode [Symbol]
+      # @param null [Boolean]
+      # @return [(String, Boolean)] The type expression, followed by `null:` value
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        if type_expression.start_with?("!")
+          normalize_type_expression(type_expression[1..-1], mode: mode, null: false)
+        elsif type_expression.end_with?("!")
+          normalize_type_expression(type_expression[0..-2], mode: mode, null: false)
+        elsif type_expression.start_with?("[") && type_expression.end_with?("]")
+          name, is_null = normalize_type_expression(type_expression[1..-2], mode: mode, null: null)
+          ["[#{name}]", is_null]
+        elsif type_expression.end_with?("Type")
+          normalize_type_expression(type_expression[0..-5], mode: mode, null: null)
+        elsif type_expression.start_with?("Types::")
+          normalize_type_expression(type_expression[7..-1], mode: mode, null: null)
+        elsif type_expression.start_with?("types.")
+          normalize_type_expression(type_expression[6..-1], mode: mode, null: null)
+        else
+          case mode
+          when :ruby
+            case type_expression
+            when "Int"
+              ["Integer", null]
+            when "Integer", "Float", "Boolean", "String", "ID"
+              [type_expression, null]
+            else
+              ["Types::#{type_expression.camelize}Type", null]
+            end
+          when :graphql
+            [type_expression.camelize, null]
+          else
+            raise "Unexpected normalize mode: #{mode}"
+          end
+        end
+      end
+
+      private
+
+      # @return [String] The user-provided type name, normalized to Ruby code
+      def type_ruby_name
+        @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(name, mode: :graphql)[0]
+      end
+
+      # @return [String] The user-provided type name, as a file name (without extension)
+      def type_file_name
+        @type_file_name ||= "#{type_graphql_name}Type".underscore
+      end
+
+      # @return [Array<NormalizedField>] User-provided fields, in `(name, Ruby type name)` pairs
+      def normalized_fields
+        @normalized_fields ||= fields.map { |f|
+          name, raw_type = f.split(":", 2)
+          type_expr, null = self.class.normalize_type_expression(raw_type, mode: :ruby)
+          NormalizedField.new(name, type_expr, null)
+        }
+      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
+          @type_expr = type_expr
+          @null = null
+        end
+
+        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
+  end
+end