redcord 0.0.2.alpha → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 679b0154429c95be05676a47608f0778c3d34e714d60eb5ec065863691fa9461
-  data.tar.gz: 43847db0f9fd339c8a91db402b8b2da70ea4b3f874b6faf8a05d20f234cf0aea
+  metadata.gz: c0c8f566eb89b44bd73c4a444deb313af1004a342a703a0e9f504364aa96df40
+  data.tar.gz: e77507ef1ebb3a1d2a6ba9f0fc654d25355f5bc685b05e4bc07368957bdc7ec3
 SHA512:
-  metadata.gz: b01c381b8e3436aaf0f4d2ebc8604bfd582c64663601a17044b0a29ca45c46e4e8ced22969ed5c53123af65808e1c4749cf262bec17e26468c1624c0023d2b9d
-  data.tar.gz: cb4403b960c7f2e017143738edcbbfbe356e7e8c8e5b761d1f98482296541dcc2255b480d1285ce233d5add5c7e7e78fda29ab8f5fafd561f106a64e9e144460
+  metadata.gz: 27d9afec9f1a663516b65096439312bdc313aed672c6476bcf38d0ce98cd9178bebf3b5a46341d69ad6fc6f3f4268655956c6e5170af2f7da8489d68e343dee5
+  data.tar.gz: 1b011be75251942091acc209189f33d72ff289496a07f5700c140a06916f83ad310e1e804fc3bd60d77815f89b57fd6a66b9efe2d7fabd81d32dfca7f281b7d6

data/lib/redcord.rb

@@ -1,11 +1,39 @@
+# frozen_string_literal: true
+
 # typed: strict
-module Redcord
-end
 
 require 'sorbet-runtime'
 
+module Redcord
+  extend T::Sig
+
+  @@configuration_blks = T.let(
+    [],
+    T::Array[T.proc.params(arg0: T.untyped).void],
+  )
+
+  sig {
+    params(
+      blk: T.proc.params(arg0: T.untyped).void,
+    ).void
+  }
+  def self.configure(&blk)
+    @@configuration_blks << blk
+  end
+
+  sig { void }
+  def self._after_initialize!
+    @@configuration_blks.each do |blk|
+      blk.call(Redcord::Base)
+    end
+
+    @@configuration_blks.clear
+  end
+end
+
 require 'redcord/base'
 require 'redcord/migration'
 require 'redcord/migration/migrator'
 require 'redcord/migration/version'
 require 'redcord/railtie'
+require 'redcord/vacuum_helper'

data/lib/redcord.rbi

@@ -45,22 +45,6 @@ module Redcord::TTL::ClassMethods
   include Redcord::Serializer::ClassMethods
 end
 
-module Redcord::ServerScripts
-  include Kernel
-
-  sig do
-    params(
-      sha: String,
-      keys: T::Array[T.untyped],
-      argv: T::Array[T.untyped],
-    ).returns(T.untyped)
-  end
-  def evalsha(sha, keys: [], argv:[]); end
-
-  sig { returns(T::Hash[Symbol, String]) }
-  def redcord_server_script_shas; end
-end
-
 module Redcord::Actions::ClassMethods
   include Kernel
   include Redcord::RedisConnection::ClassMethods

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,29 +25,65 @@ 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)
-      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))
-      instance.send(:id=, id)
-      instance
+      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),
+          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
     end
 
     sig { params(id: T.untyped).returns(T.untyped) }
     def find(id)
-      instance_key = "#{model_key}:id:#{id}"
-      args = redis.hgetall(instance_key)
-      if args.empty?
-        raise Redcord::RecordNotFound, "Couldn't find #{name} with 'id'=#{id}"
-      end
+      Redcord::Base.trace(
+       'redcord_actions_class_methods_find',
+        model_name: name,
+      ) do
+        instance_key = "#{model_key}:id:#{id}"
+        args = redis.hgetall(instance_key)
+        if args.empty?
+          raise Redcord::RecordNotFound, "Couldn't find #{name} with 'id'=#{id}"
+        end
 
-      coerce_and_set_id(args, id)
+        coerce_and_set_id(args, id)
+      end
     end
 
     sig { params(args: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
     def find_by(args)
-      where(args).to_a.first
+      Redcord::Base.trace(
+       'redcord_actions_class_methods_find_by_args',
+        model_name: name,
+      ) do
+        where(args).to_a.first
+      end
     end
 
     sig { params(args: T::Hash[Symbol, T.untyped]).returns(Redcord::Relation) }
@@ -56,7 +93,18 @@ module Redcord::Actions
 
     sig { params(id: T.untyped).returns(T::Boolean) }
     def destroy(id)
-      redis.delete_hash(model_key, id) == 1
+      Redcord::Base.trace(
+       'redcord_actions_class_methods_destroy',
+        model_name: name,
+      ) do
+        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
 
@@ -88,46 +136,105 @@ module Redcord::Actions
 
     sig { void }
     def save!
-      self.updated_at = Time.zone.now
-      _id = id
-      if _id.nil?
-        self.created_at = T.must(self.updated_at)
-        _id = redis.create_hash_returning_id(
-          self.class.model_key,
-          self.class.to_redis_hash(serialize),
-        )
-        send(:id=, _id)
-      else
-        redis.update_hash(
-          self.class.model_key,
-          _id,
-          self.class.to_redis_hash(serialize),
-        )
+      Redcord::Base.trace(
+       'redcord_actions_instance_methods_save!',
+        model_name: self.class.name,
+      ) do
+        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(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
+          redis.update_hash(
+            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 = {})
-      _id = id
-      if _id.nil?
-        _set_args!(args)
-        save!
-      else
-        args[:updated_at] = Time.zone.now
-        _set_args!(args)
-        redis.update_hash(
-          self.class.model_key,
-          _id,
-          self.class.to_redis_hash(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)
+          save!
+        else
+          args[:updated_at] = Time.zone.now
+          _set_args!(args)
+          redis.update_hash(
+            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
-      return false if id.nil?
+      Redcord::Base.trace(
+       'redcord_actions_instance_methods_destroy',
+        model_name: self.class.name,
+      ) do
+        return false if id.nil?
 
-      self.class.destroy(T.must(id))
+        self.class.destroy(T.must(id))
+      end
     end
 
     sig { returns(String) }
@@ -142,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)