typed_eav 0.1.0 → 0.2.1

data/lib/typed_eav/versioning/subscriber.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  module Versioning
+    # The Phase 04 internal subscriber. Conditionally registered with
+    # EventDispatcher.register_internal_value_change at engine boot via
+    # `TypedEAV::Versioning.register_if_enabled`. When registered, runs
+    # at slot 0 of the value-change subscriber chain.
+    #
+    # ## Contract
+    #
+    # `call(value, change_type, context)` — called by EventDispatcher.
+    # Returns nil (return value is ignored by EventDispatcher; the
+    # method's job is the side effect of writing a ValueVersion row).
+    #
+    # Two-gate short-circuit (the master switch is enforced at
+    # registration time, NOT here — when off, this callable is never
+    # registered):
+    #   1. `value.field` is nil → return nil (orphan guard).
+    #   2. `TypedEAV.registry.versioned?(value.entity_type) != true` →
+    #      return nil.
+    #
+    # ## Why a class method (not a class-with-state)
+    #
+    # The subscriber holds NO instance state — it's a stateless function
+    # of (value, change_type, context, gem state). A module method is
+    # cheaper to register (single proc reference, no allocation per call)
+    # and easier to mock in specs (`allow(Subscriber).to receive(:call)`).
+    # If future versions need per-call state (e.g., batching), the call
+    # body can construct an instance internally without API change.
+    #
+    # ## Snapshot logic
+    #
+    # The before_value / after_value hashes are keyed by typed-column
+    # name (locked in 04-CONTEXT.md). For each column in
+    # `field.class.value_columns`:
+    #   - :create → after = value[col]; before key absent (empty hash).
+    #   - :update → before = value.attribute_before_last_save(col);
+    #               after = value[col].
+    #   - :destroy → before = value[col] (still in-memory on the
+    #               destroyed record per Phase 03 P04 live-validation);
+    #               after key absent.
+    # Column names are stringified for jsonb storage so query patterns
+    # like `WHERE before_value->>'integer_value' = '42'` work uniformly
+    # regardless of how the subscriber wrote them.
+    #
+    # ## Actor resolution
+    #
+    # `TypedEAV.config.actor_resolver&.call` returns an AR record,
+    # scalar, or nil. We coerce via the same `respond_to?(:id) ? .id.to_s
+    # : .to_s` pattern as lib/typed_eav.rb:239-243 (normalize_one). nil
+    # flows through as nil (the typed_eav_value_versions.changed_by
+    # column is nullable per 04-CONTEXT.md §"actor_resolver returning
+    # nil").
+    module Subscriber
+      class << self
+        # Public entry point. EventDispatcher calls this with the locked
+        # 3-arg signature `(value, change_type, context)`.
+        #
+        # NOTE: there is NO `Config.versioning` gate here. The subscriber
+        # is only registered with EventDispatcher when `Config.versioning`
+        # was true at engine `config.after_initialize` time (see
+        # `TypedEAV::Versioning.register_if_enabled`, invoked from
+        # lib/typed_eav/engine.rb's `config.after_initialize` block). If
+        # versioning is off, the subscriber is never registered and never
+        # reached. The remaining gates are:
+        #   1. field-presence (orphan guard — Value's field_id may have
+        #      been NULLed by Phase 02's ON DELETE SET NULL cascade).
+        #   2. per-entity opt-in (Registry.versioned?).
+        def call(value, change_type, context)
+          return unless value.field
+          return unless TypedEAV.registry.versioned?(value.entity_type)
+
+          write_version_row(value, change_type, context)
+        end
+
+        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)
+
+          # CRITICAL: for :destroy events, write `value_id: nil`.
+          # By the time `after_commit on: :destroy` fires, the parent row
+          # in `typed_eav_values` has already been deleted (Postgres
+          # commits the DELETE before invoking after_commit callbacks).
+          # The FK is `ON DELETE SET NULL`, but at the moment we INSERT
+          # the version row, Postgres validates the FK against the
+          # current state of typed_eav_values — which no longer contains
+          # the parent. Writing `value.id` (still readable in-memory on
+          # the destroyed AR record) would FK-fail at INSERT.
+          #
+          # The audit trail for destroy events stays queryable via:
+          #   - entity_type + entity_id (host record identity)
+          #   - field_id (Field is NOT destroyed by Value destruction)
+          #   - before_value (snapshot of the columns at destroy time)
+          # `field_id` remains populated because destroying a Value does
+          # not destroy its Field — `value.field_id` is a live reference.
+          #
+          # For :create and :update events, `value_id: value.id` is
+          # correct (parent row exists at after_commit time).
+          version_value_id = change_type == :destroy ? nil : value.id
+
+          # Phase 06 bulk-operations correlation tag. Two delivery paths:
+          #
+          # 1. PER-VALUE SNAPSHOT (preferred). Plan 06-05's
+          #    `bulk_set_typed_eav_values` stamps `value.pending_version_group_id`
+          #    on each affected Value object BEFORE `record.save`, INSIDE
+          #    the per-record `with_context` block. Reading the snapshot
+          #    here (not `current_context`) guarantees the UUID survives
+          #    the outer-transaction `after_commit` boundary — by the time
+          #    we run, the lexical `with_context` block has unwound and
+          #    `current_context` would be empty, but the per-Value ivar
+          #    persists. Mirrors the existing in-memory ivar pattern at
+          #    `app/models/typed_eav/value.rb:92-123` (`@cast_was_invalid`).
+          #    Locked at 06-CONTEXT.md line 26 — savepoints per record
+          #    inside an outer transaction, no relaxation of the structure.
+          #
+          # 2. CONTEXT FALLBACK. Non-bulk callers may still wrap a single
+          #    write in `TypedEAV.with_context(version_group_id: uuid) { ... }`
+          #    (e.g., a script correlating one update with one external
+          #    request id). For those paths the Value ivar is unset; the
+          #    `||` falls through to `context[:version_group_id]`. Also
+          #    used as the belt-and-suspenders fallback for any future
+          #    after_commit-inside-savepoint dispatch path that bulk writes
+          #    might leverage.
+          #
+          # When neither path supplies a UUID the column (added in
+          # `db/migrate/20260506000001`) stays NULL — backward-compatible:
+          # unchanged subscribers and unchanged callers continue to work.
+          TypedEAV::ValueVersion.create!(
+            value_id: version_value_id,
+            field_id: value.field_id,
+            entity_type: value.entity_type,
+            entity_id: value.entity_id,
+            changed_by: resolve_actor,
+            before_value: before_value,
+            after_value: after_value,
+            context: context.to_h, # frozen → unfrozen jsonb-serializable hash
+            version_group_id: value.pending_version_group_id || context[:version_group_id],
+            change_type: change_type.to_s,
+            changed_at: Time.current,
+          )
+        end
+
+        def resolve_actor
+          actor = TypedEAV.config.actor_resolver&.call
+          return nil if actor.nil?
+
+          # Same coercion as lib/typed_eav.rb:239-243 (normalize_one):
+          # AR record → id.to_s; scalar → to_s.
+          actor.respond_to?(:id) ? actor.id.to_s : actor.to_s
+        end
+      end
+    end
+  end
+end

data/lib/typed_eav/versioning.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module TypedEAV
+  # Phase 04 versioning namespace. Houses the Subscriber that writes
+  # TypedEAV::ValueVersion rows in response to Value lifecycle events
+  # dispatched by EventDispatcher.
+  #
+  # ## Architecture
+  #
+  # - TypedEAV::Versioning::Subscriber.call(value, change_type, context)
+  #   is conditionally registered with
+  #   EventDispatcher.register_internal_value_change at engine boot via
+  #   `TypedEAV::Versioning.register_if_enabled`, which is invoked from
+  #   the `config.after_initialize` block in lib/typed_eav/engine.rb.
+  #   When TypedEAV.config.versioning is false (default), the helper
+  #   returns early — no callable is added to the dispatcher chain.
+  #   When true, the subscriber registers and runs FIRST in the value-
+  #   change subscriber chain (slot 0 by `after_initialize` block
+  #   declaration order — Phase 07 will declare its matview block LATER
+  #   in the same engine to keep matview at slot ≥ 1).
+  #
+  # - The subscriber is gated by TWO checks at call time (both must
+  #   pass for a version row to be written):
+  #     1. value.field is non-nil (orphan guard — Value's field_id may
+  #        have been NULLed by Phase 02's ON DELETE SET NULL cascade).
+  #     2. TypedEAV.registry.versioned?(value.entity_type) == true
+  #        (per-entity opt-in via has_typed_eav versioned: true or
+  #        include TypedEAV::Versioned).
+  #   The `Config.versioning` master switch is NOT re-checked inside
+  #   the callable — when false, the subscriber is never registered in
+  #   the first place.
+  #
+  # - Errors raised by Subscriber.call PROPAGATE per the EventDispatcher
+  #   internal-vs-user error policy (03-CONTEXT.md §User-callback error
+  #   policy). Versioning corruption must be loud — silent failure
+  #   leaves the audit log inconsistent with the live row.
+  #
+  # ## Public API surface
+  #
+  # The subscriber itself is gem-internal — apps do not call it directly.
+  # The public API is:
+  #   - `TypedEAV.config.versioning = true` — master switch.
+  #   - `has_typed_eav versioned: true` (or `include TypedEAV::Versioned`) —
+  #     per-entity opt-in.
+  #   - `TypedEAV.config.actor_resolver = -> { ... }` — actor identification.
+  #   - `TypedEAV.with_context(actor: ..., source: ...) { ... }` — request-
+  #     scoped audit context.
+  #   - `Value#history` and `Value#revert_to(version)` (plan 04-03).
+  module Versioning
+    # CRITICAL: declare nested autoload for Subscriber explicitly.
+    # The top-level `autoload :Versioning` in lib/typed_eav.rb only resolves
+    # this namespace shell — it does NOT recursively autoload nested
+    # constants. Without the explicit declaration below, the engine's
+    # config.after_initialize block (which references
+    # `TypedEAV::Versioning::Subscriber.method(:call)`) raises
+    # `NameError: uninitialized constant TypedEAV::Versioning::Subscriber`
+    # at boot time, breaking every host that enables versioning.
+    autoload :Subscriber, "typed_eav/versioning/subscriber"
+
+    # Conditionally register the Subscriber with EventDispatcher's internal
+    # value-change subscriber chain. Called by the engine's
+    # `config.after_initialize` block (lib/typed_eav/engine.rb).
+    #
+    # Extracted into a class method (not inlined inside the after_initialize
+    # block) for testability: specs can call this against a freshly-cleared
+    # `EventDispatcher.value_change_internals` to exercise both branches
+    # (versioning on/off) in-process, without booting the engine. The
+    # slot-0 regression spec (plan 04-03 P03) and the zero-overhead
+    # verification spec (this plan, subscriber_spec engine-boot block) both
+    # rely on this seam.
+    #
+    # Idempotent — safe to call multiple times. Calling twice with
+    # versioning on results in exactly ONE entry in
+    # `EventDispatcher.value_change_internals`. The idempotency check uses
+    # `Array#include?` against `Subscriber.method(:call)`; `Method#==`
+    # compares receiver+name (semantic equality), so two fresh
+    # `Subscriber.method(:call)` instances compare equal even though they
+    # are different Method objects. The engine block runs this exactly
+    # once per boot in production; the idempotency guard protects future
+    # code paths that might re-invoke for any reason.
+    #
+    # When `TypedEAV.config.versioning` is false (default), this method is
+    # a no-op: zero callable in `value_change_internals`, zero per-write
+    # dispatch cost. That is the locked CONTEXT line 17 contract.
+    def self.register_if_enabled
+      return unless TypedEAV.config.versioning
+
+      method_ref = TypedEAV::Versioning::Subscriber.method(:call)
+      return if TypedEAV::EventDispatcher.value_change_internals.include?(method_ref)
+
+      TypedEAV::EventDispatcher.register_internal_value_change(method_ref)
+    end
+  end
+end

data/lib/typed_eav.rb

@@ -14,15 +14,35 @@ module TypedEAV
   autoload :Config
   autoload :Registry
   autoload :HasTypedEAV
+  autoload :BulkWrite
+  autoload :Partition
   autoload :QueryBuilder
+  autoload :SchemaPortability
+  autoload :EventDispatcher
+  autoload :FieldStorageContract
+  autoload :CurrencyStorageContract
+  autoload :CSVMapper
+  autoload :ValueVersion
+  autoload :Versioned
+  autoload :Versioning
 
   # Raised when a model declared `has_typed_eav scope_method: ...` but no
   # scope can be resolved at query time and `config.require_scope` is truthy.
   class ScopeRequired < StandardError; end
 
-  THREAD_SCOPE_STACK = :typed_eav_scope_stack
-  THREAD_UNSCOPED    = :typed_eav_unscoped
-  private_constant :THREAD_SCOPE_STACK, :THREAD_UNSCOPED
+  THREAD_SCOPE_STACK   = :typed_eav_scope_stack
+  THREAD_UNSCOPED      = :typed_eav_unscoped
+  THREAD_CONTEXT_STACK = :typed_eav_context_stack
+  private_constant :THREAD_SCOPE_STACK, :THREAD_UNSCOPED, :THREAD_CONTEXT_STACK
+
+  # Shared frozen Hash returned by `current_context` when no `with_context`
+  # block is active. Using a single shared instance avoids allocating a new
+  # Hash on every empty-context dispatch (the hot path inside
+  # `EventDispatcher.dispatch_value_change` when no with_context block is
+  # active). Per locked decision (03-CONTEXT.md, pre-Lead resolution):
+  # always-frozen, never bare {}.
+  EMPTY_FROZEN_CONTEXT = {}.freeze
+  private_constant :EMPTY_FROZEN_CONTEXT
 
   class << self
     def config
@@ -34,27 +54,96 @@ module TypedEAV
 
     def registry = Registry
 
-    # Current ambient scope value. Resolution order:
+    # Current ambient scope tuple. Resolution order:
     #   1. Inside `unscoped { }`      → nil (hard bypass)
-    #   2. Innermost `with_scope(v)`  → v
+    #   2. Innermost `with_scope(v)`  → tuple stored on the stack
     #   3. Configured `scope_resolver` callable
     #   4. nil
     #
-    # Returns a string (via normalize), or nil when nothing resolves.
+    # ## Return-value contract (Phase 1, breaking change from v0.1.x)
+    #
+    # Returns either `nil` (no ambient scope) or a 2-element Array
+    # `[scope, parent_scope]` where each element is a String or nil.
+    # Never returns a bare scalar.
+    #
+    # ## scope_resolver contract (strict)
+    #
+    # The resolver lambda configured via `Config.scope_resolver = ->{ ... }`
+    # MUST return either `nil` or a 2-element Array. Both elements may be
+    # nil. Any other shape — most importantly a bare scalar (the v0.1.x
+    # shape) — raises `ArgumentError` directly inside `current_scope`,
+    # BEFORE any normalization is applied. We deliberately do NOT auto-coerce
+    # a bare-scalar return into `[scalar, nil]`; the BC-shim path was
+    # rejected during Phase 1 design (see `.vbw-planning/phases/01-*/01-CONTEXT.md`
+    # § "Deferred Ideas"). The strict raise is the chokepoint that makes
+    # the breaking change visible — silent coercion here would hide a
+    # contract violation in user-supplied resolver code.
+    #
+    # `parent_scope` non-nil + `scope` nil (orphan parent) is invalid; the
+    # check belongs to model-level validators added by plans 03/04, NOT
+    # to this resolver layer. The resolver is a contract surface, not a
+    # validation surface.
+    #
+    # `with_scope(scalar)` block API remains BC-permissive and is a
+    # DIFFERENT surface from the resolver-callable contract — see
+    # `with_scope` doc and `normalize_scope` doc.
     def current_scope
       return nil if Thread.current[THREAD_UNSCOPED]
 
       stack = Thread.current[THREAD_SCOPE_STACK]
-      return normalize_scope(stack.last) if stack.present?
-
-      normalize_scope(Config.scope_resolver&.call)
+      # The stack stores tuples already (with_scope normalized on push), so
+      # reads bypass normalize_scope entirely — no risk of double-coercion.
+      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)
     end
 
     # Run the block with `value` as the ambient scope, restoring the prior
     # stack on exit (exception-safe). Nests cleanly.
+    #
+    # ## Accepted input shapes (BC-permissive — public block API)
+    #
+    # - `with_scope("t1")`            — single-arg BC: pushes `["t1", nil]`.
+    # - `with_scope(ar_record)`       — pushes `[ar_record.id.to_s, nil]`.
+    # - `with_scope(["t1", "ps1"])`   — Phase 1 tuple form: pushes the tuple.
+    # - `with_scope(nil)`             — pushes nil (sentinel: no scope).
+    #
+    # The single-arg signature `with_scope(value)` keeps its v0.1.x meaning:
+    # `scope = value`, `parent_scope = nil`. Apps that have only ever passed
+    # a scalar do not need to update on upgrade.
+    #
+    # The internal stack stores normalized tuples (or nil), NOT raw values,
+    # so `current_scope` can return `stack.last` directly without further
+    # coercion.
+    #
+    # NOTE: this is the BC-permissive surface. The strict-contract surface
+    # is `Config.scope_resolver` — see `current_scope` doc. Two surfaces,
+    # two contracts: `with_scope`'s scalar-OK behavior is BC-preserving;
+    # the resolver-callable contract rejects bare scalars.
     def with_scope(value)
       stack = (Thread.current[THREAD_SCOPE_STACK] ||= [])
-      stack.push(value)
+      stack.push(normalize_scope(value))
       yield
     ensure
       stack&.pop
@@ -75,10 +164,89 @@ module TypedEAV
       !!Thread.current[THREAD_UNSCOPED]
     end
 
-    # Coerce resolver/with_scope/explicit-kwarg inputs into the string shape
-    # stored in the `scope` column. Accepts raw scalars or AR records.
+    # Run the block with `kwargs` merged into the ambient event context,
+    # restoring the prior stack on exit (exception-safe). Nests cleanly with
+    # shallow per-key merge — outer keys remain visible inside nested blocks
+    # unless overridden by name; deep-merge of nested Hash values is NOT
+    # promised.
+    #
+    # The pre-merged hash is FROZEN before being pushed so callbacks invoked
+    # downstream (`Config.on_value_change` user proc, internal subscribers)
+    # cannot mutate context for the current or outer blocks. Without freeze,
+    # a callback that did `ctx[:added] = true` would corrupt the stack for
+    # every wrapping block on the same thread.
+    #
+    # ## Why **kwargs and not positional Hash
+    #
+    # `def with_context(**kwargs)` enforces the keyword-syntax call form.
+    # Per Ruby 3.0+ kwargs/Hash separation, `TypedEAV.with_context({ foo: 1 })`
+    # raises ArgumentError ("wrong number of arguments") — the only accepted
+    # form is `TypedEAV.with_context(foo: 1)`. Without **kwargs, callers
+    # could push arbitrary Hash shapes (including nested Arrays or non-symbol
+    # keys) that wouldn't merge cleanly across nesting and wouldn't match
+    # the documented context shape that hooks read.
+    #
+    # See `with_scope` (above) for the parallel ensure-pop pattern. Mirrors
+    # `with_scope`'s shape exactly except for: (a) **kwargs vs positional
+    # value, (b) merge-into-outer-on-push vs replace-on-push.
+    def with_context(**kwargs)
+      stack  = (Thread.current[THREAD_CONTEXT_STACK] ||= [])
+      merged = (stack.last || EMPTY_FROZEN_CONTEXT).merge(kwargs).freeze
+      stack.push(merged)
+      yield
+    ensure
+      stack&.pop
+    end
+
+    # Returns the current thread's top-of-stack context Hash, or a shared
+    # frozen empty Hash when no `with_context` block is active. The return
+    # value is ALWAYS frozen — callers can rely on read-only semantics
+    # regardless of whether a block is active. NEVER returns nil.
+    def current_context
+      Thread.current[THREAD_CONTEXT_STACK]&.last || EMPTY_FROZEN_CONTEXT
+    end
+
+    # 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)]`.
+    #   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

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification
 name: typed_eav
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
-- Darrin Chuk
+- dchuk
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
 description: Add dynamic custom fields to ActiveRecord models at runtime using native
   database typed columns instead of jsonb blobs. Hybrid EAV with real indexes, real
   types, real query performance.
@@ -40,17 +54,22 @@ files:
 - app/models/typed_eav/field/base.rb
 - app/models/typed_eav/field/boolean.rb
 - app/models/typed_eav/field/color.rb
+- app/models/typed_eav/field/currency.rb
 - app/models/typed_eav/field/date.rb
 - app/models/typed_eav/field/date_array.rb
 - app/models/typed_eav/field/date_time.rb
 - app/models/typed_eav/field/decimal.rb
 - app/models/typed_eav/field/decimal_array.rb
 - app/models/typed_eav/field/email.rb
+- app/models/typed_eav/field/file.rb
+- app/models/typed_eav/field/image.rb
 - app/models/typed_eav/field/integer.rb
 - app/models/typed_eav/field/integer_array.rb
 - 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/percentage.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
@@ -58,7 +77,12 @@ files:
 - app/models/typed_eav/option.rb
 - app/models/typed_eav/section.rb
 - app/models/typed_eav/value.rb
+- app/models/typed_eav/value_version.rb
 - db/migrate/20260330000000_create_typed_eav_tables.rb
+- db/migrate/20260430000000_add_parent_scope_to_typed_eav_partitions.rb
+- db/migrate/20260501000000_add_cascade_policy_to_typed_eav_fields.rb
+- db/migrate/20260505000000_create_typed_eav_value_versions.rb
+- db/migrate/20260506000001_add_version_group_id_to_typed_eav_value_versions.rb
 - lib/generators/typed_eav/install/install_generator.rb
 - lib/generators/typed_eav/scaffold/scaffold_generator.rb
 - lib/generators/typed_eav/scaffold/templates/config/initializers/typed_eav.rb
@@ -109,13 +133,23 @@ 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_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/event_dispatcher.rb
+- lib/typed_eav/field_storage_contract.rb
 - lib/typed_eav/has_typed_eav.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/version.rb
+- lib/typed_eav/versioned.rb
+- lib/typed_eav/versioning.rb
+- lib/typed_eav/versioning/subscriber.rb
 homepage: https://github.com/dchuk/typed_eav
 licenses:
 - MIT