jat 0.0.3 → 0.0.8

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

@@ -5,129 +5,114 @@ class Jat
   module Plugins
     module SimpleApi
       class Response
-        attr_reader :jat, :jat_class, :object, :context
+        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 initialize(jat)
-          @jat = jat
-          @jat_class = jat.class
-          @object = jat.object
-          @context = jat.context
+          def call(object, context)
+            new(object, context).to_h
+          end
         end
 
-        def response
-          # Add main response
-          result = many? ? many(object) : one(object)
-          result = {root_key => result} if root_key
-          result ||= {}
+        module InstanceMethods
+          attr_reader :object, :context, :jat_class
 
-          # Add metadata to response
-          # We can add metadata to empty response, or to top-level namespace
-          # We should not mix metadata with object attributes
-          metadata.tap do |meta|
-            next if meta.empty?
-            raise Error, "Response must have a root key to add metadata" if !result.empty? && !root_key
-            result[meta_key] = meta
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
           end
 
-          result
-        end
+          def to_h
+            # Add main response
+            is_many = many?
+            root = root_key(is_many)
 
-        private
+            response = is_many ? many(object) : one(object)
+            response = {root => response} if root
+            response ||= {}
 
-        def metadata
-          result = context[:meta] || {}
+            add_metadata(response, root)
 
-          config_meta = jat_class.config[:meta]
-          return result unless config_meta
+            response
+          end
 
-          config_meta.each_with_object(result) do |(key, value), res|
-            next if res.key?(key) # do not overwrite manually added meta
+          private
 
-            value = value.call(object, context) if value.respond_to?(:call)
-            res[key] = value unless value.nil?
+          def many(objects)
+            objects.map { |obj| one(obj) }
           end
-        end
-
-        def many(objects)
-          objects.map { |obj| one(obj) }
-        end
 
-        def one(obj)
-          ResponseData.new(jat_class, obj, context, jat.traversal_map).data
-        end
+          def one(obj)
+            map = jat_class.map(context)
+            jat_class::ResponsePiece.to_h(obj, context, map)
+          end
 
-        def many?
-          @is_many ||= begin
+          def many?
             many = context[:many]
             many.nil? ? object.is_a?(Enumerable) : many
           end
-        end
 
-        # We can provide nil or false to remove root
-        def root_key
-          @root_key ||=
+          # We can provide nil or false to remove root
+          def root_key(is_many)
             if context.key?(:root)
-              context[:root]
+              root = context[:root]
+              root ? root.to_sym : root
             else
-              (many? ? jat_class.root_for_many : jat_class.root_for_one) || jat_class.root
+              config = jat_class.config
+              is_many ? config[:root_many] : config[:root_one]
             end
-        end
+          end
 
-        def meta_key
-          context[:meta_key] || jat_class.meta_key
-        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?
 
-      class ResponseData
-        attr_reader :jat_class, :object, :context, :map, :presenter
+            raise Error, "Response must have a root key to add metadata" if !response.empty? && !root
+            response[meta_key] = meta
+          end
 
-        def initialize(jat_class, object, context, map)
-          @jat_class = jat_class
-          @object = object
-          @context = context
-          @map = map
-          @presenter = jat_class::Presenter.new(object, context)
-        end
+          def meta_key
+            context[:meta_key]&.to_sym || jat_class.config[:meta_key]
+          end
 
-        def data
-          return unless object
+          def metadata
+            data = context_metadata
 
-          result = {}
+            meta = jat_class.added_meta
+            return data if meta.empty?
 
-          map.each do |key, inner_keys|
-            attribute = jat_class.attributes.fetch(key)
-            value = presenter.public_send(attribute.original_name)
+            meta.each do |name, attribute|
+              next if data.key?(name)
 
-            result[key] =
-              if attribute.relation?
-                if many?(attribute, value)
-                  value.map { |obj| response_data(attribute, obj, inner_keys) }
-                else
-                  response_data(attribute, value, inner_keys)
-                end
-              else
-                value
-              end
-          end
+              value = attribute.value(object, context)
 
-          result
-        end
+              unless value.nil?
+                data = data.dup if data.equal?(FROZEN_EMPTY_HASH)
+                data[name] = value
+              end
+            end
 
-        private
+            data
+          end
 
-        def response_data(attribute, value, map)
-          ResponseData.new(attribute.serializer.call, value, context, map).data
+          def context_metadata
+            context[:meta]&.transform_keys(&:to_sym) || FROZEN_EMPTY_HASH
+          end
         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
+        extend ClassMethods
+        include InstanceMethods
       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 :base_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 :base_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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiPreloads
+      class Preloads
+        module ClassMethods
+          def call(jat)
+            result = {}
+            append_many(result, jat.class, jat.map)
+            result
+          end
+
+          private
+
+          def append_many(result, jat_class, keys)
+            keys.each do |key, inner_keys|
+              attribute = jat_class.attributes.fetch(key)
+              preloads = attribute.preloads
+              next unless preloads
+
+              append_one(result, jat_class, preloads)
+              next if inner_keys.empty?
+
+              path = attribute.preloads_path
+              nested_result = nested(result, path)
+              nested_serializer = attribute.serializer.call
+
+              append_many(nested_result, nested_serializer, inner_keys)
+            end
+          end
+
+          def append_one(result, jat_class, preloads)
+            return if preloads.empty?
+
+            preloads = EnumDeepDup.call(preloads)
+            merge(result, preloads)
+          end
+
+          def merge(result, preloads)
+            result.merge!(preloads) do |_key, value_one, value_two|
+              merge(value_one, value_two)
+            end
+          end
+
+          def nested(result, path)
+            !path || path.empty? ? result : result.dig(*path)
+          end
+        end
+
+        extend ClassMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloads"
+
+class Jat
+  module Plugins
+    module SimpleApiPreloads
+      def self.plugin_name
+        :simple_api_preloads
+      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 :base_preloads, **opts
+      end
+
+      def self.load(jat_class, **_opts)
+        jat_class.extend(ClassMethods)
+        jat_class.include(InstanceMethods)
+      end
+
+      module ClassMethods
+        def preloads(context = {})
+          new(context).preloads
+        end
+      end
+
+      module InstanceMethods
+        def preloads
+          @preloads ||= Preloads.call(self)
+        end
+      end
+    end
+
+    register_plugin(SimpleApiPreloads.plugin_name, SimpleApiPreloads)
+  end
+end

data/lib/jat/plugins/simple_api/plugins/simple_api_validate_params/lib/fields_error.rb

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

data/lib/jat/plugins/simple_api/plugins/simple_api_validate_params/lib/validate_fields_param.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module SimpleApiValidateParams
+      class ValidateFieldsParam
+        class << self
+          def call(jat_class, fields, prev_names = [])
+            fields.each do |name, nested_fields|
+              attribute = jat_class.attributes[name]
+
+              raise_error(name, prev_names) unless attribute
+              next if nested_fields.empty?
+
+              raise_nested_error(name, prev_names, nested_fields) unless attribute.relation?
+              nested_serializer = attribute.serializer.call
+              call(nested_serializer, nested_fields, prev_names + [name])
+            end
+          end
+
+          private
+
+          def raise_error(name, prev_names)
+            field_name = field_name(name, prev_names)
+
+            raise SimpleApiFieldsError, "Field #{field_name} not exists"
+          end
+
+          def raise_nested_error(name, prev_names, nested_fields)
+            field_name = field_name(name, prev_names)
+            first_nested = nested_fields.keys.first
+
+            raise SimpleApiFieldsError, "Field #{field_name} is not a relationship to add '#{first_nested}' attribute"
+          end
+
+          def field_name(name, prev_names)
+            res = "'#{name}'"
+            res += " ('#{prev_names.join(".")}.#{name}')" if prev_names.any?
+            res
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "./lib/fields_error"
+require_relative "./lib/validate_fields_param"
+
+class Jat
+  module Plugins
+    module SimpleApiValidateParams
+      def self.plugin_name
+        :simple_api_validate_params
+      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.extend(ClassMethods)
+        jat_class.include(InstanceMethods)
+
+        jat_class::FieldsParamParser.include(FieldsParamParserMethods)
+      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 FieldsParamParserMethods
+        def parse
+          super.tap { |result| ValidateFieldsParam.call(self.class.jat_class, result) }
+        end
+      end
+    end
+
+    register_plugin(SimpleApiValidateParams.plugin_name, SimpleApiValidateParams)
+  end
+end