jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApi
+      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
+          # {
+          #   key1 => { key11 => {}, key12 => { ... } },
+          #   key2 => { key21 => {}, key22 => { ... } },
+          # }
+          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)
+
+              raise Error, recursive_error_message(stack, name) if stack.any?(name_attr)
+              stack << name_attr
+
+              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
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module SimpleApi
+      class Response
+        module ClassMethods
+          # Returns the Jat class that this Response class is namespaced under.
+          attr_accessor :jat_class
+
+          # Since Response 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}::Response"
+          end
+
+          def call(object, context)
+            new(object, context).to_h
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :object, :context, :jat_class
+
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
+          end
+
+          def to_h
+            # Add main response
+            is_many = many?
+            root = root_key(is_many)
+
+            response = is_many ? many(object) : one(object)
+            response = {root => response} if root
+            response ||= {}
+
+            add_metadata(response, root)
+
+            response
+          end
+
+          private
+
+          def many(objects)
+            objects.map { |obj| one(obj) }
+          end
+
+          def one(obj)
+            map = jat_class.map(context)
+            jat_class::ResponsePiece.to_h(obj, context, map)
+          end
+
+          def many?
+            many = context[:many]
+            many.nil? ? object.is_a?(Enumerable) : many
+          end
+
+          # We can provide nil or false to remove root
+          def root_key(is_many)
+            if context.key?(:root)
+              root = context[:root]
+              root ? root.to_sym : root
+            else
+              config = jat_class.config
+              is_many ? config[:root_many] : config[:root_one]
+            end
+          end
+
+          # Add metadata to response
+          # We can add metadata whether to empty response or to top-level namespace
+          # We should not mix metadata with object attributes
+          def add_metadata(response, root)
+            meta = metadata
+            return if meta.empty?
+
+            raise Error, "Response must have a root key to add metadata" if !response.empty? && !root
+            response[meta_key] = meta
+          end
+
+          def meta_key
+            context[:meta_key]&.to_sym || jat_class.config[:meta_key]
+          end
+
+          def metadata
+            data = context_metadata
+
+            meta = jat_class.added_meta
+            return data if meta.empty?
+
+            meta.each do |name, attribute|
+              next if data.key?(name)
+
+              value = attribute.value(object, context)
+
+              unless value.nil?
+                data = data.dup if data.equal?(FROZEN_EMPTY_HASH)
+                data[name] = value
+              end
+            end
+
+            data
+          end
+
+          def context_metadata
+            context[:meta]&.transform_keys(&:to_sym) || FROZEN_EMPTY_HASH
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module SimpleApi
+      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 to_h(object, context, map)
+            new(object, context).piece(map)
+          end
+        end
+
+        module InstanceMethods
+          attr_reader :jat_class, :object, :context
+
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
+          end
+
+          def piece(map)
+            return unless object
+
+            result = {}
+
+            map.each do |key, inner_map|
+              attribute = jat_class.attributes.fetch(key)
+              value = attribute.value(object, context)
+
+              result[key] =
+                if attribute.relation?
+                  if many?(attribute, value)
+                    value.map { |obj| inner_piece(attribute, obj, inner_map) }
+                  else
+                    inner_piece(attribute, value, inner_map)
+                  end
+                else
+                  value
+                end
+            end
+
+            result
+          end
+
+          private
+
+          def inner_piece(attribute, value, inner_map)
+            serializer = attribute.serializer.call
+            serializer::ResponsePiece.to_h(value, context, inner_map)
+          end
+
+          def many?(attribute, nested_object)
+            is_many = attribute.many?
+
+            # handle boolean
+            return is_many if (is_many == true) || (is_many == false)
+
+            # handle nil
+            nested_object.is_a?(Enumerable)
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiActiverecord
+      def self.plugin_name
+        :simple_api_activerecord
+      end
+
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:simple_api)
+        raise Error, "Please load :simple_api plugin first"
+      end
+
+      def self.load(jat_class, **opts)
+        jat_class.plugin :simple_api_preloads, **opts
+        jat_class.plugin :_activerecord_preloads, **opts
+      end
+    end
+
+    register_plugin(SimpleApiActiverecord.plugin_name, SimpleApiActiverecord)
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiLowerCamelCase
+      def self.plugin_name
+        :simple_api_lower_camel_case
+      end
+
+      def self.before_load(jat_class, **_opts)
+        raise Error, "Please load :simple_api plugin first" unless jat_class.plugin_used?(:simple_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_metadata
+          metadata = super
+          return metadata if metadata.empty?
+
+          metadata.transform_keys! { |key| Jat::LowerCamelCaseTransformation.call(key) }
+        end
+      end
+    end
+
+    register_plugin(SimpleApiLowerCamelCase.plugin_name, SimpleApiLowerCamelCase)
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiMapsCache
+      def self.plugin_name
+        :simple_api_maps_cache
+      end
+
+      def self.before_load(jat_class, **_opts)
+        return if jat_class.plugin_used?(:simple_api)
+
+        raise Error, "Please load :simple_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)
+          cache = maps_cache { super }
+          cache_key = cache_key(exposed, fields)
+          cache[cache_key]
+        end
+
+        def cache_key(exposed, fields)
+          "exposed:#{exposed}:fields:#{fields}:"
+        end
+      end
+    end
+
+    register_plugin(SimpleApiMapsCache.plugin_name, SimpleApiMapsCache)
+  end
+end