dbdoc_engine 0.1.0

data/app/controllers/dbdoc_engine/schema_diagram_controller.rb

@@ -0,0 +1,293 @@
+# app/controllers/dbdoc_engine/schema_diagram_controller.rb
+module DbdocEngine
+  class SchemaDiagramController < ApplicationController
+    layout "dbdoc_engine/header"
+
+    # Skip CSRF protection for the data endpoint to allow AJAX calls
+    skip_before_action :verify_authenticity_token, only: [ :data ]
+
+    def index
+      @groups = DbdocEngine::DbDesignTableGroupQueries.groups_with_tables_having_columns
+
+      @foreign_keys = DbdocEngine::DbDesignDynamicColumnQueries.all_foreign_keys_with_tables
+    end
+
+    def data
+      @tables = DbDesignDynamicTableQueries.active_tables_with_columns
+                  .includes(:db_design_dynamic_columns, :db_design_table_group)
+
+      @foreign_keys = DbdocEngine::DbDesignDynamicColumnQueries.all_foreign_keys_with_tables
+                        .includes(db_design_dynamic_table: :db_design_dynamic_columns)
+      @existing_table_names = DbDesignDynamicTable.where(deleted_at: nil).pluck(:table_name).to_set
+
+      dot_code = generate_graphviz_dot(@tables)
+      svg = render_graphviz_svg(dot_code)
+
+      selected_group_id = params[:group_id].presence if params[:group_id] != "all"
+      @group_colors = {}
+
+      @tables.each do |table|
+        group_color = table.db_design_table_group&.group_color || "#cccccc"
+        if selected_group_id.nil? || table.db_design_table_group_id.to_s == selected_group_id
+          @group_colors[table.table_name] = group_color
+        else
+          @group_colors[table.table_name] = "#808080"
+        end
+      end
+
+      @column_data = generate_column_data(@tables)
+      @relationship_data = generate_relationship_data
+
+      respond_to do |format|
+        format.json do
+          render json: {
+            diagram_svg: svg,
+            group_colors: @group_colors,
+            column_data: @column_data,
+            relationship_data: @relationship_data
+          }
+        end
+      end
+    end
+
+    def render_graphviz_svg(dot_code)
+      require "open3"
+      svg = nil
+      Open3.popen3("dot -Tsvg") do |stdin, stdout, stderr, wait_thr|
+        stdin.puts dot_code
+        stdin.close
+        svg = stdout.read
+        raise "Graphviz error: #{stderr.read}" if wait_thr.value != 0
+      end
+      svg
+    end
+
+    def lighten_color(hex, amount = 0.7)
+      r = hex[1..2].to_i(16)
+      g = hex[3..4].to_i(16)
+      b = hex[5..6].to_i(16)
+      r = [ (r + (255 - r) * amount), 255 ].min.round
+      g = [ (g + (255 - g) * amount), 255 ].min.round
+      b = [ (b + (255 - b) * amount), 255 ].min.round
+      "#%02X%02X%02X" % [ r, g, b ]
+    end
+
+    private
+
+    def generate_graphviz_dot(tables)
+      selected_group_id = params[:group_id].presence if params[:group_id] != "all"
+
+      dot = <<~DOT
+        digraph G {
+          graph [overlap=false rankdir=LR ratio=auto splines=true fontname="Arial" fontsize=10 compound=true]
+          node [fontname="Arial" fontsize=10 shape=plain margin=0]
+          edge [fontname="Arial" fontsize=8]
+      DOT
+
+      table_colors = {}
+
+      # Generate table nodes
+      tables.each do |table|
+        group = table.db_design_table_group
+        color = if selected_group_id.nil? || table.db_design_table_group_id.to_s == selected_group_id
+                  group&.group_color || "#cccccc"
+        else
+                  "#808080"
+        end
+
+        table_colors[table.table_name] = color
+
+        dot << generate_table_node(table, color)
+      end
+
+      # Generate edges with better labeling and grouping
+      dot << generate_relationship_edges(tables, table_colors)
+
+      dot << "}\n"
+      dot
+    end
+
+    def generate_table_node(table, color)
+      node_content = <<~TABLE
+        "#{escape_dot_string(table.table_name)}" [id="#{escape_dot_string(table.table_name)}" label=<
+          <table border="1" cellborder="0" cellspacing="0" cellpadding="8" COLOR="#{color}">
+            <tr>
+              <td bgcolor="#{color}" port="header" colspan="2" align="center">
+                <font point-size="12" color="white"><b>#{escape_html(table.table_name)}</b></font>
+              </td>
+            </tr>
+      TABLE
+
+      table.db_design_dynamic_columns.each_with_index do |column, i|
+        port_name = "port_#{i}"
+        attributes = []
+        attributes << "🔑" if column.is_primary_key
+        attributes << "🔗" if column.is_foreign_key
+        attributes << "NN" if column.not_null
+
+        node_content << <<~COLUMN
+          <tr>
+            <td port="#{port_name}" align="left">
+              #{escape_html(column.column_name)} #{attributes.join(' ')}
+            </td>
+            <td align="right">
+              <i>#{escape_html(column.data_type)}</i>
+            </td>
+          </tr>
+        COLUMN
+      end
+
+      node_content << "</table> >];\n"
+      node_content
+    end
+
+    def generate_relationship_edges(tables, table_colors)
+      edges_content = ""
+
+      @foreign_keys.each do |fk|
+        next unless @existing_table_names.include?(fk.foreign_table_name)
+
+        source_table = escape_dot_string(fk.foreign_table_name)
+        target_table = escape_dot_string(fk.db_design_dynamic_table.table_name)
+        target_column_index = fk.db_design_dynamic_table.db_design_dynamic_columns
+                                .find_index { |c| c.column_name == fk.column_name }
+        next unless target_column_index
+
+        target_port = "port_#{target_column_index}"
+        source_port = "header"
+        color = table_colors[fk.db_design_dynamic_table.table_name] || "#cccccc"
+        edge_attributes = get_edge_attributes(fk.relationship_type)
+        edge_id = "edge_#{fk.foreign_table_name}_#{fk.db_design_dynamic_table.table_name}_#{fk.column_name}"
+        edge_title = "#{fk.foreign_table_name}:#{fk.foreign_column_name || 'id'}->#{fk.db_design_dynamic_table.table_name}:#{fk.column_name}"
+        relationship_label = create_relationship_label(fk)
+
+        edges_content << <<~EDGE
+          "#{source_table}":#{source_port} -> "#{target_table}":#{target_port} [
+            id="#{escape_dot_string(edge_id)}",
+            #{edge_attributes},
+            color="#{color}",
+            penwidth=1.5,
+            label="#{relationship_label}",
+            labeltooltip="#{escape_dot_string(edge_title)}",
+            tooltip="#{escape_dot_string(edge_title)}"
+          ];
+        EDGE
+      end
+
+      edges_content
+    end
+
+    def get_edge_attributes(relationship_type)
+      case relationship_type&.to_s
+      when "one_to_one"
+        "arrowhead=tee, arrowtail=tee, dir=both, style=solid"
+      when "one_to_many"
+        "arrowhead=crow, arrowtail=tee, dir=both, style=solid"
+      when "many_to_one"
+        "arrowhead=tee, arrowtail=crow, dir=both, style=solid"
+      when "many_to_many"
+        "arrowhead=crow, arrowtail=crow, dir=both, style=solid"
+      else
+        "arrowhead=normal, arrowtail=none, dir=forward, style=solid"
+      end
+    end
+
+    def create_relationship_label(fk)
+      # Create a concise label for the relationship
+      case fk.relationship_type&.to_s
+      when "one_to_one"
+        "1:1"
+      when "one_to_many"
+        "1:N"
+      when "many_to_one"
+        "N:1"
+      when "many_to_many"
+        "N:N"
+      else
+        fk.foreign_column_name || "ref"
+      end
+    end
+
+    def escape_dot_string(str)
+      return "" if str.nil?
+      str.to_s.gsub(/["\\]/, '\\\\\\&')
+    end
+
+    def escape_html(str)
+      return "" if str.nil?
+      str.to_s.gsub(/[&<>"']/, {
+        "&" => "&amp;",
+        "<" => "&lt;",
+        ">" => "&gt;",
+        '"' => "&quot;",
+        "'" => "&#x27;"
+      })
+    end
+
+    def generate_column_data(tables)
+      column_data = {}
+
+      tables.each do |table|
+        column_data[table.table_name] = {}
+
+        table.db_design_dynamic_columns.each do |column|
+          column_data[table.table_name][column.column_name] = {
+            name: column.column_name,
+            data_type: column.data_type.to_s,
+            description: column.description || "No description available",
+            is_primary_key: column.is_primary_key,
+            is_foreign_key: column.is_foreign_key,
+            not_null: column.not_null,
+            is_unique_key: column.is_unique_key,
+            is_candidate_key: column.is_candidate_key,
+            is_indexed: column.is_indexed,
+            foreign_table_name: column.foreign_table_name,
+            foreign_column_name: column.foreign_column_name,
+            relationship_type: column.relationship_type
+          }
+        end
+      end
+
+      column_data
+    end
+
+    def generate_relationship_data
+      relationships = {}
+
+      @foreign_keys.each do |fk|
+        next unless @existing_table_names.include?(fk.foreign_table_name)
+
+        edge_id = "edge_#{fk.foreign_table_name}_#{fk.db_design_dynamic_table.table_name}_#{fk.column_name}"
+
+        relationships[edge_id] = {
+          id: edge_id,
+          source_table: fk.foreign_table_name,
+          source_column: fk.foreign_column_name || "id",
+          target_table: fk.db_design_dynamic_table.table_name,
+          target_column: fk.column_name,
+          relationship_type: fk.relationship_type || "many_to_one",
+          description: generate_relationship_description(fk)
+        }
+      end
+
+      relationships
+    end
+
+    def generate_relationship_description(fk)
+      type_description = case fk.relationship_type&.to_s
+      when "one_to_one"
+                          "One-to-One"
+      when "one_to_many"
+                          "One-to-Many"
+      when "many_to_one"
+                          "Many-to-One"
+      when "many_to_many"
+                          "Many-to-Many"
+      else
+                          "Foreign Key"
+      end
+
+      "#{type_description} relationship between #{fk.foreign_table_name} and #{fk.db_design_dynamic_table.table_name}"
+    end
+  end
+end

data/app/helper/dbdoc_engine/application_helper.rb

@@ -0,0 +1,35 @@
+# This module provides helper methods for views across the application.
+# It includes methods for handling JavaScript translations for client-side validation.
+module DbdocEngine
+  module ApplicationHelper
+    # Returns a JSON object containing localized error messages for JavaScript validation
+    def js_translations
+      {
+        group_name_required: I18n.t("dbdoc.group_name_required"),
+        group_name_unique: I18n.t("dbdoc.group_name_unique"),
+        group_color_required: I18n.t("dbdoc.group_color_required"),
+        table_name_required: I18n.t("dbdoc.table_name_required"),
+        physical_table_name_required: I18n.t("dbdoc.physical_table_name_required"),
+        table_group_must_be_selected: I18n.t("dbdoc.table_group_must_be_selected"),
+        created_by_field_required: I18n.t("dbdoc.created_by_field_required"),
+        column_name_required: I18n.t("dbdoc.column_name_required"),
+        physical_column_name_required: I18n.t("dbdoc.physical_column_name_required"),
+        data_type_must_be_selected: I18n.t("dbdoc.data_type_must_be_selected"),
+        length_is_required_for_this_data_type: I18n.t("dbdoc.length_is_required_for_this_data_type"),
+        referenced_table_is_required_for_foreign_key: I18n.t("dbdoc.referenced_table_is_required_for_foreign_key"),
+        referenced_column_is_required_for_foreign_key: I18n.t("dbdoc.referenced_column_is_required_for_foreign_key"),
+        relationship_type_is_required_for_foreign_key: I18n.t("dbdoc.relationship_type_is_required_for_foreign_key"),
+        created_by_required: I18n.t("dbdoc.created_by_required"),
+        duplicate_columns: I18n.t("dbdoc.duplicate_columns"),
+        table_name_already_exists: I18n.t("dbdoc.table_name_already_exists"),
+        updated_by_required: I18n.t("dbdoc.updated_by_required"),
+        username_required: I18n.t("dbdoc.username_required"),
+        password_required: I18n.t("dbdoc.password_required")
+      }.to_json.html_safe
+    end
+
+    def admin_nav_active?(controller_name)
+      controller_path == "dbdoc_engine/admin/#{controller_name}"
+    end
+  end
+end

data/app/helpers/dbdoc_engine/application_helper.rb

@@ -0,0 +1,4 @@
+module DbdocEngine
+  module ApplicationHelper
+  end
+end

data/app/helpers/dbdoc_engine/changelogs_helper.rb

@@ -0,0 +1,27 @@
+# app/helpers/changelogs_helper.rb
+# Provides helper methods for changelog-related views and forms
+module DbdocEngine
+  module ChangelogsHelper
+    # Returns an array of options for the entity type select dropdown
+    # Used for filtering changelogs by entity type
+    def entity_type_options
+      [
+        ['All Types', ''], # Option to show all entity types
+        ['Table Group', 'table_group'],
+        ['Table', 'table'],
+        ['Column', 'column']
+      ]
+    end
+
+    # Returns an array of options for the action type select dropdown
+    # Used for filtering changelogs by action type
+    def action_type_options
+      [
+        ['All Actions', ''], # Option to show all action types
+        ['Create', 'create'],
+        ['Update', 'update'],
+        ['Delete', 'delete']
+      ]
+    end
+  end
+end

data/app/helpers/dbdoc_engine/column_helper.rb

@@ -0,0 +1,30 @@
+# app/helpers/column_helper.rb
+module DbdocEngine
+  module ColumnHelper
+    def data_type_select(form, selected_value = nil)
+      # Define the available PostgreSQL data types
+      data_types = [
+        "integer", "smallint", "bigint", "numeric", "real", "double_precision",
+        "varchar", "character", "text", "char", "boolean", "date", "timestamp",
+        "timestamptz", "time", "timetz", "interval", "uuid", "json", "jsonb"
+      ]
+
+      # Generate the select field with select2 controller
+      content_tag(:div, data: {
+                    controller: "select2",
+                    select2_placeholder_value: t("dbdoc.select_data_type")
+                  }) do
+        form.select :data_type,
+                    options_for_select(data_types, selected_value),
+                    { prompt: t("dbdoc.select_data_type") },
+                    class: "form-select #{form.object.errors[:data_type].any? ? 'is-invalid' : ''}",
+                    data: {
+                      column_type_target: "dataType",
+                      select2_target: "select",
+                      action: "change->column-type#updateLength change->column#updateAccordionTitle",
+                      error_target: "dataType"
+                    }
+      end
+    end
+  end
+end

data/app/helpers/dbdoc_engine/db_design_dynamic_tables_helper.rb

@@ -0,0 +1,15 @@
+# app/helpers/db_design_dynamic_tables_helper.rb
+module DbdocEngine
+  module DbDesignDynamicTablesHelper
+    # Returns a list of options for group filter dropdown
+    # @param groups [Array<DbDesignTableGroup>] Collection of table groups
+    # @param selected [String, Integer] The currently selected group ID
+    # @return [Array] Options array for select dropdown
+    def group_filter_options(groups, selected = nil)
+      options_for_select(
+        [ [ I18n.t("dbdoc.all_groups"), "" ] ] + groups.map { |g| [ g.group_name, g.id ] },
+        selected: selected
+      )
+    end
+  end
+end

data/app/helpers/dbdoc_engine/home_helper.rb

@@ -0,0 +1,75 @@
+# This module provides helper methods for the home view.
+# It includes methods for formatting action badges, entity types, table row styles, and array counts.
+module DbdocEngine
+  module HomeHelper
+    # Returns a badge element with appropriate styling based on the action type.
+    def format_action_badge(action_type)
+      badge_classes = 'inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium'
+
+      case action_type
+      when 'create'
+        content_tag(:span, 'Create', class: "#{badge_classes} bg-green-100 text-green-800")
+      when 'update'
+        content_tag(:span, 'Update', class: "#{badge_classes} bg-blue-100 text-blue-800")
+      when 'delete'
+        content_tag(:span, 'Delete', class: "#{badge_classes} bg-red-100 text-red-800")
+      else
+        content_tag(:span, action_type.capitalize, class: "#{badge_classes} bg-gray-100 text-gray-800")
+      end
+    end
+
+    # Formats the entity type into a human-readable format.
+    def format_entity_type(entity_type)
+      case entity_type
+      when 'table_group'
+        'Table Group'
+      when 'table'
+        'Table'
+      when 'column'
+        'Column'
+      else
+        entity_type.capitalize
+      end
+    end
+
+    # Uses .size to leverage eager-loaded associations when available
+    def column_count(table)
+      table.db_design_dynamic_columns.size
+    end
+
+    # Converts a hex color (e.g., "#829ED4") to an RGBA string with transparency
+    def hex_to_rgba(hex_color, alpha = 0.3)
+      rgb_values = hex_color.delete('#').scan(/../).map { |component| component.to_i(16) }
+      "rgba(#{rgb_values.join(', ')}, #{alpha})"
+    end
+
+    # Returns the total count of dynamic columns
+    def dynamic_column_count
+      AdminDashboardQueries.columns_count
+    end
+
+    # Returns the total count of dynamic tables
+    def dynamic_table_count
+      AdminDashboardQueries.tables_count
+    end
+
+    # Returns the total count of changelog entries
+    def changelog_count
+      DbdocEngine::DbDesignChangelogQueries.filtered_changelogs.count
+    end
+
+    # Fetches all table groups with their associated dynamic tables
+    def fetch_table_groups
+      DbdocEngine::DbDesignTableGroupQueries.all_groups_with_tables_and_columns
+    end
+
+    def group_badge_style(group)
+      rgba_color = hex_to_rgba(group.group_color)
+      "background-color: #{rgba_color}; color: #{group.group_color};"
+    end
+
+    def table_column_count(table)
+      table.db_design_dynamic_columns.size
+    end
+  end
+end

data/app/javascript/dbdoc_engine/application.js

@@ -0,0 +1,12 @@
+// app/javascript/dbdoc_engine/application.js
+
+import "@hotwired/turbo-rails";
+import { Application } from "@hotwired/stimulus";
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading";
+
+
+// Initialize Stimulus
+const dbdoc_engine = Application.start();
+eagerLoadControllersFrom("dbdoc_engine/controllers", dbdoc_engine); // Load gem controllers
+
+window.Stimulus = dbdoc_engine;

data/app/javascript/dbdoc_engine/controllers/application.js

@@ -0,0 +1,29 @@
+import { Application } from "@hotwired/stimulus";
+
+const dbdoc_engine = dbdoc_engine.start();
+
+// Configure Stimulus development experience
+dbdoc_engine.debug = false;
+
+export { dbdoc_engine };
+export default class extends Controller {
+    connect() {
+      document.addEventListener('turbo:load', this.updateLanguageDisplay);
+    }
+    
+    disconnect() {
+      document.removeEventListener('turbo:load', this.updateLanguageDisplay);
+    }
+    
+    updateLanguageDisplay = () => {
+      // Refresh language display after Turbo navigation
+      const langController = window.Stimulus.getControllerForElementAndIdentifier(
+        document.querySelector('[data-controller="language"]'),
+        'language'
+      );
+      
+      if (langController) {
+        langController.updateButtonDisplay();
+      }
+    }
+  }

data/app/javascript/dbdoc_engine/controllers/auto_submit_controller.js

@@ -0,0 +1,17 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["form"]
+
+  connect() {
+    this.timeout = null
+  }
+
+  submit() {
+    clearTimeout(this.timeout)
+    
+    this.timeout = setTimeout(() => {
+      this.element.requestSubmit()
+    }, 300) // 300ms delay to avoid too many requests while typing
+  }
+}

data/app/javascript/dbdoc_engine/controllers/chart_controller.js

@@ -0,0 +1,58 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static values = { data: Object }
+
+  connect() {
+    this.initializeChart()
+  }
+  initializeChart() {
+    const ctx = this.element.getContext("2d")
+    if (this.chart) this.chart.destroy()
+  
+    // Check if showing all actions (multiple datasets)
+    const isAllActions = this.dataValue.datasets.length > 1
+  
+    this.chart = new window.Chart(ctx, {
+      type: "bar",
+      data: this.dataValue,
+      options: {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: {
+          legend: {
+            display: isAllActions,
+            position: 'top'
+          },
+          tooltip: {
+            callbacks: {
+              label: (context) => `${context.dataset.label}: ${context.parsed.y}`
+            }
+          }
+        },
+        scales: {
+          x: {
+            stacked: isAllActions,
+            grid: { display: false },
+            title: {
+              display: true,
+              text: 'Entity Types'
+            }
+          },
+          y: {
+            stacked: isAllActions,
+            beginAtZero: true,
+            ticks: { 
+              stepSize: 1,
+              precision: 0
+            },
+            title: {
+              display: true,
+              text: 'Number of Actions'
+            }
+          }
+        }
+      }
+    })
+  }  
+}