Merge pull request #997 from code0-tech/357-setup-actioncable-for-graphql-subscriptions

Setup ActionCable for GraphQL subscriptions

Author: Taucher2003

app/channels/application_cable/channel.rb

@@ -2,5 +2,45 @@
 
 module ApplicationCable
   class Channel < ActionCable::Channel::Base
+    def subscribe_to_channel
+      with_context { super }
+    end
+
+    def perform_action(data)
+      with_context { super }
+    end
+
+    protected
+
+    def find_authentication(authorization)
+      return Sagittarius::Authentication.new(:none, nil) if authorization.blank?
+
+      token_type, token = authorization.split(' ', 2)
+
+      create_authentication(token_type, token)
+    end
+
+    def create_authentication(token_type, token)
+      case token_type
+      when 'Session'
+        Sagittarius::Authentication.new(:session, UserSession.find_by(token: token, active: true))
+      else
+        Sagittarius::Authentication.new(:invalid, nil)
+      end
+    end
+
+    def with_context(&block)
+      Code0::ZeroTrack::Context.with_context(
+        application: 'cable',
+        ip_address: request_ip,
+        &block
+      )
+    end
+
+    def request_ip
+      return unless connection.respond_to?(:env)
+
+      ::Rack::Request.new(connection.env).ip
+    end
   end
 end

app/channels/graphql_channel.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class GraphqlChannel < ApplicationCable::Channel
+  periodically :verify_authentication, every: 30.seconds
+
+  def subscribed
+    @token = params[:token]
+    @subscription_ids = []
+
+    verify_authentication
+  end
+
+  def execute(data)
+    result = SagittariusSchema.execute(
+      query: data['query'],
+      context: {
+        current_authentication: find_authentication(@token),
+        visibility_profile: :execution,
+        channel: self,
+      },
+      variables: data['variables'],
+      operation_name: data['operationName']
+    )
+
+    @subscription_ids << result.context[:subscription_id] if result.context[:subscription_id]
+
+    transmit({ result: result.to_h, more: result.subscription? })
+  end
+
+  def unsubscribed
+    @subscription_ids.each do |sid|
+      SagittariusSchema.subscriptions.delete_subscription(sid)
+    end
+  end
+
+  private
+
+  def verify_authentication
+    with_context do
+      authentication = find_authentication(@token)
+      return unless authentication.invalid? || authentication.none?
+
+      @subscription_ids.each { |sid| SagittariusSchema.subscriptions.delete_subscription(sid) }
+      reject
+    end
+  end
+end

app/graphql/sagittarius_schema.rb

@@ -4,15 +4,18 @@
 class SagittariusSchema < GraphQL::Schema
   mutation(Types::MutationType)
   query(Types::QueryType)
+  subscription(Types::SubscriptionType)
 
   default_max_page_size 50
   max_depth 20
   connections.add(ActiveRecord::Relation, Sagittarius::Graphql::StableConnection)
 
+  use GraphQL::Subscriptions::ActionCableSubscriptions
+
   # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
   use GraphQL::Dataloader
 
-  use GraphQL::Schema::Visibility, profiles: {
+  use GraphQL::Schema::Visibility, preload: true, profiles: {
     execution: {},
     types: {},
     docs: {},

app/graphql/subscriptions/base_subscription.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Subscriptions
+  class BaseSubscription < GraphQL::Schema::Subscription
+    argument_class Types::BaseArgument
+    field_class Types::BaseField
+    object_class Types::BaseObject
+
+    def current_authentication
+      context[:current_authentication]
+    end
+
+    def self.generate_payload_type
+      result = super
+      result.graphql_name("#{graphql_name}SubscriptionPayload")
+      result
+    end
+  end
+end

app/graphql/subscriptions/echo.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Subscriptions
+  class Echo < BaseSubscription
+    description <<~DOC
+      A subscription that does not perform any real updates.
+
+      This is expected to be used for testing of endpoints, to verify
+      that a user has subscription access.
+    DOC
+
+    argument :message,
+             type: GraphQL::Types::String,
+             required: false,
+             description: 'Message to return to the user.'
+
+    field :message,
+          type: GraphQL::Types::String,
+          null: true,
+          description: 'Message returned to the user.'
+
+    def subscribe(message: nil)
+      { message: message }
+    end
+
+    def update(*)
+      { message: object[:message] }
+    end
+  end
+end

app/graphql/types/subscription_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Types
+  class SubscriptionType < Types::BaseObject
+    description 'Root subscription type'
+
+    include Sagittarius::Graphql::MountSubscription
+
+    mount_subscription Subscriptions::Echo
+  end
+end

config.cable.ru

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'config/environment'
+Rails.application.eager_load!
+
+run ActionCable.server

config/cable.yml

@@ -1,10 +1,8 @@
 development:
-  adapter: async
+  adapter: postgresql
 
 test:
   adapter: test
 
 production:
-  adapter: redis
-  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
-  channel_prefix: sagittarius_production
+  adapter: postgresql

config/initializers/action_cable.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Rails.application.configure do
+  config.action_cable.disable_request_forgery_protection = true
+end

config/puma.rb

@@ -4,6 +4,8 @@
 # are invoked here are part of Puma's configuration DSL. For more information
 # about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
 
+require_relative 'environment'
+
 # Puma can serve each request in a thread from an internal thread pool.
 # The `threads` method setting takes two numbers: a minimum and maximum.
 # Any libraries that use thread pools should be configured to match