graphql_cody 1.13.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d2aa5d3dcabeb1333411679bdf9bb39506665cd3e08a8115856f83a55def484f
+  data.tar.gz: b8f31dcb5e5f39c657d39b7089517b3accd8dc2577f94f66f909f30fb66a399f
+SHA512:
+  metadata.gz: 12afaf75f16856716e196a2757978fcf5cb8fe3c1d82eadcdb3ef07ec8c3a9d38cee262cf8c70c8f9a612867a61ad25713278abce0319e71991567785a0a42ea
+  data.tar.gz: 7774a98a8c9bfbd317a2db13cd3413504ab02102e83f4e1424fa03200426ecd82c8e00e182c2c5f1f493c41bab484fe4031b8ff138356e2a4db462b8b0fa8b0c

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--markup=markdown
+--readme=readme.md
+--title='GraphQL Ruby API Documentation'
+'lib/**/*.rb' - '*.md'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Robert Mosolgo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/generators/graphql/core.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require 'rails/generators/base'
+
+module Graphql
+  module Generators
+    module Core
+      def self.included(base)
+        base.send(
+          :class_option,
+          :directory,
+          type: :string,
+          default: "app/graphql",
+          desc: "Directory where generated files should be saved"
+        )
+      end
+
+      def insert_root_type(type, name)
+        log :add_root_type, type
+        sentinel = /< GraphQL::Schema\s*\n/m
+
+        in_root do
+          inject_into_file schema_file_path, "  #{type}(Types::#{name})\n", after: sentinel, verbose: false, force: false
+        end
+      end
+
+      def create_mutation_root_type
+        create_dir("#{options[:directory]}/mutations")
+        template("base_mutation.erb", "#{options[:directory]}/mutations/base_mutation.rb", { skip: true })
+        template("mutation_type.erb", "#{options[:directory]}/types/mutation_type.rb", { skip: true })
+        insert_root_type('mutation', 'MutationType')
+      end
+
+      def schema_file_path
+        "#{options[:directory]}/#{schema_name.underscore}.rb"
+      end
+
+      def create_dir(dir)
+        empty_directory(dir)
+        if !options[:skip_keeps]
+          create_file("#{dir}/.keep")
+        end
+      end
+
+      def module_namespacing_when_supported
+        if defined?(module_namespacing)
+          module_namespacing { yield }
+        else
+          yield
+        end
+      end
+
+      private
+
+      def schema_name
+        @schema_name ||= begin
+          if options[:schema]
+            options[:schema]
+          else
+            "#{parent_name}Schema"
+          end
+        end
+      end
+
+      def parent_name
+        require File.expand_path("config/application", destination_root)
+        if Rails.application.class.respond_to?(:module_parent_name)
+          Rails.application.class.module_parent_name
+        else
+          Rails.application.class.parent_name
+        end
+      end
+    end
+  end
+end

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 enum type by name, with the given values.
+    # To add a `value:` option, add another value after a `:`.
+    #
+    # ```
+    # rails g graphql:enum ProgrammingLanguage RUBY PYTHON PERL PERL6:"PERL"
+    # ```
+    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", "#{options[:directory]}/types/#{type_file_name}.rb"
+      end
+
+      private
+
+      def prepared_values
+        values.map { |v| v.split(":", 2) }
+      end
+    end
+  end
+end

data/lib/generators/graphql/install_generator.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/base'
+require_relative 'core'
+require_relative 'relay'
+
+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/
+    #       - base_argument.rb
+    #       - base_field.rb
+    #       - base_enum.rb
+    #       - base_input_object.rb
+    #       - base_interface.rb
+    #       - base_object.rb
+    #       - base_scalar.rb
+    #       - base_union.rb
+    #       - query_type.rb
+    #     - loaders/
+    #     - mutations/
+    #       - base_mutation.rb
+    #     - {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 `--batch` option which adds `GraphQL::Batch` setup.
+    #
+    # Use `--no-graphiql` to skip `graphiql-rails` installation.
+    #
+    # TODO: also add base classes
+    class InstallGenerator < Rails::Generators::Base
+      include Core
+      include Relay
+
+      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 :skip_mutation_root_type,
+        type: :boolean,
+        default: false,
+        desc: "Skip creation of the mutation root type"
+
+      class_option :relay,
+        type: :boolean,
+        default: true,
+        desc: "Include installation of Relay conventions (nodes, connections, edges)"
+
+      class_option :batch,
+        type: :boolean,
+        default: false,
+        desc: "Include GraphQL::Batch installation"
+
+      class_option :playground,
+        type: :boolean,
+        default: false,
+        desc: "Use GraphQL Playground over Graphiql as IDE"
+
+      # These two options are taken from Rails' own generators'
+      class_option :api,
+        type: :boolean,
+        desc: "Preconfigure smaller stack for API only apps"
+
+      def create_folder_structure
+        create_dir("#{options[:directory]}/types")
+        template("schema.erb", schema_file_path)
+
+        ["base_object", "base_argument", "base_field", "base_enum", "base_input_object", "base_interface", "base_scalar", "base_union"].each do |base_type|
+          template("#{base_type}.erb", "#{options[:directory]}/types/#{base_type}.rb")
+        end
+
+        # Note: You can't have a schema without the query type, otherwise introspection breaks
+        template("query_type.erb", "#{options[:directory]}/types/query_type.rb")
+        insert_root_type('query', 'QueryType')
+
+        create_mutation_root_type unless options.skip_mutation_root_type?
+
+        template("graphql_controller.erb", "app/controllers/graphql_controller.rb")
+        route('post "/graphql", to: "graphql#execute"')
+
+        if options[:batch]
+          gem("graphql-batch")
+          create_dir("#{options[:directory]}/loaders")
+        end
+
+        if options.api?
+          say("Skipped graphiql, as this rails project is API only")
+          say("  You may wish to use GraphiQL.app for development: https://github.com/skevy/graphiql-app")
+        elsif !options[:skip_graphiql] && !File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
+          gem("graphiql-rails", group: :development)
+
+          # This is a little cheat just to get cleaner shell output:
+          log :route, 'graphiql-rails'
+          shell.mute do
+            # Rails 5.2 has better support for `route`?
+            if Rails::VERSION::STRING > "5.2"
+              route <<-RUBY
+if Rails.env.development?
+  mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+end
+RUBY
+            else
+              route <<-RUBY
+if Rails.env.development?
+    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+  end
+RUBY
+            end
+          end
+        end
+
+        if options[:playground]
+          gem("graphql_playground-rails", group: :development)
+
+          log :route, 'graphql_playground-rails'
+          shell.mute do
+            if Rails::VERSION::STRING > "5.2"
+              route <<-RUBY
+if Rails.env.development?
+  mount GraphqlPlayground::Rails::Engine, at: "/playground", graphql_path: "/graphql"
+end
+RUBY
+            else
+              route <<-RUBY
+if Rails.env.development?
+    mount GraphqlPlayground::Rails::Engine, at: "/playground", graphql_path: "/graphql"
+  end
+RUBY
+            end
+          end
+        end
+
+        if options[:relay]
+          install_relay
+        end
+
+        if gemfile_modified?
+          say "Gemfile has been modified, make sure you `bundle install`"
+        end
+      end
+
+      private
+
+      def gemfile_modified?
+        @gemfile_modified
+      end
+
+      def gem(*args)
+        @gemfile_modified = true
+        super(*args)
+      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", "#{options[:directory]}/types/#{type_file_name}.rb"
+      end
+    end
+  end
+end

data/lib/generators/graphql/loader_generator.rb

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

data/lib/generators/graphql/mutation_generator.rb

@@ -0,0 +1,55 @@
+# 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 MutationGenerator < Rails::Generators::Base
+      include Core
+
+      desc "Create a Relay Classic mutation by name"
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :name, type: :string
+
+      def initialize(args, *options) # :nodoc:
+        # Unfreeze name in case it's given as a frozen string
+        args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
+        super
+
+        assign_names!(name)
+      end
+
+      attr_reader :file_name, :mutation_name, :field_name
+
+      def create_mutation_file
+        unless @behavior == :revoke
+          create_mutation_root_type
+        else
+          log :gsub, "#{options[:directory]}/types/mutation_type.rb"
+        end
+
+        template "mutation.erb", "#{options[:directory]}/mutations/#{file_name}.rb"
+
+        sentinel = /class .*MutationType\s*<\s*[^\s]+?\n/m
+        in_root do
+          gsub_file "#{options[:directory]}/types/mutation_type.rb", /  \# TODO\: Add Mutations as fields\s*\n/m, ""
+          inject_into_file "#{options[:directory]}/types/mutation_type.rb", "    field :#{field_name}, mutation: Mutations::#{mutation_name}\n", after: sentinel, verbose: false, force: false
+        end
+      end
+
+      private
+
+      def assign_names!(name)
+        @field_name = name.camelize.underscore
+        @mutation_name = name.camelize(:upper)
+        @file_name = name.camelize.underscore
+      end
+    end
+  end
+end

data/lib/generators/graphql/object_generator.rb

@@ -0,0 +1,79 @@
+# 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." \
+      "If the given type name matches an existing ActiveRecord model, the generated type will automatically include fields for the models database columns."
+      source_root File.expand_path('../templates', __FILE__)
+
+      argument :custom_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", "#{options[:directory]}/types/#{type_file_name}.rb"
+      end
+
+      def fields
+        columns = []
+        columns += klass.columns.map { |c| generate_column_string(c) } if class_exists?
+        columns + custom_fields
+      end
+
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        case type_expression
+        when "Text"
+          ["String", null]
+        when "Decimal"
+          ["Float", null]
+        when "DateTime", "Datetime"
+          ["GraphQL::Types::ISO8601DateTime", null]
+        when "Date"
+          ["GraphQL::Types::ISO8601Date", null]
+        else
+          super
+        end
+      end
+
+      private
+
+      def generate_column_string(column)
+        name = column.name
+        required = column.null ? "" : "!"
+        type = column_type_string(column)
+        "#{name}:#{required}#{type}"
+      end
+
+      def column_type_string(column)
+        column.name == "id" ? "ID" : column.type.to_s.camelize
+      end
+
+      def class_exists?
+        klass.is_a?(Class) && klass.ancestors.include?(ActiveRecord::Base)
+      rescue NameError
+        return false
+      end
+
+      def klass
+        @klass ||= Module.const_get(type_name.camelize)
+      end
+    end
+  end
+end

data/lib/generators/graphql/relay.rb

@@ -0,0 +1,63 @@
+# 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_id = object.to_global_id.to_s
+    # Remove this redundant prefix to make IDs shorter:
+    object_id = object_id.sub("gid://\#{GlobalID.app}/", "")
+    encoded_id = Base64.urlsafe_encode64(object_id)
+    # Remove the "=" padding
+    encoded_id = encoded_id.sub(/=+/, "")
+    # Add a type hint
+    type_hint = type_definition.graphql_name.first
+    "\#{type_hint}_\#{encoded_id}"
+  end
+
+  # Given a string UUID, find the object
+  def self.object_from_id(encoded_id_with_hint, query_ctx)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    # Split off the type hint
+    _type_hint, encoded_id = encoded_id_with_hint.split("_", 2)
+    # Decode the ID
+    id = Base64.urlsafe_decode64(encoded_id)
+    # Rebuild it for Rails then find the object:
+    full_global_id = "gid://\#{GlobalID.app}/\#{id}"
+    GlobalID::Locator.locate(full_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,20 @@
+# 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__)
+
+      def create_type_file
+        template "scalar.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
+      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 -%>