activeitem 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7992e08eadef33c715ba67e3869454bca7cf174cae56e419982b81de608075c6
-  data.tar.gz: dc1e6e803c91bb774f7e0c2edf43f6ca744ac10221bba26b8a5a4a4d7466f425
+  metadata.gz: 652850a906bc798042da7b5c3ea1396aeef9775057ad1199030354cff2b24b73
+  data.tar.gz: 55001585d52f922c371cd6ca6cc61beef3f6f5ea98e4ca268d0bfe1e6ebf8d5a
 SHA512:
-  metadata.gz: ee3f192c4bc8d0ea583f85462cb28841092e0389ed7682b6cfec753f446b687174385f74b81fa58ddc411c34b7dea1fd348aeea243a1109b0ae1ae0915565036
-  data.tar.gz: f21580968c7db755fbc2c75e4cdb2cf8c9b3ab7f400a5a83954fb297215a78ec9adf4968f2ed3e526d771747c80460d50a8b7c23f70c6e2489a5d8e84f03b4a2
+  metadata.gz: 64fb13d70a43f1f6a5668c3e93b6e1f24ceec853ea6f7d9e974a7fd5b53c7a2f8b66e9d582d6f12d10498a892a10895712092b1bbcac4929c6cad86fc164d770
+  data.tar.gz: e6495e6752c6b8ffc0b8ef98451141ad8816fe069e4e33a40c7b65f45b4bf02981390bfab503149fce243e354d9842e1ce02bfb9f75f270af40dc5593d51ab5a

data/lib/active_item/associations.rb

@@ -14,6 +14,7 @@ module ActiveItem
 
     included do
       class_attribute :_associations, default: {}
+      class_attribute :_embedded_associations, default: {}
     end
 
     def check_dependent_associations
@@ -58,6 +59,11 @@ module ActiveItem
           return
         end
 
+        if options[:embedded]
+          define_has_many_embedded(association_name, options)
+          return
+        end
+
         class_name = options[:class_name] || name.to_s.singularize.camelize
         foreign_key = options[:foreign_key] || "#{self.name.underscore}_id"
         index_name = options[:index]
@@ -99,6 +105,59 @@ module ActiveItem
         end
       end
 
+      def define_has_many_embedded(association_name, options)
+        class_name = options[:class_name] || association_name.to_s.singularize.camelize
+
+        self._associations = _associations.merge(
+          association_name => {
+            type: :has_many_embedded, class_name: class_name
+          }
+        )
+
+        # Register the embedded association so serialization knows about it
+        self._embedded_associations = _embedded_associations.merge(
+          association_name => { class_name: class_name }
+        )
+
+        # Define dirty-tracking attribute for the embedded collection
+        define_attribute_methods association_name.to_s
+
+        # Accessor that returns an EmbeddedCollection
+        define_method(association_name) do
+          ivar = :"@_embedded_#{association_name}"
+          return instance_variable_get(ivar) if instance_variable_defined?(ivar)
+
+          target_class = safe_constantize_model(class_name)
+          collection = EmbeddedCollection.new(
+            owner: self,
+            association_name: association_name,
+            target_class: target_class,
+            records: []
+          )
+          instance_variable_set(ivar, collection)
+          collection
+        end
+
+        # Setter for replacing the embedded collection
+        define_method("#{association_name}=") do |records|
+          ivar = :"@_embedded_#{association_name}"
+          target_class = safe_constantize_model(class_name)
+          collection = EmbeddedCollection.new(
+            owner: self,
+            association_name: association_name,
+            target_class: target_class,
+            records: Array(records)
+          )
+          send("#{association_name}_will_change!")
+          instance_variable_set(ivar, collection)
+          collection
+        end
+
+        define_method(:"#{association_name}_count") do
+          send(association_name).count
+        end
+      end
+
       public
 
       def belongs_to(name, options = {})

data/lib/active_item/base.rb

@@ -16,6 +16,7 @@ module ActiveItem
     include ActiveModel::Dirty
     extend ActiveModel::Callbacks
     include Associations
+    include Embeddable
     include Logging
 
     define_model_callbacks :save, :create, :update, :destroy, :initialize, :validation
@@ -175,6 +176,7 @@ module ActiveItem
         record = allocate
         record.instance_variable_set(:@id, normalized_item[primary_key])
         record.send(:populate_attributes_from_item, normalized_item)
+        record.send(:populate_embedded_associations, normalized_item)
         record.instance_variable_set(:@new_record, false)
         record.instance_variable_set(:@mutations_from_database, nil)
         record.instance_variable_set(:@dbrecord, normalized_item)
@@ -289,7 +291,7 @@ module ActiveItem
     end
 
     def has_changes_to_save?
-      changed?
+      changed? || embedded_associations_changed?
     end
 
     def to_h
@@ -347,6 +349,8 @@ module ActiveItem
     end
 
     def save(validate: true)
+      return save_via_parent(validate: validate) if self.class.embedded? && !@_saving_via_parent
+
       return false if validate && !run_validations
 
       # If inside a transaction block, enroll this save in the transaction
@@ -377,12 +381,16 @@ module ActiveItem
     end
 
     def self.create(attributes = {})
+      raise_embedded_error!(:create) if respond_to?(:embedded?) && embedded?
+
       obj = new(attributes)
       obj.save
       obj
     end
 
     def self.create!(attributes = {})
+      raise_embedded_error!(:create!) if respond_to?(:embedded?) && embedded?
+
       obj = new(attributes)
       obj.save!
       obj
@@ -442,6 +450,8 @@ module ActiveItem
     end
 
     def destroy
+      return destroy_via_parent if self.class.embedded? && !@_destroying_via_parent
+
       # If inside a transaction block, enroll this destroy in the transaction
       return enroll_destroy_in_transaction if Transaction.active?
 
@@ -449,6 +459,8 @@ module ActiveItem
       return false if result == false
 
       true
+    rescue ActiveItem::EmbeddedModelError
+      raise
     rescue DeleteRestrictionError
       false
     rescue StandardError => e
@@ -552,10 +564,149 @@ module ActiveItem
 
     def run_validations
       context = new_record? ? :create : :update
-      valid?(context)
+      return false unless valid?(context)
+
+      # Cascade validations into embedded collections
+      validate_embedded_associations
+    end
+
+    # Hydrate embedded associations from a DynamoDB item hash.
+    def populate_embedded_associations(item)
+      self.class._embedded_associations.each do |assoc_name, config|
+        dynamo_key = self.class.to_dynamo_key(assoc_name.to_s)
+        raw_array = item[dynamo_key]
+        next unless raw_array.is_a?(Array)
+
+        target_class = safe_constantize_model(config[:class_name])
+        records = raw_array.map do |hash|
+          record = Embeddable.from_embedded_hash(target_class, hash)
+          record.instance_variable_set(:@_embedded_parent, self)
+          record
+        end
+
+        collection = EmbeddedCollection.new(
+          owner: self,
+          association_name: assoc_name,
+          target_class: target_class,
+          records: records
+        )
+        instance_variable_set(:"@_embedded_#{assoc_name}", collection)
+
+        # Snapshot for dirty tracking
+        instance_variable_set(:"@_embedded_#{assoc_name}_snapshot", serialize_embedded_snapshot(collection))
+      end
+    end
+
+    # Validate all embedded associations. Returns true if all valid, false otherwise.
+    def validate_embedded_associations
+      all_valid = true
+
+      self.class._embedded_associations.each_key do |assoc_name|
+        collection = send(assoc_name)
+        collection.each_with_index do |record, idx|
+          next if record.valid?
+
+          all_valid = false
+          record.errors.each do |error|
+            errors.add(:"#{assoc_name}[#{idx}].#{error.attribute}", error.message)
+          end
+        end
+      end
+
+      all_valid
+    end
+
+    # Run callbacks on embedded records during parent save.
+    def run_embedded_callbacks(callback_type)
+      self.class._embedded_associations.each_key do |assoc_name|
+        collection = send(assoc_name)
+        collection.each do |record|
+          record.instance_variable_set(:@_saving_via_parent, true)
+          record.run_callbacks(callback_type) { nil } if record.respond_to?(:run_callbacks, true)
+          record.instance_variable_set(:@_saving_via_parent, false)
+        end
+      end
+    end
+
+    # Delegate save from an embedded record to its parent.
+    # This allows `thing.save` and `thing.update(attrs)` to work
+    # by persisting through the parent record.
+    def save_via_parent(validate: true)
+      parent = instance_variable_get(:@_embedded_parent)
+      unless parent
+        raise ActiveItem::EmbeddedModelError,
+              "Cannot save #{self.class.name} — no parent record. " \
+              "Build embedded records through the parent's collection (e.g., parent.things.build)."
+      end
+
+      return false if validate && respond_to?(:valid?) && !valid?
+
+      parent.save(validate: validate)
+    end
+
+    # Delegate destroy from an embedded record to its parent.
+    # Removes itself from the parent's collection and saves the parent.
+    def destroy_via_parent
+      parent = instance_variable_get(:@_embedded_parent)
+      unless parent
+        raise ActiveItem::EmbeddedModelError,
+              "Cannot destroy #{self.class.name} — no parent record."
+      end
+
+      # Find which collection this record belongs to and remove it
+      self.class.superclass # ensure class is loaded
+      parent.class._embedded_associations.each do |assoc_name, config|
+        target_class = parent.send(:safe_constantize_model, config[:class_name])
+        next unless is_a?(target_class)
+
+        collection = parent.send(assoc_name)
+        collection.records.delete(self)
+        break
+      end
+
+      parent.save
+    end
+
+    # Snapshot the serialized state of an embedded collection for dirty comparison.
+    def serialize_embedded_snapshot(collection)
+      collection.map(&:to_embedded_hash)
+    end
+
+    # Check if any embedded collection has changed since load.
+    def embedded_associations_changed?
+      self.class._embedded_associations.any? do |assoc_name, _config|
+        current = send(assoc_name)
+        snapshot = instance_variable_get(:"@_embedded_#{assoc_name}_snapshot") || []
+        serialize_embedded_snapshot(current) != snapshot
+      end
+    end
+
+    # Update snapshots after a successful write so subsequent saves
+    # don't re-persist unchanged embedded data.
+    def snapshot_embedded_associations
+      self.class._embedded_associations.each_key do |assoc_name|
+        collection = send(assoc_name)
+        instance_variable_set(:"@_embedded_#{assoc_name}_snapshot", serialize_embedded_snapshot(collection))
+      end
+    end
+
+    # Detect the DynamoDB 400KB item size limit error and re-raise
+    # as a friendlier ActiveItem::ItemTooLargeError.
+    def raise_if_item_too_large(error)
+      return unless error.message.include?('Item size') || error.message.include?('item size') ||
+                    error.message.include?('400') || error.message.include?('exceeds')
+
+      raise ActiveItem::ItemTooLargeError.new(
+        model_name: self.class.name,
+        table: table_name,
+        original_error: error
+      )
     end
 
     def perform_create
+      run_embedded_callbacks(:create)
+      run_embedded_callbacks(:save)
+
       item = build_dynamodb_item
       item['createdAt'] = @created_at
       item['updatedAt'] = Time.now.utc.iso8601
@@ -568,10 +719,14 @@ module ActiveItem
         expression_attribute_names: { '#pk' => self.class.primary_key.to_s }
       )
 
+      snapshot_embedded_associations
       dynamo_logger.info("#{self.class.name} created (#{self.class.primary_key}: #{id})")
     rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
       errors.add(:id, 'already exists')
       false
+    rescue Aws::DynamoDB::Errors::ValidationException => e
+      raise_if_item_too_large(e)
+      raise
     rescue Aws::DynamoDB::Errors::AccessDeniedException => e
       raise ActiveItem::AccessDeniedError.new(model_name: self.class.name, table: table_name,
                                               operation: 'PutItem', original_error: e)
@@ -588,6 +743,15 @@ module ActiveItem
         item[dynamo_key] = value
       end
 
+      # Serialize embedded collections
+      self.class._embedded_associations.each_key do |assoc_name|
+        collection = send(assoc_name)
+        next if collection.nil? || collection.empty?
+
+        dynamo_key = self.class.to_dynamo_key(assoc_name.to_s)
+        item[dynamo_key] = collection.map(&:to_embedded_hash)
+      end
+
       item
     end
 
@@ -599,19 +763,32 @@ module ActiveItem
         attrs -= composed_attrs
       end
 
+      # Embedded associations are serialized separately in build_dynamodb_item
+      if self.class._embedded_associations.any?
+        embedded_names = self.class._embedded_associations.keys.map(&:to_s)
+        attrs -= embedded_names
+      end
+
       attrs
     end
 
     def perform_update
-      return if changes.empty?
+      embedded_changed = embedded_associations_changed?
+      return if changes.empty? && !embedded_changed
+
+      run_embedded_callbacks(:update) if embedded_changed
+      run_embedded_callbacks(:save) if embedded_changed
 
       update_parts = []
       remove_parts = []
       attr_values = {}
       attr_names = {}
+      idx = 0
 
-      changes.each_with_index do |(field, (_old_val, new_val)), idx|
+      changes.each do |field, (_old_val, new_val)|
         next if field == 'updated_at'
+        # Skip embedded association fields — handled separately below
+        next if self.class._embedded_associations.key?(field.to_sym)
 
         dynamo_key = self.class.to_dynamo_key(field)
         if new_val.nil?
@@ -622,6 +799,26 @@ module ActiveItem
           attr_names["#field#{idx}"] = dynamo_key
           attr_values[":val#{idx}"] = new_val
         end
+        idx += 1
+      end
+
+      # Serialize changed embedded associations into the update expression
+      self.class._embedded_associations.each_key do |assoc_name|
+        collection = send(assoc_name)
+        snapshot = instance_variable_get(:"@_embedded_#{assoc_name}_snapshot") || []
+        current_serialized = serialize_embedded_snapshot(collection)
+        next if current_serialized == snapshot
+
+        dynamo_key = self.class.to_dynamo_key(assoc_name.to_s)
+        if collection.empty?
+          remove_parts << "#field#{idx}"
+          attr_names["#field#{idx}"] = dynamo_key
+        else
+          update_parts << "#field#{idx} = :val#{idx}"
+          attr_names["#field#{idx}"] = dynamo_key
+          attr_values[":val#{idx}"] = current_serialized
+        end
+        idx += 1
       end
 
       update_parts << '#updatedAt = :updatedAt'
@@ -640,6 +837,10 @@ module ActiveItem
       params[:expression_attribute_names] = attr_names if attr_names.any?
 
       dynamodb.update_item(params)
+      snapshot_embedded_associations
+    rescue Aws::DynamoDB::Errors::ValidationException => e
+      raise_if_item_too_large(e)
+      raise
     rescue Aws::DynamoDB::Errors::AccessDeniedException => e
       raise ActiveItem::AccessDeniedError.new(model_name: self.class.name, table: table_name,
                                               operation: 'UpdateItem', original_error: e)

data/lib/active_item/composed_of.rb

@@ -67,7 +67,7 @@ module ActiveItem
     end
 
     def perform_update
-      return if changes.empty?
+      return if changes.empty? && !embedded_associations_changed?
 
       compositions = self.class.compositions
       return super if compositions.empty?

data/lib/active_item/embeddable.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ActiveItem
+  # Mixin for models that are stored embedded within a parent record
+  # rather than in their own DynamoDB table.
+  #
+  # Usage:
+  #   class Thing < ActiveItem::Base
+  #     self.embedded = true
+  #     attr_accessor :name, :weight
+  #   end
+  #
+  # Embedded models:
+  # - Cannot be queried directly (no table)
+  # - Cannot call find, where, all, count, etc.
+  # - Are serialized/deserialized by their parent
+  # - Still support validations, callbacks, and dirty tracking
+  module Embeddable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :embedded, default: false
+    end
+
+    class_methods do
+      def embedded?
+        embedded == true
+      end
+    end
+
+    # Instance methods — prevent direct save/destroy on embedded models
+    # are handled in Base#save and Base#destroy directly.
+
+    # Serialize this embedded record to a DynamoDB-compatible hash.
+    def to_embedded_hash
+      item = { 'id' => id || SecureRandom.uuid }
+
+      self.class.attribute_names.each do |attr_name|
+        next if %w[id dbrecord].include?(attr_name)
+
+        value = instance_variable_get("@#{attr_name}")
+        next if value.nil?
+
+        dynamo_key = self.class.to_dynamo_key(attr_name)
+        item[dynamo_key] = value
+      end
+
+      item['createdAt'] = @created_at if @created_at
+      item['updatedAt'] = @updated_at if @updated_at
+      item
+    end
+
+    # Hydrate an embedded record from a DynamoDB hash.
+    def self.from_embedded_hash(klass, hash)
+      record = klass.allocate
+      record.instance_variable_set(:@id, hash['id'])
+      record.instance_variable_set(:@new_record, false)
+      record.instance_variable_set(:@created_at, hash['createdAt'])
+      record.instance_variable_set(:@updated_at, hash['updatedAt'])
+
+      klass.attribute_names.each do |attr_name|
+        next if %w[id dbrecord].include?(attr_name)
+
+        value = nil
+        found = false
+        klass.dynamo_key_variants(attr_name).each do |key|
+          next unless hash.key?(key)
+
+          value = hash[key]
+          found = true
+          break
+        end
+
+        record.instance_variable_set("@#{attr_name}", value) if found
+      end
+
+      record.send(:clear_changes_information) if record.respond_to?(:clear_changes_information, true)
+      record
+    end
+  end
+end

data/lib/active_item/embedded_collection.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module ActiveItem
+  # In-memory collection for embedded model instances.
+  # Provides Enumerable access plus ActiveItem-flavored query methods
+  # (where, find, build, etc.) that operate on the already-loaded array.
+  class EmbeddedCollection
+    include Enumerable
+
+    attr_reader :records, :association_name, :owner, :target_class
+
+    def initialize(owner:, association_name:, target_class:, records: [])
+      @owner = owner
+      @association_name = association_name
+      @target_class = target_class
+      @records = records.dup
+    end
+
+    def each(&)
+      @records.each(&)
+    end
+
+    def length
+      @records.length
+    end
+    alias size length
+    alias count length
+
+    def empty?
+      @records.empty?
+    end
+
+    def any?(&block)
+      block ? @records.any?(&block) : @records.any?
+    end
+
+    def first
+      @records.first
+    end
+
+    def last
+      @records.last
+    end
+
+    def to_a
+      @records.dup
+    end
+
+    # In-memory find by ID.
+    def find(id)
+      record = @records.find { |r| r.id == id }
+      raise ActiveItem::RecordNotFound, "Couldn't find #{@target_class.name} with id '#{id}'" unless record
+
+      record
+    end
+
+    # In-memory filtering by attribute conditions.
+    # Returns a new EmbeddedCollection with matching records.
+    def where(conditions = {})
+      filtered = @records.select do |record|
+        conditions.all? do |attr, value|
+          record.send(attr) == value
+        end
+      end
+
+      self.class.new(
+        owner: @owner,
+        association_name: @association_name,
+        target_class: @target_class,
+        records: filtered
+      )
+    end
+
+    # Build a new embedded record, add it to the collection, and mark
+    # the parent as dirty.
+    def build(attributes = {})
+      record = @target_class.new(attributes)
+      record.instance_variable_set(:@id, SecureRandom.uuid) unless record.id
+      record.instance_variable_set(:@_embedded_parent, @owner)
+      @records << record
+      mark_owner_dirty!
+      record
+    end
+
+    # Build, validate, and persist by saving the parent.
+    # Matches ActiveRecord semantics where create! actually persists.
+    def create!(attributes = {})
+      record = build(attributes)
+      unless record.valid?
+        @records.delete(record)
+        mark_owner_dirty!
+        raise ActiveItem::RecordInvalid, record
+      end
+
+      @owner.save!
+      record
+    end
+
+    # Remove a record from the collection by reference or ID.
+    def delete(record_or_id)
+      record = record_or_id.is_a?(String) ? find(record_or_id) : record_or_id
+      @records.delete(record)
+      mark_owner_dirty!
+      record
+    end
+    alias destroy delete
+
+    # Replace the entire collection.
+    def replace(new_records)
+      @records = new_records.dup
+      mark_owner_dirty!
+      self
+    end
+
+    def <<(record)
+      record.instance_variable_set(:@_embedded_parent, @owner)
+      @records << record
+      mark_owner_dirty!
+      self
+    end
+    alias push <<
+
+    def inspect
+      "#<#{self.class.name} [#{@records.map(&:inspect).join(', ')}]>"
+    end
+
+    private
+
+    def mark_owner_dirty!
+      attr_name = @association_name.to_s
+      @owner.send("#{attr_name}_will_change!") if @owner.respond_to?("#{attr_name}_will_change!", true)
+    end
+  end
+end

data/lib/active_item/errors.rb

@@ -62,4 +62,24 @@ module ActiveItem
       super("Cannot delete record because dependent #{association_name} exist")
     end
   end
+
+  # Raised when attempting to perform table-level operations on an embedded
+  # model (one that has self.embedded = true and no DynamoDB table).
+  class EmbeddedModelError < StandardError; end
+
+  # Raised when a DynamoDB put/update fails because the item exceeds the
+  # 400KB size limit — typically due to large embedded collections.
+  class ItemTooLargeError < StandardError
+    attr_reader :model_name, :table
+
+    def initialize(model_name:, table:, original_error: nil)
+      @model_name = model_name
+      @table = table
+      msg = "Item exceeds DynamoDB's 400KB limit when saving #{model_name} to #{table}. " \
+            'The embedded collection(s) may have too many records. ' \
+            'Consider reducing the number of embedded items or moving them to a separate table.'
+      msg += " (Original: #{original_error.message})" if original_error
+      super(msg)
+    end
+  end
 end

data/lib/active_item/query_helpers.rb

@@ -7,6 +7,8 @@ module ActiveItem
   # counting, existence checks, and automatic GSI index detection.
   module QueryHelpers
     def find(id)
+      raise_embedded_error!(:find) if respond_to?(:embedded?) && embedded?
+
       record = get({ primary_key.to_s => id })
       raise ActiveItem::RecordNotFound, "Couldn't find #{name} with '#{primary_key}'=#{id}" unless record
 
@@ -170,6 +172,8 @@ module ActiveItem
     #   # Equivalent to: Customer.batch_find(['cust-1', 'cust-2', 'cust-3'])
     #
     def where(**conditions)
+      raise_embedded_error!(:where) if respond_to?(:embedded?) && embedded?
+
       # If no conditions, return a Relation that supports .not() chaining
       return Relation.new(self) if conditions.empty?
 
@@ -201,6 +205,8 @@ module ActiveItem
 
     # Returns a Relation for all records (enables chaining from .all)
     def all(limit: nil)
+      raise_embedded_error!(:all) if respond_to?(:embedded?) && embedded?
+
       if limit
         Relation.new(self, limit_value: limit)
       else
@@ -255,6 +261,8 @@ module ActiveItem
     #   Customer.count { |c| c.email.include?('@gmail.com') }  # => 15
     #
     def count(**conditions, &)
+      raise_embedded_error!(:count) if respond_to?(:embedded?) && embedded?
+
       if block_given?
         # Block provided - load all records and count with Ruby
         all.count(&)
@@ -288,6 +296,8 @@ module ActiveItem
     # @param id_or_conditions [String, Hash] Primary key value or attribute conditions
     # @return [Boolean] true if a record exists matching the conditions
     def exists?(id_or_conditions = nil, **conditions)
+      raise_embedded_error!(:exists?) if respond_to?(:embedded?) && embedded?
+
       # Handle single ID parameter: Customer.exists?('cust-123')
       return !!get({ primary_key.to_s => id_or_conditions }) if id_or_conditions.is_a?(String) && conditions.empty?
 
@@ -618,5 +628,11 @@ module ActiveItem
         }
       end
     end
+
+    def raise_embedded_error!(method_name)
+      raise ActiveItem::EmbeddedModelError,
+            "Cannot call .#{method_name} on #{name} because it is an embedded model " \
+            '(no DynamoDB table). Access embedded records through their parent association.'
+    end
   end
 end

data/lib/active_item/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveItem
-  VERSION = '0.0.19'
+  VERSION = '0.0.20'
 end

data/lib/activeitem.rb

@@ -7,6 +7,8 @@ require_relative 'active_item/errors'
 require_relative 'active_item/database_helpers'
 require_relative 'active_item/query_helpers'
 require_relative 'active_item/relation'
+require_relative 'active_item/embedded_collection'
+require_relative 'active_item/embeddable'
 require_relative 'active_item/associations'
 require_relative 'active_item/composed_of'
 require_relative 'active_item/validations'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeitem
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Andy Davis
@@ -160,6 +160,8 @@ files:
 - lib/active_item/composed_of.rb
 - lib/active_item/configuration.rb
 - lib/active_item/database_helpers.rb
+- lib/active_item/embeddable.rb
+- lib/active_item/embedded_collection.rb
 - lib/active_item/errors.rb
 - lib/active_item/logging.rb
 - lib/active_item/model_loader.rb