dexkit 0.2.0 → 0.4.0

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.rb

@@ -139,3 +139,6 @@ require_relative "operation/jobs"
 
 # Top-level aliases (depend on Operation::Ok/Err)
 require_relative "match"
+
+# Make Ok/Err available without prefix inside operations
+Dex::Operation.include(Dex::Match)

data/lib/dex/query/backend.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Dex
+  class Query
+    module Backend
+      STRATEGIES = %i[eq not_eq contains starts_with ends_with gt gte lt lte in not_in].to_set.freeze
+
+      module ActiveRecordAdapter
+        module_function
+
+        def apply(scope, strategy, column, value)
+          table = scope.arel_table
+
+          case strategy
+          when :eq, :in
+            scope.where(column => value)
+          when :not_eq, :not_in
+            scope.where.not(column => value)
+          when :contains
+            scope.where(table[column].matches("%#{sanitize_like(value)}%", "\\"))
+          when :starts_with
+            scope.where(table[column].matches("#{sanitize_like(value)}%", "\\"))
+          when :ends_with
+            scope.where(table[column].matches("%#{sanitize_like(value)}", "\\"))
+          when :gt
+            scope.where(table[column].gt(value))
+          when :gte
+            scope.where(table[column].gteq(value))
+          when :lt
+            scope.where(table[column].lt(value))
+          when :lte
+            scope.where(table[column].lteq(value))
+          else
+            raise ArgumentError, "Unknown strategy: #{strategy.inspect}"
+          end
+        end
+
+        def sanitize_like(value)
+          ActiveRecord::Base.sanitize_sql_like(value.to_s)
+        end
+      end
+
+      module MongoidAdapter
+        module_function
+
+        def apply(scope, strategy, column, value)
+          case strategy
+          when :eq
+            scope.where(column => value)
+          when :not_eq
+            scope.where(column.to_sym.ne => value)
+          when :in
+            scope.where(column.to_sym.in => Array(value))
+          when :not_in
+            scope.where(column.to_sym.nin => Array(value))
+          when :contains
+            scope.where(column => /#{Regexp.escape(value.to_s)}/i)
+          when :starts_with
+            scope.where(column => /\A#{Regexp.escape(value.to_s)}/i)
+          when :ends_with
+            scope.where(column => /#{Regexp.escape(value.to_s)}\z/i)
+          when :gt
+            scope.where(column.to_sym.gt => value)
+          when :gte
+            scope.where(column.to_sym.gte => value)
+          when :lt
+            scope.where(column.to_sym.lt => value)
+          when :lte
+            scope.where(column.to_sym.lte => value)
+          else
+            raise ArgumentError, "Unknown strategy: #{strategy.inspect}"
+          end
+        end
+      end
+
+      module_function
+
+      def apply_strategy(scope, strategy, column, value)
+        adapter_for(scope).apply(scope, strategy, column, value)
+      end
+
+      def adapter_for(scope)
+        if defined?(Mongoid::Criteria) && scope.is_a?(Mongoid::Criteria)
+          MongoidAdapter
+        else
+          ActiveRecordAdapter
+        end
+      end
+    end
+  end
+end

data/lib/dex/query/filtering.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Dex
+  class Query
+    module Filtering
+      extend Dex::Concern
+
+      FilterDef = Data.define(:name, :strategy, :column, :block, :optional)
+
+      module ClassMethods
+        def _filter_registry
+          @_filter_registry ||= {}
+        end
+
+        def filter(name, strategy = :eq, column: nil, &block)
+          name = name.to_sym
+
+          if _filter_registry.key?(name)
+            raise ArgumentError, "Filter :#{name} is already declared."
+          end
+
+          unless respond_to?(:literal_properties) && literal_properties.any? { |p| p.name == name }
+            raise ArgumentError, "Filter :#{name} requires a prop with the same name."
+          end
+
+          optional = _prop_optional?(name)
+
+          if block
+            _filter_registry[name] = FilterDef.new(name: name, strategy: nil, column: nil, block: block, optional: optional)
+          else
+            unless Backend::STRATEGIES.include?(strategy)
+              raise ArgumentError, "Unknown filter strategy: #{strategy.inspect}. " \
+                                   "Valid strategies: #{Backend::STRATEGIES.to_a.join(", ")}"
+            end
+
+            _filter_registry[name] = FilterDef.new(
+              name: name,
+              strategy: strategy,
+              column: (column || name).to_sym,
+              block: nil,
+              optional: optional
+            )
+          end
+        end
+
+        def filters
+          _filter_registry.keys
+        end
+      end
+
+      private
+
+      def _apply_filters(scope)
+        self.class._filter_registry.each_value do |filter_def|
+          value = public_send(filter_def.name)
+
+          next if value.nil? && filter_def.optional
+          next if (filter_def.strategy == :in || filter_def.strategy == :not_in) && value.respond_to?(:empty?) && value.empty?
+
+          result = if filter_def.block
+            instance_exec(scope, value, &filter_def.block)
+          else
+            Backend.apply_strategy(scope, filter_def.strategy, filter_def.column, value)
+          end
+
+          scope = result unless result.nil?
+        end
+
+        scope
+      end
+    end
+  end
+end

data/lib/dex/query/sorting.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Dex
+  class Query
+    module Sorting
+      extend Dex::Concern
+
+      SortDef = Data.define(:name, :custom, :block)
+
+      module ClassMethods
+        def _sort_registry
+          @_sort_registry ||= {}
+        end
+
+        def _sort_default
+          return @_sort_default if defined?(@_sort_default)
+
+          nil
+        end
+
+        def sort(*columns, default: nil, &block)
+          if block
+            raise ArgumentError, "Block sort requires exactly one column name." unless columns.size == 1
+
+            name = columns.first.to_sym
+
+            if _sort_registry.key?(name)
+              raise ArgumentError, "Sort :#{name} is already declared."
+            end
+
+            _sort_registry[name] = SortDef.new(name: name, custom: true, block: block)
+          else
+            raise ArgumentError, "sort requires at least one column name." if columns.empty?
+
+            columns.each do |col|
+              col = col.to_sym
+
+              if _sort_registry.key?(col)
+                raise ArgumentError, "Sort :#{col} is already declared."
+              end
+
+              _sort_registry[col] = SortDef.new(name: col, custom: false, block: nil)
+            end
+          end
+
+          if default
+            if defined?(@_sort_default) && @_sort_default
+              raise ArgumentError, "Default sort is already set to #{@_sort_default.inspect}."
+            end
+
+            bare = default.to_s.delete_prefix("-").to_sym
+            unless _sort_registry.key?(bare)
+              raise ArgumentError, "Default sort references unknown sort: #{bare.inspect}."
+            end
+
+            if default.to_s.start_with?("-") && _sort_registry[bare].custom
+              raise ArgumentError, "Custom sorts cannot use the \"-\" prefix."
+            end
+
+            @_sort_default = default.to_s
+          end
+        end
+
+        def sorts
+          _sort_registry.keys
+        end
+      end
+
+      private
+
+      def _apply_sort(scope)
+        sort_value = _current_sort
+        return scope unless sort_value
+
+        desc = sort_value.start_with?("-")
+        bare = sort_value.delete_prefix("-").to_sym
+
+        sort_def = self.class._sort_registry[bare]
+        unless sort_def
+          raise ArgumentError, "Unknown sort: #{bare.inspect}. Valid sorts: #{self.class._sort_registry.keys.join(", ")}"
+        end
+
+        if desc && sort_def.custom
+          raise ArgumentError, "Custom sorts cannot use the \"-\" prefix."
+        end
+
+        if sort_def.custom
+          instance_exec(scope, &sort_def.block)
+        else
+          scope.order(bare => desc ? :desc : :asc)
+        end
+      end
+    end
+  end
+end

data/lib/dex/query.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+require_relative "query/backend"
+require_relative "query/filtering"
+require_relative "query/sorting"
+
+module Dex
+  class Query
+    RESERVED_PROP_NAMES = %i[scope sort resolve call from_params to_params param_key].to_set.freeze
+
+    include PropsSetup
+    include Filtering
+    include Sorting
+
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    class << self
+      def scope(&block)
+        raise ArgumentError, "scope requires a block." unless block
+
+        @_scope_block = block
+      end
+
+      def _scope_block
+        return @_scope_block if defined?(@_scope_block)
+
+        superclass._scope_block if superclass.respond_to?(:_scope_block)
+      end
+
+      def new(scope: nil, sort: nil, **kwargs)
+        instance = super(**kwargs)
+        instance.instance_variable_set(:@_injected_scope, scope)
+        sort_str = sort&.to_s
+        sort_str = nil if sort_str&.empty?
+        instance.instance_variable_set(:@_sort_value, sort_str)
+        instance
+      end
+
+      def call(scope: nil, sort: nil, **kwargs)
+        new(scope: scope, sort: sort, **kwargs).resolve
+      end
+
+      def count(...)
+        call(...).count
+      end
+
+      def exists?(...)
+        call(...).exists?
+      end
+
+      def any?(...)
+        call(...).any?
+      end
+
+      def param_key(key = nil)
+        if key
+          str = key.to_s
+          raise ArgumentError, "param_key must not be blank." if str.empty?
+
+          @_param_key = str
+          @_model_name = nil
+        end
+        defined?(@_param_key) ? @_param_key : nil
+      end
+
+      silence_redefinition_of_method :model_name
+      def model_name
+        return @_model_name if @_model_name
+
+        pk = param_key
+        @_model_name = if pk
+          ActiveModel::Name.new(self, nil, pk.to_s.camelize).tap do |mn|
+            mn.define_singleton_method(:param_key) { pk }
+          end
+        elsif name && !name.start_with?("#")
+          super
+        else
+          ActiveModel::Name.new(self, nil, "Query")
+        end
+      end
+
+      def _prop_optional?(name)
+        return false unless respond_to?(:literal_properties)
+
+        prop = literal_properties.find { |p| p.name == name }
+        prop&.type.is_a?(Literal::Types::NilableType) || false
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@_filter_registry, _filter_registry.dup)
+        subclass.instance_variable_set(:@_sort_registry, _sort_registry.dup)
+        subclass.instance_variable_set(:@_sort_default, _sort_default) if _sort_default
+      end
+
+      def from_params(params, scope: nil, **overrides)
+        pk = model_name.param_key
+        nested = _extract_nested_params(params, pk)
+
+        sort_value = overrides.delete(:sort)&.to_s
+        unless sort_value && !sort_value.empty?
+          sort_value = nested.delete(:sort)&.to_s
+          sort_value = nil if sort_value && sort_value.empty?
+
+          # Validate sort — drop invalid to fall back to default
+          if sort_value
+            bare = sort_value.delete_prefix("-").to_sym
+            sort_def = _sort_registry[bare]
+            sort_value = nil if sort_def.nil? || (sort_value.start_with?("-") && sort_def.custom)
+          end
+        end
+
+        kwargs = {}
+
+        literal_properties.each do |prop|
+          pname = prop.name
+          next if overrides.key?(pname)
+          next if _ref_type?(prop.type)
+
+          raw = nested[pname]
+
+          if raw.nil? || (raw.is_a?(String) && raw.empty? && _prop_optional?(pname))
+            kwargs[pname] = nil if _prop_optional?(pname)
+            next
+          end
+
+          kwargs[pname] = _coerce_param(prop.type, raw)
+        end
+
+        kwargs.merge!(overrides)
+        kwargs[:sort] = sort_value if sort_value
+        kwargs[:scope] = scope if scope
+
+        new(**kwargs)
+      end
+
+      private
+
+      def _extract_nested_params(params, pk)
+        hash = if params.respond_to?(:to_unsafe_h)
+          params.to_unsafe_h
+        elsif params.is_a?(Hash)
+          params
+        else
+          {}
+        end
+
+        nested = hash[pk] || hash[pk.to_sym] || hash
+        nested = nested.to_unsafe_h if nested.respond_to?(:to_unsafe_h)
+        return {} unless nested.is_a?(Hash)
+
+        nested.transform_keys(&:to_sym)
+      end
+
+      def _ref_type?(type)
+        return true if type.is_a?(Dex::RefType)
+        return _ref_type?(type.type) if type.respond_to?(:type)
+
+        false
+      end
+
+      def _coerce_param(type, raw)
+        inner = type.is_a?(Literal::Types::NilableType) ? type.type : type
+
+        if inner.is_a?(Literal::Types::ArrayType)
+          values = Array(raw)
+          values = values.reject { |v| v.is_a?(String) && v.empty? }
+          return values.map { |v| _coerce_single(inner.type, v) }.compact
+        end
+
+        _coerce_single(inner, raw)
+      end
+
+      def _coerce_single(type, value)
+        return value unless value.is_a?(String)
+
+        base = _resolve_coercion_class(type)
+        return value unless base
+
+        case base.name
+        when "Integer"
+          Integer(value, 10)
+        when "Float"
+          Float(value)
+        when "Date"
+          Date.parse(value)
+        when "Time"
+          Time.parse(value)
+        when "DateTime"
+          DateTime.parse(value)
+        when "BigDecimal"
+          BigDecimal(value)
+        else
+          value
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def _resolve_coercion_class(type)
+        return type if type.is_a?(Class)
+        return _resolve_coercion_class(type.type) if type.respond_to?(:type)
+
+        nil
+      end
+    end
+
+    def resolve
+      base = _evaluate_scope
+      base = _merge_injected_scope(base)
+      base = _apply_filters(base)
+      _apply_sort(base)
+    end
+
+    def sort
+      _current_sort
+    end
+
+    def to_params
+      result = {}
+
+      self.class.literal_properties.each do |prop|
+        value = public_send(prop.name)
+        result[prop.name] = value unless value.nil?
+      end
+
+      s = _current_sort
+      result[:sort] = s if s
+
+      result
+    end
+
+    def persisted?
+      false
+    end
+
+    private
+
+    def _current_sort
+      @_sort_value || self.class._sort_default
+    end
+
+    def _evaluate_scope
+      block = self.class._scope_block
+      raise ArgumentError, "No scope defined. Use `scope { Model.all }` in your Query class." unless block
+
+      instance_exec(&block)
+    end
+
+    def _merge_injected_scope(base)
+      return base unless @_injected_scope
+
+      unless base.respond_to?(:klass)
+        raise ArgumentError, "Scope block must return a queryable scope (ActiveRecord relation or Mongoid criteria), got #{base.class}."
+      end
+
+      unless @_injected_scope.respond_to?(:klass)
+        raise ArgumentError, "Injected scope must be a queryable scope (ActiveRecord relation or Mongoid criteria), got #{@_injected_scope.class}."
+      end
+
+      unless base.klass == @_injected_scope.klass
+        raise ArgumentError, "Scope model mismatch: expected #{base.klass}, got #{@_injected_scope.klass}."
+      end
+
+      base.merge(@_injected_scope)
+    end
+  end
+end

data/lib/dex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dex
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/dexkit.rb

@@ -17,6 +17,8 @@ require_relative "dex/props_setup"
 require_relative "dex/error"
 require_relative "dex/operation"
 require_relative "dex/event"
+require_relative "dex/form"
+require_relative "dex/query"
 
 module Dex
   class Configuration