typed_eav 0.1.0

data/app/models/typed_eav/field/base.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+module TypedEAV
+  module Field
+    class Base < ApplicationRecord
+      self.table_name = "typed_eav_fields"
+
+      include TypedEAV::ColumnMapping
+
+      # ── Associations ──
+
+      belongs_to :section,
+                 class_name: "TypedEAV::Section",
+                 optional: true,
+                 inverse_of: :fields
+
+      has_many :values,
+               class_name: "TypedEAV::Value",
+               foreign_key: :field_id,
+               inverse_of: :field,
+               dependent: :destroy
+
+      has_many :field_options,
+               class_name: "TypedEAV::Option",
+               foreign_key: :field_id,
+               inverse_of: :field,
+               dependent: :destroy
+
+      # ── Validations ──
+
+      RESERVED_NAMES = %w[id type class created_at updated_at].freeze
+
+      validates :name, presence: true, uniqueness: { scope: %i[entity_type scope] }
+      validates :name, exclusion: { in: RESERVED_NAMES, message: "is reserved" }
+      validates :type, presence: true
+      validates :entity_type, presence: true
+      validate :validate_default_value
+      validate :validate_type_allowed_for_entity
+
+      # ── Scopes ──
+
+      scope :for_entity, lambda { |entity_type, scope: nil|
+        scopes = [scope, nil].uniq
+        where(entity_type: entity_type, scope: scopes)
+      }
+
+      scope :sorted, -> { order(sort_order: :asc, name: :asc) }
+      scope :required_fields, -> { where(required: true) }
+
+      # ── Default value handling ──
+      # Stored in default_value_meta as {"v": <raw_value>} so the jsonb
+      # column can hold any type's default without an extra typed column.
+
+      def default_value
+        cast(default_value_meta["v"]).first
+      end
+
+      def default_value=(val)
+        default_value_meta["v"] = val
+      end
+
+      # ── Type casting ──
+      # Returns a tuple: [casted_value, invalid?].
+      #
+      # - casted_value is the coerced value (or nil when raw is nil/blank)
+      # - invalid? is true when raw was non-empty but unparseable for this
+      #   type; Value#validate_value uses the flag to surface :invalid
+      #   errors (vs :blank for nil-from-nil).
+      #
+      # Subclasses override to enforce type semantics. Default is an
+      # identity pass-through that never flags invalid.
+      #
+      # Callers that only need the coerced value should use
+      # `cast(raw).first`.
+      def cast(raw)
+        [raw, false]
+      end
+
+      # ── Introspection ──
+
+      def field_type_name
+        self.class.name.demodulize.underscore
+      end
+
+      def array_field?
+        false
+      end
+
+      def optionable?
+        false
+      end
+
+      # Allowed option values for select/multi-select validation.
+      # When `field_options` is already loaded (eager-load path), read from
+      # memory instead of issuing a fresh `pluck` query.
+      def allowed_option_values
+        if field_options.loaded?
+          field_options.map(&:value)
+        else
+          field_options.pluck(:value)
+        end
+      end
+
+      # Kept for backward compatibility but now a no-op since we don't cache.
+      def clear_option_cache!
+        # no-op
+      end
+
+      # ── Per-type value validation (polymorphic dispatch from Value) ──
+      #
+      # Default no-op. Subclasses override to enforce their constraints
+      # (length, range, pattern, option inclusion, array size, etc.) and
+      # add errors to `record.errors`. Shared helpers below (validate_length,
+      # validate_pattern, validate_range, etc.) are available to subclasses.
+      def validate_typed_value(record, val)
+        # no-op by default
+      end
+
+      protected
+
+      def options_hash
+        options&.with_indifferent_access || {}
+      end
+
+      def validate_length(record, val)
+        opts = options_hash
+        str = val.to_s
+        if opts[:min_length] && str.length < opts[:min_length].to_i
+          record.errors.add(:value, :too_short, count: opts[:min_length])
+        end
+        return unless opts[:max_length] && str.length > opts[:max_length].to_i
+
+        record.errors.add(:value, :too_long, count: opts[:max_length])
+      end
+
+      def validate_pattern(record, val)
+        opts = options_hash
+        pattern = opts[:pattern]
+        return if pattern.blank?
+
+        matched = Timeout.timeout(1) { Regexp.new(pattern).match?(val.to_s) }
+        record.errors.add(:value, :invalid) unless matched
+      rescue RegexpError
+        record.errors.add(:value, "has an invalid pattern configured")
+      rescue Timeout::Error
+        record.errors.add(:value, "pattern validation timed out")
+      end
+
+      def validate_range(record, val)
+        opts = options_hash
+        record.errors.add(:value, :greater_than_or_equal_to, count: opts[:min]) if opts[:min] && val < opts[:min].to_d
+        return unless opts[:max] && val > opts[:max].to_d
+
+        record.errors.add(:value, :less_than_or_equal_to, count: opts[:max])
+      end
+
+      def validate_date_range(record, val)
+        opts = options_hash
+        if opts[:min_date]
+          min = ::Date.parse(opts[:min_date])
+          record.errors.add(:value, :greater_than_or_equal_to, count: opts[:min_date]) if val < min
+        end
+        if opts[:max_date]
+          max = ::Date.parse(opts[:max_date])
+          record.errors.add(:value, :less_than_or_equal_to, count: opts[:max_date]) if val > max
+        end
+      rescue ::Date::Error
+        record.errors.add(:base, "field has invalid date configuration")
+      end
+
+      def validate_datetime_range(record, val)
+        opts = options_hash
+        if opts[:min_datetime]
+          min = ::Time.zone.parse(opts[:min_datetime])
+          record.errors.add(:value, :greater_than_or_equal_to, count: opts[:min_datetime]) if val < min
+        end
+        if opts[:max_datetime]
+          max = ::Time.zone.parse(opts[:max_datetime])
+          record.errors.add(:value, :less_than_or_equal_to, count: opts[:max_datetime]) if val > max
+        end
+      rescue ArgumentError
+        record.errors.add(:base, "field has invalid datetime configuration")
+      end
+
+      def validate_option_inclusion(record, val)
+        return if allowed_option_values.include?(val&.to_s)
+
+        record.errors.add(:value, :inclusion)
+      end
+
+      def validate_multi_option_inclusion(record, val)
+        invalid = Array(val).map(&:to_s) - allowed_option_values
+        record.errors.add(:value, :inclusion) if invalid.any?
+      end
+
+      def validate_array_size(record, val)
+        opts = options_hash
+        arr = Array(val)
+        if opts[:min_size] && arr.size < opts[:min_size].to_i
+          record.errors.add(:value, :too_short, count: opts[:min_size])
+        end
+        return unless opts[:max_size] && arr.size > opts[:max_size].to_i
+
+        record.errors.add(:value, :too_long, count: opts[:max_size])
+      end
+
+      private
+
+      def validate_default_value
+        return if default_value_meta.blank? || !default_value_meta.key?("v")
+
+        raw = default_value_meta["v"]
+        return if raw.nil?
+
+        _, invalid = cast(raw)
+        errors.add(:default_value, "is not valid for this field type") if invalid
+      end
+
+      # Enforces type restrictions set via `has_typed_eav types: [...]`.
+      # Skips if the entity type isn't registered (e.g., in console before
+      # models are loaded) — this is intentional fail-open behavior since
+      # unregistered entity types have no restrictions to enforce.
+      def validate_type_allowed_for_entity
+        return unless entity_type.present? && type.present?
+        return unless TypedEAV.registry.entity_types.include?(entity_type)
+        return if TypedEAV.registry.type_allowed?(entity_type, self.class)
+
+        errors.add(:type, "#{field_type_name} is not allowed for #{entity_type}")
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/boolean.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Boolean < Base
+      value_column :boolean_value
+      operators :eq, :is_null, :is_not_null
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+        return [nil, false] if raw.is_a?(String) && raw.strip.empty?
+
+        recognized = %w[true false 1 0 t f yes no on off].freeze
+        unless raw == true || raw == false || raw == 0 || raw == 1 || recognized.include?(raw.to_s.strip.downcase) # rubocop:disable Style/NumericPredicate
+          return [nil, true]
+        end
+
+        [ActiveModel::Type::Boolean.new.cast(raw), false]
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/color.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Color < Base
+      value_column :string_value
+      operators :eq, :not_eq, :is_null, :is_not_null
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        [raw.to_s.strip.downcase, false]
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/date.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Date < Base
+      value_column :date_value
+
+      store_accessor :options, :min_date, :max_date
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        casted = raw.is_a?(::Date) ? raw : ::Date.parse(raw.to_s)
+        [casted, false]
+      rescue ::Date::Error
+        [nil, true]
+      end
+
+      def validate_typed_value(record, val)
+        validate_date_range(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/date_array.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class DateArray < Base
+      value_column :json_value
+      operators :any_eq, :is_null, :is_not_null
+
+      store_accessor :options, :min_size, :max_size
+
+      def array_field? = true
+
+      # See IntegerArray#cast for the "invalid element → whole value invalid"
+      # rationale.
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        elements = Array(raw).reject { |v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+        casted = elements.map do |v|
+          ::Date.parse(v.to_s)
+        rescue StandardError
+          nil
+        end
+        return [nil, true] if casted.any?(&:nil?) && elements.any?
+
+        [casted.presence, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_array_size(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/date_time.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class DateTime < Base
+      value_column :datetime_value
+
+      store_accessor :options, :min_datetime, :max_datetime
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+        return [raw, false] if raw.is_a?(::Time)
+
+        result = ::Time.zone.parse(raw.to_s)
+        if result.nil?
+          [nil, !raw.to_s.strip.empty?]
+        else
+          [result, false]
+        end
+      rescue ArgumentError
+        [nil, true]
+      end
+
+      def validate_typed_value(record, val)
+        validate_datetime_range(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/decimal.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Decimal < Base
+      value_column :decimal_value
+
+      store_accessor :options, :min, :max, :precision_scale
+
+      validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        result = BigDecimal(raw.to_s, exception: false)
+        return [nil, !raw.to_s.strip.empty?] if result.nil?
+        return [result, false] if precision_scale.blank?
+
+        scale = Kernel.Integer(precision_scale, exception: false)
+        return [result, false] unless scale && scale >= 0
+
+        [result.round(scale), false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_range(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/decimal_array.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class DecimalArray < Base
+      value_column :json_value
+      operators :any_eq, :all_eq, :is_null, :is_not_null
+
+      store_accessor :options, :min_size, :max_size
+
+      def array_field? = true
+
+      # See IntegerArray#cast for the "invalid element → whole value invalid"
+      # rationale. Same pattern: any unparseable element marks the cast
+      # invalid and stores nil rather than a silently-pruned partial.
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        elements = Array(raw).reject { |v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+        casted = elements.map { |v| BigDecimal(v.to_s, exception: false) }
+        return [nil, true] if casted.any?(&:nil?) && elements.any?
+
+        [casted.presence, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_array_size(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/email.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Email < Base
+      value_column :string_value
+
+      store_accessor :options, :min_length, :max_length, :pattern
+      validate :validate_pattern_syntax
+
+      EMAIL_FORMAT = /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        [raw.to_s.strip.downcase, false]
+      end
+
+      def email_format_valid?(val)
+        EMAIL_FORMAT.match?(val)
+      end
+
+      def validate_typed_value(record, val)
+        validate_length(record, val)
+        validate_pattern(record, val) if pattern.present?
+        record.errors.add(:value, "is not a valid email address") unless email_format_valid?(val)
+      end
+
+      private
+
+      def validate_pattern_syntax
+        return if pattern.blank?
+
+        Regexp.new(pattern)
+      rescue RegexpError => e
+        errors.add(:pattern, "is invalid: #{e.message}")
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/integer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Integer < Base
+      value_column :integer_value
+
+      store_accessor :options, :min, :max
+
+      validates :max, comparison: { greater_than_or_equal_to: :min }, allow_nil: true, if: :min
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        str = raw.to_s.strip
+        return [nil, false] if str.empty?
+
+        bd = BigDecimal(str, exception: false)
+        return [nil, true] if bd.nil?
+        return [nil, true] if bd.frac != 0
+
+        [bd.to_i, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_range(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/integer_array.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class IntegerArray < Base
+      value_column :json_value
+      operators :any_eq, :all_eq, :is_null, :is_not_null
+
+      store_accessor :options, :min_size, :max_size, :min, :max
+
+      def array_field? = true
+
+      # Cast each element using the scalar-integer parsing rules: strings
+      # must look like integers (`/\A-?\d+\z/`). Fractional input like
+      # "1.9" is rejected instead of silently truncated to 1.
+      #
+      # If ANY element fails to cast, mark the whole value invalid and store
+      # nil — don't keep a "partially cast" array around, because a failed
+      # form re-render would drop the bad elements and confuse the user
+      # (they'd see only the good ones and not know why validation fired).
+      # This mirrors scalar `Integer#cast` which returns `[nil, true]` on
+      # invalid input.
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        elements = Array(raw).reject { |v| v.nil? || (v.respond_to?(:empty?) && v.empty?) }
+        casted = elements.map { |v| cast_integer(v) }
+        return [nil, true] if casted.any?(&:nil?) && elements.any?
+
+        [casted.presence, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_array_size(record, val)
+        validate_element_range(record, val)
+      end
+
+      private
+
+      def cast_integer(val)
+        return val if val.is_a?(Integer)
+
+        str = val.to_s
+        return nil unless str.match?(/\A-?\d+\z/)
+
+        str.to_i
+      end
+
+      def validate_element_range(record, val)
+        opts = options_hash
+        min_val = opts[:min]&.to_d
+        max_val = opts[:max]&.to_d
+        return unless min_val || max_val
+
+        Array(val).each do |el|
+          if min_val && el < min_val
+            record.errors.add(:value, :greater_than_or_equal_to, count: opts[:min])
+            break
+          end
+          if max_val && el > max_val
+            record.errors.add(:value, :less_than_or_equal_to, count: opts[:max])
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/json.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Json < Base
+      value_column :json_value
+      operators :is_null, :is_not_null
+
+      # Parse JSON strings into objects/arrays. The JSON input partial posts a
+      # string from a textarea; without parsing it would land as a JSON-
+      # encoded string in json_value instead of the intended object.
+      def cast(raw)
+        return [nil, false] if raw.nil?
+        return [raw, false] if raw.is_a?(Hash) || raw.is_a?(Array) ||
+                               raw.is_a?(Numeric) || raw == true || raw == false
+
+        str = raw.to_s
+        return [nil, false] if str.strip.empty?
+
+        [::JSON.parse(str), false]
+      rescue ::JSON::ParserError
+        [nil, true]
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/long_text.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class LongText < Base
+      value_column :text_value
+
+      store_accessor :options, :min_length, :max_length
+
+      def cast(raw)
+        [raw&.to_s, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_length(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/multi_select.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class MultiSelect < Base
+      value_column :json_value
+      operators :any_eq, :all_eq, :is_null, :is_not_null
+
+      def optionable? = true
+      def array_field? = true
+
+      def allowed_values
+        if field_options.loaded?
+          field_options.sort_by { |o| [o.sort_order || 0, o.label.to_s] }.map(&:value)
+        else
+          field_options.sorted.pluck(:value)
+        end
+      end
+
+      def cast(raw)
+        return [nil, false] if raw.nil?
+
+        # Rails emits a hidden "" sentinel for `select multiple: true` so an
+        # empty submission still round-trips. Drop nil/blank elements here so
+        # the inclusion check doesn't reject the form's own placeholder.
+        elements = Array(raw).filter_map do |v|
+          next nil if v.nil?
+
+          s = v.to_s
+          s.strip.empty? ? nil : s
+        end
+        [elements.presence, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_multi_option_inclusion(record, val)
+        validate_array_size(record, val)
+      end
+    end
+  end
+end

data/app/models/typed_eav/field/select.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Field
+    class Select < Base
+      value_column :string_value
+      operators :eq, :not_eq, :is_null, :is_not_null
+
+      def optionable? = true
+
+      def allowed_values
+        if field_options.loaded?
+          field_options.sort_by { |o| [o.sort_order || 0, o.label.to_s] }.map(&:value)
+        else
+          field_options.sorted.pluck(:value)
+        end
+      end
+
+      def cast(raw)
+        [raw&.to_s, false]
+      end
+
+      def validate_typed_value(record, val)
+        validate_option_inclusion(record, val)
+      end
+    end
+  end
+end