dexkit 0.1.0 → 0.3.0

data/lib/dex/form/nesting.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Dex
+  class Form
+    module Nesting
+      extend Dex::Concern
+
+      module ClassMethods
+        def _nested_ones
+          @_nested_ones ||= {}
+        end
+
+        def _nested_manys
+          @_nested_manys ||= {}
+        end
+
+        def nested_one(name, class_name: nil, &block)
+          raise ArgumentError, "nested_one requires a block" unless block
+
+          name = name.to_sym
+          nested_class = _build_nested_class(name, class_name, &block)
+          _nested_ones[name] = nested_class
+
+          attr_reader name
+
+          define_method(:"#{name}=") do |value|
+            coerced = _coerce_nested_one(name, value)
+            instance_variable_set(:"@#{name}", coerced)
+          end
+
+          define_method(:"build_#{name}") do |attrs = {}|
+            instance = self.class._nested_ones[name].new(attrs)
+            send(:"#{name}=", instance)
+            instance
+          end
+
+          define_method(:"#{name}_attributes=") do |attrs|
+            send(:"#{name}=", attrs)
+          end
+        end
+
+        def nested_many(name, class_name: nil, &block)
+          raise ArgumentError, "nested_many requires a block" unless block
+
+          name = name.to_sym
+          nested_class = _build_nested_class(name, class_name, &block)
+          _nested_manys[name] = nested_class
+
+          attr_reader name
+
+          define_method(:"#{name}=") do |value|
+            coerced = _coerce_nested_many(name, value)
+            instance_variable_set(:"@#{name}", coerced)
+          end
+
+          define_method(:"build_#{name.to_s.singularize}") do |attrs = {}|
+            instance = self.class._nested_manys[name].new(attrs)
+            items = send(name) || []
+            items << instance
+            instance_variable_set(:"@#{name}", items)
+            instance
+          end
+
+          define_method(:"#{name}_attributes=") do |attrs|
+            send(:"#{name}=", attrs)
+          end
+        end
+
+        private
+
+        def _build_nested_class(name, class_name, &block)
+          klass = Class.new(Dex::Form, &block)
+          const_name = class_name || name.to_s.singularize.camelize
+          const_set(const_name, klass)
+          klass
+        end
+      end
+
+      private
+
+      def _coerce_nested_one(name, value)
+        klass = self.class._nested_ones[name]
+        value = _unwrap_hash_like(value)
+        case value
+        when Hash
+          return nil if _marked_for_destroy?(value)
+          klass.new(value.except("_destroy", :_destroy))
+        when klass then value
+        when nil then value
+        else raise ArgumentError, "#{name} must be a Hash or #{klass}, got #{value.class}"
+        end
+      end
+
+      def _coerce_nested_many(name, value)
+        klass = self.class._nested_manys[name]
+        value = _unwrap_hash_like(value)
+        items = case value
+        when Array then value
+        when Hash then _normalize_nested_hash(value)
+        else raise ArgumentError, "#{name} must be an Array or Hash, got #{value.class}"
+        end
+
+        items.filter_map do |item|
+          item = _unwrap_hash_like(item)
+          case item
+          when Hash
+            next nil if _marked_for_destroy?(item)
+            klass.new(item.except("_destroy", :_destroy))
+          when klass then item
+          else raise ArgumentError, "each #{name} item must be a Hash or #{klass}"
+          end
+        end
+      end
+
+      def _unwrap_hash_like(value)
+        return value.to_unsafe_h if value.respond_to?(:to_unsafe_h)
+        return value if value.is_a?(Hash) || value.is_a?(Array) || value.is_a?(Dex::Form) || value.nil?
+
+        value.respond_to?(:to_h) ? value.to_h : value
+      end
+
+      def _normalize_nested_hash(hash)
+        hash.sort_by { |k, _| k.to_s.to_i }.map(&:last)
+      end
+
+      def _marked_for_destroy?(attrs)
+        destroy_val = attrs["_destroy"] || attrs[:_destroy]
+        ActiveModel::Type::Boolean.new.cast(destroy_val)
+      end
+
+      def _initialize_nested_defaults(provided_keys)
+        self.class._nested_ones.each_key do |name|
+          key = name.to_s
+          next if provided_keys.include?(key) || provided_keys.include?("#{key}_attributes")
+
+          send(:"#{name}=", {})
+        end
+
+        self.class._nested_manys.each_key do |name|
+          next if instance_variable_get(:"@#{name}")
+
+          instance_variable_set(:"@#{name}", [])
+        end
+      end
+
+      def _validate_nested(context)
+        valid = true
+
+        self.class._nested_ones.each_key do |name|
+          nested = send(name)
+          next unless nested
+
+          unless nested.valid?(context)
+            nested.errors.each do |error|
+              errors.add(:"#{name}.#{error.attribute}", error.message)
+            end
+            valid = false
+          end
+        end
+
+        self.class._nested_manys.each_key do |name|
+          items = send(name) || []
+          items.each_with_index do |item, index|
+            next if item.valid?(context)
+
+            item.errors.each do |error|
+              errors.add(:"#{name}[#{index}].#{error.attribute}", error.message)
+            end
+            valid = false
+          end
+        end
+
+        valid
+      end
+
+      def _nested_to_h(result)
+        self.class._nested_ones.each_key do |name|
+          nested = send(name)
+          result[name] = nested&.to_h
+        end
+
+        self.class._nested_manys.each_key do |name|
+          items = send(name) || []
+          result[name] = items.map(&:to_h)
+        end
+      end
+    end
+  end
+end

data/lib/dex/form/uniqueness_validator.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Dex
+  class Form
+    class UniquenessValidator < ActiveModel::EachValidator
+      def check_validity!
+        if options.key?(:model) && !options[:model].is_a?(Class)
+          raise ArgumentError, "uniqueness :model must be a Class, got #{options[:model].inspect}"
+        end
+        if options.key?(:conditions) && !options[:conditions].respond_to?(:call)
+          raise ArgumentError, "uniqueness :conditions must be callable"
+        end
+      end
+
+      def validate_each(form, attribute, value)
+        return if value.blank?
+
+        model_class = _resolve_model_class(form)
+        return unless model_class
+
+        column = options[:attribute] || attribute
+        query = _build_query(model_class, column, value)
+        query = _apply_scope(query, form)
+        query = _apply_conditions(query, form)
+        query = _exclude_current_record(query, form)
+
+        form.errors.add(attribute, options[:message] || :taken) if query.exists?
+      end
+
+      private
+
+      def _resolve_model_class(form)
+        return options[:model] if options[:model]
+        return form.class._model_class if form.class.respond_to?(:_model_class) && form.class._model_class
+
+        _infer_model_class(form)
+      end
+
+      def _infer_model_class(form)
+        class_name = form.class.name
+        return unless class_name
+
+        model_name = class_name.sub(/Form\z/, "")
+        return if model_name == class_name
+
+        klass = Object.const_get(model_name)
+        klass.respond_to?(:where) ? klass : nil
+      rescue NameError
+        nil
+      end
+
+      def _build_query(model_class, column, value)
+        if options[:case_sensitive] == false && value.is_a?(String) && model_class.respond_to?(:arel_table)
+          model_class.where(model_class.arel_table[column].lower.eq(value.downcase))
+        else
+          model_class.where(column => value)
+        end
+      end
+
+      def _apply_scope(query, form)
+        Array(options[:scope]).each do |scope_attr|
+          query = query.where(scope_attr => form.public_send(scope_attr))
+        end
+        query
+      end
+
+      def _apply_conditions(query, form)
+        return query unless options[:conditions]
+
+        callable = options[:conditions]
+        if callable.arity.zero?
+          query.instance_exec(&callable)
+        else
+          query.instance_exec(form, &callable)
+        end
+      end
+
+      def _exclude_current_record(query, form)
+        return query unless form.record&.persisted?
+
+        pk = form.record.class.primary_key
+        query.where.not(pk => form.record.public_send(pk))
+      end
+    end
+  end
+end

data/lib/dex/form.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+require_relative "form/nesting"
+
+module Dex
+  class Form
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Validations::Callbacks
+
+    if defined?(ActiveModel::Attributes::Normalization)
+      include ActiveModel::Attributes::Normalization
+    end
+
+    include Nesting
+    include Match
+
+    class ValidationError < StandardError
+      attr_reader :form
+
+      def initialize(form)
+        @form = form
+        super("Validation failed: #{form.errors.full_messages.join(", ")}")
+      end
+    end
+
+    class << self
+      def model(klass = nil)
+        if klass
+          raise ArgumentError, "model must be a Class, got #{klass.inspect}" unless klass.is_a?(Class)
+          @_model_class = klass
+        end
+        _model_class
+      end
+
+      def _model_class
+        return @_model_class if defined?(@_model_class)
+        superclass._model_class if superclass.respond_to?(:_model_class)
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@_nested_ones, _nested_ones.dup)
+        subclass.instance_variable_set(:@_nested_manys, _nested_manys.dup)
+      end
+    end
+
+    silence_redefinition_of_method :model_name
+    def self.model_name
+      if _model_class
+        _model_class.model_name
+      elsif name && !name.start_with?("#")
+        super
+      else
+        @_model_name ||= ActiveModel::Name.new(self, nil, name&.split("::")&.last || "Form")
+      end
+    end
+
+    attr_reader :record
+
+    def initialize(attributes = {})
+      # Accept ActionController::Parameters without requiring .permit — the form's
+      # attribute declarations are the whitelist. Only declared attributes and nested
+      # setters are assignable; everything else is silently dropped.
+      attributes = attributes.to_unsafe_h if attributes.respond_to?(:to_unsafe_h)
+      attrs = (attributes || {}).transform_keys(&:to_s)
+      record = attrs.delete("record")
+      @record = record if record.nil? || record.respond_to?(:persisted?)
+      provided_keys = attrs.keys
+      nested_attrs = _extract_nested_attributes(attrs)
+      super(attrs.slice(*self.class.attribute_names))
+      _apply_nested_attributes(nested_attrs)
+      _initialize_nested_defaults(provided_keys)
+    end
+
+    def with_record(record)
+      raise ArgumentError, "record must respond to #persisted?, got #{record.inspect}" unless record.respond_to?(:persisted?)
+
+      @record = record
+      self
+    end
+
+    def persisted?
+      record&.persisted? || false
+    end
+
+    def to_key
+      record&.to_key
+    end
+
+    def to_param
+      record&.to_param
+    end
+
+    def valid?(context = nil)
+      super_result = super
+      nested_result = _validate_nested(context)
+      super_result && nested_result
+    end
+
+    def to_h
+      result = {}
+      self.class.attribute_names.each do |name|
+        result[name.to_sym] = public_send(name)
+      end
+      _nested_to_h(result)
+      result
+    end
+
+    alias_method :to_hash, :to_h
+
+    private
+
+    def _extract_nested_attributes(attrs)
+      nested_keys = self.class._nested_ones.keys.map(&:to_s) +
+        self.class._nested_manys.keys.map(&:to_s)
+
+      extracted = {}
+      nested_keys.each do |key|
+        attr_key = "#{key}_attributes"
+        if attrs.key?(attr_key)
+          extracted[attr_key] = attrs.delete(attr_key)
+          attrs.delete(key)
+        elsif attrs.key?(key)
+          extracted[key] = attrs.delete(key)
+        end
+      end
+      extracted
+    end
+
+    def _apply_nested_attributes(nested_attrs)
+      nested_attrs.each do |key, value|
+        next if value.nil?
+        send(:"#{key}=", value)
+      end
+    end
+  end
+end
+
+require_relative "form/uniqueness_validator"

data/lib/dex/operation/async_proxy.rb

@@ -9,41 +9,41 @@ module Dex
       end
 
       def call
-        _async_ensure_active_job_loaded!
-        if _async_use_record_strategy?
-          _async_enqueue_record_job
+        ensure_active_job_loaded!
+        if use_record_strategy?
+          enqueue_record_job
         else
-          _async_enqueue_direct_job
+          enqueue_direct_job
         end
       end
 
       private
 
-      def _async_enqueue_direct_job
-        job = _async_apply_options(Operation::DirectJob)
-        job.perform_later(class_name: _async_operation_class_name, params: _async_serialized_params)
+      def enqueue_direct_job
+        job = apply_options(Operation::DirectJob)
+        job.perform_later(class_name: operation_class_name, params: serialized_params)
       end
 
-      def _async_enqueue_record_job
+      def enqueue_record_job
         record = Dex.record_backend.create_record(
-          name: _async_operation_class_name,
-          params: _async_serialized_params,
+          name: operation_class_name,
+          params: serialized_params,
           status: "pending"
         )
         begin
-          job = _async_apply_options(Operation::RecordJob)
-          job.perform_later(class_name: _async_operation_class_name, record_id: record.id)
+          job = apply_options(Operation::RecordJob)
+          job.perform_later(class_name: operation_class_name, record_id: record.id)
         rescue => e
           begin
             record.destroy
           rescue => destroy_error
-            _async_log_warning("Failed to clean up pending record #{record.id}: #{destroy_error.message}")
+            Dex.warn("Failed to clean up pending record #{record.id}: #{destroy_error.message}")
           end
           raise e
         end
       end
 
-      def _async_use_record_strategy?
+      def use_record_strategy?
         return false unless Dex.record_backend
         return false unless @operation.class.name
 
@@ -54,54 +54,48 @@ module Dex
         true
       end
 
-      def _async_apply_options(job_class)
+      def apply_options(job_class)
         options = {}
-        options[:queue] = _async_queue if _async_queue
-        options[:wait_until] = _async_scheduled_at if _async_scheduled_at
-        options[:wait] = _async_scheduled_in if _async_scheduled_in
+        options[:queue] = queue if queue
+        options[:wait_until] = scheduled_at if scheduled_at
+        options[:wait] = scheduled_in if scheduled_in
         options.empty? ? job_class : job_class.set(**options)
       end
 
-      def _async_ensure_active_job_loaded!
+      def ensure_active_job_loaded!
         return if defined?(ActiveJob::Base)
 
         raise LoadError, "ActiveJob is required for async operations. Add 'activejob' to your Gemfile."
       end
 
-      def _async_merged_options
+      def merged_options
         @operation.class.settings_for(:async).merge(@runtime_options)
       end
 
-      def _async_queue = _async_merged_options[:queue]
-      def _async_scheduled_at = _async_merged_options[:at]
-      def _async_scheduled_in = _async_merged_options[:in]
-      def _async_operation_class_name = @operation.class.name
+      def queue = merged_options[:queue]
+      def scheduled_at = merged_options[:at]
+      def scheduled_in = merged_options[:in]
+      def operation_class_name = @operation.class.name
 
-      def _async_serialized_params
-        @_async_serialized_params ||= begin
+      def serialized_params
+        @serialized_params ||= begin
           hash = @operation._props_as_json
-          _async_validate_serializable!(hash)
+          validate_serializable!(hash)
           hash
         end
       end
 
-      def _async_log_warning(message)
-        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-          Rails.logger.warn "[Dex] #{message}"
-        end
-      end
-
-      def _async_validate_serializable!(hash, path: "")
+      def validate_serializable!(hash, path: "")
         hash.each do |key, value|
           current = path.empty? ? key.to_s : "#{path}.#{key}"
           case value
           when String, Integer, Float, NilClass, TrueClass, FalseClass
             next
           when Hash
-            _async_validate_serializable!(value, path: current)
+            validate_serializable!(value, path: current)
           when Array
             value.each_with_index do |v, i|
-              _async_validate_serializable!({ i => v }, path: current)
+              validate_serializable!({ i => v }, path: current)
             end
           else
             raise ArgumentError,

data/lib/dex/operation/async_wrapper.rb

@@ -2,33 +2,17 @@
 
 module Dex
   module AsyncWrapper
-    ASYNC_KNOWN_OPTIONS = %i[queue in at].freeze
-
     module ClassMethods
       def async(**options)
-        unknown = options.keys - AsyncWrapper::ASYNC_KNOWN_OPTIONS
-        if unknown.any?
-          raise ArgumentError,
-            "unknown async option(s): #{unknown.map(&:inspect).join(", ")}. " \
-            "Known: #{AsyncWrapper::ASYNC_KNOWN_OPTIONS.map(&:inspect).join(", ")}"
-        end
-
+        validate_options!(options, %i[queue in at], :async)
         set(:async, **options)
       end
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend Dex::Concern
 
     def async(**options)
-      unknown = options.keys - AsyncWrapper::ASYNC_KNOWN_OPTIONS
-      if unknown.any?
-        raise ArgumentError,
-          "unknown async option(s): #{unknown.map(&:inspect).join(", ")}. " \
-          "Known: #{AsyncWrapper::ASYNC_KNOWN_OPTIONS.map(&:inspect).join(", ")}"
-      end
-
+      self.class.validate_options!(options, %i[queue in at], :async)
       Operation::AsyncProxy.new(self, **options)
     end
   end

data/lib/dex/operation/callback_wrapper.rb

@@ -2,9 +2,7 @@
 
 module Dex
   module CallbackWrapper
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend Dex::Concern
 
     module ClassMethods
       def before(callable = nil, &block)
@@ -57,24 +55,22 @@ module Dex
     def _callback_wrap
       return yield unless self.class._callback_any?
 
-      halted = nil
+      success_halt = nil
       result = _callback_run_around(self.class._callback_list(:around)) do
         _callback_run_before
-        caught = catch(:_dex_halt) { yield }
-        if caught.is_a?(Operation::Halt)
-          if caught.success?
-            halted = caught
-            _callback_run_after
-            caught.value
-          else
-            throw(:_dex_halt, caught)
-          end
+        interceptor = Operation::HaltInterceptor.new { yield }
+        if interceptor.error?
+          interceptor.rethrow!
+        elsif interceptor.halted?
+          success_halt = interceptor
+          _callback_run_after
+          interceptor.result
         else
           _callback_run_after
-          caught
+          interceptor.result
         end
       end
-      throw(:_dex_halt, halted) if halted
+      success_halt&.rethrow!
       result
     end
 

data/lib/dex/operation/jobs.rb

@@ -11,7 +11,7 @@ module Dex
         const_set(:DirectJob, Class.new(ActiveJob::Base) do
           def perform(class_name:, params:)
             klass = class_name.constantize
-            klass.new(**klass.send(:_dex_coerce_serialized_hash, params)).call
+            klass.new(**klass.send(:_coerce_serialized_hash, params)).call
           end
         end)
       when :RecordJob
@@ -19,39 +19,33 @@ module Dex
           def perform(class_name:, record_id:)
             klass = class_name.constantize
             record = Dex.record_backend.find_record(record_id)
-            params = klass.send(:_dex_coerce_serialized_hash, record.params || {})
+            params = klass.send(:_coerce_serialized_hash, record.params || {})
 
             op = klass.new(**params)
             op.instance_variable_set(:@_dex_record_id, record_id)
 
-            _dex_update_status(record_id, status: "running")
+            update_status(record_id, status: "running")
             op.call
           rescue => e
-            _dex_handle_failure(record_id, e)
+            handle_failure(record_id, e)
             raise
           end
 
           private
 
-          def _dex_update_status(record_id, **attributes)
+          def update_status(record_id, **attributes)
             Dex.record_backend.update_record(record_id, attributes)
           rescue => e
-            _dex_log_warning("Failed to update record status: #{e.message}")
+            Dex.warn("Failed to update record status: #{e.message}")
           end
 
-          def _dex_handle_failure(record_id, exception)
+          def handle_failure(record_id, exception)
             error_value = if exception.is_a?(Dex::Error)
               exception.code.to_s
             else
               exception.class.name
             end
-            _dex_update_status(record_id, status: "failed", error: error_value)
-          end
-
-          def _dex_log_warning(message)
-            if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-              Rails.logger.warn "[Dex] #{message}"
-            end
+            update_status(record_id, status: "failed", error: error_value)
           end
         end)
       when :Job