feat: cross-schema relationships support

Author: robert-hromej

lib/jsonapi/active_relation_resource.rb

@@ -3,6 +3,7 @@
 module JSONAPI
   class ActiveRelationResource < BasicResource
     include CrossSchemaRelationships
+    include ActiveRelationResourceExtensions
 
     root_resource
 
@@ -523,6 +524,11 @@ def find_related_polymorphic_fragments(source_fragments, relationship, options,
         filters = options.fetch(:filters, {})
         source_ids = source_fragments.collect {|item| item.identity.id}
 
+        # Handle case where relationship is passed as a symbol/string instead of a Relationship object
+        if relationship.is_a?(Symbol) || relationship.is_a?(String)
+          relationship = _relationship(relationship.to_sym)
+        end
+
         resource_klass = relationship.resource_klass
         include_directives = options.fetch(:include_directives, {})
 

lib/jsonapi/active_relation_resource_extensions.rb

@@ -2,32 +2,38 @@
 
 # Extensions to ActiveRelationResource for cross-schema support
 module JSONAPI
-  class ActiveRelationResource
-    class << self
-      # Store original methods if they exist
-      def setup_cross_schema_support
-        return if @cross_schema_support_setup
-
-        # Only alias if the method exists and hasn't been aliased already
-        if method_defined?(:find_related_fragments) && !method_defined?(:original_find_related_fragments)
-          alias_method :original_find_related_fragments, :find_related_fragments
-        end
-
-        if method_defined?(:find_included_fragments) && !method_defined?(:original_find_included_fragments)
-          alias_method :original_find_included_fragments, :find_included_fragments
+  module ActiveRelationResourceExtensions
+    def self.included(base)
+      base.class_eval do
+        # Override find_related_fragments to handle cross-schema relationships
+        def self.find_related_fragments(source_rids, relationship_name, options = {})
+          relationship = _relationship(relationship_name)
+
+          if defined?(_cross_schema_relationships) && _cross_schema_relationships && (cross_schema_info = _cross_schema_relationships[relationship_name.to_sym])
+            # Handle cross-schema relationship
+            handle_cross_schema_relationship(source_rids, relationship, cross_schema_info, options)
+          else
+            # Call the original implementation
+            super(source_rids, relationship_name, options)
+          end
         end
 
-        @cross_schema_support_setup = true
-      end
+        # Override find_included_fragments to handle cross-schema relationships
+        def self.find_included_fragments(source, relationship_name, options)
+          relationship = _relationship(relationship_name)
 
-      # Override find_related_fragments to handle cross-schema relationships
-      def find_related_fragments(source_rids, relationship_name, options = {})
-        setup_cross_schema_support
+          if defined?(_cross_schema_relationships) && _cross_schema_relationships && (cross_schema_info = _cross_schema_relationships[relationship_name.to_sym])
+            # Handle cross-schema relationship
+            handle_cross_schema_included(source, relationship, cross_schema_info, options)
+          else
+            # Call the original implementation
+            super(source, relationship_name, options)
+          end
+        end
 
-        relationship = _relationship(relationship_name)
+        private
 
-        if defined?(_cross_schema_relationships) && _cross_schema_relationships && (cross_schema_info = _cross_schema_relationships[relationship_name.to_sym])
-          # Handle cross-schema relationship
+        def self.handle_cross_schema_relationship(source_rids, relationship, cross_schema_info, options)
           schema = cross_schema_info[:schema]
 
           # Get the source records
@@ -39,24 +45,9 @@ def find_related_fragments(source_rids, relationship_name, options = {})
           else
             handle_cross_schema_to_many(source_records, relationship, schema, options)
           end
-        else
-          # Use the original method for normal relationships
-          if respond_to?(:original_find_related_fragments)
-            original_find_related_fragments(source_rids, relationship_name, options)
-          else
-            super(source_rids, relationship_name, options)
-          end
         end
-      end
-
-      # Override find_included_fragments to handle cross-schema relationships
-      def find_included_fragments(source, relationship_name, options)
-        setup_cross_schema_support
 
-        relationship = _relationship(relationship_name)
-
-        if defined?(_cross_schema_relationships) && _cross_schema_relationships && (cross_schema_info = _cross_schema_relationships[relationship_name.to_sym])
-          # Handle cross-schema relationship
+        def self.handle_cross_schema_included(source, relationship, cross_schema_info, options)
           schema = cross_schema_info[:schema]
 
           # Extract IDs from source - it could be a hash of resource fragments
@@ -78,92 +69,80 @@ def find_included_fragments(source, relationship_name, options)
           else
             handle_cross_schema_to_many(source_records, relationship, schema, options)
           end
-        elsif respond_to?(:original_find_included_fragments)
-          # Use the original method for normal relationships
-          original_find_included_fragments(source, relationship_name, options)
-        else
-          # This resource doesn't have find_included_fragments, delegate to parent
-          # We'll use the default implementation from ActiveRelationResource
-          find_included_fragments_default(source, relationship_name, options)
         end
-      end
 
-      # Default implementation for resources that don't have find_included_fragments
-      def find_included_fragments_default(source, relationship_name, options)
-        relationship = _relationship(relationship_name)
+        def self.handle_cross_schema_to_one(source_records, relationship, schema, options)
+          # For has_one or belongs_to with cross-schema
+          related_klass = relationship.resource_klass
+          foreign_key = relationship.foreign_key
+
+          # Get the foreign key values from source records
+          foreign_key_values = source_records.map { |r| r._model.send(foreign_key) }.compact.uniq
+
+          return {} if foreign_key_values.empty?
+
+          # Query the related table with schema prefix
+          # This should be configured based on the actual schema and table
+          full_table_name = "#{schema}.#{relationship.table_name || related_klass._table_name}"
+
+          # Use ActiveRecord to query cross-schema with proper connection
+          connection = ActiveRecord::Base.connection
+          quoted_table = connection.quote_table_name(full_table_name)
+          quoted_ids = foreign_key_values.map { |id| connection.quote(id) }.join(',')
+
+          sql = "SELECT * FROM #{quoted_table} WHERE id IN (#{quoted_ids})"
+          related_records = connection.exec_query(sql)
+
+          # Convert to fragments
+          fragments = {}
+          related_records.each do |record_hash|
+            # Create a model instance from the hash
+            model_class = related_klass._model_class
+            instance = model_class.instantiate(record_hash)
+            resource = related_klass.new(instance, options[:context])
+            rid = JSONAPI::ResourceIdentity.new(related_klass, instance.id)
+            fragments[rid] = JSONAPI::ResourceFragment.new(rid, resource: resource)
+          end
 
-        if relationship.polymorphic?
-          find_related_polymorphic_fragments(source, relationship_name, options, true)
-        else
-          find_related_monomorphic_fragments(source, relationship, options, true)
+          fragments
         end
-      end
-
-      private
-
-      def handle_cross_schema_to_one(source_records, relationship, schema, options)
-        # For has_one or belongs_to with cross-schema
-        related_klass = relationship.resource_klass
-        foreign_key = relationship.foreign_key
-
-        # Get the foreign key values from source records
-        foreign_key_values = source_records.map { |r| r._model.send(foreign_key) }.compact.uniq
 
-        return {} if foreign_key_values.empty?
+        def self.handle_cross_schema_to_many(source_records, relationship, schema, options)
+          # For has_many with cross-schema
+          related_klass = relationship.resource_klass
 
-        # Query the related table with schema prefix
-        full_table_name = "#{schema}.users_v1"
+          # Determine the foreign key based on the source model
+          foreign_key = relationship.foreign_key || "#{_type.to_s.singularize}_id"
 
-        # Use raw SQL to query cross-schema
-        sql = "SELECT * FROM #{full_table_name} WHERE id IN (?)"
-        related_records = ActiveRecord::Base.connection.exec_query(
-          ActiveRecord::Base.send(:sanitize_sql_array, [sql, foreign_key_values])
-        )
+          # Get source IDs
+          source_ids = source_records.map { |r| r._model.send(_primary_key) }.compact.uniq
 
-        # Convert to fragments
-        fragments = {}
-        related_records.each do |record_hash|
-          # Create a mock Employee model instance from the hash
-          employee = Employee.instantiate(record_hash)
-          resource = related_klass.new(employee, options[:context])
-          rid = JSONAPI::ResourceIdentity.new(related_klass, employee.id)
-          fragments[rid] = JSONAPI::ResourceFragment.new(rid, resource: resource)
-        end
-
-        fragments
-      end
-
-      def handle_cross_schema_to_many(source_records, relationship, schema, options)
-        # For has_many with cross-schema
-        related_klass = relationship.resource_klass
+          return {} if source_ids.empty?
 
-        # Determine the foreign key based on the source model
-        foreign_key = "#{_type.to_s.singularize}_id"
+          # Query the related table with schema prefix
+          full_table_name = "#{schema}.#{relationship.table_name || related_klass._table_name}"
 
-        # Get source IDs
-        source_ids = source_records.map { |r| r._model.send(_primary_key) }.compact.uniq
+          connection = ActiveRecord::Base.connection
+          quoted_table = connection.quote_table_name(full_table_name)
+          quoted_key = connection.quote_column_name(foreign_key)
+          quoted_ids = source_ids.map { |id| connection.quote(id) }.join(',')
 
-        return {} if source_ids.empty?
+          sql = "SELECT * FROM #{quoted_table} WHERE #{quoted_key} IN (#{quoted_ids})"
+          related_records = connection.exec_query(sql)
 
-        # Query the related table with schema prefix
-        full_table_name = "#{schema}.users_v1"
-
-        # For has_many employees, we need to handle the join table or direct relationship
-        # This is a simplified version - you may need to adjust based on your actual schema
-        sql = "SELECT * FROM #{full_table_name}"
-        related_records = ActiveRecord::Base.connection.exec_query(sql)
+          # Convert to fragments
+          fragments = {}
+          related_records.each do |record_hash|
+            # Create a model instance from the hash
+            model_class = related_klass._model_class
+            instance = model_class.instantiate(record_hash)
+            resource = related_klass.new(instance, options[:context])
+            rid = JSONAPI::ResourceIdentity.new(related_klass, instance.id)
+            fragments[rid] = JSONAPI::ResourceFragment.new(rid, resource: resource)
+          end
 
-        # Convert to fragments
-        fragments = {}
-        related_records.each do |record_hash|
-          # Create a mock Employee model instance from the hash
-          employee = Employee.instantiate(record_hash)
-          resource = related_klass.new(employee, options[:context])
-          rid = JSONAPI::ResourceIdentity.new(related_klass, employee.id)
-          fragments[rid] = JSONAPI::ResourceFragment.new(rid, resource: resource)
+          fragments
         end
-
-        fragments
       end
     end
   end

lib/jsonapi/error.rb

@@ -17,7 +17,12 @@ def initialize(options = {})
       @source         = options[:source]
       @links          = options[:links]
 
-      @status         = Rack::Utils::SYMBOL_TO_STATUS_CODE[options[:status]].to_s
+      @status         = if options[:status]
+                          code = Rack::Utils::SYMBOL_TO_STATUS_CODE[options[:status]]
+                          code ? code.to_s : options[:status].to_s
+                        else
+                          nil
+                        end
       @meta           = options[:meta]
     end
 
@@ -48,7 +53,8 @@ def update_with_overrides(error_object_overrides)
 
       if error_object_overrides[:status]
         # :nocov:
-        @status         = Rack::Utils::SYMBOL_TO_STATUS_CODE[error_object_overrides[:status]].to_s
+        code = Rack::Utils::SYMBOL_TO_STATUS_CODE[error_object_overrides[:status]]
+        @status = code ? code.to_s : error_object_overrides[:status].to_s
         # :nocov:
       end
       @meta           = error_object_overrides[:meta] || @meta

lib/jsonapi/response_document.rb

@@ -61,14 +61,26 @@ def contents
     def status
       status_codes = if has_errors?
                        @global_errors.collect do |error|
-                         error.status.to_i
+                         # Handle both numeric and symbol/string statuses
+                         if error.status.is_a?(String) && error.status.match(/^\d+$/)
+                           error.status.to_i
+                         elsif error.status.is_a?(String) || error.status.is_a?(Symbol)
+                           Rack::Utils::SYMBOL_TO_STATUS_CODE[error.status.to_sym] || 422
+                         else
+                           error.status.to_i
+                         end
                        end
                      else
                        @result_codes
                      end
 
-      # Count the unique status codes
-      counts = status_codes.each_with_object(Hash.new(0)) { |code, counts| counts[code] += 1 }
+      # Count the unique status codes, filtering out invalid codes
+      valid_codes = status_codes.select { |code| code.to_i > 0 }
+
+      # If no valid status codes, default to 200
+      return 200 if valid_codes.empty?
+
+      counts = valid_codes.each_with_object(Hash.new(0)) { |code, counts| counts[code] += 1 }
 
       # if there is only one status code we can return that
       return counts.keys[0].to_i if counts.length == 1
@@ -77,7 +89,7 @@ def status
 
       # if there are many we should return the highest general code, 200, 400, 500 etc.
       max_status = 0
-      status_codes.each do |status|
+      valid_codes.each do |status|
         code = status.to_i
         max_status = code if max_status < code
       end