jat 0.0.3 → 0.0.8

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

@@ -1,60 +1,52 @@
 # frozen_string_literal: true
 
+require "set"
+
 class Jat
   module Plugins
-    module JsonApiActiverecord
+    module JsonApiPreloads
       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/plugins/json_api_validate_params/json_api_validate_params.rb

@@ -0,0 +1,61 @@
+# 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.plugin_name
+        :json_api_validate_params
+      end
+
+      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(JsonApiValidateParams.plugin_name, JsonApiValidateParams)
+  end
+end

data/lib/jat/plugins/json_api/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/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/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/lower_camel_case/lower_camel_case.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module LowerCamelCase
+      def self.plugin_name
+        :lower_camel_case
+      end
+
+      def self.load(jat_class, **opts)
+        if jat_class.plugin_used?(:json_api)
+          jat_class.plugin :json_api_lower_camel_case, **opts
+        elsif jat_class.plugin_used?(:simple_api)
+          jat_class.plugin :simple_api_lower_camel_case, **opts
+        else
+          raise Error, "Please load :json_api or :simple_api plugin first"
+        end
+      end
+    end
+
+    register_plugin(LowerCamelCase.plugin_name, LowerCamelCase)
+  end
+end

data/lib/jat/plugins/maps_cache/maps_cache.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module MapsCache
+      def self.plugin_name
+        :maps_cache
+      end
+
+      def self.load(jat_class, **opts)
+        if jat_class.plugin_used?(:json_api)
+          jat_class.plugin :json_api_maps_cache, **opts
+        elsif jat_class.plugin_used?(:simple_api)
+          jat_class.plugin :simple_api_maps_cache, **opts
+        else
+          raise Error, "Please load :json_api or :simple_api plugin first"
+        end
+      end
+    end
+
+    register_plugin(MapsCache.plugin_name, MapsCache)
+  end
+end

data/lib/jat/plugins/preloads/preloads.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module Preloads
+      def self.plugin_name
+        :preloads
+      end
+
+      def self.load(jat_class, **opts)
+        if jat_class.plugin_used?(:json_api)
+          jat_class.plugin :json_api_preloads, **opts
+        elsif jat_class.plugin_used?(:simple_api)
+          jat_class.plugin :simple_api_preloads, **opts
+        else
+          raise Error, "Please load :json_api or :simple_api plugin first"
+        end
+      end
+    end
+
+    register_plugin(Preloads.plugin_name, Preloads)
+  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

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

@@ -1,28 +1,98 @@
 # frozen_string_literal: true
 
-require_relative "./params/parse"
-require_relative "./construct_traversal_map"
-
 class Jat
   module Plugins
     module SimpleApi
       class Map
-        class << self
+        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
           # {
           #   key1 => { key11 => {}, key12 => { ... } },
           #   key2 => { key21 => {}, key22 => { ... } },
           # }
-          def call(jat)
-            params = jat.context[:params]
-            fields = params && (params[:fields] || params["fields"])
-            exposed = jat.context[:exposed] || :default
+          def call(context)
+            exposed = context[:exposed]&.to_sym || :default
+            fields = context[:fields]
+
+            construct_map(exposed, fields)
+          end
+
+          private
+
+          def construct_map(exposed, fields)
+            fields = jat_class::FieldsParamParser.parse(fields) if fields
+            new(exposed, fields).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :exposed, :fields
+
+          EXPOSED_TYPES = {all: :all, default: :default, none: :none}.freeze
+
+          def initialize(exposed, fields)
+            @exposed = EXPOSED_TYPES.fetch(exposed)
+            @fields = fields
+          end
+
+          def to_h
+            map_for(self.class.jat_class, fields)
+          end
+
+          def map_for(serializer, fields, stack = [])
+            serializer.attributes.each_with_object({}) do |name_attr, result|
+              name = name_attr[0]
+              attribute = name_attr[1]
+              next unless expose?(attribute, fields)
 
-            manually_exposed = Params::Parse.new(fields).parse
+              raise Error, recursive_error_message(stack, name) if stack.any?(name_attr)
+              stack << name_attr
 
-            ConstructTraversalMap.new(jat.class, exposed, manually_exposed: manually_exposed).to_h
+              result[name] =
+                if attribute.relation?
+                  nested_serializer = attribute.serializer.call
+                  nested_fields = fields&.[](name)
+                  map_for(nested_serializer, nested_fields, stack)
+                else
+                  FROZEN_EMPTY_HASH
+                end
+
+              stack.pop
+            end
+          end
+
+          private
+
+          def expose?(attribute, fields)
+            case exposed
+            when :all then true
+            when :none then manually_exposed?(attribute, fields)
+            else attribute.exposed? || manually_exposed?(attribute, fields)
+            end
+          end
+
+          def manually_exposed?(attribute, fields)
+            fields&.include?(attribute.name)
+          end
+
+          def recursive_error_message(stack, name)
+            recursion = (stack.map!(&:first) << name).join(" -> ")
+            "Recursive serialization: #{recursion}"
           end
         end
+
+        extend ClassMethods
+        include InstanceMethods
       end
     end
   end