rails_json_serializer 3.0.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dbc21fe6370943050869252bcb0dc1ad737ed58058d34dca1a0877d1f09adec
-  data.tar.gz: 5b8c6a68aab5c7c7f9b67bba5987f70004f73cec4071ccdda7cec0ab96725636
+  metadata.gz: 4a17108258803bac91fbf2506e02b2953fe1d49c4ae3758acea6a6b8671a5cf0
+  data.tar.gz: f8e2ad23101fe3ba7a9253d6dbeec9d82b1c5f9392ce2df8c47db74326921858
 SHA512:
-  metadata.gz: 29e9cb62478a5a225b3c56fd8e99e2cf9b1451542d4c170e494009ddba478ca9d50cd6f0e9ba927c17365ce583826bd7396d7341e37abbd2ad4736a80c54ce7a
-  data.tar.gz: 73b5b85f6c0644f61d9c1b66710774015db55e4a273b22379b4021a156c89ed2420df53b43941992efdb4f76fd8dc1860c89c405ec1a105694d8c83d629e830e
+  metadata.gz: f95e665cd9adfc8c9900ba981d75af1b2448cb8c23baa41454b63aaeaf49e5fc04846ab60d18bbc2991491d3a7b310666a863ba830fad71fee18225a88db0f38
+  data.tar.gz: 8f7b66cce88ba721b58ce24a76d7a75791f61054ab0da38de23a495aa1f1d20c1d93b344cc4b393dc2479727c9d589bdfd4de807563ad8cf3465239aa4011901

data/lib/serializer/configuration.rb

@@ -1,12 +1,26 @@
+require "zlib"
+
 module Serializer
   class Configuration
-    attr_accessor :enable_includes, :default_cache_time, :disable_model_caching, :debug
+    attr_accessor :enable_includes, :default_cache_time, :disable_model_caching, :debug, :cache_key
+    attr_accessor :compress, :compressor, :decompressor
 
     def initialize
       @enable_includes = true
       @default_cache_time = 360
       @disable_model_caching = false
       @debug = false
+      @compress = false
+      @cache_key = Proc.new { |class_name, query_name, object_id| "#{class_name}_____#{query_name}___#{object_id}" }
+      @compressor = Proc.new { |incoming_data| Base64.encode64(Zlib::Deflate.deflate(incoming_data.to_json)) }
+
+      # have to use 'temp_val', or else there's an issue with the libraries. Won't work as a 1-liner
+      @decompressor = Proc.new do |outgoing_data|
+        temp_val1 = Base64.decode64(outgoing_data)
+        temp_val2 = Zlib::Inflate.inflate(temp_val1)
+        JSON.parse(temp_val2)
+      end
+
     end
   end
 end

data/lib/serializer/model_serializer.rb

@@ -4,6 +4,8 @@ module ModelSerializer
     # START CLASS EVAL
     klass.class_eval do
 
+
+      # I don't think we need to check for classname + serialiers. We are now including via: `include ModelSerializer` in classes
       # Rails 5 has autoloading issues with modules. They will show as not defined, when available.
       if Rails.env.development?
         begin
@@ -23,10 +25,31 @@ module ModelSerializer
         # Inject class methods, will have access to those queries on the class.
         klass.send(:extend, serializer_klass)
 
+        # Class method to clear the cache of objects without having to instantiate them.
+        def self.clear_serializer_cache id_or_ids
+          if !id_or_ids.is_a?(Array)
+            id_or_ids = [id_or_ids]
+          end
+          id_or_ids.each do |object_id|
+            self::SERIALIZER_QUERY_KEYS_CACHE.each do |query_name|
+              cache_key = Serializer.configuration.cache_key.call(self.name, query_name, object_id)
+              Rails.logger.debug "(class) CLEARING SERIALIZER CACHE: #{cache_key}" if Serializer.configuration.debug
+              Rails.cache.delete(cache_key)
+            end
+          end
+        end
+
         # no need to define it if inheriting class has defined it OR has been manually overridden.
-        # CLASS METHODS
-        klass.send(:define_singleton_method, :serializer) do |opts = {}|  
+        # CLASS METHOD - :serializer
+        klass.send(:define_singleton_method, :serializer) do |opts = {}|
+          # puts "CLASS METHOD - SERIALIZER - OPTS: #{opts.inspect}"
           query = opts[:json_query_override].present? ? self.send(opts[:json_query_override], opts) : serializer_query(opts)
+          
+          # if as_json arg, then add to as_json query
+          if opts[:disable_caching] == true
+            query[:disable_caching] = true
+          end
+          
           if Serializer.configuration.enable_includes && query[:include].present? && !opts[:skip_eager_loading]
             includes(generate_includes_from_json_query(query)).as_json(query)
           else
@@ -107,29 +130,47 @@ module ModelSerializer
             return super(options)
           end
           options[:ran_serialization] = true
+
           # 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)
+            cache_key = Serializer.configuration.cache_key.call(self.class.name, options[:cache_key], self.id)
+
+            if Rails.cache.exist?(cache_key) && options[:disable_caching] != true
+              Rails.logger.debug "Serializer: Cache reading #{cache_key}" if Serializer.configuration.debug
+              # Rails.logger.debug(options.inspect) if Serializer.configuration.debug
+              outgoing_data = Rails.cache.read(cache_key)
+              if (options.key?(:compress) && options[:compress] == true) || (!options.key?(:compress) && Serializer.configuration.compress)
+                outgoing_data = Serializer.configuration.decompressor.call(outgoing_data)
+              end
+              return outgoing_data
             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
+
+              if options[:disable_caching] != true
+                # compress data
+                cachable_data = data
+                if (options.key?(:compress) && options[:compress] == true) || (!options.key?(:compress) && Serializer.configuration.compress)
+                  cachable_data = Serializer.configuration.compressor.call(data)
+                end
+                begin
+                    Rails.logger.debug "Serializer: Caching #{cache_key} for #{(options[:cache_for] || Serializer.configuration.default_cache_time)} minutes." if Serializer.configuration.debug
+                    Rails.cache.write(cache_key, cachable_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
+              else
+                Rails.logger.debug "Serializer: Cache reading/writing for #{cache_key} is disabled" if Serializer.configuration.debug
               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`"
+              Rails.logger.debug "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)
@@ -137,9 +178,17 @@ module ModelSerializer
           end
         end
 
+        # INSTANCE METHOD - :serializer
         if !klass.method_defined?(:serializer)
           klass.send(:define_method, :serializer) do |opts = {}|
+            # puts "INSTANCE METHOD - SERIALIZER - OPTS: #{opts.inspect}"
             query = opts[:json_query_override].present? ? self.class.send(opts[:json_query_override], opts) : self.class.serializer_query(opts)
+            
+            # if as_json arg, then add to as_json query
+            if opts[:disable_caching] == true
+              query[:disable_caching] = true
+            end
+
             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)
@@ -153,8 +202,8 @@ module ModelSerializer
         klass.send(:define_method, :clear_serializer_cache) do
           if self.class.const_defined?("SERIALIZER_QUERY_KEYS_CACHE")
             self.class::SERIALIZER_QUERY_KEYS_CACHE.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
+              cache_key = Serializer.configuration.cache_key.call(self.class.name, query_name, self.id)
+              Rails.logger.debug "Serializer: CLEARING CACHE KEY: #{cache_key}" if Serializer.configuration.debug
               Rails.cache.delete(cache_key)
             end
             return true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_json_serializer
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.2.0
 platform: ruby
 authors:
 - benjamin.dana.software.dev@gmail.com
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: zlib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: An ActiveRecord JSON Serializer with supported caching and eager-loading