rails_nexus 2.0.3 → 2.1.0

data/app/javascript/controllers/rails_nexus_controller.js

@@ -274,12 +274,14 @@ export default class extends Controller {
       this.closeShortcuts()
     } else {
       this.shortcutsDialogTarget.classList.add("open")
+      document.getElementById("rn-shortcuts-button")?.setAttribute("aria-expanded", "true")
     }
   }
 
   closeShortcuts() {
     if (this.hasShortcutsDialogTarget) {
       this.shortcutsDialogTarget.classList.remove("open")
+      document.getElementById("rn-shortcuts-button")?.setAttribute("aria-expanded", "false")
     }
   }
 
@@ -371,10 +373,14 @@ export default class extends Controller {
   // ─── Loading State ────────────────────────────────────────
 
   showActivity() {
-    this.activityTarget?.classList.remove("hidden")
+    if (!this.hasActivityTarget) return
+    this.activityTarget.hidden = false
+    this.activityTarget.classList.remove("hidden")
   }
 
   hideActivity() {
-    this.activityTarget?.classList.add("hidden")
+    if (!this.hasActivityTarget) return
+    this.activityTarget.hidden = true
+    this.activityTarget.classList.add("hidden")
   }
 }

data/app/javascript/controllers/rails_nexus_sidebar_controller.js

@@ -1,15 +1,96 @@
 import { Controller } from "@hotwired/stimulus"
 
 export default class extends Controller {
-  static targets = ["drawer", "overlay"]
+  static targets = ["drawer", "overlay", "sidebar", "toggleButton"]
+
+  connect() {
+    this.handleResize = this.syncButtonState.bind(this)
+    window.addEventListener("resize", this.handleResize)
+
+    if (this.desktop() && this.sidebarHidden()) {
+      this.sidebarTarget.classList.add("is-hidden")
+    }
+
+    this.syncButtonState()
+  }
+
+  disconnect() {
+    window.removeEventListener("resize", this.handleResize)
+  }
 
   toggle() {
-    this.drawerTarget.classList.toggle("open")
-    this.overlayTarget.classList.toggle("open")
+    if (this.desktop()) {
+      const hidden = this.sidebarTarget.classList.toggle("is-hidden")
+      this.storeSidebarState(hidden)
+    } else {
+      const opening = !this.drawerTarget.classList.contains("open")
+      this.drawerTarget.classList.toggle("open", opening)
+      this.overlayTarget.classList.toggle("open", opening)
+    }
+
+    this.syncButtonState()
   }
 
   close() {
     this.drawerTarget.classList.remove("open")
     this.overlayTarget.classList.remove("open")
+    this.syncButtonState()
+  }
+
+  desktop() {
+    return window.matchMedia("(min-width: 1024px)").matches
+  }
+
+  sidebarHidden() {
+    try {
+      return localStorage.getItem("rails_nexus-sidebar-hidden") === "true"
+    } catch (_error) {
+      return false
+    }
+  }
+
+  storeSidebarState(hidden) {
+    try {
+      localStorage.setItem("rails_nexus-sidebar-hidden", hidden.toString())
+    } catch (_error) {
+      // The toggle still works when storage is unavailable.
+    }
+  }
+
+  syncButtonState() {
+    if (!this.hasToggleButtonTarget) return
+
+    const expanded = this.desktop()
+      ? !this.sidebarTarget.classList.contains("is-hidden")
+      : this.drawerTarget.classList.contains("open")
+
+    this.toggleButtonTarget.setAttribute("aria-expanded", expanded.toString())
+    this.toggleButtonTarget.setAttribute("aria-label", expanded ? "Hide navigation" : "Show navigation")
+    this.toggleButtonTarget.title = expanded ? "Hide navigation" : "Show navigation"
+  }
+
+  closeOtherMenus(event) {
+    const currentMenu = event.currentTarget
+    if (!currentMenu.open) return
+
+    const navigation = currentMenu.closest(".rn-sidebar-nav")
+    if (!navigation) return
+
+    navigation.querySelectorAll("details.rn-nav-section[open]").forEach((menu) => {
+      if (menu !== currentMenu) menu.open = false
+    })
+  }
+
+  toggleShortcuts(event) {
+    const dialog = document.querySelector("[data-rails_nexus-target='shortcutsDialog']")
+    if (!dialog) return
+
+    const isOpening = !dialog.classList.contains("open")
+    dialog.classList.toggle("open", isOpening)
+    event.currentTarget.setAttribute("aria-expanded", isOpening.toString())
+
+    if (isOpening) {
+      dialog.querySelector("button")?.focus()
+    }
   }
 }

data/app/jobs/rails_nexus/backup_job.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RailsNexus
+  class BackupJob < ApplicationJob
+    queue_as :rails_nexus_backups
+
+    # Accept either a BackupConfig record ID or a BackupConfig record
+    def perform(backup_config_id_or_record)
+      config = if backup_config_id_or_record.is_a?(RailsNexus::BackupConfig)
+        backup_config_id_or_record
+      else
+        RailsNexus::BackupConfig.find(backup_config_id_or_record)
+      end
+
+      RailsNexus::BackupService.run(config)
+    end
+  end
+end

data/app/models/rails_nexus/backup.rb

@@ -4,7 +4,7 @@ module RailsNexus
   class Backup < BaseRecord
     self.table_name = "rails_nexus_backups"
 
-    validates :model_name, presence: true
+    validates :config_name, presence: true
     validates :status, presence: true, inclusion: { in: %w[running success failed] }
     validates :started_at, presence: true
 
@@ -12,13 +12,13 @@ module RailsNexus
     scope :successful, -> { where(status: "success") }
     scope :failed, -> { where(status: "failed") }
     scope :running, -> { where(status: "running") }
-    scope :by_model, ->(name) { where(model_name: name) }
+    scope :by_config, ->(name) { where(config_name: name) }
     scope :latest_first, -> { order(started_at: :desc) }
 
     # Start tracking a backup run
-    def self.start!(model_name:, triggered_by: "system")
+    def self.start!(config_name:, triggered_by: "system")
       create!(
-        model_name: model_name,
+        config_name: config_name,
         status: "running",
         triggered_by: triggered_by,
         started_at: Time.current
@@ -47,25 +47,25 @@ module RailsNexus
     end
 
     # Get success rate for a model over the last N days
-    def self.success_rate(model_name:, days: 7)
-      records = by_model(model_name).where("started_at >= ?", days.days.ago).where.not(status: "running")
+    def self.success_rate(config_name:, days: 7)
+      records = by_config(config_name).where("started_at >= ?", days.days.ago).where.not(status: "running")
       return 0 if records.empty?
       (records.successful.count.to_f / records.count * 100).round(1)
     end
 
     # Get backup health summary
     def self.health_summary(alert_threshold_hours: 24)
-      models = RailsNexus.configuration.backup_models || []
-      results = models.map do |model_name|
-        latest = by_model(model_name).successful.latest_first.first
+      configs = RailsNexus::BackupConfig.pluck(:name)
+      results = configs.map do |config_name|
+        latest = by_config(config_name).successful.latest_first.first
         age_hours = latest ? ((Time.current - latest.started_at) / 3600).round(1) : nil
 
         {
-          model_name: model_name,
+          config_name: config_name,
           last_backup: latest&.started_at,
           age_hours: age_hours,
           status: age_hours.nil? ? "unknown" : (age_hours < alert_threshold_hours ? "healthy" : "stale"),
-          success_rate: success_rate(model_name: model_name),
+          success_rate: success_rate(config_name: config_name),
           last_file_size: latest&.file_size
         }
       end

data/app/models/rails_nexus/backup_config.rb

@@ -4,50 +4,107 @@ module RailsNexus
   class BackupConfig < BaseRecord
     self.table_name = "rails_nexus_backup_configs"
 
-    ADAPTERS = %w[mysql postgresql sqlite].freeze
+    ADAPTERS = %w[mysql postgresql sqlite mongodb redis].freeze
+
+    # ─── Boolean defaults ──────────────────────────────────────────
+    # Rails doesn't apply DB defaults to new in-memory records, so
+    # check_box helpers in form_for render unchecked. These declarations
+    # ensure the form reflects the intended defaults.
+    attribute :enabled,            :boolean, default: true
+    attribute :compress,           :boolean, default: true
+    attribute :encrypted,          :boolean, default: false
+    attribute :encrypt_base64,     :boolean, default: false
+    attribute :rsync_enabled,      :boolean, default: false
+    attribute :rsync_mirror,       :boolean, default: false
+    attribute :notify_on_success,  :boolean, default: true
+    attribute :notify_on_failure,  :boolean, default: true
+    attribute :s3_enabled,         :boolean, default: false
+    attribute :gpg_enabled,        :boolean, default: false
+    attribute :email_notify,       :boolean, default: false
+    attribute :archive_enabled,    :boolean, default: false
+    attribute :bzip2_compress,     :boolean, default: false
+    attribute :split_chunks,       :boolean, default: false
 
     validates :name, presence: true, uniqueness: true
-    validates :database_name, presence: true
+    validates :database_name, presence: true, if: -> { adapter != "redis" }
     validates :adapter, presence: true, inclusion: { in: ADAPTERS }
     validates :storage_path, presence: true
     validates :keep_count, numericality: { greater_than: 0 }
-    validates :encrypt_password, presence: true, if: :encrypt?
+    validates :encryption_password, presence: true, if: :encrypted?
     validates :rsync_host, presence: true, if: :rsync_enabled?
     validates :rsync_user, presence: true, if: :rsync_enabled?
+    validates :s3_bucket, presence: true, if: :s3_enabled?
+    validates :s3_access_key, presence: true, if: :s3_enabled?
+    validates :s3_secret_key, presence: true, if: :s3_enabled?
+    validates :gpg_password, presence: true, if: :gpg_enabled?
+    validates :email_to, presence: true, if: :email_notify?
 
     scope :enabled,  -> { where(enabled: true) }
     scope :disabled, -> { where(enabled: false) }
 
     serialize :skip_tables, coder: JSON
+    serialize :archive_paths, coder: JSON
+    serialize :archive_excludes, coder: JSON
 
+    # ─── Skip Tables ───────────────────────────────────────────────
     def skip_tables_list
       return [] if skip_tables.blank?
       skip_tables.is_a?(Array) ? skip_tables : JSON.parse(skip_tables.to_s) rescue []
     end
 
-    def skip_tables_list=(list)
-      self.skip_tables = list
+    def skip_tables_list=(value)
+      return if value.blank?
+      self.skip_tables = if value.is_a?(String)
+        value.split(",").map(&:strip).reject(&:blank?)
+      else
+        value
+      end
     end
 
-    def mysql?
-      adapter == "mysql"
+    # ─── Archive Paths ─────────────────────────────────────────────
+    def archive_paths_list
+      return [] if archive_paths.blank?
+      archive_paths.is_a?(Array) ? archive_paths : JSON.parse(archive_paths.to_s) rescue []
     end
 
-    def postgresql?
-      adapter == "postgresql"
+    def archive_paths_list=(value)
+      return if value.blank?
+      self.archive_paths = if value.is_a?(String)
+        value.split(",").map(&:strip).reject(&:blank?)
+      else
+        value
+      end
     end
 
-    def sqlite?
-      adapter == "sqlite"
+    def archive_excludes_list
+      return [] if archive_excludes.blank?
+      archive_excludes.is_a?(Array) ? archive_excludes : JSON.parse(archive_excludes.to_s) rescue []
     end
 
+    def archive_excludes_list=(value)
+      return if value.blank?
+      self.archive_excludes = if value.is_a?(String)
+        value.split(",").map(&:strip).reject(&:blank?)
+      else
+        value
+      end
+    end
+
+    # ─── Adapter checks ────────────────────────────────────────────
+    def mysql?;         adapter == "mysql";        end
+    def postgresql?;    adapter == "postgresql";    end
+    def sqlite?;        adapter == "sqlite";        end
+    def mongodb?;       adapter == "mongodb";       end
+    def redis?;         adapter == "redis";         end
+
+    # ─── Path helpers ──────────────────────────────────────────────
     def storage_path_expanded
       storage_path.gsub("~", Dir.home)
     end
 
     def dump_filename
       timestamp = Time.current.strftime("%Y%m%d_%H%M%S")
-      ext = compress? ? "sql.gz" : "sql"
+      ext = dump_extension
       "#{name}_#{timestamp}.#{ext}"
     end
 
@@ -55,14 +112,17 @@ module RailsNexus
       File.join(storage_path_expanded, dump_filename)
     end
 
-    # Get recent backup records for this config
+    # ─── Stats ─────────────────────────────────────────────────────
     def recent_backups(limit: 10)
-      RailsNexus::Backup.where(model_name: name).order(started_at: :desc).limit(limit)
+      RailsNexus::Backup.where(config_name: name).order(started_at: :desc).limit(limit)
+    end
+
+    def last_failure
+      RailsNexus::Backup.where(config_name: name, status: "failed").order(started_at: :desc).first
     end
 
-    # Summary stats
     def stats
-      backups = RailsNexus::Backup.where(model_name: name)
+      backups = RailsNexus::Backup.where(config_name: name)
       recent = backups.where("started_at >= ?", 7.days.ago)
       {
         total: backups.count,
@@ -79,6 +139,14 @@ module RailsNexus
 
     private
 
+    def dump_extension
+      parts = ["sql"]
+      parts << "gz" if compress? && !bzip2_compress?
+      parts << "bz2" if bzip2_compress?
+      parts << "enc" if encrypted?
+      parts.join(".")
+    end
+
     def human_size(bytes)
       return "0 B" if bytes.zero?
       units = %w[B KB MB GB TB]