simple_jsonapi 1.0.0

data/lib/simple_jsonapi/node/errors.rb

@@ -0,0 +1,28 @@
+module SimpleJsonapi::Node
+  # @!attribute [r] errors
+  #   @return [Array<Object>]
+  class Errors < Base
+    attr_reader :errors
+
+    # @param errors [Array<Object>]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(errors:, **options)
+      super(options)
+
+      @errors = Array.wrap(errors)
+
+      @error_nodes = @errors.map do |error|
+        build_child_node(SimpleJsonapi::Node::Error, error: error)
+      end
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if @error_nodes.any?
+        { errors: @error_nodes.map(&:as_jsonapi) }
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/node/included.rb

@@ -0,0 +1,45 @@
+module SimpleJsonapi::Node
+  class Included < Base
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(**options)
+      super
+
+      @resource_nodes = {}
+    end
+
+    # @param resource_node [Node::Resource::Base]
+    def included_resource?(resource_node)
+      @resource_nodes.key?(hash_key(resource_node))
+    end
+
+    # @param resource_node [Node::Resource::Full]
+    # @return [Node::Resource::Full]
+    def append_included_resource(resource_node)
+      if included_resource?(resource_node)
+        raise DuplicateResourceError.new(resource_node.resource_type, resource_node.resource_id)
+      end
+
+      @resource_nodes[hash_key(resource_node)] = resource_node
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if @resource_nodes.any?
+        resources_json = @resource_nodes
+                         .each_value
+                         .sort_by { |node| [node.resource_type, node.resource_id] }
+                         .map(&:as_jsonapi)
+
+        { included: resources_json }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def hash_key(resource_node)
+      [resource_node.resource_type, resource_node.resource_id]
+    end
+  end
+end

data/lib/simple_jsonapi/node/object_links.rb

@@ -0,0 +1,40 @@
+module SimpleJsonapi::Node
+  # Represents a +links+ object (a collection of links).
+  #
+  # @!attribute [r] object
+  #   @return [Object]
+  # @!attribute [r] link_definitions
+  #   @return [Hash{Symbol => Definition::Link}]
+  class ObjectLinks < Base
+    attr_reader :object, :link_definitions
+
+    # @param object [Object]
+    # @param link_definitions [Hash{Symbol => Definition::Link}]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(object:, link_definitions:, **options)
+      super(options)
+
+      @object = object
+      @link_definitions = link_definitions
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if link_definitions_to_render.any?
+        json = {}
+        link_definitions_to_render.each do |name, defn|
+          json[name] = evaluate(defn.value_proc, object)
+        end
+        { links: json }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def link_definitions_to_render
+      @link_definitions_to_render ||= link_definitions.select { |_, defn| render?(defn, object) }
+    end
+  end
+end

data/lib/simple_jsonapi/node/object_meta.rb

@@ -0,0 +1,40 @@
+module SimpleJsonapi::Node
+  # Represents a +meta+ object (a collection of meta members).
+  #
+  # @!attribute [r] object
+  #   @return [Object]
+  # @!attribute [r] meta_definitions
+  #   @return [Hash{Symbol => Definition::Meta}]
+  class ObjectMeta < Base
+    attr_reader :object, :meta_definitions
+
+    # @param object [Object]
+    # @param meta_definitions [Hash{Symbol => Definition::Meta}]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(object:, meta_definitions:, **options)
+      super(options)
+
+      @object = object
+      @meta_definitions = meta_definitions || {}
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if meta_definitions_to_render.any?
+        json = {}
+        meta_definitions_to_render.each do |name, defn|
+          json[name] = evaluate(defn.value_proc, object)
+        end
+        { meta: json }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def meta_definitions_to_render
+      @meta_definitions_to_render ||= @meta_definitions.select { |_, defn| render?(defn, object) }
+    end
+  end
+end

data/lib/simple_jsonapi/node/relationship.rb

@@ -0,0 +1,79 @@
+module SimpleJsonapi::Node
+  # Represents a single +relationship+ object.
+  #
+  # @!attribute [r] resource
+  #   @return [Object]
+  # @!attribute [r] relationship_definition
+  #   @return [Definition::Relationship]
+  class Relationship < Base
+    attr_reader :resource, :relationship_definition
+
+    # @param resource [Object]
+    # @param relationship_definition [Definition::Relationship]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(resource:, relationship_definition:, **options)
+      super(options)
+
+      @resource = resource
+      @relationship_definition = relationship_definition
+
+      if relationship_definition.singular?
+        @data_node = build_child_node(
+          SimpleJsonapi::Node::RelationshipData::Singular,
+          relationship_definition: relationship_definition,
+          resource: related_data,
+          add_to_included: add_to_included?,
+        )
+      elsif relationship_definition.collection?
+        @data_node = build_child_node(
+          SimpleJsonapi::Node::RelationshipData::Collection,
+          relationship_definition: relationship_definition,
+          resources: related_data,
+          add_to_included: add_to_included?,
+        )
+      end
+
+      @links_node = build_child_node(
+        SimpleJsonapi::Node::ObjectLinks,
+        object: resource,
+        link_definitions: relationship_definition.link_definitions,
+      )
+
+      @meta_node = build_child_node(
+        SimpleJsonapi::Node::ObjectMeta,
+        object: resource,
+        meta_definitions: relationship_definition.meta_definitions,
+      )
+    end
+
+    # @return [String]
+    def relationship_name
+      relationship_definition.name
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      rel_json = {}
+
+      rel_json.merge!(@data_node.as_jsonapi) if @data_node
+      rel_json.merge!(@links_node.as_jsonapi) if @links_node
+      rel_json.merge!(@meta_node.as_jsonapi) if @meta_node
+
+      rel_json
+    end
+
+    private
+
+    def related_data
+      @related_data ||= evaluate(
+        relationship_definition.data_definition,
+        resource,
+        sort: sort_spec[relationship_name.to_sym],
+      )
+    end
+
+    def add_to_included?
+      include_spec.include?(relationship_name)
+    end
+  end
+end

data/lib/simple_jsonapi/node/relationship_data/base.rb

@@ -0,0 +1,53 @@
+module SimpleJsonapi::Node::RelationshipData
+  # Represents a relationship's +data+ object.
+  #
+  # @abstract
+  # @!attribute [r] relationship_definition
+  #   @return [Definition::Relationship]
+  # @!attribute [r] add_to_included
+  #   @return [Boolean]
+  class Base < SimpleJsonapi::Node::Base
+    attr_reader :relationship_definition, :add_to_included
+
+    # @param relationship_definition [Definition::Relationship]
+    # @param add_to_included [Boolean]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(relationship_definition:, add_to_included:, **options)
+      super(options)
+
+      @relationship_definition = relationship_definition
+      @add_to_included = add_to_included
+
+      @serializer_inferrer = relationship_definition.serializer_inferrer
+      @include_spec = include_spec[relationship_name]
+    end
+
+    private
+
+    def build_linkage_node(related_resource)
+      build_child_node(
+        SimpleJsonapi::Node::Resource::Linkage,
+        resource: related_resource,
+        meta: { included: add_to_included },
+      )
+    end
+
+    def add_resource_to_included(related_resource, linkage_node)
+      if add_to_included && !root_node.included_resource?(linkage_node)
+        full_node = build_child_node(
+          SimpleJsonapi::Node::Resource::Full,
+          # Only support sorting on first-level relationships because
+          #  1. supporting more levels requires more tracking of how the document is being built
+          #  2. letting the API client sort a deeper relationship seems unnecessary
+          sort_related: nil,
+          resource: related_resource,
+        )
+        root_node.append_included_resource(full_node)
+      end
+    end
+
+    def relationship_name
+      relationship_definition.name
+    end
+  end
+end

data/lib/simple_jsonapi/node/relationship_data/collection.rb

@@ -0,0 +1,32 @@
+module SimpleJsonapi::Node::RelationshipData
+  # Represents a relationship's +data+ object containing a collection of
+  # resource linkage objects.
+  #
+  # @!attribute [r] resources
+  #   @return [Array<Object>]
+  class Collection < Base
+    attr_reader :resources
+
+    # @param resources [Array<Object>]
+    # @param options see {Node::RelationshipData::Base#initialize} for additional parameters
+    def initialize(resources:, **options)
+      super
+
+      @resources = Array.wrap(resources)
+      @linkage_nodes = []
+
+      @resources.each do |resource|
+        linkage_node = build_linkage_node(resource)
+
+        @linkage_nodes << linkage_node
+
+        add_resource_to_included(resource, linkage_node)
+      end
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      { data: @linkage_nodes.map(&:as_jsonapi) }
+    end
+  end
+end

data/lib/simple_jsonapi/node/relationship_data/singular.rb

@@ -0,0 +1,33 @@
+module SimpleJsonapi::Node::RelationshipData
+  # Represents a relationship's +data+ object containing a single resource
+  # linkage object.
+  #
+  # @!attribute [r] resource
+  #   @return [Object]
+  class Singular < Base
+    attr_reader :resource
+
+    # @param resource [Object]
+    # @param options see {Node::RelationshipData::Base#initialize} for additional parameters
+    def initialize(resource:, **options)
+      super
+
+      @resource = resource
+
+      unless @resource.nil?
+        @linkage_node = build_linkage_node(@resource)
+
+        add_resource_to_included(@resource, @linkage_node)
+      end
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if resource.nil?
+        { data: nil }
+      else
+        { data: @linkage_node.as_jsonapi }
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/node/relationships.rb

@@ -0,0 +1,60 @@
+module SimpleJsonapi::Node
+  # Represents a resource's +relationships+ object, which contains the
+  # individual +relationship+ object.
+  #
+  # @!attribute [r] resource
+  #   @return [Object]
+  # @!attribute [r] resource_type
+  #   @return [String]
+  # @!attribute [r] relationship_definitions
+  #   @return [Hash{Symbol => Definition::Relationship}]
+  class Relationships < Base
+    attr_reader :resource, :resource_type, :relationship_definitions
+
+    # @param resource [Object]
+    # @param resource_type [String]
+    # @param relationship_definitions [Hash{Symbol => Definition::Relationship}]
+    # @param options see {Node::Base#initialize} for additional parameters
+    def initialize(resource:, resource_type:, relationship_definitions:, **options)
+      super(options)
+
+      @resource = resource
+      @resource_type = resource_type
+      @relationship_definitions = relationship_definitions
+
+      @relationship_nodes = relationship_definitions_to_render.map do |_name, defn|
+        build_child_node(
+          SimpleJsonapi::Node::Relationship,
+          resource: resource,
+          relationship_definition: defn,
+        )
+      end
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def as_jsonapi
+      if @relationship_nodes.any?
+        json = {}
+        @relationship_nodes.each do |rel_node|
+          json[rel_node.relationship_name] = rel_node.as_jsonapi
+        end
+        { relationships: json }
+      else
+        {}
+      end
+    end
+
+    private
+
+    def relationship_definitions_to_render
+      @relationship_definitions_to_render ||= begin
+        include_all_fields = fields_spec.all_fields?(resource_type)
+        explicit_fields = fields_spec[resource_type]
+
+        relationship_definitions
+          .select { |name, _| include_all_fields || explicit_fields.include?(name) }
+          .select { |_, defn| render?(defn, resource) }
+      end
+    end
+  end
+end

data/lib/simple_jsonapi/node/resource/base.rb

@@ -0,0 +1,21 @@
+module SimpleJsonapi::Node::Resource
+  # Represents a single resource object or resource linkage object.
+  class Base < SimpleJsonapi::Node::Base
+    attr_reader :resource
+
+    def initialize(resource:, **options)
+      super(options)
+
+      @resource = resource
+      @serializer = serializer_inferrer.infer(resource).new
+    end
+
+    def resource_id
+      @resource_id ||= evaluate(serializer.id_definition, resource).to_s
+    end
+
+    def resource_type
+      @resource_type ||= evaluate(serializer.type_definition, resource).to_s
+    end
+  end
+end