typed_eav 0.2.1 → 0.3.0

data/lib/typed_eav/partition.rb

@@ -8,6 +8,14 @@ module TypedEAV
   # values. Ambient resolution (`TypedEAV.current_scope`, `with_scope`,
   # `unscoped`) stays with the adapters that know their calling context.
   module Partition
+    # Frozen orphan-parent ArgumentError message. Kept as a module constant
+    # so both `visible_fields` and `visible_sections` raise the same string
+    # without re-allocating per call. The string is the wire-stable BC error
+    # message that `partition_spec` matches against; do not change it
+    # without coordinating with downstream rescue clauses.
+    ORPHAN_PARENT_MESSAGE = "parent_scope cannot be set when scope is blank"
+    private_constant :ORPHAN_PARENT_MESSAGE
+
     class << self
       # All field definitions visible from a tuple: pure global rows,
       # scope-only rows, and full-tuple rows. Passing mode: :all_partitions is
@@ -17,7 +25,8 @@ module TypedEAV
         validate_mode!(mode)
         return TypedEAV::Field::Base.where(entity_type: entity_type) if mode == :all_partitions
 
-        validate_tuple!(scope, parent_scope)
+        raise ArgumentError, ORPHAN_PARENT_MESSAGE unless ScopeTuple.invariant_satisfied?(scope, parent_scope)
+
         TypedEAV::Field::Base.for_entity(entity_type, scope: scope, parent_scope: parent_scope)
       end
 
@@ -26,18 +35,56 @@ module TypedEAV
       def effective_fields_by_name(entity_type:, scope: nil, parent_scope: nil, mode: :partition)
         fields = visible_fields(entity_type: entity_type, scope: scope, parent_scope: parent_scope, mode: mode)
         if mode == :all_partitions
-          TypedEAV::HasTypedEAV.definitions_multimap_by_name(fields)
+          definitions_multimap_by_name(fields)
         else
-          TypedEAV::HasTypedEAV.definitions_by_name(fields)
+          definitions_by_name(fields)
         end
       end
 
+      # Indexes field definitions by name with deterministic three-way
+      # collision resolution: when global (scope=NULL, parent_scope=NULL),
+      # scope-only (scope set, parent_scope=NULL), and full-triple (both set)
+      # fields share a name, the most-specific row wins.
+      #
+      # Sort key `[scope.nil? ? 0 : 1, parent_scope.nil? ? 0 : 1]` orders rows:
+      #   [0, 0] global              (least specific) -> comes first
+      #   [1, 0] scope-only          (middle)
+      #   [1, 1] full triple         (most specific)  -> comes last
+      #
+      # `index_by(&:name)` keeps the LAST entry on duplicate keys (Rails
+      # convention via `Array#to_h`), so most-specific wins. The two-key sort
+      # extends the prior "scoped beats global" rule into "two-key beats
+      # one-key beats global" without changing the index_by-last-wins
+      # mechanism. The `(scope=NULL, parent_scope=NOT NULL)` slot is
+      # unreachable by construction (orphan-parent invariant in Field::Base),
+      # so the ordering is exhaustive across the three valid shapes.
+      #
+      # Shared by the class-query path (FilterQuery / BulkRead / EntityQuery)
+      # and the instance path (HasTypedEAV::InstanceMethods#typed_eav_defs_by_name)
+      # so the two cannot drift. Lives on Partition because partition-tuple
+      # precedence is a partition concept.
+      def definitions_by_name(defs)
+        defs.to_a
+            .sort_by { |d| [d.scope.nil? ? 0 : 1, d.parent_scope.nil? ? 0 : 1] }
+            .index_by(&:name)
+      end
+
+      # Indexes field definitions by name into a multi-map (one name ->
+      # array of fields). Used by the class-query path under
+      # `TypedEAV.unscoped { }`, where the same field name may legitimately
+      # exist across multiple tenant partitions and we must OR-across all
+      # matching field_ids per filter rather than collapse to a single row.
+      def definitions_multimap_by_name(defs)
+        defs.to_a.group_by(&:name)
+      end
+
       # All sections visible from the same tuple as field definitions.
       def visible_sections(entity_type:, scope: nil, parent_scope: nil, mode: :partition)
         validate_mode!(mode)
         return TypedEAV::Section.where(entity_type: entity_type) if mode == :all_partitions
 
-        validate_tuple!(scope, parent_scope)
+        raise ArgumentError, ORPHAN_PARENT_MESSAGE unless ScopeTuple.invariant_satisfied?(scope, parent_scope)
+
         TypedEAV::Section.for_entity(entity_type, scope: scope, parent_scope: parent_scope)
       end
 
@@ -52,13 +99,6 @@ module TypedEAV
 
         raise ArgumentError, "Unknown partition mode: #{mode.inspect}. Expected :partition or :all_partitions."
       end
-
-      def validate_tuple!(scope, parent_scope)
-        return if parent_scope.blank?
-        return if scope.present?
-
-        raise ArgumentError, "parent_scope cannot be set when scope is blank"
-      end
     end
   end
 end

data/lib/typed_eav/query_builder.rb

@@ -44,13 +44,12 @@ module TypedEAV
                 "Supported operators: #{supported.map { |o| ":#{o}" }.join(", ")}"
         end
 
-        # Phase 05: route the operator to its physical column via field-side
-        # dispatch. Single-cell types (every built-in as of Phase 04) return
-        # `value_column` for every operator — BC-safe. Multi-cell types
-        # (Phase 05 Currency) route operators like `:eq` (amount) and
-        # `:currency_eq` (currency code) to different columns. See
-        # ColumnMapping#operator_column.
-        col = field.storage_contract.query_column(operator)
+        # Route the operator to its physical column via the field-class
+        # dispatch. Single-cell types return `value_columns.first` for every
+        # operator — BC-safe. Multi-cell types (Currency) route operators
+        # like `:eq` (amount) and `:currency_eq` (currency code) to
+        # different columns. See `Field::TypedStorage.operator_column`.
+        col = field.class.operator_column(operator)
         arel_col = values_table[col]
 
         base = value_scope(field)

data/lib/typed_eav/scope_tuple.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  # Localized semantics for the `(scope, parent_scope)` tuple.
+  #
+  # Five files used to smear tuple shape/coercion/invariant logic across
+  # themselves (`lib/typed_eav.rb`, `Config`, `Partition`,
+  # `HasTypedEav#resolve_scope`, `Field::Base#for_entity`). This module
+  # gathers them in one place:
+  #
+  # - `normalize_permissive(value)` — the v0.1.x-BC scalar-friendly coercer
+  #   used by the `with_scope` block surface and by callers that already
+  #   know they may receive a loose value (single scalar, AR record, or
+  #   2-element Array). Mirrors what `TypedEAV.normalize_scope` did before
+  #   this refactor; the public method is now a 1-line BC alias to this.
+  #
+  # - `normalize_strict(value)` — the contract-surface coercer used by
+  #   `TypedEAV.current_scope` when consuming a configured
+  #   `Config.scope_resolver` return. Bare scalars / 1-element / 3-element
+  #   Arrays raise `ArgumentError` — this is the Phase-1 strict-contract
+  #   chokepoint that makes a misshaped resolver fail loudly instead of
+  #   silently coercing.
+  #
+  # - `invariant_satisfied?(scope, parent_scope)` — Boolean orphan-parent
+  #   check. Returns `false` only when `parent_scope` is present and
+  #   `scope` is blank (the dead-letter shape: a parent-scope predicate
+  #   with no scope predicate). Each caller picks its own response policy
+  #   (raise / AR error / silent narrow) on a `false` result; this helper
+  #   never raises.
+  #
+  # The split between permissive and strict normalization is the Phase-1
+  # asymmetric contract preserved verbatim: `with_scope` block input is
+  # BC-permissive (scalars are sugar for `[scalar, nil]`), `scope_resolver`
+  # callable return is strict (scalars are a contract violation).
+  module ScopeTuple
+    class << self
+      # BC-permissive normalizer for `with_scope` block input and explicit
+      # tuple inputs. Always returns either `nil` or a 2-element tuple
+      # `[scope, parent_scope]` where each element is a `String` or `nil`.
+      #
+      # Accepted inputs:
+      #
+      # - `nil`                                → `nil` (sentinel: nothing resolved).
+      # - `[a, b]` (2-element Array)           → `[normalize_one(a), normalize_one(b)]`.
+      #   Canonical Phase-1 input shape. `[scope, nil]` is the "scope-only"
+      #   tuple; `[nil, "ps1"]` (orphan-parent) is intentionally accepted at
+      #   this layer — orphan-parent rejection happens at the calling site
+      #   (Field validator → AR error, Partition query → ArgumentError,
+      #   resolve_scope → silent narrow). Keeping normalize permissive lets
+      #   tests construct invalid states intentionally.
+      # - any other value (scalar / AR record) → `[normalize_one(value), nil]`.
+      #   BC path for `with_scope(scalar)`: single-arg block usage continues
+      #   to mean "scope=scalar, parent_scope=nil".
+      def normalize_permissive(value)
+        return nil if value.nil?
+        return [normalize_one(value[0]), normalize_one(value[1])] if value.is_a?(Array) && value.size == 2
+
+        [normalize_one(value), nil]
+      end
+
+      # Strict-contract normalizer for `Config.scope_resolver` return values.
+      # Accepts ONLY `nil` or a 2-element Array. Bare scalars, 1-element
+      # Arrays, and 3-element Arrays raise `ArgumentError` quoting the bad
+      # input and pointing at the migration note — this is the chokepoint
+      # that makes a v0.1.x bare-scalar resolver fail loudly under Phase 1.
+      def normalize_strict(value)
+        return nil if value.nil?
+
+        unless value.is_a?(Array) && value.size == 2
+          raise ArgumentError,
+                "TypedEAV.config.scope_resolver must return a 2-element " \
+                "[scope, parent_scope] Array (or nil). Got: #{value.inspect}. " \
+                "v0.1.x resolvers returning a bare scalar must be updated — " \
+                "see CHANGELOG and the README migration note."
+        end
+
+        [normalize_one(value[0]), normalize_one(value[1])]
+      end
+
+      # Orphan-parent invariant predicate. Returns `true` when the tuple is
+      # internally coherent, `false` ONLY when `parent_scope` is present
+      # while `scope` is blank — the dead-letter shape that cannot match
+      # any row under the partition predicates.
+      #
+      # Truth table:
+      #   (nil, nil)     → true
+      #   ("t1", nil)    → true
+      #   ("t1", "w1")   → true
+      #   (nil, "w1")    → false
+      #   ("",  "w1")    → false   (empty string treated as blank on scope axis)
+      #   (nil, "")      → true    (empty string treated as blank on parent axis)
+      #
+      # Callers each pick their own response policy on a false result:
+      # `Partition.visible_fields` raises `ArgumentError`; `Field`'s model
+      # validator adds an AR error; `HasTypedEAV#resolve_scope` silently
+      # narrows the query. Returning a Boolean (not raising) keeps the
+      # per-caller decision local.
+      def invariant_satisfied?(scope, parent_scope)
+        return true if parent_scope.blank?
+
+        scope.present?
+      end
+
+      private
+
+      # Coerce a single scope slot (scalar or AR record) into a String or nil.
+      # The pre-refactor v0.1.x scalar-coercion preserved verbatim — applied
+      # per-slot now that scope is a tuple.
+      def normalize_one(value)
+        return nil if value.nil?
+
+        value.respond_to?(:id) ? value.id.to_s : value.to_s
+      end
+    end
+  end
+end

data/lib/typed_eav/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TypedEAV
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/typed_eav/versioning/subscriber.rb

@@ -77,12 +77,13 @@ module TypedEAV
         private
 
         def write_version_row(value, change_type, context)
-          # Build before_value / after_value snapshots through the field
-          # storage contract. Single-cell types produce one-key snapshots;
-          # multi-cell types like Currency produce one key per typed cell.
-          storage = value.field.storage_contract
-          before_value = storage.before_snapshot(value, change_type)
-          after_value  = storage.after_snapshot(value, change_type)
+          # Build before_value / after_value snapshots directly off the
+          # field's `Field::TypedStorage` helpers. Single-cell types produce
+          # one-key snapshots; multi-cell types like Currency produce one
+          # key per typed cell.
+          field = value.field
+          before_value = field.before_snapshot(value, change_type)
+          after_value  = field.after_snapshot(value, change_type)
 
           # CRITICAL: for :destroy events, write `value_id: nil`.
           # By the time `after_commit on: :destroy` fires, the parent row

data/lib/typed_eav.rb

@@ -14,14 +14,16 @@ module TypedEAV
   autoload :Config
   autoload :Registry
   autoload :HasTypedEAV
+  autoload :EntityQuery
+  autoload :FilterQuery
+  autoload :BulkRead
   autoload :BulkWrite
   autoload :Partition
   autoload :QueryBuilder
   autoload :SchemaPortability
   autoload :EventDispatcher
-  autoload :FieldStorageContract
-  autoload :CurrencyStorageContract
   autoload :CSVMapper
+  autoload :ScopeTuple
   autoload :ValueVersion
   autoload :Versioned
   autoload :Versioning
@@ -92,31 +94,16 @@ module TypedEAV
 
       stack = Thread.current[THREAD_SCOPE_STACK]
       # The stack stores tuples already (with_scope normalized on push), so
-      # reads bypass normalize_scope entirely — no risk of double-coercion.
+      # reads bypass coercion entirely — no risk of double-normalization.
       return stack.last if stack.present?
 
-      # Resolver-callable strict-contract path. We deliberately do NOT pass
-      # the raw return value through `normalize_scope`, because that helper
-      # is permissive (`scalar` → `[scalar, nil]`) for `with_scope` block BC.
-      # Routing the resolver through it would silently swallow a contract
-      # violation by a custom resolver returning a bare scalar.
-      raw = Config.scope_resolver&.call
-      return nil if raw.nil?
-
-      unless raw.is_a?(Array) && raw.size == 2
-        raise ArgumentError,
-              "TypedEAV.config.scope_resolver must return a 2-element " \
-              "[scope, parent_scope] Array (or nil). Got: #{raw.inspect}. " \
-              "v0.1.x resolvers returning a bare scalar must be updated — " \
-              "see CHANGELOG and the README migration note."
-      end
-
-      # Tuple shape verified — normalize each slot through the same scalar
-      # coercion that `normalize_scope` uses on the with_scope path. We pass
-      # the verified 2-element Array through normalize_scope (which is one
-      # of its accepted input shapes) to produce the canonical
-      # `[String|nil, String|nil]` tuple.
-      normalize_scope(raw)
+      # Resolver-callable strict-contract path. We route through
+      # `ScopeTuple.normalize_strict`, which raises `ArgumentError` on any
+      # shape other than `nil` or a 2-element Array — most importantly on
+      # the v0.1.x bare-scalar shape. The strict raise is the chokepoint
+      # that makes a misshaped resolver fail loudly; the BC-shim
+      # (silent coercion) alternative was rejected during Phase 1 design.
+      ScopeTuple.normalize_strict(Config.scope_resolver&.call)
     end
 
     # Run the block with `value` as the ambient scope, restoring the prior
@@ -143,7 +130,7 @@ module TypedEAV
     # the resolver-callable contract rejects bare scalars.
     def with_scope(value)
       stack = (Thread.current[THREAD_SCOPE_STACK] ||= [])
-      stack.push(normalize_scope(value))
+      stack.push(ScopeTuple.normalize_permissive(value))
       yield
     ensure
       stack&.pop
@@ -207,48 +194,20 @@ module TypedEAV
     end
 
     # BC-permissive normalizer for `with_scope` block input and explicit
-    # tuple inputs. Always returns either `nil` or a 2-element tuple
+    # tuple inputs. 1-line alias to `ScopeTuple.normalize_permissive` —
+    # the implementation moved during the 0.3.0 ScopeTuple extraction
+    # (issue #10), but the public method/return-shape stays as a v0.2.x BC
+    # surface. Always returns either `nil` or a 2-element tuple
     # `[scope, parent_scope]` where each element is a `String` or `nil`.
     #
-    # Accepted inputs:
-    #
-    # - `nil`                          → `nil` (sentinel: nothing resolved).
-    # - `[a, b]` (2-element Array)     → `[normalize_one(a), normalize_one(b)]`.
-    #   This is the canonical Phase-1 input shape; callers that already have
-    #   a tuple (a custom resolver, a future `with_scope([s, ps])`) pass it
-    #   through unchanged. `[scope, nil]` is the canonical "scope-only" tuple.
-    #   `[nil, "ps1"]` (orphan-parent) is intentionally accepted at this
-    #   layer — orphan-parent rejection happens in the model validator
-    #   added by plans 03/04, NOT here. Keeping normalize permissive lets
-    #   tests construct invalid states intentionally.
-    # - any other value (scalar / AR record) → `[normalize_one(value), nil]`.
-    #   This is the BC path for `with_scope(scalar)` — single-arg block usage
-    #   continues to mean "scope=scalar, parent_scope=nil".
-    #
     # ## NOT a contract chokepoint for resolver returns
     #
     # `current_scope` deliberately does NOT route a custom-resolver return
-    # value through this helper, because the bare-scalar passthrough above
-    # would silently coerce a contract violation. Resolver shape is checked
-    # in `current_scope` BEFORE this helper is called. This split — strict
-    # on the resolver-callable surface, permissive on the with_scope block
-    # surface — is the Phase 1 design.
-    def normalize_scope(value)
-      return nil if value.nil?
-      return [normalize_one(value[0]), normalize_one(value[1])] if value.is_a?(Array) && value.size == 2
-
-      [normalize_one(value), nil]
-    end
-
-    private
-
-    # Coerce a single scope slot (scalar or AR record) into a String or nil.
-    # The previous v0.1.x scalar-coercion lives here unchanged — we just
-    # apply it per-slot now that scope is a tuple.
-    def normalize_one(value)
-      return nil if value.nil?
-
-      value.respond_to?(:id) ? value.id.to_s : value.to_s
-    end
+    # through this helper — it routes through `ScopeTuple.normalize_strict`
+    # instead — because the bare-scalar passthrough here would silently
+    # coerce a contract violation. This split (strict on the resolver-
+    # callable surface, permissive on the with_scope block surface) is the
+    # Phase-1 asymmetric contract.
+    def normalize_scope(value) = ScopeTuple.normalize_permissive(value)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: typed_eav
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - dchuk
@@ -68,12 +68,15 @@ files:
 - app/models/typed_eav/field/json.rb
 - app/models/typed_eav/field/long_text.rb
 - app/models/typed_eav/field/multi_select.rb
+- app/models/typed_eav/field/optionable.rb
 - app/models/typed_eav/field/percentage.rb
+- app/models/typed_eav/field/range_bounded.rb
 - app/models/typed_eav/field/reference.rb
 - app/models/typed_eav/field/select.rb
 - app/models/typed_eav/field/text.rb
 - app/models/typed_eav/field/text_array.rb
 - app/models/typed_eav/field/url.rb
+- app/models/typed_eav/field/validated_string.rb
 - app/models/typed_eav/option.rb
 - app/models/typed_eav/section.rb
 - app/models/typed_eav/value.rb
@@ -133,19 +136,22 @@ files:
 - lib/generators/typed_eav/scaffold/templates/views/typed_eav/values/inputs/_text_array.html.erb
 - lib/generators/typed_eav/scaffold/templates/views/typed_eav/values/inputs/_url.html.erb
 - lib/typed_eav.rb
+- lib/typed_eav/bulk_read.rb
 - lib/typed_eav/bulk_write.rb
-- lib/typed_eav/column_mapping.rb
 - lib/typed_eav/config.rb
 - lib/typed_eav/csv_mapper.rb
-- lib/typed_eav/currency_storage_contract.rb
 - lib/typed_eav/engine.rb
+- lib/typed_eav/entity_query.rb
 - lib/typed_eav/event_dispatcher.rb
-- lib/typed_eav/field_storage_contract.rb
+- lib/typed_eav/field/typed_storage.rb
+- lib/typed_eav/filter_query.rb
 - lib/typed_eav/has_typed_eav.rb
+- lib/typed_eav/has_typed_eav/instance_methods.rb
 - lib/typed_eav/partition.rb
 - lib/typed_eav/query_builder.rb
 - lib/typed_eav/registry.rb
 - lib/typed_eav/schema_portability.rb
+- lib/typed_eav/scope_tuple.rb
 - lib/typed_eav/version.rb
 - lib/typed_eav/versioned.rb
 - lib/typed_eav/versioning.rb

data/lib/typed_eav/column_mapping.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module TypedEAV
-  # Maps field types to their native database column on the values table.
-  #
-  # This is the core concept borrowed from Relaticle's hybrid EAV:
-  # instead of serializing everything into a jsonb blob, each value
-  # type gets its own column so the database can natively index,
-  # sort, and enforce constraints.
-  #
-  # Usage in field type classes:
-  #
-  #   class TypedEAV::Field::Integer < TypedEAV::Field::Base
-  #     value_column :integer_value
-  #   end
-  #
-  # The value model reads this to know which column to read/write.
-  # The query builder reads this to know which column to filter on.
-  # ActiveRecord handles all type casting automatically via the
-  # column's registered ActiveRecord::Type.
-  module ColumnMapping
-    extend ActiveSupport::Concern
-
-    DEFAULT_OPERATORS_BY_COLUMN = {
-      boolean_value: %i[eq not_eq is_null is_not_null],
-      string_value: %i[eq not_eq contains not_contains starts_with ends_with is_null is_not_null],
-      text_value: %i[eq not_eq contains not_contains starts_with ends_with is_null is_not_null],
-      integer_value: %i[eq not_eq gt gteq lt lteq between is_null is_not_null],
-      decimal_value: %i[eq not_eq gt gteq lt lteq between is_null is_not_null],
-      date_value: %i[eq not_eq gt gteq lt lteq between is_null is_not_null],
-      datetime_value: %i[eq not_eq gt gteq lt lteq between is_null is_not_null],
-      json_value: %i[contains is_null is_not_null],
-    }.freeze
-    FALLBACK_OPERATORS = %i[eq not_eq is_null is_not_null].freeze
-
-    class_methods do
-      # Declare which typed column this field type stores its value in.
-      def value_column(column_name = nil)
-        unless column_name
-          return @value_column || raise(NotImplementedError,
-                                        "#{name} must declare `value_column :column_name`")
-        end
-
-        @value_column = column_name.to_sym
-      end
-
-      # All typed columns this field type stores its value across. Defaults to
-      # `[value_column]` for single-cell types — every built-in field type as
-      # of Phase 04 returns a one-element Array via this default. Phase 05
-      # Currency overrides this to return `[:decimal_value, :string_value]`
-      # (two-cell type: amount + currency code).
-      #
-      # Phase 04 versioning's snapshot logic iterates `value_columns` to build
-      # the jsonb {col_name => value} hash. Phase 04 also fixes the
-      # `Value#_dispatch_value_change_update` filter to use `value_columns.any?`
-      # instead of the singular `value_column` — forward-compatible with
-      # multi-cell types so a Currency change on the second cell alone still
-      # fires the :update event (Scout §3 / Discrepancy D3).
-      #
-      # The default delegates to `value_column` (the singular), so subclasses
-      # that haven't declared `value_column :col_name` raise the same
-      # NotImplementedError they always did when `value_columns` is invoked.
-      # This matches the existing contract — `value_column`'s raise is the
-      # "subclass must declare its column" enforcement; `value_columns`
-      # inherits that enforcement transparently.
-      def value_columns
-        [value_column]
-      end
-
-      # Which physical column this operator acts on. Defaults to `value_column`
-      # for single-cell field types — every built-in type as of Phase 04
-      # inherits the default and returns the same column for every supported
-      # operator.
-      #
-      # Multi-cell field types (Phase 05: Currency) override this to route
-      # different operators to different columns. For example, Currency stores
-      # `{amount, currency}` across `decimal_value` + `string_value`; the
-      # `:eq` operator targets amount (`decimal_value`); the `:currency_eq`
-      # operator targets currency code (`string_value`).
-      #
-      # Called from `QueryBuilder.filter` AFTER the
-      # `supported_operators.include?(operator)` validation gate, so this
-      # method is only invoked with operators the field explicitly supports.
-      # Subclasses overriding for unsupported operators is a programming
-      # error caught by the gate, not by this method.
-      #
-      # The unused `operator` parameter is intentional in the default —
-      # subclasses use it to dispatch.
-      def operator_column(_operator)
-        value_column
-      end
-
-      # All operators this field type supports for querying.
-      # Subclasses can override to restrict or extend.
-      def supported_operators
-        @supported_operators || default_operators_for(value_column)
-      end
-
-      def operators(*ops)
-        @supported_operators = ops.map(&:to_sym)
-      end
-
-      private
-
-      def default_operators_for(col)
-        DEFAULT_OPERATORS_BY_COLUMN.fetch(col, FALLBACK_OPERATORS)
-      end
-    end
-  end
-end

data/lib/typed_eav/currency_storage_contract.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module TypedEAV
-  # Storage contract for Field::Currency's two-cell value shape.
-  class CurrencyStorageContract < FieldStorageContract
-    VALUE_COLUMNS = %i[decimal_value string_value].freeze
-    AMOUNT_COLUMN = :decimal_value
-    CURRENCY_COLUMN = :string_value
-
-    def self.value_columns
-      VALUE_COLUMNS
-    end
-
-    def self.query_column(operator)
-      operator == :currency_eq ? CURRENCY_COLUMN : AMOUNT_COLUMN
-    end
-
-    delegate :value_columns, :query_column, to: :class
-
-    def read(value_record)
-      amount = value_record[AMOUNT_COLUMN]
-      currency = value_record[CURRENCY_COLUMN]
-      return nil if amount.nil? && currency.nil?
-
-      { amount: amount, currency: currency }
-    end
-
-    def write(value_record, casted)
-      if casted.nil?
-        value_record[AMOUNT_COLUMN] = nil
-        value_record[CURRENCY_COLUMN] = nil
-      else
-        value_record[AMOUNT_COLUMN] = casted[:amount]
-        value_record[CURRENCY_COLUMN] = casted[:currency]
-      end
-    end
-
-    def apply_default(value_record)
-      default = field.default_value
-      return unless default.is_a?(Hash)
-
-      value_record[AMOUNT_COLUMN] = default[:amount] || default["amount"]
-      value_record[CURRENCY_COLUMN] = default[:currency] || default["currency"]
-    end
-  end
-end

data/lib/typed_eav/field_storage_contract.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module TypedEAV
-  # One field-owned seam for native typed-column storage behavior.
-  #
-  # The contract intentionally delegates to the existing field type hooks so
-  # custom field authors keep the same public extension points while callers
-  # stop knowing which pieces belong together.
-  class FieldStorageContract
-    def initialize(field)
-      @field = field
-    end
-
-    def value_columns
-      field.class.value_columns
-    end
-
-    def query_column(operator)
-      field.class.operator_column(operator)
-    end
-
-    def read(value_record)
-      field.read_value(value_record)
-    end
-
-    def write(value_record, casted)
-      field.write_value(value_record, casted)
-    end
-
-    def apply_default(value_record)
-      field.apply_default_to(value_record)
-    end
-
-    def changed?(value_record)
-      value_columns.any? { |column| value_record.saved_change_to_attribute?(column) }
-    end
-
-    def before_snapshot(value_record, change_type)
-      case change_type.to_sym
-      when :create
-        {}
-      when :update
-        value_columns.to_h do |column|
-          [column.to_s, value_record.attribute_before_last_save(column.to_s)]
-        end
-      when :destroy
-        value_columns.to_h { |column| [column.to_s, value_record[column]] }
-      else
-        raise ArgumentError, "Unsupported change_type: #{change_type.inspect}"
-      end
-    end
-
-    def after_snapshot(value_record, change_type)
-      case change_type.to_sym
-      when :create, :update
-        value_columns.to_h { |column| [column.to_s, value_record[column]] }
-      when :destroy
-        {}
-      else
-        raise ArgumentError, "Unsupported change_type: #{change_type.inspect}"
-      end
-    end
-
-    private
-
-    attr_reader :field
-  end
-end