jat 0.0.3 → 0.0.5

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApi
+      class ResponsePiece
+        module ClassMethods
+          # Returns the Jat class that this ResponsePiece class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since ResponsePiece 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}::ResponsePiece"
+          end
+
+          def call(object, context, map, includes)
+            new(object, context, map, includes).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :jat_class, :object, :context, :map, :type_map, :includes
+
+          def initialize(object, context, map, includes)
+            @jat_class = self.class.jat_class
+            @object = object
+            @context = context
+            @map = map
+            @type_map = map.fetch(jat_class.get_type)
+            @includes = includes
+          end
+
+          def to_h
+            return unless object
+
+            attributes = get_attributes
+            relationships = get_relationships
+            links = get_links
+            meta = get_meta
+
+            result = uid
+            result[:attributes] = attributes if attributes
+            result[:relationships] = relationships if relationships
+            result[:links] = links if links.any?
+            result[:meta] = meta if meta.any?
+            result
+          end
+
+          def uid
+            {type: jat_class.get_type, id: jat_class.get_id.block.call(object, context)}
+          end
+
+          private
+
+          def get_attributes
+            attributes_names = type_map[:attributes]
+            return if attributes_names.empty?
+
+            attributes_names.each_with_object({}) do |name, attrs|
+              attribute = jat_class.attributes[name]
+              attrs[name] = attribute.block.call(object, context)
+            end
+          end
+
+          def get_relationships
+            relationships_names = type_map[:relationships]
+            return if relationships_names.empty?
+
+            relationships_names.each_with_object({}) do |name, rels|
+              rel_attribute = jat_class.attributes[name]
+              rel_object = rel_attribute.block.call(object, context)
+
+              rel_serializer = rel_attribute.serializer.call
+              rel_links = get_relationship_links(rel_serializer, rel_object)
+              rel_meta = get_relationship_meta(rel_serializer, rel_object)
+              rel_data =
+                if many?(rel_attribute, rel_object)
+                  many_relationships_data(rel_serializer, rel_object)
+                else
+                  one_relationship_data(rel_serializer, rel_object)
+                end
+
+              result = {}
+              result[:data] = rel_data
+              result[:links] = rel_links if rel_links.any?
+              result[:meta] = rel_meta if rel_meta.any?
+              rels[name] = result
+            end
+          end
+
+          def many_relationships_data(rel_serializer, rel_objects)
+            return FROZEN_EMPTY_ARRAY if rel_objects.empty?
+
+            rel_objects.map { |rel_object| add_relationship_data(rel_serializer, rel_object) }
+          end
+
+          def one_relationship_data(rel_serializer, rel_object)
+            return unless rel_object
+
+            add_relationship_data(rel_serializer, rel_object)
+          end
+
+          def add_relationship_data(rel_serializer, rel_object)
+            rel_response_data = rel_serializer::ResponsePiece.new(rel_object, context, map, includes)
+            rel_uid = rel_response_data.uid
+            includes[rel_uid] ||= rel_response_data.to_h
+            rel_uid
+          end
+
+          def many?(attribute, object)
+            is_many = attribute.many?
+
+            # handle boolean
+            return is_many if (is_many == true) || (is_many == false)
+
+            # handle nil
+            object.is_a?(Enumerable)
+          end
+
+          def get_links
+            jat_class
+              .object_links
+              .transform_values { |attr| attr.block.call(object, context) }
+              .tap(&:compact!)
+          end
+
+          def get_meta
+            jat_class
+              .added_object_meta
+              .transform_values { |attr| attr.block.call(object, context) }
+              .tap(&:compact!)
+          end
+
+          def get_relationship_links(rel_serializer, rel_object)
+            links = rel_serializer.relationship_links
+            return FROZEN_EMPTY_HASH unless links
+
+            context[:parent_object] = object
+
+            links
+              .transform_values { |attr| attr.block.call(rel_object, context) }
+              .tap(&:compact!)
+              .tap { context.delete(:parent_object) }
+          end
+
+          def get_relationship_meta(rel_serializer, rel_object)
+            meta = rel_serializer.added_relationship_meta
+            return FROZEN_EMPTY_HASH unless meta
+
+            context[:parent_object] = object
+
+            meta
+              .transform_values { |attr| attr.block.call(rel_object, context) }
+              .tap(&:compact!)
+              .tap { context.delete(:parent_object) }
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api_activerecord/json_api_activerecord.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloads"
+
+class Jat
+  module Plugins
+    module JsonApiActiverecord
+      def self.before_load(jat_class, **opts)
+        return if jat_class.plugin_used?(:json_api)
+        raise Error, "Please load :json_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.include(InstanceMethods)
+      end
+
+      def self.after_load(jat_class, **opts)
+        jat_class.plugin :_preloads, **opts
+        jat_class.plugin :_activerecord_preloads, **opts
+      end
+
+      module InstanceMethods
+        def preloads
+          @preloads ||= Preloads.call(self)
+        end
+      end
+    end
+
+    register_plugin(:json_api_activerecord, JsonApiActiverecord)
+  end
+end

data/lib/jat/plugins/{_json_api_activerecord → json_api_activerecord}/lib/preloads.rb

@@ -1,60 +1,52 @@
 # frozen_string_literal: true
 
+require "set"
+
 class Jat
   module Plugins
     module JsonApiActiverecord
       class Preloads
         class << self
           def call(jat)
-            new(jat.traversal_map.current).for(jat.class)
+            new(jat.map).for(jat.class)
           end
         end
 
-        attr_reader :initial_result
-
         def initialize(current_map)
+          @used = Set.new
           @current_map = current_map
-          @initial_result = {}
         end
 
         def for(jat_class)
-          @initial_result = {}
-          append(initial_result, jat_class)
-          initial_result
-        rescue SystemStackError
-          raise Error, "Stack level too deep, recursive preloads detected: #{initial_result}"
+          result = {}
+          append(result, jat_class)
+          result
         end
 
         private
 
-        attr_reader :current_map
+        attr_reader :current_map, :used
 
         def append(result, jat_class)
-          attrs = current_map[jat_class.type]
-          attributes_names = attrs[:attributes] + attrs[:relationships]
+          attrs = current_map[jat_class.get_type]
 
-          add_attributes(result, jat_class, attributes_names)
+          add_attributes(result, jat_class, attrs[:attributes])
+          add_attributes(result, jat_class, attrs[:relationships])
         end
 
         def add_attributes(result, jat_class, attributes_names)
           attributes_names.each do |name|
+            next unless used.add?([jat_class, name]) # Protection from recursive preloads
+
             attribute = jat_class.attributes[name]
             preloads = attribute.preloads
-            next unless preloads # we should not addd preloads and nested preloads when nil provided
+            next unless preloads # we should not add preloads and nested preloads when nil provided
 
-            add_preloads(result, preloads, attribute)
+            merge(result, deep_dup(preloads)) unless preloads.empty?
+            add_nested_preloads(result, attribute) if attribute.relation?
           end
         end
 
-        def add_preloads(result, preloads, attribute)
-          unless preloads.empty?
-            preloads = deep_dup(preloads)
-            merge(result, preloads)
-          end
-
-          add_nested_preloads(result, attribute) if attribute.relation?
-        end
-
         def add_nested_preloads(result, attribute)
           path = attribute.preloads_path
           nested_result = nested(result, path)

data/lib/jat/plugins/json_api_lower_camel_case/json_api_lower_camel_case.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiLowerCamelCase
+      def self.before_load(jat_class, **_opts)
+        raise Error, "Please load :json_api plugin first" unless jat_class.plugin_used?(:json_api)
+
+        jat_class.plugin :_lower_camel_case
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Response.include(ResponseInstanceMethods)
+      end
+
+      module ResponseInstanceMethods
+        private
+
+        def context_attr_transform(*)
+          result = super
+          return result if result.empty?
+
+          result.transform_keys! { |key| Jat::LowerCamelCaseTransformation.call(key) }
+        end
+      end
+    end
+
+    register_plugin(:json_api_lower_camel_case, JsonApiLowerCamelCase)
+  end
+end

data/lib/jat/plugins/json_api_maps_cache/json_api_maps_cache.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiMapsCache
+      def self.before_load(jat_class, **opts)
+        return if jat_class.plugin_used?(:json_api)
+        raise Error, "Please load :json_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class::Map.extend(MapsCacheClassMethods)
+      end
+
+      def self.after_load(jat_class, **opts)
+        jat_class.config[:cached_maps_count] = opts[:cached_maps_count] || 100
+      end
+
+      module MapsCacheClassMethods
+        # Caches up to `:cached_maps_count` maps for each serializer.
+        # Removes earliest value if new value exceeds limit.
+
+        def maps_cache
+          @maps_cache ||= Hash.new do |cache, cache_key|
+            cache.shift if cache.length >= jat_class.config[:cached_maps_count] # protect from memory leak
+            cache[cache_key] = EnumDeepFreeze.call(yield)
+          end
+        end
+
+        private
+
+        def construct_map(exposed, fields, includes)
+          cache = maps_cache { super }
+          cache_key = cache_key(exposed, fields, includes)
+          cache[cache_key]
+        end
+
+        def cache_key(exposed, fields, includes)
+          key = "exposed:#{exposed}:"
+          key += "includes:#{includes}:" if includes
+
+          if fields
+            key += "fields:"
+            fields.each { |type, attrs| key += "#{type}:#{attrs}:" }
+          end
+
+          key
+        end
+      end
+    end
+
+    register_plugin(:json_api_maps_cache, JsonApiMapsCache)
+  end
+end

data/lib/jat/plugins/json_api_validate_params/json_api_validate_params.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "./lib/params_error"
+require_relative "./lib/validate_fields_param"
+require_relative "./lib/validate_include_param"
+
+class Jat
+  module Plugins
+    module JsonApiValidateParams
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:json_api)
+        raise Error, "Please load :json_api plugin first"
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.extend(ClassMethods)
+        jat_class.include(InstanceMethods)
+
+        jat_class::FieldsParamParser.extend(FieldsParamParserClassMethods)
+        jat_class::IncludeParamParser.extend(IncludeParamParserClassMethods)
+      end
+
+      module InstanceMethods
+        def validate
+          @validate ||= self.class.validate(context)
+        end
+      end
+
+      module ClassMethods
+        def validate(context)
+          # Generate map for current context.
+          # Params are valid if no errors were raised
+          map(context)
+          true
+        end
+      end
+
+      module IncludeParamParserClassMethods
+        private
+
+        def parse_to_nested_hash(*)
+          super.tap { |result| ValidateIncludeParam.call(jat_class, result) }
+        end
+      end
+
+      module FieldsParamParserClassMethods
+        private
+
+        def parse_to_nested_hash(*)
+          super.tap { |result| ValidateFieldsParam.call(jat_class, result) }
+        end
+      end
+    end
+
+    register_plugin(:json_api_validate_params, JsonApiValidateParams)
+  end
+end

data/lib/jat/plugins/json_api_validate_params/lib/params_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Jat
+  class JsonApiParamsError < Error
+  end
+end

data/lib/jat/plugins/json_api_validate_params/lib/validate_fields_param.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiValidateParams
+      class ValidateFieldsParam
+        def self.call(jat_class, fields)
+          full_map = jat_class.map_full
+
+          fields.each do |type, attributes_names|
+            new(type, full_map).validate(attributes_names)
+          end
+        end
+
+        attr_reader :type, :full_map
+
+        def initialize(type, full_map)
+          @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)
+
+          allowed_types = "'#{full_map.keys.join("', '")}'"
+
+          raise JsonApiParamsError, <<~ERROR.strip
+            Response does not have resources with type '#{type}'. Existing types are: #{allowed_types}
+          ERROR
+        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)
+
+          allowed_attributes = "'#{type_serializer.attributes.keys.join("', '")}'"
+
+          raise JsonApiParamsError, <<~ERROR.strip
+            No attribute '#{attribute_name}' in resource type '#{type}'. Existing attributes are: #{allowed_attributes}
+          ERROR
+        end
+      end
+    end
+  end
+end

data/lib/jat/plugins/json_api_validate_params/lib/validate_include_param.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiValidateParams
+      class ValidateIncludeParam
+        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
+
+          private
+
+          def raise_error(jat_class, name)
+            type = jat_class.get_type
+            allowed_relationships = jat_class.attributes.each_value.select(&:relation?).map!(&:name)
+            allowed_relationships = "'#{allowed_relationships.join("', '")}'"
+
+            raise JsonApiParamsError,
+              "Type '#{type}' has no included '#{name}' relationship. " \
+              "Existing relationships are: #{allowed_relationships}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApi
+      class FieldsParamParser
+        module ClassMethods
+          # 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
+
+            new(fields).parse
+          end
+        end
+
+        module InstanceMethods
+          COMMA = ","
+          OPEN_BRACKET = "("
+          CLOSE_BRACKET = ")"
+
+          def initialize(fields)
+            @fields = fields
+          end
+
+          # user => { user: {} }
+          # user(id) => { user: { id: {} } }
+          # user(id,name) => { user: { id: {}, name: {} } }
+          # user,comments => { user: {}, comments: {} }
+          # user(comments(text)) => { user: { comments: { text: {} } } }
+          def parse
+            current_attr = nil
+
+            fields.each_char do |char|
+              case char
+              when COMMA
+                next unless current_attr
+
+                add_attribute(current_attr)
+                current_attr = nil
+              when CLOSE_BRACKET
+                if current_attr
+                  add_attribute(current_attr)
+                  current_attr = nil
+                end
+
+                route.pop
+              when OPEN_BRACKET
+                next unless current_attr
+
+                attribute_name = add_attribute(current_attr, {})
+                route << attribute_name
+                current_attr = nil
+              else
+                current_attr = current_attr ? current_attr.insert(-1, char) : char
+              end
+            end
+
+            add_attribute(current_attr) if current_attr
+
+            res
+          end
+
+          private
+
+          attr_reader :fields
+
+          def add_attribute(current_attr, nested_attrs = FROZEN_EMPTY_HASH)
+            current_resource = route.empty? ? res : res.dig(*route)
+            attribute_name = current_attr.strip.to_sym
+            current_resource[attribute_name] = nested_attrs
+            attribute_name
+          end
+
+          def res
+            @res ||= {}
+          end
+
+          def route
+            @route ||= []
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end