nats_pubsub 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a8b2a1a0ff0af4b6b51d7014811eccb2aa24b6481d4e8a297402c2d9efa088f5
+  data.tar.gz: a738e8679fe09033660b70936de917a875d24543815acd0e1035dd3b068741b6
+SHA512:
+  metadata.gz: dd2c9890448f3d1fd84e812d9210cc801d0f3226a2d69ce2f29ac2811bca0de1426effb90943ec9e2ebd60563c61c6f645624d42b40ef4606e2dc7e272c00427
+  data.tar.gz: 3aba338bb2e5db35d118f994901489f746f9ca7743ccc6f8afd615a925ae2895db9e78235e9f010557e37e37803815768f25486333d79bd9c94cedecbacea8b7

data/exe/nats_pubsub

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+
+options = {
+  environment: ENV['RAILS_ENV'] || 'development',
+  require: nil,
+  concurrency: ENV.fetch('CONCURRENCY', 5).to_i,
+  verbose: false
+}
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: nats_pubsub [options]'
+
+  opts.on('-r', '--require PATH', 'File to require (e.g., ./config/environment.rb)') do |path|
+    options[:require] = path
+  end
+
+  opts.on('-e', '--environment ENV', "Environment (default: #{options[:environment]})") do |env|
+    options[:environment] = env
+  end
+
+  opts.on('-c', '--concurrency NUM', Integer, 'Number of consumer threads (default: 5)') do |n|
+    options[:concurrency] = n
+  end
+
+  opts.on('-v', '--verbose', 'Verbose logging') do
+    options[:verbose] = true
+  end
+
+  opts.on('-h', '--help', 'Show this help') do
+    puts opts
+    puts "\nExamples:"
+    puts '  nats_pubsub -e production -c 10'
+    puts '  nats_pubsub -r ./config/environment.rb -c 5'
+    exit
+  end
+end.parse!
+
+require 'nats_pubsub'
+require 'nats_pubsub/cli'
+
+NatsPubsub::CLI.new(options).run

data/lib/generators/nats_pubsub/config/config_generator.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module NatsPubsub
+  module Generators
+    # Config generator that updates NatsPubsub configuration
+    #
+    # Usage:
+    #   rails generate nats_pubsub:config [options]
+    #
+    # Examples:
+    #   rails generate nats_pubsub:config --outbox
+    #   rails generate nats_pubsub:config --inbox
+    #   rails generate nats_pubsub:config --outbox --inbox
+    #   rails generate nats_pubsub:config --concurrency=10
+    #   rails generate nats_pubsub:config --env-file
+    #
+    # Options:
+    #   --outbox              Enable outbox pattern
+    #   --inbox               Enable inbox pattern
+    #   --concurrency=N       Set concurrency level (default: 5)
+    #   --max-deliver=N       Set max delivery attempts (default: 5)
+    #   --ack-wait=DURATION   Set ack wait timeout (default: 30s)
+    #   --env-file            Generate .env.example file
+    #   --force               Overwrite existing configuration
+    #
+    # This will:
+    #   - Update config/initializers/nats_pubsub.rb
+    #   - Optionally generate .env.example
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+      desc 'Updates NatsPubsub configuration'
+
+      class_option :outbox, type: :boolean, default: false,
+                            desc: 'Enable outbox pattern'
+      class_option :inbox, type: :boolean, default: false,
+                           desc: 'Enable inbox pattern'
+      class_option :concurrency, type: :numeric, default: nil,
+                                 desc: 'Set concurrency level'
+      class_option :max_deliver, type: :numeric, default: nil,
+                                 desc: 'Set max delivery attempts'
+      class_option :ack_wait, type: :string, default: nil,
+                              desc: 'Set ack wait timeout (e.g., 30s, 1m)'
+      class_option :env_file, type: :boolean, default: false,
+                              desc: 'Generate .env.example file'
+      class_option :force, type: :boolean, default: false,
+                           desc: 'Overwrite existing configuration'
+
+      def check_initializer_exists
+        @initializer_path = 'config/initializers/nats_pubsub.rb'
+        @initializer_exists = File.exist?(File.join(destination_root, @initializer_path))
+
+        unless @initializer_exists
+          say_status :error, 'NatsPubsub initializer not found. Run: rails generate nats_pubsub:initializer', :red
+          exit(1) unless options[:force]
+        end
+      end
+
+      def update_or_create_initializer
+        if @initializer_exists && !options[:force]
+          update_existing_initializer
+        else
+          create_new_initializer
+        end
+      end
+
+      def generate_env_file
+        return unless options[:env_file]
+
+        template 'env.example.tt', '.env.example'
+        say_status :created, '.env.example', :green
+      rescue StandardError => e
+        say_status :error, "Failed to create .env.example: #{e.message}", :red
+      end
+
+      def show_instructions
+        say "\n"
+        say_status :info, 'Configuration updated successfully!', :green
+        say "\n"
+
+        if options[:outbox] || options[:inbox]
+          say 'Next steps:', :yellow
+          say '  1. Run migrations if you enabled outbox/inbox:', :yellow
+          say '     rails db:migrate', :white
+          say "\n"
+        end
+
+        if options[:env_file]
+          say '  2. Copy .env.example to .env and configure:', :yellow
+          say '     cp .env.example .env', :white
+          say "\n"
+        end
+
+        say '  3. Restart your Rails server', :yellow
+        say "\n"
+      end
+
+      private
+
+      def update_existing_initializer
+        content = File.read(File.join(destination_root, @initializer_path))
+
+        content = update_outbox_setting(content) if options[:outbox]
+        content = update_inbox_setting(content) if options[:inbox]
+        content = update_concurrency_setting(content) if options[:concurrency]
+        content = update_max_deliver_setting(content) if options[:max_deliver]
+        content = update_ack_wait_setting(content) if options[:ack_wait]
+
+        File.write(File.join(destination_root, @initializer_path), content)
+        say_status :updated, @initializer_path, :green
+      end
+
+      def create_new_initializer
+        template 'nats_pubsub.rb.tt', @initializer_path
+        say_status :created, @initializer_path, :green
+      end
+
+      def update_outbox_setting(content)
+        content.gsub(/config\.use_outbox\s*=\s*\w+/, 'config.use_outbox = true')
+      end
+
+      def update_inbox_setting(content)
+        content.gsub(/config\.use_inbox\s*=\s*\w+/, 'config.use_inbox = true')
+      end
+
+      def update_concurrency_setting(content)
+        if content.match?(/config\.concurrency\s*=/)
+          content.gsub(/config\.concurrency\s*=\s*\d+/, "config.concurrency = #{options[:concurrency]}")
+        else
+          # Add concurrency setting after consumer tuning section
+          content.gsub(/(# Consumer Tuning\n)/, "\\1  config.concurrency = #{options[:concurrency]}\n")
+        end
+      end
+
+      def update_max_deliver_setting(content)
+        content.gsub(/config\.max_deliver\s*=\s*\d+/, "config.max_deliver = #{options[:max_deliver]}")
+      end
+
+      def update_ack_wait_setting(content)
+        content.gsub(/config\.ack_wait\s*=\s*['"][^'"]+['"]/, "config.ack_wait = '#{options[:ack_wait]}'")
+      end
+
+      # Template helper methods
+      def use_outbox?
+        options[:outbox]
+      end
+
+      def use_inbox?
+        options[:inbox]
+      end
+
+      def concurrency_value
+        options[:concurrency] || 5
+      end
+
+      def max_deliver_value
+        options[:max_deliver] || 5
+      end
+
+      def ack_wait_value
+        options[:ack_wait] || '30s'
+      end
+
+      def app_name
+        Rails.application.class.module_parent_name.underscore rescue 'app'
+      end
+
+      def rails_env
+        Rails.env rescue 'development'
+      end
+    end
+  end
+end

data/lib/generators/nats_pubsub/config/templates/env.example.tt

@@ -0,0 +1,46 @@
+# NatsPubsub Configuration
+# Copy this file to .env and configure for your environment
+
+# ===== NATS Connection =====
+
+# NATS server URLs (comma-separated for multiple servers)
+# Examples:
+#   Single server: nats://localhost:4222
+#   Multiple servers: nats://server1:4222,nats://server2:4222
+#   With auth: nats://user:pass@localhost:4222
+NATS_URLS=nats://localhost:4222
+
+# Environment prefix for subjects
+# Used to namespace events by environment (development, staging, production)
+NATS_ENV=<%= rails_env %>
+
+# Application name
+# Used in subject naming: {env}.{app_name}.{domain}.{resource}.{action}
+APP_NAME=<%= app_name %>
+
+# Destination app for cross-app data sync (optional)
+# Required when syncing data between different applications
+# DESTINATION_APP=other_app_name
+
+# ===== Connection Pool =====
+
+# Number of connections in the pool
+# Increase for high-concurrency workloads
+NATS_POOL_SIZE=5
+
+# Timeout for acquiring a connection (seconds)
+NATS_POOL_TIMEOUT=5
+
+# ===== Production Settings =====
+
+# For production, use these settings:
+
+# Multiple NATS servers for high availability
+# NATS_URLS=nats://nats1.example.com:4222,nats://nats2.example.com:4222,nats://nats3.example.com:4222
+
+# Production environment
+# NATS_ENV=production
+
+# Increase pool size for high traffic
+# NATS_POOL_SIZE=20
+# NATS_POOL_TIMEOUT=10

data/lib/generators/nats_pubsub/config/templates/nats_pubsub.rb.tt

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# NatsPubsub configuration
+NatsPubsub.configure do |config|
+  # ===== Connection Settings =====
+
+  # NATS server URLs (comma-separated for multiple servers)
+  config.nats_urls = ENV.fetch('NATS_URLS', 'nats://localhost:4222')
+
+  # Environment prefix for subjects (e.g., development, staging, production)
+  config.env = ENV.fetch('NATS_ENV', '<%= rails_env %>')
+
+  # Application name used in subject naming
+  config.app_name = ENV.fetch('APP_NAME', '<%= app_name %>')
+
+  # Destination app for cross-app data sync (optional)
+  config.destination_app = ENV.fetch('DESTINATION_APP', nil)
+
+  # ===== Connection Pool Settings =====
+
+  # Number of connections in the pool
+  config.connection_pool_size = ENV.fetch('NATS_POOL_SIZE', 5).to_i
+
+  # Timeout for acquiring a connection from the pool (seconds)
+  config.connection_pool_timeout = ENV.fetch('NATS_POOL_TIMEOUT', 5).to_i
+
+  # ===== Consumer Tuning =====
+
+  # Maximum number of delivery attempts before giving up
+  config.max_deliver = <%= max_deliver_value %>
+
+  # How long to wait for acknowledgment before redelivery
+  config.ack_wait = '<%= ack_wait_value %>'
+
+  # Backoff delays between retry attempts
+  config.backoff = %w[1s 5s 15s 30s 60s]
+
+  # Number of concurrent message processors
+  config.concurrency = <%= concurrency_value %>
+
+  # ===== Reliability Patterns =====
+
+  # Outbox Pattern: Store events in database before publishing
+  # Ensures at-least-once delivery and prevents event loss
+  config.use_outbox = <%= use_outbox? %>
+
+  # Inbox Pattern: Store received events for idempotency
+  # Prevents duplicate processing of the same event
+  config.use_inbox = <%= use_inbox? %>
+
+  # Dead Letter Queue: Send failed messages to DLQ after max attempts
+  config.use_dlq = true
+  config.dlq_max_attempts = 5
+  config.dlq_stream_suffix = '-dlq'
+
+  # ===== Model Configuration =====
+
+  # ActiveRecord models for outbox and inbox tables
+  # Override these if you use custom model names
+  config.outbox_model = 'NatsPubsub::OutboxEvent'
+  config.inbox_model = 'NatsPubsub::InboxEvent'
+
+  # ===== Logging =====
+
+  # Logger instance (defaults to Rails.logger)
+  config.logger = Rails.logger
+
+  # ===== Middleware Configuration =====
+
+  # Configure server-side middleware for message processing
+  # Middleware runs in the order they are added
+  #
+  # Example:
+  # config.server_middleware do |chain|
+  #   chain.add MyCustomMiddleware, arg1: 'value1'
+  #   chain.add AnotherMiddleware
+  # end
+end
+
+# ===== Important Notes =====
+#
+# 1. Outbox Pattern:
+#    - Requires running migrations: rails generate nats_pubsub:migrations
+#    - Ensures reliable event publishing even if NATS is down
+#    - Background worker publishes events from the outbox table
+#
+# 2. Inbox Pattern:
+#    - Requires running migrations: rails generate nats_pubsub:migrations
+#    - Prevents duplicate event processing (idempotency)
+#    - Useful for critical business operations
+#
+# 3. Environment Variables:
+#    - Use .env files or system environment variables
+#    - Generate example: rails generate nats_pubsub:config --env-file
+#
+# 4. Production Recommendations:
+#    - Enable outbox pattern for critical events
+#    - Enable inbox pattern for operations that must be idempotent
+#    - Use multiple NATS servers for high availability
+#    - Tune concurrency based on your workload
+#    - Monitor DLQ for persistent failures
+#
+# 5. Testing:
+#    - Use NatsPubsub::Testing.fake! in tests
+#    - See: packages/ruby/TESTING_GUIDE.md

data/lib/generators/nats_pubsub/initializer/initializer_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module NatsPubsub
+  module Generators
+    # Initializer generator that creates NatsPubsub configuration file
+    #
+    # Usage:
+    #   rails generate nats_pubsub:initializer
+    #
+    # This will create:
+    #   config/initializers/nats_pubsub.rb
+    #
+    # The initializer contains configuration for:
+    #   - NATS server connection
+    #   - Application settings
+    #   - JetStream options
+    #   - Logging configuration
+    #
+    # Example:
+    #   rails generate nats_pubsub:initializer
+    class InitializerGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+      desc 'Creates NatsPubsub initializer at config/initializers/nats_pubsub.rb'
+
+      def create_initializer
+        template 'nats_pubsub.rb', 'config/initializers/nats_pubsub.rb'
+        say_status :created, 'config/initializers/nats_pubsub.rb', :green
+      rescue StandardError => e
+        say_status :error, "Failed to create initializer: #{e.message}", :red
+        raise
+      end
+    end
+  end
+end

data/lib/generators/nats_pubsub/initializer/templates/nats_pubsub.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# NatsPubsub configuration
+NatsPubsub.configure do |config|
+  # NATS Connection
+  config.nats_urls       = ENV.fetch('NATS_URLS', 'nats://localhost:4222')
+  config.env             = ENV.fetch('NATS_ENV',  Rails.env)
+  config.app_name        = ENV.fetch('APP_NAME',  Rails.application.class.module_parent_name.underscore)
+  config.destination_app = ENV.fetch('DESTINATION_APP', nil) # required for cross-app data sync
+
+  # Consumer Tuning
+  config.max_deliver = 5
+  config.ack_wait    = '30s'
+  config.backoff     = %w[1s 5s 15s 30s 60s]
+
+  # Reliability Features
+  config.use_outbox = false
+  config.use_inbox  = false
+  config.use_dlq    = true
+
+  # Models (override if you keep custom AR classes)
+  config.outbox_model = 'NatsPubsub::OutboxEvent'
+  config.inbox_model  = 'NatsPubsub::InboxEvent'
+
+  # Logging
+  # config.logger = Rails.logger
+end

data/lib/generators/nats_pubsub/install/install_generator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module NatsPubsub
+  module Generators
+    # Install generator that creates NatsPubsub initializer and migrations
+    #
+    # Usage:
+    #   rails generate nats_pubsub:install
+    #
+    # Options:
+    #   --skip-initializer  Skip initializer generation
+    #   --skip-migrations   Skip migration generation
+    #
+    # Example:
+    #   rails generate nats_pubsub:install --skip-migrations
+    class InstallGenerator < Rails::Generators::Base
+      desc 'Creates NatsPubsub initializer and migrations'
+
+      class_option :skip_initializer, type: :boolean, default: false,
+                                      desc: 'Skip initializer generation'
+      class_option :skip_migrations, type: :boolean, default: false,
+                                     desc: 'Skip migration generation'
+
+      def create_initializer
+        return if options[:skip_initializer]
+
+        say_status :invoke, 'nats_pubsub:initializer', :green
+        Rails::Generators.invoke('nats_pubsub:initializer', [],
+                                 behavior: behavior,
+                                 destination_root: destination_root)
+      rescue StandardError => e
+        say_status :error, "Failed to create initializer: #{e.message}", :red
+        raise unless behavior == :revoke
+      end
+
+      def create_migrations
+        return if options[:skip_migrations]
+
+        say_status :invoke, 'nats_pubsub:migrations', :green
+        Rails::Generators.invoke('nats_pubsub:migrations', [],
+                                 behavior: behavior,
+                                 destination_root: destination_root)
+      rescue StandardError => e
+        say_status :error, "Failed to create migrations: #{e.message}", :red
+        raise unless behavior == :revoke
+      end
+
+      def show_next_steps
+        say "\n"
+        say_status :info, 'NatsPubsub installed successfully!', :green
+        say "\n"
+        say 'Next steps:', :yellow
+        say '  1. Review and configure:', :white
+        say '     config/initializers/nats_pubsub.rb', :white
+        say "\n"
+        say '  2. Run migrations (if using outbox/inbox):', :white
+        say '     rails db:migrate', :white
+        say "\n"
+        say '  3. Create your first subscriber:', :white
+        say '     rails generate nats_pubsub:subscriber UserNotification users.user', :white
+        say "\n"
+        say 'Additional generators:', :yellow
+        say '  • rails generate nats_pubsub:subscriber NAME [topics...]', :white
+        say '  • rails generate nats_pubsub:config [--outbox] [--inbox]', :white
+        say "\n"
+        say 'Documentation:', :yellow
+        say '  • Testing Guide: packages/ruby/TESTING_GUIDE.md', :white
+        say '  • Main README: README.md', :white
+        say "\n"
+      end
+    end
+  end
+end

data/lib/generators/nats_pubsub/migrations/migrations_generator.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module NatsPubsub
+  module Generators
+    # Migrations generator that creates Inbox and Outbox event tables
+    #
+    # Usage:
+    #   rails generate nats_pubsub:migrations
+    #
+    # This will create:
+    #   db/migrate/[timestamp]_create_nats_pubsub_outbox.rb
+    #   db/migrate/[timestamp]_create_nats_pubsub_inbox.rb
+    #
+    # The outbox table stores events to be published to NATS:
+    #   - Implements transactional outbox pattern
+    #   - Tracks publishing status and attempts
+    #   - Provides at-least-once delivery guarantee
+    #
+    # The inbox table stores received events from NATS:
+    #   - Prevents duplicate processing
+    #   - Tracks processing status
+    #   - Supports idempotency via event_id
+    #
+    # Example:
+    #   rails generate nats_pubsub:migrations
+    #   rake db:migrate
+    class MigrationsGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('templates', __dir__)
+      desc 'Creates Inbox/Outbox migrations for NatsPubsub'
+
+      def create_outbox_migration
+        name = 'create_nats_pubsub_outbox'
+        return say_status :skip, "migration #{name} already exists", :yellow if migration_exists?('db/migrate', name)
+
+        migration_template 'create_nats_pubsub_outbox.rb.erb', "db/migrate/#{name}.rb"
+        say_status :created, "db/migrate/#{name}.rb", :green
+      rescue StandardError => e
+        say_status :error, "Failed to create outbox migration: #{e.message}", :red
+        raise
+      end
+
+      def create_inbox_migration
+        name = 'create_nats_pubsub_inbox'
+        return say_status :skip, "migration #{name} already exists", :yellow if migration_exists?('db/migrate', name)
+
+        migration_template 'create_nats_pubsub_inbox.rb.erb', "db/migrate/#{name}.rb"
+        say_status :created, "db/migrate/#{name}.rb", :green
+      rescue StandardError => e
+        say_status :error, "Failed to create inbox migration: #{e.message}", :red
+        raise
+      end
+
+      # -- Rails::Generators::Migration plumbing --
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          Time.now.utc.strftime('%Y%m%d%H%M%S')
+        else
+          format('%.3d', current_migration_number(dirname) + 1)
+        end
+      end
+
+      private
+
+      def migration_exists?(dirname, file_name)
+        Dir.glob(File.join(dirname, '[0-9]*_*.rb')).grep(/\d+_#{file_name}\.rb$/).any?
+      end
+    end
+  end
+end

data/lib/generators/nats_pubsub/migrations/templates/create_nats_pubsub_inbox.rb.erb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class CreateNatsPubsubInbox < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  # Disable DDL transaction for concurrent index creation
+  disable_ddl_transaction!
+
+  def up
+    # Idempotency check - safe to run multiple times
+    return if table_exists?(:nats_pubsub_inbox)
+
+    create_table :nats_pubsub_inbox do |t|
+      t.string   :event_id                              # preferred dedupe key
+      t.string   :subject,     null: false
+      t.jsonb    :payload,     null: false, default: {}
+      t.jsonb    :headers,     null: false, default: {}
+      t.string   :stream
+      t.bigint   :stream_seq
+      t.integer  :deliveries
+      t.string   :status,      null: false, default: 'received' # received|processing|processed|failed
+      t.text     :last_error
+      t.datetime :received_at
+      t.datetime :processed_at
+      t.timestamps
+    end
+
+    # Add indexes concurrently to avoid table locks
+    # Partial unique index on event_id (when not null)
+    add_index :nats_pubsub_inbox, :event_id,
+              unique: true,
+              where: 'event_id IS NOT NULL',
+              algorithm: :concurrently,
+              if_not_exists: true
+
+    # Partial unique index on stream + stream_seq (when not null)
+    add_index :nats_pubsub_inbox, [:stream, :stream_seq],
+              unique: true,
+              where: 'stream IS NOT NULL AND stream_seq IS NOT NULL',
+              algorithm: :concurrently,
+              if_not_exists: true,
+              name: 'index_inbox_on_stream_and_seq'
+
+    # Index on status for filtering
+    add_index :nats_pubsub_inbox, :status,
+              algorithm: :concurrently,
+              if_not_exists: true
+
+    # Composite index for common queries (status + received_at)
+    add_index :nats_pubsub_inbox, [:status, :received_at],
+              algorithm: :concurrently,
+              if_not_exists: true,
+              name: 'index_inbox_on_status_and_received'
+
+    # Partial index for failed events
+    add_index :nats_pubsub_inbox, [:deliveries, :last_error],
+              where: "status = 'failed'",
+              algorithm: :concurrently,
+              if_not_exists: true,
+              name: 'index_inbox_failed_deliveries'
+
+    # Partial index for processed events (for cleanup)
+    add_index :nats_pubsub_inbox, :processed_at,
+              where: "status = 'processed'",
+              algorithm: :concurrently,
+              if_not_exists: true,
+              name: 'index_inbox_processed_at'
+
+    # GIN index for JSONB payload queries (PostgreSQL only)
+    if ActiveRecord::Base.connection.adapter_name.downcase.include?('postgres')
+      add_index :nats_pubsub_inbox, :payload,
+                using: :gin,
+                algorithm: :concurrently,
+                if_not_exists: true,
+                name: 'index_inbox_payload_gin'
+    end
+
+    # Database-level constraint for status values
+    execute <<-SQL
+      ALTER TABLE nats_pubsub_inbox
+      ADD CONSTRAINT check_inbox_status_values
+      CHECK (status IN ('received', 'processing', 'processed', 'failed'))
+    SQL
+  end
+
+  def down
+    # Safe rollback with checks
+    drop_table :nats_pubsub_inbox if table_exists?(:nats_pubsub_inbox)
+  end
+end