active_model_resource.rb

module V0
  module ActiveModelResource
    def self.included(klass)
      klass.extend(ClassMethods)
    end

    module ClassMethods
      def find_fragments(filters, options = {})
        linkage_relationships = to_one_relationships_for_linkage({})
        fragments = {}

        find_models(filters, options).each do |model|
          resource_identity = JSONAPI::ResourceIdentity.new(self, model.id)
          resource_fragment =
            fragments[resource_identity] =
              JSONAPI::ResourceFragment.new(resource_identity)

          linkage_relationships.each do |name|
            resource_fragment.initialize_related(name)

            related_id = model.send("#{name}_id")
            next unless related_id

            resource_fragment.add_related_identity(name,
              JSONAPI::ResourceIdentity.new(_relationship(name).resource_klass, related_id))
          end
        end

        fragments
      end

      def find_included_fragments(source_rids, relationship_name, options)
        relationship = _relationship(relationship_name)
        relationship_class = relationship.resource_klass
        fragments = {}

        source_rids.map(&:id).each do |id|
          models = [*find_model_by_id(id, options).send(relationship_name)]
          next if models.blank?

          models.each do |model|
            resource_identity = JSONAPI::ResourceIdentity.new(relationship_class, model.id)
            resource_fragment =
              fragments[resource_identity] =
                JSONAPI::ResourceFragment.new(resource_identity)

            relationship_class.to_one_relationships_for_linkage({}).each do |name|
              resource_fragment.initialize_related(name)

              related_id = model.send("#{name}_id")
              next unless related_id

              resource_fragment.add_related_identity(
                name,
                JSONAPI::ResourceIdentity.new(
                  relationship_class._relationship(name).resource_klass,
                  related_id
                )
              )
            end
          end
        end

        fragments
      end

      def find_to_populate_by_keys(keys, options = {})
        records = keys.map { |key| find_model_by_id(key, options) }
        resources_for(records, options[:context])
      end

      def find_model_error_class
        StandardError
      end

      def find_models(filters, options)
        models = []

        if filters[:id].present?
          # rubocop:disable Lint/SuppressedException
          [*filters[:id]].each do |id|
            models << find_model_by_id(id, options)
          rescue find_model_error_class
          end
          # rubocop:enable Lint/SuppressedException
        end

        models
      end

      def find_model_by_id(id, _options)
        _model_class.find(id)
      end
    end
  end
end