dami 1.0.0

data/lib/dami/plugins/associations.rb

@@ -0,0 +1,284 @@
+# File: lib/dami/plugins/associations.rb
+
+# frozen_string_literal: true
+module Dami
+  module Plugins
+    module Associations
+      @association_modules = {}
+
+      def self.clear_cache!
+        @association_modules.clear
+      end
+
+      # Defines class-level DSL methods (e.g., .association_module_for)
+      module ClassMethods
+        def association_module_cache
+          Associations.instance_variable_get(:@association_modules)
+        end
+
+        def association_module_for(model_name)
+          association_module_cache[model_name] ||= create_association_module(model_name)
+        end
+
+        private
+
+        def create_association_module(model_name)
+          mod = Module.new
+          model_config = Dami.find_model(model_name) rescue nil
+          return mod unless model_config && (rels = model_config[:relationships])
+
+          rels.each do |_type, rel_config|
+            rel_config.each do |name, _options|
+              actual_name = name.is_a?(Hash) ? name.keys.first : name
+              mod.define_method(actual_name) do
+                @preloaded[actual_name] ||= fetch_association(actual_name)
+              end
+            end
+          end
+          mod
+        end
+      end
+
+      # This module now ONLY contains the lazy-loading helper methods.
+      # The conflicting `initialize` method has been removed.
+      module LazyLoadingMethods
+        private
+        def fetch_association(assoc_name)
+          model_config = Dami.find_model(@model_name)
+          type, config = find_association_config(model_config, assoc_name)
+          return fetch_has_many_through(config) if config[:through]
+
+          case type
+          when :belongs_to
+            return fetch_polymorphic_belongs_to(config) if config[:polymorphic]
+            fk = config[:foreign_key] || "#{assoc_name}_id".to_sym
+            return nil unless (id = @record[fk])
+            model_name = config[:model] || Dami::Inflector.pluralize(assoc_name.to_s).to_sym
+            ::Dami.db(model_name).find(id)
+          when :has_many
+            _fk, model_name = association_keys(assoc_name, config)
+            query = ::Dami.db(model_name).where(association_keys(assoc_name, config)[0] => @record[:id])
+            query = query.where("#{config[:as]}_type".to_sym => Dami::Inflector.singularize(@model_name.to_s).capitalize) if config[:as]
+            query
+          when :has_one
+            _fk, model_name = association_keys(assoc_name, config)
+            query = ::Dami.db(model_name).where(association_keys(assoc_name, config)[0] => @record[:id])
+            query = query.where("#{config[:as]}_type".to_sym => Dami::Inflector.singularize(@model_name.to_s).capitalize) if config[:as]
+            query.first
+          end
+        end
+
+        def fetch_polymorphic_belongs_to(config)
+          type = @record["#{config[:name]}_type".to_sym]
+          id = @record["#{config[:name]}_id".to_sym]
+          return nil unless type && id
+          model_name = Dami::Inflector.pluralize(type.downcase).to_sym
+          ::Dami.db(model_name).find(id)
+        end
+
+        def fetch_has_many_through(config)
+          through_rel = public_send(config[:through])
+          through_records = case through_rel
+                            when Dami::Query::Builder then through_rel.to_a
+                            when Dami::RecordProxy then [through_rel]
+                            else []
+                            end
+          target_model_name = config[:model] || Dami::Inflector.pluralize(config[:name].to_s).to_sym
+          return ::Dami.db(target_model_name).where(id: []) if through_records.empty?
+          target_fk = "#{Dami::Inflector.singularize(config[:name].to_s)}_id".to_sym
+          target_ids = through_records.map { |r| r[target_fk] }.compact.uniq
+          ::Dami.db(target_model_name).where(id: target_ids)
+        end
+
+        def find_association_config(model_config, assoc_name)
+          (model_config[:relationships] || {}).each do |type, rels|
+            rels.each do |key, opts|
+              actual_name = key.is_a?(Hash) ? key.keys.first : key
+              if actual_name == assoc_name
+                full_opts = opts.is_a?(Hash) ? opts : {}
+                full_opts = key.values.first.merge(full_opts) if key.is_a?(Hash)
+                return [type, full_opts.merge(name: assoc_name)]
+              end
+            end
+          end
+          raise "Association :#{assoc_name} not found on #{@model_name}"
+        end
+
+        def association_keys(name, config)
+          owner_singular = Dami::Inflector.singularize(@model_name.to_s)
+          fk = config[:foreign_key] || (config[:as] ? "#{config[:as]}_id".to_sym : "#{owner_singular}_id".to_sym)
+          model_name = config[:model] || Dami::Inflector.pluralize(name.to_s).to_sym
+          [fk, model_name]
+        end
+      end
+
+      # Contains the preloading logic that gets included into the database adapter.
+      module AdapterMethods
+        def preload_associations(proxies, relations)
+          return proxies if proxies.empty?
+          model_name = proxies.first.instance_variable_get(:@model_name)
+          model_config = Dami.find_model(model_name)
+          relations.each do |rel_name|
+            type, config = find_association_config_for_adapter(model_config, rel_name)
+            records = proxies.map(&:to_h)
+            preloaded_map = if config[:through]
+              preload_has_many_through(records, model_name, config)
+            else
+              case type
+              when :belongs_to
+                config[:polymorphic] ? preload_polymorphic_belongs_to(records, config) : preload_belongs_to(records, config)
+              when :has_many
+                preload_has_many(records, model_name, config)
+              when :has_one
+                preload_has_one(records, model_name, config)
+              end
+            end
+            proxies.each do |proxy|
+              preloaded_data = if config[:polymorphic] && type == :belongs_to
+                type_val = proxy["#{config[:name]}_type".to_sym]
+                id_val = proxy["#{config[:name]}_id".to_sym]
+                preloaded_map[[type_val, id_val]]
+              else
+                preloaded_map[proxy[:id]]
+              end
+              dynamic_config = if config[:polymorphic] && type == :belongs_to
+                type_val = proxy["#{config[:name]}_type".to_sym]
+                config.merge(model: Dami::Inflector.pluralize(type_val.downcase).to_sym) if type_val
+              else
+                config
+              end
+              proxy.instance_variable_set(:@preloaded, proxy.instance_variable_get(:@preloaded).merge(rel_name => wrap_preloaded_data_for_adapter(rel_name, preloaded_data, dynamic_config)))
+            end
+          end
+          proxies
+        end
+
+        private
+
+        def wrap_preloaded_data_for_adapter(assoc_name, data, config)
+          return data.is_a?(Array) ? [] : nil if data.nil? || config.nil?
+          model_name = config[:model] || Dami::Inflector.pluralize(assoc_name.to_s).to_sym
+          if data.is_a?(Array)
+            data.map { |r| ::Dami::RecordProxy.new(model_name, r) }
+          else
+            ::Dami::RecordProxy.new(model_name, data)
+          end
+        end
+
+        def find_association_config_for_adapter(model_config, assoc_name)
+           (model_config[:relationships] || {}).each do |type, rels|
+             rels.each do |key, opts|
+               actual_name = key.is_a?(Hash) ? key.keys.first : key
+               if actual_name == assoc_name
+                 full_opts = opts.is_a?(Hash) ? opts : {}
+                 full_opts = key.values.first.merge(full_opts) if key.is_a?(Hash)
+                 return [type, full_opts.merge(name: assoc_name)]
+               end
+             end
+           end
+           raise "Association :#{assoc_name} not found on #{model_config[:name]}"
+        end
+
+        def preload_belongs_to(records, config)
+          fk = config[:foreign_key] || "#{config[:name]}_id".to_sym
+          model_name = config[:model] || Dami::Inflector.pluralize(config[:name].to_s).to_sym
+          fk_ids = records.map { |r| r[fk] }.compact.uniq
+          return {} if fk_ids.empty?
+          related_records = ::Dami.db(model_name).where(id: fk_ids).to_a.map(&:to_h)
+          related_map = related_records.each_with_object({}) { |r, h| h[r[:id]] = r }
+          records.each_with_object({}) { |r, h| h[r[:id]] = related_map[r[fk]] }
+        end
+
+        def preload_polymorphic_belongs_to(records, config)
+          name = config[:name]
+          records_by_type = records.group_by { |r| r["#{name}_type".to_sym] }
+          preloaded_map = {}
+          records_by_type.each do |type, recs|
+            next unless type
+            model_name = Dami::Inflector.pluralize(type.downcase).to_sym
+            ids = recs.map { |r| r["#{name}_id".to_sym] }.compact.uniq
+            next if ids.empty?
+            related_records = ::Dami.db(model_name).where(id: ids).to_a.map(&:to_h)
+            related_map = related_records.each_with_object({}) { |r, h| h[r[:id]] = r }
+            recs.each do |r|
+              preloaded_map[[type, r["#{name}_id".to_sym]]] = related_map[r["#{name}_id".to_sym]]
+            end
+          end
+          preloaded_map
+        end
+
+        def preload_has_many(records, owner_model, config)
+          owner_ids = records.map { |r| r[:id] }.uniq
+          return {} if owner_ids.empty?
+          owner_singular = Dami::Inflector.singularize(owner_model.to_s)
+          fk = config[:foreign_key] || (config[:as] ? "#{config[:as]}_id".to_sym : "#{owner_singular}_id".to_sym)
+          model_name = config[:model] || Dami::Inflector.pluralize(config[:name].to_s).to_sym
+          query = ::Dami.db(model_name).where(fk => owner_ids)
+          if config[:as]
+            type_key = "#{config[:as]}_type".to_sym
+            type_value = Dami::Inflector.singularize(owner_model.to_s).capitalize
+            query = query.where(type_key => type_value)
+          end
+          related_records = query.to_a.map(&:to_h)
+          grouped = related_records.group_by { |r| r[fk] }
+          records.each_with_object({}) { |r, h| h[r[:id]] = grouped[r[:id]] || [] }
+        end
+
+        def preload_has_one(records, owner_model, config)
+          preloaded = preload_has_many(records, owner_model, config)
+          preloaded.transform_values(&:first)
+        end
+
+        def preload_has_many_through(records, owner_model, config)
+          owner_ids = records.map { |r| r[:id] }.uniq
+          return {} if owner_ids.empty?
+          through_config = find_association_config_for_adapter(Dami.find_model(owner_model), config[:through])[1]
+          through_model_name = through_config[:model] || Dami::Inflector.pluralize(config[:through].to_s).to_sym
+          owner_singular = Dami::Inflector.singularize(owner_model.to_s)
+          through_fk_on_join = through_config[:foreign_key] || "#{owner_singular}_id".to_sym
+          join_records = ::Dami.db(through_model_name).where(through_fk_on_join => owner_ids).to_a.map(&:to_h)
+          return {} if join_records.empty?
+          target_model_name = config[:model] || Dami::Inflector.pluralize(config[:name].to_s).to_sym
+          target_fk_on_join = "#{Dami::Inflector.singularize(target_model_name.to_s)}_id".to_sym
+          target_ids = join_records.map { |r| r[target_fk_on_join] }.compact.uniq
+          return {} if target_ids.empty?
+          target_records = ::Dami.db(target_model_name).where(id: target_ids).to_a.map(&:to_h)
+          targets_by_id = target_records.each_with_object({}) { |r, h| h[r[:id]] = r }
+          join_records_by_owner_id = join_records.group_by { |r| r[through_fk_on_join] }
+          owner_ids.each_with_object({}) do |id, h|
+            joins = join_records_by_owner_id[id] || []
+            h[id] = joins.map { |j| targets_by_id[j[target_fk_on_join]] }.compact
+          end
+        end
+      end
+
+      # This is the single entry point for the plugin, orchestrating all enhancements.
+      def self.apply(dami_module)
+        dami_module.extend(ClassMethods)
+        dami_module::RecordProxy.include(LazyLoadingMethods)
+        
+        # --- THE ONE AND ONLY INITIALIZE WRAPPER ---
+        dami_module::RecordProxy.prepend(Module.new do
+          def initialize(*args)
+            # 1. Run the original, clean Dami::RecordProxy#initialize
+            super(*args)
+
+            # 2. Apply the PRESENTER module first. This gives its methods
+            #    (like a custom `def status`) the highest priority.
+            presenter_module = Dami.find_presenter_module(@model_name)
+            extend(presenter_module) if presenter_module
+
+            # 3. Apply the ASSOCIATION methods next.
+            extend Dami.association_module_for(@model_name)
+
+            # 4. Finally, define FALLBACK accessors for any schema fields
+            #    that don't already have a method from the presenter or associations.
+            _define_fallback_accessors!
+          end
+        end)
+        
+        dami_module::Adapters::Base.include(AdapterMethods)
+      end
+    end
+  end
+end

data/lib/dami/plugins/nested_attributes.rb

@@ -0,0 +1,180 @@
+# File: ./lib/dami/plugins/nested_attributes.rb
+module Dami
+  module Plugins
+    module NestedAttributes
+      class Processor
+        def initialize(parent_model_name, parent_record, attributes, persistence_options)
+          @parent_model_name = parent_model_name
+          @parent_record = parent_record
+          @attributes = attributes
+          @persistence_options = persistence_options
+          @parent_model_config = Dami.find_model(parent_model_name)
+          @errors = {}
+          @to_create = Hash.new { |h, k| h[k] = [] }
+          @to_update = Hash.new { |h, k| h[k] = {} }
+          @to_delete = Hash.new { |h, k| h[k] = [] }
+        end
+
+def validate
+  process_nested_attributes(:validate)
+  @errors
+end
+
+        def process
+          process_nested_attributes(:save)
+          execute_operations
+        end
+
+        private
+
+        def process_nested_attributes(mode)
+          nested_configs = @parent_model_config[:nests] || {}
+          
+          nested_configs.keys.each do |attr_key|
+            next unless @attributes.key?(attr_key)
+            
+            config = nested_configs[attr_key]
+            records_data = @attributes[attr_key]
+            process_nested_records(attr_key, config, records_data, mode)
+          end
+        end
+
+def process_nested_records(attr_key, config, records_data, mode)
+  assoc_name = config[:association_name]
+  child_rel = @parent_model_config.dig(:relationships, :has_many, assoc_name)
+  raise "Undefined has_many association '#{assoc_name}' for nested attributes" unless child_rel
+  
+  child_model_name = child_rel[:model] || assoc_name
+  foreign_key = child_rel[:foreign_key] || "#{Dami::Inflector.singularize(@parent_model_name.to_s)}_id".to_sym
+  
+  # Preserve the original keys when processing hashes
+  if records_data.is_a?(Hash)
+    records_data.each do |original_key, child_attrs|
+      # Use the original string key for error indexing
+      process_single_record(attr_key, original_key, child_model_name, foreign_key, config, child_attrs, mode)
+    end
+  else
+    records_array = Array(records_data)
+    records_array.each_with_index do |child_attrs, index|
+      process_single_record(attr_key, index.to_s, child_model_name, foreign_key, config, child_attrs, mode)
+    end
+  end
+end
+
+def process_single_record(attr_key, index_key, child_model_name, foreign_key, config, child_attrs, mode)
+          child_attrs = child_attrs.transform_keys(&:to_sym)
+          
+          # FIX 1: Ensure ID is always an integer if present for reliable lookups.
+          id = child_attrs[:id]&.to_i
+          destroy = ['true', '1', true].include?(child_attrs[:_destroy])
+
+          # FIX 2 (Security): On update/destroy, verify the child record belongs to the parent.
+          if id && mode == :save
+            existing_record = Dami.db(child_model_name).find(id)
+            # If the record doesn't exist OR its foreign key doesn't match the parent, ignore it.
+            return unless existing_record && existing_record[foreign_key] == @parent_record[:id]
+          end
+
+          grandchild_attrs = extract_grandchild_attributes(child_model_name, child_attrs)
+          
+          if mode == :validate || !destroy
+            validate_record(child_model_name, child_attrs, grandchild_attrs, attr_key, index_key, id)
+          end
+
+          if mode == :save
+            if destroy && config[:allow_destroy] && id
+              @to_delete[child_model_name] << id
+            elsif !destroy
+              if id
+                @to_update[child_model_name][id] = { attrs: child_attrs, grandchildren: grandchild_attrs }
+              else
+                child_attrs[foreign_key] = @parent_record[:id]
+                @to_create[child_model_name] << { attrs: child_attrs, grandchildren: grandchild_attrs }
+              end
+            end
+          end
+        end
+
+def validate_record(child_model_name, child_attrs, grandchild_attrs, attr_key, index_key, id)
+  child_errors = {}
+  
+  begin
+  
+    Dami.validate!(child_model_name, child_attrs, on: id ? :update : :create)
+  rescue Dami::ValidationError => e
+  
+    child_errors.merge!(e.errors)
+  end
+
+  # Validate grandchildren recursively
+  if grandchild_attrs.any?
+  
+    grandchild_processor = self.class.new(child_model_name, nil, grandchild_attrs, @persistence_options)
+    grandchild_errors = grandchild_processor.validate
+  
+    child_errors.merge!(grandchild_errors) unless grandchild_errors.empty?
+  end
+
+  add_error(attr_key, index_key, child_errors) unless child_errors.empty?
+  
+end
+
+        def extract_grandchild_attributes(model_name, attributes)
+          nested_keys = (Dami.find_model(model_name)[:nests] || {}).keys
+          nested_keys.each_with_object({}) do |key, hash|
+            hash[key] = attributes.delete(key) if attributes.key?(key)
+          end
+        end
+
+        def add_error(attr_key, index, error_hash)
+          (@errors[attr_key] ||= {})[index] = error_hash
+        end
+
+def execute_operations
+  # We need to execute in this order: deletes, then updates, then creates
+  execute_deletes
+  execute_updates  
+  execute_creates
+end
+
+
+def execute_deletes
+  @to_delete.each do |model, ids|
+    ids.each do |id|
+      before = Dami.db(model).find(id)
+      result = Dami.db(model).where(id: id).delete
+      after = Dami.db(model).find(id)
+    end
+  end
+end
+
+        def execute_updates
+          @to_update.each do |model, updates|
+            updates.each do |id, data|
+              Dami.db(model).where(id: id).update(data[:attrs], **@persistence_options)
+              if data[:grandchildren].any?
+                child_record = Dami.db(model).find(id)
+                processor = self.class.new(model, child_record, data[:grandchildren], @persistence_options)
+                processor.process
+              end
+            end
+          end
+        end
+
+def execute_creates
+  @to_create.each do |model, records|
+    records.each do |data|
+      created_child = Dami.db(model).create(data[:attrs], **@persistence_options)
+      if data[:grandchildren].any?
+        processor = self.class.new(model, created_child, data[:grandchildren], @persistence_options)
+        processor.process
+      else
+        #
+      end
+    end
+  end
+end
+      end
+    end
+  end
+end

data/lib/dami/plugins/protection.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module Dami
+  module Plugins
+    module Protection
+      module DamiClassMethods
+        def filter_input!(model_name, attrs, permit: [], protect: true)
+          model_config = find_model(model_name)
+          virtual_fields = (model_config[:virtual_fields] || {}).keys
+          nested_attr_keys = (model_config[:nests] || {}).keys
+          known_fields = (model_config[:fields] || {}).keys + virtual_fields + nested_attr_keys + [:id]
+          unknown = attrs.keys - known_fields
+          raise UnknownFieldsError.new("Unknown fields: #{unknown.join(', ')}", unknown) unless unknown.empty?
+          if protect
+            protections = model_config.dig(:protection, :protect) || []
+            permitted_by_model = model_config.dig(:protection, :permit) || []
+            permitted = permit + permitted_by_model
+            violations = attrs.keys.select do |key|
+              protections.include?(key) && !permitted.include?(key)
+            end
+            raise ProtectionError.new("Protected fields not permitted: #{violations.join(', ')}", violations) unless violations.empty?
+          end
+          attrs.reject { |k, _| virtual_fields.include?(k) }
+        end
+      end
+      def self.apply(dami_module)
+        dami_module.extend(DamiClassMethods)
+      end
+    end
+  end
+end

data/lib/dami/plugins/validations.rb

@@ -0,0 +1,90 @@
+# File: lib/dami/plugins/validation.rb
+module Dami
+  module Plugins
+    module Validations
+      class Registry
+        def initialize
+          @rules = {}
+        end
+        def register(name, rule_def)
+          @rules[name.to_sym] = rule_def
+        end
+        def get(name)
+          @rules[name.to_sym] || raise("Unknown validation rule: #{name}")
+        end
+# File: lib/dami/plugins/validation.rb - line 16
+def validate(value, rule_name, params = [], context = {})
+          rule = get(rule_name)
+          rule_config = rule.is_a?(Proc) ? rule.call(*params) : rule
+          check = rule_config[:check]
+          
+          # --- THE FIX: Use the new Dami.translate system ---
+          # 1. Use an inline message if provided directly in the rule definition.
+          message = rule_config[:message]
+          # 2. Otherwise, fetch it from the new localization system.
+          message ||= Dami.translate("validations.#{rule_name}", *params)
+          # 3. Use a generic fallback if no translation is found.
+          message ||= "is invalid"
+          
+          return message unless check
+          
+          result = check.arity == 1 ? check.call(value) : check.call(value, context)
+          result ? nil : message
+        end
+      end
+      module DamiClassMethods
+        def validation_registry
+          @validation_registry ||= Registry.new
+        end
+        def rules(namespace = :default, rules_hash)
+          rules_hash.each do |name, rule_def|
+            validation_registry.register(name, rule_def)
+          end
+        end
+        def validate!(model_name, attrs, on: :create)
+          model_config = find_model(model_name)
+          errors = {}
+          (model_config.dig(:validations) || {}).each do |field, rule_definitions|
+            next unless on == :create || attrs.key?(field)
+            Array(rule_definitions).each do |rule_def|
+              rule_options = rule_def.is_a?(Hash) ? rule_def : { rule: rule_def }
+              next if should_skip_validation?(rule_options, attrs, on)
+              error_msg = validate_rule(attrs[field], rule_options[:rule], attrs)
+              (errors[field] ||= []) << error_msg if error_msg
+            end
+          end
+          raise ValidationError.new("Validation failed", errors) unless errors.empty?
+        end
+        private
+        def should_skip_validation?(rule_def, attrs, on)
+          return true if rule_def[:on] && !Array(rule_def[:on]).include?(on)
+          if (if_cond = rule_def[:if])
+            return true unless if_cond.is_a?(Proc) && if_cond.call(attrs)
+          end
+          if (unless_cond = rule_def[:unless])
+            if unless_cond.is_a?(Proc)
+              return true if unless_cond.call(attrs)
+            else
+              return true if unless_cond.all? { |k, v| attrs[k] == v }
+            end
+          end
+          if (when_cond = rule_def[:when])
+            return true unless when_cond.all? { |k, v| attrs[k] == v }
+          end
+          false
+        end
+        def validate_rule(value, rule, context)
+          case rule
+          when Symbol
+            validation_registry.validate(value, rule, [], context)
+          when Array
+            validation_registry.validate(value, rule.first, rule[1..-1], context)
+          end
+        end
+      end
+      def self.apply(dami_module)
+        dami_module.extend(DamiClassMethods)
+      end
+    end
+  end
+end