jat 0.0.1 → 0.0.7

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "./include/parse"
+require_relative "./include/validate"
+
+class Jat
+  module Plugins
+    module JsonApi
+      module Params
+        class Include
+          class << self
+            # returns Hash { type => [attr1, attr2] }
+            def call(jat, includes_string)
+              return {} unless includes_string
+
+              jat_class = jat.class
+              includes = Parse.call(includes_string)
+              Validate.call(jat_class, includes)
+
+              typed_includes(jat_class, includes, {})
+            end
+
+            private
+
+            def typed_includes(jat_class, includes, result)
+              includes.each do |included_attr_name, nested_includes|
+                add_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_include(result, serializer, included_attr_name)
+              type = serializer.type
+
+              includes = result[type] || []
+              includes |= [included_attr_name]
+
+              result[type] = includes
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Serializes to JSON-API format
+class Jat
+  module Plugins
+    module JsonApi
+      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 :jat_class, :object, :context
+
+          def initialize(object, context)
+            @object = object
+            @context = context
+            @jat_class = self.class.jat_class
+          end
+
+          def to_h
+            data, includes = data_with_includes
+            meta = document_meta
+            links = document_links
+            jsonapi = jsonapi_data
+
+            result = {}
+            result[:links] = links if links.any?
+            result[:data] = data if data
+            result[:included] = includes.values if includes.any?
+            result[:meta] = meta if meta.any?
+            result[:jsonapi] = jsonapi if jsonapi.any?
+            result
+          end
+
+          private
+
+          def data_with_includes
+            includes = {}
+            map = jat_class::Map.call(context)
+            data = many?(object, context) ? many(object, includes, map) : one(object, includes, map)
+            [data, includes]
+          end
+
+          def many(objects, includes, map)
+            objects.map { |object| one(object, includes, map) }
+          end
+
+          def one(object, includes, map)
+            jat_class::ResponsePiece.call(object, context, map, includes)
+          end
+
+          def many?(data, context)
+            many = context[:many]
+            many.nil? ? data.is_a?(Enumerable) : many
+          end
+
+          def jsonapi_data
+            combine(jat_class.jsonapi_data, context_jsonapi)
+          end
+
+          def document_links
+            combine(jat_class.document_links, context_links)
+          end
+
+          def document_meta
+            combine(jat_class.added_document_meta, context_meta)
+          end
+
+          def combine(attributes, context_data)
+            return context_data if attributes.empty?
+
+            data = context_data
+
+            attributes.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_jsonapi
+            context_attr_transform(:jsonapi)
+          end
+
+          def context_links
+            context_attr_transform(:links)
+          end
+
+          def context_meta
+            context_attr_transform(:meta)
+          end
+
+          def context_attr_transform(key)
+            context[key]&.transform_keys(&:to_sym) || FROZEN_EMPTY_HASH
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+# 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: type, id: id}
+          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.value(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.value(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
+            simple_uid = "#{rel_uid[:id]}-#{rel_uid[:type]}"
+            includes[simple_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.value(object, context) }
+              .tap(&:compact!)
+          end
+
+          def get_meta
+            jat_class
+              .added_object_meta
+              .transform_values { |attr| attr.value(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.value(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.value(rel_object, context) }
+              .tap(&:compact!)
+              .tap { context.delete(:parent_object) }
+          end
+
+          def type
+            @type ||= jat_class.get_type
+          end
+
+          def id
+            @id ||= jat_class.get_id.value(object, context)
+          end
+        end
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiActiverecord
+      def self.plugin_name
+        :json_api_activerecord
+      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.plugin :json_api_preloads, **opts
+        jat_class.plugin :_activerecord_preloads, **opts
+      end
+    end
+
+    register_plugin(JsonApiActiverecord.plugin_name, JsonApiActiverecord)
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiLowerCamelCase
+      def self.plugin_name
+        :json_api_lower_camel_case
+      end
+
+      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(JsonApiLowerCamelCase.plugin_name, JsonApiLowerCamelCase)
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Jat
+  module Plugins
+    module JsonApiMapsCache
+      def self.plugin_name
+        :json_api_maps_cache
+      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::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(JsonApiMapsCache.plugin_name, JsonApiMapsCache)
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "./lib/preloads"
+
+class Jat
+  module Plugins
+    module JsonApiPreloads
+      def self.plugin_name
+        :json_api_preloads
+      end
+
+      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 :_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(JsonApiPreloads.plugin_name, JsonApiPreloads)
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "set"
+
+class Jat
+  module Plugins
+    module JsonApiPreloads
+      class Preloads
+        class << self
+          def call(jat)
+            new(jat.map).for(jat.class)
+          end
+        end
+
+        def initialize(current_map)
+          @used = Set.new
+          @current_map = current_map
+        end
+
+        def for(jat_class)
+          result = {}
+          append(result, jat_class)
+          result
+        end
+
+        private
+
+        attr_reader :current_map, :used
+
+        def append(result, jat_class)
+          attrs = current_map[jat_class.get_type]
+
+          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 add preloads and nested preloads when nil provided
+
+            merge(result, deep_dup(preloads)) unless preloads.empty?
+            add_nested_preloads(result, attribute) if attribute.relation?
+          end
+        end
+
+        def add_nested_preloads(result, attribute)
+          path = attribute.preloads_path
+          nested_result = nested(result, path)
+          nested_serializer = attribute.serializer.call
+
+          append(nested_result, nested_serializer)
+        end
+
+        def merge(result, preloads)
+          result.merge!(preloads) do |_key, value_one, value_two|
+            merge(value_one, value_two)
+          end
+        end
+
+        def deep_dup(preloads)
+          preloads.dup.transform_values! do |nested_preloads|
+            deep_dup(nested_preloads)
+          end
+        end
+
+        def nested(result, path)
+          !path || path.empty? ? result : result.dig(*path)
+        end
+      end
+    end
+  end
+end

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