rails-graphql 1.0.0.beta → 1.0.0.rc2

data/lib/rails/graphql/helpers/with_schema_fields.rb

@@ -17,21 +17,24 @@ module Rails
           def inherited(subclass)
             super if defined? super
 
-            TYPE_FIELD_CLASS.each_key do |kind|
-              fields = instance_variable_defined?("@#{kind}_fields")
-              fields = fields ? instance_variable_get("@#{kind}_fields") : {}
-              fields.each_value { |field| subclass.add_proxy_field(kind, field) }
+            TYPE_FIELD_CLASS.each_key do |type|
+              fields = instance_variable_defined?("@#{type}_fields")
+              fields = fields ? instance_variable_get("@#{type}_fields") : EMPTY_HASH
+              fields.each_value { |field| subclass.add_proxy_field(type, field) }
             end
           end
         end
 
         # Helper class to be used as the +self+ in configuration blocks
         ScopedConfig = Struct.new(:source, :type) do
-          def arg(*args, **xargs, &block)
+          def argument(*args, **xargs, &block)
             xargs[:owner] ||= source
             GraphQL::Argument.new(*args, **xargs, &block)
           end
 
+          alias arg argument
+          alias kind type
+
           private
 
             def respond_to_missing?(method_name, include_private = false)
@@ -55,7 +58,6 @@ module Rails
                   safe_field:  :safe_add_field,
                   field:       :add_field,
                   proxy_field: :add_proxy_field,
-                  field?:      :has_field?,
                   import:      :import_into,
                   import_all:  :import_all_into,
                 )
@@ -76,13 +78,16 @@ module Rails
           end
         end
 
+        # Allow hash access with the type or the type and the name
+        def [](type, name = nil)
+          name.nil? ? fields_for(type) : find_field(type, name)
+        end
+
         # Check if there are fields set fot he given type
         def fields_for?(type)
           public_send("#{type}_fields?")
         end
 
-        alias [] :fields_for
-
         # Return the object name for a given +type+ of list of fields
         def type_name_for(type)
           method_name = :"#{type}_type_name"
@@ -100,7 +105,7 @@ module Rails
         # Add a new field of the give +type+
         # See {OutputField}[rdoc-ref:Rails::GraphQL::OutputField] class.
         def add_field(type, *args, **xargs, &block)
-          klass = Field.const_get(TYPE_FIELD_CLASS[type])
+          klass = Field.const_get(TYPE_FIELD_CLASS[type], false)
           object = klass.new(*args, **xargs, owner: self, &block)
 
           raise DuplicatedError, (+<<~MSG).squish if has_field?(type, object.name)
@@ -116,11 +121,12 @@ module Rails
         # Add a new field to the list but use a proxy instead of a hard copy of
         # a given +field+
         def add_proxy_field(type, field, *args, **xargs, &block)
+          field = field.field if field.is_a?(Module) && field <= Alternative::Query
           raise ArgumentError, (+<<~MSG).squish if field.schema_type != type
             A #{field.schema_type} field cannot be added as a #{type} field.
           MSG
 
-          klass = Field.const_get(TYPE_FIELD_CLASS[type])
+          klass = Field.const_get(TYPE_FIELD_CLASS[type], false)
           raise ArgumentError, (+<<~MSG).squish unless field.is_a?(klass)
             The #{field.class.name} is not a valid field for #{type} fields.
           MSG
@@ -180,12 +186,15 @@ module Rails
           MSG
         end
 
-        # Get the list of GraphQL names of all the fields difined
+        # Get the list of GraphQL names of all the fields defined
         def field_names_for(type, enabled_only = true)
-          return unless fields_for?(type)
-          list = fields_for(type)
-          list = list.select(&:enabled?) if enabled_only
-          list.map(&:gql_name).compact
+          source = (enabled_only ? enabled_fields_from(type) : lazy_each_field_from(type))
+          source&.map(&:gql_name)&.eager
+        end
+
+        # Return a lazy enumerator for enabled fields
+        def enabled_fields_from(type)
+          lazy_each_field_from(type)&.select(&:enabled?)
         end
 
         # Run a configuration block for the given +type+
@@ -195,8 +204,6 @@ module Rails
 
         # Import a class of fields into the given section of schema fields
         def import_into(type, source)
-          return if source.try(:abstract?)
-
           # Import an alternative declaration of a field
           if source.is_a?(Module) && source <= Alternative::Query
             return add_proxy_field(type, source.field)
@@ -229,10 +236,10 @@ module Rails
         # TODO: Maybe add deepness into the recursive value
         def import_all_into(type, mod, recursive: false, **xargs)
           mod.constants.each do |const_name|
-            object = mod.const_get(const_name)
+            object = mod.const_get(const_name, false)
 
             import_into(type, object, **xargs) if object.is_a?(Class)
-            import_all_into(type, object, recursive: recursive, **xargs) if recursive
+            import_all_into(type, object, recursive: recursive, **xargs) if recursive && object.is_a?(Module)
           end
         end
 
@@ -253,9 +260,9 @@ module Rails
         def validate!(*)
           super if defined? super
 
-          TYPE_FIELD_CLASS.each_key do |kind|
-            next unless public_send("#{kind}_fields?")
-            fields_for(kind).each_value(&:validate!)
+          TYPE_FIELD_CLASS.each_key do |type|
+            next unless public_send("#{type}_fields?")
+            fields_for(type).each_value(&:validate!)
           end
         end
 
@@ -264,52 +271,69 @@ module Rails
           find_field!(gid.scope, gid.name)
         end
 
-        TYPE_FIELD_CLASS.each_key do |kind|
+        TYPE_FIELD_CLASS.each_key do |type|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{kind}_field?(name)
-              has_field?(:#{kind}, name)
+            def #{type}_fields?
+              defined?(@#{type}_fields) && @#{type}_fields.present?
             end
 
-            def #{kind}_field(name)
-              find_field(:#{kind}, name)
+            def #{type}_fields(&block)
+              configure_fields(:#{type}, &block) if block.present?
+              @#{type}_fields if defined?(@#{type}_fields)
             end
 
-            def add_#{kind}_field(*args, **xargs, &block)
-              add_field(:#{kind}, *args, **xargs, &block)
+            def add_#{type}_field(*args, **xargs, &block)
+              add_field(:#{type}, *args, **xargs, &block)
             end
 
-            def #{kind}_fields?
-              defined?(@#{kind}_fields) && @#{kind}_fields.present?
+            def #{type}_field?(name)
+              has_field?(:#{type}, name)
             end
 
-            def #{kind}_fields(&block)
-              configure_fields(:#{kind}, &block) if block.present?
-              @#{kind}_fields if defined?(@#{kind}_fields)
+            def #{type}_field(name)
+              find_field(:#{type}, name)
             end
 
-            def #{kind}_type_name
+            def #{type}_type_name
               source = (respond_to?(:config) ? config : GraphQL.config)
-              source.schema_type_names[:#{kind}]
+              source.schema_type_names[:#{type}]
             end
 
-            def #{kind}_type
-              if defined?(@#{kind}_fields) && @#{kind}_fields.present?
-                OpenStruct.new(
-                  name: "\#{name}[:#{kind}]",
-                  kind: :object,
-                  object?: true,
-                  kind_enum: 'OBJECT',
-                  fields: @#{kind}_fields,
-                  gql_name: #{kind}_type_name,
-                  interfaces: nil,
-                  description: nil,
-                  interfaces?: false,
-                  internal?: false,
-                ).freeze
-              end
+            def #{type}_type
+              return unless #{type}_fields?
+
+              OpenStruct.new(
+                name: "\#{name}[:#{type}]",
+                kind: :object,
+                object?: true,
+                kind_enum: 'OBJECT',
+                fields: @#{type}_fields,
+                gql_name: #{type}_type_name,
+                description: nil,
+                output_type?: true,
+                operational?: true,
+                interfaces?: false,
+                internal?: false,
+              ).freeze
             end
           RUBY
         end
+
+        protected
+
+          # A little helper to define arguments using the :arguments key
+          def argument(*args, **xargs, &block)
+            xargs[:owner] = self
+            GraphQL::Argument.new(*args, **xargs, &block)
+          end
+
+          alias arg argument
+
+        private
+
+          def lazy_each_field_from(type)
+            fields_for(type).each_pair.lazy.each_entry.map(&:last) if fields_for?(type)
+          end
       end
     end
   end

data/lib/rails/graphql/introspection.rb

@@ -26,7 +26,7 @@ module Rails
 
       protected
 
-        # Enaqble introspection fields
+        # Enable introspection fields
         def enable_introspection!
           redefine_singleton_method(:introspection?) { true }
           introspection_dependencies!

data/lib/rails/graphql/railtie.rb

@@ -123,8 +123,9 @@ module Rails
       initializer 'graphql.reloader', before: :load_config_initializers do |app|
         next unless (path = app.root.join('app', 'graphql')).exist?
 
-        children = config.graphql.paths.join(',')
-        autoloader = app.autoloaders.main
+        children = config.graphql.paths.to_a.join(',')
+        autoloader = app.respond_to?(:autoloaders) ? app.autoloaders : Rails.autoloaders
+        autoloader = autoloader.main
 
         ActiveSupport::Dependencies.autoload_paths.delete(path.to_s)
         autoloader.collapse(path.glob("**/{#{children}}").select(&:directory?))

data/lib/rails/graphql/railties/app/base_channel.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module GraphQL
+  base = ActionCable::Channel::Base
+  base = ApplicationCable::Channel if defined?(ApplicationCable::Channel)
+
+  BaseChannel = Class.new(base) do
+    include ::Rails::GraphQL::Channel
+  end
+end

data/lib/rails/graphql/railties/app/base_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module GraphQL
+  base = ActionController::Base
+  base = ApplicationController if defined?(ApplicationController)
+
+  BaseController = Class.new(base) do
+    include ::Rails::GraphQL::Controller
+
+    skip_before_action :verify_authenticity_token
+  end
+end

data/lib/rails/graphql/railties/app/views/_cable.js.erb

@@ -0,0 +1,56 @@
+var queue = [];
+var current = null;
+var identifier = JSON.stringify({ channel: '<%= channel %>' });
+var socket = new WebSocket("ws://" + window.location.hostname + "/<%= url %>");
+
+// TOOD: This is a temporary implementation
+socket.onopen = function(event) {
+  const msg = { command: 'subscribe', identifier: identifier };
+  socket.send(JSON.stringify(msg));
+};
+
+socket.onmessage = function(event) {
+  const msg = JSON.parse(event.data);
+  if (msg.type === "ping") {
+    return;
+  }
+
+  if (msg.type === "confirm_subscription") {
+    execute_next();
+    return;
+  }
+
+  if (msg.message && current) {
+    current.resolve(msg.message.result);
+    current = null;
+    execute_next();
+  } else {
+    console.dir(msg);
+  }
+};
+
+function execute_next() {
+  if (socket.readyState != '1' || queue.length === 0 || current) {
+    return;
+  }
+
+  current = queue.shift();
+  socket.send(JSON.stringify({
+    command: 'message',
+    identifier: identifier,
+    data: JSON.stringify({ action: 'execute', ...current.data }),
+  }));
+}
+
+function graphQLFetcher(graphQLParams) {
+  var resolve;
+  var promise = new Promise((success) => {
+    resolve = success;
+  });
+
+  var item = { data: graphQLParams, promise, resolve };
+
+  queue.push(item);
+  execute_next();
+  return promise;
+};

data/lib/rails/graphql/railties/app/views/_fetch.js.erb

@@ -0,0 +1,20 @@
+function graphQLFetcher(graphQLParams) {
+  // This example expects a GraphQL server at the path /graphql.
+  // Change this to point wherever you host your GraphQL server.
+  return fetch('<%= url %>', {
+    method: 'post',
+    headers: {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(graphQLParams),
+  }).then(function (response) {
+    return response.text();
+  }).then(function (responseBody) {
+    try {
+      return JSON.parse(responseBody);
+    } catch (error) {
+      return responseBody;
+    }
+  });
+}

data/lib/rails/graphql/railties/app/views/graphiql.html.erb

@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="robots" content="noindex" />
+  <meta name="referrer" content="origin" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>SWAPI GraphQL API</title>
+  <style>
+    body {
+      height: 100vh;
+      margin: 0;
+      overflow: hidden;
+    }
+    #splash {
+      color: #333;
+      display: flex;
+      flex-direction: column;
+      font-family: system, -apple-system, "San Francisco", ".SFNSDisplay-Regular", "Segoe UI", Segoe, "Segoe WP", "Helvetica Neue", helvetica, "Lucida Grande", arial, sans-serif;
+      height: 100vh;
+      justify-content: center;
+      text-align: center;
+    }
+  </style>
+  <link rel="icon" href="favicon.ico">
+  <link type="text/css" href="//unpkg.com/graphiql/graphiql.min.css" rel="stylesheet" />
+</head>
+<body>
+  <div id="splash">
+    Loading&hellip;
+  </div>
+  <script src="//cdn.jsdelivr.net/es6-promise/4.0.5/es6-promise.auto.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/react/umd/react.production.min.js"></script>
+  <script src="https://cdn.jsdelivr.net/npm/react-dom/umd/react-dom.production.min.js"></script>
+  <script src="//unpkg.com/graphiql/graphiql.min.js"></script>
+  <script>
+      // Parse the search string to get url parameters.
+      var search = window.location.search;
+      var parameters = {};
+      search.substr(1).split('&').forEach(function (entry) {
+        var eq = entry.indexOf('=');
+        if (eq >= 0) {
+          parameters[decodeURIComponent(entry.slice(0, eq))] =
+            decodeURIComponent(entry.slice(eq + 1));
+        }
+      });
+
+      // if variables was provided, try to format it.
+      if (parameters.variables) {
+        try {
+          parameters.variables =
+            JSON.stringify(JSON.parse(parameters.variables), null, 2);
+        } catch (e) {
+          // Do nothing, we want to display the invalid JSON as a string, rather
+          // than present an error.
+        }
+      }
+
+      // When the query and variables string is edited, update the URL bar so
+      // that it can be easily shared
+      function onEditQuery(newQuery) {
+        parameters.query = newQuery;
+        updateURL();
+      }
+      function onEditVariables(newVariables) {
+        parameters.variables = newVariables;
+        updateURL();
+      }
+      function onEditOperationName(newOperationName) {
+        parameters.operationName = newOperationName;
+        updateURL();
+      }
+      function updateURL() {
+        var newSearch = '?' + Object.keys(parameters).filter(function (key) {
+          return Boolean(parameters[key]);
+        }).map(function (key) {
+          return encodeURIComponent(key) + '=' +
+            encodeURIComponent(parameters[key]);
+        }).join('&');
+        history.replaceState(null, null, newSearch);
+      }
+
+      <%= render partial: "/#{settings[:mode]}", formats: :js, locals: settings %>
+
+      // Render <GraphiQL /> into the body.
+      ReactDOM.render(
+        React.createElement(GraphiQL, {
+          fetcher: graphQLFetcher,
+          query: parameters.query,
+          variables: parameters.variables,
+          operationName: parameters.operationName,
+          onEditQuery: onEditQuery,
+          onEditVariables: onEditVariables,
+          onEditOperationName: onEditOperationName
+        }),
+        document.body,
+      );
+  </script>
+</body>
+</html>
+

data/lib/rails/graphql/railties/base_generator.rb

@@ -7,23 +7,17 @@ module Rails
     # A module to help generators to operate
     module BaseGenerator
       TEMPALTES_PATH = '../../../generators/graphql/templates'
+      APP_MODULE_NAME = Rails.application.class.name.chomp('::Application')
 
       def self.included(base)
+        base.const_set(:APP_MODULE_NAME, APP_MODULE_NAME)
         base.send(:namespace, "graphql:#{base.name.demodulize.underscore[0..-11]}")
         base.send(:source_root, File.expand_path(TEMPALTES_PATH, __dir__))
-        base.send(:class_option, :directory,
-          type: :string,
+        base.send(:class_option, :directory, type: :string,
           default: 'app/graphql',
           desc: 'Directory where generated files should be saved',
         )
       end
-
-      protected
-
-        def app_module_name
-          require File.expand_path('config/application', destination_root)
-          Rails.application.class.name.chomp('::Application')
-        end
     end
   end
 end

data/lib/rails/graphql/railties/channel.rb

@@ -79,12 +79,6 @@ module Rails
           }
         end
 
-        # The list of ids of subscription and to which field they are
-        # associated with
-        def gql_subscriptions
-          @gql_subscriptions ||= {}
-        end
-
         # The instance of a GraphQL request. It can't simply perform using
         # +execute+, because it is important to check if any subscription was
         # generated
@@ -117,8 +111,8 @@ module Rails
         end
 
         # Get the GraphQL variables for a request
-        def gql_variables(data)
-          variables = data['variables']
+        def gql_variables(data, variables = nil)
+          variables ||= data['variables']
 
           case variables
           when ::ActionController::Parameters then variables.permit!.to_h
@@ -128,6 +122,12 @@ module Rails
           end
         end
 
+        # The list of ids of subscription and to which field they are
+        # associated with
+        def gql_subscriptions
+          @gql_subscriptions ||= {}
+        end
+
         # Remove all subscriptions
         def gql_clear_subscriptions
           gql_remove_subscription(*gql_subscriptions.keys) unless gql_subscriptions.empty?

data/lib/rails/graphql/railties/controller.rb

@@ -22,6 +22,9 @@ module Rails
         # Each controller is assigned to a GraphQL schema on which the requests
         # will be performed from. It can be a string or the class
         class_attribute :gql_schema, instance_accessor: false
+
+        # Add the internal views directory
+        prepend_view_path("#{__dir__}/app/views")
       end
 
       # POST /execute
@@ -30,43 +33,43 @@ module Rails
       end
 
       # GET /describe
-      def describe
-        render plain: gql_schema_header + gql_describe_schema + gql_schema_footer
+      def describe(schema = gql_schema)
+        render plain: [
+          gql_schema_header(schema),
+          gql_describe_schema(schema),
+          gql_schema_footer,
+        ].join
+      end
+
+      # GET /graphiql
+      def graphiql
+        render '/graphiql', layout: false, locals: { settings: graphiql_settings }
       end
 
       protected
 
+        # Identifies if the request should be threated as a compiled request
+        def gql_compiled_request?(*)
+          false
+        end
+
         # Render a response as a GraphQL request
         def gql_request_response(*args, **xargs)
           render json: gql_request(*args, **xargs)
         end
 
-        # Shows a text representation of the schema
-        def gql_describe_schema(schema = gql_schema)
-          schema.to_gql(
-            with_descriptions: !params.key?(:without_descriptions),
-            with_spec: !params.key?(:without_spec),
-          )
-        end
-
         # Execute a GraphQL request
-        def gql_request(query, **xargs)
+        def gql_request(document, **xargs)
           request_xargs = REQUEST_XARGS.each_with_object({}) do |setting, result|
             result[setting] ||= (xargs[setting] || send(:"gql_#{setting}"))
           end
 
           request_xargs[:hash] ||= gql_query_cache_key
           request_xargs[:origin] ||= self
+          request_xargs[:compiled] ||= gql_compiled_request?(document)
 
           request_xargs = request_xargs.except(*%i[query_cache_key query_cache_version])
-          ::Rails::GraphQL::Request.execute(query, **request_xargs)
-        end
-
-        # Print a header of the current schema for the description process
-        # TODO: Maybe add a way to detect from which file the schema is being loaded
-        def gql_schema_header
-          ns = +" [#{gql_schema.namespace}]" if gql_schema.namespace != :base
-          +"#{DESCRIBE_HEADER}# Schema #{gql_schema.name}#{ns}\n"
+          ::Rails::GraphQL::Request.execute(document, **request_xargs)
         end
 
         # The schema on which the requests will be performed from
@@ -87,10 +90,12 @@ module Rails
         end
 
         # Get the GraphQL query to execute
-        def gql_query
+        def gql_document
           params[:query]
         end
 
+        alias gql_query gql_document
+
         # Get the cache key of the query for persisted queries
         def gql_query_cache_key(key = nil, version = nil)
           return unless (key ||= params[:query_cache_key]).present?
@@ -117,6 +122,30 @@ module Rails
           end
         end
 
+        # Return the settings for the GraphiQL view
+        def graphiql_settings(mode = nil)
+          if mode == :cable
+            { mode: :cable, url: '/cable', channel: 'GraphQL::BaseChannel' }
+          else
+            { mode: :fetch, url: '/graphql' }
+          end
+        end
+
+        # Shows a text representation of the schema
+        def gql_describe_schema(schema)
+          schema.to_gql(
+            with_descriptions: !params.key?(:without_descriptions),
+            with_spec: !params.key?(:without_spec),
+          )
+        end
+
+        # Print a header of the current schema for the description process
+        # TODO: Maybe add a way to detect from which file the schema is being loaded
+        def gql_schema_header(schema)
+          ns = +" [#{schema.namespace}]" if schema.namespace != :base
+          +"#{DESCRIBE_HEADER}# Schema #{schema.name}#{ns}\n"
+        end
+
         # Show the footer of the describe page
         def gql_schema_footer
           $/ + $/ + '# Version: ' + gql_version + $/ +
@@ -133,12 +162,8 @@ module Rails
 
         # Find the default application schema
         def gql_application_default_schema
-          app_class = Rails.application.class
-          source_name = app_class.respond_to?(:module_parent_name) \
-            ? :module_parent_name \
-            : :parent_name
-
-          klass = "::GraphQL::#{app_class.public_send(source_name)}Schema".constantize
+          app_class = Rails.application.class.name.chomp('::Application')
+          klass = "::GraphQL::#{app_class}Schema".safe_constantize
           self.class.gql_schema = klass
         end
     end

data/lib/rails/graphql/request/arguments.rb

@@ -35,7 +35,8 @@ module Rails
           end
         end
 
-        delegate :key?, to: :@table
+        delegate :key?, :[], to: :@table
+        alias to_hash to_h
 
         class << self
           # Easy access to the easy loader method