graphql-anycable 0.5.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c831aba1f67077cccb4ef5f1b7858715cf056e554551dab59acdf265a8c671e
-  data.tar.gz: 5049b208e8a02a2e110e698f5336a1314577d2e1f8a37742ce07807daac6e41a
+  metadata.gz: a0437da8b1214b8c5aa81733cd8b0b4449a527f9d7f487e3d0e97034ffefea2e
+  data.tar.gz: ef6d5a734dfc73824e2a37e7b3d3bcd47eb3af597b99a9d91a7aa41c7fc85797
 SHA512:
-  metadata.gz: d9451177ced38d8f963fe8b7f4c5b8ae1933a1d9730403202ee0864f23b3649752e538f8e480aedcae042aac2958b60145dc1305b79e67a3e480a96279df2bb1
-  data.tar.gz: 1367ac8df59b0470725197da7be2701175cb8571146f81eaa896dd00b3052eee1f91e2abdabdf67bb5a18754385e11169d942864a65e1fb59cdb7f8afdd5938e
+  metadata.gz: eae7c1026142f0d4360d556af37eeae4937e9cde79bf0e05a8aed6a3dac9e40a6445f7970b11bc9c8a25def13ee42d1c0507452d6c168805452dc9a7d8fb1c30
+  data.tar.gz: f2985e19bad56f101099ca1da605f0eb62b606034d595530c86bbd672b146b65ef7f54212813fdf110dba961dfaa14e400bab390505828b4a8dc7fa289039155

data/.github/workflows/build-release.yml

@@ -1,4 +1,4 @@
-name: Build and release gem to RubyGems
+name: Build and release gem
 
 on:
   push:
@@ -21,16 +21,26 @@ jobs:
           git fetch --tags --force # Really fetch annotated tag. See https://github.com/actions/checkout/issues/290#issuecomment-680260080
           echo ::set-output name=version::${GITHUB_REF#refs/tags/v}
           echo ::set-output name=subject::$(git for-each-ref $GITHUB_REF --format='%(contents:subject)')
-          # Multiline body for release. See https://github.community/t/set-output-truncates-multiline-strings/16852/5
           BODY="$(git for-each-ref $GITHUB_REF --format='%(contents:body)')"
+          # Extract changelog entries between this and previous version headers
+          escaped_version=$(echo ${GITHUB_REF#refs/tags/v} | sed -e 's/[]\/$*.^[]/\\&/g')
+          changelog=$(awk "BEGIN{inrelease=0} /## ${escaped_version}/{inrelease=1;next} /## [0-9]+\.[0-9]+\.[0-9]+/{inrelease=0;exit} {if (inrelease) print}" CHANGELOG.md)
+          # Multiline body for release. See https://github.community/t/set-output-truncates-multiline-strings/16852/5
+          BODY="${BODY}"$'\n'"${changelog}"
           BODY="${BODY//'%'/'%25'}"
           BODY="${BODY//$'\n'/'%0A'}"
           BODY="${BODY//$'\r'/'%0D'}"
           echo "::set-output name=body::$BODY"
+          # Add pre-release option if tag name has any suffix after vMAJOR.MINOR.PATCH
+          if [[ ${GITHUB_REF#refs/tags/} =~ ^v[0-9]+\.[0-9]+\.[0-9]+.+ ]]; then
+            echo ::set-output name=prerelease::true
+          fi
       - name: Build gem
         run: gem build
+      - name: Calculate checksums
+        run: sha256sum graphql-anycable-${{ steps.tag.outputs.version }}.gem > SHA256SUM
       - name: Check version
-        run: ls graphql-anycable-${{ steps.tag.outputs.version }}.gem
+        run: ls -l graphql-anycable-${{ steps.tag.outputs.version }}.gem
       - name: Create Release
         id: create_release
         uses: actions/create-release@v1
@@ -41,9 +51,8 @@ jobs:
           release_name: ${{ steps.tag.outputs.subject }}
           body: ${{ steps.tag.outputs.body }}
           draft: false
-          prerelease: false
-      - name: Upload Release Asset
-        id: upload-release-asset
+          prerelease: ${{ steps.tag.outputs.prerelease }}
+      - name: Upload built gem as release asset
         uses: actions/upload-release-asset@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -52,13 +61,22 @@ jobs:
           asset_path: graphql-anycable-${{ steps.tag.outputs.version }}.gem
           asset_name: graphql-anycable-${{ steps.tag.outputs.version }}.gem
           asset_content_type: application/x-tar
-      - name: Install publish prerequisites
+      - name: Upload checksums as release asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: SHA256SUM
+          asset_name: SHA256SUM
+          asset_content_type: text/plain
+      - name: Publish to GitHub packages
+        env:
+          GEM_HOST_API_KEY: Bearer ${{ secrets.GITHUB_TOKEN }}
         run: |
-          sudo apt-get update
-          sudo apt-get install oathtool
+          gem push graphql-anycable-${{ steps.tag.outputs.version }}.gem --host https://rubygems.pkg.github.com/${{ github.repository_owner }}
       - name: Publish to RubyGems
         env:
           GEM_HOST_API_KEY: "${{ secrets.RUBYGEMS_API_KEY }}"
-          RUBYGEMS_OTP_KEY: "${{ secrets.RUBYGEMS_OTP_KEY }}"
         run: |
-          gem push graphql-anycable-${{ steps.tag.outputs.version }}.gem --otp=$(oathtool --totp --base32 $RUBYGEMS_OTP_KEY)
+          gem push graphql-anycable-${{ steps.tag.outputs.version }}.gem

data/.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: Run tests
+name: Tests
 
 on:
   pull_request:
@@ -10,36 +10,26 @@ on:
 
 jobs:
   test:
-    name: "Run tests"
-    if: "! contains(toJSON(github.event.commits.latest.message), '[ci skip]')"
+    name: "GraphQL-Ruby ${{ matrix.graphql }} (interpreter: ${{ matrix.interpreter }} with AnyCable ${{ matrix.anycable }}, use_client_id: ${{ matrix.client_id }}) on Ruby ${{ matrix.ruby }}"
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
         include:
-          - ruby: 2.7
-            graphql: '~> 1.11.0'
-            anycable: '~> 1.0.0'
+          - ruby: "3.0"
+            graphql: '~> 1.12.0'
+            anycable: '~> 1.1.0'
+            client_id: 'false'
             interpreter: yes
           - ruby: 2.7
-            graphql: '~> 1.11.0'
-            anycable: '~> 1.0.0'
-            interpreter: no
-          - ruby: 2.6
-            graphql: '~> 1.10.0'
-            anycable: '~> 1.0.0'
+            graphql: '~> 1.12.0'
+            anycable: '~> 1.1.0'
+            client_id: 'false'
             interpreter: yes
           - ruby: 2.6
-            graphql: '~> 1.10.0'
+            graphql: '~> 1.11.0'
             anycable: '~> 1.0.0'
-            interpreter: no
-          - ruby: 2.5
-            graphql: '~> 1.9.0'
-            anycable: '~> 0.6.0'
-            interpreter: yes
-          - ruby: 2.5
-            graphql: '~> 1.9.0'
-            anycable: '~> 0.6.0'
+            client_id: 'true'
             interpreter: no
     container:
       image: ruby:${{ matrix.ruby }}
@@ -47,6 +37,7 @@ jobs:
         CI: true
         GRAPHQL_RUBY_VERSION: ${{ matrix.graphql }}
         ANYCABLE_VERSION: ${{ matrix.anycable }}
+        GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID: ${{ matrix.client_id }}
     steps:
       - uses: actions/checkout@v2
       - uses: actions/cache@v2

data/CHANGELOG.md

@@ -5,6 +5,98 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+## 1.1.1 - 2021-12-06
+
+### Fixed
+
+- Handling of buggy istate values on unsubscribe (when `use_client_provided_uniq_id: false`). [@palkan] [#20](https://github.com/anycable/graphql-anycable/pull/20)
+- A bug when `#unsubscribe` happens before `#execute`. [@palkan] [#20](https://github.com/anycable/graphql-anycable/pull/20)
+
+## 1.1.0 - 2021-11-17
+
+### Added
+
+- Support for generating unique channel IDs server-side and storing them in the channel states.
+
+  Currently, we rely on `params["channelId"]` to track subscriptions. This value is random when using `graphql-ruby` JS client, but is not guaranteed to be random in general.
+
+  Now you can opt-in to use server-side IDs by specifying `use_client_provided_uniq_id: false` in YAML config or thru the `GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID=false` env var.
+
+  NOTE: Relying on client-side IDs is deprecated and will be removed in the future versions.
+
+  You must also update your cleanup code in the `Channel#unsubscribed`:
+
+```diff
+-        channel_id = params.fetch("channelId")
+-        MySchema.subscriptions.delete_channel_subscriptions(channel_id)
++        MySchema.subscriptions.delete_channel_subscriptions(self)
+```
+
+## 1.0.1 - 2021-04-16
+
+### Added
+
+ - Guard check for presence of ActionCable channel instance in the GraphQL execution context.
+
+   This allows to detect wrong configuration (user forgot to pass channel into context) or wrong usage (subscription query was sent via HTTP request, not via WebSocket channel) of the library and provides clear error message to gem users.
+
+## 1.0.0 - 2021-04-01
+
+### Added
+
+ - Support for [Subscriptions Broadcast](https://graphql-ruby.org/subscriptions/broadcast.html) feature in GraphQL-Ruby 1.11+. [@Envek] ([#15](https://github.com/anycable/graphql-anycable/pull/15))
+
+### Changed
+
+ - Subscription data storage format changed to support broadcasting feature (see [#15](https://github.com/anycable/graphql-anycable/pull/15))
+
+### Removed
+
+ - Drop support for GraphQL-Ruby before 1.11
+
+ - Drop support for AnyCable before 1.0
+
+ - Drop `:action_cable_stream` option from context: it is not used in reality.
+
+   See [rmosolgo/graphql-ruby#3076](https://github.com/rmosolgo/graphql-ruby/pull/3076) for details
+
+### Upgrading notes
+
+ 1. Change method of plugging in of this gem from `use GraphQL::Subscriptions::AnyCableSubscriptions` to `use GraphQL::AnyCable`:
+
+    ```ruby
+    use GraphQL::AnyCable
+    ```
+
+    If you need broadcasting, add `broadcast: true` option and ensure that [Interpreter mode](https://graphql-ruby.org/queries/interpreter.html) is enabled.
+
+    ```ruby
+    use GraphQL::Execution::Interpreter
+    use GraphQL::Analysis::AST
+    use GraphQL::AnyCable, broadcast: true, default_broadcastable: true
+    ```
+
+ 2. Enable `handle_legacy_subscriptions` setting for seamless upgrade from previous versions:
+
+    ```sh
+    GRAPHQL_ANYCABLE_HANDLE_LEGACY_SUBSCRIPTIONS=true
+    ```
+
+    Disable or remove this setting when you sure that all clients has re-subscribed (e.g. after `subscription_expiration_seconds` has passed after upgrade) as it imposes small performance penalty.
+
+## 0.5.0 - 2020-08-26
+
+### Changed
+
+ - Allow to plug in this gem by calling `use GraphQL::AnyCable` instead of `use GraphQL::Subscriptions::AnyCableSubscriptions`. [@Envek]
+ - Rename `GraphQL::Anycable` constant to `GraphQL::AnyCable` for consistency with AnyCable itself. [@Envek]
+
+## 0.4.2 - 2020-08-25
+
+Technical release to test publishing via GitHub Actions.
+
 ## 0.4.1 - 2020-08-21
 
 ### Fixed
@@ -57,3 +149,4 @@ Initial version: store subscriptions on redis, re-execute queries in sync. [@Env
 [@bibendi]: https://github.com/bibendi "Misha Merkushin"
 [@FX-HAO]: https://github.com/FX-HAO "Fuxin Hao"
 [@Envek]: https://github.com/Envek "Andrey Novikov"
+[@palkan]: https://github.com/palkan "Vladimir Dementyev"

data/Gemfile

@@ -7,8 +7,9 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 # Specify your gem's dependencies in graphql-anycable.gemspec
 gemspec
 
-gem "graphql",  ENV.fetch("GRAPHQL_RUBY_VERSION", "~> 1.11")
+gem "graphql",  ENV.fetch("GRAPHQL_RUBY_VERSION", "~> 1.12")
 gem "anycable", ENV.fetch("ANYCABLE_VERSION", "~> 1.0")
+gem "anycable-rails", ENV.fetch("ANYCABLE_VERSION", "~> 1.0"), require: false
 
 group :development, :test do
   gem "pry"

data/README.md

@@ -3,6 +3,7 @@
 A (mostly) drop-in replacement for default ActionCable subscriptions adapter shipped with [graphql gem] but works with [AnyCable]!
 
 [![Gem Version](https://badge.fury.io/rb/graphql-anycable.svg)](https://badge.fury.io/rb/graphql-anycable)
+[![Tests](https://github.com/anycable/graphql-anycable/actions/workflows/test.yml/badge.svg)](https://github.com/anycable/graphql-anycable/actions/workflows/test.yml)
 
 <a href="https://evilmartians.com/?utm_source=graphql-anycable&utm_campaign=project_page">
 <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
@@ -33,7 +34,7 @@ AnyCable must be configured with redis broadcast adapter (this is default).
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'graphql-anycable'
+gem 'graphql-anycable', '~> 1.0'
 ```
 
 And then execute:
@@ -50,7 +51,7 @@ Or install it yourself as:
  
     ```ruby
     class MySchema < GraphQL::Schema
-      use GraphQL::AnyCable
+      use GraphQL::AnyCable, broadcast: true
     
       subscription SubscriptionType
     end
@@ -76,8 +77,7 @@ Or install it yourself as:
       end
     
       def unsubscribed
-        channel_id = params.fetch("channelId")
-        MySchema.subscriptions.delete_channel_subscriptions(channel_id)
+        MySchema.subscriptions.delete_channel_subscriptions(self)
       end
     
       private
@@ -99,6 +99,28 @@ Or install it yourself as:
     MySchema.subscriptions.trigger(:product_updated, {}, Product.first!, scope: account.id)
     ```
 
+## Broadcasting
+
+By default, graphql-anycable evaluates queries and transmits results for every subscription client individually. Of course, it is a waste of resources if you have hundreds or thousands clients subscribed to the same data (and has huge negative impact on performance).
+
+Thankfully, GraphQL-Ruby has added [Subscriptions Broadcast](https://graphql-ruby.org/subscriptions/broadcast.html) feature that allows to group exact same subscriptions, execute them and transmit results only once.
+
+To enable this feature, turn on [Interpreter](https://graphql-ruby.org/queries/interpreter.html) and pass `broadcast` option set to `true` to graphql-anycable.
+
+By default all fields are marked as _not safe for broadcasting_. If a subscription has at least one non-broadcastable field in its query, GraphQL-Ruby will execute every subscription for every client independently. If you sure that all your fields are safe to be broadcasted, you can pass `default_broadcastable` option set to `true` (but be aware that it can have security impllications!)
+
+```ruby
+class MySchema < GraphQL::Schema
+  use GraphQL::Execution::Interpreter # Required for graphql-ruby before 1.12.4
+  use GraphQL::Analysis::AST
+  use GraphQL::AnyCable, broadcast: true, default_broadcastable: true
+
+  subscription SubscriptionType
+end
+```
+
+See GraphQL-Ruby [broadcasting docs](https://graphql-ruby.org/subscriptions/broadcast.html) for more details.
+
 ## Operations
 
 To avoid filling Redis storage with stale subscription data:
@@ -118,6 +140,8 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
     ```.env
     GRAPHQL_ANYCABLE_SUBSCRIPTION_EXPIRATION_SECONDS=604800
     GRAPHQL_ANYCABLE_USE_REDIS_OBJECT_ON_CLEANUP=true
+    GRAPHQL_ANYCABLE_HANDLE_LEGACY_SUBSCRIPTIONS=false
+    GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID=false
     ```
 
  2. YAML configuration files:
@@ -127,6 +151,8 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
     production:
       subscription_expiration_seconds: 300 # 5 minutes
       use_redis_object_on_cleanup: false # For restricted redis installations
+      handle_legacy_subscriptions: false # For seamless upgrade from pre-1.0 versions
+      use_client_provided_uniq_id: false # To avoid problems with non-uniqueness of Apollo channel identifiers
     ```
 
  3. Configuration from your application code:
@@ -143,39 +169,46 @@ And any other way provided by [anyway_config]. Check its documentation!
 
 As in AnyCable there is no place to store subscription data in-memory, it should be persisted somewhere to be retrieved on `GraphQLSchema.subscriptions.trigger` and sent to subscribed clients. `graphql-anycable` uses the same Redis database as AnyCable itself.
 
- 1. Event subscriptions: `graphql-event:#{event.topic}` set containing identifiers for all subscriptions for given operation with certain context and arguments (serialized in _topic_). Used to find all subscriptions on `GraphQLSchema.subscriptions.trigger`.
+ 1. Grouped event subscriptions: `graphql-fingerprints:#{event.topic}` sorted set. Used to find all subscriptions on `GraphQLSchema.subscriptions.trigger`.
 
     ```
-    SMEMBERS graphql-event:1:myStats:
+    ZREVRANGE graphql-fingerprints:1:myStats: 0 -1
+    => 1:myStats:/MyStats/fBDZmJU1UGTorQWvOyUeaHVwUxJ3T9SEqnetj6SKGXc=/0/RBNvo1WzZ4oRRq0W9-hknpT7T8If536DEMBg9hyq_4o=
+    ```
+
+ 2. Event subscriptions: `graphql-subscriptions:#{event.fingerptint}` set containing identifiers for all subscriptions for given operation with certain context and arguments (serialized in _topic_). Fingerprints are already scoped by topic.
+
+    ```
+    SMEMBERS graphql-subscriptions:1:myStats:/MyStats/fBDZmJU1UGTorQWvOyUeaHVwUxJ3T9SEqnetj6SKGXc=/0/RBNvo1WzZ4oRRq0W9-hknpT7T8If536DEMBg9hyq_4o=
     => 52ee8d65-275e-4d22-94af-313129116388
     ```
 
- 2. Subscription data: `graphql-subscription:#{subscription_id}` hash contains everything required to evaluate subscription on trigger and create data for client.
+    > For backward compatibility with pre-1.0 versions of this gem older `graphql-event:#{event.topic}` set containing subscription identifiers is also supported.
+    >
+    > ```
+    > SMEMBERS graphql-event:1:myStats:
+    > => 52ee8d65-275e-4d22-94af-313129116388
+    > ```
+
+ 3. Subscription data: `graphql-subscription:#{subscription_id}` hash contains everything required to evaluate subscription on trigger and create data for client.
 
     ```
     HGETALL graphql-subscription:52ee8d65-275e-4d22-94af-313129116388
     => {
-      context:        '{"user_id":1,"user":{"__gid__":"Z2lkOi8vZWJheS1tYWcyL1VzZXIvMQ"},"subscription_id":"52ee8d65-275e-4d22-94af-313129116388\","action_cable_stream":"graphql-subscription:52ee8d65-275e-4d22-94af-313129116388",}',
+      context:        '{"user_id":1,"user":{"__gid__":"Z2lkOi8vZWJheS1tYWcyL1VzZXIvMQ"}}',
       variables:      '{}',
       operation_name: 'MyStats'
       query_string:   'subscription MyStats { myStatsUpdated { completed total processed __typename } }',
     }
     ```
 
- 3. Channel subscriptions: `graphql-channel:#{channel_id}` set containing identifiers for subscriptions created in ActionCable channel to delete them on client disconnect.
+ 4. Channel subscriptions: `graphql-channel:#{channel_id}` set containing identifiers for subscriptions created in ActionCable channel to delete them on client disconnect.
 
     ```
     SMEMBERS graphql-channel:17420c6ed9e
     => 52ee8d65-275e-4d22-94af-313129116388
     ```
 
- 4. Subscription events: `graphql-subscription-events:#{subscription_id}` set containing event topics to delete subscription identifier from event subscriptions set on unsubscribe (or client disconnect).
-
-    ```
-    SMEMBERS graphql-subscription-events:52ee8d65-275e-4d22-94af-313129116388
-    => 1:myStats:
-    ```
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/graphql-anycable.gemspec

@@ -26,13 +26,16 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "anycable",      ">= 0.6.0", "< 2"
+  spec.add_dependency "anycable",      "~> 1.0"
   spec.add_dependency "anyway_config", ">= 1.3", "< 3"
-  spec.add_dependency "graphql",       "~> 1.8"
+  spec.add_dependency "graphql",       "~> 1.11"
   spec.add_dependency "redis",         ">= 4.2.0"
 
+  spec.add_development_dependency "anycable-rails"
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "fakeredis"
+  spec.add_development_dependency "rack"
+  spec.add_development_dependency "railties"
   spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/graphql/anycable/cleaner.rb

@@ -9,6 +9,8 @@ module GraphQL
         clean_channels
         clean_subscriptions
         clean_events
+        clean_fingerprint_subscriptions
+        clean_topic_fingerprints
       end
 
       def clean_channels
@@ -36,6 +38,8 @@ module GraphQL
       end
 
       def clean_events
+        return unless config.handle_legacy_subscriptions
+
         redis.scan_each(match: "#{adapter::SUBSCRIPTION_EVENTS_PREFIX}*") do |key|
           subscription_id = key.sub(/\A#{adapter::SUBSCRIPTION_EVENTS_PREFIX}/, "")
           next if redis.exists?(adapter::SUBSCRIPTION_PREFIX + subscription_id)
@@ -48,6 +52,27 @@ module GraphQL
         end
       end
 
+      def clean_fingerprint_subscriptions
+        redis.scan_each(match: "#{adapter::SUBSCRIPTIONS_PREFIX}*") do |key|
+          redis.smembers(key).each do |subscription_id|
+            next if redis.exists?(adapter::SUBSCRIPTION_PREFIX + subscription_id)
+
+            redis.srem(key, subscription_id)
+          end
+        end
+      end
+
+      def clean_topic_fingerprints
+        redis.scan_each(match: "#{adapter::FINGERPRINTS_PREFIX}*") do |key|
+          redis.zremrangebyscore(key, '-inf', '0')
+          redis.zrange(key, 0, -1).each do |fingerprint|
+            next if redis.exists?(adapter::SUBSCRIPTIONS_PREFIX + fingerprint)
+
+            redis.zrem(key, fingerprint)
+          end
+        end
+      end
+
       private
 
       def adapter

data/lib/graphql/anycable/config.rb

@@ -10,6 +10,16 @@ module GraphQL
 
       attr_config subscription_expiration_seconds: nil
       attr_config use_redis_object_on_cleanup: true
+      attr_config handle_legacy_subscriptions: false
+      attr_config use_client_provided_uniq_id: true
+
+      on_load do
+        next unless use_client_provided_uniq_id?
+
+        warn "[Deprecated] Using client provided channel uniq IDs could lead to unexpected behaviour, " \
+             " please, set GraphQL::AnyCable.config.use_client_provided_uniq_id = false or GRAPHQL_ANYCABLE_USE_CLIENT_PROVIDED_UNIQ_ID=false, " \
+             " and update the `#unsubscribed` callback code according to the latest docs."
+      end
     end
   end
 end

data/lib/graphql/anycable/errors.rb

@@ -0,0 +1,20 @@
+module GraphQL
+  module AnyCable
+    # This error is thrown when ActionCable channel wasn't provided to subscription implementation.
+    # Typical cases:
+    #  1. application developer forgot to pass ActionCable channel into context
+    #  2. subscription query was sent via usual HTTP request, not websockets as intended
+    class ChannelConfigurationError < ::RuntimeError
+      def initialize(msg = nil)
+        super(msg || <<~DEFAULT_MESSAGE)
+          ActionCable channel wasn't provided in the context for GraphQL query execution!
+
+          This can occur in the following cases:
+           1. ActionCable channel instance wasn't passed into GraphQL execution context in the channel's execute method.
+              See https://github.com/anycable/graphql-anycable#usage
+           2. Subscription query was sent via usual HTTP request, not via WebSocket as intended
+        DEFAULT_MESSAGE
+      end
+    end
+  end
+end

data/lib/graphql/anycable/tasks/clean_expired_subscriptions.rake

@@ -5,10 +5,7 @@ require "graphql-anycable"
 namespace :graphql do
   namespace :anycable do
     desc "Clean up stale graphql channels, subscriptions, and events from redis"
-    task clean: %i[clean:channels clean:subscriptions clean:events]
-
-    # Old name that was used earlier
-    task clean_expired_subscriptions: :clean
+    task clean: %i[clean:channels clean:subscriptions clean:events clean:fingerprint_subscriptions clean:topic_fingerprints]
 
     namespace :clean do
       # Clean up old channels
@@ -21,10 +18,20 @@ namespace :graphql do
         GraphQL::AnyCable::Cleaner.clean_subscriptions
       end
 
-      # Clean up subscription_ids from events for expired subscriptions
+      # Clean up legacy subscription_ids from events for expired subscriptions
       task :events do
         GraphQL::AnyCable::Cleaner.clean_events
       end
+
+      # Clean up subscription_ids from event fingerprints for expired subscriptions
+      task :fingerprint_subscriptions do
+        GraphQL::AnyCable::Cleaner.clean_fingerprint_subscriptions
+      end
+
+      # Clean up fingerprints from event topics. for expired subscriptions
+      task :topic_fingerprints do
+        GraphQL::AnyCable::Cleaner.clean_topic_fingerprints
+      end
     end
   end
 end

data/lib/graphql/anycable/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module AnyCable
-    VERSION = "0.5.0"
+    VERSION = "1.1.1"
   end
 end

data/lib/graphql/subscriptions/anycable_subscriptions.rb

@@ -2,6 +2,7 @@
 
 require "anycable"
 require "graphql/subscriptions"
+require "graphql/anycable/errors"
 
 # rubocop: disable Metrics/AbcSize, Metrics/LineLength, Metrics/MethodLength
 
@@ -44,8 +45,7 @@ require "graphql/subscriptions"
 #     end
 #
 #     def unsubscribed
-#       channel_id = params.fetch("channelId")
-#       MySchema.subscriptions.delete_channel_subscriptions(channel_id)
+#       MySchema.subscriptions.delete_channel_subscriptions(self)
 #     end
 #   end
 #
@@ -56,10 +56,13 @@ module GraphQL
 
       def_delegators :"GraphQL::AnyCable", :redis, :config
 
-      SUBSCRIPTION_PREFIX = "graphql-subscription:"
-      SUBSCRIPTION_EVENTS_PREFIX = "graphql-subscription-events:"
+      SUBSCRIPTION_PREFIX  = "graphql-subscription:"  # HASH: Stores subscription data: query, context, …
+      FINGERPRINTS_PREFIX  = "graphql-fingerprints:"  # ZSET: To get fingerprints by topic
+      SUBSCRIPTIONS_PREFIX = "graphql-subscriptions:" # SET:  To get subscriptions by fingerprint
+      CHANNEL_PREFIX       = "graphql-channel:"       # SET:  Auxiliary structure for whole channel's subscriptions cleanup
+      # For backward compatibility:
       EVENT_PREFIX = "graphql-event:"
-      CHANNEL_PREFIX = "graphql-channel:"
+      SUBSCRIPTION_EVENTS_PREFIX = "graphql-subscription-events:"
 
       # @param serializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`
       def initialize(serializer: Serialize, **rest)
@@ -70,43 +73,102 @@ module GraphQL
       # An event was triggered.
       # Re-evaluate all subscribed queries and push the data over ActionCable.
       def execute_all(event, object)
+        execute_legacy(event, object) if config.handle_legacy_subscriptions
+
+        fingerprints = redis.zrange(FINGERPRINTS_PREFIX + event.topic, 0, -1)
+        return if fingerprints.empty?
+
+        fingerprint_subscription_ids = Hash[fingerprints.zip(
+          redis.pipelined do
+            fingerprints.map do |fingerprint|
+              redis.smembers(SUBSCRIPTIONS_PREFIX + fingerprint)
+            end
+          end
+        )]
+
+        fingerprint_subscription_ids.each do |fingerprint, subscription_ids|
+          execute_grouped(fingerprint, subscription_ids, event, object)
+        end
+
+        # Call to +trigger+ returns this. Convenient for playing in console
+        Hash[fingerprint_subscription_ids.map { |k,v| [k, v.size] }]
+      end
+
+      # The fingerprint has told us that this response should be shared by all subscribers,
+      # so just run it once, then deliver the result to every subscriber
+      def execute_grouped(fingerprint, subscription_ids, event, object)
+        return if subscription_ids.empty?
+
+        subscription_id = subscription_ids.find { |sid| redis.exists?(SUBSCRIPTION_PREFIX + sid) }
+        return unless subscription_id # All subscriptions has expired but haven't cleaned up yet
+
+        result = execute_update(subscription_id, event, object)
+        return unless result
+
+        # Having calculated the result _once_, send the same payload to all subscribers
+        deliver(SUBSCRIPTIONS_PREFIX + fingerprint, result)
+      end
+
+      # For migration from pre-1.0 graphql-anycable gem
+      def execute_legacy(event, object)
         redis.smembers(EVENT_PREFIX + event.topic).each do |subscription_id|
           next unless redis.exists?(SUBSCRIPTION_PREFIX + subscription_id)
-          execute(subscription_id, event, object)
+          result = execute_update(subscription_id, event, object)
+          next unless result
+
+          deliver(SUBSCRIPTION_PREFIX + subscription_id, result)
         end
       end
 
+      # Disable this method as there is no fingerprint (it can be retrieved from subscription though)
+      def execute(subscription_id, event, object)
+        raise NotImplementedError, "Use execute_all method instead of execute to get actual event fingerprint"
+      end
+
       # This subscription was re-evaluated.
       # Send it to the specific stream where this client was waiting.
-      def deliver(subscription_id, result)
-        payload = {result: result.to_h, more: true}
-        anycable.broadcast(SUBSCRIPTION_PREFIX + subscription_id, payload.to_json)
+      # @param strean_key [String]
+      # @param result [#to_h] result to send to clients
+      def deliver(stream_key, result)
+        payload = { result: result.to_h, more: true }.to_json
+        anycable.broadcast(stream_key, payload)
       end
 
       # Save query to "storage" (in redis)
       def write_subscription(query, events)
         context = query.context.to_h
-        subscription_id = context[:subscription_id] ||= build_id
+        subscription_id = context.delete(:subscription_id) || build_id
         channel = context.delete(:channel)
-        stream = context[:action_cable_stream] ||= SUBSCRIPTION_PREFIX + subscription_id
-        channel.stream_from(stream)
+
+        raise GraphQL::AnyCable::ChannelConfigurationError unless channel
+
+        channel_uniq_id = config.use_client_provided_uniq_id? ? channel.params["channelId"] : subscription_id
+
+        # Store subscription_id in the channel state to cleanup on disconnect
+        write_subscription_id(channel, channel_uniq_id)
+
+
+        events.each do |event|
+          channel.stream_from(SUBSCRIPTIONS_PREFIX + event.fingerprint)
+        end
 
         data = {
           query_string: query.query_string,
           variables: query.provided_variables.to_json,
           context: @serializer.dump(context.to_h),
-          operation_name: query.operation_name
+          operation_name: query.operation_name,
+          events: events.map { |e| [e.topic, e.fingerprint] }.to_h.to_json,
         }
 
         redis.multi do
-          redis.sadd(CHANNEL_PREFIX + channel.params["channelId"], subscription_id)
+          redis.sadd(CHANNEL_PREFIX + channel_uniq_id, subscription_id)
           redis.mapped_hmset(SUBSCRIPTION_PREFIX + subscription_id, data)
-          redis.sadd(SUBSCRIPTION_EVENTS_PREFIX + subscription_id, events.map(&:topic))
           events.each do |event|
-            redis.sadd(EVENT_PREFIX + event.topic, subscription_id)
+            redis.zincrby(FINGERPRINTS_PREFIX + event.topic, 1, event.fingerprint)
+            redis.sadd(SUBSCRIPTIONS_PREFIX + event.fingerprint, subscription_id)
           end
           next unless config.subscription_expiration_seconds
-          redis.expire(CHANNEL_PREFIX + channel.params["channelId"], config.subscription_expiration_seconds)
+          redis.expire(CHANNEL_PREFIX + channel_uniq_id, config.subscription_expiration_seconds)
           redis.expire(SUBSCRIPTION_PREFIX + subscription_id, config.subscription_expiration_seconds)
         end
       end
@@ -117,25 +179,56 @@ module GraphQL
           "#{SUBSCRIPTION_PREFIX}#{subscription_id}",
           :query_string, :variables, :context, :operation_name
         ).tap do |subscription|
+          return if subscription.values.all?(&:nil?) # Redis returns hash with all nils for missing key
+
           subscription[:context] = @serializer.load(subscription[:context])
           subscription[:variables] = JSON.parse(subscription[:variables])
           subscription[:operation_name] = nil if subscription[:operation_name].strip == ""
         end
       end
 
-      # The channel was closed, forget about it.
       def delete_subscription(subscription_id)
-        # Remove subscription ids from all events
+        events = redis.hget(SUBSCRIPTION_PREFIX + subscription_id, :events)
+        events = events ? JSON.parse(events) : {}
+        fingerprint_subscriptions = {}
+        redis.pipelined do
+          events.each do |topic, fingerprint|
+            redis.srem(SUBSCRIPTIONS_PREFIX + fingerprint, subscription_id)
+            score = redis.zincrby(FINGERPRINTS_PREFIX + topic, -1, fingerprint)
+            fingerprint_subscriptions[FINGERPRINTS_PREFIX + topic] = score
+          end
+          # Delete subscription itself
+          redis.del(SUBSCRIPTION_PREFIX + subscription_id)
+        end
+        # Clean up fingerprints that doesn't have any subscriptions left
+        redis.pipelined do
+          fingerprint_subscriptions.each do |key, score|
+            redis.zremrangebyscore(key, '-inf', '0') if score.value.zero?
+          end
+        end
+        delete_legacy_subscription(subscription_id)
+      end
+
+      def delete_legacy_subscription(subscription_id)
+        return unless config.handle_legacy_subscriptions
+
         events = redis.smembers(SUBSCRIPTION_EVENTS_PREFIX + subscription_id)
-        events.each do |event_topic|
-          redis.srem(EVENT_PREFIX + event_topic, subscription_id)
+        redis.pipelined do
+          events.each do |event_topic|
+            redis.srem(EVENT_PREFIX + event_topic, subscription_id)
+          end
+          redis.del(SUBSCRIPTION_EVENTS_PREFIX + subscription_id)
         end
-        # Delete subscription itself
-        redis.del(SUBSCRIPTION_EVENTS_PREFIX + subscription_id)
-        redis.del(SUBSCRIPTION_PREFIX + subscription_id)
       end
 
-      def delete_channel_subscriptions(channel_id)
+      # The channel was closed, forget about it and its subscriptions
+      def delete_channel_subscriptions(channel_or_id)
+        # For backward compatibility
+        channel_id = channel_or_id.is_a?(String) ? channel_or_id : read_subscription_id(channel_or_id)
+
+        # Missing in case disconnect happens before #execute
+        return unless channel_id
+
         redis.smembers(CHANNEL_PREFIX + channel_id).each do |subscription_id|
           delete_subscription(subscription_id)
         end
@@ -147,6 +240,34 @@ module GraphQL
       def anycable
         @anycable ||= ::AnyCable.broadcast_adapter
       end
+
+      def read_subscription_id(channel)
+        return channel.instance_variable_get(:@__sid__) if channel.instance_variable_defined?(:@__sid__)
+
+        istate = fetch_channel_istate(channel)
+
+        return unless istate
+
+        channel.instance_variable_set(:@__sid__, istate["sid"])
+      end
+
+      def write_subscription_id(channel, val)
+        channel.connection.socket.istate["sid"] = val
+        channel.instance_variable_set(:@__sid__, val)
+      end
+
+      def fetch_channel_istate(channel)
+        # For Rails integration
+        return channel.__istate__ if channel.respond_to?(:__istate__)
+
+        return unless channel.connection.socket.istate
+
+        if channel.connection.socket.istate[channel.identifier]
+          JSON.parse(channel.connection.socket.istate[channel.identifier])
+        else
+          channel.connection.socket.istate
+        end
+      end
     end
   end
 end

data/lib/graphql-anycable.rb

@@ -10,8 +10,8 @@ require_relative "graphql/subscriptions/anycable_subscriptions"
 
 module GraphQL
   module AnyCable
-    def self.use(schema)
-      schema.use GraphQL::Subscriptions::AnyCableSubscriptions
+    def self.use(schema, **options)
+      schema.use GraphQL::Subscriptions::AnyCableSubscriptions, **options
     end
 
     module_function
@@ -36,6 +36,3 @@ module GraphQL
     end
   end
 end
-
-# For backward compatibility
-GraphQL::Anycable = GraphQL::AnyCable

metadata

@@ -1,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: graphql-anycable
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Andrey Novikov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-25 00:00:00.000000000 Z
+date: 2021-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.6.0
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: anyway_config
   requirement: !ruby/object:Gem::Requirement
@@ -56,14 +50,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.11'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -78,6 +72,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: anycable-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +114,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -161,6 +197,7 @@ files:
 - lib/graphql/anycable.rb
 - lib/graphql/anycable/cleaner.rb
 - lib/graphql/anycable/config.rb
+- lib/graphql/anycable/errors.rb
 - lib/graphql/anycable/railtie.rb
 - lib/graphql/anycable/tasks/clean_expired_subscriptions.rake
 - lib/graphql/anycable/version.rb
@@ -184,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A drop-in replacement for GraphQL ActionCable subscriptions for AnyCable.