dbviewer 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3385fea543f18e7af2bd9a924b5095f76235612d569fc1e1a828222b8b1a3b53
-  data.tar.gz: 762f1ee1b3774c9186cbdac735beb0717c6a3feb64ffecd7833ec8732ce91898
+  metadata.gz: 53152d4109f427b7d3d32f38292f6c7add1aecc15e7bf9ce8db74458f24f8de8
+  data.tar.gz: dc556f4746314538c53a16cd1eabd811b91cfb6c35bee177971de3eae40f9f93
 SHA512:
-  metadata.gz: a1552e63407dd92eb3bfa821a4712f6cb57b5c68462c6028a9e3debe14f2e72ce073c631ec1616aa50a5158939ae667899ef4999c2ac5feff8a6f22edd783b08
-  data.tar.gz: 2852a40ddec1a2a86d2b9764bf527fd21dd140aa57a7ef36da6d7dcf312362c6b24b753c6badd04aee89328557136c954adbad95a442540a233f53affac5489c
+  metadata.gz: e4b267eee75e4a92a6a139e226834ff051e306524e1450833b644467b3661c83bffcadb9920450f1196c12919b474f6dca7c3cc6b12f352899c5803984c930e7
+  data.tar.gz: f62a2d830f539f8636522035fa60e08535f27c8b0cb77eed42c4baf1103171533e1b8327975a696f5d3c7125bfbc9ae4dc20c1a21d145b3f7b56117f95ccb742

data/README.md

@@ -32,6 +32,11 @@ It's designed for development, debugging, and database analysis, offering a clea
   - View table structure reference while writing queries
   - Protection against potentially harmful SQL operations
   - Query execution statistics and timing
+- **Multiple Database Connections**:
+  - Connect to multiple databases within your application
+  - Switch between connections on-the-fly to view different database schemas
+  - Add new database connections from the UI without code changes
+  - Test connections to verify they're working properly
 - **Enhanced UI Features**:
   - Responsive, Bootstrap-based interface that works on desktop and mobile
   - Fixed header navigation with quick access to all features
@@ -142,6 +147,34 @@ You can also create this file manually if you prefer.
 
 The configuration is accessed through `Dbviewer.configuration` throughout the codebase. You can also access it via `Dbviewer.config` which is an alias for backward compatibility.
 
+### Multiple Database Connections
+
+DBViewer supports working with multiple database connections in your application. This is useful for applications that connect to multiple databases or use different connection pools.
+
+To configure multiple database connections, set them up in your initializer:
+
+```ruby
+# config/initializers/dbviewer.rb
+Dbviewer.configure do |config|
+  # Multiple database connections configuration
+  config.database_connections = {
+    primary: {
+      connection_class: "ActiveRecord::Base",
+      name: "Primary Database"
+    },
+    secondary: {
+      connection_class: "SecondaryDatabase",
+      name: "Blog Database"
+    }
+  }
+
+  # Set the default active connection
+  config.current_connection = :primary
+end
+```
+
+Each connection needs to reference an ActiveRecord class that establishes a database connection. For more details, see [Multiple Database Connections](docs/multiple_connections.md).
+
 ## 🪵 Query Logging
 
 DBViewer includes a powerful SQL query logging system that captures and analyzes database queries. You can access this log through the `/dbviewer/logs` endpoint. The logging system offers two storage backends:
@@ -413,12 +446,6 @@ graph TB
     Engine -.->|"setup()"| QueryLogger
     Config -.->|"logging settings"| QueryLogger
 
-    classDef decoupled fill:#e1f5fe,stroke:#01579b,stroke-width:2px
-    classDef controller fill:#f3e5f5,stroke:#4a148c,stroke-width:2px
-    classDef database fill:#e8f5e8,stroke:#1b5e20,stroke-width:2px
-    classDef query fill:#fff3e0,stroke:#e65100,stroke-width:2px
-    classDef storage fill:#fce4ec,stroke:#880e4f,stroke-width:2px
-
     class CacheManager,QueryLogger decoupled
     class HomeController,TablesController,LogsController,ERDController,APIController controller
     class Manager,MetadataManager,DynamicModelFactory database

data/app/assets/javascripts/dbviewer/connections.js

@@ -0,0 +1,70 @@
+
+document.addEventListener('DOMContentLoaded', function() {
+  // Add connection form validation
+  const forms = document.querySelectorAll('.needs-validation');
+  
+  Array.from(forms).forEach(form => {
+    form.addEventListener('submit', event => {
+      if (!form.checkValidity()) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      
+      form.classList.add('was-validated');
+    }, false);
+  });
+  
+  // Handle connection test
+  const testButtons = document.querySelectorAll('.test-connection-btn');
+  
+  Array.from(testButtons).forEach(button => {
+    button.addEventListener('click', async function(event) {
+      event.preventDefault();
+      const connectionKey = this.dataset.connectionKey;
+      const statusElement = document.getElementById(`connection-status-${connectionKey}`);
+      
+      if (!statusElement) return;
+      
+      statusElement.innerHTML = '<i class="bi bi-arrow-repeat spin me-1"></i> Testing connection...';
+      statusElement.classList.remove('text-success', 'text-danger');
+      
+      try {
+        const response = await fetch(`/dbviewer/api/connections/${connectionKey}/test`, {
+          method: 'GET',
+          headers: {
+            'Accept': 'application/json',
+            'X-Requested-With': 'XMLHttpRequest'
+          }
+        });
+        
+        const data = await response.json();
+        
+        if (data.success) {
+          statusElement.innerHTML = '<i class="bi bi-check-circle-fill me-1"></i> Connection successful';
+          statusElement.classList.add('text-success');
+        } else {
+          statusElement.innerHTML = `<i class="bi bi-x-circle-fill me-1"></i> ${data.error || 'Connection failed'}`;
+          statusElement.classList.add('text-danger');
+        }
+      } catch (error) {
+        statusElement.innerHTML = '<i class="bi bi-x-circle-fill me-1"></i> Error testing connection';
+        statusElement.classList.add('text-danger');
+      }
+    });
+  });
+});
+
+// Auto-generate connection key from name
+function setupConnectionKeyGenerator() {
+  const nameInput = document.getElementById('connection_name');
+  const keyInput = document.getElementById('connection_key');
+  
+  if (nameInput && keyInput) {
+    nameInput.addEventListener('input', function() {
+      keyInput.value = this.value
+        .toLowerCase()
+        .replace(/\s+/g, '_')
+        .replace(/[^a-z0-9_]/g, '');
+    });
+  }
+}

data/app/controllers/concerns/dbviewer/database_operations.rb

@@ -5,12 +5,100 @@ module Dbviewer
     extend ActiveSupport::Concern
 
     included do
-      helper_method :current_table?, :get_database_name, :get_adapter_name if respond_to?(:helper_method)
+      helper_method :current_table?, :get_database_name, :get_adapter_name,
+                    :current_connection_key, :available_connections if respond_to?(:helper_method)
     end
 
-    # Initialize the database manager
+    # Get the current active connection key
+    def current_connection_key
+      # Get the connection key from the session or fall back to the default
+      key = session[:dbviewer_connection] || Dbviewer.configuration.current_connection
+
+      # Ensure the key actually exists in our configured connections
+      if key && Dbviewer.configuration.database_connections.key?(key.to_sym)
+        return key.to_sym
+      end
+
+      # If the key doesn't exist, fall back to any available connection
+      first_key = Dbviewer.configuration.database_connections.keys.first
+      if first_key
+        session[:dbviewer_connection] = first_key # Update the session
+        return first_key
+      end
+
+      # If there are no connections configured, use a default key
+      # This should never happen in normal operation, but it's a safety measure
+      :default
+    end
+
+    # Set the current connection to use
+    def switch_connection(connection_key)
+      connection_key = connection_key.to_sym if connection_key.respond_to?(:to_sym)
+
+      if connection_key && Dbviewer.configuration.database_connections.key?(connection_key)
+        session[:dbviewer_connection] = connection_key
+        # Clear the database manager to force it to be recreated with the new connection
+        @database_manager = nil
+        return true
+      else
+        # If the connection key doesn't exist, reset to default connection
+        if Dbviewer.configuration.database_connections.key?(Dbviewer.configuration.current_connection)
+          session[:dbviewer_connection] = Dbviewer.configuration.current_connection
+          @database_manager = nil
+          return true
+        else
+          # If even the default connection isn't valid, try the first available connection
+          first_key = Dbviewer.configuration.database_connections.keys.first
+          if first_key
+            session[:dbviewer_connection] = first_key
+            @database_manager = nil
+            return true
+          end
+        end
+      end
+
+      false # Return false if we couldn't set a valid connection
+    end
+
+    # Get list of available connections
+    def available_connections
+      connections = Dbviewer.configuration.database_connections.map do |key, config|
+        # Try to determine the adapter name if it's not already stored
+        adapter_name = nil
+        if config[:adapter_name].present?
+          adapter_name = config[:adapter_name]
+        elsif config[:connection].present?
+          begin
+            adapter_name = config[:connection].connection.adapter_name
+          rescue => e
+            Rails.logger.error("Error getting adapter name: #{e.message}")
+          end
+        end
+
+        {
+          key: key,
+          name: config[:name] || key.to_s.humanize,
+          adapter_name: adapter_name,
+          current: key.to_sym == current_connection_key.to_sym
+        }
+      end
+
+      # Ensure at least one connection is marked as current
+      unless connections.any? { |c| c[:current] }
+        # If no connection is current, mark the first one as current
+        if connections.any?
+          connections.first[:current] = true
+          # Also update the session
+          session[:dbviewer_connection] = connections.first[:key]
+        end
+      end
+
+      connections
+    end
+
+    # Initialize the database manager with the current connection
     def database_manager
-      @database_manager ||= ::Dbviewer::Database::Manager.new
+      @database_manager = ::Dbviewer::Database::Manager.new(current_connection_key)
     end
 
     # Initialize the table query operations manager
@@ -21,6 +109,12 @@ module Dbviewer
 
     # Get the name of the current database
     def get_database_name
+      # First check if this connection has a name in the configuration
+      current_conn_config = Dbviewer.configuration.database_connections[current_connection_key]
+      if current_conn_config && current_conn_config[:name].present?
+        return current_conn_config[:name]
+      end
+
       adapter = database_manager.connection.adapter_name.downcase
 
       case adapter
@@ -34,7 +128,7 @@ module Dbviewer
         result ? result["db_name"] : "Database"
       when /sqlite/
         # For SQLite, extract the database name from the connection_config
-        database_path = ActiveRecord::Base.connection.pool.spec.config[:database] || ""
+        database_path = database_manager.connection.pool.spec.config[:database] || ""
         File.basename(database_path, ".*") || "SQLite Database"
       else
         "Database" # Default fallback
@@ -68,11 +162,21 @@ module Dbviewer
           name: table_name
         }
 
-        # Only fetch record counts if explicitly requested
-        table_stats[:record_count] = database_manager.record_count(table_name) if include_record_counts
+        # Only fetch record count if specifically requested
+        if include_record_counts
+          begin
+            table_stats[:record_count] = database_manager.record_count(table_name)
+          rescue => e
+            Rails.logger.error("Error fetching record count for #{table_name}: #{e.message}")
+            table_stats[:record_count] = 0
+          end
+        end
 
         table_stats
       end
+    rescue => e
+      Rails.logger.error("Error fetching tables: #{e.message}")
+      []
     end
 
     # Gather database analytics information

data/app/controllers/dbviewer/api/entity_relationship_diagrams_controller.rb

@@ -4,74 +4,44 @@ module Dbviewer
       before_action :set_tables
 
       def relationships
-        # Fetch all relationships asynchronously
-        begin
-          @table_relationships = fetch_table_relationships
-          render_success({
-            relationships: @table_relationships,
-            status: "success"
-          })
-        rescue => e
-          Rails.logger.error("[DBViewer] Error fetching relationships: #{e.message}")
-          render json: {
-            relationships: [],
-            status: "error",
-            error: e.message
-          }, status: :internal_server_error
-        end
+        @table_relationships = fetch_table_relationships
+        render_success({
+          relationships: @table_relationships,
+          status: "success"
+        })
       end
 
       def table_relationships
-        # Fetch relationships for specific tables
         table_names = params[:tables]&.split(",") || []
-
-        if table_names.blank?
-          render json: {
-            relationships: [],
-            status: "error",
-            error: "No tables specified"
-          }, status: :bad_request
-          return
-        end
-
-        begin
-          relationships = []
-
-          table_names.each do |table_name|
-            next unless @tables.any? { |t| t[:name] == table_name }
-
-            begin
-              metadata = fetch_table_metadata(table_name)
-              if metadata && metadata[:foreign_keys].present?
-                metadata[:foreign_keys].each do |fk|
-                  relationships << {
-                    from_table: table_name,
-                    to_table: fk[:to_table],
-                    from_column: fk[:column],
-                    to_column: fk[:primary_key],
-                    name: fk[:name]
-                  }
-                end
+        relationships = []
+
+        table_names.each do |table_name|
+          next unless @tables.any? { |t| t[:name] == table_name }
+
+          begin
+            metadata = fetch_table_metadata(table_name)
+            if metadata && metadata[:foreign_keys].present?
+              metadata[:foreign_keys].each do |fk|
+                relationships << {
+                  from_table: table_name,
+                  to_table: fk[:to_table],
+                  from_column: fk[:column],
+                  to_column: fk[:primary_key],
+                  name: fk[:name]
+                }
               end
-            rescue => e
-              Rails.logger.error("[DBViewer] Error fetching relationships for #{table_name}: #{e.message}")
-              # Continue with other tables even if one fails
             end
+          rescue => e
+            Rails.logger.error("[DBViewer] Error fetching relationships for #{table_name}: #{e.message}")
+            # Continue with other tables even if one fails
           end
-
-          render_success({
-            relationships: relationships,
-            status: "success",
-            processed_tables: table_names
-          })
-        rescue => e
-          Rails.logger.error("[DBViewer] Error in table_relationships: #{e.message}")
-          render json: {
-            relationships: [],
-            status: "error",
-            error: e.message
-          }, status: :internal_server_error
         end
+
+        render_success({
+          relationships: relationships,
+          status: "success",
+          processed_tables: table_names
+        })
       end
 
       private

data/app/controllers/dbviewer/api/tables_controller.rb

@@ -16,6 +16,26 @@ module Dbviewer
         render_success(total_relationships: total_relationships)
       end
 
+      def relationship_counts
+        table_name = params[:id]
+        record_id = params[:record_id]
+
+        reverse_foreign_keys = fetch_table_metadata(table_name).dig(:reverse_foreign_keys) || []
+        relationship_counts = reverse_foreign_keys.map do |rel|
+          {
+            table: rel[:from_table],
+            foreign_key: rel[:column],
+            count: database_manager.get_model_for(rel[:from_table]).where(rel[:column] => record_id).count
+          }
+        end
+
+        render_success({
+          table_name: table_name,
+          record_id: record_id,
+          relationships: relationship_counts
+        })
+      end
+
       private
 
       def fetch_tables_count

data/app/controllers/dbviewer/connections_controller.rb

@@ -0,0 +1,35 @@
+module Dbviewer
+  class ConnectionsController < ApplicationController
+    # GET /dbviewer/connections
+    def index
+      @connections = available_connections
+
+      respond_to do |format|
+        format.html
+        format.json { render json: @connections }
+      end
+    end
+
+    # POST /dbviewer/connections/:id
+    def update
+      connection_key = params[:id]
+
+      if switch_connection(connection_key)
+        # Safely get the connection name
+        connection_config = Dbviewer.configuration.database_connections[connection_key.to_sym]
+        connection_name = connection_config && connection_config[:name] ? connection_config[:name] : "selected"
+
+        respond_to do |format|
+          format.html { redirect_to root_path, notice: "Switched to #{connection_name} database." }
+          format.json { render json: { success: true, current: connection_key } }
+        end
+      else
+        # Handle the case where switching failed
+        respond_to do |format|
+          format.html { redirect_to connections_path, alert: "Failed to switch connection. The connection may be invalid." }
+          format.json { render json: { success: false, error: "Invalid connection" }, status: :unprocessable_entity }
+        end
+      end
+    end
+  end
+end

data/app/controllers/dbviewer/home_controller.rb

@@ -1,6 +1,11 @@
 module Dbviewer
   class HomeController < ApplicationController
     def index
+      @current_connection_info = {
+        name: get_database_name,
+        adapter: get_adapter_name,
+        key: current_connection_key
+      }
     end
 
     private

data/app/helpers/dbviewer/application_helper.rb

@@ -33,7 +33,13 @@ module Dbviewer
 
     # Generate operator options based on column type
     def operator_options_for_column_type(column_type)
-      if column_type && (column_type =~ /datetime/ || column_type =~ /^date$/ || column_type =~ /^time$/)
+      # Common operators for all types
+      common_operators = [
+        [ "is null", "is_null" ],
+        [ "is not null", "is_not_null" ]
+      ]
+
+      type_specific_operators = if column_type && (column_type =~ /datetime/ || column_type =~ /^date$/ || column_type =~ /^time$/)
         # Date/Time operators
         [
           [ "=", "eq" ],
@@ -64,28 +70,58 @@ module Dbviewer
           [ "ends with", "ends_with" ]
         ]
       end
+
+      # Return type-specific operators first, then common operators
+      type_specific_operators + common_operators
     end
 
     # Render column filter input based on column type
     def render_column_filter_input(form, column_name, column_type, column_filters)
-      if column_type && column_type =~ /datetime/
+      # Get selected operator to check if it's a null operator
+      operator = column_filters["#{column_name}_operator"]
+      is_null_operator = operator == "is_null" || operator == "is_not_null"
+
+      # Clean up the value for non-null operators if the value contains a null operator
+      # This ensures we don't carry over 'is_null' or 'is_not_null' values when switching operators
+      value = column_filters[column_name]
+      if !is_null_operator && value.present? && (value == "is_null" || value == "is_not_null")
+        value = nil
+      end
+
+      # For null operators, display a non-editable field without placeholder
+      if is_null_operator
+        # Keep a hidden field for the actual value
+        hidden_field = form.hidden_field("column_filters[#{column_name}]",
+          value: operator,
+          class: "null-filter-value",
+          data: { column: column_name })
+
+        # Add a visible but disabled text field with no placeholder or value
+        visible_field = form.text_field("column_filters[#{column_name}_display]",
+          disabled: true,
+          value: "",
+          class: "form-control form-control-sm column-filter rounded-0 disabled-filter",
+          data: { column: "#{column_name}_display" })
+
+        hidden_field + visible_field
+      elsif column_type && column_type =~ /datetime/
         form.datetime_local_field("column_filters[#{column_name}]",
-          value: column_filters[column_name],
+          value: value,
           class: "form-control form-control-sm column-filter rounded-0",
           data: { column: column_name })
       elsif column_type && column_type =~ /^date$/
         form.date_field("column_filters[#{column_name}]",
-          value: column_filters[column_name],
+          value: value,
           class: "form-control form-control-sm column-filter rounded-0",
           data: { column: column_name })
       elsif column_type && column_type =~ /^time$/
         form.time_field("column_filters[#{column_name}]",
-          value: column_filters[column_name],
+          value: value,
           class: "form-control form-control-sm column-filter rounded-0",
           data: { column: column_name })
       else
         form.text_field("column_filters[#{column_name}]",
-          value: column_filters[column_name],
+          value: value,
           placeholder: "",
           class: "form-control form-control-sm column-filter rounded-0",
           data: { column: column_name })
@@ -113,8 +149,10 @@ module Dbviewer
       column_type = column_type_from_info(column_name, columns)
 
       content_tag(:div, class: "filter-input-group") do
-        render_operator_select(form, column_name, column_type, column_filters) +
-        render_column_filter_input(form, column_name, column_type, column_filters)
+        operator_select = render_operator_select(form, column_name, column_type, column_filters)
+        input_field = render_column_filter_input(form, column_name, column_type, column_filters)
+
+        operator_select + input_field
       end
     end