dbdoc_engine 0.1.0

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

@@ -0,0 +1,423 @@
+import { Controller } from "@hotwired/stimulus"
+
+/**
+ * Stimulus controller that handles form validation for database table creation/editing
+ * Validates table information, columns, and checks for duplicate column names
+ */
+export default class extends Controller {
+  // Define target elements that can be referenced in the controller
+  static targets = ["tableName", "physicalTableName", "tableGroup", "createdBy", "updatedBy"]
+
+  /**
+   * Connect lifecycle method - called when controller is connected to the DOM
+   * Sets up event listeners for real-time data syncing
+   */
+  connect() {
+    // Check if we're in create mode (hidden updated_by field exists)
+    const hiddenUpdatedBy = this.element.querySelector('input[name$="[updated_by]"][type="hidden"]');
+    const createdBy = this.element.querySelector('input[name$="[created_by]"]');
+    
+    // If both fields exist, set up the sync between created_by and updated_by
+    if (hiddenUpdatedBy && createdBy) {
+      // Sync on input changes
+      createdBy.addEventListener('input', () => {
+        hiddenUpdatedBy.value = createdBy.value;
+      });
+    }
+  }
+
+  /**
+   * Main validation method triggered on form submission
+   * Prevents default form submission, validates all required fields,
+   * and only submits if all validations pass
+   * 
+   * @param {Event} event - The form submission event
+   */
+  validate(event) {
+    event.preventDefault()
+    let isValid = true
+
+    // Reset previous error states
+    this.clearErrors()
+
+    // For new record: Make sure hidden updated_by is synced with created_by before validation
+    const hiddenUpdatedBy = this.element.querySelector('input[name$="[updated_by]"][type="hidden"]');
+    const createdBy = this.element.querySelector('input[name$="[created_by]"]');
+    if (hiddenUpdatedBy && createdBy) {
+      hiddenUpdatedBy.value = createdBy.value;
+    }
+
+    // Store all invalid elements for scrolling later
+    const invalidElements = []
+
+    // Run all validation checks and aggregate results
+    isValid = this.validateTableInformation(invalidElements) && isValid
+    isValid = this.validateColumns(invalidElements) && isValid
+    isValid = this.checkDuplicateColumnNames(invalidElements) && isValid
+
+    if (isValid) {
+      event.target.submit() // If everything is valid, submit the form
+    } else {
+      // If not valid, scroll to the first invalid element
+      if (invalidElements.length > 0) {
+        // Expand accordion section if the error is in a column
+        const accordionParent = this.findAccordionParent(invalidElements[0])
+        if (accordionParent) {
+          this.expandAccordion(accordionParent)
+        }
+        
+        // Scroll to the element with error
+        setTimeout(() => {
+          invalidElements[0].scrollIntoView({ behavior: 'smooth', block: 'center' })
+          invalidElements[0].focus()
+        }, accordionParent ? 400 : 0) // Small delay when expanding accordion
+      }
+    }
+  }
+
+  /**
+   * Validates the main table information fields
+   * Checks for required values in table name, physical name, group, created by fields,
+   * and updated_by when editing an existing table
+   * 
+   * @param {Array} invalidElements - Array to collect invalid elements
+   * @returns {boolean} - True if all table information is valid, false otherwise
+   */
+  validateTableInformation(invalidElements = []) {
+    let isValid = true;
+  
+    // Select input fields safely using attribute selectors
+    const tableName = this.element.querySelector('[name$="[table_name]"]');
+    const physicalTableName = this.element.querySelector('[name$="[physical_table_name]"]');
+    const tableGroup = this.element.querySelector('[name$="[db_design_table_group_id]"]');
+    const createdBy = this.element.querySelector('[name$="[created_by]"]');
+    
+    // Updated by field - first get the visible one (not hidden)
+    const visibleUpdatedBy = this.element.querySelector('input[name$="[updated_by]"]:not([type="hidden"])');
+    // Determines if we're in edit mode (has visible updated_by field)
+    const isEditing = !!visibleUpdatedBy;
+    
+    // Validate each field only if it exists, showing appropriate errors
+    if (!tableName || !tableName.value.trim()) {
+      this.showError(tableName, "table_name_required");
+      invalidElements.push(tableName);
+      isValid = false;
+    }
+  
+    if (!physicalTableName || !physicalTableName.value.trim()) {
+      this.showError(physicalTableName, "physical_table_name_required");
+      if (!invalidElements.length) invalidElements.push(physicalTableName);
+      isValid = false;
+    }
+  
+    if (!tableGroup || !tableGroup.value.trim()) {
+      this.showError(tableGroup, "table_group_must_be_selected");
+      if (!invalidElements.length) invalidElements.push(tableGroup);
+      isValid = false;
+    }
+  
+    if (!createdBy || !createdBy.value.trim()) {
+      this.showError(createdBy, "created_by_field_required");
+      if (!invalidElements.length) invalidElements.push(createdBy);
+      isValid = false;
+    }
+    
+    // Only validate updated_by when editing (only if visible updated_by exists)
+    if (isEditing && (!visibleUpdatedBy.value.trim())) {
+      this.showError(visibleUpdatedBy, "updated_by_required");
+      if (!invalidElements.length) invalidElements.push(visibleUpdatedBy);
+      isValid = false;
+    }
+  
+    return isValid;
+  }
+  
+  /**
+   * Validates all column fields for each table column
+   * Skips columns marked for deletion and validates required fields
+   * Performs special validation for foreign keys and data types with length requirements
+   * 
+   * @param {Array} invalidElements - Array to collect invalid elements
+   * @returns {boolean} - True if all columns are valid, false otherwise
+   */
+  validateColumns(invalidElements = []) {
+    const columnContainers = document.querySelectorAll('.column-fields')
+    let allColumnsValid = true
+
+    columnContainers.forEach((container) => {
+      // Skip columns marked for deletion
+      const destroyInput = container.querySelector('[name$="[_destroy]"]')
+      if (destroyInput && destroyInput.value === '1') {
+        return
+      }
+
+      // Select column fields
+      const columnName = container.querySelector('[name$="[column_name]"]')
+      const physicalColumnName = container.querySelector('[name$="[physical_column_name]"]')
+      const dataType = container.querySelector('[name$="[data_type]"]')
+      const length = container.querySelector('[name$="[length]"]')
+      const createdBy = container.querySelector('[name$="[created_by]"]')
+
+      // Find foreign key related elements with more robust selection
+      const foreignKeyCheckbox = container.querySelector('[name$="[is_foreign_key]"]')
+      const foreignKeyFieldsContainer = container.querySelector('.foreign-key-fields')
+      const referencedTable = container.querySelector('[name$="[foreign_table_name]"]')
+      const referencedColumn = container.querySelector('[name$="[foreign_column_name]"]')
+      const relationshipType = container.querySelector('[name$="[relationship_type]"]')
+
+      // Multiple ways to determine if foreign key is active
+      const isForeignKeyChecked = foreignKeyCheckbox?.checked || 
+                           foreignKeyCheckbox?.value === '1' || 
+                           !foreignKeyFieldsContainer?.classList.contains('hidden')
+
+      let columnHasError = false;
+
+      // Validate required column fields
+      if (!columnName.value.trim()) {
+        this.showError(columnName, "column_name_required")
+        if (!columnHasError) {
+          invalidElements.push(columnName)
+          columnHasError = true
+        }
+        allColumnsValid = false
+      }
+
+      if (!physicalColumnName.value.trim()) {
+        this.showError(physicalColumnName, "physical_column_name_required")
+        if (!columnHasError) {
+          invalidElements.push(physicalColumnName)
+          columnHasError = true
+        }
+        allColumnsValid = false
+      }
+
+      if (!dataType.value) {
+        this.showError(dataType, "data_type_must_be_selected")
+        if (!columnHasError) {
+          invalidElements.push(dataType)
+          columnHasError = true
+        }
+        allColumnsValid = false
+      }
+
+      // Special validation for data types that require length specification
+      const lengthRequiredTypes = ['varchar', 'character', 'char']
+      if (lengthRequiredTypes.includes(dataType.value) && (!length.value || parseInt(length.value) <= 0)) {
+        this.showError(length, "length_is_required_for_this_data_type")
+        if (!columnHasError) {
+          invalidElements.push(length)
+          columnHasError = true
+        }
+        allColumnsValid = false
+      }
+
+      if (!createdBy.value.trim()) {
+        this.showError(createdBy, "created_by_field_required")
+        if (!columnHasError) {
+          invalidElements.push(createdBy)
+          columnHasError = true
+        }
+        allColumnsValid = false
+      }
+
+      // Enhanced foreign key validation - only validate if it's marked as a foreign key
+      if (isForeignKeyChecked) {
+        // Check if referenced table is selected
+        if (!referencedTable || !referencedTable.value.trim()) {
+          this.showError(referencedTable, "referenced_table_is_required_for_foreign_key")
+          if (!columnHasError) {
+            invalidElements.push(referencedTable)
+            columnHasError = true
+          }
+          allColumnsValid = false
+        }
+
+        // Check if referenced column is selected  
+        if (!referencedColumn || !referencedColumn.value.trim()) {
+          this.showError(referencedColumn, "referenced_column_is_required_for_foreign_key")
+          if (!columnHasError) {
+            invalidElements.push(referencedColumn)
+            columnHasError = true
+          }
+          allColumnsValid = false
+        }
+
+        if (!relationshipType || !relationshipType.value.trim()) {
+          this.showError(relationshipType, "relationship_type_is_required_for_foreign_key")
+          if (!columnHasError) {
+            invalidElements.push(relationshipType)
+            columnHasError = true
+          }
+          allColumnsValid = false
+        }
+      }
+    })
+
+    return allColumnsValid
+  }
+
+  /**
+   * Checks for duplicate column names within the table
+   * Collects all active column names and marks duplicates with errors
+   * 
+   * @param {Array} invalidElements - Array to collect invalid elements
+   * @returns {boolean} - True if no duplicates found, false otherwise
+   */
+  checkDuplicateColumnNames(invalidElements = []) {
+    const columnContainers = document.querySelectorAll('.column-fields')
+    const columnNames = new Map()
+    let hasDuplicates = false
+
+    // First pass: collect all active column names
+    columnContainers.forEach((container) => {
+      // Skip columns marked for deletion
+      const destroyInput = container.querySelector('[name$="[_destroy]"]')
+      if (destroyInput && destroyInput.value === '1') {
+        return
+      }
+
+      const columnNameInput = container.querySelector('[name$="[column_name]"]')
+      if (columnNameInput && columnNameInput.value.trim()) {
+        const columnName = columnNameInput.value.trim().toLowerCase()
+        
+        if (columnNames.has(columnName)) {
+          // Store references to all inputs with this name for error marking
+          columnNames.set(columnName, [...columnNames.get(columnName), columnNameInput])
+          hasDuplicates = true
+        } else {
+          columnNames.set(columnName, [columnNameInput])
+        }
+      }
+    })
+
+    // Second pass: show errors for duplicates
+    if (hasDuplicates) {
+      columnNames.forEach((inputs, name) => {
+        if (inputs.length > 1) {
+          inputs.forEach((input, index) => {
+            this.showError(input, "duplicate_columns")
+            // Only add the first instance of each duplicate to the invalid elements
+            if (index === 0 && invalidElements.length === 0) {
+              invalidElements.push(input)
+            }
+          })
+        }
+      })
+      return false
+    }
+
+    return true
+  }
+
+  /**
+   * Displays an error message for an input element
+   * Adds is-invalid class and creates/updates an error message div
+   * 
+   * @param {HTMLElement} element - The input element to mark as invalid
+   * @param {string} messageKey - The translation key for the error message
+   */
+  showError(element, messageKey) {
+    if (!element) return
+  
+    // Add 'is-invalid' class to input/select field
+    element.classList.add('is-invalid')
+  
+    // Get translated message from the hidden translations div
+    const translatedMessage = this.getTranslation(messageKey)
+  
+    // First, remove any existing error messages for this element
+    const existingErrors = element.parentNode.querySelectorAll('.invalid-feedback')
+    existingErrors.forEach(errorEl => errorEl.remove())
+  
+    // Create a new error message element
+    const errorElement = document.createElement('div')
+    errorElement.classList.add('invalid-feedback', 'd-block')
+    errorElement.textContent = translatedMessage
+    
+    // Append it after the input element
+    element.parentNode.appendChild(errorElement)
+  }
+
+  /**
+   * Retrieves a translated error message using a global translations object
+   * Falls back to the key itself if translation not found
+   * 
+   * @param {string} key - The translation key
+   * @returns {string} - The translated message or the key if not found
+   */
+  getTranslation(key) {
+    // Use the global Translations object if available
+    if (window.Translations && window.Translations[key]) {
+      return window.Translations[key];
+    }
+    return key;
+  }
+
+  /**
+   * Clears all validation errors from the form
+   * Removes is-invalid classes and error message elements
+   */
+  clearErrors() {
+    // Remove 'is-invalid' class and error messages
+    this.element.querySelectorAll('.is-invalid').forEach(el => {
+      el.classList.remove('is-invalid')
+      const errorEl = el.nextElementSibling
+      if (errorEl && errorEl.classList.contains('invalid-feedback')) {
+        errorEl.remove()
+      }
+    })
+  }
+
+  /**
+   * Finds the closest accordion parent element for an input
+   * Updated to work with custom dbdoc-accordion controller
+   * 
+   * @param {HTMLElement} element - The input element
+   * @returns {HTMLElement|null} - The accordion item element or null
+   */
+  findAccordionParent(element) {
+    if (!element) return null
+
+    // Look for the accordion item that contains the dbdoc-accordion controller
+    let parent = element.closest('[data-controller*="dbdoc-accordion"]')
+    
+    return parent
+  }
+
+  /**
+   * Expands an accordion section using the custom dbdoc-accordion controller
+   * 
+   * @param {HTMLElement} accordionElement - The accordion item element with dbdoc-accordion controller
+   */
+  expandAccordion(accordionElement) {
+    if (!accordionElement) return
+
+    // Get the Stimulus controller instance for the accordion
+    const accordionController = window.Stimulus.getControllerForElementAndIdentifier(accordionElement, 'dbdoc-accordion')
+    
+    if (accordionController) {
+      // Check if it's already open by looking at the content target
+      const contentTarget = accordionController.contentTarget
+      const isOpen = contentTarget && contentTarget.classList.contains('show')
+      
+      if (!isOpen) {
+        // Use the controller's open method to expand the accordion
+        accordionController.open()
+      }
+    } else {
+      // Fallback method if controller instance is not accessible
+      const contentElement = accordionElement.querySelector('[data-dbdoc-accordion-target="content"]')
+      const buttonElement = accordionElement.querySelector('[data-dbdoc-accordion-target="button"]')
+      
+      if (contentElement && buttonElement) {
+        const isOpen = contentElement.classList.contains('show')
+        
+        if (!isOpen) {
+          contentElement.classList.add('show')
+          buttonElement.setAttribute('aria-expanded', 'true')
+          buttonElement.classList.remove('collapsed')
+        }
+      }
+    }
+  }
+}

data/app/jobs/dbdoc_engine/application_job.rb

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

data/app/mailers/dbdoc_engine/application_mailer.rb

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

data/app/models/dbdoc_engine/application_record.rb

@@ -0,0 +1,6 @@
+# app/models/dbdoc_engine/application_record.rb
+module DbdocEngine
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/dbdoc_engine/concerns/soft_deletable.rb

@@ -0,0 +1,30 @@
+# app/models/concerns/soft_deletable.rb
+module DbdocEngine::Concerns::SoftDeletable
+  extend ActiveSupport::Concern
+
+  included do
+    scope :without_deleted, -> { where(deleted_at: nil) }
+    scope :with_deleted, -> { unscope(where: :deleted_at) }
+    scope :only_deleted, -> { unscope(where: :deleted_at).where.not(deleted_at: nil) }
+  end
+
+  def deleted?
+    deleted_at.present?
+  end
+
+  def soft_delete
+    update(deleted_at: Time.current)
+  end
+
+  def restore
+    update(deleted_at: nil)
+  end
+
+  def self.soft_delete_all
+    update_all(deleted_at: Time.current)
+  end
+
+  def self.restore_all
+    update_all(deleted_at: nil)
+  end
+end

data/app/models/dbdoc_engine/db_design_changelog.rb

@@ -0,0 +1,44 @@
+# Model for logging changes made to tables, table groups, and columns.
+# It tracks actions such as create, update, and delete, and stores related metadata like entity names,
+# descriptions, and the user who made the changes.
+module DbdocEngine
+  class DbDesignChangelog < ApplicationRecord
+    self.table_name = 'db_design_changelogs'
+    # Constants for action types
+    ACTION_CREATE = 'create'.freeze
+    ACTION_UPDATE = 'update'.freeze
+    ACTION_DELETE = 'delete'.freeze
+
+    # Constants for entity types
+    ENTITY_TABLE_GROUP = 'table_group'.freeze
+    ENTITY_TABLE = 'table'.freeze
+    ENTITY_COLUMN = 'column'.freeze
+
+    # Validations
+    validates :change_timestamp, presence: true
+
+    # Ensures action type is present and valid
+    validates :action_type, presence: true, inclusion: { in: [ACTION_CREATE, ACTION_UPDATE, ACTION_DELETE] }
+
+    # Ensures entity type is present and valid
+    validates :entity_type, presence: true, inclusion: { in: [ENTITY_TABLE_GROUP, ENTITY_TABLE, ENTITY_COLUMN] }
+
+    # Ensures entity name is provided
+    validates :entity_name, presence: true
+
+    # Ensures a description of the change is provided
+    validates :description, presence: true
+
+    # Ensures the name of the user who made the change is provided
+    validates :changed_by, presence: true
+
+    # Helper method to create changelog entry
+    def self.log_change(*args)
+      DbdocEngine::DbDesignChangelogQueries.log_change(*args)
+    end
+
+    def self.filtered_changelogs(params)
+      DbdocEngine::DbDesignChangelogQueries.filtered_changelogs(params)
+    end
+  end
+end