graphql-streaming 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d5ec7f6cbeb19b73697a7a70311260bd8a741316
-  data.tar.gz: 4fa0ca9c16f693ed294860248a55559ef8060471
+  metadata.gz: 2997980ed238638983e004e2291f16a5c5b4539c
+  data.tar.gz: 6f8e53cc1153a79f6560fc60a266b12f04e6d52e
 SHA512:
-  metadata.gz: 1b1ece8cadcbaf967a114bf782f96845cbc5600686278b3a443844a850031b8d935a251ce9cec70e4e16e38b78109a374029b81405aa6798ca69f351d2d68ede
-  data.tar.gz: 9a0e5d527a300ae45377bfdf12e6ea3538574f6c2b5b4fd7d2134f08e28b26e20075d8b6e9dc787207d7ce30f2e5981d8e87ba46b0b7b4891650a54f67b1a2b7
+  metadata.gz: 4f020c2238d33f5fb86ef144b14630baad9ea458535eb40465a0b7839c08b5fa68962e4097fc0e70efef18f1e79d1effab0e31ef58852092d133f411acec6b30
+  data.tar.gz: 98bc9d602d0cd84fa266f1e844e8840abdff20ed133c58c8a2a71c2af16fdacf215beb01300f4a18cbf4e5333d45cf4a4469f9e9e589fce9ce8d3d08dac62a47

data/README.md

@@ -1,4 +1,4 @@
-# Graphql::Streaming
+# GraphQL::Streaming [![Build Status](https://travis-ci.org/rmosolgo/graphql-streaming.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-streaming) [![Gem Version](https://badge.fury.io/rb/graphql-streaming.svg)](https://badge.fury.io/rb/graphql-streaming)
 
 Experimental tools for GraphQL over a long-lived connection, including `subscription`, `@defer` and `@stream`. ([demo](https://github.com/rmosolgo/graphql-ruby-stream-defer-demo))
 
@@ -82,29 +82,31 @@ The `onResponse` function will be called with GraphQL response after each patch
 
 You can use [Rails 5's `ActionCable`](http://edgeguides.rubyonrails.org/action_cable_overview.html) to send and receive GraphQL.
 
-In your channel, implement an action called `#fetch(data)` for executing GraphQL queries. It should add an `ActionCableCollector` as `context[:collector]`, using `data["query_id"]` from the client. For example:
+In your channel, implement an action called `#fetch(data)` for executing GraphQL queries. It should use `stream_graphql_query` using `data["query_id"]` from the client. For example:
 
 ```ruby
 class GraphqlChannel < ApplicationCable::Channel
-  # ...
+  include GraphQL::Streaming::ActionCableChannel
 
   def fetch(data)
     query_string = data["query"]
     variables = ensure_hash(data["variables"] || {})
-    context = {}
+    context = {
+      # ...
+    }
 
     # Get the query ID, which is added by the GraphQLChannel client
     query_id = data["query_id"]
-    # Get a broadcaster, which is the target for patches
-    broadcaster = ActionCable.server.broadcaster_for(channel_name)
-    # The collector passes patches on to the broadcaster
-    context[:collector] = GraphQL::Streaming::ActionCableCollector.new(query_id, broadcaster)
 
-    # Run the query
-    Schema.execute(query_string, variables: variables, context: context)
-
-    # Tell the client to stop listening for patches
-    context[:collector].close
+    # Make the query within a `stream_graphql_query` block
+    stream_graphql_query(query_id: query_id) do |stream_ctx|
+      # the block provides a subscriber and collector,
+      # merge them into your context:
+      merged_ctx = context.merge(stream_ctx)
+      # don't forget to prevent stale data
+      merged_ctx[:current_user].reload
+      GraphQL.execute(query_string, variables: variables, context: merged_ctx)
+    end
   end
 end
 ```
@@ -157,24 +159,17 @@ The `onResponse` handler will be called with the whole response _each time_ a pa
 The subscriber rides along with your query (as `context[:subscriber]`). It listens for triggers from the application, and when they happen, it re-evaluates the query and pushes an update over its channel.
 
 ```ruby
-# Get the query ID from the client
-query_id = data["query_id"]
-
-context = { current_user: user_from_session(session) }
-
-context[:subscriber] = GraphQL::Streaming::ActionCableSubscriber.new(self, query_id) do
-  # This block is called when a matching trigger occurs
-  context[:current_user].reload
-  Schema.execute(query_string, variables: variables, context: context)
-end
-
-Schema.execute(query_string, variables: variables, context: context)
-
+class GraphqlChannel < ApplicationCable::Channel
+  include GraphQL::Streaming::ActionCableChannel
 
-# If there are no outstanding subscriptions,
-# tell the client to stop listening for patches
-if !context[:subscriber].subscribed?
-  context[:collector].close
+  def fetch(data)
+    # ...
+    query_id = data["query_id"]
+    stream_graphql_query(query_id: query_id) do |stream_ctx|
+      stream_ctx[:subscriber] # => #<ActionCableSubscriber ... >
+      # ...
+    end
+  end
 end
 ```
 
@@ -227,6 +222,19 @@ would be updated by
 GraphQL::Streaming::ActionCableSubscriber.trigger(:post, {id: 1})
 ```
 
+#### Unsubscribing
+
+A client can unsubscribe from future patches with `.clear`. For example:
+
+```js
+// Subscribe to data from the server
+var queryHandle = App.graphqlChannel.fetch(queryString, queryVariables, onResponse)
+// Unsubscribe from server pushes
+App.graphqlChannel.clear(queryHandle)
+```
+
+No further patches will be sent to the client.
+
 ## Development
 
 - `bundle exec rake test` to run the tests
@@ -236,10 +244,11 @@ GraphQL::Streaming::ActionCableSubscriber.trigger(:post, {id: 1})
 
 - What happens to subscriptions when you redeploy or ActionCable loses its connection? Need to handle reconnecting in some way.
 - Handle errors in subscriber block
-- Improve middleware so you don't have to manually close `ActionCableCollector`s
 - Tests for JS?
 - Other platforms (Pusher, HTTP/2)?
-- Public alternative to `@channel.send(:transmit, payload)`?
+- Request features from ActionCable
+  - Public alternative to `@channel.send(:transmit, payload)`?
+  - Some way to stop certain streams (see monkey patches in action_cable_channel.rb)
 
 ## License
 

data/Rakefile

@@ -7,4 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :spec
+task default: :test

data/graphql-streaming.gemspec

@@ -5,7 +5,7 @@ require 'graphql/streaming/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "graphql-streaming"
-  spec.version       = Graphql::Streaming::VERSION
+  spec.version       = GraphQL::Streaming::VERSION
   spec.authors       = ["Robert Mosolgo"]
   spec.email         = ["rdmosolgo@gmail.com"]
 

data/lib/graphql/streaming/action_cable_channel.rb

@@ -0,0 +1,71 @@
+module GraphQL
+  module Streaming
+    # TODO: This contains MONKEYPATCHES to support stopping certain streams
+    module ActionCableChannel
+      # MONKEY PATCH
+      # Return the newly-created stream, so you can stop it later
+      def stream_from(*args, &block)
+        super
+        streams.last
+      end
+
+      # Stop streams which were captured from stream_from
+      def stop_specific_streams(streams_to_stop)
+        @_streams -= streams_to_stop
+        streams_to_stop.each do |broadcasting, callback|
+          pubsub.unsubscribe broadcasting, callback
+          logger.info "#{self.class.name} stopped streaming from #{broadcasting}"
+        end
+        nil
+      end
+
+      # Work around the fact that `transmit` is private
+      def send_graphql_payload(payload)
+        transmit(payload)
+      end
+
+      private
+
+      # Setup a subscriber and collector and yield them to the block
+      def stream_graphql_query(query_id:, &query_exec)
+        # This object emits patches
+        collector = GraphQL::Streaming::ActionCableCollector.new(self, query_id)
+
+        # This re-evals the query in response to triggers
+        subscriber = GraphQL::Streaming::ActionCableSubscriber.new(self, query_id) do
+          # No subscriber so we don't re-subscribe
+          reeval_stream_ctx = { collector: collector }
+          query_exec.call(reeval_stream_ctx)
+        end
+
+        graphql_queries[query_id] << collector
+        graphql_queries[query_id] << subscriber
+
+        stream_ctx = {
+          collector: collector,
+          subscriber: subscriber,
+        }
+        # make the first GraphQL call
+        query_exec.call(stream_ctx)
+
+        if !subscriber.subscribed?
+          # If there are no ongoing subscriptions,
+          # tell the client to stop listening for patches
+          clear_graphql_query(query_id)
+        end
+      end
+
+      # Remove any subscriptions or collectors for this query
+      def clear_graphql_query(query_id)
+        graphql_queries[query_id].map(&:close)
+        graphql_queries[query_id].clear
+      end
+
+      # A registry of queries for this channel,
+      # keys are query_ids, values are subscribers or collectors
+      def graphql_queries
+        @graphql_queries ||= Hash.new { |h, k| h[k] = [] }
+      end
+    end
+  end
+end

data/lib/graphql/streaming/action_cable_collector.rb

@@ -38,31 +38,35 @@ module GraphQL
     class ActionCableCollector
       # @param [String] A unique identifier for this query (probably provided by the client)
       # @param [ActionCable::Server::Broadcasting::Broadcaster] The broadcast target for GraphQL's patches
-      def initialize(query_id, broadcaster)
+      def initialize(channel, query_id)
         @query_id = query_id
-        @broadcaster = broadcaster
+        @channel = channel
+        @closed = false
       end
 
       # Implements the "collector" API for DeferredExecution.
       # Sends `{patch: {...}, query_id: @query_id}` over `@broadcaster`.
       # @return [void]
       def patch(path:, value:)
-        @broadcaster.broadcast({
-          query_id: @query_id,
-          patch: {
-            path: path,
-            value: value,
-          },
-        })
+        if !@closed
+          @channel.send_graphql_payload({
+            query_id: @query_id,
+            patch: {
+              path: path,
+              value: value,
+            },
+          })
+        end
       end
 
       # Broadcast a message to terminate listeners on this query
       # @return [void]
       def close
-        @broadcaster.broadcast({
+        @channel.send_graphql_payload({
           query_id: @query_id,
           close: true,
         })
+        @closed = true
       end
     end
   end

data/lib/graphql/streaming/action_cable_subscriber.rb

@@ -29,9 +29,9 @@ module GraphQL
         @query_id = query_id
         @query_exec = query_exec
         @subscribed = false
+        @own_streams = []
       end
 
-
       # Trigger an event with arguments
       #
       # @example Trigger post_changed
@@ -45,22 +45,19 @@ module GraphQL
         ActionCable.server.broadcast("#{CHANNEL_PREFIX}#{subscription_handle}", trigger_options)
       end
 
+      # Subscribe to event named `subscription_handle`, but only
+      # when called with arguments `arguments`
+      # @param [String] the event name to subscribe to
+      # @param [Hash] the arguments to subscribe to
       def register(subscription_handle, arguments)
         @subscribed = true
+        handle = "#{CHANNEL_PREFIX}#{subscription_handle}"
         original_args = stringify_hash(arguments)
 
-        @channel.stream_from("#{CHANNEL_PREFIX}#{subscription_handle}") do |trigger_json|
+        @own_streams << @channel.stream_from(handle) do |trigger_json|
           trigger_args = JSON.parse(trigger_json)
           if original_args == trigger_args
-            payload = {
-              patch: {
-                path: [],
-                value: @query_exec.call,
-              },
-              query_id: @query_id,
-            }
-            # TODO: request public method for this?
-            @channel.send(:transmit, payload)
+            reevaluate_query
           end
         end
       end
@@ -70,8 +67,31 @@ module GraphQL
         @subscribed
       end
 
+      # Tell this subscriber to stop sending patches
+      # @return [void]
+      def close
+        @channel.stop_specific_streams(@own_streams)
+        @own_streams.clear
+        @subscribed = false
+        nil
+      end
+
       private
 
+      # Re-evaluate the given block
+      # and send the result as a patch to the
+      # root of the query result
+      def reevaluate_query
+        payload = {
+          patch: {
+            path: [],
+            value:  @query_exec.call,
+          },
+          query_id: @query_id,
+        }
+        @channel.send_graphql_payload(payload)
+      end
+
       def stringify_hash(value)
         case value
         when Hash

data/lib/graphql/streaming/clients/graphql-streaming/graphql_channel.js

@@ -30,6 +30,7 @@ var GraphQLChannel = {
       }
     },
 
+    // @return [Any] A handle for cancelling this query
     fetch: function(queryString, variables, onResponse) {
       var queryId = GraphQLChannel._getQueryId()
       GraphQLChannel.registry.set(queryId, onResponse)
@@ -40,6 +41,21 @@ var GraphQLChannel = {
         variables: JSON.stringify(variables),
         query_id: queryId,
       })
+      return queryId
+    },
+
+    // Unsubscribe from any future patches
+    //
+    // @example Ignoring any subscription or deferred fields
+    //    var queryHandle = App.GraphqlChannel.fetch(/* ... */)
+    //    App.GraphqlChannel.clear(queryHandle)
+    //
+    // @param [Any] a handle returned by `fetch`
+    // @return void
+    clear: function(queryId) {
+      GraphQLChannel.log("[GraphQLChannel clearing]", queryId)
+      GraphQLChannel.registry.unset(queryId)
+      this.perform("clear", {query_id: queryId})
     }
   },
 

data/lib/graphql/streaming/version.rb

@@ -1,5 +1,5 @@
-module Graphql
+module GraphQL
   module Streaming
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/graphql/streaming.rb

@@ -1,5 +1,6 @@
 require "graphql"
 require "graphql/streaming/action_cable_collector"
+require "graphql/streaming/action_cable_channel"
 require "graphql/streaming/action_cable_subscriber"
 require "graphql/streaming/assign_subscription_field"
 require "graphql/streaming/stream_collector"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-streaming
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-10 00:00:00.000000000 Z
+date: 2016-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -83,6 +83,7 @@ files:
 - bin/setup
 - graphql-streaming.gemspec
 - lib/graphql/streaming.rb
+- lib/graphql/streaming/action_cable_channel.rb
 - lib/graphql/streaming/action_cable_collector.rb
 - lib/graphql/streaming/action_cable_subscriber.rb
 - lib/graphql/streaming/assign_subscription_field.rb