ruby_llm_community 1.0.0 → 1.1.0

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module RubyLLM
+  # Generator for RubyLLM Rails models and migrations
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    namespace 'ruby_llm:install'
+
+    source_root File.expand_path('templates', __dir__)
+
+    argument :model_mappings, type: :array, default: [], banner: 'chat:ChatName message:MessageName ...'
+
+    class_option :skip_active_storage, type: :boolean, default: false,
+                                       desc: 'Skip ActiveStorage installation and attachment setup'
+
+    desc 'Creates models and migrations for RubyLLM Rails integration\n' \
+         'Usage: rails g ruby_llm:install [chat:ChatName] [message:MessageName] ...'
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
+
+    def postgresql?
+      ::ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
+    rescue StandardError
+      false
+    end
+
+    def parse_model_mappings
+      @model_names = {
+        chat: 'Chat',
+        message: 'Message',
+        tool_call: 'ToolCall',
+        model: 'Model'
+      }
+
+      model_mappings.each do |mapping|
+        if mapping.include?(':')
+          key, value = mapping.split(':', 2)
+          @model_names[key.to_sym] = value.classify
+        end
+      end
+
+      @model_names
+    end
+
+    %i[chat message tool_call model].each do |type|
+      define_method("#{type}_model_name") do
+        @model_names ||= parse_model_mappings
+        @model_names[type]
+      end
+
+      define_method("#{type}_table_name") do
+        table_name_for(send("#{type}_model_name"))
+      end
+    end
+
+    def acts_as_chat_declaration
+      acts_as_chat_params = []
+      messages_assoc = message_model_name.tableize.to_sym
+      model_assoc = model_model_name.underscore.to_sym
+
+      if messages_assoc != :messages
+        acts_as_chat_params << "messages: :#{messages_assoc}"
+        if message_model_name != messages_assoc.to_s.classify
+          acts_as_chat_params << "message_class: '#{message_model_name}'"
+        end
+      end
+
+      if model_assoc != :model
+        acts_as_chat_params << "model: :#{model_assoc}"
+        acts_as_chat_params << "model_class: '#{model_model_name}'" if model_model_name != model_assoc.to_s.classify
+      end
+
+      if acts_as_chat_params.any?
+        "acts_as_chat #{acts_as_chat_params.join(', ')}"
+      else
+        'acts_as_chat'
+      end
+    end
+
+    def acts_as_message_declaration
+      params = []
+
+      add_message_association_params(params, :chat, chat_model_name)
+      add_message_association_params(params, :tool_calls, tool_call_model_name, tableize: true)
+      add_message_association_params(params, :model, model_model_name)
+
+      params.any? ? "acts_as_message #{params.join(', ')}" : 'acts_as_message'
+    end
+
+    private
+
+    def add_message_association_params(params, default_assoc, model_name, tableize: false)
+      assoc = tableize ? model_name.tableize.to_sym : model_name.underscore.to_sym
+
+      return if assoc == default_assoc
+
+      params << "#{default_assoc}: :#{assoc}"
+      expected_class = assoc.to_s.classify
+      params << "#{default_assoc.to_s.singularize}_class: '#{model_name}'" if model_name != expected_class
+    end
+
+    public
+
+    def acts_as_tool_call_declaration
+      acts_as_tool_call_params = []
+      message_assoc = message_model_name.underscore.to_sym
+
+      if message_assoc != :message
+        acts_as_tool_call_params << "message: :#{message_assoc}"
+        if message_model_name != message_assoc.to_s.classify
+          acts_as_tool_call_params << "message_class: '#{message_model_name}'"
+        end
+      end
+
+      if acts_as_tool_call_params.any?
+        "acts_as_tool_call #{acts_as_tool_call_params.join(', ')}"
+      else
+        'acts_as_tool_call'
+      end
+    end
+
+    def acts_as_model_declaration
+      acts_as_model_params = []
+      chats_assoc = chat_model_name.tableize.to_sym
+
+      if chats_assoc != :chats
+        acts_as_model_params << "chats: :#{chats_assoc}"
+        acts_as_model_params << "chat_class: '#{chat_model_name}'" if chat_model_name != chats_assoc.to_s.classify
+      end
+
+      if acts_as_model_params.any?
+        "acts_as_model #{acts_as_model_params.join(', ')}"
+      else
+        'acts_as_model'
+      end
+    end
+
+    def create_migration_files
+      # Create migrations with timestamps to ensure proper order
+      # First create chats table
+      migration_template 'create_chats_migration.rb.tt',
+                         "db/migrate/create_#{chat_table_name}.rb"
+
+      # Then create messages table (must come before tool_calls due to foreign key)
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_messages_migration.rb.tt',
+                         "db/migrate/create_#{message_table_name}.rb"
+
+      # Then create tool_calls table (references messages)
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_tool_calls_migration.rb.tt',
+                         "db/migrate/create_#{tool_call_table_name}.rb"
+
+      # Create models table
+      sleep 1 # Ensure different timestamp
+      migration_template 'create_models_migration.rb.tt',
+                         "db/migrate/create_#{model_table_name}.rb"
+    end
+
+    def create_model_files
+      template 'chat_model.rb.tt', "app/models/#{chat_model_name.underscore}.rb"
+      template 'message_model.rb.tt', "app/models/#{message_model_name.underscore}.rb"
+      template 'tool_call_model.rb.tt', "app/models/#{tool_call_model_name.underscore}.rb"
+
+      template 'model_model.rb.tt', "app/models/#{model_model_name.underscore}.rb"
+    end
+
+    def create_initializer
+      template 'initializer.rb.tt', 'config/initializers/ruby_llm.rb'
+    end
+
+    def install_active_storage
+      return if options[:skip_active_storage]
+
+      say '  Installing ActiveStorage for file attachments...', :cyan
+      rails_command 'active_storage:install'
+    end
+
+    def table_name_for(model_name)
+      # Convert namespaced model names to proper table names
+      # e.g., "Assistant::Chat" -> "assistant_chats" (not "assistant/chats")
+      model_name.underscore.pluralize.tr('/', '_')
+    end
+
+    def show_install_info
+      say "\n  ✅ RubyLLM installed!", :green
+
+      say '  ✅ ActiveStorage configured for file attachments support', :green unless options[:skip_active_storage]
+
+      say "\n  Next steps:", :yellow
+      say '     1. Run: rails db:migrate'
+      say '     2. Set your API keys in config/initializers/ruby_llm.rb'
+
+      say "     3. Start chatting: #{chat_model_name}.create!(model: 'gpt-4.1-nano').ask('Hello!')"
+
+      say "\n  🚀 Model registry is database-backed!", :cyan
+      say '     Models automatically load from the database'
+      say '     Pass model names as strings - RubyLLM handles the rest!'
+      say "     Specify provider when needed: Chat.create!(model: 'gemini-2.5-flash', provider: 'vertexai')"
+
+      if options[:skip_active_storage]
+        say "\n  📎 Note: ActiveStorage was skipped", :yellow
+        say '     File attachments won\'t work without ActiveStorage.'
+        say '     To enable later:'
+        say '       1. Run: rails active_storage:install && rails db:migrate'
+        say "       2. Add to your #{message_model_name} model: has_many_attached :attachments"
+      end
+
+      say "\n  📚 Documentation: https://rubyllm.com", :cyan
+
+      say "\n  ❤️  Love RubyLLM?", :magenta
+      say '     • ⭐ Star on GitHub: https://github.com/crmne/ruby_llm'
+      say '     • 🐦 Follow for updates: https://x.com/paolino'
+      say "\n"
+    end
+  end
+end

data/lib/generators/ruby_llm/install/templates/chat_model.rb.tt

@@ -1,3 +1,3 @@
-class <%= options[:chat_model_name] %> < ApplicationRecord
+class <%= chat_model_name %> < ApplicationRecord
   <%= acts_as_chat_declaration %>
-end
+end

data/lib/generators/ruby_llm/install/templates/create_chats_migration.rb.tt

@@ -1,8 +1,8 @@
-class Create<%= options[:chat_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class Create<%= chat_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :<%= options[:chat_model_name].tableize %> do |t|
-      t.string :model_id
+    create_table :<%= chat_table_name %> do |t|
+      t.references :<%= model_table_name.singularize %>, foreign_key: true
       t.timestamps
     end
   end
-end
+end

data/lib/generators/ruby_llm/install/templates/create_messages_migration.rb.tt

@@ -1,15 +1,16 @@
-# Migration for creating messages table with references to chats and tool_calls
-class Create<%= options[:message_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class Create<%= message_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :<%= options[:message_model_name].tableize %> do |t|
-      t.references :<%= options[:chat_model_name].tableize.singularize %>, null: false, foreign_key: true
-      t.string :role
+    create_table :<%= message_table_name %> do |t|
+      t.references :<%= chat_table_name.singularize %>, null: false, foreign_key: true
+      t.string :role, null: false
       t.text :content
-      t.string :model_id
+      t.references :<%= model_table_name.singularize %>, foreign_key: true
       t.integer :input_tokens
       t.integer :output_tokens
-      t.references :<%= options[:tool_call_model_name].tableize.singularize %>
+      t.references :<%= tool_call_table_name.singularize %>, foreign_key: true
       t.timestamps
     end
+
+    add_index :<%= message_table_name %>, :role
   end
 end

data/lib/generators/ruby_llm/install/templates/create_models_migration.rb.tt

@@ -1,6 +1,6 @@
-class Create<%= options[:model_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class Create<%= model_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :<%= options[:model_model_name].tableize %> do |t|
+    create_table :<%= model_table_name %> do |t|
       t.string :model_id, null: false
       t.string :name, null: false
       t.string :provider, null: false
@@ -30,5 +30,14 @@ class Create<%= options[:model_model_name].pluralize %> < ActiveRecord::Migratio
       t.index :modalities, using: :gin
 <% end %>
     end
+
+    # Load models from JSON
+    say_with_time "Loading models from models.json" do
+      RubyLLM.models.load_from_json!
+      model_class = '<%= model_model_name %>'.constantize
+      model_class.save_to_database
+
+      "Loaded #{model_class.count} models"
+    end
   end
-end
+end

data/lib/generators/ruby_llm/install/templates/create_tool_calls_migration.rb.tt

@@ -1,14 +1,15 @@
 <%#- # Migration for creating tool_calls table with database-specific JSON handling -%>
-class Create<%= options[:tool_call_model_name].pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class Create<%= tool_call_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
   def change
-    create_table :<%= options[:tool_call_model_name].tableize %> do |t|
-      t.references :<%= options[:message_model_name].tableize.singularize %>, null: false, foreign_key: true
+    create_table :<%= tool_call_table_name %> do |t|
+      t.references :<%= message_table_name.singularize %>, null: false, foreign_key: true
       t.string :tool_call_id, null: false
       t.string :name, null: false
       t.<%= postgresql? ? 'jsonb' : 'json' %> :arguments, default: {}
       t.timestamps
     end
 
-    add_index :<%= options[:tool_call_model_name].tableize %>, :tool_call_id
+    add_index :<%= tool_call_table_name %>, :tool_call_id, unique: true
+    add_index :<%= tool_call_table_name %>, :name
   end
-end
+end

data/lib/generators/ruby_llm/install/templates/initializer.rb.tt

@@ -1,11 +1,12 @@
 RubyLLM.configure do |config|
-  config.openai_api_key = ENV["OPENAI_API_KEY"]
-  config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
-
+  config.openai_api_key = Rails.application.credentials.dig(:openai_api_key)
   # config.default_model = "gpt-4.1-nano"
-<% unless options[:skip_model] %>
 
-  # Model registry persistence
-  config.model_registry_class = "<%= options[:model_model_name] %>"
-<% end %>
-end
+  # Use the new association-based acts_as API (recommended)
+  config.use_new_acts_as = true
+<% if model_model_name != 'Model' -%>
+
+  # Custom model registry class name
+  config.model_registry_class = "<%= model_model_name %>"
+<% end -%>
+end

data/lib/generators/ruby_llm/install/templates/message_model.rb.tt

@@ -1,3 +1,4 @@
-class <%= options[:message_model_name] %> < ApplicationRecord
-  <%= acts_as_message_declaration %>
-end
+class <%= message_model_name %> < ApplicationRecord
+  <%= acts_as_message_declaration %><% unless options[:skip_active_storage] %>
+  has_many_attached :attachments<% end %>
+end

data/lib/generators/ruby_llm/install/templates/model_model.rb.tt

@@ -1,6 +1,3 @@
-# frozen_string_literal: true
-
-# Model registry persistence
-class <%= options[:model_model_name] %> < ApplicationRecord
+class <%= model_model_name %> < ApplicationRecord
   <%= acts_as_model_declaration %>
-end
+end

data/lib/generators/ruby_llm/install/templates/tool_call_model.rb.tt

@@ -1,3 +1,3 @@
-class <%= options[:tool_call_model_name] %> < ApplicationRecord
+class <%= tool_call_model_name %> < ApplicationRecord
   <%= acts_as_tool_call_declaration %>
-end
+end

data/lib/generators/ruby_llm/upgrade_to_v1_7/templates/migration.rb.tt

@@ -0,0 +1,137 @@
+class MigrateToRubyLLMModelReferences < ActiveRecord::Migration<%= migration_version %>
+  def up
+    model_class = <%= model_model_name %>
+    chat_class = <%= chat_model_name %>
+    message_class = <%= message_model_name %>
+
+    # Then check for any models in existing data that aren't in models.json
+    say_with_time "Checking for additional models in existing data" do
+      collect_and_create_models(chat_class, :<%= chat_table_name %>, model_class)
+      collect_and_create_models(message_class, :<%= message_table_name %>, model_class)
+      model_class.count
+    end
+
+    # Migrate foreign keys
+    migrate_foreign_key(:<%= chat_table_name %>, chat_class, model_class, :<%= model_table_name.singularize %>)
+    migrate_foreign_key(:<%= message_table_name %>, message_class, model_class, :<%= model_table_name.singularize %>)
+  end
+
+  def down
+    # Remove foreign key references
+    if column_exists?(:<%= message_table_name %>, :<%= model_table_name.singularize %>_id)
+      remove_reference :<%= message_table_name %>, :<%= model_table_name.singularize %>, foreign_key: true
+    end
+
+    if column_exists?(:<%= chat_table_name %>, :<%= model_table_name.singularize %>_id)
+      remove_reference :<%= chat_table_name %>, :<%= model_table_name.singularize %>, foreign_key: true
+    end
+
+    # Restore original model_id string columns
+    if column_exists?(:<%= message_table_name %>, :model_id_string)
+      rename_column :<%= message_table_name %>, :model_id_string, :model_id
+    end
+
+    if column_exists?(:<%= chat_table_name %>, :model_id_string)
+      rename_column :<%= chat_table_name %>, :model_id_string, :model_id
+    end
+  end
+
+  private
+
+  def collect_and_create_models(record_class, table_name, model_class)
+    return unless column_exists?(table_name, :model_id)
+
+    has_provider = column_exists?(table_name, :provider)
+
+    # Collect unique model/provider combinations using read_attribute to bypass overrides
+    models_set = Set.new
+
+    record_class.find_each do |record|
+      model_id = record.read_attribute(:model_id)
+      next if model_id.blank?
+
+      provider = has_provider ? record.read_attribute(:provider) : nil
+      models_set.add([ model_id, provider ])
+    end
+
+    models_set.each do |model_id, provider|
+      find_or_create_model(model_id, provider, model_class)
+    end
+  end
+
+  def find_or_create_model(model_id, provider, model_class)
+    return if model_id.blank?
+
+    begin
+      model_info, _provider = RubyLLM.models.resolve(model_id, provider: provider)
+
+      model_class.find_or_create_by!(
+        model_id: model_info.id,
+        provider: model_info.provider
+      ) do |m|
+        m.name = model_info.name || model_info.id
+        m.family = model_info.family
+        m.model_created_at = model_info.created_at
+        m.context_window = model_info.context_window
+        m.max_output_tokens = model_info.max_output_tokens
+        m.knowledge_cutoff = model_info.knowledge_cutoff
+        m.modalities = model_info.modalities.to_h
+        m.capabilities = model_info.capabilities
+        m.pricing = model_info.pricing.to_h
+        m.metadata = model_info.metadata
+      end
+    rescue => e
+      # Skip models that can't be resolved - they'll need manual fixing
+      Rails.logger.warn "Skipping unresolvable model: #{model_id} - will need manual update"
+      nil
+    end
+  end
+
+
+  def migrate_foreign_key(table_name, record_class, model_class, foreign_key_name)
+    return unless column_exists?(table_name, :model_id)
+
+    # Check if we need to rename the string column to avoid collision
+    if column_exists?(table_name, :model_id) && !foreign_key_exists?(table_name, :models)
+      # Temporarily rename the string column
+      rename_column table_name, :model_id, :model_id_string
+    end
+
+    # Add the foreign key reference
+    unless column_exists?(table_name, "#{foreign_key_name}_id")
+      add_reference table_name, foreign_key_name, foreign_key: true
+    end
+
+    say_with_time "Migrating #{table_name} model references" do
+      record_class.reset_column_information
+      has_provider = column_exists?(table_name, :provider)
+
+      # Determine which column to read from (renamed or original)
+      model_id_column = column_exists?(table_name, :model_id_string) ? :model_id_string : :model_id
+
+      record_class.find_each do |record|
+        model_id = record.read_attribute(model_id_column)
+        next if model_id.blank?
+
+        provider = has_provider ? record.read_attribute(:provider) : nil
+
+        model = if has_provider && provider.present?
+          model_class.find_by(model_id: model_id, provider: provider)
+        else
+          find_model_for_record(model_id, model_class)
+        end
+
+        record.update_column("#{foreign_key_name}_id", model.id) if model
+      end
+    end
+  end
+
+  def find_model_for_record(model_id, model_class)
+    begin
+      model_info, _provider = RubyLLM.models.resolve(model_id)
+      model_class.find_by(model_id: model_info.id, provider: model_info.provider)
+    rescue => e
+      model_class.find_by(model_id: model_id)
+    end
+  end
+end

data/lib/generators/ruby_llm/upgrade_to_v1_7/upgrade_to_v1_7_generator.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module RubyLLM
+  class UpgradeToV17Generator < Rails::Generators::Base # rubocop:disable Style/Documentation
+    include Rails::Generators::Migration
+
+    namespace 'ruby_llm:upgrade_to_v1_7'
+    source_root File.expand_path('templates', __dir__)
+
+    # Override source_paths to include install templates
+    def self.source_paths
+      [
+        File.expand_path('templates', __dir__),
+        File.expand_path('../install/templates', __dir__)
+      ]
+    end
+
+    argument :model_mappings, type: :array, default: [], banner: 'chat:ChatName message:MessageName ...'
+
+    desc 'Upgrades existing RubyLLM apps to v1.7 with new Rails-like API\n' \
+         'Usage: rails g ruby_llm:upgrade_to_v1_7 [chat:ChatName] [message:MessageName] ...'
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    def parse_model_mappings
+      @model_names = {
+        chat: 'Chat',
+        message: 'Message',
+        tool_call: 'ToolCall',
+        model: 'Model'
+      }
+
+      model_mappings.each do |mapping|
+        if mapping.include?(':')
+          key, value = mapping.split(':', 2)
+          @model_names[key.to_sym] = value.classify
+        end
+      end
+
+      @model_names
+    end
+
+    %i[chat message tool_call model].each do |type|
+      define_method("#{type}_model_name") do
+        @model_names ||= parse_model_mappings
+        @model_names[type]
+      end
+
+      define_method("#{type}_table_name") do
+        table_name_for(send("#{type}_model_name"))
+      end
+    end
+
+    def create_migration_file
+      # First check if models table exists, if not create it
+      unless table_exists?(table_name_for(model_model_name))
+        migration_template 'create_models_migration.rb.tt',
+                           "db/migrate/create_#{table_name_for(model_model_name)}.rb",
+                           migration_version: migration_version,
+                           model_model_name: model_model_name
+
+        sleep 1 # Ensure different timestamp
+      end
+
+      migration_template 'migration.rb.tt',
+                         'db/migrate/migrate_to_ruby_llm_model_references.rb',
+                         migration_version: migration_version,
+                         chat_model_name: chat_model_name,
+                         message_model_name: message_model_name,
+                         tool_call_model_name: tool_call_model_name,
+                         model_model_name: model_model_name
+    end
+
+    def create_model_file
+      # Check if Model file already exists
+      model_path = "app/models/#{model_model_name.underscore}.rb"
+
+      if File.exist?(Rails.root.join(model_path))
+        say_status :skip, model_path, :yellow
+      else
+        create_file model_path do
+          <<~RUBY
+            class #{model_model_name} < ApplicationRecord
+              #{acts_as_model_declaration}
+            end
+          RUBY
+        end
+      end
+    end
+
+    def acts_as_model_declaration
+      acts_as_model_params = []
+      chats_assoc = chat_model_name.tableize.to_sym
+
+      if chats_assoc != :chats
+        acts_as_model_params << "chats: :#{chats_assoc}"
+        acts_as_model_params << "chat_class: '#{chat_model_name}'" if chat_model_name != chats_assoc.to_s.classify
+      end
+
+      if acts_as_model_params.any?
+        "acts_as_model #{acts_as_model_params.join(', ')}"
+      else
+        'acts_as_model'
+      end
+    end
+
+    def update_initializer
+      initializer_content = File.read('config/initializers/ruby_llm.rb')
+
+      unless initializer_content.include?('config.use_new_acts_as')
+        inject_into_file 'config/initializers/ruby_llm.rb', before: /^end/ do
+          lines = ["\n  # Enable the new Rails-like API", '  config.use_new_acts_as = true']
+          lines << "  config.model_registry_class = \"#{model_model_name}\"" if model_model_name != 'Model'
+          lines << "\n"
+          lines.join("\n")
+        end
+      end
+    rescue Errno::ENOENT
+      say_status :error, 'config/initializers/ruby_llm.rb not found', :red
+    end
+
+    def show_next_steps
+      say_status :success, 'Migration created!', :green
+      say <<~INSTRUCTIONS
+
+        Next steps:
+        1. Review the migration: db/migrate/*_migrate_to_ruby_llm_model_references.rb
+        2. Run: rails db:migrate
+        3. Update config/initializers/ruby_llm.rb as shown above
+        4. Test your application thoroughly
+
+        The migration will:
+        - Create the Models table if it doesn't exist
+        - Load all models from models.json
+        - Migrate your existing data to use foreign keys
+        - Preserve all existing data (string columns renamed to model_id_string)
+
+      INSTRUCTIONS
+    end
+
+    private
+
+    def migration_version
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
+
+    def table_name_for(model_name)
+      # Convert namespaced model names to proper table names
+      # e.g., "Assistant::Chat" -> "assistant_chats" (not "assistant/chats")
+      model_name.underscore.pluralize.tr('/', '_')
+    end
+
+    def table_exists?(table_name)
+      ::ActiveRecord::Base.connection.table_exists?(table_name)
+    rescue StandardError
+      false
+    end
+
+    def postgresql?
+      ::ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
+    rescue StandardError
+      false
+    end
+  end
+end