dbviewer 0.3.1

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

@@ -0,0 +1,42 @@
+module Dbviewer
+  module ErrorHandling
+    extend ActiveSupport::Concern
+
+    included do
+      # Ensure common database errors are handled gracefully
+      rescue_from ActiveRecord::ActiveRecordError, with: :handle_database_error
+    end
+
+    # Handle database connection errors
+    def handle_database_error(exception)
+      message = case exception
+      when ActiveRecord::ConnectionNotEstablished
+        "Database connection could not be established."
+      when ActiveRecord::StatementInvalid
+        "Invalid SQL statement: #{exception.message}"
+      else
+        "Database error: #{exception.message}"
+      end
+
+      flash.now[:error] = message
+      Rails.logger.error("Database error: #{exception.message}\n#{exception.backtrace.join("\n")}")
+
+      # Determine where to redirect based on the current action
+      if action_name == "show" || action_name == "query"
+        @error = message
+        @records = nil
+        render action_name
+      else
+        @tables = []
+        render :index
+      end
+    end
+
+    def log_error(error, prefix = "Error")
+      error_msg = "#{prefix}: #{error.message}"
+      flash.now[:error] = error_msg
+      Rails.logger.error("#{prefix}: #{error.message}\n#{error.backtrace.join("\n")}")
+      error_msg
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+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
+
+    # Set pagination parameters from request or defaults
+    def set_pagination_params
+      @current_page = [ 1, params[:page].to_i ].max
+      @per_page = params[:per_page] ? params[:per_page].to_i : self.class.default_per_page
+      @per_page = self.class.default_per_page unless self.class.per_page_options.include?(@per_page)
+    end
+
+    # Set sorting parameters from request or defaults
+    def set_sorting_params
+      @order_by = params[:order_by].presence ||
+                  database_manager.primary_key(@table_name).presence ||
+                  (@columns.first ? @columns.first[:name] : nil)
+
+      @order_direction = params[:order_direction].upcase if params[:order_direction].present?
+      @order_direction = "ASC" unless self.class::VALID_SORT_DIRECTIONS.include?(@order_direction)
+    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/dbviewer/application_controller.rb

@@ -0,0 +1,21 @@
+module Dbviewer
+  class ApplicationController < ActionController::Base
+    include Dbviewer::DatabaseOperations
+    include Dbviewer::ErrorHandling
+
+    before_action :ensure_development_environment
+    before_action :set_tables
+
+    private
+
+    def ensure_development_environment
+      unless Rails.env.development? || Rails.env.test? || params[:override_env_check] == ENV["DBVIEWER_PRODUCTION_ACCESS_KEY"]
+        render plain: "DBViewer is only available in development and test environments for security reasons.", status: :forbidden
+      end
+    end
+
+    def set_tables
+      @tables = fetch_tables_with_stats
+    end
+  end
+end

data/app/controllers/dbviewer/entity_relationship_diagrams_controller.rb

@@ -0,0 +1,24 @@
+module Dbviewer
+  class EntityRelationshipDiagramsController < ApplicationController
+    def index
+      @tables = fetch_tables_with_stats
+
+      if @tables.present?
+        @table_relationships = fetch_table_relationships
+      else
+        @table_relationships = []
+        flash.now[:warning] = "No tables found in database to generate ERD."
+      end
+
+      respond_to do |format|
+        format.html # Default to HTML view
+        format.json do
+          render json: {
+            tables: @tables,
+            relationships: @table_relationships
+          }
+        end
+      end
+    end
+  end
+end

data/app/controllers/dbviewer/home_controller.rb

@@ -0,0 +1,10 @@
+module Dbviewer
+  class HomeController < ApplicationController
+    skip_before_action :set_tables
+
+    def index
+      @tables = fetch_tables_with_stats(include_record_counts: true)
+      @analytics = fetch_database_analytics
+    end
+  end
+end

data/app/controllers/dbviewer/logs_controller.rb

@@ -0,0 +1,39 @@
+module Dbviewer
+  class LogsController < ApplicationController
+    before_action :set_filters, only: [ :index ]
+
+    def index
+      @queries = Dbviewer::Logger.instance.recent_queries(
+        limit: @limit,
+        table_filter: @table_filter,
+        request_id: @request_id,
+        min_duration: @min_duration
+      )
+
+      if @request_id.present? || @table_filter.present? || @min_duration.present?
+        @stats = Dbviewer::Logger.instance.stats_for_queries(@queries)
+        @filtered_stats = true
+      else
+        @stats = Dbviewer::Logger.instance.stats
+        @filtered_stats = false
+      end
+    end
+
+    def destroy_all
+      Dbviewer::Logger.instance.clear
+      flash[:success] = "Query logs cleared successfully"
+
+      redirect_to logs_path
+    end
+
+    private
+
+    def set_filters
+      @table_filter = params[:table_filter]
+      @request_id = params[:request_id]
+      @min_duration = params[:min_duration]
+      @limit = (params[:limit] || 100).to_i
+      @limit = 1000 if @limit > 1000
+    end
+  end
+end

data/app/controllers/dbviewer/tables_controller.rb

@@ -0,0 +1,73 @@
+module Dbviewer
+  class TablesController < ApplicationController
+    include Dbviewer::PaginationConcern
+
+    def index
+      @tables = fetch_tables_with_stats
+    end
+
+    def show
+      @table_name = params[:id]
+      @columns = fetch_table_columns(@table_name)
+      @metadata = fetch_table_metadata(@table_name)
+      @tables = fetch_tables_with_stats  # Fetch tables for sidebar
+
+      set_pagination_params
+      set_sorting_params
+
+      @total_count = fetch_table_record_count(@table_name)
+      @total_pages = calculate_total_pages(@total_count, @per_page)
+      @records = fetch_table_records(@table_name)
+
+      # Fetch timestamp visualization data if the table has a created_at column
+      if has_timestamp_column?(@table_name)
+        @time_grouping = params[:time_group] || "daily"
+        @timestamp_data = fetch_timestamp_data(@table_name, @time_grouping)
+      end
+
+      respond_to do |format|
+        format.html # Default HTML response
+        format.json do
+          render json: {
+            table_name: @table_name,
+            columns: @columns,
+            metadata: @metadata,
+            record_count: @total_count
+          }
+        end
+      end
+    end
+
+    def query
+      @table_name = params[:id]
+      @read_only_mode = true # Flag to indicate we're in read-only mode
+      @columns = fetch_table_columns(@table_name)
+      @tables = fetch_tables_with_stats  # Fetch tables for sidebar
+
+      # Set active table for sidebar highlighting
+      @active_table = @table_name
+
+      prepare_query
+      execute_query
+
+      render :query
+    end
+
+    def export_csv
+      table_name = params[:id]
+      limit = (params[:limit] || 10000).to_i
+      include_headers = params[:include_headers] != "0"
+
+      csv_data = export_table_to_csv(table_name, limit, include_headers)
+
+      # Set filename with timestamp for uniqueness
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      filename = "#{table_name}_export_#{timestamp}.csv"
+
+      # Send data as file
+      send_data csv_data,
+                type: "text/csv; charset=utf-8; header=present",
+                disposition: "attachment; filename=#{filename}"
+    end
+  end
+end

data/app/helpers/dbviewer/application_helper.rb

@@ -0,0 +1,118 @@
+module Dbviewer
+  module ApplicationHelper
+    def format_cell_value(value)
+      return "NULL" if value.nil?
+      return value.to_s.truncate(100) unless value.is_a?(String)
+
+      case value
+      when /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+        # ISO 8601 datetime
+        begin
+          Time.parse(value).strftime("%Y-%m-%d %H:%M:%S")
+        rescue
+          value.to_s.truncate(100)
+        end
+      when /\A\d{4}-\d{2}-\d{2}\z/
+        # Date
+        value
+      when /\A{.+}\z/, /\A\[.+\]\z/
+        # JSON
+        begin
+          JSON.pretty_generate(JSON.parse(value)).truncate(100)
+        rescue
+          value.to_s.truncate(100)
+        end
+      else
+        value.to_s.truncate(100)
+      end
+    end
+
+    # Dark mode helper methods
+
+    # Returns the theme toggle icon based on the current theme
+    def theme_toggle_icon
+      '<i class="bi bi-moon"></i><i class="bi bi-sun"></i>'.html_safe
+    end
+
+    # Returns the aria label for the theme toggle button
+    def theme_toggle_label
+      "Toggle dark mode"
+    end
+
+    # Returns the appropriate background class for stat cards that adapts to dark mode
+    def stat_card_bg_class
+      "stat-card-bg"
+    end
+
+    # Helper method for code blocks background that adapts to dark mode
+    def code_block_bg_class
+      "sql-code-block"
+    end
+
+    # Determine if the current table should be active in the sidebar
+    def current_table?(table_name)
+      @table_name.present? && @table_name == table_name
+    end
+
+    # Format table name for display - truncate if too long
+    def format_table_name(table_name)
+      if table_name.length > 20
+        "#{table_name.first(17)}..."
+      else
+        table_name
+      end
+    end
+
+    # Get appropriate icon for column data type
+    def column_type_icon(column_type)
+      case column_type.to_s.downcase
+      when /int/, /serial/, /number/, /decimal/, /float/, /double/
+        "bi-123"
+      when /char/, /text/, /string/, /uuid/
+        "bi-fonts"
+      when /date/, /time/
+        "bi-calendar"
+      when /bool/
+        "bi-toggle-on"
+      when /json/, /jsonb/
+        "bi-braces"
+      when /array/
+        "bi-list-ol"
+      else
+        "bi-file-earmark"
+      end
+    end
+
+    # Helper method to determine if current controller and action match
+    def active_nav_class(controller_name, action_name = nil)
+      current_controller = params[:controller].split("/").last
+      active = current_controller == controller_name
+
+      if action_name.present?
+        active = active && params[:action] == action_name
+      end
+
+      active ? "active" : ""
+    end
+
+    # Helper for highlighting dashboard link
+    def dashboard_nav_class
+      active_nav_class("home")
+    end
+
+    # Helper for highlighting tables link
+    def tables_nav_class
+      active_nav_class("tables")
+    end
+
+    # Helper for highlighting ERD link
+    def erd_nav_class
+      active_nav_class("entity_relationship_diagrams")
+    end
+
+    # Helper for highlighting SQL Logs link
+    def logs_nav_class
+      active_nav_class("logs")
+    end
+  end
+end

data/app/jobs/dbviewer/application_job.rb

@@ -0,0 +1,4 @@
+module Dbviewer
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/dbviewer/application_mailer.rb

@@ -0,0 +1,6 @@
+module Dbviewer
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/dbviewer/application_record.rb

@@ -0,0 +1,5 @@
+module Dbviewer
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/services/dbviewer/query_parser.rb

@@ -0,0 +1,82 @@
+module Dbviewer
+  # QueryParser handles parsing SQL queries and extracting useful information
+  class QueryParser
+    # Extract table names from an SQL query string
+    def self.extract_tables(sql)
+      return [] if sql.nil?
+
+      # Convert to lowercase for case-insensitive matching
+      sql = sql.downcase
+
+      # Extract table names after FROM or JOIN
+      sql.scan(/(?:from|join)\s+[`"']?(\w+)[`"']?/).flatten.uniq
+    end
+
+    # Normalize a SQL query to find similar patterns
+    # Replaces specific values with placeholders
+    def self.normalize(sql)
+      return "" if sql.nil?
+
+      sql.gsub(/\b\d+\b/, "N")
+         .gsub(/'[^']*'/, "'X'")
+         .gsub(/"[^"]*"/, '"X"')
+    end
+
+    # Check if the query is from the DBViewer library
+    def self.from_dbviewer?(event)
+      # Check if the SQL itself references DBViewer tables
+      if event.payload[:sql].match(/\b(from|join|update|into)\s+["`']?dbviewer_/i)
+        return true
+      end
+
+      # Check the caller information if available
+      caller = event.payload[:caller]
+      if caller.is_a?(String) && caller.include?("/dbviewer/")
+        return true
+      end
+
+      # Check if query name indicates it's from DBViewer
+      if event.payload[:name].is_a?(String) &&
+         (event.payload[:name].include?("Dbviewer") || event.payload[:name].include?("DBViewer") || event.payload[:name] == "SQL")
+        return true
+      end
+
+      # Check for common DBViewer operations
+      sql = event.payload[:sql].downcase
+      if sql.include?("table_structure") ||
+         sql.include?("schema_migrations") ||
+         sql.include?("database_analytics")
+        return true
+      end
+
+      false
+    end
+
+    # Format bind parameters for storage
+    def self.format_binds(binds)
+      return [] unless binds.respond_to?(:map)
+
+      binds.map do |bind|
+        if bind.respond_to?(:value)
+          bind.value
+        elsif bind.is_a?(Array) && bind.size == 2
+          bind.last
+        else
+          bind.to_s
+        end
+      end
+    rescue
+      []
+    end
+
+    # Determine if a query should be skipped based on content
+    def self.should_skip_query?(event)
+      event.payload[:name] == "SCHEMA" ||
+      event.payload[:sql].include?("SHOW TABLES") ||
+      event.payload[:sql].include?("sqlite_master") ||
+      event.payload[:sql].include?("information_schema") ||
+      event.payload[:sql].include?("pg_catalog") ||
+      from_dbviewer?(event)
+    end
+  end
+end