jat 0.0.1 → 0.0.3

data/lib/jat/plugins/json_api/json_api.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative "./lib/response"
+require_relative "./lib/traversal_map"
+require_relative "./lib/presenters/document_links_presenter"
+require_relative "./lib/presenters/document_meta_presenter"
+require_relative "./lib/presenters/jsonapi_presenter"
+require_relative "./lib/presenters/links_presenter"
+require_relative "./lib/presenters/meta_presenter"
+require_relative "./lib/presenters/relationship_links_presenter"
+require_relative "./lib/presenters/relationship_meta_presenter"
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module JsonApi
+      def self.after_load(jat_class, **opts)
+        jat_class.plugin(:_json_api_activerecord, **opts) if opts[:activerecord]
+
+        jat_class.const_set(:JsonapiPresenter, Class.new(Jat::Presenters::JsonapiPresenter))
+        jat_class::JsonapiPresenter.jat_class = jat_class
+
+        jat_class.const_set(:LinksPresenter, Class.new(Jat::Presenters::LinksPresenter))
+        jat_class::LinksPresenter.jat_class = jat_class
+
+        jat_class.const_set(:DocumentLinksPresenter, Class.new(Jat::Presenters::DocumentLinksPresenter))
+        jat_class::DocumentLinksPresenter.jat_class = jat_class
+
+        jat_class.const_set(:RelationshipLinksPresenter, Class.new(Jat::Presenters::RelationshipLinksPresenter))
+        jat_class::RelationshipLinksPresenter.jat_class = jat_class
+
+        jat_class.const_set(:MetaPresenter, Class.new(Jat::Presenters::MetaPresenter))
+        jat_class::MetaPresenter.jat_class = jat_class
+
+        jat_class.const_set(:DocumentMetaPresenter, Class.new(Jat::Presenters::DocumentMetaPresenter))
+        jat_class::DocumentMetaPresenter.jat_class = jat_class
+
+        jat_class.const_set(:RelationshipMetaPresenter, Class.new(Jat::Presenters::RelationshipMetaPresenter))
+        jat_class::RelationshipMetaPresenter.jat_class = jat_class
+      end
+
+      module InstanceMethods
+        def to_h
+          Response.new(self).response
+        end
+
+        def traversal_map
+          @traversal_map ||= TraversalMap.new(self)
+        end
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          subclass.type(@type) if defined?(@type)
+
+          # Initialize JsonApi data Presenters
+          jsonapi_data_presenter_class = Class.new(self::Presenters::JsonapiPresenter)
+          jsonapi_data_presenter_class.jat_class = subclass
+          subclass.const_set(:JsonapiPresenter, jsonapi_data_presenter_class)
+          jsonapi_data.each { |key, block| subclass.jsonapi(key, &block) }
+
+          # Initialize Links Presenters
+          links_presenter_class = Class.new(self::Presenters::LinksPresenter)
+          links_presenter_class.jat_class = subclass
+          subclass.const_set(:LinksPresenter, links_presenter_class)
+          object_links.each { |key, block| subclass.object_link(key, &block) }
+
+          # Initialize DocumentLinks Presenters
+          document_links_presenter_class = Class.new(self::Presenters::DocumentLinksPresenter)
+          document_links_presenter_class.jat_class = subclass
+          subclass.const_set(:DocumentLinksPresenter, document_links_presenter_class)
+          document_links.each { |key, block| subclass.document_link(key, &block) }
+
+          # Initialize RelationshipLinks Presenters
+          relationship_links_presenter_class = Class.new(self::Presenters::RelationshipLinksPresenter)
+          relationship_links_presenter_class.jat_class = subclass
+          subclass.const_set(:RelationshipLinksPresenter, relationship_links_presenter_class)
+          relationship_links.each { |key, block| subclass.relationship_link(key, &block) }
+
+          # Initialize Meta Presenters
+          meta_presenter_class = Class.new(self::Presenters::MetaPresenter)
+          meta_presenter_class.jat_class = subclass
+          subclass.const_set(:MetaPresenter, meta_presenter_class)
+          added_object_meta.each { |key, block| subclass.object_meta(key, &block) }
+
+          # Initialize DocumentMeta Presenters
+          document_meta_presenter_class = Class.new(self::Presenters::DocumentMetaPresenter)
+          document_meta_presenter_class.jat_class = subclass
+          subclass.const_set(:DocumentMetaPresenter, document_meta_presenter_class)
+          added_document_meta.each { |key, block| subclass.document_meta(key, &block) }
+
+          # Initialize RelationshipMeta Presenters
+          relationship_meta_presenter_class = Class.new(self::Presenters::RelationshipMetaPresenter)
+          relationship_meta_presenter_class.jat_class = subclass
+          subclass.const_set(:RelationshipMetaPresenter, relationship_meta_presenter_class)
+          added_relationship_meta.each { |key, block| subclass.relationship_meta(key, &block) }
+
+          super
+        end
+
+        def type(new_type = nil)
+          return (defined?(@type) && @type) || raise(Error, "#{self} has no defined type") unless new_type
+
+          new_type = new_type.to_sym
+          @type = new_type
+        end
+
+        def relationship(name, serializer:, **opts, &block)
+          attribute(name, serializer: serializer, **opts, &block)
+        end
+
+        # JSON API block values
+        #
+        # https://jsonapi.org/format/#document-jsonapi-object
+        def jsonapi_data(value = nil)
+          @jsonapi_data ||= {}
+        end
+
+        def jsonapi(key, &block)
+          jsonapi_data[key.to_sym] = block
+          self::JsonapiPresenter.add_method(key, block)
+          block
+        end
+
+        # Links related to the resource
+        #
+        # https://jsonapi.org/format/#document-resource-object-links
+        def object_links
+          @object_links ||= {}
+        end
+
+        def object_link(key, &block)
+          object_links[key.to_sym] = block
+          self::LinksPresenter.add_method(key, block)
+          block
+        end
+
+        # Top-level document links
+        #
+        # https://jsonapi.org/format/#document-top-level
+        def document_links
+          @document_links ||= {}
+        end
+
+        def document_link(key, &block)
+          document_links[key.to_sym] = block
+          self::DocumentLinksPresenter.add_method(key, block)
+          block
+        end
+
+        # Relationship links
+        #
+        # https://jsonapi.org/format/#document-resource-object-linkage
+        def relationship_links
+          @relationship_links ||= {}
+        end
+
+        def relationship_link(key, &block)
+          relationship_links[key.to_sym] = block
+          self::RelationshipLinksPresenter.add_method(key, block)
+          block
+        end
+
+        # Object meta
+        #
+        # https://jsonapi.org/format/#document-resource-objects
+        def added_object_meta
+          @added_object_meta ||= {}
+        end
+
+        def object_meta(key, &block)
+          added_object_meta[key.to_sym] = block
+          self::MetaPresenter.add_method(key, block)
+          block
+        end
+
+        # Top-level document meta
+        #
+        # https://jsonapi.org/format/#document-meta
+        def added_document_meta
+          @added_document_meta ||= {}
+        end
+
+        def document_meta(key, &block)
+          added_document_meta[key.to_sym] = block
+          self::DocumentMetaPresenter.add_method(key, block)
+          block
+        end
+
+        # Relationship meta
+        #
+        # https://jsonapi.org/format/#document-resource-object-relationships
+        def added_relationship_meta
+          @added_relationship_meta ||= {}
+        end
+
+        def relationship_meta(key, &block)
+          added_relationship_meta[key.to_sym] = block
+          self::RelationshipMetaPresenter.add_method(key, block)
+          block
+        end
+      end
+    end
+
+    register_plugin(:json_api, JsonApi)
+  end
+end

data/lib/jat/plugins/json_api/lib/construct_traversal_map.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+##
+# Combines all serializer and its realtions exposed fields into one hash.
+# Returns Hash
+# {
+#   type1 => {
+#     serializer: ser1,
+#     attributes: [attr1, attr2, ...],
+#     relationships: [attr1, attr2, ...]
+#   },
+#
+class Jat
+  module Plugins
+    module JsonApi
+      class ConstructTraversalMap
+        attr_reader :jat_class, :result, :exposed, :manually_exposed
+
+        EXPOSED_VALUES = {all: :all, exposed: :exposed, manual: :manual}.freeze
+
+        def initialize(jat_class, exposed, manually_exposed: {})
+          @jat_class = jat_class
+          @exposed = EXPOSED_VALUES.fetch(exposed)
+          @manually_exposed = manually_exposed
+        end
+
+        def to_h
+          @result = {}
+          append(jat_class)
+          result
+        end
+
+        private
+
+        def append(jat_class)
+          type = jat_class.type
+          return result if result.key?(type)
+
+          result[type] = {
+            serializer: jat_class,
+            attributes: [],
+            relationships: []
+          }
+
+          fill(jat_class)
+        end
+
+        def fill(jat_class)
+          type = jat_class.type
+          type_result = result[type]
+
+          jat_class.attributes.each_value do |attribute|
+            next unless expose?(type, attribute)
+
+            fill_attr(type_result, attribute)
+          end
+        end
+
+        def fill_attr(type_result, attribute)
+          name = attribute.name
+
+          if attribute.relation?
+            type_result[:relationships] << name
+            append(attribute.serializer.call)
+          else
+            type_result[:attributes] << name
+          end
+        end
+
+        def expose?(type, attribute)
+          return false if attribute.name == :id
+
+          case exposed
+          when :all then true
+          when :manual then manually_exposed?(type, attribute)
+          else attribute.exposed? || manually_exposed?(type, attribute)
+          end
+        end
+
+        # Return `attribute.exposed?` when type is not provided
+        # Checks type is in exposed attributes
+        def manually_exposed?(type, attribute)
+          return attribute.exposed? unless manually_exposed.key?(type)
+
+          exposed_attrs = manually_exposed[type]
+          exposed_attrs.include?(attribute.name)
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/map.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative "./params/fields"
+require_relative "./params/include"
+require_relative "./construct_traversal_map"
+
+class Jat
+  module Plugins
+    module JsonApi
+      class Map
+        class << self
+          # Returns structure like
+          # {
+          #   type => {
+          #     attributes: [attr1, attr2, ...],
+          #     relationships: [rel1, rel2, ...]
+          #   }
+          # }
+          def call(jat)
+            params = jat.context[:params]
+            fields = params && (params[:fields] || params["fields"])
+            includes = params && (params[:include] || params["include"])
+
+            default_attrs = jat.traversal_map.exposed
+            includes_attrs = requested_includes_fields(jat, includes)
+            fields_attrs = requested_fields(jat, fields)
+
+            default_attrs.merge!(includes_attrs).merge!(fields_attrs)
+          end
+
+          private
+
+          def requested_includes_fields(jat, includes)
+            return {} unless includes
+
+            include_types = Params::Include.call(jat, includes)
+            ConstructTraversalMap
+              .new(jat.class, :exposed, manually_exposed: include_types)
+              .to_h
+          end
+
+          def requested_fields(jat, fields)
+            return {} unless fields
+
+            fields_types = Params::Fields.call(jat, fields)
+            ConstructTraversalMap
+              .new(jat.class, :manual, manually_exposed: fields_types)
+              .to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/params/fields/parse.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Fields
+          class Parse
+            COMMA = ","
+
+            class << self
+              # returns Hash { type => [attr1, attr2] }
+              def call(fields)
+                return {} unless fields
+
+                fields.each_with_object({}) do |(type, attrs_string), obj|
+                  attrs = attrs_string.split(COMMA).map!(&:to_sym)
+                  obj[type.to_sym] = attrs
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/params/fields/validate.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Fields
+          class Validate
+            class << self
+              def call(jat, fields)
+                fields.each do |type, attributes_names|
+                  new(jat, type).validate(attributes_names)
+                end
+              end
+            end
+
+            attr_reader :jat, :type
+
+            def initialize(jat, type)
+              @jat = jat
+              @type = type
+            end
+
+            def validate(attributes_names)
+              check_fields_type
+              check_attributes_names(attributes_names)
+            end
+
+            private
+
+            def check_fields_type
+              return if jat.traversal_map.full.key?(type)
+
+              raise Error, "#{jat.class} and its children have no requested type `#{type}`"
+            end
+
+            def check_attributes_names(attributes_names)
+              attributes_names.each do |attribute_name|
+                check_attribute_name(attribute_name)
+              end
+            end
+
+            def check_attribute_name(attribute_name)
+              type_data = jat.traversal_map.full.fetch(type)
+              type_serializer = type_data.fetch(:serializer)
+              return if type_serializer.attributes.key?(attribute_name)
+
+              raise Error, "#{type_serializer} has no requested attribute or relationship `#{attribute_name}`"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/params/fields.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "./fields/parse"
+require_relative "./fields/validate"
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Fields
+          class << self
+            # returns Hash { type => [key1, key2] }
+            def call(jat, fields)
+              parsed_fields = Parse.call(fields)
+              Validate.call(jat, parsed_fields)
+              parsed_fields
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/params/include/parse.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Include
+          class Parse
+            COMMA = ","
+            DOT = "."
+
+            class << self
+              def call(includes_string)
+                return {} unless includes_string
+
+                string_to_hash(includes_string)
+              end
+
+              private
+
+              def string_to_hash(includes_string)
+                includes_string.split(COMMA).each_with_object({}) do |part, obj|
+                  includes = parse_part(part)
+                  deep_merge!(obj, includes)
+                end
+              end
+
+              def parse_part(part)
+                val = {}
+
+                part.split(DOT).reverse_each do |inc|
+                  val = {inc.to_sym => val}
+                end
+
+                val
+              end
+
+              def deep_merge!(this_hash, other_hash)
+                this_hash.merge!(other_hash) do |_key, this_val, other_val|
+                  deep_merge(this_val, other_val)
+                end
+              end
+
+              def deep_merge(this_hash, other_hash)
+                this_hash.merge(other_hash) do |_key, this_val, other_val|
+                  deep_merge(this_val, other_val)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/params/include/validate.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Include
+          class Validate
+            class << self
+              def call(jat_class, includes)
+                includes.each do |name, nested_includes|
+                  attribute = jat_class.attributes[name]
+                  raise_error(jat_class, name) if !attribute || !attribute.relation?
+
+                  nested_serializer = attribute.serializer.call
+                  call(nested_serializer, nested_includes)
+                end
+              end
+
+              def raise_error(jat_class, name)
+                raise Error, "#{jat_class} has no `#{name}` relationship"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/params/include.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "./include/parse"
+require_relative "./include/validate"
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Include
+          class << self
+            # returns Hash { type => [attr1, attr2] }
+            def call(jat, includes_string)
+              return {} unless includes_string
+
+              jat_class = jat.class
+              includes = Parse.call(includes_string)
+              Validate.call(jat_class, includes)
+
+              typed_includes(jat_class, includes, {})
+            end
+
+            private
+
+            def typed_includes(jat_class, includes, result)
+              includes.each do |included_attr_name, nested_includes|
+                add_include(result, jat_class, included_attr_name)
+
+                nested_serializer = jat_class.attributes.fetch(included_attr_name).serializer.call
+                typed_includes(nested_serializer, nested_includes, result)
+              end
+
+              result
+            end
+
+            def add_include(result, serializer, included_attr_name)
+              type = serializer.type
+
+              includes = result[type] || []
+              includes |= [included_attr_name]
+
+              result[type] = includes
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/presenters/document_links_presenter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class DocumentLinksPresenter
+      module InstanceMethods
+        # Presented object
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(object, context)
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::DocumentLinksPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(object, &block) }
+          when 2 then -> { instance_exec(object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end

data/lib/jat/plugins/json_api/lib/presenters/document_meta_presenter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Jat
+  module Presenters
+    class DocumentMetaPresenter
+      module InstanceMethods
+        # Presented object
+        attr_reader :object
+
+        # Presented context
+        attr_reader :context
+
+        def initialize(object, context)
+          @object = object
+          @context = context
+        end
+      end
+
+      module ClassMethods
+        attr_accessor :jat_class
+
+        def inspect
+          "#{jat_class.inspect}::Presenters::DocumentMetaPresenter"
+        end
+
+        def add_method(name, block)
+          # Warning-free method redefinition
+          remove_method(name) if method_defined?(name, false)
+          define_method(name, &block_without_args(block))
+        end
+
+        private
+
+        def block_without_args(block)
+          case block.parameters.count
+          when 0 then block
+          when 1 then -> { instance_exec(object, &block) }
+          when 2 then -> { instance_exec(object, context, &block) }
+          else raise Error, "Invalid block arguments count"
+          end
+        end
+      end
+
+      extend ClassMethods
+      include InstanceMethods
+    end
+  end
+end