dami 1.0.0

data/lib/dami/cli.rb

@@ -0,0 +1,117 @@
+# File: ./lib/dami/cli.rb
+
+# frozen_string_literal: true
+require 'thor'
+require 'fileutils'
+require_relative '../dami' # Load the main Dami library
+
+module Dami
+  # 1. Define the parent namespace first to prevent loading errors.
+  class CLI < Thor; end
+
+  # 2. Define a base class for our subcommands to share common helper methods.
+  class CLI::Base < Thor
+    private
+
+    # This helper loads the user's application environment. It looks for a
+    # standard initializer and then loads all model files from the configured path.
+    def load_user_app
+      initializer_path = File.expand_path("config/initializers/dami.rb", Dir.pwd)
+      require initializer_path if File.exist?(initializer_path)
+      
+      model_paths = Array(Dami.configuration.models_path)
+      model_paths.each do |path|
+        search_path = File.expand_path(path)
+        Dir.glob(File.join(search_path, '**', '*.rb')).each { |file| load file }
+      end
+    end
+  end
+
+  # 3. Define the subcommand classes.
+
+  # Handles all `dami db:*` subcommands.
+  class DB < CLI::Base
+    desc "migrate", "Run all pending database migrations"
+    def migrate
+      load_user_app
+      puts "Running migrations..."
+      
+      db = Dami.database(:default) # Assumes the app has already connected.
+      migrator = Dami::Migrator.new(db)
+      migrator.migrate
+      
+      puts "✅ Migrations complete. Schema has been updated in #{Dami.configuration.schema_path}."
+    end
+    
+    desc "rollback [STEPS]", "Revert the last migration (or the last STEPS migrations)"
+    def rollback(steps = 1)
+      load_user_app
+      db = Dami.database(:default)
+      Dami::Migrator.new(db).rollback(steps.to_i)
+      puts "✅ Rolled back #{steps} migration(s). Schema has been updated in #{Dami.configuration.schema_path}."
+    end
+
+    desc "schema_dump", "Generate a schema file from the current database state"
+    def schema_dump
+      load_user_app
+      puts "Dumping schema..."
+      
+      db = Dami.database(:default)
+      dumper = Dami::Schema::Dumper.new(db)
+      schema_content = dumper.dump
+
+      schema_path = Dami.configuration.schema_path
+      FileUtils.mkdir_p(File.dirname(schema_path))
+      File.write(schema_path, schema_content)
+      puts "✅ Schema dumped to #{schema_path}"
+    end
+  end
+
+  # Handles all `dami generate *` subcommands.
+  class Generate < CLI::Base
+    desc "migration NAME", "Generate a new migration by comparing models to the schema"
+    def migration(name)
+      load_user_app
+      
+      loader = Dami::Schema::Loader.new
+      loader.load_from_path(Dami.configuration.schema_path)
+      
+      introspector = Dami::Schema::Introspector.new
+      
+      differ = Dami::Schema::Diff.new(loader.schema, introspector.introspect)
+      diff_result = differ.diff
+
+      if diff_result[:up].empty?
+        puts "✅ Schema is up to date. No migration generated."
+      else
+        generator = Dami::Schema::Generator.new
+        path = generator.generate(diff_result, name)
+        puts "✅ New migration created: #{path}"
+      end
+    end
+  end
+
+  # 4. Finally, reopen the main CLI class to add the subcommands.
+  #    This works because `DB` and `Generate` are now fully defined.
+  class CLI < Thor
+    desc "db", "Manage database tasks (migrate, rollback, schema_dump)"
+    subcommand "db", DB
+
+    desc "generate", "Generate new files (e.g., migrations)"
+    subcommand "generate", Generate
+  end
+end
+
+# This modification to the Configuration class is still needed.
+# It ensures the CLI has a place to get database connection details from.
+class Dami::Configuration
+  attr_accessor :database_config
+
+  # We redefine initialize to add the new attribute with a default.
+  def initialize
+    @models_path = 'app/models'
+    @migrations_path = 'db/migrations'
+    @schema_path = 'db/schema.rb'
+    @database_config = {}
+  end
+end

data/lib/dami/configuration.rb

@@ -0,0 +1,246 @@
+module Dami
+  def self.model(name, &block)
+    config = ModelConfig.new(name)
+    config.instance_eval(&block)
+    (@models ||= {})[name] = config.to_h.merge(name: name).freeze
+  end
+  def self.behavior(model_name, &block)
+    model_config = find_model(model_name)
+    BehaviorProxy.new(model_config).instance_eval(&block)
+  end
+  def self.scopes(model_name, &block)
+    model_config = find_model(model_name)
+    ScopesProxy.new(model_config.fetch(:scopes, {})).instance_eval(&block)
+  end
+  class Configuration
+    attr_accessor :models_path, :migrations_path, :schema_path, :database_config
+    def initialize
+      @models_path = 'app/models'
+      @migrations_path = 'db/migrations'
+      @schema_path = 'db/schema.rb'
+      @database_config = {}
+    end
+  end
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+  def self.configure
+    yield(configuration)
+  end
+  class ModelConfig
+    def initialize(name)
+      @config = {
+        database: :default,
+        fields: {},
+        virtual_fields: {},
+        protection: {},
+        relationships: {},
+        validations: {},
+        scopes: {},
+        nests: {}
+      }
+    end
+    def database(name)
+      @config[:database] = name
+    end
+    def fields(&block)
+      FieldsProxy.new(@config[:fields]).instance_eval(&block)
+    end
+    def virtual(&block)
+      FieldsProxy.new(@config[:virtual_fields]).instance_eval(&block)
+    end
+    def relationships(&block)
+      RelationshipProxy.new(@config[:relationships]).instance_eval(&block)
+    end
+    def nests(*names, **options)
+      proxy = NestsProxy.new(@config[:nests])
+      names.each { |name| proxy.nest(name, **options) }
+    end
+    def validate(*args, &block)
+      raise Dami::InvalidDSLError.new('validate', 'behavior')
+    end
+    def protection(*args, &block)
+      raise Dami::InvalidDSLError.new('protection', 'behavior')
+    end
+    def scope(*args, &block)
+      raise Dami::InvalidDSLError.new('scope', 'scopes')
+    end
+    def to_h
+      @config
+    end
+  end
+  class FieldsProxy
+    def initialize(target)
+      @target = target
+    end
+    def field(name, type, **options)
+      @target[name] = { type: type, **options }
+    end
+  end
+  class RelationshipProxy
+    def initialize(target)
+      @target = target
+    end
+    def belongs_to(*names, **options)
+      (@target[:belongs_to] ||= {}).merge!(parse_relations(names, options))
+    end
+    def has_one(*names, **options)
+      (@target[:has_one] ||= {}).merge!(parse_relations(names, options))
+    end
+    def has_many(*names, **options)
+      (@target[:has_many] ||= {}).merge!(parse_relations(names, options))
+    end
+    private
+    def parse_relations(names, options)
+      relations = {}
+      options.each { |key, value| relations[key] = value if value.is_a?(Hash) }
+      non_rel_opts = options.reject { |_, v| v.is_a?(Hash) }
+      names.each { |name| relations[name] = non_rel_opts }
+      relations
+    end
+  end
+  class BehaviorProxy
+    def initialize(model_config)
+      @model_config = model_config
+      @model_config[:validations] ||= {}
+      @model_config[:protection] ||= {}
+      @model_config[:protection][:protect] ||= []
+      @model_config[:protection][:permit] ||= []
+    end
+    def validate(&block)
+      validator = ValidationBuilder.new(@model_config[:validations], model_config: @model_config)
+      validator.instance_eval(&block)
+    end
+    def protection(&block)
+      protector = ProtectionBuilder.new(@model_config[:protection])
+      protector.instance_eval(&block)
+    end
+    def on(operation, &block)
+      validator = ValidationBuilder.new(@model_config[:validations], context: operation, model_config: @model_config)
+      validator.instance_eval(&block)
+    end
+    def fields(*args, &block)
+      raise Dami::InvalidDSLError.new('fields', 'model')
+    end
+    def virtual(*args, &block)
+      raise Dami::InvalidDSLError.new('virtual', 'model')
+    end
+    def relationships(*args, &block)
+      raise Dami::InvalidDSLError.new('relationships', 'model')
+    end
+    def nests(*args, &block)
+      raise Dami::InvalidDSLError.new('nests', 'model')
+    end
+    def scope(*args, &block)
+      raise Dami::InvalidDSLError.new('scope', 'scopes')
+    end
+    class ValidationBuilder
+      def initialize(config, context: nil, model_config: nil)
+        @config = config
+        @context = context
+        @model_config = model_config
+      end
+      def rule(field, *rules, **options, &block)
+        field = field.to_sym
+        @config[field] ||= []
+        if_cond = options.delete(:if)
+        unless_cond = options.delete(:unless)
+        when_cond = options.delete(:when)
+        rules.concat(options.map { |k, v| v == true ? k : [k, v] })
+        rules.each do |rule_def|
+          rule_entry = { rule: rule_def, on: @context ? [@context] : [:create, :update] }
+          rule_entry[:if] = if_cond if if_cond
+          rule_entry[:unless] = unless_cond if unless_cond
+          rule_entry[:when] = when_cond if when_cond
+          @config[field] << rule_entry
+        end
+      end
+      def all(only: nil, except: nil, **kwargs, &block)
+        all_fields = []
+        if @model_config
+          all_fields.concat(@model_config[:fields].keys) if @model_config[:fields]
+          all_fields.concat(@model_config[:virtual_fields].keys) if @model_config[:virtual_fields]
+        end
+        fields_to_validate = if only
+          Array(only).map(&:to_sym) & all_fields
+        elsif except
+          all_fields - Array(except).map(&:to_sym)
+        else
+          all_fields
+        end
+        if kwargs.any?
+          fields_to_validate.each do |field|
+            rule(field, **kwargs)
+          end
+        end
+        if block_given?
+          temp_builder = TempRuleBuilder.new(@context)
+          temp_builder.instance_eval(&block)
+          fields_to_validate.each do |field|
+            temp_builder.rules.each do |rule_def|
+              rule(field, *rule_def[:args], **rule_def[:kwargs])
+            end
+          end
+        end
+      end
+      def on(operation, &block)
+        nested = ValidationBuilder.new(@config, context: operation, model_config: @model_config)
+        nested.instance_eval(&block)
+      end
+      class TempRuleBuilder
+        attr_reader :rules
+        def initialize(context)
+          @context = context
+          @rules = []
+        end
+        def rule(*args, **kwargs)
+          @rules << { args: args, kwargs: kwargs }
+        end
+      end
+    end
+    class ProtectionBuilder
+      def initialize(config)
+        @config = config
+        @config[:protect] ||= []
+        @config[:permit] ||= []
+      end
+      def protect(*fields)
+        @config[:protect].concat(fields.map(&:to_sym))
+        @config[:protect].uniq!
+      end
+      def permit(*fields)
+        @config[:permit].concat(fields.map(&:to_sym))
+        @config[:permit].uniq!
+      end
+    end
+  end
+  class ScopesProxy
+    def initialize(target)
+      @target = target
+    end
+    def scope(name, body)
+      @target[name] = body
+    end
+    def fields(*args, &block)
+      raise Dami::InvalidDSLError.new('fields', 'model')
+    end
+    def validate(*args, &block)
+      raise Dami::InvalidDSLError.new('validate', 'behavior')
+    end
+    def protection(*args, &block)
+      raise Dami::InvalidDSLError.new('protection', 'behavior')
+    end
+  end
+  class NestsProxy
+    def initialize(target)
+      @target = target
+    end
+    def nest(association_name, **options)
+      attributes_key = "#{association_name}_attributes".to_sym
+      @target[attributes_key] = {
+        association_name: association_name,
+        allow_destroy: options.fetch(:allow_destroy, false)
+      }.freeze
+    end
+  end
+end

data/lib/dami/core.rb

@@ -0,0 +1,98 @@
+# File: lib/dami/core.rb
+
+require_relative 'adapters/sqlite/connection'
+
+module Dami
+  @databases = {}
+  @models = {}
+  @flows = {}
+  @presenter_modules = {}
+
+  def self.plugin(mod)
+    mod.apply(self) if mod.respond_to?(:apply)
+  end
+
+def self.clear_all!
+    @databases.clear
+    @models.clear
+    @flows.clear
+    @presenter_modules&.clear
+    (@translations || {}).clear
+    Plugins::Associations.clear_cache!
+  end
+
+
+def self.present(model_name, &block)
+  presenter_module = Module.new
+  presenter_module.module_eval(&block)  # Changed from instance_eval
+  (@presenter_modules ||= {})[model_name] = presenter_module
+end
+
+  def self.find_presenter_module(model_name)
+    (@presenter_modules || {})[model_name]
+  end
+
+  # RecordProxy#initialize (extended by the Associations plugin) already applies
+  # the presenter, the association accessors and the field accessors.
+  def self.wrap_record(model_name, record_hash)
+    return nil unless record_hash
+    ::Dami::RecordProxy.new(model_name, record_hash)
+  end
+
+  def self.connect(name = :default, adapter:, **config)
+    adapter_class = Dami::Adapters.const_get(adapter.to_s.capitalize)
+    db_instance = adapter_class.new(config)
+    db_instance.connect
+    @databases[name] = db_instance
+    db_instance
+  end
+
+  def self.database(name = :default)
+    @databases.fetch(name) { raise "Database :#{name} not connected" }
+  end
+
+  def self.find_model(name)
+    @models.fetch(name) { raise "Model :#{name} not defined" }
+  end
+
+  def self.db(model_name)
+    model_config = find_model(model_name)
+    db_name = model_config[:database] || :default
+    builder_class = create_builder_with_scopes(model_name, model_config[:scopes] || {})
+    builder_class.new(model_name, db_name: db_name)
+  end
+
+  # Runs a flow inside one transaction.
+  #   * A Success halt commits.
+  #   * A Failure halt ROLLS BACK every write the flow made (raising Rollback
+  #     out of the transaction block is what triggers it).
+  #   * An unhandled exception rolls back and re-raises.
+  # after-commit hooks run only once the transaction has actually committed.
+  def self.run(flow_name, **params)
+    flow = find_flow(flow_name)
+    context = FlowContext.new(params)
+    result = nil
+    begin
+      Dami.database.transaction do
+        result = catch(:halt) { flow.call(context) }
+        raise Rollback if result.is_a?(Failure)
+      end
+    rescue Rollback
+      # Intentional: the transaction was rolled back; `result` is the Failure.
+    end
+    context.run_after_commit_hooks! if result.is_a?(Success)
+    result
+  end
+
+  def self.create_builder_with_scopes(model_name, scopes)
+    return Dami::Query::Builder if scopes.empty?
+    Class.new(Dami::Query::Builder) do
+      scopes.each do |name, body|
+        define_method(name) do |*args|
+          instance_exec(*args, &body)
+        end
+      end
+    end
+  end
+  private_class_method :create_builder_with_scopes
+end

data/lib/dami/dsl_guardrails.rb

@@ -0,0 +1,45 @@
+# File: lib/dami/dsl_guardrails.rb
+
+module Dami
+  module DSLGuardrails
+    # Methods that belong in Dami.behavior
+    def validate(*args, &block)
+      raise InvalidDSLError.new('validate', 'behavior')
+    end
+    
+    def protection(*args, &block)
+      raise InvalidDSLError.new('protection', 'behavior')
+    end
+    
+    def on(*args, &block)
+      raise InvalidDSLError.new('on', 'behavior')
+    end
+    
+    # Methods that belong in Dami.model
+    def fields(*args, &block)
+      raise InvalidDSLError.new('fields', 'model')
+    end
+    
+    def virtual(*args, &block)
+      raise InvalidDSLError.new('virtual', 'model')
+    end
+    
+    def relationships(*args, &block)
+      raise InvalidDSLError.new('relationships', 'model')
+    end
+    
+    def nests(*args, &block)
+      raise InvalidDSLError.new('nests', 'model')
+    end
+    
+    # Methods that belong in Dami.scopes
+    def scope(*args, &block)
+      raise InvalidDSLError.new('scope', 'scopes')
+    end
+    
+    # Methods that belong in Dami.present
+    def helper(*args, &block)
+      raise InvalidDSLError.new('helper', 'present')
+    end
+  end
+end

data/lib/dami/errors.rb

@@ -0,0 +1,89 @@
+# File: lib/dami/errors.rb
+
+module Dami
+  # Base error class
+  class Error < StandardError; end
+  
+  # Validation errors
+  class ValidationError < Error
+    attr_reader :errors
+    
+    def initialize(message = "Validation failed", errors = {})
+      @errors = errors
+      super(message)
+    end
+  end
+  
+  # Protection errors - backward compatible
+  class ProtectionError < Error
+    attr_reader :fields
+    
+    def initialize(message, fields = nil)
+      @fields = fields
+      super(message)
+    end
+  end
+  
+  class UnknownFieldsError < Error
+    attr_reader :fields
+    
+    def initialize(message, fields = nil)
+      @fields = fields
+      super(message)
+    end
+  end
+  
+  # Database errors
+  class ForeignKeyViolation < Error
+    attr_reader :table, :column, :value
+    
+    def initialize(message, table: nil, column: nil, value: nil)
+      @table = table
+      @column = column
+      @value = value
+      super("Foreign key violation: #{message}")
+    end
+  end
+  
+  class UniqueConstraintViolation < Error
+    attr_reader :table, :column, :value
+
+    def initialize(message, table: nil, column: nil, value: nil)
+      @table = table
+      @column = column
+      @value = value
+      super("Unique constraint violation: #{message}")
+    end
+  end
+
+  class NotNullViolation < Error
+    attr_reader :table, :column
+
+    def initialize(message, table: nil, column: nil)
+      @table = table
+      @column = column
+      super("Not-null constraint violation: #{message}")
+    end
+  end
+  
+  # DSL Architecture errors
+  class InvalidDSLError < Error
+    def initialize(method_name, correct_location)
+      super(
+        "'#{method_name}' is not allowed here. " \
+        "Please define it in a Dami.#{correct_location} block."
+      )
+    end
+  end
+  
+  # Command errors
+  class InvalidCommand < Error; end
+
+  # Raised internally by Dami.run to abort the surrounding transaction when a
+  # flow halts with a Failure. Never escapes Dami.run.
+  class Rollback < Error; end
+
+  # Raised when a caller passes something that is not a plain SQL identifier
+  # (letters, digits, underscore, dot) where a column or table name is expected.
+  class InvalidIdentifier < Error; end
+end