redcord 0.0.3 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7612a04876a98367ab0b8a6d94a0254d0d79aa564b3bd43e5119785f114d962c
-  data.tar.gz: 9b679659f7087bfd65d202a58be3f0836b1a7e8bc889f16d34e423340ce8c4ed
+  metadata.gz: 9f33907b35b938f14be13d1d20f89f1530d72a28cb55e7e38a53f61743a2bfe5
+  data.tar.gz: 1297ac81f293f35572a0015782aa621b1d5ba0e3e691ea86abadbdde26ca094a
 SHA512:
-  metadata.gz: 44796213c268dfb63e59472c9b59470e3b01dd7a26b0acc63aa48e0f7ff537c25906957d3700b24639eb41d9526708898dc8ff82a4eeea193fc7ec1a3a5cfe43
-  data.tar.gz: d656f40756c62507113ac660429e9dc10751f40158c8768d47ccdb238ac2d392ccdfc055744ef68837608e7ed33f5673527178a9d0ef77a928d4cabd49da055f
+  metadata.gz: f4d23f458c6f6de224293010b60f19d7c07199c66eb382e5bd5a7917a429900658bfd42202107c3e72ace588ea526bcf3edb6b56dfeaa7a6b58f3eea4b91dc81
+  data.tar.gz: d1aa8dedf1dccad372489072405725fe51e3712b634524c73c574130ab8473bab1fefdedfbd47466c956ab7e96e121153798f08a4250b30e7dc30d33039bf801

data/lib/redcord.rb

@@ -36,3 +36,4 @@ require 'redcord/migration'
 require 'redcord/migration/migrator'
 require 'redcord/migration/version'
 require 'redcord/railtie'
+require 'redcord/vacuum_helper'

data/lib/redcord/actions.rb

@@ -9,6 +9,7 @@ require 'redcord/relation'
 module Redcord
   # Raised by Model.find
   class RecordNotFound < StandardError; end
+  class InvalidAction < StandardError; end
 end
 
 module Redcord::Actions
@@ -24,15 +25,36 @@ module Redcord::Actions
   module ClassMethods
     extend T::Sig
 
+    sig { returns(Integer) }
+    def count
+      Redcord::Base.trace(
+       'redcord_actions_class_methods_count',
+        model_name: name,
+      ) do
+        res = 0
+        redis.scan_each_shard("#{model_key}:id:*") { res += 1 }
+        res
+      end
+    end
+
     sig { params(args: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
     def create!(args)
       Redcord::Base.trace(
        'redcord_actions_class_methods_create!',
         model_name: name,
       ) do
+        self.props.keys.each { |attr_key| args[attr_key] = nil unless args.key?(attr_key) }
         args[:created_at] = args[:updated_at] = Time.zone.now
         instance = TypeCoerce[self].new.from(args)
-        id = redis.create_hash_returning_id(model_key, to_redis_hash(args))
+        id = redis.create_hash_returning_id(
+          model_key,
+          to_redis_hash(args),
+          ttl: _script_arg_ttl,
+          index_attrs: _script_arg_index_attrs,
+          range_index_attrs: _script_arg_range_index_attrs,
+          custom_index_attrs: _script_arg_custom_index_attrs,
+          hash_tag: instance.hash_tag,
+        )
         instance.send(:id=, id)
         instance
       end
@@ -75,7 +97,13 @@ module Redcord::Actions
        'redcord_actions_class_methods_destroy',
         model_name: name,
       ) do
-        redis.delete_hash(model_key, id) == 1
+        redis.delete_hash(
+          model_key,
+          id,
+          index_attrs: _script_arg_index_attrs,
+          range_index_attrs: _script_arg_range_index_attrs,
+          custom_index_attrs: _script_arg_custom_index_attrs,
+        ) == 1
       end
     end
   end
@@ -115,10 +143,19 @@ module Redcord::Actions
         self.updated_at = Time.zone.now
         _id = id
         if _id.nil?
+          serialized_instance = serialize
+          self.class.props.keys.each do |attr_key|
+            serialized_instance[attr_key.to_s] = nil unless serialized_instance.key?(attr_key.to_s) 
+          end
           self.created_at = T.must(self.updated_at)
           _id = redis.create_hash_returning_id(
             self.class.model_key,
-            self.class.to_redis_hash(serialize),
+            self.class.to_redis_hash(serialized_instance),
+            ttl: self.class._script_arg_ttl,
+            index_attrs: self.class._script_arg_index_attrs,
+            range_index_attrs: self.class._script_arg_range_index_attrs,
+            custom_index_attrs: self.class._script_arg_custom_index_attrs,
+            hash_tag: hash_tag,
           )
           send(:id=, _id)
         else
@@ -126,17 +163,37 @@ module Redcord::Actions
             self.class.model_key,
             _id,
             self.class.to_redis_hash(serialize),
+            ttl: self.class._script_arg_ttl,
+            index_attrs: self.class._script_arg_index_attrs,
+            range_index_attrs: self.class._script_arg_range_index_attrs,
+            custom_index_attrs: self.class._script_arg_custom_index_attrs,
+            hash_tag: hash_tag,
           )
         end
       end
     end
 
+    sig { returns(T::Boolean) }
+    def save
+      save!
+
+      true
+    rescue Redis::CommandError
+      # TODO: break down Redis::CommandError by parsing the error message
+      false
+    end
+
     sig { params(args: T::Hash[Symbol, T.untyped]).void }
-    def update!(args = {})
+    def update!(args)
       Redcord::Base.trace(
        'redcord_actions_instance_methods_update!',
         model_name: self.class.name,
       ) do
+        shard_by_attr = self.class.shard_by_attribute
+        if args.keys.include?(shard_by_attr)
+          raise Redcord::InvalidAction, "Cannot update shard_by attribute #{shard_by_attr}"
+        end
+
         _id = id
         if _id.nil?
           _set_args!(args)
@@ -148,11 +205,26 @@ module Redcord::Actions
             self.class.model_key,
             _id,
             self.class.to_redis_hash(args),
+            ttl: self.class._script_arg_ttl,
+            index_attrs: self.class._script_arg_index_attrs,
+            range_index_attrs: self.class._script_arg_range_index_attrs,
+            custom_index_attrs: self.class._script_arg_custom_index_attrs,
+            hash_tag: hash_tag,
           )
         end
       end
     end
 
+    sig { params(args: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+    def update(args)
+      update!(args)
+
+      true
+    rescue Redis::CommandError
+      # TODO: break down Redis::CommandError by parsing the error message
+      false
+    end
+
     sig { returns(T::Boolean) }
     def destroy
       Redcord::Base.trace(
@@ -177,14 +249,14 @@ module Redcord::Actions
       end
     end
 
-    sig { returns(T.nilable(Integer)) }
+    sig { returns(T.nilable(String)) }
     def id
       instance_variable_get(:@_id)
     end
 
     private
 
-    sig { params(id: Integer).returns(Integer) }
+    sig { params(id: String).returns(String) }
     def id=(id)
       instance_variable_set(:@_id, id)
     end

data/lib/redcord/attribute.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 # typed: strict
+module Redcord
+  class InvalidAttribute < StandardError; end
+end
 
 module Redcord::Attribute
   extend T::Sig
@@ -10,18 +13,33 @@ module Redcord::Attribute
   # type.
   RangeIndexType = T.type_alias {
     T.any(
-      T.nilable(Float),
-      T.nilable(Integer),
-      T.nilable(Time),
+      Float,
+      Integer,
+      NilClass,
+      Numeric,
+      Time,
     )
   }
 
+  # Implicitly determine what data type can be a used in custom index on Redis based on Ruby type.
+  # Custom index currently supports positive integers with up to 19 characters in decimal notation, 
+  # will raise error in Lua if bigger numbers are used.
+  CustomIndexType = T.type_alias {
+    T.any(
+      Integer,
+      Time,
+    )
+  }
+  
   sig { params(klass: T.class_of(T::Struct)).void }
   def self.included(klass)
     klass.extend(ClassMethods)
+    klass.include(InstanceMethods)
     klass.class_variable_set(:@@index_attributes, Set.new)
     klass.class_variable_set(:@@range_index_attributes, Set.new)
+    klass.class_variable_set(:@@custom_index_attributes, Hash.new { |h, k| h[k] = [] })
     klass.class_variable_set(:@@ttl, nil)
+    klass.class_variable_set(:@@shard_by_attribute, nil)
   end
 
   module ClassMethods
@@ -46,30 +64,81 @@ module Redcord::Attribute
     def index_attribute(attr, type)
       if should_range_index?(type)
         class_variable_get(:@@range_index_attributes) << attr
-        sadd_proc_on_redis_connection('range_index_attrs', attr.to_s)
       else
         class_variable_get(:@@index_attributes) << attr
-        sadd_proc_on_redis_connection('index_attrs', attr.to_s)
       end
     end
+    
+    sig { params(index_name: Symbol, attrs: T::Array[Symbol]).void }
+    def custom_index(index_name, attrs)
+      attrs.each do |attr|
+        type = props[attr][:type]
+        if !can_custom_index?(type)
+          raise(Redcord::WrongAttributeType, "Custom index doesn't support '#{type}' attributes.")
+        end
+      end
+      shard_by_attr = class_variable_get(:@@shard_by_attribute)
+      if shard_by_attr and shard_by_attr != attrs.first
+        raise(
+          Redcord::CustomIndexInvalidDesign,
+          "shard_by attribute '#{shard_by_attr}' must be placed first in '#{index_name}' index"
+        )
+      end
+      class_variable_get(:@@custom_index_attributes)[index_name] = attrs
+    end
 
     sig { params(duration: T.nilable(ActiveSupport::Duration)).void }
     def ttl(duration)
       class_variable_set(:@@ttl, duration)
     end
 
-    private
+    def shard_by_attribute(attr=nil)
+      return class_variable_get(:@@shard_by_attribute) if attr.nil?
 
-    sig { params(redis_key: String, item_to_add: String).void }
-    def sadd_proc_on_redis_connection(redis_key, item_to_add)
-      # TODO: Currently we're setting indexed attributes through procs that are
-      # run when a RedisConnection is established. This should be replaced with
-      # migrations
-      Redcord::RedisConnection.procs_to_prepare << proc do |redis|
-        redis.sadd("#{model_key}:#{redis_key}", item_to_add)
+      # attr must be an non-index attribute (index: false)
+      if class_variable_get(:@@index_attributes).include?(attr) ||
+          class_variable_get(:@@range_index_attributes).include?(attr)
+        raise Redcord::InvalidAttribute, "Cannot shard by an index attribute '#{attr}'"
       end
+
+      class_variable_get(:@@custom_index_attributes).each do |index_name, attrs|
+        if attr != attrs.first
+          raise(
+            Redcord::CustomIndexInvalidDesign,
+            "shard_by attribute '#{attr}' must be placed first in '#{index_name}' index"
+          )
+        end
+
+        # Delete the shard_by_attribute since it would be a constant in the
+        # custom index set
+        attrs.shift
+      end
+
+      class_variable_set(:@@shard_by_attribute, attr)
     end
 
+    sig { returns(Integer) }
+    def _script_arg_ttl
+      class_variable_get(:@@ttl)&.to_i || -1
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def _script_arg_index_attrs
+      class_variable_get(:@@index_attributes).to_a
+    end
+
+    sig { returns(T::Array[Symbol]) }
+    def _script_arg_range_index_attrs
+      class_variable_get(:@@range_index_attributes).to_a
+    end
+
+    sig { returns(T::Hash[Symbol, T::Array]) }
+    def _script_arg_custom_index_attrs
+      class_variable_get(:@@custom_index_attributes)
+    end
+
+    private
+
     sig { params(type: T.any(Class, T::Types::Base)).returns(T::Boolean) }
     def should_range_index?(type)
       # Change Ruby raw type to Sorbet type in order to call subtype_of?
@@ -77,6 +146,34 @@ module Redcord::Attribute
 
       type.subtype_of?(RangeIndexType)
     end
+
+    sig { params(type: T.any(Class, T::Types::Base)).returns(T::Boolean) }
+    def can_custom_index?(type)
+      # Change Ruby raw type to Sorbet type in order to call subtype_of?
+      type = T::Types::Simple.new(type) if type.is_a?(Class)
+      type.subtype_of?(CustomIndexType)
+    end
+  end
+
+  module InstanceMethods
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    def hash_tag
+      attr = self.class.class_variable_get(:@@shard_by_attribute)
+
+      return nil if attr.nil?
+
+      # A blank hash tag would cause MOVED error in cluster mode
+      tag = send(attr)
+      default_tag = '__redcord_hash_tag_null__'
+
+      if tag == default_tag
+        raise Redcord::InvalidAttribute, "#{attr}=#{default_tag} conflicts with default hash_tag value"
+      end
+
+      "{#{tag || default_tag}}"
+    end
   end
 
   mixes_in_class_methods(ClassMethods)

data/lib/redcord/base.rb

@@ -56,9 +56,19 @@ module Redcord::Base
       # coerced to the specified attribute types. Like ActiveRecord,
       # Redcord manages the created_at and updated_at fields behind the
       # scene.
-      attribute :id, T.nilable(Integer), index: true
-      attribute :created_at, T.nilable(Time), index: true
-      attribute :updated_at, T.nilable(Time), index: true
+      prop :created_at, T.nilable(Time)
+      prop :updated_at, T.nilable(Time)
     end
   end
+
+  sig { returns(T::Array[T.class_of(Redcord::Base)]) }
+  def self.descendants
+    descendants = []
+    # TODO: Use T::Struct instead of Class
+    ObjectSpace.each_object(Class) do |klass|
+      descendants << klass if klass < self
+    end
+    descendants
+  end
+
 end

data/lib/redcord/connection_pool.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'connection_pool'
+require_relative 'redis'
+
+class Redcord::ConnectionPool
+  def initialize(pool_size:, timeout:, **client_options)
+    @connection_pool = ::ConnectionPool.new(size: pool_size, timeout: timeout) do
+      # Construct a new client every time the block gets called
+      Redcord::Redis.new(**client_options, logger: Redcord::Logger.proxy)
+    end
+  end
+
+  # Avoid method_missing when possible for better performance
+  methods = Set.new(Redcord::Redis.instance_methods(false) + Redis.instance_methods(false))
+  methods.each do |method_name|
+    define_method method_name do |*args, &blk|
+      @connection_pool.with do |redis|
+        redis.send(method_name, *args, &blk)
+      end
+    end
+  end
+
+  def method_missing(method_name, *args, &blk)
+    @connection_pool.with do |redis|
+      redis.send(method_name, *args, &blk)
+    end
+  end
+end

data/lib/redcord/migration.rb

@@ -2,11 +2,13 @@
 class Redcord::Migration
 end
 
+require 'redcord/migration/index'
 require 'redcord/migration/ttl'
 
 class Redcord::Migration
   extend T::Sig
   extend T::Helpers
+  include Redcord::Migration::Index
   include Redcord::Migration::TTL
 
   abstract!

data/lib/redcord/migration/index.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module Redcord::Migration::Index
+  extend T::Sig
+
+  sig { params(model: T.class_of(Redcord::Base), index_name: Symbol).void }
+  def remove_index(model, index_name)
+    model.redis.scan_each_shard("#{model.model_key}:#{index_name}:*") { |key| _del_set(model, key) }
+
+    attr_set = "#{model.model_key}:#{index_name}"
+    nil_attr_set = "#{attr_set}:"
+
+    model.redis.scan_each_shard("#{nil_attr_set}*") { |key| _del_set(model, key) }
+    model.redis.scan_each_shard("#{attr_set}*") { |key| _del_zset(model, key) }
+  end
+
+  sig { params(model: T.class_of(Redcord::Base), index_name: Symbol).void }
+  def remove_custom_index(model, index_name)
+    index_key = "#{model.model_key}:custom_index:#{index_name}"
+    index_content_key = "#{model.model_key}:custom_index:#{index_name}_content"
+    model.redis.scan_each_shard("#{index_key}*") { |key| model.redis.unlink(key) }
+    model.redis.scan_each_shard("#{index_content_key}*") { |key| model.redis.unlink(key) }
+  end
+
+  sig {
+    params(
+      model: T.class_of(Redcord::Base),
+      attr_set_name: String,
+      index_name: Symbol,
+    ).void
+  }
+  def _remove_index_from_attr_set(model:, attr_set_name:, index_name:)
+    model.redis.srem("#{model.model_key}:#{attr_set_name}", index_name)
+  end
+
+  sig { params(model: T.class_of(Redcord::Base), key: String).void }
+  def _del_set(model, key)
+    # Use SPOP here to minimize blocking
+    loop do
+      break unless model.redis.spop(key)
+    end
+
+    model.redis.del(key)
+  end
+
+  sig { params(model: T.class_of(Redcord::Base), key: String).void }
+  def _del_zset(model, key)
+    # ZPOPMIN might not be avaliable on old redis servers
+    model.redis.zscan_each(match: key) do |id, _|
+      model.redis.zrem(key, id)
+    end
+
+    model.redis.del(key)
+  end
+end