graphql-anycable 1.2.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bafa1a80487eeb78627ed0752751eb488dd33ca9709d38b205d61d310f97d7ae
-  data.tar.gz: 821cba31fd376a471c9db5757a2da3e51d936f618f372a624fab1515dea5d4e6
+  metadata.gz: eebb61e4181214e0f86bdf0cc33e7153e0a02c6c8de5e37996ca9457e6231385
+  data.tar.gz: 6fa0f37c132f8c22454bcdf9d995ac9b0c3f40c3913b0047f7be3b91eb68d07f
 SHA512:
-  metadata.gz: fdad5b3cfcc372ec326ebfa9641ecdc81d5f586aca7fc54edb5bc1985d4e0e8fabd3ba93eb25cf8e9f55556a7d5410a2971596ab52936706199cdb6c6f3faa10
-  data.tar.gz: f71265d7dc1f0afdb4162e2d6a00d87c92bd53aa484429a5dff138e7f53db754b75a55137d999314f6c600eee3d88d661b6ab91a87b1bdd9f52a0317a7d9e43a
+  metadata.gz: 06b6b55507a369100a71e9a30b93cf0fccef1d82c948b71693e43a4629116749453577aa0919d5de12c3bad8f6703d9652b0378c6ad90c4775ab355fe9b4ce7d
+  data.tar.gz: d0ed4156e37e936fad396659517245b1f4540451e4b4012ec8d1478cc4c1b1d244c254b690b168f4d8d2d36a3aadf1c22643c5cde639b08c119c8ec801d97152

data/.github/workflows/lint.yml

@@ -0,0 +1,34 @@
+name: Lint Ruby
+
+on:
+  push:
+    branches:
+    - master
+    paths:
+    - "gemfiles/*"
+    - "Gemfile"
+    - "**/*.rb"
+    - "**/*.gemspec"
+    - ".github/workflows/lint.yml"
+  pull_request:
+    paths:
+    - "gemfiles/*"
+    - "Gemfile"
+    - "**/*.rb"
+    - "**/*.gemspec"
+    - ".github/workflows/lint.yml"
+
+jobs:
+  rubocop:
+    runs-on: ubuntu-latest
+    env:
+      BUNDLE_GEMFILE: "gemfiles/rubocop.gemfile"
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.1
+        bundler-cache: true
+    - name: Lint Ruby code with RuboCop
+      run: |
+        bundle exec rubocop

data/.github/workflows/test.yml

@@ -24,11 +24,15 @@ jobs:
             redis_version: latest
           - ruby: "3.2"
             graphql: '~> 2.2.0'
-            anycable: '~> 1.4.0'
+            anycable: '~> 1.5.0'
             redis_version: '7.2'
           - ruby: "3.1"
+            graphql: '~> 2.1.0'
+            anycable: '~> 1.4.0'
+            redis_version: '6.2'
+          - ruby: "3.0"
             graphql: '~> 2.0.0'
-            anycable: '~> 1.3.0'
+            anycable: '~> 1.4.0'
             redis_version: '6.2'
     env:
       CI: true

data/.rubocop/rspec.yml

@@ -0,0 +1,46 @@
+require:
+  - rubocop-rspec
+
+# Disable all cops by default,
+# only enable those defined explcitly in this configuration file
+RSpec:
+  Enabled: false
+
+RSpec/Focus:
+  Enabled: true
+
+RSpec/EmptyExampleGroup:
+  Enabled: true
+
+RSpec/EmptyLineAfterExampleGroup:
+  Enabled: true
+
+RSpec/EmptyLineAfterFinalLet:
+  Enabled: true
+
+RSpec/EmptyLineAfterHook:
+  Enabled: true
+
+RSpec/EmptyLineAfterSubject:
+  Enabled: true
+
+RSpec/HookArgument:
+  Enabled: true
+
+RSpec/HooksBeforeExamples:
+  Enabled: true
+
+RSpec/ImplicitExpect:
+  Enabled: true
+
+RSpec/IteratedExpectation:
+  Enabled: true
+
+RSpec/LetBeforeExamples:
+  Enabled: true
+
+RSpec/MissingExampleGroupArgument:
+  Enabled: true
+
+RSpec/ReceiveCounts:
+  Enabled: true

data/.rubocop/strict.yml

@@ -0,0 +1,7 @@
+Lint/Debugger: # don't leave binding.pry
+  Enabled: true
+  Exclude: []
+
+RSpec/Focus: # run ALL tests on CI
+  Enabled: true
+  Exclude: []

data/.rubocop.yml

@@ -1,46 +1,30 @@
----
-require:
-- rubocop-rspec
-
-AllCops:
-  TargetRubyVersion: 2.3
+inherit_mode:
+  merge:
+    - Exclude
 
-Metrics/BlockLength:
-  Exclude:
-  - "Gemfile"
-  - "spec/**/*"
-
-Style/BracesAroundHashParameters:
-  EnforcedStyle: context_dependent
+require:
+  - standard
+  - standard-custom
+  - standard-performance
+  - rubocop-performance
 
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
+inherit_gem:
+  standard: config/base.yml
+  standard-performance: config/base.yml
+  standard-custom: config/base.yml
 
-# Allow to use let!
-RSpec/LetSetup:
-  Enabled: false
+inherit_from:
+  - .rubocop/rspec.yml
+  - .rubocop/strict.yml
 
-RSpec/MultipleExpectations:
-  Enabled: false
+AllCops:
+  NewCops: disable
+  SuggestExtensions: false
+  TargetRubyVersion: 3.2
 
-Bundler/OrderedGems:
+Style/ArgumentsForwarding:
   Enabled: false
 
-Style/TrailingCommaInArguments:
-  Description: 'Checks for trailing comma in argument lists.'
-  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-trailing-params-comma'
-  Enabled: true
-  EnforcedStyleForMultiline: consistent_comma
-
-Style/TrailingCommaInArrayLiteral:
-  Description: 'Checks for trailing comma in array literals.'
-  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas'
-  Enabled: true
-  EnforcedStyleForMultiline: consistent_comma
-
-Style/TrailingCommaInHashLiteral:
-  Description: 'Checks for trailing comma in hash literals.'
-  StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#no-trailing-array-commas'
-  Enabled: true
-  EnforcedStyleForMultiline: consistent_comma
-
+Style/GlobalVars:
+  Exclude:
+    - "spec/**/*.rb"

data/CHANGELOG.md

@@ -7,8 +7,22 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## Unreleased
 
+## 1.3.0 - 2024-08-13
+
+### Changed
+
+- Redis subscriptions store configuration has been decoupled from AnyCable, so you can use any broadcasting adapter and configure Redis as you like. [@palkan] ([#44](https://github.com/anycable/graphql-anycable/pull/44))
+
 ## 1.2.0 - 2024-05-07
 
+### Added
+
+- Stats collection about subscriptions, channels, etc via `GraphQL::AnyCable.stats`. [@prog-supdex] ([#37](https://github.com/anycable/graphql-anycable/pull/37))
+
+  See [Stats](https://github.com/anycable/graphql-anycable?tab=readme-ov-file#stats) section in README for details.
+
+- Configuration option `redis_prefix` for namespacing Redis keys. [@prog-supdex] ([#36](https://github.com/anycable/graphql-anycable/pull/36))
+
 ### Changed
 
 - Depend on `anycable-core` gem instead of `anycable`.
@@ -197,6 +211,9 @@ Technical release to test publishing via GitHub Actions.
 
 Initial version: store subscriptions on redis, re-execute queries in sync. [@Envek]
 
+[@prog-supdex]: https://github.com/prog-supdex "Igor Platonov"
+[@ilyasgaraev]: https://github.com/ilyasgaraev "Ilyas Garaev"
+[@smasry]: https://github.com/smasry "Samer Masry"
 [@gsamokovarov]: https://github.com/gsamokovarov "Genadi Samokovarov"
 [@bibendi]: https://github.com/bibendi "Misha Merkushin"
 [@FX-HAO]: https://github.com/FX-HAO "Fuxin Hao"

data/Gemfile

@@ -7,14 +7,17 @@ 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", "~> 2.3")
+gem "graphql", ENV.fetch("GRAPHQL_RUBY_VERSION", "~> 2.3")
 gem "anycable", ENV.fetch("ANYCABLE_VERSION", "~> 1.5")
 gem "anycable-rails", ENV.fetch("ANYCABLE_RAILS_VERSION", "~> 1.5")
+gem "rack", "< 3.0" if /1\.4/.match?(ENV.fetch("ANYCABLE_VERSION", "~> 1.5"))
+
+gem "ostruct"
 
 group :development, :test do
-  gem "pry"
-  gem "pry-byebug", platform: :mri
+  gem "debug", platforms: [:mri] unless ENV["CI"]
+end
 
-  gem "rubocop"
-  gem "rubocop-rspec"
+group :development do
+  eval_gemfile "gemfiles/rubocop.gemfile"
 end

data/README.md

@@ -11,58 +11,52 @@ A (mostly) drop-in replacement for default ActionCable subscriptions adapter shi
 
 ## Why?
 
-AnyCable is fast because it does not execute any Ruby code. But default subscription implementation shipped with [graphql gem] requires to do exactly that: re-evaluate GraphQL queries in ActionCable process. AnyCable doesn't support this (it's possible but hard to implement).
+AnyCable is fast because it does not execute any Ruby code. But default subscription implementation shipped with [graphql gem] requires to do exactly that: re-evaluate GraphQL queries in Action Cable process. AnyCable doesn't support this (it's possible but hard to implement).
 
 See https://github.com/anycable/anycable-rails/issues/40 for more details and discussion.
 
 ## Differences
 
- - Subscription information is stored in Redis database configured to be used by AnyCable. Expiration or data cleanup should be configured separately (see below).
- - GraphQL queries for all subscriptions are re-executed in the process that triggers event (it may be web server, async jobs, rake tasks or whatever)
+- Subscription information is stored in a Redis database. By default, we use AnyCable Redis configuration. Expiration or data cleanup should be configured separately (see below).
+- GraphQL queries for all subscriptions are re-executed in the process that triggers event (it may be web server, async jobs, rake tasks or whatever)
 
 ## Compatibility
 
- - Should work with ActionCable in development
- - Should work without Rails via [LiteCable] 
-
-## Requirements
-
-AnyCable must be configured with redis broadcast adapter (this is default).
+- Works with Action Cable (e.g., in development/test)
+- Works without Rails (e.g., via [LiteCable][])
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'graphql-anycable', '~> 1.0'
+gem "graphql-anycable", "~> 1.0"
 ```
 
 And then execute:
 
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install graphql-anycable
+```sh
+bundle install
+```
 
 ## Usage
 
- 1. Plug it into the schema (replace from ActionCable adapter if you have one):
- 
+ 1. Plug it into the schema (replace the Action Cable adapter if you have one):
+
     ```ruby
     class MySchema < GraphQL::Schema
       use GraphQL::AnyCable, broadcast: true
-    
+
       subscription SubscriptionType
     end
     ```
- 
- 2. Execute query in ActionCable/LiteCable channel.
- 
+
+ 2. Execute a query within an Action Cable/LiteCable channel.
+
     ```ruby
     class GraphqlChannel < ApplicationCable::Channel
       def execute(data)
-        result = 
+        result =
           MySchema.execute(
             query: data["query"],
             context: context,
@@ -75,11 +69,11 @@ Or install it yourself as:
           more: result.subscription?,
         )
       end
-    
+
       def unsubscribed
         MySchema.subscriptions.delete_channel_subscriptions(self)
       end
-    
+
       private
 
       def context
@@ -90,29 +84,38 @@ Or install it yourself as:
       end
     end
     ```
- 
-    Make sure that you're passing channel instance as `channel` key to the context. 
- 
+
+    Make sure that you're passing channel instance as `channel` key to the context.
+
  3. Trigger events as usual:
- 
+
     ```ruby
     MySchema.subscriptions.trigger(:product_updated, {}, Product.first!, scope: account.id)
     ```
 
+ 4. (Optional) When using other AnyCable broadcasting adapters than Redis, you MUST configure Redis for graphql-anycable yourself:
+
+    ```ruby
+    GraphQL::AnyCable.redis = Redis.new(url: ENV["REDIS_URL"])
+
+    # you can also use a Proc (e.g., if you want to use a connection pool)
+    redis_pool = ConnectionPool.new(size: 10) { Redis.new(url: ENV["REDIS_URL"]) }
+
+    GraphQL::AnyCable.redis = ->(&block) { redis_pool.with { |conn| block.call(conn) } }
+    ```
+
 ## 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.
+To enable this feature, pass the `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. Remove it when upgrading to 2.0
-  use GraphQL::Analysis::AST # Required for graphql-ruby before 1.12. Remove it when upgrading to 2.0
   use GraphQL::AnyCable, broadcast: true, default_broadcastable: true
 
   subscription SubscriptionType
@@ -125,7 +128,7 @@ See GraphQL-Ruby [broadcasting docs](https://graphql-ruby.org/subscriptions/broa
 
 To avoid filling Redis storage with stale subscription data:
 
- 1. Set `subscription_expiration_seconds` setting to number of seconds (e.g. `604800` for 1 week). See [configuration](#Configuration) section below for details.
+ 1. Set `subscription_expiration_seconds` setting to number of seconds (e.g. `604800` for 1 week). See [configuration](#configuration) section below for details.
 
  2. Execute `rake graphql:anycable:clean` once in a while to clean up stale subscription data.
 
@@ -165,39 +168,46 @@ GraphQL-AnyCable uses [anyway_config] to configure itself. There are several pos
 And any other way provided by [anyway_config]. Check its documentation!
 
 ## Emergency actions
-In situations when you don't set `subscription_expiration_seconds`, have a lot of inactive subscriptions, and `GraphQL::AnyCable::Cleaner` does`t help in that, 
+
+In situations when you don't set `subscription_expiration_seconds`, have a lot of inactive subscriptions, and `GraphQL::AnyCable::Cleaner` does`t help in that,
 you can do the following actions for clearing subscriptions
 
 1. Set `config.subscription_expiration_seconds`. After that, the new subscriptions will have `TTL`
+
 2. Run the script
+
 ```ruby
-   redis = GraphQL::AnyCable.redis
-   config = GraphQL::AnyCable.config
-   
-   # do it for subscriptions
-   redis.scan_each("graphql-subscription:*") do |key|
-     redis.expire(key, config.subscription_expiration_seconds) if redis.ttl(key) < 0
-     # or you can just remove it immediately
-     # redis.del(key) if redis.ttl(key) < 0
-   end
-
-   # do it for channels
-   redis.scan_each("graphql-channel:*") do |key|
-     redis.expire(key, config.subscription_expiration_seconds) if redis.ttl(key) < 0
-     # or you can just remove it immediately
-     # redis.del(key) if redis.ttl(key) < 0
-   end
+config = GraphQL::AnyCable.config
+
+GraphQL::AnyCable.with_redis do |redis|
+  # do it for subscriptions
+  redis.scan_each("graphql-subscription:*") do |key|
+    redis.expire(key, config.subscription_expiration_seconds) if redis.ttl(key) < 0
+    # or you can just remove it immediately
+    # redis.del(key) if redis.ttl(key) < 0
+  end
+
+  # do it for channels
+  redis.scan_each("graphql-channel:*") do |key|
+    redis.expire(key, config.subscription_expiration_seconds) if redis.ttl(key) < 0
+    # or you can just remove it immediately
+    # redis.del(key) if redis.ttl(key) < 0
+  end
+end
 ```
 
-Or you can change the `redis_prefix` in the `configuration` and then remove all records with the old_prefix 
-For instance:
+Or you can change the `redis_prefix` in the `configuration` and then remove all records with the old_prefix. For instance:
+
+1. Change the `redis_prefix`. The default `redis_prefix` is `graphql`.
+
+2. Run the ruby script, which remove all records with `old prefix`:
 
-1. Change the `redis_prefix`. The default `redis_prefix` is `graphql`
-2. Run the ruby script, which remove all records with `old prefix`
 ```ruby
+GraphQL::AnyCable.with_redis do |redis|
   redis.scan_each("graphql-*") do |key|
     redis.del(key)
   end
+end
 ```
 
 ## Data model
@@ -206,21 +216,21 @@ As in AnyCable there is no place to store subscription data in-memory, it should
 
  1. Grouped event subscriptions: `graphql-fingerprints:#{event.topic}` sorted set. Used to find all subscriptions on `GraphQLSchema.subscriptions.trigger`.
 
-    ```
+    ```sh
     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.
 
-    ```
+    ```sh
     SMEMBERS graphql-subscriptions:1:myStats:/MyStats/fBDZmJU1UGTorQWvOyUeaHVwUxJ3T9SEqnetj6SKGXc=/0/RBNvo1WzZ4oRRq0W9-hknpT7T8If536DEMBg9hyq_4o=
     => 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.
 
-    ```
+    ```sh
     HGETALL graphql-subscription:52ee8d65-275e-4d22-94af-313129116388
     => {
       context:        '{"user_id":1,"user":{"__gid__":"Z2lkOi8vZWJheS1tYWcyL1VzZXIvMQ"}}',
@@ -232,29 +242,29 @@ As in AnyCable there is no place to store subscription data in-memory, it should
 
  4. Channel subscriptions: `graphql-channel:#{subscription_id}` set containing identifiers for subscriptions created in ActionCable channel to delete them on client disconnect.
 
-    ```
+    ```sh
     SMEMBERS graphql-channel:17420c6ed9e
     => 52ee8d65-275e-4d22-94af-313129116388
     ```
 
 ## Stats
 
-You can grab Redis subscription statistics by calling
+You can grab Redis subscription statistics by calling:
 
 ```ruby
-    GraphQL::AnyCable.stats
+GraphQL::AnyCable.stats
 ```
 
-It will return a total of the amount of the key with the following prefixes
+It will return a total of the amount of the key with the following prefixes:
 
-```
-    graphql-subscription
-    graphql-fingerprints
-    graphql-subscriptions
-    graphql-channel
+```txt
+graphql-subscription
+graphql-fingerprints
+graphql-subscriptions
+graphql-channel
 ```
 
-The response will look like this
+The response will look like this:
 
 ```json
   {
@@ -267,13 +277,13 @@ The response will look like this
   }
 ```
 
-You can also grab the number of subscribers grouped by subscriptions
+You can also grab the number of subscribers grouped by subscriptions:
 
 ```ruby
-    GraphQL::AnyCable.stats(include_subscriptions: true)
+GraphQL::AnyCable.stats(include_subscriptions: true)
 ```
 
-It will return the response that contains `subscriptions`
+It will return the response that contains `subscriptions`:
 
 ```json
   {
@@ -290,59 +300,58 @@ It will return the response that contains `subscriptions`
   }
 ```
 
-Also, you can set another `scan_count`, if needed.
-The default value is 1_000
+Also, you can set another `scan_count`, if needed. The default value is 1_000:
 
 ```ruby
-    GraphQL::AnyCable.stats(scan_count: 100)
+GraphQL::AnyCable.stats(scan_count: 100)
 ```
 
-We can set statistics data to [Yabeda][] for tracking amount of subscriptions
+We can set statistics data to [Yabeda][] for tracking amount of subscriptions:
 
 ```ruby
-  # config/initializers/metrics.rb
-  Yabeda.configure do
-    group :graphql_anycable_statistics do
-      gauge :subscriptions_count,  comment: "Number of graphql-anycable subscriptions"
-    end
+# config/initializers/metrics.rb
+Yabeda.configure do
+  group :graphql_anycable_statistics do
+    gauge :subscriptions_count,  comment: "Number of graphql-anycable subscriptions"
   end
+end
 ```
 
 ```ruby
-  # in your app
-  statistics = GraphQL::AnyCable.stats[:total]
+# in your app
+statistics = GraphQL::AnyCable.stats[:total]
 
-  statistics.each do |key , value|
-    Yabeda.graphql_anycable_statistics.subscriptions_count.set({name: key}, value)
-  end
+statistics.each do |key , value|
+  Yabeda.graphql_anycable_statistics.subscriptions_count.set({name: key}, value)
+end
 ```
 
-Or you can use `collect`
+Or you can use `collect`:
+
 ```ruby
-  # config/initializers/metrics.rb
-  Yabeda.configure do
-    group :graphql_anycable_statistics do
-      gauge :subscriptions_count,  comment: "Number of graphql-anycable subscriptions"
-    end
-    
-    collect do
-      statistics = GraphQL::AnyCable.stats[:total]
+# config/initializers/metrics.rb
+Yabeda.configure do
+  group :graphql_anycable_statistics do
+    gauge :subscriptions_count,  comment: "Number of graphql-anycable subscriptions"
+  end
 
-      statistics.each do |redis_prefix, value|
-        graphql_anycable_statistics.subscriptions_count.set({name: redis_prefix}, value)
-      end
+  collect do
+    statistics = GraphQL::AnyCable.stats[:total]
+
+    statistics.each do |redis_prefix, value|
+      graphql_anycable_statistics.subscriptions_count.set({name: redis_prefix}, value)
     end
   end
+end
 ```
 
-
 ## Testing applications which use `graphql-anycable`
 
 You can pass custom redis-server URL to AnyCable using ENV variable.
 
-    ```bash
-    REDIS_URL=redis://localhost:6379/5 bundle exec rspec
-    ```
+```bash
+REDIS_URL=redis://localhost:6379/5 bundle exec rspec
+```
 
 ## Development
 
@@ -382,7 +391,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 7. GitHub Actions will create a new release, build and push gem into [rubygems.org](https://rubygems.org)! You're done!
 
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Envek/graphql-anycable.

data/Rakefile

@@ -5,4 +5,11 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+begin
+  require "rubocop/rake_task"
+  RuboCop::RakeTask.new
+rescue LoadError
+  task(:rubocop) {}
+end
+
+task default: [:rubocop, :spec]

data/gemfiles/rubocop.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org" do
+  gem "standard", "~> 1.28"
+
+  gem "rubocop-rspec"
+end

data/graphql-anycable.gemspec

@@ -5,31 +5,33 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "graphql/anycable/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "graphql-anycable"
-  spec.version       = GraphQL::AnyCable::VERSION
-  spec.authors       = ["Andrey Novikov"]
-  spec.email         = ["envek@envek.name"]
+  spec.name = "graphql-anycable"
+  spec.version = GraphQL::AnyCable::VERSION
+  spec.authors = ["Andrey Novikov"]
+  spec.email = ["envek@envek.name"]
 
-  spec.summary       = <<~SUMMARY
+  spec.summary = <<~SUMMARY
     A drop-in replacement for GraphQL ActionCable subscriptions for AnyCable.
   SUMMARY
 
-  spec.homepage      = "https://github.com/Envek/graphql-anycable"
-  spec.license       = "MIT"
+  spec.homepage = "https://github.com/Envek/graphql-anycable"
+  spec.license = "MIT"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = ">= 3.0.0"
+
   spec.add_dependency "anycable-core", "~> 1.1"
   spec.add_dependency "anyway_config", ">= 1.3", "< 3"
-  spec.add_dependency "graphql",       ">= 1.11", "< 3"
-  spec.add_dependency "redis",         ">= 4.2.0"
+  spec.add_dependency "graphql", ">= 1.11", "< 3"
+  spec.add_dependency "redis", ">= 4.2.0"
 
   spec.add_development_dependency "anycable-rails"
   spec.add_development_dependency "bundler", "~> 2.0"

data/lib/graphql/anycable/cleaner.rb

@@ -16,11 +16,13 @@ module GraphQL
         return unless config.subscription_expiration_seconds
         return unless config.use_redis_object_on_cleanup
 
-        redis.scan_each(match: "#{redis_key(adapter::CHANNEL_PREFIX)}*") do |key|
-          idle = redis.object("IDLETIME", key)
-          next if idle&.<= config.subscription_expiration_seconds
+        AnyCable.with_redis do |redis|
+          redis.scan_each(match: "#{redis_key(adapter::CHANNEL_PREFIX)}*") do |key|
+            idle = redis.object("IDLETIME", key)
+            next if idle&.<= config.subscription_expiration_seconds
 
-          redis.del(key)
+            redis.del(key)
+          end
         end
       end
 
@@ -28,31 +30,37 @@ module GraphQL
         return unless config.subscription_expiration_seconds
         return unless config.use_redis_object_on_cleanup
 
-        redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTION_PREFIX)}*") do |key|
-          idle = redis.object("IDLETIME", key)
-          next if idle&.<= config.subscription_expiration_seconds
+        AnyCable.with_redis do |redis|
+          redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTION_PREFIX)}*") do |key|
+            idle = redis.object("IDLETIME", key)
+            next if idle&.<= config.subscription_expiration_seconds
 
-          redis.del(key)
+            redis.del(key)
+          end
         end
       end
 
       def clean_fingerprint_subscriptions
-        redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTIONS_PREFIX)}*") do |key|
-          redis.smembers(key).each do |subscription_id|
-            next if redis.exists?(redis_key(adapter::SUBSCRIPTION_PREFIX) + subscription_id)
+        AnyCable.with_redis do |redis|
+          redis.scan_each(match: "#{redis_key(adapter::SUBSCRIPTIONS_PREFIX)}*") do |key|
+            redis.smembers(key).each do |subscription_id|
+              next if redis.exists?(redis_key(adapter::SUBSCRIPTION_PREFIX) + subscription_id)
 
-            redis.srem(key, subscription_id)
+              redis.srem(key, subscription_id)
+            end
           end
         end
       end
 
       def clean_topic_fingerprints
-        redis.scan_each(match: "#{redis_key(adapter::FINGERPRINTS_PREFIX)}*") do |key|
-          redis.zremrangebyscore(key, '-inf', '0')
-          redis.zrange(key, 0, -1).each do |fingerprint|
-            next if redis.exists?(redis_key(adapter::SUBSCRIPTIONS_PREFIX) + fingerprint)
-
-            redis.zrem(key, fingerprint)
+        AnyCable.with_redis do |redis|
+          redis.scan_each(match: "#{redis_key(adapter::FINGERPRINTS_PREFIX)}*") do |key|
+            redis.zremrangebyscore(key, "-inf", "0")
+            redis.zrange(key, 0, -1).each do |fingerprint|
+              next if redis.exists?(redis_key(adapter::SUBSCRIPTIONS_PREFIX) + fingerprint)
+
+              redis.zrem(key, fingerprint)
+            end
           end
         end
       end
@@ -63,10 +71,6 @@ module GraphQL
         GraphQL::Subscriptions::AnyCableSubscriptions
       end
 
-      def redis
-        GraphQL::AnyCable.redis
-      end
-
       def config
         GraphQL::AnyCable.config
       end

data/lib/graphql/anycable/config.rb

@@ -6,7 +6,7 @@ module GraphQL
   module AnyCable
     class Config < Anyway::Config
       config_name :graphql_anycable
-      env_prefix  :graphql_anycable
+      env_prefix :graphql_anycable
 
       attr_config subscription_expiration_seconds: nil
       attr_config use_redis_object_on_cleanup: true

data/lib/graphql/anycable/stats.rb

@@ -18,12 +18,14 @@ module GraphQL
       def collect
         total_subscriptions_result = {total: {}}
 
-        list_prefixes_keys.each do |name, prefix|
-          total_subscriptions_result[:total][name] = count_by_scan(match: "#{prefix}*")
-        end
+        AnyCable.with_redis do |redis|
+          list_prefixes_keys.each do |name, prefix|
+            total_subscriptions_result[:total][name] = count_by_scan(redis, match: "#{prefix}*")
+          end
 
-        if include_subscriptions
-          total_subscriptions_result[:subscriptions] = group_subscription_stats
+          if include_subscriptions
+            total_subscriptions_result[:subscriptions] = group_subscription_stats(redis)
+          end
         end
 
         total_subscriptions_result
@@ -32,22 +34,22 @@ module GraphQL
       private
 
       # Counting all keys, that match the pattern with iterating by count
-      def count_by_scan(match:)
+      def count_by_scan(redis, match:)
         sb_amount = 0
-        cursor = '0'
+        cursor = "0"
 
         loop do
           cursor, result = redis.scan(cursor, match: match, count: scan_count)
           sb_amount += result.count
 
-          break if cursor == '0'
+          break if cursor == "0"
         end
 
         sb_amount
       end
 
       # Calculate subscribes, grouped by subscriptions
-      def group_subscription_stats
+      def group_subscription_stats(redis)
         subscription_groups = {}
 
         redis.scan_each(match: "#{list_prefixes_keys[:fingerprints]}*", count: scan_count) do |fingerprint_key|
@@ -79,10 +81,6 @@ module GraphQL
         GraphQL::Subscriptions::AnyCableSubscriptions
       end
 
-      def redis
-        GraphQL::AnyCable.redis
-      end
-
       def config
         GraphQL::AnyCable.config
       end

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

@@ -5,7 +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 clean:fingerprint_subscriptions clean:topic_fingerprints]
+    task clean: %i[clean:channels clean:subscriptions clean:fingerprint_subscriptions clean:topic_fingerprints]
 
     namespace :clean do
       # Clean up old channels

data/lib/graphql/anycable/version.rb

@@ -2,6 +2,6 @@
 
 module GraphQL
   module AnyCable
-    VERSION = "1.2.0"
+    VERSION = "1.3.1"
   end
 end

data/lib/graphql/subscriptions/anycable_subscriptions.rb

@@ -54,12 +54,13 @@ module GraphQL
     class AnyCableSubscriptions < GraphQL::Subscriptions
       extend Forwardable
 
-      def_delegators :"GraphQL::AnyCable", :redis, :config
+      def_delegators :"GraphQL::AnyCable", :with_redis, :config
+      def_delegators :"::AnyCable", :broadcast
 
-      SUBSCRIPTION_PREFIX  = "subscription:"  # HASH: Stores subscription data: query, context, …
-      FINGERPRINTS_PREFIX  = "fingerprints:"  # ZSET: To get fingerprints by topic
+      SUBSCRIPTION_PREFIX = "subscription:"  # HASH: Stores subscription data: query, context, …
+      FINGERPRINTS_PREFIX = "fingerprints:"  # ZSET: To get fingerprints by topic
       SUBSCRIPTIONS_PREFIX = "subscriptions:" # SET:  To get subscriptions by fingerprint
-      CHANNEL_PREFIX       = "channel:"       # SET:  Auxiliary structure for whole channel's subscriptions cleanup
+      CHANNEL_PREFIX = "channel:"       # SET:  Auxiliary structure for whole channel's subscriptions cleanup
 
       # @param serializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`
       def initialize(serializer: Serialize, **rest)
@@ -70,23 +71,25 @@ module GraphQL
       # An event was triggered.
       # Re-evaluate all subscribed queries and push the data over ActionCable.
       def execute_all(event, object)
-        fingerprints = redis.zrange(redis_key(FINGERPRINTS_PREFIX) + event.topic, 0, -1)
+        fingerprints = with_redis { |redis| redis.zrange(redis_key(FINGERPRINTS_PREFIX) + event.topic, 0, -1) }
         return if fingerprints.empty?
 
-        fingerprint_subscription_ids = Hash[fingerprints.zip(
-          redis.pipelined do |pipeline|
-            fingerprints.map do |fingerprint|
-              pipeline.smembers(redis_key(SUBSCRIPTIONS_PREFIX) + fingerprint)
+        fingerprint_subscription_ids = with_redis do |redis|
+          fingerprints.zip(
+            redis.pipelined do |pipeline|
+              fingerprints.map do |fingerprint|
+                pipeline.smembers(redis_key(SUBSCRIPTIONS_PREFIX) + fingerprint)
+              end
             end
-          end
-        )]
+          ).to_h
+        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] }]
+        fingerprint_subscription_ids.map { |k, v| [k, v.size] }.to_h
       end
 
       # The fingerprint has told us that this response should be shared by all subscribers,
@@ -94,7 +97,7 @@ module GraphQL
       def execute_grouped(fingerprint, subscription_ids, event, object)
         return if subscription_ids.empty?
 
-        subscription_id = subscription_ids.find { |sid| redis.exists?(redis_key(SUBSCRIPTION_PREFIX) + sid) }
+        subscription_id = with_redis { |redis| subscription_ids.find { |sid| redis.exists?(redis_key(SUBSCRIPTION_PREFIX) + sid) } }
         return unless subscription_id # All subscriptions has expired but haven't cleaned up yet
 
         result = execute_update(subscription_id, event, object)
@@ -114,8 +117,8 @@ module GraphQL
       # @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)
+        payload = {result: result.to_h, more: true}.to_json
+        broadcast(stream_key, payload)
       end
 
       # Save query to "storage" (in redis)
@@ -138,37 +141,58 @@ module GraphQL
           variables: query.provided_variables.to_json,
           context: @serializer.dump(context.to_h),
           operation_name: query.operation_name.to_s,
-          events: events.map { |e| [e.topic, e.fingerprint] }.to_h.to_json,
+          events: events.map { |e| [e.topic, e.fingerprint] }.to_h.to_json
         }
 
-        redis.multi do |pipeline|
-          pipeline.sadd(redis_key(CHANNEL_PREFIX) + subscription_id, [subscription_id])
-          pipeline.mapped_hmset(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, data)
-          events.each do |event|
-            pipeline.zincrby(redis_key(FINGERPRINTS_PREFIX) + event.topic, 1, event.fingerprint)
-            pipeline.sadd(redis_key(SUBSCRIPTIONS_PREFIX) + event.fingerprint, [subscription_id])
+        with_redis do |redis|
+          redis.multi do |pipeline|
+            pipeline.sadd(redis_key(CHANNEL_PREFIX) + subscription_id, [subscription_id])
+            pipeline.mapped_hmset(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, data)
+            events.each do |event|
+              pipeline.zincrby(redis_key(FINGERPRINTS_PREFIX) + event.topic, 1, event.fingerprint)
+              pipeline.sadd(redis_key(SUBSCRIPTIONS_PREFIX) + event.fingerprint, [subscription_id])
+            end
+            next unless config.subscription_expiration_seconds
+            pipeline.expire(redis_key(CHANNEL_PREFIX) + subscription_id, config.subscription_expiration_seconds)
+            pipeline.expire(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, config.subscription_expiration_seconds)
           end
-          next unless config.subscription_expiration_seconds
-          pipeline.expire(redis_key(CHANNEL_PREFIX) + subscription_id, config.subscription_expiration_seconds)
-          pipeline.expire(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, config.subscription_expiration_seconds)
         end
       end
 
       # Return the query from "storage" (in redis)
       def read_subscription(subscription_id)
-        redis.mapped_hmget(
-          "#{redis_key(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 == ""
+        with_redis do |redis|
+          redis.mapped_hmget(
+            "#{redis_key(SUBSCRIPTION_PREFIX)}#{subscription_id}",
+            :query_string, :variables, :context, :operation_name
+          ).tap do |subscription|
+            next 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
       end
 
-      def delete_subscription(subscription_id)
+      # The channel was closed, forget about it and its subscriptions
+      def delete_channel_subscriptions(channel)
+        raise(ArgumentError, "Please pass channel instance to #{__method__} in your #unsubscribed method") if channel.is_a?(String)
+
+        channel_id = read_subscription_id(channel)
+
+        # Missing in case disconnect happens before #execute
+        return unless channel_id
+
+        with_redis do |redis|
+          redis.smembers(redis_key(CHANNEL_PREFIX) + channel_id).each do |subscription_id|
+            delete_subscription(subscription_id, redis: redis)
+          end
+          redis.del(redis_key(CHANNEL_PREFIX) + channel_id)
+        end
+      end
+
+      def delete_subscription(subscription_id, redis: AnyCable.redis)
         events = redis.hget(redis_key(SUBSCRIPTION_PREFIX) + subscription_id, :events)
         events = events ? JSON.parse(events) : {}
         fingerprint_subscriptions = {}
@@ -184,32 +208,13 @@ module GraphQL
         # Clean up fingerprints that doesn't have any subscriptions left
         redis.pipelined do |pipeline|
           fingerprint_subscriptions.each do |key, score|
-            pipeline.zremrangebyscore(key, '-inf', '0') if score.value.zero?
+            pipeline.zremrangebyscore(key, "-inf", "0") if score.value.zero?
           end
         end
       end
 
-      # The channel was closed, forget about it and its subscriptions
-      def delete_channel_subscriptions(channel)
-        raise(ArgumentError, "Please pass channel instance to #{__method__} in your #unsubscribed method") if channel.is_a?(String)
-
-        channel_id = read_subscription_id(channel)
-
-        # Missing in case disconnect happens before #execute
-        return unless channel_id
-
-        redis.smembers(redis_key(CHANNEL_PREFIX) + channel_id).each do |subscription_id|
-          delete_subscription(subscription_id)
-        end
-        redis.del(redis_key(CHANNEL_PREFIX) + channel_id)
-      end
-
       private
 
-      def anycable
-        @anycable ||= ::AnyCable.broadcast_adapter
-      end
-
       def read_subscription_id(channel)
         return channel.instance_variable_get(:@__sid__) if channel.instance_variable_defined?(:@__sid__)
 

data/lib/graphql-anycable.rb

@@ -11,33 +11,55 @@ require_relative "graphql/subscriptions/anycable_subscriptions"
 
 module GraphQL
   module AnyCable
-    def self.use(schema, **options)
-      schema.use GraphQL::Subscriptions::AnyCableSubscriptions, **options
-    end
+    class << self
+      def use(schema, **opts)
+        schema.use(GraphQL::Subscriptions::AnyCableSubscriptions, **opts)
+      end
 
-    def self.stats(**options)
-      Stats.new(**options).collect
-    end
+      def stats(**opts)
+        Stats.new(**opts).collect
+      end
+
+      def redis
+        warn "Usage of `GraphQL::AnyCable.redis` is deprecated. Instead of `GraphQL::AnyCable.redis.whatever` use `GraphQL::AnyCable.with_redis { |redis| redis.whatever }`"
+        @redis ||= with_redis { |conn| conn }
+      end
+
+      def redis=(connector)
+        @redis_connector = if connector.is_a?(::Proc)
+          connector
+        else
+          ->(&block) { block.call connector }
+        end
+      end
+
+      def with_redis(&block)
+        @redis_connector || default_redis_connector
+        @redis_connector.call(&block)
+      end
+
+      def config
+        @config ||= Config.new
+      end
+
+      def configure
+        yield(config) if block_given?
+      end
 
-    module_function
+      private
 
-    def redis
-      @redis ||= begin
+      def default_redis_connector
         adapter = ::AnyCable.broadcast_adapter
         unless adapter.is_a?(::AnyCable::BroadcastAdapters::Redis)
           raise "Unsupported AnyCable adapter: #{adapter.class}. " \
-                  "graphql-anycable works only with redis broadcast adapter."
+                "Please, configure Redis connector manually:\n\n" \
+                "  GraphQL::AnyCable.configure do |config|\n" \
+                "    config.redis = Redis.new(url: 'redis://localhost:6379/0')\n" \
+                "  end\n"
         end
-        ::AnyCable.broadcast_adapter.redis_conn
-      end
-    end
 
-    def config
-      @config ||= GraphQL::AnyCable::Config.new
-    end
-
-    def configure
-      yield(config) if block_given?
+        self.redis = ::AnyCable.broadcast_adapter.redis_conn
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-anycable
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Andrey Novikov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-07 00:00:00.000000000 Z
+date: 2025-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: anycable-core
@@ -162,7 +162,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+description:
 email:
 - envek@envek.name
 executables: []
@@ -171,11 +171,14 @@ extra_rdoc_files: []
 files:
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
+- ".github/workflows/lint.yml"
 - ".github/workflows/release.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop/rspec.yml"
+- ".rubocop/strict.yml"
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -183,6 +186,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- gemfiles/rubocop.gemfile
 - graphql-anycable.gemspec
 - lib/Rakefile
 - lib/graphql-anycable.rb
@@ -199,7 +203,7 @@ homepage: https://github.com/Envek/graphql-anycable
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -207,15 +211,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: A drop-in replacement for GraphQL ActionCable subscriptions for AnyCable.
 test_files: []