dscf-core 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 230e498b674cb3acf80fd9c7637b89c3e8da0e697a108f5d1b8998b9218eda59
-  data.tar.gz: d62246472662f80db9df2478a08afa9eebd163af916aa9a70f408ccbe695bf25
+  metadata.gz: 26fe3945c60e59f5abf2ccff51c02da617f1c063cf19c903c5505567ceed13ca
+  data.tar.gz: 57d0f65ee3a45cb0a8e5560fa90cf99ac1ec6f09ef7c161900eb3357c945ac89
 SHA512:
-  metadata.gz: aadfeecee56e8ffc6ade9f47f244a7e313b23e23913dd99636c0bcff48fa53deb029c0461c8f92d4094352932f99f9941c3de5c97987a5f71bad92aec01364e5
-  data.tar.gz: 5ec8e1e44f084814ba4139be60f4f9c306f42eb383aced86d12764c61a205369242a09e72450f98104e7cb15bece45680210473827dbb691d9c05388581b188b
+  metadata.gz: a75424cbfffeca3f5205660320c9a6cd8a424680d76368f611feef1e578e7b55f90bcc6a0b44eec22d3d09a0c9621f0eb3fffbb149cc64965fa47a2fefea06a6
+  data.tar.gz: 393d2aac7b201c4e84e66fecba0e54ec510977f5b4996bd9b0371e458f3a991408e9cd0ef6f339421fca5d96b303f4a9bee304b93818ad88ac637fdcf9b3c00e

data/app/controllers/concerns/dscf/core/auditable_controller.rb

@@ -16,14 +16,28 @@ module Dscf
 
       class_methods do
         # DSL: Define what to audit
-        # auditable associated: [:reviews], only: [:status], on: [:approve, :reject]
-        # auditable only: [:name, :email], on: [:create, :update]
+        #
+        # Simple format (backwards compatible):
+        #   auditable associated: [:reviews], only: [:status], on: [:approve, :reject]
+        #   auditable only: [:name, :email], on: [:create, :update]
+        #
+        # Advanced format with per-association filters:
+        #   auditable on: [:create, :update],
+        #             only: [:status, :approved_at],          # filter for main record
+        #             except: [:internal_notes],              # exclude for main record
+        #             associated: {
+        #               reviews: { only: [:status, :approved_at] },  # filter for reviews
+        #               comments: { except: [:private_flag] }        # exclude for comments
+        #             }
         def auditable(associated: [], only: [], except: [], on: [], action: nil, transactional: true)
           # Validate configuration
           validate_audit_config!(associated: associated, only: only, except: except, on: on, action: action)
 
+          # Normalize associated to always be a hash internally
+          normalized_associated = normalize_associated_for_config(associated)
+
           config = {
-            associated: Array(associated),
+            associated: normalized_associated,
             only: Array(only),
             except: Array(except),
             on: Array(on).map(&:to_sym),
@@ -33,16 +47,56 @@ module Dscf
           self._audit_configs += [config]
         end
 
+        # Normalize associated configuration to hash format
+        # Input: [:reviews, :comments] or { reviews: { only: [:status] }, comments: {} }
+        # Output: { reviews: { only: [...], except: [...] }, comments: { only: nil, except: nil } }
+        private def normalize_associated_for_config(associated)
+          return {} if associated.blank?
+
+          if associated.is_a?(Array)
+            # Old format: [:reviews, :comments] -> convert to hash
+            associated.each_with_object({}) { |name, h| h[name] = {} }
+          elsif associated.is_a?(Hash)
+            # New format: already a hash
+            associated
+          else
+            {}
+          end
+        end
+
         # Validate audit configuration at definition time
         def validate_audit_config!(associated:, only:, except:, on:, action:)
-          # Validate associated is array of symbols
-          Array(associated).each do |assoc|
-            unless assoc.is_a?(Symbol)
-              raise ArgumentError, "auditable associated: must be an array of symbols, got #{assoc.class} for #{assoc.inspect}"
+          # Validate associated format
+          if associated.is_a?(Array)
+            Array(associated).each do |assoc|
+              unless assoc.is_a?(Symbol)
+                raise ArgumentError, "auditable associated: must be an array of symbols, got #{assoc.class} for #{assoc.inspect}"
+              end
+            end
+          elsif associated.is_a?(Hash)
+            associated.each do |assoc_name, assoc_config|
+              unless assoc_name.is_a?(Symbol)
+                raise ArgumentError, "auditable associated: hash keys must be symbols, got #{assoc_name.class}"
+              end
+
+              if assoc_config.present? && !assoc_config.is_a?(Hash)
+                raise ArgumentError, "auditable associated: hash values must be hashes with :only/:except, got #{assoc_config.class}"
+              end
+
+              # Validate only/except in association config
+              next unless assoc_config.is_a?(Hash)
+
+              assoc_only = Array(assoc_config[:only])
+              assoc_except = Array(assoc_config[:except])
+              overlap = assoc_only & assoc_except
+              if overlap.any?
+                Rails.logger.warn "⚠️  Auditable config warning: 'only' and 'except' overlap for #{assoc_name}: " \
+                                  "#{overlap.join(', ')}. 'except' will take precedence."
+              end
             end
           end
 
-          # Validate only/except don't overlap
+          # Validate only/except don't overlap for main record
           only_arr = Array(only).map(&:to_sym)
           except_arr = Array(except).map(&:to_sym)
           overlap = only_arr & except_arr
@@ -147,7 +201,9 @@ module Dscf
         # Capture current state of associations
         @audit_snapshot[:before_associated] = {}
         active_configs.each do |config|
-          config[:associated].each do |assoc_name|
+          # Handle both array and hash formats for associated
+          assoc_names = config[:associated].is_a?(Hash) ? config[:associated].keys : config[:associated]
+          assoc_names.each do |assoc_name|
             next unless record.respond_to?(assoc_name)
 
             begin
@@ -211,7 +267,9 @@ module Dscf
         after_associated = {}
 
         active_configs.each do |config|
-          config[:associated].each do |assoc_name|
+          # Handle both array and hash formats for associated
+          assoc_names = config[:associated].is_a?(Hash) ? config[:associated].keys : config[:associated]
+          assoc_names.each do |assoc_name|
             next unless record.respond_to?(assoc_name)
 
             begin

data/app/controllers/concerns/dscf/core/reviewable_controller.rb

@@ -78,7 +78,7 @@ module Dscf
                 status: :bad_request
               )
             end
-            perform_review_action(**action_config.slice(:status, :require_feedback, :after, :update_model))
+            perform_review_action(**action_config.slice(:status, :require_feedback, :after, :update_model, :from))
           end
         end
 
@@ -88,7 +88,7 @@ module Dscf
             approve: {status: "approved"},
             reject: {status: "rejected", require_feedback: true},
             request_modification: {status: "modify", require_feedback: true},
-            resubmit: {status: "pending", update_model: true}
+            resubmit: {status: "pending", update_model: true, from: "modify"}
           }
         end
 
@@ -109,10 +109,22 @@ module Dscf
 
         def validate_action_config(actions, statuses, context_name)
           actions.each do |action_name, opts|
-            next if statuses.include?(opts[:status])
+            unless statuses.include?(opts[:status])
+              raise ArgumentError, <<~MSG
+                Action '#{action_name}' in context '#{context_name}' maps to invalid status '#{opts[:status]}'. Must be one of: #{statuses.join(', ')}
+              MSG
+            end
+
+            # Validate 'from' constraints if present
+            next unless opts[:from].present?
+
+            from_statuses = Array(opts[:from]).map(&:to_s)
+            invalid_statuses = from_statuses - statuses
+
+            next if invalid_statuses.empty?
 
             raise ArgumentError, <<~MSG
-              Action '#{action_name}' in context '#{context_name}' maps to invalid status '#{opts[:status]}'. Must be one of: #{statuses.join(', ')}
+              Action '#{action_name}' in context '#{context_name}' has invalid 'from' statuses: #{invalid_statuses.join(', ')}. Must be one of: #{statuses.join(', ')}
             MSG
           end
         end
@@ -146,7 +158,8 @@ module Dscf
         self.class.review_action_names.include?(action_name.to_sym)
       end
 
-      def perform_review_action(status:, require_feedback: false, require_submission_ready: false, after: nil, update_model: false)
+      def perform_review_action(status:, require_feedback: false, require_submission_ready: false, after: nil, update_model: false,
+                                from: nil)
         begin
           context_config
         rescue ArgumentError => e
@@ -154,6 +167,20 @@ module Dscf
         end
 
         current_review = reviewable_resource.current_review_for(current_review_context)
+        current_status = current_review&.status || context_config[:initial_status]
+
+        # Check if action can be performed from the current status
+        if from.present?
+          allowed_from_statuses = Array(from).map(&:to_s)
+          unless allowed_from_statuses.include?(current_status)
+            error_message = "Action '#{action_name}' can only be performed from: " \
+                            "#{allowed_from_statuses.join(', ')}. Current status is '#{current_status}'"
+            return render_error(
+              errors: [error_message],
+              status: :unprocessable_entity
+            )
+          end
+        end
 
         # Check if submission is ready (for submit action)
         if require_submission_ready && !submission_ready?(reviewable_resource)
@@ -172,10 +199,10 @@ module Dscf
                      feedback_data
                    end
 
-        unless valid_transition?(current_review&.status, status)
+        unless valid_transition?(current_status, status)
           return render_error(
             errors: [
-              "Cannot transition from '#{current_review&.status || context_config[:initial_status]}' to '#{status}'"
+              "Cannot transition from '#{current_status}' to '#{status}'"
             ]
           )
         end

data/app/jobs/dscf/core/audit_logger_job.rb

@@ -68,6 +68,7 @@ module Dscf
           # 1. Main record changes
           main_changes = diff_records(before_main, after_main)
           if main_changes.present?
+            # Apply main record filtering (supports only/except at root level)
             filtered = filter_changes(main_changes, config[:only], config[:except])
             if filtered.present?
               structured_changes[:main][:changes] ||= {}
@@ -76,7 +77,10 @@ module Dscf
           end
 
           # 2. Associated record changes
-          config[:associated].each do |assoc_name|
+          # Support both old format (array) and new format (hash with per-association filters)
+          associations_config = normalize_associated_config(config[:associated])
+
+          associations_config.each do |assoc_name, assoc_options|
             assoc_key = assoc_name.to_sym
             before_assoc = before_associated[assoc_key] || []
             after_assoc = after_associated[assoc_key] || []
@@ -84,8 +88,10 @@ module Dscf
             assoc_changes = diff_associated_records(before_assoc, after_assoc, assoc_name)
             next unless assoc_changes.present?
 
-            # Apply filtering to associated changes
-            filtered_assoc_changes = filter_associated_changes(assoc_changes, config[:only], config[:except])
+            # Apply per-association filtering
+            assoc_only = assoc_options[:only]
+            assoc_except = assoc_options[:except]
+            filtered_assoc_changes = filter_associated_changes(assoc_changes, assoc_only, assoc_except)
             next unless filtered_assoc_changes.present?
 
             # Structure: { "reviews.123" => { action: "created", changes: {...} } }
@@ -115,6 +121,29 @@ module Dscf
         structured_changes
       end
 
+      # Normalize associated config to support both array and hash formats
+      # Input: [:reviews, :comments] or { reviews: { only: [:status] }, comments: {} }
+      # Output: { reviews: { only: [...], except: [...] }, comments: { only: nil, except: nil } }
+      def normalize_associated_config(associated)
+        return {} if associated.blank?
+
+        if associated.is_a?(Array)
+          # Old format: [:reviews, :comments] -> convert to hash with no filters
+          associated.each_with_object({}) { |name, h| h[name] = {only: nil, except: nil} }
+        elsif associated.is_a?(Hash)
+          # New format: already a hash, ensure each value is a hash with only/except
+          associated.transform_values do |value|
+            if value.is_a?(Hash)
+              {only: value[:only], except: value[:except]}
+            else
+              {only: nil, except: nil}
+            end
+          end
+        else
+          {}
+        end
+      end
+
       # Diff two record states (before/after)
       def diff_records(before, after)
         return {} if after.blank?
@@ -156,6 +185,7 @@ module Dscf
       end
 
       # Diff associated records (handle create/update/delete)
+      # Automatically excludes timestamp fields (created_at, updated_at) for associated records
       def diff_associated_records(before_list, after_list, assoc_name)
         changes = {}
 
@@ -167,9 +197,18 @@ module Dscf
         after_map.each do |id, after_rec|
           next if before_map[id]
 
+          # Convert attributes to change format (old: nil, new: value)
+          # Skip timestamp fields automatically
+          created_changes = {}
+          (after_rec[:attributes] || {}).each do |key, value|
+            next if %w[created_at updated_at].include?(key.to_s)
+
+            created_changes[key] = {old: nil, new: value}
+          end
+
           changes["#{assoc_name}.#{id}"] = {
             action: "created",
-            attributes: after_rec[:attributes]
+            changes: created_changes
           }
         end
 
@@ -179,19 +218,32 @@ module Dscf
           next unless after_rec
 
           record_changes = diff_records(before_rec, after_rec)
+          # Skip timestamp fields from updates
+          record_changes.reject! { |key, _| %w[created_at updated_at].include?(key.to_s) }
           next unless record_changes.present?
 
           changes["#{assoc_name}.#{id}"] = {
             action: "updated",
             changes: record_changes
           }
+        end
 
-          # Detect deleted records (in before but not in after)
+        # Detect deleted records (in before but not in after)
+        before_map.each do |id, before_rec|
           next if after_map[id]
 
+          # Convert attributes to change format (old: value, new: nil)
+          # Skip timestamp fields automatically
+          deleted_changes = {}
+          (before_rec[:attributes] || {}).each do |key, value|
+            next if %w[created_at updated_at].include?(key.to_s)
+
+            deleted_changes[key] = {old: value, new: nil}
+          end
+
           changes["#{assoc_name}.#{id}"] = {
             action: "deleted",
-            attributes: before_rec[:attributes]
+            changes: deleted_changes
           }
         end
 

data/lib/dscf/core/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Core
-    VERSION = "0.2.6".freeze
+    VERSION = "0.2.7".freeze
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-core
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Asrat
 bindir: bin
 cert_chain: []
-date: 2025-11-03 00:00:00.000000000 Z
+date: 2025-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails