redcord 0.0.1.alpha → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abc776db5aa9171e1f8a478013a55179158d7c9dc97e65953c27c162ad4069c7
-  data.tar.gz: 55d37148a8069725c09637f29392a6461993d93f6999bc76247e646f96a94528
+  metadata.gz: 525c939f4cee5b8adbb11b0530a2b2f44f6a26a8bb1a55e4dc837d725b3f71fb
+  data.tar.gz: f7e1747cc025310b20ab5e8d675fefe6d951ec60c5c09056454e11c8c366008e
 SHA512:
-  metadata.gz: 1cfe27b4241554f39ce0f8f0dbce4492f308e3a1db5607f4dbb7153832f976b692987926a6cc9c7c051121f55819f9e9b9b10c02b82250986d3aa6fdf4964e8e
-  data.tar.gz: fa4865ee7e9ad1b70b4c7037d196bb60ed2aed8ab774356ec07b06a9cefd1f964d05f4da1cdd7cd2e09a5366f7bfb8da06ab84e50e282cfc74cccbb16a185621
+  metadata.gz: 6e2ff5ff1008d0a9e59e02438010e78324ec86c3ce03c470f28175498c7b29fbd277f97509f59dead80e258609ed033c9d686119726553b206996c064d4c7827
+  data.tar.gz: bba7b07d1e6b222614667a271b25973f5d1693d2090cb533dcbbfaf092f6200cce75ce5a7cf76356277bc1d51ae5011405465caae64ad295b85faa63d016c191

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

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 # typed: strict
+
 require 'sorbet-coerce'
 
 require 'redcord/relation'
@@ -6,9 +9,7 @@ require 'redcord/relation'
 module Redcord
   # Raised by Model.find
   class RecordNotFound < StandardError; end
-  # Raised by Model.where
-  class AttributeNotIndexed < StandardError; end
-  class WrongAttributeType < TypeError; end
+  class InvalidAction < StandardError; end
 end
 
 module Redcord::Actions
@@ -24,25 +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.new(
-          "Couldn't find #{name} with 'id'=#{id}"
-        )
+      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)
+      end
+    end
+
+    sig { params(args: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+    def find_by(args)
+      Redcord::Base.trace(
+       'redcord_actions_class_methods_find_by_args',
+        model_name: name,
+      ) do
+        where(args).to_a.first
       end
-      coerce_and_set_id(args, id)
     end
 
     sig { params(args: T::Hash[Symbol, T.untyped]).returns(Redcord::Relation) }
@@ -52,7 +93,18 @@ module Redcord::Actions
 
     sig { params(id: T.untyped).returns(T::Boolean) }
     def destroy(id)
-      return 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
 
@@ -65,45 +117,124 @@ module Redcord::Actions
     sig { abstract.returns(T.nilable(ActiveSupport::TimeWithZone)) }
     def created_at; end
 
-    sig { abstract.params(time: ActiveSupport::TimeWithZone).returns(T.nilable(ActiveSupport::TimeWithZone)) }
+    sig {
+      abstract.params(
+        time: ActiveSupport::TimeWithZone,
+      ).returns(T.nilable(ActiveSupport::TimeWithZone))
+    }
     def created_at=(time); end
 
     sig { abstract.returns(T.nilable(ActiveSupport::TimeWithZone)) }
     def updated_at; end
 
-    sig { abstract.params(time: ActiveSupport::TimeWithZone).returns(T.nilable(ActiveSupport::TimeWithZone)) }
+    sig {
+      abstract.params(
+        time: ActiveSupport::TimeWithZone,
+      ).returns(T.nilable(ActiveSupport::TimeWithZone))
+    }
     def updated_at=(time); end
 
     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?
-      self.class.destroy(T.must(id))
+      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))
+      end
     end
 
     sig { returns(String) }
@@ -118,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
+    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,19 +1,45 @@
+# frozen_string_literal: true
+
 # typed: strict
+module Redcord
+  class InvalidAttribute < StandardError; end
+end
+
 module Redcord::Attribute
   extend T::Sig
   extend T::Helpers
 
-  # We implicitly determine what should be a range index on Redis based on Ruby type.
+  # We implicitly determine what should be a range index on Redis based on Ruby
+  # type.
   RangeIndexType = T.type_alias {
-    T.any(T.nilable(Time), T.nilable(Float), T.nilable(Integer))
+    T.any(
+      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
@@ -26,48 +52,127 @@ module Redcord::Attribute
         options: T::Hash[Symbol, T.untyped],
       ).void
     end
-    def attribute(name, type, options={})
+    def attribute(name, type, options = {})
       # TODO: support uniq options
+      # TODO: validate types
       prop(name, type)
-      if options[:index]
-        index_attribute(name, type)
-      end
+
+      index_attribute(name, type) if options[:index]
     end
-    
 
-    sig { params(attr: Symbol, type: T.any(Class,T::Types::Base)).void }
+    sig { params(attr: Symbol, type: T.any(Class, T::Types::Base)).void }
     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
-    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.new do |redis|
-        redis.sadd("#{model_key}:#{redis_key}", item_to_add)
+    def shard_by_attribute(attr=nil)
+      return class_variable_get(:@@shard_by_attribute) if attr.nil?
+
+      # 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
 
-    sig { params(type: T.any(Class,T::Types::Base)).returns(T::Boolean) }
+    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?
-      if type.is_a?(Class)
-        type = T::Types::Simple.new(type)
+      type = T::Types::Simple.new(type) if type.is_a?(Class)
+
+      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
-      return type.subtype_of?(RangeIndexType)
+
+      "{#{tag || default_tag}}"
     end
   end