dbviewer 0.7.10 → 0.7.11

data/config/routes.rb

@@ -4,7 +4,6 @@ Dbviewer::Engine.routes.draw do
       get "query"
       post "query"
       get "export_csv"
-      get "mini_erd"
     end
   end
 
@@ -26,13 +25,14 @@ Dbviewer::Engine.routes.draw do
   get "dashboard", to: "home#index", as: :dashboard
 
   namespace :api do
-    resources :tables, only: [ :index ] do
+    resources :tables, only: [ :index, :show ] do
       collection do
         get "records"
         get "relationships_count"
       end
       member do
         get "relationship_counts"
+        get "mini_erd"
       end
     end
 

data/lib/dbviewer/database/manager.rb

@@ -75,8 +75,8 @@ module Dbviewer
       # @param table_name [String] Name of the table
       # @param column_filters [Hash] Hash of column_name => filter_value for filtering
       # @return [Integer] Number of filtered records
-      def filtered_record_count(table_name, column_filters = {})
-        @table_query_operations.filtered_record_count(table_name, column_filters)
+      def table_record_count(table_name, column_filters = {})
+        @table_query_operations.table_record_count(table_name, column_filters)
       end
 
       # Get the number of columns in a table

data/lib/dbviewer/datatable/query_operations.rb

@@ -48,9 +48,6 @@ module Dbviewer
 
         # Format results
         to_result_set(records, column_names)
-      rescue => e
-        Rails.logger.error("[DBViewer] Error executing table query: #{e.message}")
-        raise e
       end
 
       # Get the total count of records in a table
@@ -58,23 +55,13 @@ module Dbviewer
       # @return [Integer] Number of records
       def table_count(table_name)
         get_model_for(table_name).count
-      rescue => e
-        Rails.logger.error("[DBViewer] Error counting records in table #{table_name}: #{e.message}")
-        0
-      end
-
-      # Get the number of records in a table (alias for table_count)
-      # @param table_name [String] Name of the table
-      # @return [Integer] Number of records
-      def record_count(table_name)
-        table_count(table_name)
       end
 
       # Get the number of records in a table with filters applied
       # @param table_name [String] Name of the table
       # @param column_filters [Hash] Hash of column_name => filter_value for filtering
       # @return [Integer] Number of filtered records
-      def filtered_record_count(table_name, column_filters = {})
+      def table_record_count(table_name, column_filters = {})
         return table_count(table_name) unless column_filters.present?
 
         model = get_model_for(table_name)
@@ -83,9 +70,6 @@ module Dbviewer
         # Apply filters in the same way as table_records
         query = apply_column_filters(query, table_name, column_filters)
         query.count
-      rescue => e
-        Rails.logger.error("[DBViewer] Error counting filtered records in table #{table_name}: #{e.message}")
-        0
       end
 
       ## -- Delegator

data/lib/dbviewer/engine.rb

@@ -15,5 +15,34 @@ module Dbviewer
     initializer "dbviewer.notifications" do
       Dbviewer::Query::NotificationSubscriber.subscribe
     end
+
+    # Configure assets for the engine
+    initializer "dbviewer.assets" do |app|
+      # Add engine assets path to asset load paths
+      app.config.assets.paths << root.join("app", "assets", "javascripts").to_s
+      app.config.assets.paths << root.join("app", "assets", "stylesheets").to_s
+      app.config.assets.paths << root.join("app", "assets", "images").to_s
+
+      # Make sure we precompile individual JavaScript files
+      app.config.assets.precompile += %w[
+        dbviewer/utility.js
+        dbviewer/error_handler.js
+        dbviewer/home.js
+        dbviewer/layout.js
+        dbviewer/sidebar.js
+        dbviewer/query.js
+        dbviewer/entity_relationship_diagram.js
+        dbviewer/table.js
+      ]
+
+      # Make sure stylesheets are precompiled too
+      app.config.assets.precompile += %w[
+        dbviewer/application.css
+        dbviewer/home.css
+        dbviewer/query.css
+        dbviewer/table.css
+        dbviewer/entity_relationship_diagram.css
+      ]
+    end
   end
 end

data/lib/dbviewer/version.rb

@@ -1,3 +1,3 @@
 module Dbviewer
-  VERSION = "0.7.10"
+  VERSION = "0.7.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbviewer
 version: !ruby/object:Gem::Version
-  version: 0.7.10
+  version: 0.7.11
 platform: ruby
 authors:
 - Wailan Tirajoh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-19 00:00:00.000000000 Z
+date: 2025-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -77,28 +77,33 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/assets/images/dbviewer/emoji-favicon.txt
+- app/assets/images/dbviewer/favicon.ico
+- app/assets/images/dbviewer/favicon.png
+- app/assets/images/dbviewer/favicon.svg
 - app/assets/javascripts/dbviewer/entity_relationship_diagram.js
+- app/assets/javascripts/dbviewer/error_handler.js
 - app/assets/javascripts/dbviewer/home.js
 - app/assets/javascripts/dbviewer/layout.js
 - app/assets/javascripts/dbviewer/query.js
 - app/assets/javascripts/dbviewer/sidebar.js
 - app/assets/javascripts/dbviewer/table.js
+- app/assets/javascripts/dbviewer/utility.js
 - app/assets/stylesheets/dbviewer/application.css
 - app/assets/stylesheets/dbviewer/entity_relationship_diagram.css
 - app/assets/stylesheets/dbviewer/home.css
 - app/assets/stylesheets/dbviewer/logs.css
 - app/assets/stylesheets/dbviewer/query.css
 - app/assets/stylesheets/dbviewer/table.css
-- app/controllers/concerns/dbviewer/connection_management.rb
-- app/controllers/concerns/dbviewer/data_export.rb
-- app/controllers/concerns/dbviewer/database_information.rb
 - app/controllers/concerns/dbviewer/database_operations.rb
-- app/controllers/concerns/dbviewer/datatable_support.rb
+- app/controllers/concerns/dbviewer/database_operations/connection_management.rb
+- app/controllers/concerns/dbviewer/database_operations/data_export.rb
+- app/controllers/concerns/dbviewer/database_operations/database_information.rb
+- app/controllers/concerns/dbviewer/database_operations/datatable_operations.rb
+- app/controllers/concerns/dbviewer/database_operations/query_operations.rb
+- app/controllers/concerns/dbviewer/database_operations/relationship_management.rb
+- app/controllers/concerns/dbviewer/database_operations/table_operations.rb
 - app/controllers/concerns/dbviewer/disabled_state_validation.rb
-- app/controllers/concerns/dbviewer/pagination_concern.rb
-- app/controllers/concerns/dbviewer/query_operations.rb
-- app/controllers/concerns/dbviewer/relationship_management.rb
-- app/controllers/concerns/dbviewer/table_operations.rb
 - app/controllers/dbviewer/api/base_controller.rb
 - app/controllers/dbviewer/api/database_controller.rb
 - app/controllers/dbviewer/api/entity_relationship_diagrams_controller.rb

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