dbviewer 0.7.10 → 0.8.0

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

@@ -1,88 +0,0 @@
-module Dbviewer
-  module ConnectionManagement
-    extend ActiveSupport::Concern
-
-    included do
-      helper_method :current_connection_key, :available_connections if respond_to?(:helper_method)
-    end
-
-    # Get the current active connection key
-    def current_connection_key
-      key = session[:dbviewer_connection] || Dbviewer.configuration.current_connection
-      return key.to_sym if key && Dbviewer.configuration.database_connections.key?(key.to_sym)
-
-      first_key = Dbviewer.configuration.database_connections.keys.first
-      if first_key
-        session[:dbviewer_connection] = first_key
-        return first_key
-      end
-
-      :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
-  end
-end

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

@@ -1,32 +0,0 @@
-require "csv"
-
-module Dbviewer
-  module DataExport
-    extend ActiveSupport::Concern
-
-    # Export table data to CSV
-    def export_table_to_csv(table_name, query_params = nil, include_headers = true)
-      records = database_manager.table_query_operations.table_records(table_name, query_params)
-
-      csv_data = CSV.generate do |csv|
-        # Add headers if requested
-        csv << records.columns if include_headers
-
-        # Add rows
-        records.rows.each do |row|
-          csv << row.map { |cell| format_csv_value(cell) }
-        end
-      end
-
-      csv_data
-    end
-
-    private
-
-    # Format cell values for CSV export to handle nil values and special characters
-    def format_csv_value(value)
-      return "" if value.nil?
-      value.to_s
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Dbviewer
-  module DatabaseInformation
-    extend ActiveSupport::Concern
-
-    included do
-      helper_method :get_database_name, :get_adapter_name if respond_to?(:helper_method)
-    end
-
-    # 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]
-      return current_conn_config[:name] if current_conn_config && current_conn_config[:name].present?
-
-      adapter = database_manager.connection.adapter_name.downcase
-
-      case adapter
-      when /mysql/
-        query = "SELECT DATABASE() as db_name"
-        result = database_manager.execute_query(query).first
-        result ? result["db_name"] : "Database"
-      when /postgres/
-        query = "SELECT current_database() as db_name"
-        result = database_manager.execute_query(query).first
-        result ? result["db_name"] : "Database"
-      when /sqlite/
-        # For SQLite, extract the database name from the connection_config
-        database_path = database_manager.connection.pool.spec.config[:database] || ""
-        File.basename(database_path, ".*") || "SQLite Database"
-      else
-        "Database" # Default fallback
-      end
-    end
-
-    # Get the name of the current database adapter
-    def get_adapter_name
-      adapter_name = database_manager.connection.adapter_name.downcase
-      adapter_mappings = {
-        /mysql/i => "MySQL",
-        /postgres/i => "PostgreSQL",
-        /sqlite/i => "SQLite",
-        /oracle/i => "Oracle",
-        /sqlserver|mssql/i => "SQL Server"
-      }
-      adapter_mappings.find { |pattern, _| adapter_name =~ pattern }&.last || adapter_name.titleize
-    rescue
-      "Unknown"
-    end
-
-    # Gather database analytics information
-    def fetch_database_analytics
-      tables = fetch_tables(include_record_counts: true)
-
-      {
-        total_tables: tables.size,
-        total_records: tables.sum { |t| t[:record_count] },
-        largest_tables: tables.sort_by { |t| -t[:record_count] }.first(10),
-        empty_tables: tables.select { |t| t[:record_count] == 0 }
-      }
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Dbviewer
-  module DatatableSupport
-    extend ActiveSupport::Concern
-
-    # Consolidated method to fetch all datatable-related data in one call
-    # Returns a hash containing all necessary datatable information
-    def fetch_datatable_data(table_name, query_params)
-      columns = fetch_table_columns(table_name)
-      return default_datatable_structure(table_name) if columns.empty?
-
-      if query_params.column_filters.empty?
-        total_count = fetch_table_record_count(table_name)
-      else
-        total_count = fetch_filtered_record_count(table_name, query_params.column_filters)
-      end
-
-      {
-        columns: columns,
-        records: fetch_table_records(table_name, query_params),
-        total_count: total_count,
-        total_pages: total_count > 0 ? (total_count.to_f / query_params.per_page).ceil : 0,
-        metadata: fetch_table_metadata(table_name),
-        current_page: query_params.page,
-        per_page: query_params.per_page,
-        order_by: query_params.order_by,
-        direction: query_params.direction
-      }
-    end
-
-    private
-
-    # Default structure for tables with no data/columns
-    def default_datatable_structure(table_name)
-      {
-        columns: [],
-        records: [],
-        total_count: 0,
-        total_pages: 0,
-        metadata: {},
-        current_page: 1,
-        per_page: 25,
-        order_by: nil,
-        direction: "ASC"
-      }
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Dbviewer
-  module PaginationConcern
-    extend ActiveSupport::Concern
-
-    included do
-      # Sort direction validation
-      const_set(:VALID_SORT_DIRECTIONS, %w[ASC DESC].freeze) unless const_defined?(:VALID_SORT_DIRECTIONS)
-    end
-
-    module ClassMethods
-      # Use configuration values from Dbviewer module
-      def per_page_options
-        Dbviewer.configuration.per_page_options
-      end
-
-      def default_per_page
-        Dbviewer.configuration.default_per_page
-      end
-    end
-
-    def fetch_total_count(table_name, query_params)
-      if query_params.column_filters.present? && query_params.column_filters.values.any?(&:present?)
-        fetch_filtered_record_count(table_name, query_params.column_filters)
-      else
-        fetch_table_record_count(table_name)
-      end
-    end
-
-    # Calculate the total number of pages
-    def calculate_total_pages(total_count, per_page)
-      (total_count.to_f / per_page).ceil
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module Dbviewer
-  module QueryOperations
-    extend ActiveSupport::Concern
-
-    # Prepare the SQL query - either from params or default
-    def prepare_query(table_name, query)
-      query = query.present? ? query.to_s : default_query(table_name)
-
-      # Validate query for security
-      unless ::Dbviewer::Validator::Sql.safe_query?(query)
-        query = default_query(table_name)
-        flash.now[:warning] = "Only SELECT queries are allowed. Your query contained potentially unsafe operations. Using default query instead."
-      end
-
-      query
-    end
-
-    # Execute the prepared SQL query
-    def execute_query(query)
-      database_manager.execute_query(@query)
-    end
-
-    def default_query(table_name)
-      quoted_table = safe_quote_table_name(table_name)
-      "SELECT * FROM #{quoted_table} LIMIT 100"
-    end
-  end
-end

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

@@ -1,173 +0,0 @@
-module Dbviewer
-  module RelationshipManagement
-    extend ActiveSupport::Concern
-
-    # Fetch relationships between tables for ERD visualization
-    def fetch_table_relationships(tables)
-      tables.flat_map { |table| extract_table_relationships_from_metadata(table[:name]) }
-    end
-
-    # Get mini ERD data for a specific table and its relationships
-    def fetch_mini_erd_for_table(table_name)
-      outgoing_data = collect_outgoing_relationships(table_name)
-      incoming_data = collect_incoming_relationships(table_name)
-
-      initial_tables = [ { name: table_name } ]
-      all_relationships = outgoing_data[:relationships] + incoming_data[:relationships]
-      all_tables = (initial_tables + outgoing_data[:tables] + incoming_data[:tables]).uniq { |t| t[:name] }
-
-      {
-        tables: all_tables,
-        relationships: all_relationships,
-        timestamp: Time.now.to_i
-      }
-    end
-
-    private
-
-    # Extract relationships for a single table from its metadata
-    # @param table_name [String] The name of the table to process
-    # @return [Array<Hash>] Array of relationship hashes for this table
-    def extract_table_relationships_from_metadata(table_name)
-      metadata = database_manager.table_metadata(table_name)
-      return [] unless metadata&.dig(:foreign_keys)&.present?
-
-      metadata[:foreign_keys].map do |fk|
-        {
-          from_table: table_name,
-          to_table: fk[:to_table],
-          from_column: fk[:column],
-          to_column: fk[:primary_key],
-          name: fk[:name]
-        }
-      end
-    end
-
-    # Collect outgoing relationships from the specified table to other tables
-    # @param table_name [String] The source table name
-    # @return [Hash] Hash containing :tables and :relationships arrays
-    def collect_outgoing_relationships(table_name)
-      tables = []
-      relationships = []
-
-      metadata = fetch_table_metadata(table_name)
-      return { tables: tables, relationships: relationships } unless metadata&.dig(:foreign_keys)&.present?
-
-      metadata[:foreign_keys].each do |fk|
-        result = process_outgoing_foreign_key(table_name, fk)
-        if result
-          relationships << result[:relationship]
-          tables << result[:table]
-        end
-      end
-
-      {
-        tables: tables,
-        relationships: relationships
-      }
-    end
-
-    # Process a single outgoing foreign key relationship
-    # @param table_name [String] The source table name
-    # @param fk [Hash] Foreign key metadata
-    # @return [Hash, nil] Hash containing :relationship and :table, or nil if invalid
-    def process_outgoing_foreign_key(table_name, fk)
-      return nil unless fk[:to_table].present? && fk[:column].present?
-
-      relationship = build_relationship_hash(
-        from_table: table_name.to_s,
-        to_table: fk[:to_table].to_s,
-        from_column: fk[:column].to_s,
-        to_column: fk[:primary_key].to_s.presence || "id",
-        name: fk[:name].to_s.presence || "#{table_name}_to_#{fk[:to_table]}",
-        direction: "outgoing"
-      )
-
-      {
-        relationship: relationship,
-        table: {
-          name: fk[:to_table].to_s
-        }
-      }
-    end
-
-    # Collect incoming relationships from other tables to the specified table
-    # @param table_name [String] The target table name
-    # @return [Hash] Hash containing :tables and :relationships arrays
-    def collect_incoming_relationships(table_name)
-      results = database_manager.tables
-        .reject { |other_table_name| other_table_name == table_name }
-        .map { |other_table_name| process_table_for_incoming_relationships(table_name, other_table_name) }
-        .compact
-
-      {
-        tables: results.flat_map { |result| result[:tables] },
-        relationships: results.flat_map { |result| result[:relationships] }
-      }
-    end
-
-    # Process a single table to find incoming relationships to the target table
-    # @param target_table [String] The target table name
-    # @param source_table [String] The source table name to check
-    # @return [Hash, nil] Hash containing :tables and :relationships arrays, or nil if no relationships
-    def process_table_for_incoming_relationships(target_table, source_table)
-      other_metadata = fetch_table_metadata(source_table)
-      return nil unless other_metadata&.dig(:foreign_keys)&.present?
-
-      results = other_metadata[:foreign_keys]
-        .map { |fk| process_incoming_foreign_key(target_table, source_table, fk) }
-        .compact
-
-      return nil if results.empty?
-
-      {
-        tables: results.map { |result| result[:table] },
-        relationships: results.map { |result| result[:relationship] }
-      }
-    end
-
-    # Process a single incoming foreign key relationship
-    # @param target_table [String] The target table name
-    # @param source_table [String] The source table name
-    # @param fk [Hash] Foreign key metadata
-    # @return [Hash, nil] Hash containing :relationship and :table, or nil if invalid
-    def process_incoming_foreign_key(target_table, source_table, fk)
-      return nil unless fk[:to_table] == target_table && fk[:column].present?
-
-      relationship = build_relationship_hash(
-        from_table: source_table.to_s,
-        to_table: target_table.to_s,
-        from_column: fk[:column].to_s,
-        to_column: fk[:primary_key].to_s.presence || "id",
-        name: fk[:name].to_s.presence || "#{source_table}_to_#{target_table}",
-        direction: "incoming"
-      )
-
-      {
-        relationship: relationship,
-        table: {
-          name: source_table.to_s
-        }
-      }
-    end
-
-    # Build a standardized relationship hash
-    # @param from_table [String] Source table name
-    # @param to_table [String] Target table name
-    # @param from_column [String] Source column name
-    # @param to_column [String] Target column name
-    # @param name [String] Relationship name
-    # @param direction [String] Relationship direction
-    # @return [Hash] Standardized relationship hash
-    def build_relationship_hash(from_table:, to_table:, from_column:, to_column:, name:, direction:)
-      {
-        from_table: from_table,
-        to_table: to_table,
-        from_column: from_column,
-        to_column: to_column,
-        name: name,
-        direction: direction
-      }
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-module Dbviewer
-  module TableOperations
-    extend ActiveSupport::Concern
-
-    # Fetch all tables with their stats
-    # By default, don't include record counts for better performance on sidebar
-    def fetch_tables(include_record_counts = false)
-      database_manager.tables.map do |table_name|
-        table_stats = {
-          name: table_name
-        }
-        table_stats[:record_count] = database_manager.record_count(table_name) if include_record_counts
-        table_stats
-      end
-    end
-
-    # Get column information for a specific table
-    def fetch_table_columns(table_name)
-      database_manager.table_columns(table_name)
-    end
-
-    # Get the total number of records in a table
-    def fetch_table_record_count(table_name)
-      database_manager.table_count(table_name)
-    end
-
-    # Fetch records for a table with pagination and sorting
-    def fetch_table_records(table_name, query_params)
-      database_manager.table_records(table_name, query_params)
-    end
-
-    # Get filtered record count for a table
-    def fetch_filtered_record_count(table_name, column_filters)
-      database_manager.filtered_record_count(table_name, column_filters)
-    end
-
-    # Safely quote a table name, with fallback
-    def safe_quote_table_name(table_name)
-      database_manager.connection.quote_table_name(table_name) rescue table_name.to_s
-    end
-
-    # Get table metadata for display (e.g., primary key, foreign keys, indexes)
-    def fetch_table_metadata(table_name)
-      database_manager.table_metadata(table_name)
-    end
-
-    private
-
-    # Check if a table has a created_at column for timestamp visualization
-    def has_timestamp_column?(table_name)
-      fetch_table_columns(table_name).any? do |column|
-        column[:name] == "created_at" && [ :datetime, :timestamp ].include?(column[:type])
-      end
-    end
-  end
-end