jpie 1.0.0 → 1.0.2

data/lib/json_api/resources/concerns/meta_dsl.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Resources
+    module MetaDsl
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def meta(hash = nil, &block)
+          @meta = hash || block
+        end
+
+        def resource_meta
+          if instance_variable_defined?(:@meta)
+            @meta
+          elsif superclass != JSONAPI::Resource && superclass.respond_to?(:resource_meta)
+            superclass.resource_meta
+          end
+        end
+      end
+    end
+  end
+end

data/lib/json_api/resources/concerns/model_class_helpers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Resources
+    module ModelClassHelpers
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def resource_for_model(model_class)
+          resource_const = "#{model_class.name}Resource"
+          resource_const.safe_constantize if resource_const.respond_to?(:safe_constantize) || defined?(ActiveSupport)
+        rescue NameError
+          nil
+        end
+
+        def model_class
+          name.sub(/Resource$/, "").classify.constantize
+        end
+
+        def safe_model_class
+          return nil unless respond_to?(:name) && name
+          return nil unless defined?(ActiveSupport)
+
+          name.sub(/Resource$/, "").classify.safe_constantize
+        rescue NoMethodError
+          nil
+        end
+
+        def reflection_model_class
+          model_class
+        rescue StandardError
+          safe_model_class
+        end
+      end
+    end
+  end
+end

data/lib/json_api/resources/concerns/relationships_dsl.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Resources
+    module RelationshipsDsl
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def has_one(name, meta: nil, **options)
+          @relationships ||= []
+          detect_polymorphic(name, options)
+          @relationships << { name: name.to_sym, type: :has_one, meta:, options: }
+        end
+
+        def has_many(name, meta: nil, **options)
+          @relationships ||= []
+          validate_append_only_options!(options)
+          detect_polymorphic(name, options)
+          @relationships << { name: name.to_sym, type: :has_many, meta:, options: }
+        end
+
+        def belongs_to(name, meta: nil, **options)
+          @relationships ||= []
+          detect_polymorphic(name, options)
+          @relationships << { name: name.to_sym, type: :belongs_to, meta:, options: }
+        end
+
+        def relationship_definitions
+          declared_relationships = instance_variable_defined?(:@relationships)
+          rels = @relationships || []
+          rels = superclass.relationship_definitions + rels if should_inherit_relationships?(declared_relationships)
+          rels.uniq { |r| r[:name] }
+        end
+
+        def relationship_names
+          relationship_definitions.map { |r| r[:name] }
+        end
+      end
+
+      module RelationshipHelperMethods
+        def validate_append_only_options!(options)
+          if options[:append_only] && options[:purge_on_nil] == true
+            raise ArgumentError, "Cannot use append_only: true with purge_on_nil: true"
+          end
+
+          options[:purge_on_nil] = false if options[:append_only] && !options.key?(:purge_on_nil)
+        end
+
+        def detect_polymorphic(name, options)
+          return if options.key?(:polymorphic)
+
+          model_klass = reflection_model_class
+          return unless model_klass.respond_to?(:reflect_on_association)
+
+          reflection = model_klass.reflect_on_association(name)
+          options[:polymorphic] = reflection&.polymorphic?
+        end
+
+        def should_inherit_relationships?(declared_relationships)
+          !declared_relationships &&
+            superclass != JSONAPI::Resource &&
+            superclass.respond_to?(:relationship_definitions)
+        end
+      end
+
+      included do
+        extend RelationshipHelperMethods
+      end
+    end
+  end
+end

data/lib/json_api/resources/concerns/sortable_fields_dsl.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Resources
+    module SortableFieldsDsl
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def sortable_fields(*field_names)
+          @sortable_fields ||= []
+          @sortable_fields.concat(field_names.map(&:to_sym))
+          @sortable_fields.uniq!
+        end
+
+        def permitted_sortable_fields
+          sort_fields = @sortable_fields || []
+          sort_fields = inherited_sort_only_fields + sort_fields if should_inherit_sortable_fields?
+          (permitted_attributes + sort_fields).uniq
+        end
+
+        def should_inherit_sortable_fields?
+          !instance_variable_defined?(:@sortable_fields) &&
+            !instance_variable_defined?(:@attributes) &&
+            superclass != JSONAPI::Resource &&
+            superclass.respond_to?(:permitted_sortable_fields)
+        end
+
+        def inherited_sort_only_fields
+          parent_sort_fields = superclass.permitted_sortable_fields
+          parent_attributes = superclass.permitted_attributes
+          parent_sort_fields - parent_attributes
+        end
+      end
+    end
+  end
+end

data/lib/json_api/resources/resource.rb

@@ -1,236 +1,30 @@
 # frozen_string_literal: true
 
+require_relative "concerns/attributes_dsl"
+require_relative "concerns/filters_dsl"
+require_relative "concerns/sortable_fields_dsl"
+require_relative "concerns/relationships_dsl"
+require_relative "concerns/meta_dsl"
+require_relative "concerns/model_class_helpers"
+
 module JSONAPI
   class Resource
-    class << self
-      def resource_for_model(model_class)
-        resource_const = "#{model_class.name}Resource"
-        resource_const.safe_constantize if resource_const.respond_to?(:safe_constantize) || defined?(ActiveSupport)
-      rescue NameError
-        nil
-      end
-
-      def attributes(*attrs)
-        @attributes ||= []
-        @attributes.concat(attrs.map(&:to_sym))
-        @attributes.uniq!
-      end
-
-      def creatable_fields(*fields)
-        @creatable_fields ||= []
-        @creatable_fields.concat(fields.map(&:to_sym))
-        @creatable_fields.uniq!
-      end
-
-      def updatable_fields(*fields)
-        @updatable_fields ||= []
-        @updatable_fields.concat(fields.map(&:to_sym))
-        @updatable_fields.uniq!
-      end
-
-      def filters(*filter_names)
-        @filters ||= []
-        @filters.concat(filter_names.map(&:to_sym))
-        @filters.uniq!
-      end
-
-      def permitted_filters_through
-        relationship_names
-      end
-
-      def sortable_fields(*field_names)
-        @sortable_fields ||= []
-        @sortable_fields.concat(field_names.map(&:to_sym))
-        @sortable_fields.uniq!
-      end
-
-      def meta(hash = nil, &block)
-        @meta = hash || block
-      end
-
-      def resource_meta
-        if instance_variable_defined?(:@meta)
-          @meta
-        elsif superclass != JSONAPI::Resource && superclass.respond_to?(:resource_meta)
-          superclass.resource_meta
-        end
-      end
-
-      def has_one(name, meta: nil, **options)
-        @relationships ||= []
-
-        unless options.key?(:polymorphic)
-          model_klass = reflection_model_class
-          if model_klass.respond_to?(:reflect_on_association)
-            reflection = model_klass.reflect_on_association(name)
-            options[:polymorphic] = reflection&.polymorphic?
-          end
-        end
-
-        @relationships << { name: name.to_sym, type: :has_one, meta:, options: }
-      end
-
-      def has_many(name, meta: nil, **options)
-        @relationships ||= []
-
-        if options[:append_only] && options[:purge_on_nil] == true
-          raise ArgumentError, "Cannot use append_only: true with purge_on_nil: true"
-        end
-
-        options[:purge_on_nil] = false if options[:append_only] && !options.key?(:purge_on_nil)
-
-        unless options.key?(:polymorphic)
-          model_klass = reflection_model_class
-          if model_klass.respond_to?(:reflect_on_association)
-            reflection = model_klass.reflect_on_association(name)
-            options[:polymorphic] = reflection&.polymorphic?
-          end
-        end
-
-        @relationships << { name: name.to_sym, type: :has_many, meta:, options: }
-      end
-
-      def belongs_to(name, meta: nil, **options)
-        @relationships ||= []
-
-        unless options.key?(:polymorphic)
-          model_klass = reflection_model_class
-          if model_klass.respond_to?(:reflect_on_association)
-            reflection = model_klass.reflect_on_association(name)
-            options[:polymorphic] = reflection&.polymorphic?
-          end
-        end
-
-        @relationships << { name: name.to_sym, type: :belongs_to, meta:, options: }
-      end
-
-      def permitted_attributes
-        # For STI subclasses, merge with parent class attributes unless the subclass declares its own
-        declared_attributes = instance_variable_defined?(:@attributes)
-        attrs = @attributes || []
-        if !declared_attributes &&
-           superclass != JSONAPI::Resource &&
-           superclass.respond_to?(:permitted_attributes)
-          attrs = superclass.permitted_attributes + attrs
-        end
-        attrs.uniq
-      end
-
-      def permitted_creatable_fields
-        if instance_variable_defined?(:@creatable_fields)
-          fields = @creatable_fields || []
-        elsif superclass != JSONAPI::Resource &&
-              superclass.respond_to?(:permitted_creatable_fields) &&
-              superclass.instance_variable_defined?(:@creatable_fields)
-          parent_fields = superclass.permitted_creatable_fields
-          fields = parent_fields
-        else
-          fields = permitted_attributes
-        end
-
-        fields.uniq
-      end
-
-      def permitted_updatable_fields
-        if instance_variable_defined?(:@updatable_fields)
-          fields = @updatable_fields || []
-        elsif superclass != JSONAPI::Resource &&
-              superclass.respond_to?(:permitted_updatable_fields) &&
-              superclass.instance_variable_defined?(:@updatable_fields)
-          parent_fields = superclass.permitted_updatable_fields
-          fields = parent_fields
-        else
-          fields = permitted_attributes
-        end
-
-        fields.uniq
-      end
-
-      def permitted_filters
-        # For STI subclasses, merge with parent class filters unless the subclass declares its own
-        declared_filters = instance_variable_defined?(:@filters)
-        filter_list = @filters || []
-        if !declared_filters &&
-           superclass != JSONAPI::Resource &&
-           superclass.respond_to?(:permitted_filters)
-          filter_list = superclass.permitted_filters + filter_list
-        end
-        filter_list.uniq
-      end
-
-      def permitted_sortable_fields
-        # Include both attributes (which are sortable) and sort-only fields
-        # For STI subclasses, merge with parent class sortable fields when no subclass DSL is declared
-        declared_sortable = instance_variable_defined?(:@sortable_fields)
-        declared_attributes = instance_variable_defined?(:@attributes)
-        sort_fields = @sortable_fields || []
-        if !declared_sortable &&
-           !declared_attributes &&
-           superclass != JSONAPI::Resource &&
-           superclass.respond_to?(:permitted_sortable_fields)
-          parent_sort_fields = superclass.permitted_sortable_fields
-          # Only merge parent's sort-only fields, not attributes (attributes are already included via permitted_attributes)
-          parent_attributes = superclass.permitted_attributes
-          parent_sort_only = parent_sort_fields - parent_attributes
-          sort_fields = parent_sort_only + sort_fields
-        end
-        # Combine with attributes (all attributes are sortable)
-        (permitted_attributes + sort_fields).uniq
-      end
-
-      def relationship_definitions
-        # For STI subclasses, merge with parent class relationships
-        declared_relationships = instance_variable_defined?(:@relationships)
-        rels = @relationships || []
-        if !declared_relationships &&
-           superclass != JSONAPI::Resource &&
-           superclass.respond_to?(:relationship_definitions)
-          rels = superclass.relationship_definitions + rels
-        end
-        rels.uniq { |r| r[:name] }
-      end
-
-      def relationship_names
-        relationship_definitions.map { |r| r[:name] }
-      end
-
-      def model_class
-        name.sub(/Resource$/, "").classify.constantize
-      end
-
-      def safe_model_class
-        return nil unless respond_to?(:name) && name
-        return nil unless defined?(ActiveSupport)
-
-        name.sub(/Resource$/, "").classify.safe_constantize
-      rescue NoMethodError
-        nil
-      end
-
-      def reflection_model_class
-        model_class
-      rescue NameError
-        safe_model_class
-      rescue StandardError
-        safe_model_class
-      end
-    end
+    include Resources::AttributesDsl
+    include Resources::FiltersDsl
+    include Resources::SortableFieldsDsl
+    include Resources::RelationshipsDsl
+    include Resources::MetaDsl
+    include Resources::ModelClassHelpers
 
-    # Instance method to initialize resource with model instance
-    # This allows the serializer to instantiate resources directly
     def initialize(record = nil, context = {})
       @record = record
       @context = context
       @transformed_params = {}
     end
 
-    # Accessor for the underlying model instance
-    # @record is the preferred internal name, but :resource is kept for backward compatibility
     attr_reader :record
     alias resource record
 
-    # Returns transformed params accumulated by resource setters during deserialization
-    # Resources can override this method or use the default implementation
     def transformed_params
       @transformed_params || {}
     end

data/lib/json_api/routing.rb

@@ -2,71 +2,80 @@
 
 module JSONAPI
   module Routing
-    def jsonapi_resources(resource, controller: nil, defaults: {}, sti: false, **options, &block)
+    def jsonapi_resources(resource, controller: nil, defaults: {}, sti: false, **options, &)
       resource_name = resource.to_s
+      controller = detect_controller(resource_name) if controller.nil?
 
-      # Smart Controller Detection:
-      # If no controller is specified, try to find one in the current scope.
-      # If we find "Trust::VendorsController", use it (by passing nil to 'resources').
-      # If NOT found, default to the generic "json_api/resources".
-      if controller.nil?
-        scoped_module = @scope[:module]
-        potential_controller_name = if scoped_module
-                                      "#{scoped_module.to_s.camelize}::#{resource_name.pluralize.camelize}Controller"
-                                    else
-                                      "#{resource_name.pluralize.camelize}Controller"
-                                    end
+      JSONAPI::ResourceLoader.find(resource_name)
+      defaults = defaults.merge(format: :jsonapi, resource_type: resource_name)
+      options[:only] = :index if sti
 
-        begin
-          # Check if the controller exists constant
-          potential_controller_name.constantize
-          # It exists! Leave controller as nil so Rails uses standard routing conventions
-        rescue NameError
-          # It doesn't exist, fallback to generic controller
-          controller = "json_api/resources"
-        end
-      end
+      define_resource_routes(resource, controller, defaults, options, &)
+      define_sti_routes(resource, resource_name, defaults, sti)
+    end
 
-      # Validate that resource class exists at boot time
-      JSONAPI::ResourceLoader.find(resource_name)
+    private
 
-      defaults = defaults.merge(format: :jsonapi, resource_type: resource_name)
+    def detect_controller(resource_name)
+      potential_controller_name = build_controller_name(resource_name)
+      potential_controller_name.constantize
+      nil
+    rescue NameError
+      "json_api/resources"
+    end
 
-      options[:only] = :index if sti
+    def build_controller_name(resource_name)
+      scoped_module = @scope[:module]
+      base_name = "#{resource_name.pluralize.camelize}Controller"
+      return base_name unless scoped_module
 
-      resources(resource, controller:, defaults:, **options) do
-        member do
-          get "relationships/:relationship_name", to: "json_api/relationships#show", as: :relationship
-          patch "relationships/:relationship_name", to: "json_api/relationships#update"
-          delete "relationships/:relationship_name", to: "json_api/relationships#destroy"
-        end
+      "#{scoped_module.to_s.camelize}::#{base_name}"
+    end
 
+    def define_resource_routes(resource, controller, defaults, options, &block)
+      resources(resource, controller:, defaults:, **options) do
+        define_relationship_routes
         instance_eval(&block) if block
       end
+    end
+
+    def define_relationship_routes
+      member do
+        get "relationships/:relationship_name", to: "json_api/relationships#show", as: :relationship
+        patch "relationships/:relationship_name", to: "json_api/relationships#update"
+        delete "relationships/:relationship_name", to: "json_api/relationships#destroy"
+      end
+    end
 
+    def define_sti_routes(resource, resource_name, defaults, sti)
       return unless sti
 
       if sti.is_a?(Array)
-        sti.each do |sub_resource_name|
-          jsonapi_resources(sub_resource_name, defaults:)
-        end
+        define_explicit_sti_routes(sti,
+                                   defaults,)
       else
-        begin
-          resource_class = JSONAPI::ResourceLoader.find(resource_name)
-          model_class = resource_class.model_class
+        define_auto_sti_routes(resource, resource_name,
+                               defaults,)
+      end
+    end
+
+    def define_explicit_sti_routes(sti_resources, defaults)
+      sti_resources.each { |sub_resource_name| jsonapi_resources(sub_resource_name, defaults:) }
+    end
+
+    def define_auto_sti_routes(resource, resource_name, defaults)
+      resource_class = JSONAPI::ResourceLoader.find(resource_name)
+      model_class = resource_class.model_class
+      return unless model_class.respond_to?(:descendants)
 
-          if model_class.respond_to?(:descendants)
-            model_class.descendants.each do |subclass|
-              sub_resource_name = subclass.name.underscore.pluralize.to_sym
-              next if sub_resource_name == resource.to_sym
+      model_class.descendants.each do |subclass|
+        sub_resource_name = subclass.name.underscore.pluralize.to_sym
+        next if sub_resource_name == resource.to_sym
 
-              jsonapi_resources(sub_resource_name, defaults:)
-            end
-          end
-        rescue NameError, JSONAPI::ResourceLoader::MissingResourceClass
-          # Silently skip if model/resource not found
-        end
+        jsonapi_resources(sub_resource_name, defaults:)
       end
+    rescue NameError, JSONAPI::ResourceLoader::MissingResourceClass
+      nil
     end
   end
 end

data/lib/json_api/serialization/concerns/attributes_deserialization.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Serialization
+    module AttributesDeserialization
+      def attributes
+        attrs = extract_attributes_from_params
+        attrs = attrs.transform_keys(&:to_sym) if attrs.respond_to?(:transform_keys)
+        permitted_attrs = permitted_attributes_for_action
+        attrs.slice(*permitted_attrs)
+      end
+
+      def extract_attributes_from_params
+        @params.dig(:data, :attributes) || @params[:attributes] || {}
+      end
+
+      def permitted_attributes_for_action
+        fields = if @action == :create
+                   @definition.permitted_creatable_fields
+                 else
+                   @definition.permitted_updatable_fields
+                 end
+        fields.map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/json_api/serialization/concerns/attributes_serialization.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Serialization
+    module AttributesSerialization
+      def serialize_attributes(fields = {})
+        type_fields = extract_type_fields(fields)
+        return {} if type_fields.empty? && fields.any?
+
+        attributes = build_attributes_hash
+        return attributes if type_fields.empty?
+
+        attributes.slice(*type_fields.map(&:to_sym))
+      end
+
+      private
+
+      def extract_type_fields(fields)
+        fields[record_type.to_sym] || []
+      end
+
+      def build_attributes_hash
+        permitted_attrs = definition.permitted_attributes.map(&:to_sym)
+        attributes = {}
+        definition_instance = definition.new(record, {})
+
+        permitted_attrs.each do |attr_sym|
+          attributes[attr_sym] = get_attribute_value(definition_instance, attr_sym)
+        end
+
+        attributes.compact
+      end
+
+      def get_attribute_value(definition_instance, attr_sym)
+        return definition_instance.public_send(attr_sym) if definition_instance.respond_to?(attr_sym, false)
+
+        attr_name = attr_sym.to_s
+        return record.attributes[attr_name] if model_has_attribute?(attr_name)
+
+        nil
+      end
+
+      def model_has_attribute?(attr_name)
+        record.respond_to?(:attributes) &&
+          record.attributes.is_a?(Hash) &&
+          record.attributes.key?(attr_name)
+      end
+    end
+  end
+end