graphql-anycable_postgresql-store 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 98dc409019bc7dcd4b3cf768c48b0c849fa51b2a8fe13e752485cf37dbc6d347
+  data.tar.gz: fd1f0469d8f228257092cd4e6a8dcacfca9306139fb6e624c0c8ddd71a408bf3
+SHA512:
+  metadata.gz: ee6d8b98417a98906635103a89c4c7683bc931f1da3f627a6e17aabbb8f62b41ea662f68e2d7c5f3950f878c2cdc41836ca2fd20cf0ad7fb849f319e4f4bf7b4
+  data.tar.gz: 935c1c06e7115264b065c57320fe1917bfc46fd12ae67cf58ebf6b32a5b9a44fafbdbdd07c29b7d73e6713e965f83c53105adad2c090716f7e81874739e84796

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format progress

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0 - 2026-05-27
+
+- Add PostgreSQL subscription store for `graphql-anycable`.
+- Register `:postgresql` and `:postgres` subscription store aliases.
+- Add Rails install generator for the PostgreSQL store tables.
+- Add store-backed stats support for `GraphQL::AnyCable.stats`.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TikiTDO
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+# GraphQL AnyCable PostgreSQL Store
+
+[![Tests](https://github.com/TikiTDO/graphql-anycable_postgresql-store/actions/workflows/test.yml/badge.svg)](https://github.com/TikiTDO/graphql-anycable_postgresql-store/actions/workflows/test.yml)
+
+PostgreSQL subscription store for [`graphql-anycable`](https://github.com/anycable/graphql-anycable).
+
+This gem stores GraphQL subscription state in PostgreSQL. It does not deliver AnyCable broadcasts itself; delivery still goes through the AnyCable broadcast adapter configured by the application.
+
+This gem requires a `graphql-anycable` version that supports custom subscription stores.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "graphql-anycable_postgresql-store"
+```
+
+Then configure `graphql-anycable` to use the store:
+
+```ruby
+GraphQL::AnyCable.configure do |config|
+  config.subscription_store = :postgresql
+end
+```
+
+The gem also registers `:postgres` as an alias for `:postgresql`.
+
+## Configuration
+
+Configure the PostgreSQL connection and table names with environment variables:
+
+```.env
+GRAPHQL_ANYCABLE_POSTGRESQL_STORE_POSTGRES_URL=postgres://localhost:5432/postgres
+GRAPHQL_ANYCABLE_POSTGRESQL_STORE_SUBSCRIPTIONS_TABLE=graphql_anycable_subscriptions
+GRAPHQL_ANYCABLE_POSTGRESQL_STORE_SUBSCRIPTION_EVENTS_TABLE=graphql_anycable_subscription_events
+GRAPHQL_ANYCABLE_POSTGRESQL_STORE_CHANNEL_SUBSCRIPTIONS_TABLE=graphql_anycable_channel_subscriptions
+```
+
+Or configure the gem from application code:
+
+```ruby
+GraphQL::AnyCable::PostgreSQLStore.configure do |config|
+  config.postgres_url = ENV["DATABASE_URL"]
+  config.subscriptions_table = "graphql_anycable_subscriptions"
+  config.subscription_events_table = "graphql_anycable_subscription_events"
+  config.channel_subscriptions_table = "graphql_anycable_channel_subscriptions"
+end
+```
+
+If `postgres_url` is not configured, the store falls back to `AnyCable.config.postgres_url` when available, then to `DATABASE_URL`. If none are set, `PG.connect` uses libpq defaults.
+
+## Database schema
+
+Rails applications with ActiveRecord can install the migration:
+
+```sh
+bin/rails generate graphql:anycable:postgresql_store:install
+bin/rails db:migrate
+```
+
+The generator skips migration creation when ActiveRecord generator support is not available.
+
+Applications can also create the tables directly:
+
+```sql
+CREATE TABLE graphql_anycable_subscriptions (
+  id text PRIMARY KEY,
+  query_string text NOT NULL,
+  variables text NOT NULL,
+  context text NOT NULL,
+  operation_name text NOT NULL,
+  events jsonb NOT NULL DEFAULT '{}',
+  expires_at timestamptz,
+  created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE graphql_anycable_subscription_events (
+  subscription_id text NOT NULL REFERENCES graphql_anycable_subscriptions(id) ON DELETE CASCADE,
+  topic text NOT NULL,
+  fingerprint text NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (subscription_id, topic, fingerprint)
+);
+
+CREATE INDEX index_graphql_anycable_subscription_events_topic_fingerprint
+  ON graphql_anycable_subscription_events (topic, fingerprint);
+
+CREATE INDEX index_graphql_anycable_subscription_events_fingerprint
+  ON graphql_anycable_subscription_events (fingerprint);
+
+CREATE TABLE graphql_anycable_channel_subscriptions (
+  channel_id text NOT NULL,
+  subscription_id text NOT NULL REFERENCES graphql_anycable_subscriptions(id) ON DELETE CASCADE,
+  created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (channel_id, subscription_id)
+);
+```
+
+## Stats
+
+`GraphQL::AnyCable.stats` delegates to this store when `subscription_store` is
+configured as `:postgresql` or `:postgres`. The store reports active
+subscriptions, topics, fingerprints, and channels with SQL aggregate queries;
+`scan_count` is accepted for graphql-anycable interface compatibility and is not
+used by PostgreSQL.
+
+## Development
+
+Install dependencies and run tests:
+
+```sh
+GRAPHQL_ANYCABLE_PATH=../graphql-anycable bundle exec rspec
+```
+
+Set `POSTGRES_URL` or `DATABASE_URL` to run the store integration spec against PostgreSQL.
+
+CI runs the spec suite against a PostgreSQL service and checks out the `graphql-anycable` interface branch until the custom store API is released.
+
+## Release
+
+Release notes are kept in `CHANGELOG.md` and published through GitHub Releases.
+Build the gem with:
+
+```sh
+bundle exec rake build
+```
+
+Publish the same versioned gem artifact to RubyGems and GitHub Releases:
+
+```sh
+gem push pkg/graphql-anycable_postgresql-store-0.1.0.gem
+gh release create v0.1.0 pkg/graphql-anycable_postgresql-store-0.1.0.gem \
+  --title "v0.1.0" \
+  --notes-file CHANGELOG.md
+```

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/graphql-anycable_postgresql-store.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/graphql/anycable/postgresql_store/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "graphql-anycable_postgresql-store"
+  spec.version = GraphQL::AnyCable::PostgreSQLStore::VERSION
+  spec.authors = ["TikiTDO"]
+
+  spec.summary = "PostgreSQL subscription store for graphql-anycable."
+  spec.description = "Stores graphql-anycable subscription state in PostgreSQL."
+  spec.homepage = "https://github.com/TikiTDO/graphql-anycable_postgresql-store"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/TikiTDO/graphql-anycable_postgresql-store/issues",
+    "changelog_uri" => "https://github.com/TikiTDO/graphql-anycable_postgresql-store/releases",
+    "homepage_uri" => spec.homepage,
+    "allowed_push_host" => "https://rubygems.org",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => spec.homepage
+  }
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |file|
+      file.start_with?("spec/", ".github/", ".git", "Gemfile")
+    end
+  end
+  spec.files = (spec.files + %w[CHANGELOG.md]).uniq
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.add_dependency "anyway_config", ">= 1.3", "< 3"
+  spec.add_dependency "graphql-anycable", ">= 1.3.1"
+  spec.add_dependency "pg", ">= 1.2"
+
+  spec.add_development_dependency "bundler", ">= 2.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/generators/graphql/anycable/postgresql_store/install_generator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+begin
+  require "rails/generators/active_record"
+rescue LoadError
+  # ActiveRecord is optional; non-ActiveRecord applications can use the SQL from the README.
+end
+
+module GraphQL
+  module AnyCable
+    module PostgreSQLStore
+      class InstallGenerator < Rails::Generators::Base
+        namespace "graphql:anycable:postgresql_store:install"
+
+        source_root File.expand_path("templates", __dir__)
+
+        include ActiveRecord::Generators::Migration if defined?(ActiveRecord::Generators::Migration)
+
+        def self.next_migration_number(dirname)
+          if defined?(ActiveRecord::Generators::Base)
+            ActiveRecord::Generators::Base.next_migration_number(dirname)
+          else
+            Time.now.utc.strftime("%Y%m%d%H%M%S")
+          end
+        end
+
+        def create_migration
+          unless respond_to?(:migration_template, true)
+            say_status :skip, "ActiveRecord generators are not available", :yellow
+            return
+          end
+
+          migration_template(
+            "create_graphql_anycable_postgresql_store_tables.rb",
+            "db/migrate/create_graphql_anycable_postgresql_store_tables.rb"
+          )
+        end
+
+        private
+
+        def migration_version
+          return "" unless defined?(ActiveRecord::Migration) && ActiveRecord::Migration.respond_to?(:[])
+
+          "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/anycable/postgresql_store/templates/create_graphql_anycable_postgresql_store_tables.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class CreateGraphqlAnycablePostgresqlStoreTables < ActiveRecord::Migration<%= migration_version %>
+  def up
+    execute <<~SQL
+      CREATE TABLE IF NOT EXISTS graphql_anycable_subscriptions (
+        id text PRIMARY KEY,
+        query_string text NOT NULL,
+        variables text NOT NULL,
+        context text NOT NULL,
+        operation_name text NOT NULL,
+        events jsonb NOT NULL DEFAULT '{}',
+        expires_at timestamptz,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS graphql_anycable_subscription_events (
+        subscription_id text NOT NULL REFERENCES graphql_anycable_subscriptions(id) ON DELETE CASCADE,
+        topic text NOT NULL,
+        fingerprint text NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (subscription_id, topic, fingerprint)
+      );
+
+      CREATE INDEX IF NOT EXISTS index_graphql_anycable_subscription_events_topic_fingerprint
+        ON graphql_anycable_subscription_events (topic, fingerprint);
+
+      CREATE INDEX IF NOT EXISTS index_graphql_anycable_subscription_events_fingerprint
+        ON graphql_anycable_subscription_events (fingerprint);
+
+      CREATE TABLE IF NOT EXISTS graphql_anycable_channel_subscriptions (
+        channel_id text NOT NULL,
+        subscription_id text NOT NULL REFERENCES graphql_anycable_subscriptions(id) ON DELETE CASCADE,
+        created_at timestamptz NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (channel_id, subscription_id)
+      );
+    SQL
+  end
+
+  def down
+    execute <<~SQL
+      DROP TABLE IF EXISTS graphql_anycable_channel_subscriptions;
+      DROP TABLE IF EXISTS graphql_anycable_subscription_events;
+      DROP TABLE IF EXISTS graphql_anycable_subscriptions;
+    SQL
+  end
+end

data/lib/graphql/anycable/postgresql_store/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "anyway"
+
+module GraphQL
+  module AnyCable
+    module PostgreSQLStore
+      class Config < Anyway::Config
+        config_name :graphql_anycable_postgresql_store
+        env_prefix :graphql_anycable_postgresql_store
+
+        attr_config postgres_url: nil
+        attr_config subscriptions_table: "graphql_anycable_subscriptions"
+        attr_config subscription_events_table: "graphql_anycable_subscription_events"
+        attr_config channel_subscriptions_table: "graphql_anycable_channel_subscriptions"
+      end
+    end
+  end
+end

data/lib/graphql/anycable/postgresql_store/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module GraphQL
+  module AnyCable
+    module PostgreSQLStore
+      class Railtie < Rails::Railtie
+      end
+    end
+  end
+end

data/lib/graphql/anycable/postgresql_store/store.rb

@@ -0,0 +1,266 @@
+# frozen_string_literal: true
+
+require "time"
+
+module GraphQL
+  module AnyCable
+    module PostgreSQLStore
+      class Store
+        SUBSCRIPTIONS_PREFIX = "subscriptions:"
+
+        def initialize(config: PostgreSQLStore.config, graphql_config: GraphQL::AnyCable.config)
+          load_pg!
+
+          @config = config
+          @graphql_config = graphql_config
+          @mutex = Mutex.new
+          @subscriptions_table = quote_table_name(config.subscriptions_table)
+          @events_table = quote_table_name(config.subscription_events_table)
+          @channels_table = quote_table_name(config.channel_subscriptions_table)
+        end
+
+        def stream_for(fingerprint)
+          "#{graphql_config.redis_prefix}-#{SUBSCRIPTIONS_PREFIX}#{fingerprint}"
+        end
+
+        def fingerprints_for_topic(topic)
+          with_connection do |conn|
+            conn.exec_params(<<~SQL, [topic]).map { |row| row.fetch("fingerprint") }
+              SELECT events.fingerprint
+              FROM #{events_table} events
+              INNER JOIN #{subscriptions_table} subscriptions
+                ON subscriptions.id = events.subscription_id
+              WHERE events.topic = $1
+                AND (subscriptions.expires_at IS NULL OR subscriptions.expires_at > CURRENT_TIMESTAMP)
+              GROUP BY events.fingerprint
+              ORDER BY COUNT(*) ASC, MIN(events.created_at) ASC
+            SQL
+          end
+        end
+
+        def subscription_ids_for_fingerprints(fingerprints)
+          result = fingerprints.to_h { |fingerprint| [fingerprint, []] }
+          return result if fingerprints.empty?
+
+          with_connection do |conn|
+            conn.exec_params(<<~SQL, fingerprints).each do |row|
+              SELECT events.fingerprint, events.subscription_id
+              FROM #{events_table} events
+              INNER JOIN #{subscriptions_table} subscriptions
+                ON subscriptions.id = events.subscription_id
+              WHERE events.fingerprint IN (#{placeholders(fingerprints.length)})
+                AND (subscriptions.expires_at IS NULL OR subscriptions.expires_at > CURRENT_TIMESTAMP)
+              ORDER BY events.fingerprint ASC, events.created_at ASC
+            SQL
+              result[row.fetch("fingerprint")] << row.fetch("subscription_id")
+            end
+          end
+
+          result
+        end
+
+        def subscription_exists?(subscription_id)
+          with_connection do |conn|
+            conn.exec_params(<<~SQL, [subscription_id]).getvalue(0, 0) == "t"
+              SELECT EXISTS (
+                SELECT 1
+                FROM #{subscriptions_table}
+                WHERE id = $1
+                  AND (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)
+              )
+            SQL
+          end
+        end
+
+        def write_subscription(subscription_id, channel_id:, data:, events:, expiration_seconds:)
+          expires_at = expiration_seconds ? (Time.now.utc + expiration_seconds).iso8601(6) : nil
+          subscription_params = [
+            subscription_id,
+            data.fetch(:query_string),
+            data.fetch(:variables),
+            data.fetch(:context),
+            data.fetch(:operation_name),
+            data.fetch(:events),
+            expires_at
+          ]
+
+          with_connection do |conn|
+            transaction(conn) do
+              conn.exec_params(<<~SQL, subscription_params)
+                INSERT INTO #{subscriptions_table}
+                  (id, query_string, variables, context, operation_name, events, expires_at, created_at, updated_at)
+                VALUES ($1, $2, $3, $4, $5, $6, $7, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+                ON CONFLICT (id) DO UPDATE SET
+                  query_string = EXCLUDED.query_string,
+                  variables = EXCLUDED.variables,
+                  context = EXCLUDED.context,
+                  operation_name = EXCLUDED.operation_name,
+                  events = EXCLUDED.events,
+                  expires_at = EXCLUDED.expires_at,
+                  updated_at = CURRENT_TIMESTAMP
+              SQL
+
+              conn.exec_params("DELETE FROM #{events_table} WHERE subscription_id = $1", [subscription_id])
+              conn.exec_params("DELETE FROM #{channels_table} WHERE subscription_id = $1", [subscription_id])
+              conn.exec_params(<<~SQL, [channel_id, subscription_id])
+                INSERT INTO #{channels_table} (channel_id, subscription_id, created_at)
+                VALUES ($1, $2, CURRENT_TIMESTAMP)
+                ON CONFLICT (channel_id, subscription_id) DO NOTHING
+              SQL
+
+              events.each do |event|
+                conn.exec_params(<<~SQL, [subscription_id, event.topic, event.fingerprint])
+                  INSERT INTO #{events_table} (subscription_id, topic, fingerprint, created_at)
+                  VALUES ($1, $2, $3, CURRENT_TIMESTAMP)
+                  ON CONFLICT (subscription_id, topic, fingerprint) DO NOTHING
+                SQL
+              end
+            end
+          end
+        end
+
+        def read_subscription(subscription_id)
+          with_connection do |conn|
+            result = conn.exec_params(<<~SQL, [subscription_id])
+              SELECT query_string, variables, context, operation_name
+              FROM #{subscriptions_table}
+              WHERE id = $1
+                AND (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)
+            SQL
+            return if result.ntuples.zero?
+
+            result.first.transform_keys(&:to_sym)
+          end
+        end
+
+        def delete_channel_subscriptions(channel_id)
+          with_connection do |conn|
+            transaction(conn) do
+              conn.exec_params(<<~SQL, [channel_id])
+                DELETE FROM #{subscriptions_table}
+                WHERE id IN (
+                  SELECT subscription_id
+                  FROM #{channels_table}
+                  WHERE channel_id = $1
+                )
+              SQL
+              conn.exec_params("DELETE FROM #{channels_table} WHERE channel_id = $1", [channel_id])
+            end
+          end
+        end
+
+        def delete_subscription(subscription_id)
+          with_connection do |conn|
+            conn.exec_params("DELETE FROM #{subscriptions_table} WHERE id = $1", [subscription_id])
+          end
+        end
+
+        def stats(scan_count:, include_subscriptions: false)
+          # PostgreSQL uses aggregate queries rather than key scans; scan_count
+          # is accepted to match graphql-anycable's store stats interface.
+          raise ArgumentError, "scan_count must be positive" if scan_count.to_i <= 0
+
+          with_connection do |conn|
+            result = {total: total_stats(conn)}
+            result[:subscriptions] = subscription_stats(conn) if include_subscriptions
+            result
+          end
+        end
+
+        private
+
+        attr_reader :channels_table, :config, :events_table, :graphql_config, :mutex, :subscriptions_table
+
+        def load_pg!
+          require "pg"
+        rescue LoadError
+          raise "Please, install the pg gem to use PostgreSQL GraphQL::AnyCable subscriptions"
+        end
+
+        def with_connection
+          mutex.synchronize { yield connection }
+        end
+
+        def connection
+          @connection ||= ::PG.connect(postgres_url)
+        end
+
+        def postgres_url
+          config.postgres_url ||
+            (::AnyCable.config.postgres_url if defined?(::AnyCable) && ::AnyCable.config.respond_to?(:postgres_url)) ||
+            ENV["DATABASE_URL"]
+        end
+
+        def transaction(conn)
+          conn.exec("BEGIN")
+          yield
+          conn.exec("COMMIT")
+        rescue
+          conn.exec("ROLLBACK")
+          raise
+        end
+
+        def placeholders(count)
+          Array.new(count) { |index| "$#{index + 1}" }.join(", ")
+        end
+
+        def total_stats(conn)
+          conn.exec_params(<<~SQL).first.transform_values(&:to_i).transform_keys(&:to_sym)
+            SELECT
+              (
+                SELECT COUNT(*)
+                FROM #{subscriptions_table}
+                WHERE #{active_subscription_sql}
+              ) AS subscription,
+              (
+                SELECT COUNT(DISTINCT events.topic)
+                FROM #{events_table} events
+                INNER JOIN #{subscriptions_table} subscriptions
+                  ON subscriptions.id = events.subscription_id
+                WHERE #{active_subscription_sql("subscriptions")}
+              ) AS fingerprints,
+              (
+                SELECT COUNT(DISTINCT events.fingerprint)
+                FROM #{events_table} events
+                INNER JOIN #{subscriptions_table} subscriptions
+                  ON subscriptions.id = events.subscription_id
+                WHERE #{active_subscription_sql("subscriptions")}
+              ) AS subscriptions,
+              (
+                SELECT COUNT(DISTINCT channels.channel_id)
+                FROM #{channels_table} channels
+                INNER JOIN #{subscriptions_table} subscriptions
+                  ON subscriptions.id = channels.subscription_id
+                WHERE #{active_subscription_sql("subscriptions")}
+              ) AS channel
+          SQL
+        end
+
+        def subscription_stats(conn)
+          conn.exec_params(<<~SQL).to_h { |row| [row.fetch("topic"), row.fetch("subscriptions").to_i] }
+            SELECT events.topic, COUNT(DISTINCT events.subscription_id) AS subscriptions
+            FROM #{events_table} events
+            INNER JOIN #{subscriptions_table} subscriptions
+              ON subscriptions.id = events.subscription_id
+            WHERE #{active_subscription_sql("subscriptions")}
+            GROUP BY events.topic
+            ORDER BY events.topic ASC
+          SQL
+        end
+
+        def active_subscription_sql(table_name = nil)
+          prefix = table_name ? "#{table_name}." : ""
+          "(#{prefix}expires_at IS NULL OR #{prefix}expires_at > CURRENT_TIMESTAMP)"
+        end
+
+        def quote_table_name(name)
+          parts = name.to_s.split(".")
+          raise ArgumentError, "PostgreSQL table name cannot be empty" if parts.empty? || parts.any?(&:empty?)
+          raise ArgumentError, "PostgreSQL table name must be table or schema.table" if parts.size > 2
+
+          parts.map { |part| ::PG::Connection.quote_ident(part) }.join(".")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/anycable/postgresql_store/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module AnyCable
+    module PostgreSQLStore
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/graphql/anycable/postgresql_store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "graphql-anycable"
+
+unless GraphQL::AnyCable.respond_to?(:register_subscription_store)
+  raise LoadError, "graphql-anycable_postgresql-store requires a graphql-anycable version with custom subscription stores"
+end
+
+require_relative "postgresql_store/version"
+require_relative "postgresql_store/config"
+require_relative "postgresql_store/store"
+require_relative "postgresql_store/railtie" if defined?(Rails::Railtie)
+
+module GraphQL
+  module AnyCable
+    module PostgreSQLStore
+      class << self
+        def config
+          @config ||= Config.new
+        end
+
+        def configure
+          yield(config) if block_given?
+        end
+      end
+    end
+  end
+end
+
+GraphQL::AnyCable.register_subscription_store(:postgresql) do
+  GraphQL::AnyCable::PostgreSQLStore::Store.new
+end
+
+GraphQL::AnyCable.register_subscription_store(:postgres) do
+  GraphQL::AnyCable::PostgreSQLStore::Store.new
+end

data/lib/graphql-anycable_postgresql-store.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "graphql/anycable/postgresql_store"

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: graphql-anycable_postgresql-store
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- TikiTDO
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: anyway_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: graphql-anycable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Stores graphql-anycable subscription state in PostgreSQL.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- graphql-anycable_postgresql-store.gemspec
+- lib/generators/graphql/anycable/postgresql_store/install_generator.rb
+- lib/generators/graphql/anycable/postgresql_store/templates/create_graphql_anycable_postgresql_store_tables.rb
+- lib/graphql-anycable_postgresql-store.rb
+- lib/graphql/anycable/postgresql_store.rb
+- lib/graphql/anycable/postgresql_store/config.rb
+- lib/graphql/anycable/postgresql_store/railtie.rb
+- lib/graphql/anycable/postgresql_store/store.rb
+- lib/graphql/anycable/postgresql_store/version.rb
+homepage: https://github.com/TikiTDO/graphql-anycable_postgresql-store
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/TikiTDO/graphql-anycable_postgresql-store/issues
+  changelog_uri: https://github.com/TikiTDO/graphql-anycable_postgresql-store/releases
+  homepage_uri: https://github.com/TikiTDO/graphql-anycable_postgresql-store
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/TikiTDO/graphql-anycable_postgresql-store
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: PostgreSQL subscription store for graphql-anycable.
+test_files: []