rhino-rails 4.2.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1168eadabff8797a003d07665dfb30f4c1581e78e5df400ac9d72116d323d413
-  data.tar.gz: 0ec4d0b8ce91cadecdc94af585261ecd148157eacf7e720494adeb566187010c
+  metadata.gz: c15dd271d0b613f2effa9bb7c8d050b3214c74884e3021461150017f0f159af6
+  data.tar.gz: 5b4e5dcb736acc54674ad24e9d689cd93582e7ba0195554ef99e7735f2c33050
 SHA512:
-  metadata.gz: e79bfcd2a29520962874939ec5621c5dbb6242c19681515a36aac49f0ba158a95bbf631638055a342de181248c43e2ce7f9480d77ef79900ec216682f238e3bf
-  data.tar.gz: 264a1e3201782888918077db9e46ba4bea10bb7262d14b5d4a2eaa67ff843fd5b859579dfdfca57041d5a11babfc26f57bc23806359fcf7ca931f07c70d74d41
+  metadata.gz: 93c2de702533d23edcfe6b334aa0ffaf0f327efe6518a8c608e8072b4fe27862430d6591a651e730f198f9e9e8cf39456005464490a12137dadce641613ef268
+  data.tar.gz: 7fe767badf982f99dd3fca7b72c441929ee0eb336b72b117ed4a5296cdcaafacda6582a338025e6e611f1a0e87117d6d906469c8b01abc9339109d9da32c711a

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rhino
+
+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/lib/rhino/blueprint/sorter.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Rhino
+  module Blueprint
+    # Orders blueprints so that a referenced model's table is created before any
+    # model whose migration adds a foreign key to it (parents before children).
+    #
+    # Foreign keys are taken from +foreignId+ columns that carry a +foreign_model+
+    # mapping to another model in the same generation set. References that impose
+    # no ordering are ignored:
+    #   - self-references (a model's FK to its own table — one migration),
+    #   - references to models NOT in this set (e.g. Organization/User, whose
+    #     tables are created by +rhino:install+, not the blueprint run).
+    #
+    # Uses Kahn's algorithm with a stable tie-break: among models with no
+    # remaining unmet dependency, the one earliest in the input order wins. The
+    # input is already alphabetical (by file name), so the output stays
+    # alphabetical wherever relationships don't force a reorder.
+    #
+    # A circular FK dependency (A -> B -> A) has no linear migration order. Such
+    # models are emitted in a deterministic best-effort order and reported via
+    # {#cycles} so the caller can warn (one side should be a nullable/deferred FK).
+    class Sorter
+      # Model names involved in a circular foreign-key dependency during the last
+      # {#sort} (empty when the dependency graph is acyclic).
+      attr_reader :cycles
+
+      def initialize
+        @cycles = []
+      end
+
+      # Re-order blueprints into a valid migration sequence (parents first).
+      #
+      # @param blueprints [Array<Hash>] normalized blueprints (each with a
+      #   +:model+ name and +:columns+).
+      # @return [Array<Hash>] the blueprints, re-ordered.
+      def sort(blueprints)
+        @cycles = []
+        return blueprints.dup if blueprints.length < 2
+
+        by_model = {}
+        blueprints.each do |bp|
+          model = bp[:model]
+          by_model[model] ||= bp if model
+        end
+
+        dependents = {}
+        indegree = {}
+        by_model.each_key do |m|
+          dependents[m] = []
+          indegree[m] = 0
+        end
+
+        by_model.each do |model, bp|
+          seen = {}
+          dependency_models(bp).each do |ref|
+            next if ref == model || !by_model.key?(ref) || seen[ref]
+
+            seen[ref] = true
+            dependents[ref] << model
+            indegree[model] += 1
+          end
+        end
+
+        input_order = by_model.keys
+
+        # Record the models that actually participate in a cycle (reachable from
+        # themselves), in input order, so the caller can warn about the full cycle.
+        input_order.each do |model|
+          @cycles << model if reachable_from_self?(model, dependents)
+        end
+
+        ordered = []
+        resolved = {}
+        while ordered.length < by_model.length
+          # Earliest-input model with all dependencies already emitted...
+          pick = input_order.find { |m| !resolved[m] && indegree[m].zero? }
+          # ...or, when a cycle blocks the graph, the earliest unresolved model
+          # (deterministic cycle-break; the cycle itself is reported via #cycles).
+          pick ||= input_order.find { |m| !resolved[m] }
+
+          ordered << by_model[pick]
+          resolved[pick] = true
+          dependents[pick].each { |child| indegree[child] -= 1 }
+        end
+
+        ordered
+      end
+
+      private
+
+      # Whether +start+ can reach itself by following dependency edges — i.e. it
+      # participates in a circular foreign-key dependency. +adj+ maps a model to
+      # the models that reference it (its dependents).
+      def reachable_from_self?(start, adj)
+        stack = (adj[start] || []).dup
+        visited = {}
+        until stack.empty?
+          node = stack.pop
+          return true if node == start
+          next if visited[node]
+
+          visited[node] = true
+          (adj[node] || []).each { |n| stack << n }
+        end
+        false
+      end
+
+      # The model names this blueprint's migration adds foreign keys to, taken
+      # from its +foreignId+ columns that carry a +foreign_model+.
+      def dependency_models(blueprint)
+        (blueprint[:columns] || [])
+          .select { |c| c[:type] == "foreignId" && c[:foreign_model] }
+          .map { |c| c[:foreign_model] }
+      end
+    end
+  end
+end

data/lib/rhino/commands/blueprint_command.rb

@@ -4,6 +4,7 @@ require "rhino/commands/base_command"
 require "fileutils"
 require "rhino/blueprint/blueprint_parser"
 require "rhino/blueprint/blueprint_validator"
+require "rhino/blueprint/sorter"
 require "rhino/blueprint/manifest_manager"
 require "rhino/blueprint/generators/policy_generator"
 require "rhino/blueprint/generators/test_generator"
@@ -85,6 +86,27 @@ module Rhino
 
         say "  Found #{yaml_files.length} blueprint(s)", :cyan
 
+        # Order so a referenced model's table is migrated before any model that
+        # foreign-keys to it (parents before children). Migration timestamps are
+        # assigned in iteration order, so this is what makes the set runnable.
+        parsed_for_order = []
+        unparseable = []
+        yaml_files.each do |f|
+          parsed_for_order << { file: f, blueprint: parser.parse_model(f) }
+        rescue StandardError
+          unparseable << f
+        end
+        sorter = Rhino::Blueprint::Sorter.new
+        ordered = sorter.sort(parsed_for_order.map { |p| p[:blueprint] })
+        file_by_model = parsed_for_order.each_with_object({}) do |p, h|
+          h[p[:blueprint][:model]] ||= p[:file]
+        end
+        yaml_files = ordered.map { |bp| file_by_model[bp[:model]] }.compact + unparseable
+        if sorter.cycles.any?
+          say "  ⚠ Circular foreign-key dependency among: #{sorter.cycles.join(', ')}. " \
+              "Migration order is best-effort — make one side nullable or add the FK in a later migration.", :yellow
+        end
+
         # 3. Process each blueprint
         is_multi_tenant = multi_tenant_enabled?
         org_identifier = detect_org_identifier

data/lib/rhino/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rhino
-  VERSION = "4.2.0"
+  VERSION = "4.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rhino-rails
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.2.1
 platform: ruby
 authors:
 - Bruno Cipolla
@@ -186,6 +186,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
 - README.md
 - lib/rhino-rails.rb
 - lib/rhino.rb
@@ -198,6 +199,7 @@ files:
 - lib/rhino/blueprint/generators/seeder_generator.rb
 - lib/rhino/blueprint/generators/test_generator.rb
 - lib/rhino/blueprint/manifest_manager.rb
+- lib/rhino/blueprint/sorter.rb
 - lib/rhino/commands/base_command.rb
 - lib/rhino/commands/blueprint_command.rb
 - lib/rhino/commands/export_postman_command.rb