que-schema 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7527f5ce44a1b320c5d7614f8967b608ded6a21116ef4821855e49ca22fb1730
+  data.tar.gz: ac0e1cd4f0d2384cf5e7344724ad5075d261ce1383a6d63140c8d60071067308
+SHA512:
+  metadata.gz: a7c65e8a37a8d36feadac9be7fd2df507898b2711edc379ecbe2a317175569604d18b47e49fdf4e23f82e5f362161ed49f5e12e835321cd70ed38818743ec6a4
+  data.tar.gz: af2ffccca2ea04ae3d5ed731085100cedac5c9c709032c7c0a34e6fad606ef0585fad059877add945aa7315da6c04c757dd1fcedf41f2f94a5b60b29aadf9a65

data/.github/workflows/release.yml

@@ -0,0 +1,15 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        type: boolean
+        default: false
+        description: "Test without publishing to RubyGems"
+
+jobs:
+  release:
+    uses: SOFware/reissue/.github/workflows/shared-ruby-gem-release.yml@main
+    with:
+      dry_run: ${{ inputs.dry_run }}

data/.github/workflows/test.yml

@@ -0,0 +1,39 @@
+name: Test
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports: ["5432:5432"]
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      DATABASE_URL: postgresql://postgres:postgres@localhost:5432/que_schema_test
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "4.0"
+          bundler-cache: true
+
+      - name: Run tests
+        run: bundle exec rake

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# CHANGELOG
+
+
+
+## [0.1.0] - 2026-03-09
+
+### Added
+
+- Schema dump/load support for Que via ActiveRecord integration (0aa34d1)

data/Gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "pg"
+gem "reissue"
+gem "rspec", "~> 3.0"
+gem "simplecov"
+gem "simplecov_json_formatter"
+gem "standardrb"

data/Gemfile.lock

@@ -0,0 +1,238 @@
+PATH
+  remote: .
+  specs:
+    que-schema (0.1.0)
+      activerecord (>= 6.0)
+      que
+      railties (>= 6.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (8.1.2)
+      actionview (= 8.1.2)
+      activesupport (= 8.1.2)
+      nokogiri (>= 1.8.5)
+      rack (>= 2.2.4)
+      rack-session (>= 1.0.1)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+      useragent (~> 0.16)
+    actionview (8.1.2)
+      activesupport (= 8.1.2)
+      builder (~> 3.1)
+      erubi (~> 1.11)
+      rails-dom-testing (~> 2.2)
+      rails-html-sanitizer (~> 1.6)
+    activemodel (8.1.2)
+      activesupport (= 8.1.2)
+    activerecord (8.1.2)
+      activemodel (= 8.1.2)
+      activesupport (= 8.1.2)
+      timeout (>= 0.4.0)
+    activesupport (8.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ast (2.4.3)
+    base64 (0.3.0)
+    bigdecimal (4.0.1)
+    builder (3.3.0)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    crass (1.0.6)
+    date (3.5.1)
+    diff-lcs (1.6.2)
+    docile (1.4.1)
+    drb (2.2.3)
+    erb (6.0.2)
+    erubi (1.13.1)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    io-console (0.8.2)
+    irb (1.17.0)
+      pp (>= 0.6.0)
+      prism (>= 1.3.0)
+      rdoc (>= 4.0.0)
+      reline (>= 0.4.2)
+    json (2.18.1)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    logger (1.7.0)
+    loofah (2.25.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    minitest (6.0.2)
+      drb (~> 2.0)
+      prism (~> 1.5)
+    nokogiri (1.19.1-aarch64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.1-aarch64-linux-musl)
+      racc (~> 1.4)
+    nokogiri (1.19.1-arm-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.1-arm-linux-musl)
+      racc (~> 1.4)
+    nokogiri (1.19.1-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.1-x86_64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.19.1-x86_64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.19.1-x86_64-linux-musl)
+      racc (~> 1.4)
+    parallel (1.27.0)
+    parser (3.3.10.2)
+      ast (~> 2.4.1)
+      racc
+    pg (1.6.3)
+    pg (1.6.3-aarch64-linux)
+    pg (1.6.3-aarch64-linux-musl)
+    pg (1.6.3-arm64-darwin)
+    pg (1.6.3-x86_64-darwin)
+    pg (1.6.3-x86_64-linux)
+    pg (1.6.3-x86_64-linux-musl)
+    pp (0.6.3)
+      prettyprint
+    prettyprint (0.2.0)
+    prism (1.9.0)
+    psych (5.3.1)
+      date
+      stringio
+    que (2.4.1)
+    racc (1.8.1)
+    rack (3.2.5)
+    rack-session (2.1.1)
+      base64 (>= 0.1.0)
+      rack (>= 3.0.0)
+    rack-test (2.2.0)
+      rack (>= 1.3)
+    rackup (2.3.1)
+      rack (>= 3)
+    rails-dom-testing (2.3.0)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.7.0)
+      loofah (~> 2.25)
+      nokogiri (>= 1.15.7, != 1.16.7, != 1.16.6, != 1.16.5, != 1.16.4, != 1.16.3, != 1.16.2, != 1.16.1, != 1.16.0.rc1, != 1.16.0)
+    railties (8.1.2)
+      actionpack (= 8.1.2)
+      activesupport (= 8.1.2)
+      irb (~> 1.13)
+      rackup (>= 1.0.0)
+      rake (>= 12.2)
+      thor (~> 1.0, >= 1.2.2)
+      tsort (>= 0.2)
+      zeitwerk (~> 2.6)
+    rainbow (3.1.1)
+    rake (13.3.1)
+    rdoc (7.2.0)
+      erb
+      psych (>= 4.0.0)
+      tsort
+    regexp_parser (2.11.3)
+    reissue (0.4.18)
+      rake
+    reline (0.6.3)
+      io-console (~> 0.5)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rubocop (1.84.2)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.0)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-performance (1.26.1)
+      lint_roller (~> 1.1)
+      rubocop (>= 1.75.0, < 2.0)
+      rubocop-ast (>= 1.47.1, < 2.0)
+    ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.13.2)
+    simplecov_json_formatter (0.1.4)
+    standard (1.54.0)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.84.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.8)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.9.0)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.26.0)
+    standardrb (1.0.1)
+      standard
+    stringio (3.2.0)
+    thor (1.5.0)
+    timeout (0.6.0)
+    tsort (0.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+    uri (1.1.1)
+    useragent (0.16.11)
+    zeitwerk (2.7.5)
+
+PLATFORMS
+  aarch64-linux
+  aarch64-linux-gnu
+  aarch64-linux-musl
+  arm-linux-gnu
+  arm-linux-musl
+  arm64-darwin
+  x86_64-darwin
+  x86_64-linux
+  x86_64-linux-gnu
+  x86_64-linux-musl
+
+DEPENDENCIES
+  pg
+  que-schema!
+  rake (~> 13.0)
+  reissue
+  rspec (~> 3.0)
+  simplecov
+  simplecov_json_formatter
+  standardrb
+
+BUNDLED WITH
+   2.7.2

data/README.md

@@ -0,0 +1,69 @@
+# que-schema
+
+Enables **schema.rb** compatibility for the [que](https://github.com/que-rb/que) job queue gem. With this gem, you can use Rails' default `:ruby` schema format instead of being forced to `structure.sql`.
+
+## Why
+
+Que's migrations create PostgreSQL-specific objects (PL/pgSQL functions, triggers, UNLOGGED tables, storage options) that ActiveRecord's schema dumper doesn't represent in `schema.rb` by default. Apps using Que have typically had to set `config.active_record.schema_format = :sql` and maintain `structure.sql`. This gem patches the schema dump/load pipeline so all of Que's constructs round-trip through `schema.rb` with **zero changes** to your existing Que migrations.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "que-schema"
+```
+
+No configuration required. Keep using `schema.rb` (the default). If you were on `structure.sql` only for Que, you can switch back to `:ruby` and run `db:schema:dump`; the dump will include Que's schema via custom DSL calls.
+
+## How it works
+
+- **Dump:** The gem prepends into `ActiveRecord::SchemaDumper`. When it sees the `que_jobs` table (and reads the Que schema version from the table comment), it emits `que_define_schema(version: N)` after table definitions (tables must exist first because Que's functions reference the `public.que_jobs` type). Any `que_*` table detected as UNLOGGED via `pg_class` is written as `que_create_unlogged_table` instead of `create_table`. GIN indexes on `que_*` tables are detected dynamically and suppressed from the normal table dumps (they are recreated by `que_define_schema`). Fillfactor settings on `que_*` tables are also suppressed.
+- **Load:** `db:schema:load` runs your `schema.rb`. The gem adds `que_define_schema(version:)` and `que_create_unlogged_table` to the schema context. `que_define_schema` runs the stored SQL for that version (functions, triggers, indexes, fillfactor, table comment). `que_create_unlogged_table` is implemented as `create_table` + `ALTER TABLE ... SET UNLOGGED`.
+
+No monkey-patching of Que; everything is done by extending ActiveRecord.
+
+## Supported Que versions
+
+- **Que migration version 7** is supported (current).
+
+Support for older migration versions (e.g. 5, 6) can be added later by adding SQL assets under `lib/que_schema/sql/v5`, etc.
+
+## Requirements
+
+- Rails 6.0+
+- PostgreSQL (Que is PostgreSQL-only)
+- Ruby >= 2.7
+
+## Limitations
+
+- **PostgreSQL only.** The gem does nothing on SQLite/MySQL; it only runs when the adapter is PostgreSQL.
+- **UNLOGGED table:** `que_lockers` is created as UNLOGGED. If you run `db:schema:load` against a non-PostgreSQL database, that call would fail (expected).
+
+## Development
+
+### Tests
+
+Uses RSpec. Requires a running PostgreSQL. The test database (`que_schema_test`) is created automatically if it doesn't exist.
+
+```bash
+bundle install
+bundle exec rake
+```
+
+You can set `DATABASE_URL` to point to a different PostgreSQL instance:
+
+```bash
+export DATABASE_URL=postgresql://user:pass@host:5432/que_schema_test
+bundle exec rake
+```
+
+### Adding support for a new Que migration version
+
+1. Add a directory `lib/que_schema/sql/v<N>/` with `functions.sql`, `triggers.sql`, and optionally `down.sql`.
+2. Copy the exact `CREATE FUNCTION` / `CREATE TRIGGER` SQL from [que-rb/que](https://github.com/que-rb/que) for that version; use `CREATE OR REPLACE` and `DROP TRIGGER IF EXISTS` for idempotency.
+3. Extend the schema dumper version detection if the new version uses a different table comment or detection method.
+
+## License
+
+MIT.

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "reissue/gem"
+
+RSpec::Core::RakeTask.new(:spec)
+
+Reissue::Task.create :reissue do |task|
+  task.version_file = "lib/que_schema/version.rb"
+  task.fragment = :git
+  task.push_finalize = :branch
+end
+
+task default: :spec

data/checksums/que-schema-0.1.0.gem.sha512

@@ -0,0 +1 @@
+aae14df55017ee2128437cd923ce6c9cc34f56b8b53cb77a362750c7271ad172492a1df977b92397d669907a105f8650d2ed55aceb4cb0a05343dd13ec73327c

data/lib/que-schema.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "que_schema/version"
+require "que_schema/schema_statements"
+require "que_schema/schema_dumper"
+require "que_schema/migration_helpers"
+require "que_schema/railtie" if defined?(Rails)

data/lib/que_schema/migration_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "que"
+
+module QueSchema
+  # Convenience methods for migrations when setting up Que via ActiveRecord.
+  module MigrationHelpers
+    # Creates the Que schema for the given version.
+    # Delegates to Que.migrate! which handles everything.
+    def create_que_schema(version:)
+      que_define_schema(version: version)
+    end
+
+    # Drops the entire Que schema by migrating down to version 0.
+    # Removes all Que tables, functions, and triggers.
+    def drop_que_schema
+      return unless connection.adapter_name.match?(/postgresql/i)
+
+      Que.connection_proc = proc { |&block| block.call(connection.raw_connection) }
+      Que.migrate!(version: 0)
+    end
+  end
+end

data/lib/que_schema/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module QueSchema
+  class Railtie < ::Rails::Railtie
+    config.before_initialize do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Migration.include(QueSchema::SchemaStatements)
+        ActiveRecord::Migration.include(QueSchema::MigrationHelpers)
+        ActiveRecord::Schema.include(QueSchema::SchemaStatements)
+        ActiveRecord::SchemaDumper.prepend(QueSchema::SchemaDumper)
+      end
+    end
+  end
+end

data/lib/que_schema/schema_dumper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module QueSchema
+  # Prepended into ActiveRecord::SchemaDumper to emit que_define_schema
+  # and suppress Que-managed tables (Que.migrate! recreates them on load).
+  module SchemaDumper
+    private
+
+    def tables(stream)
+      super
+
+      if postgresql? && (version = que_schema_version) && version > 0
+        stream.puts "  # Que internal schema — emitted by que-schema gem"
+        stream.puts "  que_define_schema(version: #{version})"
+        stream.puts
+      end
+    end
+
+    # Suppress all que_* tables — Que.migrate! creates them during schema load.
+    def table(table_name, stream)
+      return if postgresql? && que_table?(table_name)
+
+      super
+    end
+
+    def que_schema_version
+      return nil unless @connection.table_exists?("que_jobs")
+
+      result = @connection.execute(<<~SQL)
+        SELECT obj_description(c.oid, 'pg_class') AS comment
+        FROM pg_class c
+        WHERE c.relname = 'que_jobs'
+        AND c.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
+      SQL
+      raw = result.first&.[]("comment") || result.first&.[](:comment)
+      raw.to_s.strip.to_i
+    end
+
+    def postgresql?
+      @connection.respond_to?(:adapter_name) && @connection.adapter_name.match?(/postgresql/i)
+    end
+
+    def que_table?(table_name)
+      table_name.start_with?("que_")
+    end
+  end
+end

data/lib/que_schema/schema_statements.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "que"
+
+module QueSchema
+  # DSL methods for schema.rb: available in ActiveRecord::Schema and ActiveRecord::Migration
+  # so that db:schema:load can execute que_define_schema.
+  module SchemaStatements
+    # Recreates the full Que schema for the given version by delegating to
+    # Que.migrate!. This creates tables, functions, triggers, indexes, and
+    # all other database objects that Que needs.
+    def que_define_schema(version:)
+      return unless postgresql?
+
+      Que.connection_proc = proc { |&block| block.call(connection.raw_connection) }
+      Que.migrate!(version: version.to_i)
+    end
+
+    private
+
+    def postgresql?
+      return false unless respond_to?(:connection)
+
+      conn = connection
+      conn.respond_to?(:adapter_name) && conn.adapter_name.match?(/postgresql/i)
+    end
+  end
+end

data/lib/que_schema/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module QueSchema
+  VERSION = "0.1.0"
+end

data/spec/integration_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "stringio"
+
+RSpec.describe "QueSchema integration (round-trip)" do
+  let(:conn) { QueSchema::Spec.connection }
+  let(:pool) { ActiveRecord::Base.connection_pool }
+
+  after do
+    QueSchema::Spec.clean!
+  end
+
+  it "full round-trip: create schema -> dump -> drop -> load -> verify" do
+    # Create schema via que_define_schema (which delegates to Que.migrate!)
+    c = conn
+    schema_context = Object.new.extend(QueSchema::SchemaStatements)
+    schema_context.define_singleton_method(:connection) { c }
+    schema_context.que_define_schema(version: 7)
+
+    # Dump schema
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(pool, stream)
+    schema_rb = stream.string
+
+    expect(schema_rb).to include("que_define_schema(version: 7)")
+    expect(schema_rb).not_to match(/create_table "que_jobs"/)
+    expect(schema_rb).not_to match(/create_table "que_lockers"/)
+    expect(schema_rb).not_to match(/create_table "que_values"/)
+
+    # Drop everything
+    QueSchema::Spec.clean!
+    expect(conn.table_exists?(:que_jobs)).to be false
+
+    # Load schema (eval the dumped schema)
+    eval(schema_rb) # rubocop:disable Security/Eval
+
+    # Verify tables were recreated by Que.migrate!
+    expect(conn.table_exists?(:que_jobs)).to be true
+    expect(conn.table_exists?(:que_values)).to be true
+    expect(conn.table_exists?(:que_lockers)).to be true
+
+    # Verify functions were recreated
+    r = conn.execute(<<~SQL)
+      SELECT proname FROM pg_proc
+      WHERE proname IN ('que_validate_tags', 'que_job_notify', 'que_determine_job_state', 'que_state_notify')
+    SQL
+    names = r.map { |row| row["proname"] || row[:proname] }
+    expect(names).to contain_exactly("que_validate_tags", "que_job_notify", "que_determine_job_state", "que_state_notify")
+
+    # Verify triggers were recreated
+    r = conn.execute(<<~SQL)
+      SELECT tgname FROM pg_trigger
+      WHERE tgrelid = 'que_jobs'::regclass
+      AND tgname IN ('que_job_notify', 'que_state_notify')
+    SQL
+    trigger_names = r.map { |row| row["tgname"] || row[:tgname] }
+    expect(trigger_names).to contain_exactly("que_job_notify", "que_state_notify")
+
+    # Verify que_lockers is UNLOGGED
+    r = conn.execute("SELECT relpersistence FROM pg_class WHERE relname = 'que_lockers'")
+    expect(r.first["relpersistence"] || r.first[:relpersistence]).to eq("u")
+
+    # Verify table comment (schema version)
+    r = conn.execute(<<~SQL)
+      SELECT obj_description(c.oid, 'pg_class') AS comment
+      FROM pg_class c
+      WHERE c.relname = 'que_jobs'
+    SQL
+    expect(r.first["comment"] || r.first[:comment]).to eq("7")
+
+    # Verify a job can be inserted
+    conn.execute("INSERT INTO que_jobs (queue, priority, job_class, args, data, job_schema_version) VALUES ('default', 100, 'TestJob', '[]', '{}', 7)")
+    count = conn.execute("SELECT count(*) AS cnt FROM que_jobs")
+    expect((count.first["cnt"] || count.first[:cnt]).to_i).to eq(1)
+  end
+end

data/spec/migration_helpers_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe QueSchema::MigrationHelpers do
+  let(:test_class) do
+    Class.new do
+      include QueSchema::SchemaStatements
+      include QueSchema::MigrationHelpers
+
+      attr_accessor :connection
+    end
+  end
+
+  let(:connection) { QueSchema::Spec.connection }
+  let(:instance) { test_class.new.tap { |i| i.connection = connection } }
+
+  after do
+    QueSchema::Spec.clean!
+  end
+
+  describe "#create_que_schema" do
+    it "delegates to que_define_schema" do
+      expect(instance).to receive(:que_define_schema).with(version: 7)
+      instance.create_que_schema(version: 7)
+    end
+
+    it "creates the full Que schema" do
+      instance.create_que_schema(version: 7)
+      expect(connection.table_exists?(:que_jobs)).to be true
+    end
+  end
+
+  describe "#drop_que_schema" do
+    it "removes all Que tables, functions, and triggers" do
+      instance.create_que_schema(version: 7)
+      expect(connection.table_exists?(:que_jobs)).to be true
+
+      instance.drop_que_schema
+      expect(connection.table_exists?(:que_jobs)).to be false
+      expect(connection.table_exists?(:que_values)).to be false
+      expect(connection.table_exists?(:que_lockers)).to be false
+    end
+
+    context "when not PostgreSQL" do
+      let(:connection) { double("connection", adapter_name: "SQLite") }
+
+      it "does nothing" do
+        expect(connection).not_to receive(:execute)
+        instance.drop_que_schema
+      end
+    end
+  end
+end

data/spec/que_schema_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe QueSchema do
+  it "has a version number" do
+    expect(QueSchema::VERSION).to be_a(String)
+    expect(QueSchema::VERSION).not_to be_empty
+  end
+
+  it "defines SchemaStatements module" do
+    expect(QueSchema::SchemaStatements).to be_a(Module)
+  end
+
+  it "defines SchemaDumper module" do
+    expect(QueSchema::SchemaDumper).to be_a(Module)
+  end
+
+  it "defines MigrationHelpers module" do
+    expect(QueSchema::MigrationHelpers).to be_a(Module)
+  end
+
+  it "includes SchemaStatements in ActiveRecord::Migration" do
+    expect(ActiveRecord::Migration.ancestors).to include(QueSchema::SchemaStatements)
+  end
+
+  it "includes MigrationHelpers in ActiveRecord::Migration" do
+    expect(ActiveRecord::Migration.ancestors).to include(QueSchema::MigrationHelpers)
+  end
+
+  it "includes SchemaStatements in ActiveRecord::Schema" do
+    expect(ActiveRecord::Schema.ancestors).to include(QueSchema::SchemaStatements)
+  end
+
+  it "prepends SchemaDumper into ActiveRecord::SchemaDumper" do
+    expect(ActiveRecord::SchemaDumper.ancestors).to include(QueSchema::SchemaDumper)
+  end
+end

data/spec/railtie_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+if defined?(Rails)
+  RSpec.describe QueSchema::Railtie do
+    it "is defined as a Rails::Railtie subclass" do
+      # We can't fully test Railtie without Rails, but we can verify the class
+      # is loadable and structured correctly when Rails is defined.
+      expect(QueSchema::Railtie).to be < Rails::Railtie
+    end
+  end
+end
+
+# When Rails is not defined, just verify the file doesn't blow up
+RSpec.describe "QueSchema without Rails" do
+  it "does not load Railtie when Rails is not defined" do
+    # que-schema.rb guards: require "que_schema/railtie" if defined?(Rails)
+    # Since we're not in a Rails app, Railtie may or may not be loaded
+    # depending on test ordering, but the gem should work without Rails
+    expect(defined?(QueSchema)).to eq("constant")
+  end
+end

data/spec/schema_dumper_spec.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "stringio"
+
+RSpec.describe QueSchema::SchemaDumper do
+  let(:connection) { double("connection") }
+
+  let(:dumper_class) do
+    mod = described_class
+    Class.new do
+      prepend mod
+
+      attr_accessor :connection
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def tables(stream)
+        stream.puts "  # original tables output"
+      end
+
+      def table(table_name, stream)
+        stream.puts "  create_table \"#{table_name}\", force: :cascade do |t|"
+        stream.puts "  end"
+      end
+
+      private :tables, :table
+    end
+  end
+
+  let(:dumper) { dumper_class.new(connection) }
+
+  def stub_postgresql!
+    allow(connection).to receive(:adapter_name).and_return("PostgreSQL")
+    allow(connection).to receive(:respond_to?).with(:adapter_name).and_return(true)
+  end
+
+  describe "#tables" do
+    context "when PostgreSQL with que_jobs" do
+      before do
+        stub_postgresql!
+        allow(connection).to receive(:table_exists?).with("que_jobs").and_return(true)
+        allow(connection).to receive(:execute).and_return([{"comment" => "7"}])
+      end
+
+      it "emits que_define_schema after tables" do
+        stream = StringIO.new
+        dumper.send(:tables, stream)
+        output = stream.string
+
+        expect(output).to include("que_define_schema(version: 7)")
+        expect(output).to include("# original tables output")
+        expect(output.index("que_define_schema")).to be > output.index("original tables")
+      end
+    end
+
+    context "when PostgreSQL without que_jobs" do
+      before do
+        stub_postgresql!
+        allow(connection).to receive(:table_exists?).with("que_jobs").and_return(false)
+      end
+
+      it "does not emit que_define_schema" do
+        stream = StringIO.new
+        dumper.send(:tables, stream)
+        expect(stream.string).not_to include("que_define_schema")
+      end
+    end
+
+    context "when not PostgreSQL" do
+      before do
+        allow(connection).to receive(:adapter_name).and_return("SQLite")
+        allow(connection).to receive(:respond_to?).with(:adapter_name).and_return(true)
+      end
+
+      it "does not emit que_define_schema" do
+        stream = StringIO.new
+        dumper.send(:tables, stream)
+        expect(stream.string).not_to include("que_define_schema")
+      end
+    end
+
+    context "when comment is nil" do
+      before do
+        stub_postgresql!
+        allow(connection).to receive(:table_exists?).with("que_jobs").and_return(true)
+        allow(connection).to receive(:execute).and_return([{"comment" => nil}])
+      end
+
+      it "does not emit que_define_schema when version is 0" do
+        stream = StringIO.new
+        dumper.send(:tables, stream)
+        expect(stream.string).not_to include("que_define_schema")
+      end
+    end
+  end
+
+  describe "#table" do
+    context "when PostgreSQL" do
+      before { stub_postgresql! }
+
+      it "suppresses que_* tables" do
+        stream = StringIO.new
+        dumper.send(:table, "que_jobs", stream)
+        expect(stream.string).to be_empty
+      end
+
+      it "suppresses que_lockers" do
+        stream = StringIO.new
+        dumper.send(:table, "que_lockers", stream)
+        expect(stream.string).to be_empty
+      end
+
+      it "suppresses que_values" do
+        stream = StringIO.new
+        dumper.send(:table, "que_values", stream)
+        expect(stream.string).to be_empty
+      end
+
+      it "suppresses any future que_* table" do
+        stream = StringIO.new
+        dumper.send(:table, "que_something_new", stream)
+        expect(stream.string).to be_empty
+      end
+
+      it "does not suppress non-que tables" do
+        stream = StringIO.new
+        dumper.send(:table, "users", stream)
+        expect(stream.string).to include('create_table "users"')
+      end
+    end
+
+    context "when not PostgreSQL" do
+      before do
+        allow(connection).to receive(:adapter_name).and_return("SQLite")
+        allow(connection).to receive(:respond_to?).with(:adapter_name).and_return(true)
+      end
+
+      it "does not suppress que_* tables" do
+        stream = StringIO.new
+        dumper.send(:table, "que_jobs", stream)
+        expect(stream.string).to include('create_table "que_jobs"')
+      end
+    end
+  end
+
+  describe "#que_table? (private)" do
+    it "returns true for que_ prefixed tables" do
+      expect(dumper.send(:que_table?, "que_jobs")).to be true
+      expect(dumper.send(:que_table?, "que_lockers")).to be true
+      expect(dumper.send(:que_table?, "que_values")).to be true
+      expect(dumper.send(:que_table?, "que_new_future_table")).to be true
+    end
+
+    it "returns false for non-que tables" do
+      expect(dumper.send(:que_table?, "users")).to be false
+      expect(dumper.send(:que_table?, "queue_items")).to be false
+    end
+  end
+
+  describe "#que_schema_version (private)" do
+    it "returns the version from the table comment" do
+      allow(connection).to receive(:table_exists?).with("que_jobs").and_return(true)
+      allow(connection).to receive(:execute).and_return([{"comment" => "7"}])
+      expect(dumper.send(:que_schema_version)).to eq(7)
+    end
+
+    it "returns nil when que_jobs does not exist" do
+      allow(connection).to receive(:table_exists?).with("que_jobs").and_return(false)
+      expect(dumper.send(:que_schema_version)).to be_nil
+    end
+
+    it "returns 0 when comment is nil" do
+      allow(connection).to receive(:table_exists?).with("que_jobs").and_return(true)
+      allow(connection).to receive(:execute).and_return([{"comment" => nil}])
+      expect(dumper.send(:que_schema_version)).to eq(0)
+    end
+
+    it "returns 0 when no rows returned" do
+      allow(connection).to receive(:table_exists?).with("que_jobs").and_return(true)
+      allow(connection).to receive(:execute).and_return([])
+      expect(dumper.send(:que_schema_version)).to eq(0)
+    end
+
+    it "handles symbol key for comment" do
+      allow(connection).to receive(:table_exists?).with("que_jobs").and_return(true)
+      allow(connection).to receive(:execute).and_return([{comment: "7"}])
+      expect(dumper.send(:que_schema_version)).to eq(7)
+    end
+  end
+
+  describe "#postgresql? (private)" do
+    it "returns true for PostgreSQL" do
+      allow(connection).to receive(:respond_to?).with(:adapter_name).and_return(true)
+      allow(connection).to receive(:adapter_name).and_return("PostgreSQL")
+      expect(dumper.send(:postgresql?)).to be true
+    end
+
+    it "returns false for non-PostgreSQL" do
+      allow(connection).to receive(:respond_to?).with(:adapter_name).and_return(true)
+      allow(connection).to receive(:adapter_name).and_return("SQLite")
+      expect(dumper.send(:postgresql?)).to be false
+    end
+
+    it "returns false when adapter_name is not available" do
+      allow(connection).to receive(:respond_to?).with(:adapter_name).and_return(false)
+      expect(dumper.send(:postgresql?)).to be false
+    end
+  end
+end

data/spec/schema_load_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "QueSchema schema load" do
+  let(:conn) { QueSchema::Spec.connection }
+
+  after do
+    QueSchema::Spec.clean!
+  end
+
+  it "que_define_schema(version: 7) creates the full Que schema" do
+    c = conn
+    schema_context = Object.new
+    schema_context.extend(QueSchema::SchemaStatements)
+    schema_context.define_singleton_method(:connection) { c }
+    schema_context.que_define_schema(version: 7)
+
+    # Tables
+    expect(conn.table_exists?(:que_jobs)).to be true
+    expect(conn.table_exists?(:que_values)).to be true
+    expect(conn.table_exists?(:que_lockers)).to be true
+
+    # Functions
+    r = conn.execute(<<~SQL)
+      SELECT proname FROM pg_proc WHERE proname IN ('que_validate_tags', 'que_job_notify', 'que_determine_job_state', 'que_state_notify')
+    SQL
+    names = r.map { |row| row["proname"] || row[:proname] }
+    expect(names).to contain_exactly("que_validate_tags", "que_job_notify", "que_determine_job_state", "que_state_notify")
+
+    # Triggers
+    r = conn.execute("SELECT tgname FROM pg_trigger WHERE tgrelid = 'que_jobs'::regclass AND tgname IN ('que_job_notify', 'que_state_notify')")
+    names = r.map { |row| row["tgname"] || row[:tgname] }
+    expect(names).to contain_exactly("que_job_notify", "que_state_notify")
+  end
+
+  it "que_define_schema creates que_lockers as UNLOGGED" do
+    c = conn
+    schema_context = Object.new.extend(QueSchema::SchemaStatements)
+    schema_context.define_singleton_method(:connection) { c }
+    schema_context.que_define_schema(version: 7)
+
+    r = conn.execute("SELECT relpersistence FROM pg_class WHERE relname = 'que_lockers'")
+    expect(r.first["relpersistence"] || r.first[:relpersistence]).to eq("u")
+  end
+end

data/spec/schema_statements_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe QueSchema::SchemaStatements do
+  let(:test_class) do
+    Class.new do
+      include QueSchema::SchemaStatements
+
+      attr_accessor :connection
+    end
+  end
+
+  let(:connection) { QueSchema::Spec.connection }
+  let(:instance) { test_class.new.tap { |i| i.connection = connection } }
+
+  after do
+    QueSchema::Spec.clean!
+  end
+
+  describe "#que_define_schema" do
+    context "when not PostgreSQL" do
+      let(:connection) { double("connection", adapter_name: "SQLite") }
+
+      it "returns nil without executing SQL" do
+        expect(connection).not_to receive(:execute)
+        result = instance.que_define_schema(version: 7)
+        expect(result).to be_nil
+      end
+    end
+
+    context "when PostgreSQL" do
+      it "creates all Que tables, functions, and triggers for version 7" do
+        instance.que_define_schema(version: 7)
+
+        expect(connection.table_exists?(:que_jobs)).to be true
+        expect(connection.table_exists?(:que_values)).to be true
+        expect(connection.table_exists?(:que_lockers)).to be true
+
+        r = connection.execute("SELECT proname FROM pg_proc WHERE proname IN ('que_validate_tags', 'que_job_notify', 'que_determine_job_state', 'que_state_notify')")
+        names = r.map { |row| row["proname"] || row[:proname] }
+        expect(names).to contain_exactly("que_validate_tags", "que_job_notify", "que_determine_job_state", "que_state_notify")
+      end
+
+      it "creates que_lockers as UNLOGGED" do
+        instance.que_define_schema(version: 7)
+
+        r = connection.execute("SELECT relpersistence FROM pg_class WHERE relname = 'que_lockers'")
+        expect(r.first["relpersistence"] || r.first[:relpersistence]).to eq("u")
+      end
+
+      it "creates triggers on que_jobs" do
+        instance.que_define_schema(version: 7)
+
+        r = connection.execute("SELECT tgname FROM pg_trigger WHERE tgrelid = 'que_jobs'::regclass AND tgname IN ('que_job_notify', 'que_state_notify')")
+        names = r.map { |row| row["tgname"] || row[:tgname] }
+        expect(names).to contain_exactly("que_job_notify", "que_state_notify")
+      end
+
+      it "is idempotent" do
+        instance.que_define_schema(version: 7)
+        expect { instance.que_define_schema(version: 7) }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#postgresql? (private)" do
+    it "returns false when no connection method exists" do
+      obj = Object.new
+      obj.extend(QueSchema::SchemaStatements)
+      expect(obj.send(:postgresql?)).to be false
+    end
+
+    it "returns false for non-PostgreSQL adapters" do
+      fake_conn = double("connection", adapter_name: "Mysql2")
+      allow(fake_conn).to receive(:respond_to?).with(:adapter_name).and_return(true)
+      inst = test_class.new.tap { |i| i.connection = fake_conn }
+      expect(inst.send(:postgresql?)).to be false
+    end
+
+    it "returns true for PostgreSQL adapter" do
+      expect(instance.send(:postgresql?)).to be true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "simplecov"
+require "simplecov_json_formatter"
+SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::JSONFormatter
+])
+SimpleCov.start do
+  add_filter %r{spec/}
+  add_filter %r{vendor/}
+  minimum_coverage 90
+end
+
+require "active_record"
+require "que-schema"
+require "support/database"
+
+# Apply patches when running without Rails (Railtie only runs when Rails boots)
+ActiveRecord::Migration.include(QueSchema::SchemaStatements)
+ActiveRecord::Migration.include(QueSchema::MigrationHelpers)
+ActiveRecord::Schema.include(QueSchema::SchemaStatements)
+ActiveRecord::SchemaDumper.prepend(QueSchema::SchemaDumper)
+
+# Establish database connection for all specs
+QueSchema::Spec.establish_connection
+
+# Suppress migration output during tests
+ActiveRecord::Migration.verbose = false
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+end

data/spec/support/database.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "que"
+
+module QueSchema
+  module Spec
+    DATABASE_NAME = "que_schema_test"
+    DATABASE_URL = ENV["DATABASE_URL"] || "postgresql://localhost/#{DATABASE_NAME}"
+
+    def self.establish_connection
+      return if @connected
+
+      begin
+        ActiveRecord::Base.establish_connection(DATABASE_URL)
+        ActiveRecord::Base.connection.execute("SELECT 1")
+      rescue ActiveRecord::NoDatabaseError
+        create_database
+        ActiveRecord::Base.establish_connection(DATABASE_URL)
+      end
+
+      @connected = true
+    end
+
+    def self.create_database
+      base_url = DATABASE_URL.sub(%r{/[^/]+\z}, "/postgres")
+      ActiveRecord::Base.establish_connection(base_url)
+      ActiveRecord::Base.connection.create_database(DATABASE_NAME)
+    end
+
+    def self.connection
+      establish_connection
+      ActiveRecord::Base.connection
+    end
+
+    def self.clean!
+      conn = connection
+
+      # Delegate to Que.migrate! which drops everything in the correct order,
+      # respecting dependencies between constraints, functions, and tables.
+      Que.connection_proc = proc { |&block| block.call(conn.raw_connection) }
+      Que.migrate!(version: 0)
+    rescue
+      # If Que.migrate! fails (e.g. tables don't exist), dynamically discover
+      # and drop all que_* objects so we don't hardcode Que's internal names.
+      conn.execute(<<~SQL).each { |row| conn.execute("DROP TABLE IF EXISTS #{conn.quote_table_name(row["tablename"])} CASCADE") }
+        SELECT tablename FROM pg_tables WHERE schemaname = 'public' AND tablename LIKE 'que_%'
+      SQL
+      conn.execute(<<~SQL).each { |row| conn.execute("DROP FUNCTION IF EXISTS #{row["oid"]}::regprocedure CASCADE") }
+        SELECT oid FROM pg_proc WHERE proname LIKE 'que_%' AND pronamespace = 'public'::regnamespace
+      SQL
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: que-schema
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jim Gay
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: que
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: Patches Rails' ActiveRecord schema dumper so applications using que-rb/que
+  can use schema.rb instead of structure.sql. Round-trips Que's PostgreSQL functions,
+  triggers, and options through the Ruby schema format.
+email:
+- jim@saturnflyer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/release.yml"
+- ".github/workflows/test.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- checksums/que-schema-0.1.0.gem.sha512
+- lib/que-schema.rb
+- lib/que_schema/migration_helpers.rb
+- lib/que_schema/railtie.rb
+- lib/que_schema/schema_dumper.rb
+- lib/que_schema/schema_statements.rb
+- lib/que_schema/version.rb
+- spec/integration_spec.rb
+- spec/migration_helpers_spec.rb
+- spec/que_schema_spec.rb
+- spec/railtie_spec.rb
+- spec/schema_dumper_spec.rb
+- spec/schema_load_spec.rb
+- spec/schema_statements_spec.rb
+- spec/spec_helper.rb
+- spec/support/database.rb
+homepage: https://github.com/SOFware/que-schema
+licenses: []
+metadata:
+  homepage_uri: https://github.com/SOFware/que-schema
+  source_code_uri: https://github.com/SOFware/que-schema
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.5
+specification_version: 4
+summary: Enables schema.rb compatibility for the que job queue gem
+test_files: []