rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/railtie.rb

@@ -4,8 +4,8 @@ require 'rails/railtie'
 require 'action_controller'
 require 'action_controller/railtie'
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = Rails GraphQL Railtie
     #
     # Rails integration and configuration
@@ -21,19 +21,43 @@ module Rails # :nodoc:
         require_relative './schema'
       end
 
+      console do
+        config.graphql.enable_string_collector = false
+        config.graphql.default_response_format = :hash
+      end
+
       # Ensure a valid logger
-      initializer 'graphql.logger' do
+      initializer 'graphql.logger' do |app|
         ActiveSupport.on_load(:graphql) do
           return if config.logger.present?
-          if ::Rails.logger.respond_to?(:tagged)
-            config.logger = ::Rails.logger
+
+          logger = ::Rails.logger
+          if logger.respond_to?(:tagged)
+            config.logger = logger
           else
-            config.logger = ActiveSupport::TaggedLogging.new(::Rails.logger)
+            config.logger = ActiveSupport::TaggedLogging.new(logger)
+          end
+        end
+      end
+
+      initializer 'graphql.active_record_backtrace_print' do
+        if defined?(ActiveRecord)
+          base = Module.new
+          base.send(:define_method, :to_gql_backtrace) do
+            +"#<#{self.class.name} id: #{id}>"
           end
+
+          relation = Module.new
+          relation.send(:define_method, :to_gql_backtrace) do
+            +"[#<#{model.name}>](#{size})"
+          end
+
+          ActiveRecord::Base.include(base)
+          ActiveRecord::Relation.include(relation)
         end
       end
 
-      # Expose database runtime to controller for logging.
+      # Expose GraphQL runtime to controller for logging
       initializer 'graphql.log_runtime' do
         require_relative './railties/controller_runtime'
         ActiveSupport.on_load(:action_controller) do
@@ -41,45 +65,77 @@ module Rails # :nodoc:
         end
       end
 
+      # Clean up GraphQL params from logger
+      initializer 'graphql.params_cleanup' do
+        key = 'start_processing.action_controller'
+        ActiveSupport::Notifications.subscribe(key) do |*, payload|
+          payload[:params].except!(*config.graphql.omit_parameters) \
+            if payload[:headers]['action_controller.instance'].is_a?(GraphQL::Controller)
+        end
+      end
+
+      # Copy filter params when they are not exclusively set for GraphQL
+      initializer 'graphql.params_filter' do |app|
+        config.after_initialize do
+          config.graphql.filter_parameters ||= app.config.filter_parameters
+        end
+      end
+
       # Backtrace cleaner for removing gem paths
       initializer 'graphql.backtrace_cleaner' do
         require_relative './railties/log_subscriber'
         ActiveSupport.on_load(:graphql) do
-          GraphQL::LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
+          LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
         end
       end
 
-      # Add reloader ability for files under 'app/graphql'
-      # TODO: Maybe improve to use rails auto loader
-      initializer 'graphql.reloader' do
-        Rails::GraphQL.eager_load!
-        ActiveSupport::Reloader.to_prepare do
-          Rails::GraphQL.type_map.use_checkpoint!
-          Rails::GraphQL.reload_ar_adapters!
-
-          Object.send(:remove_const, :GraphQL) if Object.const_defined?(:GraphQL)
+      # Add the GraphQL Global ID serializer to active job serializers
+      initializer 'graphql.global_id' do
+        ActiveSupport.on_load(:active_job) do
+          ActiveJob::Serializers.add_serializers(Rails::GraphQL::GlobalID::Serializer)
+        end
+      end
 
-          load "#{__dir__}/shortcuts.rb"
+      # Simply switch to hash output if rails is running on test mode
+      initializer 'graphql.tests' do
+        if Rails.env.test?
+          config.graphql.enable_string_collector = false
+          config.graphql.default_response_format = :hash
+        end
+      end
 
-          $LOAD_PATH.each do |path|
-            next unless path =~ %r{\/app\/graphql$}
-            Dir.glob("#{path}/**/*.rb").sort.each(&method(:load))
+      # Set GraphQL cache store same as rails default cache store, unless the
+      # default value is a Null Cache, then use the fallback instead
+      initializer 'graphql.cache', after: :initialize_cache do
+        config.graphql.cache ||= begin
+          if !::Rails.cache.is_a?(::ActiveSupport::Cache::NullStore)
+            ::Rails.cache
+          elsif config.graphql.cache_fallback.is_a?(Proc)
+            config.graphql.cache_fallback.call
+          else
+            config.graphql.cache_fallback
           end
-
-          GraphQL::Source.send(:build_pending!)
         end
       end
 
-      # initializer "active_record.set_reloader_hooks" do
-      #   ActiveSupport.on_load(:active_record) do
-      #     ActiveSupport::Reloader.before_class_unload do
-      #       if ActiveRecord::Base.connected?
-      #         ActiveRecord::Base.clear_cache!
-      #         ActiveRecord::Base.clear_reloadable_connections!
-      #       end
-      #     end
-      #   end
-      # end
+      # Properly setup how GraphQL reload itself
+      # TODO: Check proper support for Rails engines
+      initializer 'graphql.reloader', before: :load_config_initializers do |app|
+        next unless (path = app.root.join('app', 'graphql')).exist?
+
+        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?))
+        autoloader.push_dir(path, namespace: ::GraphQL)
+        config.watchable_dirs[path.to_s] = [:rb]
+
+        autoloader.on_unload do |_, value, _|
+          value.unregister! if value.is_a?(Helpers::Unregisterable)
+        end
+      end
     end
   end
 end

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

@@ -1,35 +1,23 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Base Generator
     #
     # 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)
-
-          app_class = Rails.application.class
-          source_name = app_class.respond_to?(:module_parent_name) \
-            ? :module_parent_name \
-            : :parent_name
-
-          app_class.send(source_name)
-        end
     end
   end
 end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    # = GraphQL Channel
+    #
+    # The channel helper methods that allow GraphQL to be performed on an
+    # Action Cable channel. It also provides structure fro working with
+    # subscriptions
+    module Channel
+      extend ActiveSupport::Concern
+
+      included do
+        # Each channel 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
+
+        # Set it up a callback after unsubscribed so that all the subscriptions
+        # can be properly unsubscribed
+        after_unsubscribe :gql_clear_subscriptions
+      end
+
+      # The default action of the helper to perform GraphQL requests. Any other
+      # action cab be added and use the granular methods here provided
+      def execute(data)
+        transmit(gql_request_response(data))
+      end
+
+      protected
+
+        # Identifies if the received request within +data+ should be threated as
+        # a compiled request
+        def gql_compiled_request?(*)
+          false
+        end
+
+        # Get the response of a request withing the given +data+
+        def gql_request_response(data)
+          xargs = gql_params(data)
+          schema, context, query = xargs.extract!(:schema, :context, :query).values
+
+          request = gql_request(schema)
+          request.context = context
+          request.execute(query, **xargs)
+
+          gql_merge_subscriptions(request)
+          gql_response(request)
+        end
+
+        # Merge the subscriptions in this channel and the ones that were added
+        # by the last request
+        def gql_merge_subscriptions(request)
+          gql_subscriptions.merge!(request.subscriptions)
+        end
+
+        # Properly format the response of the provided +request+ so it can be
+        # transmitted
+        def gql_response(request)
+          { result: request.response.as_json, more: request.subscriptions? }
+        end
+
+        # Build the necessary params from the provided data
+        def gql_params(data)
+          cache_key = gql_query_cache_key(
+            data['query_cache_key'],
+            data['query_cache_version'],
+          )
+
+          {
+            query: data['query'],
+            origin: self,
+            variables: gql_variables(data),
+            operation_name: data['operation_name'] || data['operationName'],
+            compiled: gql_compiled_request?(data),
+            context: gql_context(data),
+            schema: gql_schema(data),
+            hash: cache_key,
+            as: :hash,
+          }
+        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
+        def gql_request(schema = gql_schema)
+          @gql_request ||= ::Rails::GraphQL::Request.new(schema)
+        end
+
+        # Get the cache key of the query for persisted queries
+        def gql_query_cache_key(key = nil, version = nil)
+          CacheKey.new(key, version) if key.present?
+        end
+
+        # The schema on which the requests will be performed from
+        def gql_schema(*)
+          schema = self.class.gql_schema
+          schema = schema.constantize if schema.is_a?(String)
+          schema ||= gql_application_default_schema
+          return schema if schema.is_a?(Module) && schema < ::Rails::GraphQL::Schema
+
+          raise ExecutionError, (+<<~MSG).squish
+            Unable to find a valid schema for #{self.class.name},
+            defined value: #{schema.inspect}.
+          MSG
+        end
+
+        # Get the GraphQL context for a requests
+        # +ActionCable::Channel::Base#extract_action+
+        def gql_context(data)
+          { action: (data['action'] || :receive).to_sym }
+        end
+
+        # Get the GraphQL variables for a request
+        def gql_variables(data, variables = nil)
+          variables ||= data['variables']
+
+          case variables
+          when ::ActionController::Parameters then variables.permit!.to_h
+          when String then variables.present? ? JSON.parse(variables) : {}
+          when Hash   then variables
+          else {}
+          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?
+        end
+
+        # Remove one or more subscriptions
+        def gql_remove_subscriptions(*sids)
+          gql_schema.remove_subscriptions(*sids)
+        end
+
+        alias gql_remove_subscription gql_remove_subscriptions
+
+      private
+
+        # 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
+          self.class.gql_schema = klass
+        end
+    end
+  end
+end