graphql 1.4.5 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbc1c5f1e53ac27a08d6ffa5956514b54d1fb547
-  data.tar.gz: 4614d534b6cf6b55140909b0b04af5ce9560b3cd
+  metadata.gz: f8a07faba9f807e0d1a1cb2d658dbb03aebd5aff
+  data.tar.gz: 7cc789d4ff25519e433770bab5fbdff0421338c4
 SHA512:
-  metadata.gz: 39b333cf8e34be84ab666461a8609c11468783a906f927998b31f5a1ff96c4ca40f114769871bb421b9d7f51b21fa4c0aa6ab018ef543713da431ff0983fca75
-  data.tar.gz: 2d0a5d0e3aaf5d53735ae687a6486ed3c1387bd325c51eb482cc6bb7dbb275ba880e7d5680229118309b2e2056ad23422473f43a4167ae580947e0120ea89d0d
+  metadata.gz: c4699ee8d911f2a26824b08f938bec2d3b564f28864491d355d242e91dd79b17de8b301d91f8016409cf76da93e811364620bb24637a81a616093df5a16a2035
+  data.tar.gz: f805fd9332370ceb6876dc9e68178a5f1753edb6993e14881eba5b36bb7935502a7419c7a0d03fd0b405533be943f4cc4db50f430b7f61cafd331a3ab97a7858

data/lib/generators/graphql/enum_generator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+
+module Graphql
+  module Generators
+    # Generate an interface type by name,
+    # with the specified fields.
+    #
+    # ```
+    # rails g graphql:interface NamedEntityType name:String!
+    # ```
+    class EnumGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::EnumType with the given name and values"
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :values,
+        type: :array,
+        default: [],
+        banner: "value{:ruby_value} value{:ruby_value} ...",
+        desc: "Values for this enum (if present, ruby_value will be inserted verbatim)"
+
+      def create_type_file
+        template "enum.erb", "app/graphql/types/#{type_file_name}.rb"
+      end
+
+      private
+
+      def prepared_values
+        values.map { |v| v.split(":", 2) }
+      end
+    end
+  end
+end

data/lib/generators/graphql/function_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require "rails/generators/named_base"
+
+module Graphql
+  module Generators
+    class FunctionGenerator < Rails::Generators::NamedBase
+      desc "Create a GraphQL::Function by name"
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_function_file
+        template "function.erb", "app/graphql/functions/#{file_name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/graphql/install_generator.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+require 'rails/generators/base'
+
+module Graphql
+  module Generators
+    # Add GraphQL to a Rails app with `rails g graphql:install`.
+    #
+    # Setup a folder structure for GraphQL:
+    #
+    # ```
+    # - app/
+    #   - graphql/
+    #     - resolvers/
+    #     - types/
+    #       - query_type.rb
+    #     - loaders/
+    #     - mutations/
+    #     - {app_name}_schema.rb
+    # ```
+    #
+    # (Add `.gitkeep`s by default, support `--skip-keeps`)
+    #
+    # Add a controller for serving GraphQL queries:
+    #
+    # ```
+    # app/controllers/graphql_controller.rb
+    # ```
+    #
+    # Add a route for that controller:
+    #
+    # ```ruby
+    # # config/routes.rb
+    # post "/graphql", to: "graphql#execute"
+    # ```
+    #
+    # Accept a `--relay` option which adds
+    # The root `node(id: ID!)` field.
+    #
+    # Accept a `--batch` option which adds `GraphQL::Batch` setup.
+    #
+    # Use `--no-graphiql` to skip `graphiql-rails` installation.
+    class InstallGenerator < Rails::Generators::Base
+      desc "Install GraphQL folder structure and boilerplate code"
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option :schema,
+        type: :string,
+        default: nil,
+        desc: "Name for the schema constant (default: {app_name}Schema)"
+
+      class_option :skip_keeps,
+        type: :boolean,
+        default: false,
+        desc: "Skip .keep files for source control"
+
+      class_option :skip_graphiql,
+        type: :boolean,
+        default: false,
+        desc: "Skip graphiql-rails installation"
+
+      class_option :relay,
+        type: :boolean,
+        default: false,
+        desc: "Include GraphQL::Relay installation"
+
+      class_option :batch,
+        type: :boolean,
+        default: false,
+        desc: "Include GraphQL::Batch installation"
+
+
+      GRAPHIQL_ROUTE = <<-RUBY
+if Rails.env.development?
+    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+  end
+RUBY
+
+      def create_folder_structure
+        create_dir("app/graphql/mutations")
+        create_dir("app/graphql/types")
+        template("query_type.erb", "app/graphql/types/query_type.rb")
+        template("schema.erb", "app/graphql/#{schema_name.underscore}.rb")
+        template("graphql_controller.erb", "app/controllers/graphql_controller.rb")
+        route('post "/graphql", to: "graphql#execute"')
+
+        if !options[:skip_graphiql]
+          gem("graphiql-rails", group: :development)
+          route(GRAPHIQL_ROUTE)
+        end
+
+        if options[:batch]
+          gem("graphql-batch")
+          create_dir("app/graphql/loaders")
+        end
+      end
+
+      private
+
+      def create_dir(dir)
+        empty_directory(dir)
+        if !options[:skip_keeps]
+          create_file("#{dir}/.keep")
+        end
+      end
+
+      def schema_name
+        @schema_name ||= begin
+          if options[:schema]
+            options[:schema]
+          else
+            require File.expand_path("config/application", destination_root)
+            "#{Rails.application.class.parent_name}Schema"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/interface_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+
+module Graphql
+  module Generators
+    # Generate an interface type by name,
+    # with the specified fields.
+    #
+    # ```
+    # rails g graphql:interface NamedEntityType name:String!
+    # ```
+    class InterfaceGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::InterfaceType with the given name and fields"
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :fields,
+        type: :array,
+        default: [],
+        banner: "name:type name:type ...",
+        desc: "Fields for this interface (type may be expressed as Ruby or GraphQL)"
+
+      def create_type_file
+        template "interface.erb", "app/graphql/types/#{type_file_name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/graphql/loader_generator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "rails/generators/named_base"
+
+module Graphql
+  module Generators
+    # @example Generate a `GraphQL::Batch` loader by name.
+    #     rails g graphql:loader RecordLoader
+    class LoaderGenerator < Rails::Generators::NamedBase
+      desc "Create a GraphQL::Batch::Loader by name"
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_loader_file
+        template "loader.erb", "app/graphql/loaders/#{file_name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/graphql/mutation_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require 'rails/generators/named_base'
+
+module Graphql
+  module Generators
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `Relay::Mutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class MutationGenerator < Rails::Generators::NamedBase
+      desc "Create a Relay mutation by name"
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_mutation_file
+        template "mutation.erb", "app/graphql/mutations/#{file_name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/graphql/object_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+
+module Graphql
+  module Generators
+    # Generate an object type by name,
+    # with the specified fields.
+    #
+    # ```
+    # rails g graphql:object PostType name:String!
+    # ```
+    #
+    # Add the Node interface with `--node`.
+    class ObjectGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::ObjectType with the given name and fields"
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :fields,
+        type: :array,
+        default: [],
+        banner: "name:type name:type ...",
+        desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      class_option :node,
+        type: :boolean,
+        default: false,
+        desc: "Include the Relay Node interface"
+
+      def create_type_file
+        template "object.erb", "app/graphql/types/#{type_file_name}.rb"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+<%= type_ruby_name %> = GraphQL::EnumType.define do
+  name "<%= type_graphql_name %>"
+<% prepared_values.each do |v| %>  value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
+<% end %>end

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

@@ -0,0 +1,17 @@
+class Functions::<%= name %> < GraphQL::Function
+  # Define `initialize` to store field-level options, eg
+  #
+  #     field :myField, function: Functions::<%= name %>.new(type: MyType)
+  #
+  # attr_reader :type
+  # def initialize(type:)
+  #   @type = type
+  # end
+
+  # add arguments by type:
+  # argument :id, !GraphQL::ID_TYPE
+
+  # Resolve function:
+  def call(obj, args, ctx)
+  end
+end

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

@@ -0,0 +1,32 @@
+class GraphqlController < ApplicationController
+  def execute
+    variables = ensure_hash(params[:variables])
+    query = params[:query]
+    context = {
+      # Query context goes here, for example:
+      # current_user: current_user,
+    }
+    result = <%= schema_name %>.execute(query, variables: variables, context: context)
+    render json: result
+  end
+
+  private
+
+  # Handle form data, JSON body, or a blank value
+  def ensure_hash(ambiguous_param)
+    case ambiguous_param
+    when String
+      if ambiguous_param.present?
+        ensure_hash(JSON.parse(ambiguous_param))
+      else
+        {}
+      end
+    when Hash, ActionController::Parameters
+      ambiguous_param
+    when nil
+      {}
+    else
+      raise ArgumentError, "Unexpected parameter: #{ambiguous_param}"
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+<%= type_ruby_name %> = GraphQL::InterfaceType.define do
+  name "<%= type_graphql_name %>"
+<% normalized_fields.each do |f| %>  field :<%= f[0] %>, <%= f[1] %>
+<% end %>end

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

@@ -0,0 +1,15 @@
+class Loaders::<%= name %> < GraphQL::Batch::Loader
+  # Define `initialize` to store grouping arguments, eg
+  #
+  #     Loaders::<%= 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

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

@@ -0,0 +1,12 @@
+Mutations::<%= name %> = GraphQL::Relay::Mutation.define do
+  name "<%= name %>"
+  # TODO: define return fields
+  # return_field :post, Types::PostType
+
+  # TODO: define arguments
+  # input_field :name, !types.String
+
+  resolve ->(obj, args, ctx) {
+    # TODO: define resolve function
+  }
+end

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

@@ -0,0 +1,5 @@
+<%= type_ruby_name %> = GraphQL::ObjectType.define do
+  name "<%= type_graphql_name %>"
+<% if options.node %>  implements GraphQL::Relay::Node.interface
+<% end %><% normalized_fields.each do |f| %>  field :<%= f[0] %>, <%= f[1] %>
+<% end %>end

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

@@ -0,0 +1,15 @@
+Types::QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  # Add root-level fields here.
+  # They will be entry points for queries on your schema.
+
+  # TODO: remove me
+  field :testField, types.String do
+    description "An example field added by the generator"
+    resolve ->(obj, args, ctx) {
+      "Hello World!"
+    }
+  end
+<% if options[:relay] %>
+  field :node, GraphQL::Relay::Node.field
+<% end %>end

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

@@ -0,0 +1,34 @@
+<%= schema_name %> = GraphQL::Schema.define do
+  query(Types::QueryType)
+<% if options[:relay] %>
+  # Relay Object Identification:
+
+  # Return a string UUID for `object`
+  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)
+  }
+
+  # Given a string UUID, find the object
+  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
+    # ...
+  }
+
+  # Object Resolution
+  resolve_type -> (obj, ctx) {
+    # TODO: Implement this function
+    # to return the correct type for `obj`
+    raise(NotImplementedError)
+  }
+<% end %><% if options[:batch] %>
+  # GraphQL::Batch setup:
+  lazy_resolve(Promise, :sync)
+  instrument(:query, GraphQL::Batch::Setup)
+<% end %>end

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

@@ -0,0 +1,4 @@
+<%= type_ruby_name %> = GraphQL::UnionType.define do
+  name "<%= type_graphql_name %>"
+<% if possible_types.any? %>  possible_types [<%= normalized_possible_types.join(", ") %>]
+<% end %>end

data/lib/generators/graphql/type_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'rails/generators/base'
+require 'graphql'
+
+module Graphql
+  module Generators
+    class TypeGeneratorBase < Rails::Generators::Base
+      argument :type_name,
+        type: :string,
+        required: true,
+        banner: "TypeName",
+        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+
+      # 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]
+      # @return [String]
+      def self.normalize_type_expression(type_expression, mode:)
+        if type_expression.start_with?("!")
+          "!#{normalize_type_expression(type_expression[1..-1], mode: mode)}"
+        elsif type_expression.end_with?("!")
+          "!#{normalize_type_expression(type_expression[0..-2], mode: mode)}"
+        elsif type_expression.start_with?("[") && type_expression.end_with?("]")
+          "types[#{normalize_type_expression(type_expression[1..-2], mode: mode)}]"
+        elsif type_expression.start_with?("types[") && type_expression.end_with?("]")
+          "types[#{normalize_type_expression(type_expression[6..-2], mode: mode)}]"
+        elsif type_expression.end_with?("Type")
+          normalize_type_expression(type_expression[0..-5], mode: mode)
+        elsif type_expression.start_with?("Types::")
+          normalize_type_expression(type_expression[7..-1], mode: mode)
+        elsif type_expression.start_with?("types.")
+          normalize_type_expression(type_expression[6..-1], mode: mode)
+        else
+          case mode
+          when :ruby
+            case type_expression
+            when "Int", "Float", "Boolean", "String", "ID"
+              "types.#{type_expression}"
+            else
+              "Types::#{type_expression}Type"
+            end
+          when :graphql
+            type_expression
+          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(type_name, mode: :ruby)
+      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)
+      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<Array(String, String)>>] User-provided fields, in `(name, Ruby type name)` pairs
+      def normalized_fields
+        @normalized_fields ||= fields.map { |f|
+          name, raw_type = f.split(":", 2)
+          [name, self.class.normalize_type_expression(raw_type, mode: :ruby)]
+        }
+      end
+    end
+  end
+end