eav_field 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad4c68d056641acdb72729aa099b55285fb948de48ed41511fdb2472f1a6292c
+  data.tar.gz: 74be0f6ec80589ee374f5604fe347d97a5e07bf4933ab7bc5b6ac8cbe7dc8302
+SHA512:
+  metadata.gz: afedd539adaa261644b67ab9078edb02e845a1189abfaa31e975d74bc5a8284b361da247564fdc0149cca96812ba75bafd23d0f55c0f5eacc07fa0ff974f6bf6
+  data.tar.gz: 359ba7b4509ed4f67723922a37c8849c5ca15ce5ef78abd7f63dbca9ada9040ccea75c165b8359564e95fbdad40cd7a811e6e92b5cac94ef4532cbf9787013db

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 — 2026-10-09
+
+- Add `has_eav_fields` for existing Active Record models.
+- Persist model-scoped definitions and polymorphic typed values.
+- Support string, text, integer, decimal, boolean, date, datetime, and JSON fields.
+- Add defaults, required-field validation, transactional autosave, and equality queries.
+- Provide a Rails installation generator with bigint, UUID, and string owner ID options.
+- Add Minitest integration coverage, RuboCop configuration, and a Rails CI matrix.
+- Release under the MIT License.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mouad Imam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,139 @@
+# EavField
+
+EavField adds an entity-attribute-value (EAV) system to existing Active Record models. Your model is the entity; database records define its dynamic attributes; separate records store their typed values. Adding a field does not require changing the owner's table.
+
+Requires Ruby 3.2+ and Active Record/Railties 7.1–8.x. The gem constrains JSON to 2.x for compatibility with these Rails versions. The development suite uses SQLite and Minitest.
+
+## Install in a Rails application
+
+Add the gem to your application's `Gemfile`:
+
+```ruby
+gem "eav_field", "~> 0.1.0"
+```
+
+Then run from the Rails application's root:
+
+```sh
+bundle install
+bin/rails generate eav_field:install
+bin/rails db:migrate
+```
+
+For local gem development, replace the dependency with `gem "eav_field", path: "../eav_field"`, adjusting the path to this checkout.
+
+The generator creates `eav_field_definitions` and `eav_field_values`. Owner IDs use `bigint` by default. For PostgreSQL UUID owners, generate with `--entity-id-type=uuid`; for string IDs, use `--entity-id-type=string`. All participating models must have IDs compatible with the selected column type.
+
+Opt in on any existing model:
+
+```ruby
+class Product < ApplicationRecord
+  has_eav_fields
+end
+```
+
+## Define and use fields
+
+Create definitions after migrating, for example in a Rails console or data migration:
+
+```ruby
+Product.define_eav_field(:color, type: :string, default: "black")
+Product.define_eav_field(:weight, type: :decimal)
+Product.define_eav_field(:available, type: :boolean, required: true, default: false)
+Product.define_eav_field(:metadata, type: :json)
+
+product = Product.new(name: "Chair")
+product.eav_fields = { color: "blue", weight: "1.25", metadata: { origin: "MA" } }
+product.save!
+
+product.reload.eav_fields[:color]     # => "blue"
+product.eav_fields[:weight]           # => BigDecimal("1.25")
+product.eav_fields[:available]        # => false
+product.eav_fields.to_h               # All defined fields, including defaults.
+
+product.eav_fields[:color] = "green"
+product.save!                        # Saves field changes with the owner.
+product.update!(eav_fields: { weight: "1.5" })
+```
+
+Both symbol and string keys work. Hash assignment merges fields; omitted fields keep their values. `read_eav_field`, `write_eav_field`, and `delete_eav_field` are also available directly on the owner.
+
+Definitions are scoped to the model's polymorphic base class. Different models can use the same field name with different types. STI subclasses share their base model's definitions. Names use lowercase letters, digits, and underscores, starting with a letter, such as `shipping_weight`.
+
+Definitions persist across application restarts. Keep definition creation out of model class bodies. Duplicate definitions raise `ActiveRecord::RecordInvalid`; for repeatable seeds, check `Product.eav_field_definitions.exists?(name: "color")` before defining a field.
+
+## Types and validation
+
+| Type | Accepted values |
+| --- | --- |
+| `string` | Strings up to 255 characters |
+| `text` | Longer strings |
+| `integer` | Signed 64-bit integers or whole-number strings |
+| `decimal` | Finite numbers or numeric strings; precision 30, scale 10 |
+| `boolean` | `true`, `false`, `1`, `0`, or their lowercase string forms |
+| `date` | `Date` objects or `YYYY-MM-DD` strings |
+| `datetime` | Time objects or ISO 8601 strings with an explicit offset; stored in UTC |
+| `json` | JSON-compatible objects, arrays, and scalar values; keys become strings |
+
+Unknown fields raise `EavField::UnknownField`. Invalid assignments raise `EavField::InvalidValue` immediately. Every value in a batch is checked before any field is changed. Required fields participate in owner validation, and `false` and `0` count as present. Datetimes use microsecond precision. [SQLite's numeric storage](https://sqlite.org/datatype3.html#type_affinity) can lose precision for large decimal values; validate decimal behavior against your application's database.
+
+Missing value records return the definition's default without creating a row. Assigning `nil` stores an explicit null override. Delete the override to restore the default:
+
+```ruby
+product.eav_fields.delete(:color)
+product.save!
+product.eav_fields[:color] # => "black"
+```
+
+Definition names, types, and entity scopes are immutable after creation. Defaults and `required` flags can be updated through `Product.eav_field_definitions`. Adding a required definition affects validation of existing owners on their next save.
+
+## Query fields
+
+```ruby
+Product.with_eav_field(:color, "blue")
+Product.where(name: "Chair").with_eav_field(:weight, "1.25")
+Product.with_eav_field(:color, "blue").with_eav_field(:available, false)
+```
+
+These return chainable Active Record relations with typed equality comparisons. Matching defaults include owners without a stored override; explicit null overrides remain distinct from non-null defaults. Queries use persisted values. JSON equality raises `EavField::UnsupportedQuery` because JSON comparisons differ between database adapters.
+
+## Persistence and lifecycle
+
+The gem uses [Rails polymorphic associations](https://guides.rubyonrails.org/association_basics.html#polymorphic-associations) and [association autosave](https://api.rubyonrails.org/classes/ActiveRecord/AutosaveAssociation.html) to validate and save values in the owner's transaction. Unique indexes prevent duplicate definitions and duplicate values for an owner and field. The definition foreign key cascades deletion of its values.
+
+The EAV tables and participating models must use the same Active Record database connection. Multiple databases and composite owner primary keys are outside the current scope.
+
+Destroying an owner deletes its values and preserves definitions. Destroying a definition removes that field's stored values for all owners. Active Record operations that bypass callbacks, such as `delete_all`, also bypass owner cleanup. Polymorphic owner references have no database foreign key; use `destroy`/`destroy_all` when cleanup is required.
+
+Definitions are shared across a model rather than scoped per tenant. The gem does not add controllers, an administration UI, or authorization policies.
+
+## Develop and verify
+
+Run from this repository's root:
+
+```sh
+bundle install
+bundle exec rake test       # Minitest, including real Rails installation and rollback.
+bundle exec rubocop         # Lint and check formatting.
+bundle exec rubocop -a      # Apply safe formatting corrections.
+bundle exec rake            # Tests and lint together.
+bundle exec rake build      # Build pkg/eav_field-0.1.0.gem.
+```
+
+To check a different Rails series:
+
+```sh
+RAILS_VERSION="~> 7.1.0" bundle update
+RAILS_VERSION="~> 7.1.0" bundle exec rake test
+bundle update              # Restore the default Rails 8.1 development bundle.
+```
+
+Implementation lives in `lib/eav_field/`; generators and migration templates live in `lib/generators/`; tests live in `test/` and use `*_test.rb` filenames. Use two-space Ruby indentation and the committed RuboCop configuration. CI covers Rails 7.1, 7.2, 8.0, and 8.1 on Ruby 3.2 and 3.3.
+
+## Releases
+
+Update `lib/eav_field/version.rb` and `CHANGELOG.md`, run the tests and lint, then build the gem. Publish the reviewed package to RubyGems and create a matching `v<VERSION>` Git tag and GitHub release. Release packages are generated in `pkg/` and excluded from Git.
+
+## License and support
+
+Released under the [MIT License](LICENSE). Report bugs and request features through [GitHub Issues](https://github.com/Mouados-byte/eav_field/issues). Published versions are available on [RubyGems](https://rubygems.org/gems/eav_field).

data/lib/eav_field/attribute_definition.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module EavField
+  class AttributeDefinition < ActiveRecord::Base
+    self.table_name = "eav_field_definitions"
+
+    has_many :values, class_name: "EavField::Value", inverse_of: :attribute_definition, dependent: :destroy
+
+    validates :entity_type, presence: true, length: { maximum: 255 }
+    validates :name, presence: true, length: { maximum: 100 },
+      format: { with: /\A[a-z][a-z0-9_]*\z/ }, uniqueness: { scope: :entity_type }
+    validates :data_type, inclusion: { in: Types::COLUMNS.keys }
+    validates :required, inclusion: { in: [ true, false ] }
+
+    before_validation :normalize_default
+    validate :identity_is_immutable, on: :update
+
+    def cast(value)
+      Types.cast(data_type, value)
+    end
+
+    def default
+      cast(default_value)
+    end
+
+    private
+
+    def normalize_default
+      return unless Types::COLUMNS.key?(data_type)
+
+      self.default_value = Types.dump(data_type, default_value)
+    rescue InvalidValue => error
+      errors.add(:default_value, error.message)
+    end
+
+    def identity_is_immutable
+      %w[ entity_type name data_type ].each do |attribute|
+        errors.add(attribute, "cannot change after creation") if will_save_change_to_attribute?(attribute)
+      end
+    end
+  end
+end

data/lib/eav_field/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EavField
+  class Error < StandardError; end
+  class UnknownField < Error; end
+  class InvalidValue < Error; end
+  class UnsupportedQuery < Error; end
+  class NotEnabled < Error; end
+end

data/lib/eav_field/field_set.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EavField
+  class FieldSet
+    include Enumerable
+
+    def initialize(owner)
+      @owner = owner
+    end
+
+    def [](name)
+      @owner.read_eav_field(name)
+    end
+
+    def []=(name, value)
+      @owner.write_eav_field(name, value)
+    end
+
+    def delete(name)
+      @owner.delete_eav_field(name)
+    end
+
+    def fetch(name, *args, &block)
+      to_h.fetch(name, *args, &block)
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+
+      to_h.each(&block)
+    end
+
+    def to_h
+      @owner.eav_fields_snapshot
+    end
+
+    def keys
+      to_h.keys
+    end
+  end
+end

data/lib/eav_field/has_fields.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module EavField
+  module HasFields
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def has_eav_fields
+        association = reflect_on_association(:eav_values)
+        return if association&.class_name == "EavField::Value"
+        raise NotEnabled, "#{name} already defines an eav_values association" if association
+
+        has_many :eav_values, -> { includes(:attribute_definition) }, as: :entity,
+          class_name: "EavField::Value", inverse_of: :entity, autosave: true, dependent: :destroy
+        validate :validate_required_eav_fields
+      end
+
+      def eav_field_definitions
+        ensure_eav_fields_enabled!
+        AttributeDefinition.where(entity_type: polymorphic_name)
+      end
+
+      def define_eav_field(name, type:, required: false, default: nil)
+        eav_field_definitions.create!(name: name.to_s, data_type: type.to_s,
+          required: required, default_value: default)
+      end
+
+      def find_eav_field!(name)
+        eav_field_definitions.find_by(name: name.to_s) ||
+          raise(UnknownField, "Unknown EAV field #{name.inspect} for #{self.name}")
+      end
+
+      def with_eav_field(name, value)
+        definition = find_eav_field!(name)
+        raise UnsupportedQuery, "JSON field equality is not portable across databases" if definition.data_type == "json"
+
+        cast_value = definition.cast(value)
+        entries = Value.where(attribute_definition_id: definition.id, entity_type: polymorphic_name)
+        matching = entries.where(Types.column_for(definition.data_type) => cast_value).select(:entity_id)
+        result = where(primary_key => matching)
+        if cast_value == definition.default
+          result = result.or(where.not(primary_key => entries.select(:entity_id)))
+        end
+        result
+      end
+
+      private
+
+      def ensure_eav_fields_enabled!
+        return if reflect_on_association(:eav_values)&.class_name == "EavField::Value"
+
+        raise NotEnabled, "Call has_eav_fields in #{name} before using EAV fields"
+      end
+    end
+
+    def eav_fields
+      self.class.send(:ensure_eav_fields_enabled!)
+      FieldSet.new(self)
+    end
+
+    # Hash assignment merges fields; omitted fields retain their current values.
+    def eav_fields=(fields)
+      raise ArgumentError, "eav_fields must be a hash" unless fields.respond_to?(:each_pair)
+
+      assignments = fields.each_pair.map do |name, value|
+        definition = self.class.find_eav_field!(name)
+        [ definition, definition.cast(value) ]
+      end
+      assignments.each { |definition, value| assign_eav_value(definition, value) }
+    end
+
+    def read_eav_field(name)
+      definition = self.class.find_eav_field!(name)
+      entry = eav_entry_for(definition)
+      entry ? entry.value : definition.default
+    end
+
+    def write_eav_field(name, value)
+      definition = self.class.find_eav_field!(name)
+      assign_eav_value(definition, definition.cast(value))
+      value
+    end
+
+    # Removing an override restores the definition's default on the next read.
+    def delete_eav_field(name)
+      definition = self.class.find_eav_field!(name)
+      entry = eav_entry_for(definition)
+      previous_value = entry ? entry.value : definition.default
+      entry&.mark_for_destruction
+      previous_value
+    end
+
+    def eav_fields_snapshot
+      entries = eav_values.reject { |entry| entry.marked_for_destruction? || entry.destroyed? }
+        .index_by(&:attribute_definition_id)
+      self.class.eav_field_definitions.each_with_object({}.with_indifferent_access) do |definition, fields|
+        entry = entries[definition.id]
+        fields[definition.name] = entry ? entry.value : definition.default
+      end
+    end
+
+    private
+
+    def eav_entry_for(definition)
+      eav_values.detect do |entry|
+        entry.attribute_definition_id == definition.id && !entry.marked_for_destruction? && !entry.destroyed?
+      end
+    end
+
+    def assign_eav_value(definition, value)
+      entry = eav_entry_for(definition)
+      unless entry
+        deleted_entry = eav_values.detect do |candidate|
+          candidate.attribute_definition_id == definition.id && candidate.persisted? && candidate.marked_for_destruction?
+        end
+        entry = deleted_entry.reload if deleted_entry
+      end
+      entry ||= eav_values.build(attribute_definition: definition)
+      entry.value = value
+    end
+
+    def validate_required_eav_fields
+      self.class.eav_field_definitions.where(required: true).each do |definition|
+        entry = eav_entry_for(definition)
+        value = entry ? entry.value : definition.default
+        errors.add("eav_fields.#{definition.name}", "can't be blank") if Types.missing?(value)
+      end
+    end
+  end
+end

data/lib/eav_field/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module EavField
+  class Railtie < Rails::Railtie
+    generators do
+      require "generators/eav_field/install/install_generator"
+    end
+  end
+end

data/lib/eav_field/types.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "time"
+
+module EavField
+  module Types
+    COLUMNS = {
+      "string" => "string_value",
+      "text" => "text_value",
+      "integer" => "integer_value",
+      "decimal" => "decimal_value",
+      "boolean" => "boolean_value",
+      "date" => "date_value",
+      "datetime" => "datetime_value",
+      "json" => "json_value"
+    }.freeze
+
+    module_function
+
+    def column_for(type)
+      COLUMNS.fetch(type.to_s) { raise InvalidValue, "Unsupported field type: #{type.inspect}" }
+    end
+
+    def cast(type, value)
+      column_for(type)
+      return if value.nil?
+
+      case type.to_s
+      when "string", "text"
+        raise TypeError unless value.is_a?(String)
+        raise RangeError if type.to_s == "string" && value.length > 255
+
+        value
+      when "integer"
+        cast_integer(value)
+      when "decimal"
+        cast_decimal(value)
+      when "boolean"
+        cast_boolean(value)
+      when "date"
+        cast_date(value)
+      when "datetime"
+        cast_datetime(value)
+      when "json"
+        cast_json(value)
+      end
+    rescue ArgumentError, TypeError, RangeError
+      raise InvalidValue, "#{value.inspect} is not a valid #{type} value"
+    end
+
+    def dump(type, value)
+      cast_value = cast(type, value)
+      return if cast_value.nil?
+
+      case type.to_s
+      when "decimal"
+        cast_value.to_s("F")
+      when "date"
+        cast_value.iso8601
+      when "datetime"
+        cast_value.iso8601(6)
+      else
+        cast_value
+      end
+    end
+
+    def missing?(value)
+      value != false && value.blank?
+    end
+
+    def cast_integer(value)
+      number = if value.is_a?(Integer)
+        value
+      elsif value.is_a?(String) && value.match?(/\A[+-]?\d+\z/)
+        Integer(value, 10)
+      else
+        raise TypeError
+      end
+      raise RangeError unless (-(2**63)...(2**63)).cover?(number)
+
+      number
+    end
+
+    def cast_decimal(value)
+      raise TypeError unless value.is_a?(String) || value.is_a?(Integer) || value.is_a?(Float) || value.is_a?(BigDecimal)
+
+      number = BigDecimal(value.to_s)
+      raise RangeError unless number.finite? && number.abs < 10**20
+      raise RangeError if number.to_s("F").split(".").last.length > 10
+
+      number
+    end
+
+    def cast_boolean(value)
+      return value if value == true || value == false
+      return value == 1 if value.is_a?(Integer) && [ 0, 1 ].include?(value)
+      return true if value.is_a?(String) && [ "true", "1" ].include?(value)
+      return false if value.is_a?(String) && [ "false", "0" ].include?(value)
+
+      raise TypeError
+    end
+
+    def cast_date(value)
+      return value.to_date if value.is_a?(Date)
+      raise TypeError unless value.is_a?(String) && value.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+
+      Date.iso8601(value)
+    end
+
+    def cast_datetime(value)
+      return value.getutc.round(6) if value.is_a?(Time)
+      return value.utc.round(6) if value.is_a?(ActiveSupport::TimeWithZone)
+      return Time.iso8601(value.iso8601(6)).utc if value.is_a?(DateTime)
+
+      unless value.is_a?(String) && value.match?(/\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?(?:Z|[+-]\d{2}:\d{2})\z/)
+        raise TypeError
+      end
+
+      Date.iso8601(value[0, 10])
+      Time.iso8601(value).utc.round(6)
+    end
+
+    def cast_json(value)
+      case value
+      when Hash
+        value.to_h do |key, item|
+          raise TypeError unless key.is_a?(String) || key.is_a?(Symbol)
+
+          [ key.to_s, cast_json(item) ]
+        end
+      when Array
+        value.map { |item| cast_json(item) }
+      when Float
+        raise RangeError unless value.finite?
+
+        value
+      when String, Integer, TrueClass, FalseClass, NilClass
+        value
+      else
+        raise TypeError
+      end
+    end
+  end
+end

data/lib/eav_field/value.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module EavField
+  class Value < ActiveRecord::Base
+    self.table_name = "eav_field_values"
+
+    belongs_to :attribute_definition, class_name: "EavField::AttributeDefinition", inverse_of: :values, optional: false
+    belongs_to :entity, polymorphic: true, inverse_of: :eav_values, optional: false
+
+    validates :attribute_definition_id, uniqueness: { scope: [ :entity_type, :entity_id ] }
+    validate :definition_matches_entity
+    validate :typed_columns_are_valid
+
+    def value
+      self[Types.column_for(attribute_definition.data_type)]
+    end
+
+    def value=(input)
+      cast_value = attribute_definition.cast(input)
+      Types::COLUMNS.each_value { |column| self[column] = nil }
+      self[Types.column_for(attribute_definition.data_type)] = cast_value
+    end
+
+    private
+
+    def definition_matches_entity
+      return unless entity && attribute_definition
+
+      unless entity.class.reflect_on_association(:eav_values) && entity.class.polymorphic_name == attribute_definition.entity_type
+        errors.add(:attribute_definition, "belongs to a different entity type")
+      end
+    end
+
+    def typed_columns_are_valid
+      return unless attribute_definition && Types::COLUMNS.key?(attribute_definition.data_type)
+
+      active_column = Types.column_for(attribute_definition.data_type)
+      if Types::COLUMNS.values.any? { |column| column != active_column && !self[column].nil? }
+        errors.add(:value, "must use only the column matching its field type")
+      end
+      attribute_definition.cast(value)
+      if attribute_definition.required? && Types.missing?(value)
+        errors.add(:value, "can't be blank")
+      end
+    rescue InvalidValue => error
+      errors.add(:value, error.message)
+    end
+  end
+end

data/lib/eav_field/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EavField
+  VERSION = "0.1.0"
+end

data/lib/eav_field.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_support/concern"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/hash/indifferent_access"
+
+require "eav_field/version"
+require "eav_field/errors"
+require "eav_field/types"
+require "eav_field/attribute_definition"
+require "eav_field/value"
+require "eav_field/field_set"
+require "eav_field/has_fields"
+
+ActiveSupport.on_load(:active_record) do
+  include EavField::HasFields
+end
+
+require "eav_field/railtie" if defined?(Rails::Railtie)

data/lib/generators/eav_field/install/install_generator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record/migration"
+
+module EavField
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+      desc "Create the EAV field definitions and values tables."
+
+      class_option :entity_id_type, type: :string, default: "bigint", enum: %w[ bigint uuid string ],
+        desc: "ID type of the existing models that will use EAV fields"
+
+      def copy_migration
+        migration_template "create_eav_field_tables.rb.tt", "db/migrate/create_eav_field_tables.rb"
+      end
+
+      private
+
+      def migration_version
+        "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
+      end
+    end
+  end
+end

data/lib/generators/eav_field/install/templates/create_eav_field_tables.rb.tt

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class CreateEavFieldTables < ActiveRecord::Migration[<%= migration_version %>]
+  def change
+    create_table :eav_field_definitions do |t|
+      t.string :entity_type, null: false
+      t.string :name, limit: 100, null: false
+      t.string :data_type, limit: 20, null: false
+      t.boolean :required, default: false, null: false
+      t.json :default_value
+      t.timestamps
+    end
+
+    add_index :eav_field_definitions, [ :entity_type, :name ], unique: true,
+      name: "index_eav_field_definitions_on_entity_and_name"
+
+    create_table :eav_field_values do |t|
+      t.references :attribute_definition, null: false,
+        foreign_key: { to_table: :eav_field_definitions, on_delete: :cascade }
+      t.string :entity_type, null: false
+      t.column :entity_id, :<%= options[:entity_id_type] %>, null: false
+      t.string :string_value
+      t.text :text_value
+      t.bigint :integer_value
+      t.decimal :decimal_value, precision: 30, scale: 10
+      t.boolean :boolean_value
+      t.date :date_value
+      t.datetime :datetime_value, precision: 6
+      t.json :json_value
+      t.timestamps
+    end
+
+    add_index :eav_field_values, [ :entity_type, :entity_id, :attribute_definition_id ], unique: true,
+      name: "index_eav_field_values_on_entity_and_definition"
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: eav_field
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mouad Imam
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+description: Add database-defined, validated, queryable fields to existing Rails models
+  without altering their tables.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/eav_field.rb
+- lib/eav_field/attribute_definition.rb
+- lib/eav_field/errors.rb
+- lib/eav_field/field_set.rb
+- lib/eav_field/has_fields.rb
+- lib/eav_field/railtie.rb
+- lib/eav_field/types.rb
+- lib/eav_field/value.rb
+- lib/eav_field/version.rb
+- lib/generators/eav_field/install/install_generator.rb
+- lib/generators/eav_field/install/templates/create_eav_field_tables.rb.tt
+homepage: https://github.com/Mouados-byte/eav_field
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/Mouados-byte/eav_field
+  documentation_uri: https://github.com/Mouados-byte/eav_field#readme
+  bug_tracker_uri: https://github.com/Mouados-byte/eav_field/issues
+  changelog_uri: https://github.com/Mouados-byte/eav_field/blob/v0.1.0/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Typed entity-attribute-value fields for Active Record models.
+test_files: []