dynamic-active-model 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 471bcb2966f59d8f8f4f7df9f32432cf6ff215685a770e2a99956844e0f2d8d5
-  data.tar.gz: 69941d0598425aaf866cfdc29a6e8252d38df291d61523e6edae6243d7f049c0
+  metadata.gz: 4b97bc188a4c9b06a6cfa87bf1af11ef77bd1e80dbf795b61992d90a940202f8
+  data.tar.gz: add2284f1e7f247f47bb3146b145bb8fe8880baa95acc37b904c791d4077c24d
 SHA512:
-  metadata.gz: a7b6cd8138519d8879df5fab6349771b2cc586d340752d566431a985aac152f102c10654dd60098695f303f3fd35eec5b85f109d269ac24a489b51de0a6f2e05
-  data.tar.gz: 3402b23d14abd1b92525642021a5586a202d83aa09683cfe14ae576d9ead974fdccd72374bb7d4f47b77ffc56ca4ba8c8fbb48f3c8cdc371ba283b2f15f24a9f
+  metadata.gz: 9a185c609164a98c20d755c47d45db2ed059aebe42811d15c987ebb8f3e18d8dd6b7101e714252d046b85ef0f42cad1997d557ead86d0fac534a18314751bac5
+  data.tar.gz: 6dc01aefd21b1dce01a1b4bc9926bd4424a25da6fb0bbcaeb728b6692fff88de984567f2fa988e4dbde917d996b3a2166bfa6d19671fa1831438e745700f25f7

data/bin/dynamic-db-explorer

@@ -66,6 +66,10 @@ OptionParser.new do |opts|
     options[:id_suffix] = v
   end
 
+  opts.on('--foreign-key-constraints', 'Also relate columns through foreign key constraints') do
+    options[:foreign_key_constraints] = true
+  end
+
   opts.on('-c', '--config FILE', "config file, default #{DEFAULT_CONFIG_FILE}") do |v|
     options[:config_file] = v
   end
@@ -91,6 +95,7 @@ if options[:config_file]
   config = YAML.safe_load_file(options[:config_file], permitted_classes: [Symbol])[options[:config_section]]
   options[:skip_tables] = config.delete('skip_tables') || []
   options[:relationships] = config.delete('relationships') || {}
+  options[:foreign_key_constraints] ||= config.delete('foreign_key_constraints') || false
   if (module_name = config.delete('module'))
     raise ArgumentError, "Invalid module name: #{module_name}" unless module_name.match?(/\A[A-Z][A-Za-z0-9_]*\z/)
 
@@ -104,7 +109,8 @@ DYNAMIC_DATABASE = DynamicActiveModel::Explorer.explore(
   options[:base_module],
   options[:connection_options],
   options[:skip_tables],
-  options[:relationships]
+  options[:relationships],
+  foreign_key_constraints: options[:foreign_key_constraints] || false
 )
 
 if options[:class_files_dir]

data/lib/dynamic-active-model/associations.rb

@@ -53,6 +53,13 @@ module DynamicActiveModel
         .add(foreign_key, relationship_name)
     end
 
+    # Relates columns through the database's foreign key constraints as well as by
+    # naming convention. A column with a constraint follows the constraint.
+    # @return [void]
+    def use_foreign_key_constraints!
+      @constraints = ForeignKeyConstraints.new(@database)
+    end
+
     # Builds all relationships between models based on foreign keys and constraints
     # This method:
     # 1. Maps foreign keys to their corresponding models
@@ -64,15 +71,7 @@ module DynamicActiveModel
       foreign_key_to_models = create_foreign_key_to_model_map
 
       @database.models.each do |model|
-        model.column_names.each do |column_name|
-          next unless foreign_key_to_models[column_name.downcase]
-
-          foreign_key_to_models[column_name.downcase].each do |foreign_model, relationship_name|
-            next if foreign_model == model
-
-            add_relationships(relationship_name, model, foreign_model, column_name)
-          end
-        end
+        model.column_names.each { |column_name| add_column_relationships(model, column_name, foreign_key_to_models) }
       end
 
       @join_tables.each do |join_table_model|
@@ -85,6 +84,30 @@ module DynamicActiveModel
 
     private
 
+    # Relates a column through its foreign key constraint when it has one (and
+    # constraints are in use), otherwise by naming convention
+    # @param model [Class] The model with the column
+    # @param column_name [String]
+    # @param foreign_key_to_models [Hash] See #create_foreign_key_to_model_map
+    def add_column_relationships(model, column_name, foreign_key_to_models)
+      constraint = @constraints&.find(model, column_name)
+      return add_constraint_relationships(constraint) if constraint
+
+      foreign_key_to_models.fetch(column_name.downcase, []).each do |foreign_model, relationship_name|
+        next if foreign_model == model
+
+        add_relationships(relationship_name, model, foreign_model, column_name)
+      end
+    end
+
+    # Adds the relationships a foreign key constraint describes; unlike the naming
+    # convention, these may reference the same model (employees.manager_id)
+    # @param constraint [ForeignKeyConstraints::Constraint]
+    def add_constraint_relationships(constraint)
+      add_relationships(constraint.relationship_name, constraint.model, constraint.referenced_model,
+                        constraint.column, constraint.primary_key)
+    end
+
     # Adds has_and_belongs_to_many relationships between two models
     # @param join_table_model [Class] The join table model
     # @param models [Array<Class>] The two models to be related
@@ -101,12 +124,14 @@ module DynamicActiveModel
     # @param model [Class] The model with the foreign key
     # @param belongs_to_model [Class] The model being referenced
     # @param foreign_key [String] The foreign key column name
-    def add_relationships(relationship_name, model, belongs_to_model, foreign_key)
-      add_belongs_to(relationship_name, model, belongs_to_model, foreign_key)
+    # @param primary_key [String] The referenced column, normally the primary key
+    def add_relationships(relationship_name, model, belongs_to_model, foreign_key,
+                          primary_key = belongs_to_model.primary_key)
+      add_belongs_to(relationship_name, model, belongs_to_model, foreign_key, primary_key)
       if unique_index?(model, foreign_key)
-        add_has_one(relationship_name, belongs_to_model, model, foreign_key)
+        add_has_one(relationship_name, belongs_to_model, model, foreign_key, primary_key)
       else
-        add_has_many(relationship_name, belongs_to_model, model, foreign_key)
+        add_has_many(relationship_name, belongs_to_model, model, foreign_key, primary_key)
       end
     end
 
@@ -115,12 +140,13 @@ module DynamicActiveModel
     # @param model [Class] The model with the foreign key
     # @param belongs_to_model [Class] The model being referenced
     # @param foreign_key [String] The foreign key column name
-    def add_belongs_to(relationship_name, model, belongs_to_model, foreign_key)
+    # @param primary_key [String] The referenced column
+    def add_belongs_to(relationship_name, model, belongs_to_model, foreign_key, primary_key)
       model.belongs_to(
         relationship_name.singularize.to_sym,
         class_name: belongs_to_model.name,
         foreign_key: foreign_key,
-        primary_key: belongs_to_model.primary_key
+        primary_key: primary_key
       )
     end
 
@@ -129,12 +155,13 @@ module DynamicActiveModel
     # @param model [Class] The referenced (parent) model that gets the association
     # @param has_many_model [Class] The model with the foreign key
     # @param foreign_key [String] The foreign key column name
-    def add_has_many(relationship_name, model, has_many_model, foreign_key)
+    # @param primary_key [String] The referenced column on the parent model
+    def add_has_many(relationship_name, model, has_many_model, foreign_key, primary_key)
       model.has_many(
         generate_has_many_association_name(relationship_name, model, has_many_model),
         class_name: has_many_model.name,
         foreign_key: foreign_key,
-        primary_key: model.primary_key
+        primary_key: primary_key
       )
     end
 
@@ -143,12 +170,13 @@ module DynamicActiveModel
     # @param model [Class] The referenced (parent) model that gets the association
     # @param has_one_model [Class] The model with the foreign key
     # @param foreign_key [String] The foreign key column name
-    def add_has_one(relationship_name, model, has_one_model, foreign_key)
+    # @param primary_key [String] The referenced column on the parent model
+    def add_has_one(relationship_name, model, has_one_model, foreign_key, primary_key)
       model.has_one(
         generate_has_one_association_name(relationship_name, model, has_one_model),
         class_name: has_one_model.name,
         foreign_key: foreign_key,
-        primary_key: model.primary_key
+        primary_key: primary_key
       )
     end
 

data/lib/dynamic-active-model/explorer.rb

@@ -14,6 +14,9 @@ module DynamicActiveModel
   #   skip_tables = ['temporary_data', 'audit_logs']
   #   DynamicActiveModel::Explorer.explore(DB, database_config, skip_tables)
   #
+  # @example With Foreign Key Constraints
+  #   DynamicActiveModel::Explorer.explore(DB, database_config, foreign_key_constraints: true)
+  #
   # @example With Custom Relationships
   #   relationships = {
   #     'users' => {
@@ -30,13 +33,15 @@ module DynamicActiveModel
     # @param relationships [Hash] Custom foreign key relationships to add
     # @param table_class_names [Hash] Custom class names by table name
     # @param parent_class [Class, nil] Optional superclass for the base class (see Factory)
+    # @param foreign_key_constraints [Boolean] Also relate columns through the database's
+    #   foreign key constraints (see ForeignKeyConstraints)
     # @return [Database] The configured database instance
     # @raise [ClassNameConflict] If two tables map to the same class name
     def self.explore(base_module, connection_options, skip_tables = [], relationships = {}, table_class_names = {},
-                     parent_class: nil)
+                     parent_class: nil, foreign_key_constraints: false)
       database = create_models!(base_module, connection_options, skip_tables, table_class_names,
                                 parent_class: parent_class)
-      build_relationships!(database, relationships)
+      build_relationships!(database, relationships, foreign_key_constraints: foreign_key_constraints)
       database
     end
 
@@ -67,9 +72,11 @@ module DynamicActiveModel
     # Sets up relationships between created models
     # @param database [Database] The database instance containing the models
     # @param relationships [Hash] Custom foreign key relationships to add
+    # @param foreign_key_constraints [Boolean] Also relate columns through foreign key constraints
     # @return [void]
-    def self.build_relationships!(database, relationships)
+    def self.build_relationships!(database, relationships, foreign_key_constraints: false)
       relations = Associations.new(database)
+      relations.use_foreign_key_constraints! if foreign_key_constraints
       relationships.each do |table_name, foreign_keys|
         foreign_keys.each do |foreign_key, relationship_name|
           relations.add_foreign_key(table_name, foreign_key, relationship_name)

data/lib/dynamic-active-model/foreign_key_constraints.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module DynamicActiveModel
+  # Reads the database's foreign key constraints and resolves them to models, so
+  # Associations can relate columns that don't follow the <table>_id naming
+  # convention (posts.author_id => users) and self-references (employees.manager_id).
+  #
+  # Skipped: composite constraints, columns without the id suffix (a belongs_to
+  # named after the column itself would hide it), and constraints whose table or
+  # referenced table has no model.
+  #
+  # @example
+  #   constraints = DynamicActiveModel::ForeignKeyConstraints.new(database)
+  #   constraints.find(DB::Post, 'author_id') # => #<struct referenced_model=DB::User, ...>
+  class ForeignKeyConstraints
+    # A constraint resolved to models
+    Constraint = Struct.new(:model, :column, :referenced_model, :primary_key, :relationship_name)
+
+    # @param database [Database] The database whose models' constraints to read
+    def initialize(database)
+      @database = database
+      @constraints = database.models.flat_map { |model| constraints_for(model) }
+                             .to_h { |constraint| [[constraint.model, constraint.column], constraint] }
+    end
+
+    # @param model [Class] The model with the column
+    # @param column [String] The column name
+    # @return [Constraint, nil] The column's constraint, if it has one
+    def find(model, column)
+      @constraints[[model, column]]
+    end
+
+    # @return [Integer] Number of usable constraints
+    def size
+      @constraints.size
+    end
+
+    private
+
+    # @param model [Class]
+    # @return [Array<Constraint>] The model's usable constraints
+    def constraints_for(model)
+      model.connection.foreign_keys(model.table_name).filter_map do |foreign_key|
+        column = foreign_key.column
+        next unless column.is_a?(String) && column.end_with?(ForeignKey.id_suffix)
+
+        referenced_model = @database.get_model(foreign_key.to_table)
+        next unless referenced_model
+
+        Constraint.new(model, column, referenced_model, foreign_key.primary_key,
+                       relationship_name(column, referenced_model))
+      end
+    end
+
+    # Names the relationship like the naming convention does: author_id => "author",
+    # but user_id referencing users => "users", so its has_many stays :posts
+    # @param column [String]
+    # @param referenced_model [Class]
+    # @return [String]
+    def relationship_name(column, referenced_model)
+      name = column.delete_suffix(ForeignKey.id_suffix)
+      table_name = referenced_model.table_name.underscore
+      name == table_name.singularize ? table_name : name
+    end
+  end
+end

data/lib/dynamic-active-model/setup.rb

@@ -53,6 +53,7 @@ module DynamicActiveModel
         {
           connection_options: nil,
           parent_class: nil,
+          foreign_key_constraints: false,
           skip_tables: [],
           relationships: {},
           table_class_names: {},
@@ -84,6 +85,15 @@ module DynamicActiveModel
         dynamic_active_model_config[:parent_class]
       end
 
+      # Sets or gets whether columns are also related through the database's foreign
+      # key constraints (see ForeignKeyConstraints)
+      # @param enabled [Boolean, nil]
+      # @return [Boolean] The current setting
+      def foreign_key_constraints(enabled = nil)
+        update_config(:foreign_key_constraints, enabled) unless enabled.nil?
+        dynamic_active_model_config[:foreign_key_constraints]
+      end
+
       # Sets or gets the list of tables to skip
       # @param tables [Array<String>, nil] Tables to skip
       # @return [Array<String>] The current list of skipped tables
@@ -165,7 +175,8 @@ module DynamicActiveModel
             skip_tables,
             relationships,
             table_class_names,
-            parent_class: parent_class
+            parent_class: parent_class,
+            foreign_key_constraints: foreign_key_constraints
           )
         )
         database.update_all_models(extensions_path, extensions_suffix) if extensions_path

data/lib/dynamic-active-model/version.rb

@@ -2,5 +2,5 @@
 
 module DynamicActiveModel
   # Gem version, bumped by release-please
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/dynamic-active-model.rb

@@ -37,6 +37,9 @@ module DynamicActiveModel
   # Handles foreign key relationships and constraints
   autoload :ForeignKey, 'dynamic-active-model/foreign_key'
 
+  # Resolves the database's foreign key constraints to models
+  autoload :ForeignKeyConstraints, 'dynamic-active-model/foreign_key_constraints'
+
   # Manages automatic discovery and setup of model relationships
   autoload :Associations, 'dynamic-active-model/associations'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-active-model
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Doug Youch
@@ -56,6 +56,7 @@ files:
 - lib/dynamic-active-model/explorer.rb
 - lib/dynamic-active-model/factory.rb
 - lib/dynamic-active-model/foreign_key.rb
+- lib/dynamic-active-model/foreign_key_constraints.rb
 - lib/dynamic-active-model/setup.rb
 - lib/dynamic-active-model/template_class_file.rb
 - lib/dynamic-active-model/version.rb