vorpal 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c866f3e83daac73f28e5c9a53875b73d7f8db95cbf437200f0b0c69cce81d317
-  data.tar.gz: e1e91f848552e1f3710849370978d4a1e322e65b12c65bebcd995b76960ba44e
+  metadata.gz: cf920ae279d48b7b9db84a79c77eeb521602a885c8fe88e8f2121e47a5a46e41
+  data.tar.gz: 9e97596434cf65e598279005a0bb325cadde5d7a6d3f2180ea5a828432f89760
 SHA512:
-  metadata.gz: 5bcd5518f56b4c43f4180d3f63c75c6186c1bd89bee939b8410e656f3df411920238eaf51da4a590367f929507c3bdb1ada98cf972d6ebf6785432417018b9a2
-  data.tar.gz: 85e53e6946ea0d0f06e14d8913ac3eba45668b3d08bfc0036a789620ea05af587cb5a97991467eadfea1f76d5dd3fccaf71c96aeec2345327d9538e714e0e720
+  metadata.gz: d7c07c613b24c7d342be0361e33bda6db6cff0270222db1b7ca8018cf141fb623b2583e49a0d39db51d53389225e527d6a5fd74f133edc6f7653309e86644be4
+  data.tar.gz: 492d62d23506de0e26ffdc8e525169dcb78d6c1060dc9309c9828e9865f2341e8f01cc84fe95a059d01d89462c62292a67ebcfc4148ce4ace770884a56e5e04c

data/README.md

@@ -1,4 +1,4 @@
-# Vorpal [![Build Status](https://travis-ci.com/nulogy/vorpal.svg?branch=master)](https://travis-ci.com/nulogy/vorpal) [![Code Climate](https://codeclimate.com/github/nulogy/vorpal/badges/gpa.svg)](https://codeclimate.com/github/nulogy/vorpal) [![Code Coverage](https://codecov.io/gh/nulogy/vorpal/branch/master/graph/badge.svg)](https://codecov.io/gh/nulogy/vorpal/branch/master)
+# Vorpal [![Build Status](https://travis-ci.com/nulogy/vorpal.svg?branch=main)](https://travis-ci.com/nulogy/vorpal) [![Code Climate](https://codeclimate.com/github/nulogy/vorpal/badges/gpa.svg)](https://codeclimate.com/github/nulogy/vorpal) [![Code Coverage](https://codecov.io/gh/nulogy/vorpal/branch/main/graph/badge.svg)](https://codecov.io/gh/nulogy/vorpal/branch/main)
 
 Separate your domain model from your persistence mechanism. Some problems call for a really sharp tool.
 
@@ -45,27 +45,21 @@ Or install it yourself as:
 Start with a domain model of POROs and AR::Base objects that form an aggregate:
 
 ```ruby
-class Tree; end
-
 class Branch
-  include Virtus.model
-
-  attribute :id, Integer
-  attribute :length, Decimal
-  attribute :diameter, Decimal
-  attribute :tree, Tree
+  attr_accessor :id
+  attr_accessor :length
+  attr_accessor :diameter
+  attr_accessor :tree
 end
 
-class Gardener < ActiveRecord::Base
+class Gardener
 end
 
 class Tree
-  include Virtus.model
-
-  attribute :id, Integer
-  attribute :name, String
-  attribute :gardener, Gardener
-  attribute :branches, Array[Branch]
+  attr_accessor :id
+  attr_accessor :name
+  attr_accessor :gardener
+  attr_accessor :branches
 end
 ```
 
@@ -162,9 +156,35 @@ TreeRepository.destroy(dead_tree)
 TreeRepository.destroy_by_id(dead_tree_id)
 ```
 
+### Ids
+
+Vorpal by default will use auto-incrementing Integers from a DB sequence for ids. However, UUID v4 ids are also 
+supported:
+
+```ruby
+Vorpal.define do
+  # UUID v4 id!
+  map Tree, primary_key_type: :uuid do
+    # ..
+  end
+
+  # Also a UUID v4 id, the Rails Way!
+  map Trunk, id: :uuid do
+    # ..
+  end
+
+  # If you feel the need to specify an auto-incrementing integer id.
+  map Branch, primary_key_type: :serial do
+    # ..
+  end
+end
+```
+
+CAVEAT: Vorpal currently does NOT SUPPORT anyone but Vorpal setting the id of an entity!
+
 ## API Documentation
 
-http://rubydoc.info/github/nulogy/vorpal/master/frames
+http://rubydoc.info/github/nulogy/vorpal/main/frames
 
 ## Caveats
 It also does not do some things that you might expect from other ORMs:
@@ -181,9 +201,8 @@ It also does not do some things that you might expect from other ORMs:
 1. Only supports PostgreSQL.
 
 ## Future Enhancements
-* Support for UUID primary keys.
+* Support for clients to set UUID-based ids.
 * Nicer DSL for specifying attributes that have different names in the domain model than in the DB.
-* Show how to implement POROs without using Virtus (it is unsupported and can be crazy slow)
 * Aggregate updated_at.
 * Better support for value objects.
 
@@ -201,7 +220,7 @@ It also does not do some things that you might expect from other ORMs:
 
 **A.** Create a method on a [Repository](http://martinfowler.com/eaaCatalog/repository.html)! They have full access to the DB/ORM so you can use [Arel](https://github.com/rails/arel) and go [crazy](http://asciicasts.com/episodes/239-activerecord-relation-walkthrough) or use direct SQL if you want. 
 
-For example, use the [#query](https://rubydoc.info/github/nulogy/vorpal/master/Vorpal/AggregateMapper#query-instance_method) method on the [AggregateMapper](https://rubydoc.info/github/nulogy/vorpal/master/Vorpal/AggregateMapper) to access the underyling [ActiveRecordRelation](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html):
+For example, use the [#query](https://rubydoc.info/github/nulogy/vorpal/main/Vorpal/AggregateMapper#query-instance_method) method on the [AggregateMapper](https://rubydoc.info/github/nulogy/vorpal/main/Vorpal/AggregateMapper) to access the underyling [ActiveRecordRelation](https://api.rubyonrails.org/classes/ActiveRecord/Relation.html):
 
 ```ruby
   def find_special_ones

data/lib/vorpal/config/class_config.rb

@@ -0,0 +1,71 @@
+require 'equalizer'
+
+module Vorpal
+  module Config
+    # @private
+    class ClassConfig
+      include Equalizer.new(:domain_class, :db_class)
+      attr_reader :serializer, :deserializer, :domain_class, :db_class, :primary_key_type, :local_association_configs
+      attr_accessor :has_manys, :belongs_tos, :has_ones
+
+      ALLOWED_PRIMARY_KEY_TYPE_OPTIONS = [:serial, :uuid]
+
+      def initialize(attrs)
+        @has_manys = []
+        @belongs_tos = []
+        @has_ones = []
+        @local_association_configs = []
+
+        @serializer = attrs[:serializer]
+        @deserializer = attrs[:deserializer]
+        @domain_class = attrs[:domain_class]
+        @db_class = attrs[:db_class]
+        @primary_key_type = attrs[:primary_key_type]
+        raise "Invalid primary_key_type: '#{@primary_key_type}'" unless ALLOWED_PRIMARY_KEY_TYPE_OPTIONS.include?(@primary_key_type)
+      end
+
+      def build_db_object(attributes)
+        db_class.new(attributes)
+      end
+
+      def set_db_object_attributes(db_object, attributes)
+        db_object.attributes = attributes
+      end
+
+      def get_db_object_attributes(db_object)
+        symbolize_keys(db_object.attributes)
+      end
+
+      def serialization_required?
+        domain_class.superclass.name != 'ActiveRecord::Base'
+      end
+
+      def serialize(object)
+        serializer.serialize(object)
+      end
+
+      def deserialize(db_object)
+        attributes = get_db_object_attributes(db_object)
+        serialization_required? ? deserializer.deserialize(domain_class.new, attributes) : db_object
+      end
+
+      def set_attribute(db_object, attribute, value)
+        db_object.send("#{attribute}=", value)
+      end
+
+      def get_attribute(db_object, attribute)
+        db_object.send(attribute)
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        result = {}
+        hash.each_key do |key|
+          result[key.to_sym] = hash[key]
+        end
+        result
+      end
+    end
+  end
+end

data/lib/vorpal/configs.rb

@@ -1,13 +1,13 @@
 require 'vorpal/util/hash_initialization'
 require 'vorpal/exceptions'
+require 'vorpal/config/class_config'
 require 'equalizer'
 
 module Vorpal
   # @private
-  class MasterConfig
-    def initialize(class_configs)
-      @class_configs = class_configs
-      initialize_association_configs
+  class MainConfig
+    def initialize
+      @class_configs = []
     end
 
     def config_for(clazz)
@@ -20,7 +20,9 @@ module Vorpal
       @class_configs.detect { |conf| conf.db_class == db_object.class }
     end
 
-    private
+    def add_class_config(class_config)
+      @class_configs << class_config
+    end
 
     def initialize_association_configs
       association_configs = {}
@@ -50,6 +52,8 @@ module Vorpal
       end
     end
 
+    private
+
     def build_association_config(association_configs, local_config, fk, fk_type)
       association_config = AssociationConfig.new(local_config, fk, fk_type)
       if association_configs[association_config]
@@ -126,67 +130,6 @@ module Vorpal
     end
   end
 
-  # @private
-  class ClassConfig
-    include Equalizer.new(:domain_class, :db_class)
-    attr_reader :serializer, :deserializer, :domain_class, :db_class, :local_association_configs
-    attr_accessor :has_manys, :belongs_tos, :has_ones
-
-    def initialize(attrs)
-      @has_manys = []
-      @belongs_tos = []
-      @has_ones = []
-      @local_association_configs = []
-
-      attrs.each do |k,v|
-        instance_variable_set("@#{k}", v)
-      end
-    end
-
-    def build_db_object(attributes)
-      db_class.new(attributes)
-    end
-
-    def set_db_object_attributes(db_object, attributes)
-      db_object.attributes = attributes
-    end
-
-    def get_db_object_attributes(db_object)
-      symbolize_keys(db_object.attributes)
-    end
-
-    def serialization_required?
-      domain_class.superclass.name != 'ActiveRecord::Base'
-    end
-
-    def serialize(object)
-      serializer.serialize(object)
-    end
-
-    def deserialize(db_object)
-      attributes = get_db_object_attributes(db_object)
-      serialization_required? ? deserializer.deserialize(domain_class.new, attributes) : db_object
-    end
-
-    def set_attribute(db_object, attribute, value)
-      db_object.send("#{attribute}=", value)
-    end
-
-    def get_attribute(db_object, attribute)
-      db_object.send(attribute)
-    end
-
-    private
-
-    def symbolize_keys(hash)
-      result = {}
-      hash.each_key do |key|
-        result[key.to_sym] = hash[key]
-      end
-      result
-    end
-  end
-
   # @private
   class ForeignKeyInfo
     include Equalizer.new(:fk_column, :fk_type_column, :fk_type)

data/lib/vorpal/dsl/config_builder.rb

@@ -16,74 +16,32 @@ module Vorpal
       @defaults_generator = DefaultsGenerator.new(clazz, db_driver)
     end
 
-    # Maps the given attributes to and from the domain object and the DB. Not needed
-    # if a serializer and deserializer were provided.
+    # @private
     def attributes(*attributes)
       @attributes.concat(attributes)
     end
 
-    # Defines a one-to-many association to another type where the foreign key is stored on the child.
-    #
-    # In Object-Oriented programming, associations are *directed*. This means that they can only be
-    # traversed in one direction: from the type that defines the association (the one with the
-    # getter) to the type that is associated. They end that defines the association is called the
-    # 'Parent' and the end that is associated is called the 'Child'.
-    #
-    # @param name [String] Name of the association getter.
-    # @param options [Hash]
-    # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
-    # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
-    # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
-    # @option options [Class] :child_class (name converted to a Class) The child class.
+    # @private
     def has_many(name, options={})
-      @has_manys << {name: name}.merge(options)
+      @has_manys << build_has_many({name: name}.merge(options))
     end
 
-    # Defines a one-to-one association to another type where the foreign key
-    # is stored on the child.
-    #
-    # In Object-Oriented programming, associations are *directed*. This means that they can only be
-    # traversed in one direction: from the type that defines the association (the one with the
-    # getter) to the type that is associated. They end that defines the association is called the
-    # 'Parent' and the end that is associated is called the 'Child'.
-    #
-    # @param name [String] Name of the association getter.
-    # @param options [Hash]
-    # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
-    # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
-    # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
-    # @option options [Class] :child_class (name converted to a Class) The child class.
+    # @private
     def has_one(name, options={})
-      @has_ones << {name: name}.merge(options)
+      @has_ones << build_has_one({name: name}.merge(options))
     end
 
-    # Defines a one-to-one association with another type where the foreign key
-    # is stored on the parent.
-    #
-    # This association can be polymorphic. I.E. children can be of different types.
-    #
-    # In Object-Oriented programming, associations are *directed*. This means that they can only be
-    # traversed in one direction: from the type that defines the association (the one with the
-    # getter) to the type that is associated. They end that defines the association is called the
-    # 'Parent' and the end that is associated is called the 'Child'.
-    #
-    # @param name [String] Name of the association getter.
-    # @param options [Hash]
-    # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
-    # @option options [String] :fk (Child class name converted to snakecase and appended with a '_id') The name of the DB column on the parent that contains the foreign key reference to the child.
-    # @option options [String] :fk_type The name of the DB column on the parent that contains the child class name. Only needed when the association is polymorphic.
-    # @option options [Class] :child_class (name converted to a Class) The child class.
-    # @option options [[Class]] :child_classes The list of possible classes that can be children. This is for polymorphic associations. Takes precedence over `:child_class`.
+    # @private
     def belongs_to(name, options={})
-      @belongs_tos << {name: name}.merge(options)
+      @belongs_tos << build_belongs_to({name: name}.merge(options))
     end
 
     # @private
     def build
       class_config = build_class_config
-      class_config.has_manys = build_has_manys
-      class_config.has_ones = build_has_ones
-      class_config.belongs_tos = build_belongs_tos
+      class_config.has_manys = @has_manys
+      class_config.has_ones = @has_ones
+      class_config.belongs_tos = @belongs_tos
 
       class_config
     end
@@ -96,18 +54,15 @@ module Vorpal
     private
 
     def build_class_config
-      Vorpal::ClassConfig.new(
+      Vorpal::Config::ClassConfig.new(
         domain_class: @domain_class,
         db_class: @class_options[:to] || @defaults_generator.build_db_class(@class_options[:table_name]),
         serializer: @class_options[:serializer] || @defaults_generator.serializer(attributes_with_id),
         deserializer: @class_options[:deserializer] || @defaults_generator.deserializer(attributes_with_id),
+        primary_key_type: @class_options[:primary_key_type] || @class_options[:id] || :serial,
       )
     end
 
-    def build_has_manys
-      @has_manys.map { |options| build_has_many(options) }
-    end
-
     def build_has_many(options)
       options[:child_class] ||= @defaults_generator.child_class(options[:name])
       options[:fk] ||= @defaults_generator.foreign_key(@domain_class.name)
@@ -115,10 +70,6 @@ module Vorpal
       Vorpal::HasManyConfig.new(options)
     end
 
-    def build_has_ones
-      @has_ones.map { |options| build_has_one(options) }
-    end
-
     def build_has_one(options)
       options[:child_class] ||= @defaults_generator.child_class(options[:name])
       options[:fk] ||= @defaults_generator.foreign_key(@domain_class.name)
@@ -126,10 +77,6 @@ module Vorpal
       Vorpal::HasOneConfig.new(options)
     end
 
-    def build_belongs_tos
-      @belongs_tos.map { |options| build_belongs_to(options) }
-    end
-
     def build_belongs_to(options)
       child_class = options[:child_classes] || options[:child_class] || @defaults_generator.child_class(options[:name])
       options[:child_classes] = Array(child_class)

data/lib/vorpal/dsl/configuration.rb

@@ -4,54 +4,143 @@ require 'vorpal/driver/postgresql'
 
 module Vorpal
   module Dsl
-  module Configuration
-
-    # Configures and creates a {Engine} instance.
-    #
-    # @param options [Hash] Global configuration options for the engine instance.
-    # @option options [Object] :db_driver (Object that will be used to interact with the DB.)
-    #  Must be duck-type compatible with {Postgresql}.
+    # Implements the Vorpal DSL.
     #
-    # @return [Engine] Instance of the mapping engine.
-    def define(options={}, &block)
-      master_config = build_config(&block)
-      db_driver = options.fetch(:db_driver, Driver::Postgresql.new)
-      Engine.new(db_driver, master_config)
-    end
-
-    # Maps a domain class to a relational table.
+    # ```ruby
+    # engine = Vorpal.define do
+    #   map Tree do
+    #     attributes :name
+    #     belongs_to :trunk
+    #     has_many :branches
+    #   end
     #
-    # @param domain_class [Class] Type of the domain model to be mapped
-    # @param options [Hash] Configure how to map the domain model
-    # @option options [String] :to
-    #   Class of the ActiveRecord object that will map this domain class to the DB.
-    #   Optional, if one is not specified, it will be generated.
-    # @option options [Object] :serializer (map the {ConfigBuilder#attributes} directly)
-    #   Object that will convert the domain objects into a hash.
+    #   map Trunk do
+    #     attributes :length
+    #     has_one :tree
+    #   end
     #
-    #   Must have a `(Hash) serialize(Object)` method.
-    # @option options [Object] :deserializer (map the {ConfigBuilder#attributes} directly)
-    #   Object that will set a hash of attribute_names->values onto a new domain
-    #   object.
+    #   map Branch do
+    #     attributes :length
+    #     belongs_to :tree
+    #   end
+    # end
     #
-    #   Must have a `(Object) deserialize(Object, Hash)` method.
-    def map(domain_class, options={}, &block)
-      @class_configs << build_class_config(domain_class, options, &block)
-    end
+    # mapper = engine.mapper_for(Tree)
+    # ```
+    module Configuration
+      # Configures and creates a {Engine} instance.
+      #
+      # @param options [Hash] Global configuration options for the engine instance.
+      # @option options [Object] :db_driver (Object that will be used to interact with the DB.)
+      #  Must be duck-type compatible with {Postgresql}.
+      #
+      # @return [Engine] Instance of the mapping engine.
+      def define(options={}, &block)
+        @main_config = MainConfig.new
+        instance_exec(&block)
+        @main_config.initialize_association_configs
+        db_driver = options.fetch(:db_driver, Driver::Postgresql.new)
+        engine = Engine.new(db_driver, @main_config)
+        @main_config = nil # make sure this MainConfig is never re-used by accident.
+        engine
+      end
 
-    # @private
-    def build_class_config(domain_class, options={}, &block)
-      builder = ConfigBuilder.new(domain_class, options, Driver::Postgresql.new)
-      builder.instance_exec(&block) if block_given?
-      builder.build
-    end
+      # Maps a domain class to a relational table.
+      #
+      # @param domain_class [Class] Type of the domain model to be mapped
+      # @param options [Hash] Configure how to map the domain model
+      # @option options [String] :to
+      #   Class of the ActiveRecord object that will map this domain class to the DB.
+      #   Optional, if one is not specified, it will be generated.
+      # @option options [Object] :serializer (map the {ConfigBuilder#attributes} directly)
+      #   Object that will convert the domain objects into a hash.
+      #
+      #   Must have a `(Hash) serialize(Object)` method.
+      # @option options [Object] :deserializer (map the {ConfigBuilder#attributes} directly)
+      #   Object that will set a hash of attribute_names->values onto a new domain
+      #   object.
+      #
+      #   Must have a `(Object) deserialize(Object, Hash)` method.
+      #  @option options [Symbol] :primary_key_type [:serial, :uuid] (:serial)
+      #    The type of primary key for the class. :serial for auto-incrementing integer, :uuid for a UUID
+      #  @option options [Symbol] :id
+      #    Same as :primary_key_type. Exists for compatibility with the Rails API.
+      def map(domain_class, options={}, &block)
+        class_config = build_class_config(domain_class, options, &block)
+        @main_config.add_class_config(class_config)
+        class_config
+      end
 
-    # @private
-    def build_config(&block)
-      @class_configs = []
-      self.instance_exec(&block)
-      MasterConfig.new(@class_configs)
+      # @private
+      def build_class_config(domain_class, options, &block)
+        @builder = ConfigBuilder.new(domain_class, options, Driver::Postgresql.new)
+        instance_exec(&block) if block_given?
+        class_config = @builder.build
+        @builder = nil # make sure this ConfigBuilder is never re-used by accident.
+        class_config
+      end
+
+      # Maps the given attributes to and from the domain object and the DB. Not needed
+      # if a serializer and deserializer were provided.
+      def attributes(*attributes)
+        @builder.attributes(*attributes)
+      end
+
+      # Defines a one-to-many association to another type where the foreign key is stored on the child.
+      #
+      # In Object-Oriented programming, associations are *directed*. This means that they can only be
+      # traversed in one direction: from the type that defines the association (the one with the
+      # getter) to the type that is associated. They end that defines the association is called the
+      # 'Parent' and the end that is associated is called the 'Child'.
+      #
+      # @param name [String] Name of the association getter.
+      # @param options [Hash]
+      # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
+      # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
+      # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
+      # @option options [Class] :child_class (name converted to a Class) The child class.
+      def has_many(name, options={})
+        @builder.has_many(name, options)
+      end
+
+      # Defines a one-to-one association to another type where the foreign key
+      # is stored on the child.
+      #
+      # In Object-Oriented programming, associations are *directed*. This means that they can only be
+      # traversed in one direction: from the type that defines the association (the one with the
+      # getter) to the type that is associated. They end that defines the association is called the
+      # 'Parent' and the end that is associated is called the 'Child'.
+      #
+      # @param name [String] Name of the association getter.
+      # @param options [Hash]
+      # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
+      # @option options [String] :fk (Parent class name converted to snakecase and appended with a '_id') The name of the DB column on the child that contains the foreign key reference to the parent.
+      # @option options [String] :fk_type The name of the DB column on the child that contains the parent class name. Only needed when there is an association from the child side that is polymorphic.
+      # @option options [Class] :child_class (name converted to a Class) The child class.
+      def has_one(name, options={})
+        @builder.has_one(name, options)
+      end
+
+      # Defines a one-to-one association with another type where the foreign key
+      # is stored on the parent.
+      #
+      # This association can be polymorphic. I.E. children can be of different types.
+      #
+      # In Object-Oriented programming, associations are *directed*. This means that they can only be
+      # traversed in one direction: from the type that defines the association (the one with the
+      # getter) to the type that is associated. They end that defines the association is called the
+      # 'Parent' and the end that is associated is called the 'Child'.
+      #
+      # @param name [String] Name of the association getter.
+      # @param options [Hash]
+      # @option options [Boolean] :owned (True) True if the child type belongs to the aggregate. Changes to any object belonging to the aggregate will be persisted when the aggregate is persisted.
+      # @option options [String] :fk (Child class name converted to snakecase and appended with a '_id') The name of the DB column on the parent that contains the foreign key reference to the child.
+      # @option options [String] :fk_type The name of the DB column on the parent that contains the child class name. Only needed when the association is polymorphic.
+      # @option options [Class] :child_class (name converted to a Class) The child class.
+      # @option options [[Class]] :child_classes The list of possible classes that can be children. This is for polymorphic associations. Takes precedence over `:child_class`.
+      def belongs_to(name, options={})
+        @builder.belongs_to(name, options)
+      end
     end
   end
-  end
 end

data/lib/vorpal/engine.rb

@@ -7,9 +7,9 @@ require 'vorpal/exceptions'
 module Vorpal
   class Engine
     # @private
-    def initialize(db_driver, master_config)
+    def initialize(db_driver, main_config)
       @db_driver = db_driver
-      @configs = master_config
+      @configs = main_config
     end
 
     # Creates a mapper for saving/updating/loading/destroying an aggregate to/from
@@ -34,6 +34,9 @@ module Vorpal
       serialize(all_owned_objects, mapping, loaded_db_objects)
       new_objects = get_unsaved_objects(mapping.keys)
       begin
+        # Primary keys are set eagerly (instead of waiting for them to be set by ActiveRecord upon create)
+        # because we want to support non-null FK constraints without needing to figure the correct
+        # order to save entities in.
         set_primary_keys(all_owned_objects, mapping)
         set_foreign_keys(all_owned_objects, mapping)
         remove_orphans(mapping, loaded_db_objects)
@@ -89,10 +92,16 @@ module Vorpal
       @configs.config_for(domain_class).db_class
     end
 
+    # Try to use {AggregateMapper#query} instead.
     def query(domain_class)
       @db_driver.query(@configs.config_for(domain_class).db_class, mapper_for(domain_class))
     end
 
+    # @private
+    def class_config(domain_class)
+      @configs.config_for(domain_class)
+    end
+
     private
 
     def wrap(collection_or_not)
@@ -165,7 +174,11 @@ module Vorpal
     def set_primary_keys(owned_objects, mapping)
       owned_objects.each do |config, objects|
         in_need_of_primary_keys = objects.find_all { |obj| obj.id.nil? }
-        primary_keys = @db_driver.get_primary_keys(config.db_class, in_need_of_primary_keys.length)
+        if config.primary_key_type == :uuid
+          primary_keys = Array.new(in_need_of_primary_keys.length) { SecureRandom.uuid }
+        elsif config.primary_key_type == :serial
+          primary_keys = @db_driver.get_primary_keys(config.db_class, in_need_of_primary_keys.length)
+        end
         in_need_of_primary_keys.zip(primary_keys).each do |object, primary_key|
           mapping[object].id = primary_key
           object.id = primary_key

data/lib/vorpal/version.rb

@@ -1,3 +1,3 @@
 module Vorpal
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/vorpal.gemspec

@@ -24,7 +24,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "rake", "~> 13"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "virtus", "~> 1.0"
   spec.add_development_dependency "appraisal", "~> 2.2"
 
   spec.required_ruby_version = ">= 2.5.7"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vorpal
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Sean Kirby
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-03 00:00:00.000000000 Z
+date: 2020-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: simple_serializer
@@ -80,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: virtus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -179,6 +165,7 @@ files:
 - lib/vorpal/aggregate_mapper.rb
 - lib/vorpal/aggregate_traversal.rb
 - lib/vorpal/aggregate_utils.rb
+- lib/vorpal/config/class_config.rb
 - lib/vorpal/configs.rb
 - lib/vorpal/db_loader.rb
 - lib/vorpal/driver/postgresql.rb