rails_json_serializer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b1a107c67b6ae1ccb5ad9abcd8f13b1255e46b07d48726c44b89e2e41186a2bb
+  data.tar.gz: be454318e55f60ca236b4fbb1ecb9a68fe144e636e13deb43587f94385f7c0cf
+SHA512:
+  metadata.gz: 7af60e8a27c62b336d31ec574aa5b3321ec7d73e3097c90d4027763f71148dc587d5113c9ae36576ea8869f4908d40145997c657ce2d5f4321fa9695df56128b
+  data.tar.gz: 4b3e8f9aebd58d53de0dc13688fdfb3d0b8f4ffdf0015d688e8329fc0d50b3dc8d81cc69dda3e16e51c08fbc82fb35fd2755c984cd8de53f9ea0c59650c8cd7c

data/lib/serializer.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+require 'serializer/application_serializer'
+Dir[File.join(Rails.root, 'app', 'serializers', '**', '*.rb')].each {|file| require file }
+require 'serializer/configuration'
+require 'serializer/concern'
+
+module Serializer
+  # config src: http://lizabinante.com/blog/creating-a-configurable-ruby-gem/
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end
+
+# include the extension 
+ActiveRecord::Base.send(:include, Serializer::Concern)

data/lib/serializer/application_serializer.rb

@@ -0,0 +1,10 @@
+module ApplicationSerializer
+  def serializer_query opts = {}
+    {
+      include: {
+      },
+      methods: %w(),
+      cache_key: __callee__,
+    }
+  end
+end

data/lib/serializer/concern.rb

@@ -0,0 +1,172 @@
+module Serializer
+  module Concern
+    # ActiveSupport extend src: https://stackoverflow.com/questions/2328984/rails-extending-activerecordbase
+    extend ActiveSupport::Concern
+
+    # START MODEL INSTANCE METHODS
+    def clear_serializer_cache
+      if self.class.const_defined?("#{self.class.name}Serializer")
+        serializer_klass = "#{self.class.name}Serializer".constantize
+        serializer_klass.public_instance_methods.each do |query_name|
+          cache_key = "#{self.class.name}_____#{query_name}___#{self.id}"
+          Rails.logger.info "Serializer: CLEARING CACHE KEY: #{cache_key}" if Serializer.configuration.debug
+          Rails.cache.delete(cache_key)
+        end
+        return true
+      else
+        Rails.logger.info "Serializer: Class #{self.class.name} does not have the serializer module #{self.class.name}Serializer defined." if Serializer.configuration.debug
+        return nil
+      end
+    end
+
+    def as_json options = {}
+      # Not caching records that don't have IDs.
+      if !Serializer.configuration.disable_model_caching && self.id && options[:cache_key].present? && !(options.key?(:cache_for) && options[:cache_for].nil?)
+        cache_key = "#{self.class.name}_____#{options[:cache_key]}___#{self.id}"
+        if Rails.cache.exist?(cache_key)
+          Rails.logger.info "Serializer: Cache reading #{cache_key}" if Serializer.configuration.debug
+          return Rails.cache.read(cache_key)
+        else
+          data = super(options)
+          data = self.class.as_json_associations_alias_fix(options, data)
+          begin
+            Rails.logger.info "Serializer: Caching #{cache_key} for #{(options[:cache_for] || Serializer.configuration.default_cache_time)} minutes." if Serializer.configuration.debug
+            Rails.cache.write(cache_key, data, expires_in: (options[:cache_for] || Serializer.configuration.default_cache_time).minute)
+          rescue Exception => e
+            Rails.logger.error "Serializer: Internal Server Error on #{self.class}#as_json ID: #{self.id} for cache key: #{cache_key}"
+            Rails.logger.error e.class
+            Rails.logger.error e.message
+            Rails.logger.error e.backtrace
+          end
+          return data
+        end
+      else
+        if Serializer.configuration.debug && !Serializer.configuration.disable_model_caching && self.id && options[:cache_key].present? && options.key?(:cache_for) && options[:cache_for].nil?
+          Rails.logger.info "Serializer: Caching #{cache_key} NOT caching due to `cache_for: nil`"
+        end
+        data = super(options)
+        data = self.class.as_json_associations_alias_fix(options, data)
+        return data
+      end
+    end
+
+    # Can override the query, using the options. ex: {json_query_override: :tiny_serializer_query}
+    def serializer opts = {}
+      query = opts[:json_query_override].present? ? self.class.send(opts[:json_query_override], opts) : self.class.serializer_query(opts)
+      if Serializer.configuration.enable_includes && query[:include].present? && self.class.column_names.include?('id') && self.id.present? && !opts[:skip_eager_loading] && self.respond_to?(:persisted?) && self.persisted?
+        # It's an extra SQL call, but most likely worth it to pre-load associations
+        self.class.includes(self.class.generate_includes_from_json_query(query)).find(self.id).as_json(query)
+      else
+        as_json(query)
+      end
+    end
+    # END MODEL INSTANCE METHODS
+
+    class_methods do
+       # START MODEL CLASS METHODS
+      def inherited subclass
+        if subclass.const_defined?("#{subclass.name}Serializer")
+          serializer_klass = "#{subclass.name}Serializer".constantize
+
+          if serializer_klass.class == Module
+            if !serializer_klass.const_defined?("SerializerMethods")
+              serializer_klass.const_set('SerializerMethods', Module.new {})
+            end
+
+            serializer_klass.public_instance_methods.each do |query_name|
+              serializer_name = query_name[/(?<name>.+)_query/, :name]
+              if serializer_name.nil?
+                Rails.logger.info "Serializer: #{serializer_klass.name} method #{query_name} does not end in '(.+)_query', as is expected of serializers" if Serializer.configuration.debug
+                next
+              end
+              # Skip if chosen to override it.
+              next if serializer_klass.respond_to?(serializer_name)
+              if serializer_name == 'serializer'
+                serializer_klass::SerializerMethods.send(:define_method, serializer_name) do |opts = {}|    
+                  super({json_query_override: query_name}.merge(opts))
+                end
+              else
+                serializer_klass::SerializerMethods.send(:define_method, serializer_name) do |opts = {}|    
+                  serializer({json_query_override: query_name}.merge(opts))
+                end
+              end
+            end
+
+            # Inject instance methods
+            subclass.send(:include, serializer_klass::SerializerMethods)
+            # Inject class methods
+            subclass.send(:extend, serializer_klass::SerializerMethods)
+            # Inject class methods that has queries
+            subclass.send(:extend, serializer_klass)
+          else
+            Rails.logger.info "Serializer: #{serializer_klass.name} was not a Module as expected" if Serializer.configuration.debug
+          end
+        end
+        super(subclass)
+      end
+
+      # Can override the query, using the options. ex: {json_query_override: :tiny_children_serializer_query}
+      def serializer opts = {}
+        query = opts[:json_query_override].present? ? self.send(opts[:json_query_override], opts) : serializer_query(opts)
+        if Serializer.configuration.enable_includes && query[:include].present? && !opts[:skip_eager_loading]
+          includes(generate_includes_from_json_query(query)).as_json(query)
+        else
+          # Have to use 'all' gets stack level too deep otherwise. Not sure why.
+          all.as_json(query)
+        end
+      end
+
+      def as_json_associations_alias_fix options, data, opts = {}
+        if data
+          # Depth is almost purely for debugging purposes
+          opts[:depth] ||= 0
+          if options[:include].present?
+            options[:include].each do |include_key, include_hash|
+              # The includes doesn't have to have a hash attached. Skip it if it doesn't.
+              next if include_hash.nil?
+              data_key = include_key.to_s
+              if include_hash[:as].present?
+                if include_hash[:as].to_s == include_key.to_s
+                  raise "Serializer: Cannot alias json query association to have the same as the original key; as: #{include_hash[:as].to_s}; original_key: #{include_key.to_s} on self: #{name}"
+                end
+                alias_name = include_hash[:as]
+                data[alias_name.to_s] = data[include_key.to_s]
+                data.delete(include_key.to_s)
+                data_key = alias_name.to_s
+              end
+              # At this point, the data could be an array of objects, with no as_json options.
+              if !data[data_key].is_a?(Array)
+                data[data_key] = as_json_associations_alias_fix(include_hash, data[data_key], {depth: opts[:depth] + 1})
+              else
+                data[data_key].each_with_index do |value,i|
+                  data[data_key][i] = as_json_associations_alias_fix(include_hash, value, {depth: opts[:depth] + 1})
+                end
+              end
+            end
+          end
+        end
+        return data
+      end
+
+      def generate_includes_from_json_query options = {}, klass = nil
+        query_filter = {}
+        klass = self if klass.nil?
+        if options[:include].present? && !options[:skip_eager_loading]
+          options[:include].each do |include_key, include_hash|
+            # Will 'next' if there is a scope that takes arguments, an instance-dependent scope.
+            # Can't eager load when assocation has a instance condition for it's associative scope.
+            # Might not be a real assocation
+            next if klass.reflect_on_association(include_key).nil?
+            next if klass.reflect_on_association(include_key).scope&.arity&.nonzero?
+            query_filter[include_key] = {}
+            next if include_hash.none?
+            query_filter[include_key] = generate_includes_from_json_query(include_hash, klass.reflect_on_association(include_key).klass)
+          end
+        end
+        return query_filter
+      end
+      # END MODEL CLASS METHODS
+
+    end
+  end
+end

data/lib/serializer/configuration.rb

@@ -0,0 +1,12 @@
+module Serializer
+  class Configuration
+    attr_accessor :enable_includes, :default_cache_time, :disable_model_caching, :debug
+
+    def initialize
+      @enable_includes = true
+      @default_cache_time = 360
+      @disable_model_caching = false
+      @debug = false
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: rails_json_serializer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- benjamin.dana.software.dev@gmail.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/serializer.rb
+- lib/serializer/application_serializer.rb
+- lib/serializer/concern.rb
+- lib/serializer/configuration.rb
+homepage: https://github.com/danabr75/rails_json_serializer
+licenses:
+- GNU
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: An ActiveRecord JSON Serializer with supported caching and eager-loading
+test_files: []