jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "./lib/fields_param_parser"
+require_relative "./lib/include_param_parser"
+require_relative "./lib/map"
+require_relative "./lib/response"
+require_relative "./lib/response_piece"
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module JsonApi
+      def self.plugin_name
+        :json_api
+      end
+
+      def self.before_load(jat_class, **_opts)
+        response_plugin = jat_class.config[:response_plugin_loaded]
+        return unless response_plugin
+
+        raise Error, "Response plugin `#{response_plugin}` was already loaded before"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+        jat_class.extend(ClassMethods)
+      end
+
+      def self.after_load(jat_class, **opts)
+        jat_class.config[:response_plugin_loaded] = plugin_name
+
+        fields_parser_class = Class.new(FieldsParamParser)
+        fields_parser_class.jat_class = jat_class
+        jat_class.const_set(:FieldsParamParser, fields_parser_class)
+
+        includes_parser_class = Class.new(IncludeParamParser)
+        includes_parser_class.jat_class = jat_class
+        jat_class.const_set(:IncludeParamParser, includes_parser_class)
+
+        map_class = Class.new(Map)
+        map_class.jat_class = jat_class
+        jat_class.const_set(:Map, map_class)
+
+        response_class = Class.new(Response)
+        response_class.jat_class = jat_class
+        jat_class.const_set(:Response, response_class)
+
+        response_piece_class = Class.new(ResponsePiece)
+        response_piece_class.jat_class = jat_class
+        jat_class.const_set(:ResponsePiece, response_piece_class)
+
+        jat_class.id
+      end
+
+      module InstanceMethods
+        def to_h(object)
+          self.class::Response.call(object, context)
+        end
+
+        def map
+          @map ||= self.class.map(context)
+        end
+      end
+
+      module ClassMethods
+        def inherited(subclass)
+          super
+
+          fields_parser_class = Class.new(self::FieldsParamParser)
+          fields_parser_class.jat_class = subclass
+          subclass.const_set(:FieldsParamParser, fields_parser_class)
+
+          includes_parser_class = Class.new(self::IncludeParamParser)
+          includes_parser_class.jat_class = subclass
+          subclass.const_set(:IncludeParamParser, includes_parser_class)
+
+          map_class = Class.new(self::Map)
+          map_class.jat_class = subclass
+          subclass.const_set(:Map, map_class)
+
+          response_class = Class.new(self::Response)
+          response_class.jat_class = subclass
+          subclass.const_set(:Response, response_class)
+
+          response_piece_class = Class.new(self::ResponsePiece)
+          response_piece_class.jat_class = subclass
+          subclass.const_set(:ResponsePiece, response_piece_class)
+
+          subclass.type(@type) if defined?(@type)
+          subclass.id(&get_id.params[:block])
+
+          # Assign same jsonapi_data
+          jsonapi_data.each_value do |attribute|
+            params = attribute.params
+            subclass.jsonapi(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same object_links
+          object_links.each_value do |attribute|
+            params = attribute.params
+            subclass.object_link(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same document_links
+          document_links.each_value do |attribute|
+            params = attribute.params
+            subclass.document_link(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same relationship_links
+          relationship_links.each_value do |attribute|
+            params = attribute.params
+            subclass.relationship_link(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same added_object_meta
+          added_object_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.object_meta(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same added_document_meta
+          added_document_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.document_meta(params[:name], **params[:opts], &params[:block])
+          end
+
+          # Assign same added_relationship_meta
+          added_relationship_meta.each_value do |attribute|
+            params = attribute.params
+            subclass.relationship_meta(params[:name], **params[:opts], &params[:block])
+          end
+        end
+
+        def get_type
+          (defined?(@type) && @type) || raise(Error, "#{self} has no defined type")
+        end
+
+        def type(new_type)
+          @type = new_type.to_sym
+        end
+
+        def get_id
+          @id
+        end
+
+        def id(**opts, &block)
+          @id = self::Attribute.new(name: :id, opts: opts, block: block)
+        end
+
+        # JSON API block values
+        #
+        # https://jsonapi.org/format/#document-jsonapi-object
+        def jsonapi_data(_value = nil)
+          @jsonapi_data ||= {}
+        end
+
+        def jsonapi(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          jsonapi_data[new_attr.name] = new_attr
+        end
+
+        # Links related to the resource
+        #
+        # https://jsonapi.org/format/#document-resource-object-links
+        def object_links
+          @object_links ||= {}
+        end
+
+        def object_link(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          object_links[new_attr.name] = new_attr
+        end
+
+        # Top-level document links
+        #
+        # https://jsonapi.org/format/#document-top-level
+        def document_links
+          @document_links ||= {}
+        end
+
+        def document_link(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          document_links[new_attr.name] = new_attr
+        end
+
+        # Relationship links
+        #
+        # https://jsonapi.org/format/#document-resource-object-linkage
+        def relationship_links
+          @relationship_links ||= {}
+        end
+
+        def relationship_link(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          relationship_links[new_attr.name] = new_attr
+        end
+
+        # Object meta
+        #
+        # https://jsonapi.org/format/#document-resource-objects
+        def added_object_meta
+          @added_object_meta ||= {}
+        end
+
+        def object_meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_object_meta[new_attr.name] = new_attr
+        end
+
+        # Top-level document meta
+        #
+        # https://jsonapi.org/format/#document-meta
+        def added_document_meta
+          @added_document_meta ||= {}
+        end
+
+        def document_meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_document_meta[new_attr.name] = new_attr
+        end
+
+        # Relationship meta
+        #
+        # https://jsonapi.org/format/#document-resource-object-relationships
+        def added_relationship_meta
+          @added_relationship_meta ||= {}
+        end
+
+        def relationship_meta(name, **opts, &block)
+          new_attr = self::Attribute.new(name: name, opts: opts, block: block)
+          added_relationship_meta[new_attr.name] = new_attr
+        end
+
+        def map(context)
+          self::Map.call(context)
+        end
+
+        def map_full
+          @map_full ||= self::Map.call(exposed: :all)
+        end
+
+        def map_exposed
+          @map_exposed ||= self::Map.call(exposed: :default)
+        end
+      end
+    end
+
+    register_plugin(JsonApi.plugin_name, JsonApi)
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class FieldsParamParser
+        module ClassMethods
+          COMMA = ","
+
+          # Returns the Jat class that this FieldsParamParser class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since FieldsParamParser is anonymously subclassed when Jat is subclassed,
+          # and then assigned to a constant of the Jat subclass, make inspect
+          # reflect the likely name for the class.
+          def inspect
+            "#{jat_class.inspect}::FieldsParamParser"
+          end
+
+          def parse(fields)
+            return FROZEN_EMPTY_HASH unless fields
+
+            parse_to_nested_hash(fields)
+          end
+
+          private
+
+          def parse_to_nested_hash(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
+
+        extend ClassMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class IncludeParamParser
+        module ClassMethods
+          COMMA = ","
+          DOT = "."
+
+          # Returns the Jat class that this IncludeParamParser class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since IncludeParamParser is anonymously subclassed when Jat is subclassed,
+          # and then assigned to a constant of the Jat subclass, make inspect
+          # reflect the likely name for the class.
+          def inspect
+            "#{jat_class.inspect}::IncludeParamParser"
+          end
+
+          def parse(includes_string_param)
+            return {} unless includes_string_param
+
+            includes_hash = parse_to_nested_hash(includes_string_param)
+            typed_includes(jat_class, includes_hash, {})
+          end
+
+          private
+
+          def parse_to_nested_hash(includes_string_param)
+            includes_string_param.split(COMMA).each_with_object({}) do |part, obj|
+              includes = parse_part(part)
+              deep_merge!(obj, includes)
+            end
+          end
+
+          def typed_includes(jat_class, includes, result)
+            includes.each do |included_attr_name, nested_includes|
+              add_typed_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_typed_include(result, serializer, included_attr_name)
+            type = serializer.get_type
+
+            includes = result[type] || []
+            includes |= [included_attr_name]
+
+            result[type] = includes
+          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
+
+        extend ClassMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class Map
+        module ClassMethods
+          # Returns the Jat class that this Map class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since Map is anonymously subclassed when Jat is subclassed,
+          # and then assigned to a constant of the Jat subclass, make inspect
+          # reflect the likely name for the class.
+          def inspect
+            "#{jat_class.inspect}::Map"
+          end
+
+          # Returns structure like
+          # {
+          #   type1 => {
+          #     attributes: [attr1, attr2, ...],
+          #     relationships: [rel1, rel2, ...]
+          #   },
+          #   type2 => { ... }
+          # }
+          def call(context)
+            exposed = context[:exposed]&.to_sym || :default
+            fields = context[:fields]
+            includes = context[:include]
+
+            construct_map(exposed, fields, includes)
+          end
+
+          private
+
+          def construct_map(exposed, fields, includes)
+            fields = jat_class::FieldsParamParser.parse(fields) if fields
+            includes = jat_class::IncludeParamParser.parse(includes) if includes
+
+            new(exposed, fields, includes).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :jat_class, :exposed, :includes, :fields
+
+          EXPOSED_TYPES = {all: :all, default: :default, none: :none}.freeze
+
+          def initialize(exposed, fields, includes)
+            @jat_class = self.class.jat_class
+            @exposed = EXPOSED_TYPES.fetch(exposed)
+            @fields = fields
+            @includes = includes
+          end
+
+          def to_h
+            map = {}
+            append_map(map, jat_class)
+            map
+          end
+
+          private
+
+          def append_map(map, jat_class)
+            type = jat_class.get_type
+            return map if map.key?(type)
+
+            type_map = {serializer: jat_class}
+            map[type] = type_map
+
+            fill_type_map(map, type_map, type, jat_class)
+
+            type_map[:attributes] ||= FROZEN_EMPTY_ARRAY
+            type_map[:relationships] ||= FROZEN_EMPTY_ARRAY
+          end
+
+          def fill_type_map(map, type_map, type, jat_class)
+            jat_class.attributes.each_value do |attribute|
+              next unless expose?(type, attribute)
+
+              fill_attr(map, type_map, attribute)
+            end
+          end
+
+          def fill_attr(map, type_map, attribute)
+            name = attribute.name
+
+            if attribute.relation?
+              (type_map[:relationships] ||= []) << name
+              append_map(map, attribute.serializer.call)
+            else
+              (type_map[:attributes] ||= []) << name
+            end
+          end
+
+          def expose?(type, attribute)
+            attribute_name = attribute.name
+            fields_attribute_names = fields && fields[type]
+            return fields_attribute_names.include?(attribute_name) if fields_attribute_names
+
+            includes_attribute_names = includes && includes[type]
+            includes_attribute_names&.include?(attribute_name) || attribute_exposed?(attribute)
+          end
+
+          def attribute_exposed?(attribute)
+            case exposed
+            when :all then true
+            when :none then false
+            else attribute.exposed?
+            end
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      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,58 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Fields
+          class Validate
+            class << self
+              def call(jat, fields)
+                full_map = jat.maps.full
+
+                fields.each do |type, attributes_names|
+                  new(jat, type, full_map).validate(attributes_names)
+                end
+              end
+            end
+
+            attr_reader :jat, :type, :full_map
+
+            def initialize(jat, type, full_map)
+              @jat = jat
+              @type = type
+              @full_map = full_map
+            end
+
+            def validate(attributes_names)
+              check_fields_type
+              check_attributes_names(attributes_names)
+            end
+
+            private
+
+            def check_fields_type
+              return if full_map.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 = full_map.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