dami 1.0.0

data/lib/dami/query/builder.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+require_relative 'enumerable'
+require_relative 'persistence'
+
+module Dami
+  module Query
+    class Builder
+      include ::Enumerable
+      include Dami::Query::Enumerable
+      include Dami::Query::Persistence
+
+      def initialize(model_name, db_name: :default, conditions: [], order_by: nil, limit: nil, offset: nil, preload: [], select_columns: nil, joins: [])
+        @model_name = model_name
+        @db_name = db_name
+        @conditions = conditions
+        @order_by = order_by
+        @limit = limit
+        @offset = offset
+        @preload = preload
+        @select_columns = select_columns
+        @joins = joins
+      end
+
+def where(*args, &block)
+      if block
+        sub_query = self.class.new(@model_name)
+        block.call(sub_query)
+        clone_with(conditions: @conditions + [[:and, sub_query.instance_variable_get(:@conditions)]])
+      else
+        # If multiple arguments are passed (e.g., from a raw SQL scope),
+        # keep them as an array. Otherwise, it's a hash.
+        conds = args.length > 1 ? args : args.first
+        clone_with(conditions: @conditions + [[:and, conds]])
+      end
+    end
+
+      def or(conds = nil, &block)
+        if block
+          sub_query = self.class.new(@model_name, db_name: @db_name)
+          block.call(sub_query)
+          clone_with(conditions: @conditions + [[:or, sub_query.instance_variable_get(:@conditions)]])
+        else
+          clone_with(conditions: @conditions + [[:or, conds]])
+        end
+      end
+      
+      def join(table, conditions)
+        join_clause = { type: :inner, table: table, conditions: conditions }
+        clone_with(joins: @joins + [join_clause])
+      end
+
+      def left_join(table, conditions)
+        join_clause = { type: :left, table: table, conditions: conditions }
+        clone_with(joins: @joins + [join_clause])
+      end
+
+      def select(*columns)
+        clone_with(select_columns: columns)
+      end
+      
+      def order(field)
+        clone_with(order_by: field)
+      end
+      
+      def limit(count)
+        clone_with(limit: count.to_i)
+      end
+      
+      def offset(count)
+        clone_with(offset: count.to_i)
+      end
+      
+      def preload(*relations)
+        clone_with(preload: @preload + relations)
+      end
+
+      private
+      
+      def reverse_order_query
+        return order(id: :desc) unless @order_by
+
+        reversed_order = case @order_by
+        when Hash
+          @order_by.transform_values { |dir| dir == :asc ? :desc : :asc }
+        when String, Symbol
+          parts = @order_by.to_s.split(',').map do |part|
+            field, dir = part.strip.split(/\s+/)
+            new_dir = (dir&.upcase == 'DESC') ? 'ASC' : 'DESC'
+            "#{field} #{new_dir}"
+          end
+          parts.join(', ')
+        else
+          { id: :desc }
+        end
+
+        clone_with(order_by: reversed_order)
+      end
+
+      def adapter
+        Dami.database(@db_name)
+      end
+      
+      def clone_with(**new_opts)
+        self.class.new(
+          @model_name, 
+          db_name: @db_name, 
+          conditions: @conditions, 
+          order_by: @order_by, 
+          limit: @limit, 
+          offset: @offset, 
+          preload: @preload,
+          select_columns: @select_columns,
+          joins: @joins,
+          **new_opts
+        )
+      end
+      
+      def build_query_structure
+        { 
+          model_name: @model_name, 
+          conditions: @conditions, 
+          order_by: @order_by, 
+          limit: @limit, 
+          offset: @offset,
+          select_columns: @select_columns,
+          joins: @joins,
+          preload: @preload
+        }
+      end
+    end
+  end
+end

data/lib/dami/query/enumerable.rb

@@ -0,0 +1,62 @@
+module Dami
+  module Query
+    module Enumerable
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      def to_a
+        query_structure = build_query_structure
+        records = adapter.query_records(query_structure)
+        proxies = records.map { |r| Dami.wrap_record(@model_name, r) }
+        @preload.empty? ? proxies : adapter.preload_associations(proxies, @preload)
+      end
+      alias_method :all, :to_a
+
+      def find(id)
+        record = adapter.find_record(@model_name, id)
+        Dami.wrap_record(@model_name, record)
+      end
+      def find_each(batch_size: 1000, &block)
+        find_in_batches(batch_size: batch_size) do |batch|
+          batch.each(&block)
+        end
+      end
+      
+      def find_in_batches(batch_size: 1000)
+        query = @order_by ? self : order(:id)
+        offset = 0
+        loop do
+          records = query.limit(batch_size).offset(offset).to_a
+          break if records.empty?
+          yield records
+          break if records.length < batch_size
+          offset += records.length
+        end
+      end
+
+      def first
+        limit(1).to_a.first
+      end
+
+      def last
+        reverse_order_query.first
+      end
+
+      def any?
+        adapter.query_exists?(build_query_structure)
+      end
+
+      def exists?(conds = nil)
+        conds ? where(conds).any? : any?
+      end
+
+      # This is the updated method
+      def count
+        adapter.count_records(build_query_structure)
+      end
+      alias_method :length, :count
+      alias_method :size, :count
+    end
+  end
+end

data/lib/dami/query/persistence.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+module Dami
+  module Query
+    module Persistence
+      def create(attrs = {}, **options, &block)
+        attributes = attrs.merge(options)
+        if block_given?
+          draft = ::Dami::Draft.new(original: nil, data: attributes)
+          yield(draft)
+          raise ::Dami::ValidationError.new("Validation failed", draft.errors) unless draft.valid?
+          attributes = draft.data
+        end
+        prepared = _prepare_persistence(attributes, :create)
+        return nil if prepared[:db_parent_attrs].empty? && prepared[:nested_attributes].empty?
+        parent_proxy = nil
+        adapter.transaction do
+          parent_record_hash = adapter.insert_record(@model_name, prepared[:db_parent_attrs])
+          parent_proxy = ::Dami::RecordProxy.new(@model_name, parent_record_hash)
+          if prepared[:nested_attributes].any?
+            processor = ::Dami::Plugins::NestedAttributes::Processor.new(@model_name, parent_proxy, prepared[:nested_attributes], prepared[:persistence_opts])
+            processor.process
+          end
+        end
+        parent_proxy ? find(parent_proxy[:id]) : nil
+      end
+      def update(attrs = {}, **options, &block)
+        original_record = self.first
+        return nil unless original_record
+        attributes = attrs.merge(options)
+        if block_given?
+          draft = ::Dami::Draft.new(original: original_record.to_h, data: attributes)
+          yield(draft)
+          return nil unless draft.valid?
+          attributes = draft.data
+        end
+        return original_record if attributes.empty?
+        prepared = _prepare_persistence(attributes, :update, original_record)
+        adapter.transaction do
+          adapter.update_records(build_query_structure, prepared[:db_parent_attrs]) if prepared[:db_parent_attrs].any?
+          if prepared[:nested_attributes].any?
+            processor = ::Dami::Plugins::NestedAttributes::Processor.new(@model_name, original_record, prepared[:nested_attributes], prepared[:persistence_opts])
+            processor.process
+          end
+        end
+        find(original_record[:id])
+      end
+# File: lib/dami/query/persistence.rb
+
+def create_many(records, permit: [], protect: true)
+  raise ArgumentError, "create_many requires an array of hashes" unless records.is_a?(Array)
+  return [] if records.empty?
+  
+  # Phase 1: Validate and prepare ALL records first
+  prepared_records = []
+  all_errors = {}
+  
+  records.each_with_index do |attrs, index|
+    begin
+      attributes = attrs.merge(permit: permit, protect: protect)
+      prepared = _prepare_persistence(attributes, :create)
+      
+      if prepared[:nested_attributes].any?
+        raise ArgumentError, "create_many does not support nested attributes. Use create() for complex records."
+      end
+      
+      if prepared[:db_parent_attrs].empty?
+        raise ArgumentError, "Record #{index} has no valid attributes after filtering"
+      end
+      
+      prepared_records << prepared[:db_parent_attrs]
+    rescue Dami::ValidationError => e
+      # FIX: Just store the error object, not try to set errors
+      all_errors[index] = e.errors
+    rescue Dami::ProtectionError, Dami::UnknownFieldsError => e
+      raise e
+    end
+  end
+  
+  # If ANY validations failed, raise with collected errors
+  unless all_errors.empty?
+    # FIX: Create a custom message and pass errors in the initializer
+    message = "Validation failed for #{all_errors.size} record(s): " + 
+              all_errors.map { |idx, errs| "Record #{idx}: #{errs}" }.join("; ")
+    raise Dami::ValidationError.new(message, all_errors)
+  end
+  
+  # Phase 2: Bulk insert in transaction
+  result_ids = adapter.transaction do
+    adapter.insert_many(@model_name, prepared_records)
+  end
+  
+  # Phase 3: Return wrapped records
+  result_ids.map.with_index do |id, index|
+    record_hash = prepared_records[index].merge(id: id)
+    ::Dami::RecordProxy.new(@model_name, record_hash)
+  end
+end
+      def delete
+        adapter.delete_records(build_query_structure)
+      end
+      private
+
+def _prepare_persistence(attributes, operation, parent_record = nil)
+  persistence_opts = {
+    permit: attributes.delete(:permit) || [],
+    protect: attributes.key?(:protect) ? attributes.delete(:protect) : true
+  }
+  model_config = Dami.find_model(@model_name)
+  parent_attributes = attributes.dup
+  nested_attributes = (model_config[:nests] || {}).keys.each_with_object({}) do |key, hash|
+    hash[key] = parent_attributes.delete(key) if parent_attributes.key?(key)
+  end
+  all_errors = {}
+  if nested_attributes.any?
+    processor = ::Dami::Plugins::NestedAttributes::Processor.new(@model_name, parent_record, nested_attributes, persistence_opts)
+    nested_errors = processor.validate
+    nested_errors.each do |nested_attr_key, nested_error_value|
+      all_errors[nested_attr_key] = nested_error_value
+    end
+  end
+  begin
+    Dami.validate!(@model_name, parent_attributes, on: operation)
+  rescue Dami::ValidationError => e
+    all_errors.merge!(e.errors)
+  end
+  raise Dami::ValidationError.new("Validation failed", all_errors) unless all_errors.empty?
+  filtered_parent_attrs = Dami.filter_input!(@model_name, parent_attributes, **persistence_opts)
+  db_parent_attrs = filtered_parent_attrs.reject { |k, _| (model_config[:virtual_fields] || {}).key?(k) }
+  { db_parent_attrs: db_parent_attrs, nested_attributes: nested_attributes, persistence_opts: persistence_opts }
+end
+    end
+  end
+end

data/lib/dami/record_proxy.rb

@@ -0,0 +1,32 @@
+# File: lib/dami/record_proxy.rb
+
+# frozen_string_literal: true
+module Dami
+  class RecordProxy
+    def initialize(model_name, record, preloaded = {})
+      @model_name = model_name
+      @record = record
+      @preloaded = preloaded
+    end
+
+    def [](key)
+      @record[key]
+    end
+
+    def to_h
+      @record
+    end
+
+    # This helper is called by the associations plugin's initialize wrapper.
+    def _define_fallback_accessors!
+      return unless @record.is_a?(Hash)
+      @record.each_key do |key|
+        unless respond_to?(key)
+          define_singleton_method(key) do
+            @record[key]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dami/result.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Dami
+  class Success
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+    def success?
+      true
+    end
+    def failure?
+      false
+    end
+  end
+  class Failure
+    attr_reader :error
+    def initialize(error)
+      @error = error
+    end
+    def success?
+      false
+    end
+    def failure?
+      true
+    end
+  end
+end

data/lib/dami/schema/diff.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Dami
+  module Schema
+    class Diff
+      def initialize(old_schema, new_schema)
+        @old_schema = old_schema
+        @new_schema = new_schema
+        @up_commands = []
+        @down_commands = []
+      end
+
+      # The main public method that computes the differences.
+      def diff
+        find_added_tables
+        find_removed_tables
+        find_changed_tables
+
+        { up: @up_commands, down: @down_commands }
+      end
+
+      private
+
+      def find_added_tables
+        (@new_schema.keys - @old_schema.keys).each do |table_name|
+          @up_commands << { command: :create_table, name: table_name, columns: @new_schema[table_name][:columns] }
+          @down_commands.unshift({ command: :drop_table, name: table_name })
+          # Also add any indexes for the new table
+          (@new_schema[table_name][:indexes] || {}).each do |column_name, _|
+            @up_commands << { command: :add_index, table: table_name, column: column_name }
+          end
+        end
+      end
+
+      def find_removed_tables
+        (@old_schema.keys - @new_schema.keys).each do |table_name|
+          @up_commands << { command: :drop_table, name: table_name }
+          @down_commands.unshift({ command: :create_table, name: table_name, columns: @old_schema[table_name][:columns] })
+          # Restore indexes for the dropped table on rollback
+          (@old_schema[table_name][:indexes] || {}).each do |column_name, _|
+            @down_commands.unshift({ command: :add_index, table: table_name, column: column_name })
+          end
+        end
+      end
+      
+      def find_changed_tables
+        (@old_schema.keys & @new_schema.keys).each do |table_name|
+          diff_columns(table_name)
+          diff_indexes(table_name)
+        end
+      end
+
+      def diff_columns(table_name)
+        old_cols = @old_schema[table_name][:columns]
+        new_cols = @new_schema[table_name][:columns]
+        
+        (new_cols.keys - old_cols.keys).each do |col_name|
+          @up_commands << { command: :add_column, table: table_name, name: col_name, type: new_cols[col_name][:type] }
+          @down_commands.unshift({ command: :remove_column, table: table_name, name: col_name })
+        end
+        
+        (old_cols.keys - new_cols.keys).each do |col_name|
+          @up_commands << { command: :remove_column, table: table_name, name: col_name }
+          @down_commands.unshift({ command: :add_column, table: table_name, name: col_name, type: old_cols[col_name][:type] })
+        end
+      end
+
+      def diff_indexes(table_name)
+        old_indexes = @old_schema[table_name][:indexes] || {}
+        new_indexes = @new_schema[table_name][:indexes] || {}
+
+        (new_indexes.keys - old_indexes.keys).each do |col_name|
+          @up_commands << { command: :add_index, table: table_name, column: col_name }
+          @down_commands.unshift({ command: :remove_index, table: table_name, column: col_name })
+        end
+
+        (old_indexes.keys - new_indexes.keys).each do |col_name|
+          @up_commands << { command: :remove_index, table: table_name, column: col_name }
+          @down_commands.unshift({ command: :add_index, table: table_name, column: col_name })
+        end
+      end
+    end
+  end
+end

data/lib/dami/schema/dumper.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Dami
+  module Schema
+    class Dumper
+      def initialize(adapter)
+        @adapter = adapter
+      end
+
+      # The main public method. It inspects the database and returns
+      # a string containing the full schema definition.
+      def dump
+        output = []
+        output << "Dami.define_schema do\n"
+
+        tables = @adapter.tables
+        tables.each do |table_name|
+          next if table_name == 'schema_migrations' # Skip the internal migrations table
+
+          output << dump_table(table_name)
+        end
+
+        tables.each do |table_name|
+          output << dump_indexes(table_name)
+        end
+
+        output << "end\n"
+        output.join("\n")
+      end
+
+      private
+
+      def dump_table(table_name)
+        columns = @adapter.columns(table_name)
+        return "" if columns.empty?
+
+        parts = []
+        parts << "  create_table \"#{table_name}\" do |t|"
+        columns.each do |column|
+          # We skip the 'id' column as it's created by default.
+          next if column[:name] == "id"
+          parts << "    t.field \"#{column[:name]}\", :#{column[:type]}"
+        end
+        parts << "  end"
+        parts.join("\n")
+      end
+
+      def dump_indexes(table_name)
+        indexes = @adapter.indexes(table_name)
+        return "" if indexes.empty?
+
+        parts = []
+        indexes.each do |index|
+          parts << "  add_index \"#{index[:table]}\", \"#{index[:column]}\""
+        end
+        parts.join("\n")
+      end
+    end
+  end
+end

data/lib/dami/schema/generator.rb

@@ -0,0 +1,69 @@
+# File: ./lib/dami/schema/generator.rb
+
+# frozen_string_literal: true
+
+module Dami
+  module Schema
+    class Generator
+      def generate(diff_result, name)
+        return if diff_result[:up].empty?
+
+        timestamp = Time.now.utc.strftime('%Y%m%d%H%M%S')
+        
+        # THE FIX: This converts "AddEmailToUsers" into "add_email_to_users"
+        snake_case_name = name.gsub(/::/, '/')
+                              .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+                              .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+                              .tr("-", "_")
+                              .downcase
+        
+        filename = "#{timestamp}_#{snake_case_name}.rb"
+        
+        migrations_dir = Dami.configuration.migrations_path
+        path = File.join(migrations_dir, filename)
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, generate_content(diff_result))
+        
+        path
+      end
+
+      private
+
+      def generate_content(diff_result)
+        up_content = diff_result[:up].map { |cmd| command_to_string(cmd) }.join("\n    ")
+        down_content = diff_result[:down].map { |cmd| command_to_string(cmd) }.join("\n    ")
+
+        <<~RUBY
+          # This file is auto-generated. You can edit it before running migrations.
+
+          def up
+            #{up_content}
+          end
+
+          def down
+            #{down_content}
+          end
+        RUBY
+      end
+
+      def command_to_string(cmd)
+        case cmd[:command]
+        when :create_table
+          cols = cmd[:columns].map { |name, opts| "t.field :#{name}, :#{opts[:type]}" }.join("\n      ")
+          "create_table(:#{cmd[:name]}) do |t|\n      #{cols}\n    end"
+        when :drop_table
+          "drop_table(:#{cmd[:name]})"
+        when :add_column
+          "add_column(:#{cmd[:table]}, :#{cmd[:name]}, :#{cmd[:type]})"
+        when :remove_column
+          "remove_column(:#{cmd[:table]}, :#{cmd[:name]})"
+        when :add_index
+          "add_index(:#{cmd[:table]}, :#{cmd[:column]})"
+        when :remove_index
+          "remove_index(:#{cmd[:table]}, :#{cmd[:column]})"
+        end
+      end
+    end
+  end
+end

data/lib/dami/schema/introspector.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Dami
+  module Schema
+    # Introspects live Dami.model definitions to build a canonical hash representation.
+    class Introspector
+      def introspect
+        schema = {}
+        Dami.instance_variable_get(:@models).each do |model_name, config|
+          table_name = model_name.to_s
+          schema[table_name] = { columns: {}, indexes: {} }
+
+          # 1. Parse all defined fields
+          (config[:fields] || {}).each do |field_name, field_config|
+            schema[table_name][:columns][field_name.to_s] = { type: field_config[:type] }
+          end
+
+          # 2. Introspect relationships to infer indexes
+          (config[:relationships] || {}).each do |type, relations|
+            next unless type == :belongs_to
+            relations.each_key do |rel_name|
+              # A `belongs_to :user` implies a `user_id` column and an index on it.
+              # We assume the column is already defined in `fields`.
+              # Here, we just add the desired index.
+              fk_name = "#{rel_name}_id"
+              schema[table_name][:indexes][fk_name] = {}
+            end
+          end
+        end
+        schema
+      end
+    end
+  end
+end

data/lib/dami/schema/loader.rb

@@ -0,0 +1,58 @@
+# File: ./lib/dami/schema/loader.rb
+
+# frozen_string_literal: true
+
+module Dami
+  module Schema
+    # Parses a db/schema.rb file into a canonical hash representation.
+    class Loader
+      attr_reader :schema
+
+      def initialize
+        @schema = {}
+      end
+
+      def load_from_path(path)
+        return unless File.exist?(path)
+        
+        # THE FIX: Capture `self` (the loader instance) into a variable.
+        loader_instance = self
+        
+        # Now, the monkey-patched method uses the captured variable, ensuring
+        # the block is always evaluated in the context of the correct loader instance.
+        Dami.define_singleton_method(:define_schema) { |&block| loader_instance.instance_eval(&block) }
+        
+        load(path)
+      ensure
+        # Always restore the original method to avoid side effects.
+        Dami.define_singleton_method(:define_schema) { |_| }
+      end
+
+      private
+
+      # --- DSL Methods available inside db/schema.rb ---
+
+      def create_table(name, &block)
+        @schema[name] ||= { columns: {}, indexes: {} }
+        proxy = TableProxy.new(@schema[name][:columns])
+        yield(proxy)
+      end
+
+      def add_index(table_name, column_name, **options)
+        @schema[table_name] ||= { columns: {}, indexes: {} }
+        @schema[table_name][:indexes][column_name] = options
+      end
+
+      # A simple proxy to handle the `t.field` calls inside `create_table`
+      class TableProxy
+        def initialize(columns_hash)
+          @columns = columns_hash
+        end
+
+        def field(name, type, **options)
+          @columns[name] = { type: type }.merge(options)
+        end
+      end
+    end
+  end
+end