kredis 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f3e3619ec3a977b472348572202b324c813d550d43cc866ec1aab7dad8e463f0
-  data.tar.gz: 920c49f0cfe443a71dd5dc8f112070ab8061bbe2d352c98b45026ceeed871f2e
+  metadata.gz: 0c7614f548dde6852fd7e654215ba56f103fec5ac7ad6ae477fe2621f3b9964a
+  data.tar.gz: a023026462ec8a09f1e26550ce56abaeb95b1f0582665787cda48ef91e9048d1
 SHA512:
-  metadata.gz: 8f97bda6b251a100411c0338d2760aa1c2565f3ee1901f5f4971123cbe8b7a49fabf64ccc210775e9694263fd1a2a142641bcf81659776f746d05163640afda5
-  data.tar.gz: 546b9246e3952a92452fe55cf574233b12d50f29bdeb345c7efe3ebf86bd3ab9a6ff4d22731438ae3258586caca530c1e7229ffee9b581a4a22b04f585dd4467
+  metadata.gz: e3755bc5be9370676ac5b2a4a6100a26d0ed09b1248d87114911020ec1b9eb6ab094d25ec6686478069add02197d5188f59edcab04ccc69fed9bb80d1db9966f
+  data.tar.gz: 6f97f9ad814700b69b5663697add1f4b2d3468d05752c053c883ca0e8d93703b91af06f6a2593ee6ba79835435663c51c78cd17df32dafb1d7efc666150e77f6

data/README.md

@@ -20,6 +20,23 @@ integer = Kredis.integer "myinteger"
 integer.value = 5  # => SET myinteger "5"
 5 == integer.value # => GET myinteger
 
+decimal = Kredis.decimal "mydecimal" # accuracy!
+decimal.value = "%.47f" % (1.0/10) # => SET mydecimal "0.10000000000000000555111512312578270211815834045"
+BigDecimal("0.10000000000000000555111512312578270211815834045e0") == decimal.value # => GET mydecimal
+
+float = Kredis.float "myfloat" # speed!
+float.value = 1.0/10 # => SET myfloat "0.1"
+0.1 == float.value # => GET myfloat
+
+boolean = Kredis.boolean "myboolean"
+boolean.value = true # => SET myboolean "t"
+true == boolean.value # => GET myboolean
+
+datetime = Kredis.datetime "mydatetime"
+memoized_midnight = Time.zone.now.midnight
+datetime.value = memoized_midnight # SET mydatetime "2021-07-27T00:00:00.000000000Z"
+memoized_midnight == datetime.value # => GET mydatetime
+
 json = Kredis.json "myjson"
 json.value = { "one" => 1, "two" => "2" }  # => SET myjson "{\"one\":1,\"two\":\"2\"}"
 { "one" => 1, "two" => "2" } == json.value  # => GET myjson
@@ -29,78 +46,110 @@ There are data structures for counters, enums, flags, lists, unique lists, sets,
 
 ```ruby
 list = Kredis.list "mylist"
-list << "hello world!"
-[ "hello world!" ] == list.elements
+list << "hello world!"               # => RPUSH mylist "hello world!"
+[ "hello world!" ] == list.elements  # => LRANGE mylist 0, -1
 
 integer_list = Kredis.list "myintegerlist", typed: :integer
-integer_list.append([ 1, 2, 3 ])        # => LPUSH myintegerlist "1" "2" "3"
-integer_list << 4                       # => LPUSH myintegerlist "4"
-[ 1, 2, 3, 4 ] == integer_list.elements # LRANGE 0 -1
+integer_list.append([ 1, 2, 3 ])        # => RPUSH myintegerlist "1" "2" "3"
+integer_list << 4                       # => RPUSH myintegerlist "4"
+[ 1, 2, 3, 4 ] == integer_list.elements # => LRANGE myintegerlist 0 -1
 
 unique_list = Kredis.unique_list "myuniquelist"
-unique_list.append(%w[ 2 3 4 ])
-unique_list.prepend(%w[ 1 2 3 4 ])
+unique_list.append(%w[ 2 3 4 ])                # => LREM myuniquelist 0, "2" + LREM myuniquelist 0, "3" + LREM myuniquelist 0, "4"  + RPUSH myuniquelist "2", "3", "4"
+unique_list.prepend(%w[ 1 2 3 4 ])             # => LREM myuniquelist 0, "1"  + LREM myuniquelist 0, "2" + LREM myuniquelist 0, "3" + LREM myuniquelist 0, "4"  + LPUSH myuniquelist "1", "2", "3", "4"
 unique_list.append([])
-unique_list << "5"
-unique_list.remove(3)
-[ "1", "2", "4", "5" ] == unique_list.elements
+unique_list << "5"                             # => LREM myuniquelist 0, "5" + RPUSH myuniquelist "5"
+unique_list.remove(3)                          # => LREM myuniquelist 0, "3"
+[ "4", "2", "1", "5" ] == unique_list.elements # => LRANGE myuniquelist 0, -1
 
 set = Kredis.set "myset", typed: :datetime
-set.add(DateTime.tomorrow, DateTime.yesterday)            # => SADD myset "2021-02-03 00:00:00 +0100" "2021-02-01 00:00:00 +0100"
-set << DateTime.tomorrow                                  # => SADD myset "2021-02-03 00:00:00 +0100"
-2 == set.size                                             # => SCARD myset
-[ DateTime.tomorrow, DateTime.yesterday ] == set.elements # => SMEMBERS myset
+set.add(DateTime.tomorrow, DateTime.yesterday)           # => SADD myset "2021-02-03 00:00:00 +0100" "2021-02-01 00:00:00 +0100"
+set << DateTime.tomorrow                                 # => SADD myset "2021-02-03 00:00:00 +0100"
+2 == set.size                                            # => SCARD myset
+[ DateTime.tomorrow, DateTime.yesterday ] == set.members # => SMEMBERS myset
+
+hash = Kredis.hash "myhash"
+hash.update("key" => "value", "key2" => "value2")     # => HSET myhash "key", "value", "key2", "value2"
+{ "key" => "value", "key2" => "value2" } == hash.to_h # => HGETALL myhash
+"value2" == hash["key2"]                              # => HMGET myhash "key2"
+%w[ key key2 ] == hash.keys                           # => HKEYS myhash
+%w[ value value2 ] == hash.values                     # => HVALS myhash
+hash.remove                                           # => DEL myhash
+
+high_scores = Kredis.hash "high_scores", typed: :integer
+high_scores.update(space_invaders: 100, pong: 42)             # HSET high_scores "space_invaders", "100", "pong", "42"
+%w[ space_invaders pong ] == high_scores.keys                 # HKEYS high_scores
+[ 100, 42 ] == high_scores.values                             # HVALS high_scores
+{ "space_invaders" => 100, "pong" => 42 } == high_scores.to_h # HGETALL high_scores
 
 head_count = Kredis.counter "headcount"
 0 == head_count.value              # => GET "headcount"
-head_count.increment
-head_count.increment
-head_count.decrement
+head_count.increment               # => SET headcount 0 NX + INCRBY headcount 1
+head_count.increment               # => SET headcount 0 NX + INCRBY headcount 1
+head_count.decrement               # => SET headcount 0 NX + DECRBY headcount 1
 1 == head_count.value              # => GET "headcount"
 
 counter = Kredis.counter "mycounter", expires_in: 5.seconds
-counter.increment by: 2         # => SETEX "mycounter" 900 0 + INCR "mycounter" 2
+counter.increment by: 2         # => SET mycounter 0 EX 5 NX + INCRBY "mycounter" 2
 2 == counter.value              # => GET "mycounter"
 sleep 6.seconds
 0 == counter.value              # => GET "mycounter"
 
+cycle = Kredis.cycle "mycycle", values: %i[ one two three ]
+:one == cycle.value             # => GET mycycle
+cycle.next                      # => GET mycycle + SET mycycle 1
+:two == cycle.value             # => GET mycycle
+cycle.next                      # => GET mycycle + SET mycycle 2
+:three == cycle.value           # => GET mycycle
+cycle.next                      # => GET mycycle + SET mycycle 0
+:one == cycle.value             # => GET mycycle
+
 enum = Kredis.enum "myenum", values: %w[ one two three ], default: "one"
-"one" == enum.value
-true == enum.one?
-enum.value = "two"
-"two" == enum.value
+"one" == enum.value             # => GET myenum  
+true == enum.one?               # => GET myenum
+enum.value = "two"              # => SET myenum "two"
+"two" == enum.value             # => GET myenum
 enum.value = "four"
-"two" == enum.value
-enum.reset
-"one" == enum.value
+"two" == enum.value             # => GET myenum
+enum.reset                      # => DEL myenum
+"one" == enum.value             # => GET myenum  
 
 slots = Kredis.slots "myslots", available: 3
-true == slots.available?
-slots.reserve
-true == slots.available?
-slots.reserve
-true == slots.available?
-slots.reserve
-true == slots.available?
-slots.reserve
-false == slots.available?
-slots.release
-true == slots.available?
-slots.reset
+true == slots.available?        # => GET myslots
+slots.reserve                   # => INCR myslots
+true == slots.available?        # => GET myslots
+slots.reserve                   # => INCR myslots     
+true == slots.available?        # => GET myslots
+slots.reserve                   # => INCR myslots
+false == slots.available?       # => GET myslots
+slots.reserve                   # => INCR myslots + DECR myslots  
+false == slots.available?       # => GET myslots
+slots.release                   # => DECR myslots
+true == slots.available?        # => GET myslots
+slots.reset                     # => DEL myslots
+
+
+slot = Kredis.slot "myslot"
+true == slot.available?        # => GET myslot
+slot.reserve                   # => INCR myslot
+false == slot.available?       # => GET myslot
+slot.release                   # => DECR myslot
+true == slot.available?        # => GET myslot
+slot.reset                     # => DEL myslot
 
 flag = Kredis.flag "myflag"
-false == flag.marked?
-flag.mark
-true == flag.marked?
-flag.remove
-false == flag.marked?
-
-flag.mark(expires_in: 1.second)
-true == flag.marked?
+false == flag.marked?           # => EXISTS myflag
+flag.mark                       # => SET myflag 1
+true == flag.marked?            # => EXISTS myflag
+flag.remove                     # => DEL myflag  
+false == flag.marked?           # => EXISTS myflag
+
+flag.mark(expires_in: 1.second) #=> SET myflag 1 EX 1
+true == flag.marked?            #=> EXISTS myflag
 sleep 0.5.seconds
-true == flag.marked?
+true == flag.marked?            #=> EXISTS myflag
 sleep 0.6.seconds
-false == flag.marked?
+false == flag.marked?           #=> EXISTS myflag
 ```
 
 And using structures on a different than the default `shared` redis instance, relying on `config/redis/secondary.yml`:
@@ -124,12 +173,23 @@ class Person < ApplicationRecord
 end
 
 person = Person.find(5)
-person.names.append "David", "Heinemeier", "Hansson" # => SADD person:5:names "David" "Heinemeier" "Hansson"
-true == person.morning.bright?
-person.morning.value = "blue"
-true == person.morning.blue?
+person.names.append "David", "Heinemeier", "Hansson" # => RPUSH people:5:names "David" "Heinemeier" "Hansson"
+true == person.morning.bright?                       # => GET people:1:morning
+person.morning.value = "blue"                        # => SET people:1:morning
+true == person.morning.blue?                         # => GET people:1:morning
 ```
 
+You can also define `after_change` callbacks that trigger on mutations:
+
+```ruby
+class Person < ApplicationRecord
+  kredis_list :names, after_change: ->(p) {  }
+  kredis_unique_list :skills, limit: 2, after_change: :skillset_changed
+
+  def skillset_changed
+  end
+end
+```
 
 ## Installation
 
@@ -156,6 +216,32 @@ test:
 
 Additional configurations can be added under `config/redis/*.yml` and referenced when a type is created, e.g. `Kredis.string("mystring", config: :strings)` would lookup `config/redis/strings.yml`. Under the hood `Kredis.configured_for` is called which'll pass the configuration on to `Redis.new`.
 
+### Setting SSL options on Redis Connections
+
+If you need to connect to Redis with SSL, the recommended approach is to set your Redis instance manually by adding an entry to the `Kredis::Connections.connections` hash. Below an example showing how to connect to Redis using Client Authentication:
+
+```ruby
+Kredis::Connections.connections[:shared] = Redis.new(
+  url: ENV['REDIS_URL'],
+  ssl_params: {
+    cert_store: OpenSSL::X509::Store.new.tap { |store|
+      store.add_file(Rails.root.join('config', 'ca_cert.pem').to_s)
+    },
+
+    cert: OpenSSL::X509::Certificate.new(File.read(
+      Rails.root.join('config', 'client.crt')
+    )),
+
+    key: OpenSSL::PKey::RSA.new(
+      Rails.application.credentials.redis[:client_key]
+    ),
+
+    verify_mode: OpenSSL::SSL::VERIFY_PEER
+  }
+)
+```
+
+The above code could be added to either `config/environments/production.rb` or an initializer. Please ensure that your client private key, if used, is stored your credentials file or another secure location.
 
 ## License
 

data/lib/kredis/attributes.rb

@@ -2,68 +2,87 @@ module Kredis::Attributes
   extend ActiveSupport::Concern
 
   class_methods do
-    def kredis_proxy(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_proxy(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_string(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_string(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_integer(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_integer(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_datetime(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_decimal(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_flag(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_datetime(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    end
+
+    def kredis_flag(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
 
       define_method("#{name}?") do
         send(name).marked?
       end
     end
 
-    def kredis_enum(name, key: nil, values:, default:, config: :shared)
-      kredis_connection_with __method__, name, key, values: values, default: default, config: config
+    def kredis_float(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    end
+
+    def kredis_enum(name, key: nil, values:, default:, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, values: values, default: default, config: config, after_change: after_change
+    end
+
+    def kredis_json(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_json(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_list(name, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_list(name, key: nil, typed: :string, config: :shared)
-      kredis_connection_with __method__, name, key, typed: typed, config: config
+    def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, limit: limit, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared)
-      kredis_connection_with __method__, name, key, limit: limit, typed: typed, config: config
+    def kredis_set(name, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_set(name, key: nil, typed: :string, config: :shared)
-      kredis_connection_with __method__, name, key, typed: typed, config: config
+    def kredis_slot(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_slot(name, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, config: config
+    def kredis_slots(name, available:, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, available: available, config: config, after_change: after_change
     end
 
-    def kredis_slots(name, available:, key: nil, config: :shared)
-      kredis_connection_with __method__, name, key, available: available, config: config
+    def kredis_counter(name, key: nil, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, config: config, after_change: after_change
+    end
+
+    def kredis_hash(name, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
     end
 
     private
       def kredis_connection_with(method, name, key, **options)
         ivar_symbol = :"@#{name}_#{method}"
         type = method.to_s.sub("kredis_", "")
+        after_change = options.delete(:after_change)
 
         define_method(name) do
           if instance_variable_defined?(ivar_symbol)
             instance_variable_get(ivar_symbol)
           else
-            instance_variable_set(ivar_symbol, Kredis.send(type, kredis_key_evaluated(key) || kredis_key_for_attribute(name), **options))
+            new_type = Kredis.send(type, kredis_key_evaluated(key) || kredis_key_for_attribute(name), **options)
+            instance_variable_set ivar_symbol,
+              after_change ? enrich_after_change_with_record_access(new_type, after_change) : new_type
           end
         end
       end
@@ -84,4 +103,11 @@ module Kredis::Attributes
     def extract_kredis_id
       try(:id) or raise NotImplementedError, "kredis needs a unique id, either implement an id method or pass a custom key."
     end
+
+    def enrich_after_change_with_record_access(type, original_after_change)
+      case original_after_change
+      when Proc   then Kredis::Types::CallbacksProxy.new(type, ->(_) { original_after_change.call(self) })
+      when Symbol then Kredis::Types::CallbacksProxy.new(type, ->(_) { send(original_after_change) })
+      end
+    end
 end

data/lib/kredis/connections.rb

@@ -6,13 +6,22 @@ module Kredis::Connections
 
   def configured_for(name)
     connections[name] ||= begin
-      logger&.info "[Kredis] Connected to #{name}"
-      Redis.new configurator.config_for("redis/#{name}")
+      Kredis.instrument :meta, message: "Connected to #{name}" do
+        Redis.new configurator.config_for("redis/#{name}")
+      end
     end
   end
 
   def clear_all
-    logger&.info "[Kredis] Connections all cleared"
-    connections.each_value(&:flushdb)
+    Kredis.instrument :meta, message: "Connections all cleared" do
+      connections.each_value do |connection|
+        if Kredis.namespace
+          keys = connection.keys("#{Kredis.namespace}:*")
+          connection.del keys if keys.any?
+        else
+          connection.flushdb
+        end
+      end
+    end
   end
 end

data/lib/kredis/log_subscriber.rb

@@ -0,0 +1,22 @@
+require "active_support/log_subscriber"
+
+class Kredis::LogSubscriber < ActiveSupport::LogSubscriber
+  def proxy(event)
+    debug formatted_in(YELLOW, event, type: "Proxy")
+  end
+
+  def migration(event)
+    debug formatted_in(YELLOW, event, type: "Migration")
+  end
+
+  def meta(event)
+    info formatted_in(MAGENTA, event)
+  end
+
+  private
+    def formatted_in(color, event, type: nil)
+      color "  Kredis #{type} (#{event.duration.round(1)}ms)  #{event.payload[:message]}", color, true
+    end
+end
+
+Kredis::LogSubscriber.attach_to :kredis

data/lib/kredis/migration.rb

@@ -5,6 +5,7 @@ class Kredis::Migration
 
   def initialize(config = :shared)
     @redis = Kredis.configured_for config
+    # TODO: Replace script loading with `copy` command once Redis 6.2+ is the minimum supported version.
     @copy_sha = @redis.script "load", "redis.call('SETNX', KEYS[2], redis.call('GET', KEYS[1])); return 1;"
   end
 
@@ -21,8 +22,9 @@ class Kredis::Migration
     namespaced_to = Kredis.namespaced_key(to)
 
     if to.present? && from != namespaced_to
-      log_migration "Migrating key #{from} to #{namespaced_to}"
-      @redis.evalsha @copy_sha, keys: [ from, namespaced_to ]
+      log_migration "Migrating key #{from} to #{namespaced_to}" do
+        @redis.evalsha @copy_sha, keys: [ from, namespaced_to ]
+      end
     else
       log_migration "Skipping blank/unaltered migration key #{from} → #{to}"
     end
@@ -45,7 +47,7 @@ class Kredis::Migration
       end until cursor == "0"
     end
 
-    def log_migration(message)
-      Kredis.logger&.debug "[Kredis Migration] #{message}"
+    def log_migration(message, &block)
+      Kredis.instrument :migration, message: message, &block
     end
 end

data/lib/kredis/railtie.rb

@@ -1,33 +1,29 @@
-require "rails/railtie"
+class Kredis::Railtie < ::Rails::Railtie
+  config.kredis = ActiveSupport::OrderedOptions.new
 
-module Kredis
-  class Railtie < ::Rails::Railtie
-    config.kredis = ActiveSupport::OrderedOptions.new
-
-    initializer "kredis.testing" do
-      ActiveSupport.on_load(:active_support_test_case) do
-        parallelize_setup { |worker| Kredis.namespace = "test-#{worker}" }
-        teardown { Kredis.clear_all }
-      end
+  initializer "kredis.testing" do
+    ActiveSupport.on_load(:active_support_test_case) do
+      parallelize_setup { |worker| Kredis.namespace = "test-#{worker}" }
+      teardown { Kredis.clear_all }
     end
+  end
 
-    initializer "kredis.logger" do
-      Kredis.logger = config.kredis.logger || Rails.logger
-    end
+  initializer "kredis.logger" do
+    Kredis::LogSubscriber.logger = config.kredis.logger || Rails.logger
+  end
 
-    initializer "kredis.configurator" do
-      Kredis.configurator = Rails.application
-    end
+  initializer "kredis.configurator" do
+    Kredis.configurator = Rails.application
+  end
 
-    initializer "kredis.attributes" do
-      # No load hook for Active Model, just defer until after initialization.
-      config.after_initialize do
-        ActiveModel::Model.include Kredis::Attributes if defined?(ActiveModel::Model)
-      end
+  initializer "kredis.attributes" do
+    # No load hook for Active Model, just defer until after initialization.
+    config.after_initialize do
+      ActiveModel::Model.include Kredis::Attributes if defined?(ActiveModel::Model)
+    end
 
-      ActiveSupport.on_load(:active_record) do
-        include Kredis::Attributes
-      end
+    ActiveSupport.on_load(:active_record) do
+      include Kredis::Attributes
     end
   end
 end

data/lib/kredis/type/datetime.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kredis
+  module Type
+    class DateTime < ActiveModel::Type::DateTime
+      def serialize(value)
+        super&.iso8601(9)
+      end
+
+      def cast_value(value)
+        super&.to_datetime
+      end
+    end
+  end
+end

data/lib/kredis/type/json.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kredis
+  module Type
+    class Json < ActiveModel::Type::Value
+      def type
+        :json
+      end
+
+      def cast_value(value)
+        JSON.load(value)
+      end
+
+      def serialize(value)
+        JSON.dump(value)
+      end
+    end
+  end
+end

data/lib/kredis/type_casting.rb

@@ -1,45 +1,35 @@
+require "json"
+require "active_model/type"
+require "kredis/type/json"
+require "kredis/type/datetime"
+
 module Kredis::TypeCasting
   class InvalidType < StandardError; end
 
-  VALID_TYPES = %i[ string integer decimal float boolean datetime json ]
-
-  def type_to_string(value)
-    case value
-    when nil
-      ""
-    when Integer
-      value.to_s
-    when BigDecimal
-      value.to_d
-    when Float
-      value.to_s
-    when TrueClass, FalseClass
-      value ? "t" : "f"
-    when Time, DateTime, ActiveSupport::TimeWithZone
-      value.iso8601(9)
-    when Hash
-      JSON.dump(value)
-    else
-      value
-    end
+  TYPES = {
+    string: ActiveModel::Type::String.new,
+    integer: ActiveModel::Type::Integer.new,
+    decimal: ActiveModel::Type::Decimal.new,
+    float: ActiveModel::Type::Float.new,
+    boolean: ActiveModel::Type::Boolean.new,
+    datetime: Kredis::Type::DateTime.new,
+    json: Kredis::Type::Json.new
+  }
+
+  def type_to_string(value, type)
+    raise InvalidType if type && !TYPES.key?(type)
+
+    TYPES[type || :string].serialize(value)
   end
 
   def string_to_type(value, type)
-    raise InvalidType if type && !type.in?(VALID_TYPES)
-
-    case type
-    when nil, :string then value
-    when :integer     then value.to_i
-    when :decimal     then value.to_d
-    when :float       then value.to_f
-    when :boolean     then value == "t" ? true : false
-    when :datetime    then Time.iso8601(value)
-    when :json        then JSON.load(value)
-    end if value.present?
+    raise InvalidType if type && !TYPES.key?(type)
+
+    TYPES[type || :string].cast(value)
   end
 
-  def types_to_strings(values)
-    Array(values).flatten.map { |value| type_to_string(value) }
+  def types_to_strings(values, type)
+    Array(values).flatten.map { |value| type_to_string(value, type) }
   end
 
   def strings_to_types(values, type)

data/lib/kredis/types/callbacks_proxy.rb

@@ -0,0 +1,31 @@
+class Kredis::Types::CallbacksProxy
+  attr_reader :type
+  delegate :to_s, to: :type
+
+  AFTER_CHANGE_OPERATIONS = {
+    Kredis::Types::Counter => %i[ increment decrement reset ],
+    Kredis::Types::Cycle => %i[ next ],
+    Kredis::Types::Enum => %i[ value= reset ],
+    Kredis::Types::Flag => %i[ mark remove ],
+    Kredis::Types::Hash => %i[ update delete ],
+    Kredis::Types::List => %i[ remove prepend append << ],
+    Kredis::Types::Scalar => %i[ value= clear ],
+    Kredis::Types::Set => %i[ add << remove replace take clear ],
+    Kredis::Types::Slots => %i[ reserve release reset ]
+  }
+
+  def initialize(type, callback)
+    @type, @callback = type, callback
+  end
+
+  def method_missing(method, *args, **kwargs, &block)
+    result = type.send(method, *args, **kwargs, &block)
+    invoke_suitable_after_change_callback_for method
+    result
+  end
+
+  private
+    def invoke_suitable_after_change_callback_for(method)
+      @callback.call(type) if AFTER_CHANGE_OPERATIONS[type.class]&.include? method
+    end
+end

data/lib/kredis/types/counter.rb

@@ -1,5 +1,5 @@
 class Kredis::Types::Counter < Kredis::Types::Proxying
-  proxying :multi, :set, :incrby, :decrby, :get
+  proxying :multi, :set, :incrby, :decrby, :get, :del
 
   attr_accessor :expires_in
 
@@ -20,4 +20,8 @@ class Kredis::Types::Counter < Kredis::Types::Proxying
   def value
     get.to_i
   end
+
+  def reset
+    del
+  end
 end

data/lib/kredis/types/cycle.rb

@@ -0,0 +1,13 @@
+class Kredis::Types::Cycle < Kredis::Types::Counter
+  attr_accessor :values
+
+  alias index value
+
+  def value
+    values[index]
+  end
+
+  def next
+    set (index + 1) % values.size
+  end
+end

data/lib/kredis/types/enum.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/object/inclusion"
+
 class Kredis::Types::Enum < Kredis::Types::Proxying
   proxying :set, :get, :del
 

data/lib/kredis/types/hash.rb

@@ -0,0 +1,44 @@
+require "active_support/core_ext/hash"
+
+class Kredis::Types::Hash < Kredis::Types::Proxying
+  proxying :hget, :hset, :hmget, :hdel, :hgetall, :hkeys, :hvals, :del
+
+  attr_accessor :typed
+
+  def [](key)
+    string_to_type(hget(key), typed)
+  end
+
+  def []=(key, value)
+    update key => value
+  end
+
+  def update(**entries)
+    hset entries.transform_values{ |val| type_to_string(val, typed) } if entries.flatten.any?
+  end
+
+  def values_at(*keys)
+    strings_to_types(hmget(keys) || [], typed)
+  end
+
+  def delete(*keys)
+    hdel keys if keys.flatten.any?
+  end
+
+  def remove
+    del
+  end
+
+  def entries
+    (hgetall || {}).transform_values { |val| string_to_type(val, typed) }.with_indifferent_access
+  end
+  alias to_h entries
+
+  def keys
+    hkeys || []
+  end
+
+  def values
+    strings_to_types(hvals || [], typed)
+  end
+end

data/lib/kredis/types/list.rb

@@ -9,15 +9,15 @@ class Kredis::Types::List < Kredis::Types::Proxying
   alias to_a elements
 
   def remove(*elements)
-    types_to_strings(elements).each { |element| lrem 0, element }
+    types_to_strings(elements, typed).each { |element| lrem 0, element }
   end
 
   def prepend(*elements)
-    lpush types_to_strings(elements) if elements.flatten.any?
+    lpush types_to_strings(elements, typed) if elements.flatten.any?
   end
 
   def append(*elements)
-    rpush types_to_strings(elements) if elements.flatten.any?
+    rpush types_to_strings(elements, typed) if elements.flatten.any?
   end
   alias << append
 end

data/lib/kredis/types/proxy.rb

@@ -14,9 +14,10 @@ class Kredis::Types::Proxy
   end
 
   def method_missing(method, *args, **kwargs)
-    failsafe do
-      Kredis.logger&.debug log_message(method, *args, **kwargs)
-      redis.public_send method, key, *args, **kwargs
+    Kredis.instrument :proxy, **log_message(method, *args, **kwargs) do
+      failsafe do
+        redis.public_send method, key, *args, **kwargs
+      end
     end
   end
 
@@ -24,8 +25,7 @@ class Kredis::Types::Proxy
     def log_message(method, *args, **kwargs)
       args      = args.flatten.reject(&:blank?).presence
       kwargs    = kwargs.reject { |_k, v| v.blank? }.presence
-      type_name = self.class.name.split("::").last
 
-      "[Kredis #{type_name}] #{method.upcase} #{key} #{args&.inspect} #{kwargs&.inspect}".chomp
+      { message: "#{method.upcase} #{key} #{args&.inspect} #{kwargs&.inspect}".chomp }
     end
 end

data/lib/kredis/types/scalar.rb

@@ -1,14 +1,20 @@
 class Kredis::Types::Scalar < Kredis::Types::Proxying
-  proxying :set, :get, :exists?, :del
+  proxying :set, :get, :exists?, :del, :expire, :expireat
 
-  attr_accessor :typed, :default
+  attr_accessor :typed, :default, :expires_in
 
   def value=(value)
-    set type_to_string(value)
+    set type_to_string(value, typed), ex: expires_in
   end
 
   def value
-    string_to_type(get, typed) || default
+    value_after_casting = string_to_type(get, typed)
+
+    if value_after_casting.nil?
+      default
+    else
+      value_after_casting
+    end
   end
 
   def to_s
@@ -22,4 +28,12 @@ class Kredis::Types::Scalar < Kredis::Types::Proxying
   def clear
     del
   end
+
+  def expire_in(seconds)
+    expire seconds.to_i
+  end
+
+  def expire_at(datetime)
+    expireat datetime.to_i
+  end
 end

data/lib/kredis/types/set.rb

@@ -9,12 +9,12 @@ class Kredis::Types::Set < Kredis::Types::Proxying
   alias to_a members
 
   def add(*members)
-    sadd types_to_strings(members) if members.flatten.any?
+    sadd types_to_strings(members, typed) if members.flatten.any?
   end
   alias << add
 
   def remove(*members)
-    srem types_to_strings(members) if members.flatten.any?
+    srem types_to_strings(members, typed) if members.flatten.any?
   end
 
   def replace(*members)
@@ -25,7 +25,7 @@ class Kredis::Types::Set < Kredis::Types::Proxying
   end
 
   def include?(member)
-    sismember type_to_string(member)
+    sismember type_to_string(member, typed)
   end
 
   def size

data/lib/kredis/types.rb

@@ -1,73 +1,90 @@
 module Kredis::Types
-  def proxy(key, config: :shared)
-    Proxy.new configured_for(config), namespaced_key(key)
+  autoload :CallbacksProxy, "kredis/types/callbacks_proxy"
+
+  def proxy(key, config: :shared, after_change: nil)
+    type_from(Proxy, config, key, after_change: after_change)
   end
 
 
-  def scalar(key, typed: :string, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: typed, default: default
+  def scalar(key, typed: :string, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: typed, default: default, expires_in: expires_in)
+  end
+
+  def string(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :string, default: default, expires_in: expires_in)
   end
 
-  def string(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :string, default: default
+  def integer(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :integer, default: default, expires_in: expires_in)
   end
 
-  def integer(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :integer, default: default
+  def decimal(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :decimal, default: default, expires_in: expires_in)
   end
 
-  def decimal(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :decimal, default: default
+  def float(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :float, default: default, expires_in: expires_in)
   end
 
-  def float(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :float, default: default
+  def boolean(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :boolean, default: default, expires_in: expires_in)
   end
 
-  def boolean(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :boolean, default: default
+  def datetime(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :datetime, default: default, expires_in: expires_in)
   end
 
-  def datetime(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :datetime, default: default
+  def json(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Scalar, config, key, after_change: after_change, typed: :json, default: default, expires_in: expires_in)
   end
 
-  def json(key, default: nil, config: :shared)
-    Scalar.new configured_for(config), namespaced_key(key), typed: :json, default: default
+
+  def counter(key, expires_in: nil, config: :shared, after_change: nil)
+    type_from(Counter, config, key, after_change: after_change, expires_in: expires_in)
   end
 
+  def cycle(key, values:, expires_in: nil, config: :shared, after_change: nil)
+    type_from(Cycle, config, key, after_change: after_change, values: values, expires_in: expires_in)
+  end
 
-  def counter(key, expires_in: nil, config: :shared)
-    Counter.new configured_for(config), namespaced_key(key), expires_in: expires_in
+  def flag(key, config: :shared, after_change: nil)
+    type_from(Flag, config, key, after_change: after_change)
   end
 
-  def flag(key, config: :shared)
-    Flag.new configured_for(config), namespaced_key(key)
+  def enum(key, values:, default:, config: :shared, after_change: nil)
+    type_from(Enum, config, key, after_change: after_change, values: values, default: default)
   end
 
-  def enum(key, values:, default:, config: :shared)
-    Enum.new configured_for(config), namespaced_key(key), values: values, default: default
+  def hash(key, typed: :string, config: :shared, after_change: nil)
+    type_from(Hash, config, key, after_change: after_change, typed: typed)
   end
 
-  def list(key, typed: :string, config: :shared)
-    List.new configured_for(config), namespaced_key(key), typed: typed
+  def list(key, typed: :string, config: :shared, after_change: nil)
+    type_from(List, config, key, after_change: after_change, typed: typed)
   end
 
-  def unique_list(key, typed: :string, limit: nil, config: :shared)
-    UniqueList.new configured_for(config), namespaced_key(key), typed: typed, limit: limit
+  def unique_list(key, typed: :string, limit: nil, config: :shared, after_change: nil)
+    type_from(UniqueList, config, key, after_change: after_change, typed: typed, limit: limit)
   end
 
-  def set(key, typed: :string, config: :shared)
-    Set.new configured_for(config), namespaced_key(key), typed: typed
+  def set(key, typed: :string, config: :shared, after_change: nil)
+    type_from(Set, config, key, after_change: after_change, typed: typed)
   end
 
-  def slot(key, config: :shared)
-    Slots.new configured_for(config), namespaced_key(key), available: 1
+  def slot(key, config: :shared, after_change: nil)
+    type_from(Slots, config, key, after_change: after_change, available: 1)
   end
 
-  def slots(key, available:, config: :shared)
-    Slots.new configured_for(config), namespaced_key(key), available: available
+  def slots(key, available:, config: :shared, after_change: nil)
+    type_from(Slots, config, key, after_change: after_change, available: available)
   end
+
+  private
+    def type_from(type_klass, config, key, after_change: nil, **options)
+      type_klass.new(configured_for(config), namespaced_key(key), **options).then do |type|
+        after_change ? CallbacksProxy.new(type, after_change) : type
+      end
+    end
 end
 
 require "kredis/types/proxy"
@@ -75,8 +92,10 @@ require "kredis/types/proxying"
 
 require "kredis/types/scalar"
 require "kredis/types/counter"
+require "kredis/types/cycle"
 require "kredis/types/flag"
 require "kredis/types/enum"
+require "kredis/types/hash"
 require "kredis/types/list"
 require "kredis/types/unique_list"
 require "kredis/types/set"

data/lib/kredis/version.rb

@@ -1,3 +1,3 @@
 module Kredis
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/lib/kredis.rb

@@ -1,20 +1,30 @@
-require "kredis/railtie"
+require "active_support"
+require "active_support/core_ext/module/attribute_accessors"
+
 require "kredis/version"
 
 require "kredis/connections"
+require "kredis/log_subscriber"
 require "kredis/namespace"
+require "kredis/type_casting"
 require "kredis/types"
 require "kredis/attributes"
-require "kredis/type_casting"
 
-module Kredis
-  include Connections, Namespace, Types, TypeCasting
+require "kredis/railtie" if defined?(Rails::Railtie)
 
+module Kredis
+  include Connections, Namespace, TypeCasting, Types
   extend self
 
+  autoload :Migration, "kredis/migration"
+
   mattr_accessor :logger
 
   def redis(config: :shared)
     configured_for(config)
   end
+
+  def instrument(channel, **options, &block)
+    ActiveSupport::Notifications.instrument("#{channel}.kredis", **options, &block)
+  end
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
 - David Heinemeier Hansson
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-05 00:00:00.000000000 Z
+date: 2021-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,21 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
-description:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: 
 email: david@hey.com
 executables: []
 extensions: []
@@ -50,14 +64,20 @@ files:
 - lib/kredis.rb
 - lib/kredis/attributes.rb
 - lib/kredis/connections.rb
+- lib/kredis/log_subscriber.rb
 - lib/kredis/migration.rb
 - lib/kredis/namespace.rb
 - lib/kredis/railtie.rb
+- lib/kredis/type/datetime.rb
+- lib/kredis/type/json.rb
 - lib/kredis/type_casting.rb
 - lib/kredis/types.rb
+- lib/kredis/types/callbacks_proxy.rb
 - lib/kredis/types/counter.rb
+- lib/kredis/types/cycle.rb
 - lib/kredis/types/enum.rb
 - lib/kredis/types/flag.rb
+- lib/kredis/types/hash.rb
 - lib/kredis/types/list.rb
 - lib/kredis/types/proxy.rb
 - lib/kredis/types/proxy/failsafe.rb
@@ -71,7 +91,7 @@ homepage: https://github.com/rails/kredis
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +106,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key:
+rubygems_version: 3.1.4
+signing_key: 
 specification_version: 4
 summary: Higher-level data structures built on Redis.
 test_files: []