que-schema 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4438db2533fe5a222835a08cb3ba75791ee157b1b87753fcd304dc1c70bf4749
-  data.tar.gz: 2c4136d7b17cf7905b87b8496b609e0d79b6e510c0f3c32ea19076e8f1961aa1
+  metadata.gz: 2dd48b725a6da899c882691afa3af22e3b4e1a6a5253f69eded20bbfe52c59e7
+  data.tar.gz: 8f2fdde04cebaa445a54b7281674257a414de7a1ad26077f61a6c85db481b3b0
 SHA512:
-  metadata.gz: 6f42bf02fd3c6de18f3110ebc8315b053d78ee693861d3debd750ad6a6e2387536f4168c63fb6c509a517d36b5ae506bf6e0c746b94f96db8d598bfe34e63efd
-  data.tar.gz: 39e649e71e5d217345bb29e078c020d8c3f63da926dd587ee1ede1f310a6f93435bd889854efa69504837741abd4c716b46fa850570bd28a0e32fa9d015dff99
+  metadata.gz: 26cb3c0d957a76c85d7d66cc66f4c72f1dd9c0244e1a58626ab309f658381451e044daf49364b775dfa5e9696c6eb9b06fe9baf0b27295c1d354fa6408f18d35
+  data.tar.gz: c41c48b31d14db35ea739c888c5dd424f19f1d4f24a2dbd4778ac97144f8482e178b3f7e86384304df84f2e975b1831ba621b5d3d23447a46fca971a6784bcab

data/CHANGELOG.md

@@ -2,14 +2,22 @@
 
 
 
-## [0.1.1] - 2026-03-09
+## [0.1.3] - 2026-04-01
 
-### Fixed
+### Added
 
-- Schema dumper suppressing que_scheduler_* tables (1669e0d)
+- Automatic que-scheduler schema management when que-scheduler gem is present (2bf5b3b)
 
-## [0.1.0] - 2026-03-09
+## [0.1.2] - 2026-03-09
 
 ### Added
 
-- Schema dump/load support for Que via ActiveRecord integration (0aa34d1)
+- Suppress Que-managed functions and triggers in schema dump (629c074)
+
+### Fixed
+
+- Duplicate trigger errors during db:schema:load (629c074)
+
+### Changed
+
+- SchemaDumper prepend timing for correct ancestor order (629c074)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    que-schema (0.1.1)
+    que-schema (0.1.3)
       activerecord (>= 6.0)
       que
       railties (>= 6.0)

data/lib/que_schema/railtie.rb

@@ -7,8 +7,14 @@ module QueSchema
         ActiveRecord::Migration.include(QueSchema::SchemaStatements)
         ActiveRecord::Migration.include(QueSchema::MigrationHelpers)
         ActiveRecord::Schema.include(QueSchema::SchemaStatements)
-        ActiveRecord::SchemaDumper.prepend(QueSchema::SchemaDumper)
       end
     end
+
+    # Prepend SchemaDumper after initialization so it sits
+    # above Fx/Scenic in the ancestor chain and can filter
+    # out Que-managed functions and triggers.
+    config.after_initialize do
+      ActiveRecord::SchemaDumper.prepend(QueSchema::SchemaDumper)
+    end
   end
 end

data/lib/que_schema/schema_dumper.rb

@@ -7,13 +7,15 @@ module QueSchema
     private
 
     def tables(stream)
-      super
-
+      # Emit que_define_schema before tables so Que objects
+      # exist when later functions/triggers reference them.
       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
+
+      super
     end
 
     # Suppress Que-managed tables — Que.migrate! recreates them during
@@ -41,12 +43,78 @@ module QueSchema
       @connection.respond_to?(:adapter_name) && @connection.adapter_name.match?(/postgresql/i)
     end
 
-    # Only tables created by Que.migrate! — other que_* tables
-    # (e.g. que_scheduler_*) belong to separate gems.
-    QUE_MANAGED_TABLES = %w[que_jobs que_lockers que_values].freeze
+    # Only objects created by Que.migrate! — other que_*
+    # objects (e.g. que_scheduler_*) belong to separate gems
+    # unless que-schema manages them too.
+    QUE_MANAGED_TABLES = %w[
+      que_jobs que_lockers que_values
+    ].freeze
+
+    QUE_MANAGED_FUNCTIONS = %w[
+      que_validate_tags que_determine_job_state
+      que_job_notify que_state_notify
+    ].freeze
+
+    QUE_MANAGED_TRIGGERS = %w[
+      que_job_notify que_state_notify
+    ].freeze
+
+    QUE_SCHEDULER_TABLES = %w[
+      que_scheduler_audit que_scheduler_audit_enqueued
+    ].freeze
+
+    QUE_SCHEDULER_FUNCTIONS = %w[
+      que_scheduler_check_job_exists
+      que_scheduler_prevent_job_deletion
+    ].freeze
+
+    QUE_SCHEDULER_TRIGGERS = %w[
+      que_scheduler_prevent_job_deletion_trigger
+    ].freeze
+
+    def que_scheduler?
+      defined?(Que::Scheduler::Migrations)
+    end
 
     def que_table?(table_name)
-      QUE_MANAGED_TABLES.include?(table_name)
+      return true if QUE_MANAGED_TABLES.include?(table_name)
+      return true if que_scheduler? && QUE_SCHEDULER_TABLES.include?(table_name)
+
+      false
+    end
+
+    def que_function?(name)
+      return true if QUE_MANAGED_FUNCTIONS.include?(name.to_s)
+      return true if que_scheduler? && QUE_SCHEDULER_FUNCTIONS.include?(name.to_s)
+
+      false
+    end
+
+    def que_trigger?(name)
+      return true if QUE_MANAGED_TRIGGERS.include?(name.to_s)
+      return true if que_scheduler? && QUE_SCHEDULER_TRIGGERS.include?(name.to_s)
+
+      false
+    end
+
+    # Override Fx::SchemaDumper methods to filter out
+    # Que-managed objects when Fx is present.
+    def functions(stream)
+      return super unless postgresql? && defined?(::Fx)
+
+      dumpable = Fx.database.functions
+        .reject { |f| que_function?(f.name) }
+      dumpable.each { |f| stream.puts(f.to_schema) }
+      stream.puts if dumpable.any?
+    end
+
+    def triggers(stream)
+      return super unless postgresql? && defined?(::Fx)
+
+      dumpable = Fx.database.triggers
+        .reject { |t| que_trigger?(t.name) }
+      stream.puts if dumpable.any?
+      dumpable.each { |t| stream.puts(t.to_schema) }
     end
   end
 end

data/lib/que_schema/schema_statements.rb

@@ -14,6 +14,14 @@ module QueSchema
 
       Que.connection_proc = proc { |&block| block.call(connection.raw_connection) }
       Que.migrate!(version: version.to_i)
+      apply_que_scheduler_schema
+    end
+
+    def apply_que_scheduler_schema
+      return unless defined?(Que::Scheduler::Migrations)
+
+      Que::Scheduler::Migrations.migrate!(version: Que::Scheduler::Migrations::MAX_VERSION)
+      Que::Scheduler::Migrations.reenqueue_scheduler_if_missing
     end
 
     private

data/lib/que_schema/version.rb

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

data/spec/schema_dumper_spec.rb

@@ -45,14 +45,14 @@ RSpec.describe QueSchema::SchemaDumper do
         allow(connection).to receive(:execute).and_return([{"comment" => "7"}])
       end
 
-      it "emits que_define_schema after tables" do
+      it "emits que_define_schema before 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")
+        expect(output.index("que_define_schema")).to be < output.index("original tables")
       end
     end
 
@@ -146,6 +146,70 @@ RSpec.describe QueSchema::SchemaDumper do
     end
   end
 
+  describe "#que_function? (private)" do
+    it "returns true for Que-managed functions" do
+      %w[que_validate_tags que_determine_job_state que_job_notify que_state_notify].each do |name|
+        expect(dumper.send(:que_function?, name)).to be true
+      end
+    end
+
+    it "returns false for functions from other que_* gems" do
+      expect(dumper.send(:que_function?, "que_scheduler_check_job_exists")).to be false
+      expect(dumper.send(:que_function?, "que_scheduler_prevent_job_deletion")).to be false
+    end
+  end
+
+  describe "#que_trigger? (private)" do
+    it "returns true for Que-managed triggers" do
+      expect(dumper.send(:que_trigger?, "que_job_notify")).to be true
+      expect(dumper.send(:que_trigger?, "que_state_notify")).to be true
+    end
+
+    it "returns false for triggers from other que_* gems" do
+      expect(dumper.send(:que_trigger?, "que_scheduler_prevent_job_deletion_trigger")).to be false
+    end
+  end
+
+  describe "#functions (private)" do
+    let(:que_fn) { double("function", name: "que_job_notify", to_schema: '  create_function :que_job_notify') }
+    let(:app_fn) { double("function", name: "my_app_function", to_schema: '  create_function :my_app_function') }
+    let(:scheduler_fn) { double("function", name: "que_scheduler_check_job_exists", to_schema: '  create_function :que_scheduler_check_job_exists') }
+
+    before do
+      stub_postgresql!
+      stub_const("Fx", double("Fx", database: double(functions: [que_fn, app_fn, scheduler_fn])))
+    end
+
+    it "filters out Que-managed functions" do
+      stream = StringIO.new
+      dumper.send(:functions, stream)
+      output = stream.string
+
+      expect(output).not_to include("que_job_notify")
+      expect(output).to include("my_app_function")
+      expect(output).to include("que_scheduler_check_job_exists")
+    end
+  end
+
+  describe "#triggers (private)" do
+    let(:que_trigger) { double("trigger", name: "que_job_notify", to_schema: '  create_trigger :que_job_notify') }
+    let(:app_trigger) { double("trigger", name: "que_scheduler_prevent_job_deletion_trigger", to_schema: '  create_trigger :que_scheduler_prevent_job_deletion_trigger') }
+
+    before do
+      stub_postgresql!
+      stub_const("Fx", double("Fx", database: double(triggers: [que_trigger, app_trigger])))
+    end
+
+    it "filters out Que-managed triggers" do
+      stream = StringIO.new
+      dumper.send(:triggers, stream)
+      output = stream.string
+
+      expect(output).not_to include("que_job_notify")
+      expect(output).to include("que_scheduler_prevent_job_deletion_trigger")
+    end
+  end
+
   describe "#que_table? (private)" do
     it "returns true for Que-managed tables" do
       expect(dumper.send(:que_table?, "que_jobs")).to be true
@@ -164,6 +228,96 @@ RSpec.describe QueSchema::SchemaDumper do
     end
   end
 
+  context "when que-scheduler is present" do
+    before do
+      stub_const("Que::Scheduler::Migrations", double("Migrations"))
+    end
+
+    describe "#que_table?" do
+      it "suppresses que_scheduler tables" do
+        expect(dumper.send(:que_table?, "que_scheduler_audit")).to be true
+        expect(dumper.send(:que_table?, "que_scheduler_audit_enqueued")).to be true
+      end
+
+      it "still suppresses core que tables" do
+        expect(dumper.send(:que_table?, "que_jobs")).to be true
+      end
+
+      it "does not suppress non-que tables" do
+        expect(dumper.send(:que_table?, "users")).to be false
+      end
+    end
+
+    describe "#que_function?" do
+      it "suppresses que_scheduler functions" do
+        expect(dumper.send(:que_function?, "que_scheduler_check_job_exists")).to be true
+        expect(dumper.send(:que_function?, "que_scheduler_prevent_job_deletion")).to be true
+      end
+
+      it "still suppresses core que functions" do
+        expect(dumper.send(:que_function?, "que_job_notify")).to be true
+      end
+    end
+
+    describe "#que_trigger?" do
+      it "suppresses que_scheduler triggers" do
+        expect(dumper.send(:que_trigger?, "que_scheduler_prevent_job_deletion_trigger")).to be true
+      end
+
+      it "still suppresses core que triggers" do
+        expect(dumper.send(:que_trigger?, "que_job_notify")).to be true
+      end
+    end
+
+    describe "#table" do
+      before { stub_postgresql! }
+
+      it "suppresses que_scheduler_audit" do
+        stream = StringIO.new
+        dumper.send(:table, "que_scheduler_audit", stream)
+        expect(stream.string).to be_empty
+      end
+    end
+
+    describe "#functions" do
+      before do
+        stub_postgresql!
+        stub_const("Fx", double("Fx", database: double(functions: [
+          double("function", name: "que_scheduler_check_job_exists", to_schema: "  create_function :que_scheduler_check_job_exists"),
+          double("function", name: "my_app_function", to_schema: "  create_function :my_app_function")
+        ])))
+      end
+
+      it "filters out que_scheduler functions" do
+        stream = StringIO.new
+        dumper.send(:functions, stream)
+        output = stream.string
+
+        expect(output).not_to include("que_scheduler_check_job_exists")
+        expect(output).to include("my_app_function")
+      end
+    end
+
+    describe "#triggers" do
+      before do
+        stub_postgresql!
+        stub_const("Fx", double("Fx", database: double(triggers: [
+          double("trigger", name: "que_scheduler_prevent_job_deletion_trigger", to_schema: "  create_trigger :que_scheduler_prevent_job_deletion_trigger"),
+          double("trigger", name: "my_app_trigger", to_schema: "  create_trigger :my_app_trigger")
+        ])))
+      end
+
+      it "filters out que_scheduler triggers" do
+        stream = StringIO.new
+        dumper.send(:triggers, stream)
+        output = stream.string
+
+        expect(output).not_to include("que_scheduler_prevent_job_deletion_trigger")
+        expect(output).to include("my_app_trigger")
+      end
+    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)

data/spec/schema_statements_spec.rb

@@ -64,6 +64,46 @@ RSpec.describe QueSchema::SchemaStatements do
     end
   end
 
+  describe "que-scheduler integration" do
+    context "when Que::Scheduler::Migrations is defined" do
+      before do
+        scheduler_mod = Module.new do
+          class << self
+            attr_accessor :migrate_called_with, :reenqueue_called
+
+            def migrate!(version:)
+              self.migrate_called_with = version
+            end
+
+            def reenqueue_scheduler_if_missing
+              self.reenqueue_called = true
+            end
+          end
+        end
+        scheduler_mod.const_set(:MAX_VERSION, 8)
+        stub_const("Que::Scheduler::Migrations", scheduler_mod)
+      end
+
+      it "calls Que::Scheduler::Migrations.migrate! with MAX_VERSION" do
+        instance.que_define_schema(version: 7)
+
+        expect(Que::Scheduler::Migrations.migrate_called_with).to eq(8)
+      end
+
+      it "calls reenqueue_scheduler_if_missing" do
+        instance.que_define_schema(version: 7)
+
+        expect(Que::Scheduler::Migrations.reenqueue_called).to be true
+      end
+    end
+
+    context "when Que::Scheduler::Migrations is not defined" do
+      it "does not raise an error" do
+        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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: que-schema
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Jim Gay
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Enables schema.rb compatibility for the que job queue gem
 test_files: []