redcord 0.0.1.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: abc776db5aa9171e1f8a478013a55179158d7c9dc97e65953c27c162ad4069c7
+  data.tar.gz: 55d37148a8069725c09637f29392a6461993d93f6999bc76247e646f96a94528
+SHA512:
+  metadata.gz: 1cfe27b4241554f39ce0f8f0dbce4492f308e3a1db5607f4dbb7153832f976b692987926a6cc9c7c051121f55819f9e9b9b10c02b82250986d3aa6fdf4964e8e
+  data.tar.gz: fa4865ee7e9ad1b70b4c7037d196bb60ed2aed8ab774356ec07b06a9cefd1f964d05f4da1cdd7cd2e09a5366f7bfb8da06ab84e50e282cfc74cccbb16a185621

data/lib/redcord.rb

@@ -0,0 +1,11 @@
+# typed: strict
+module Redcord
+end
+
+require 'sorbet-runtime'
+
+require 'redcord/base'
+require 'redcord/migration'
+require 'redcord/migration/migrator'
+require 'redcord/migration/version'
+require 'redcord/railtie'

data/lib/redcord.rbi

@@ -0,0 +1,94 @@
+# typed: strong
+module ModuleClassMethodsAsInstanceMethods
+  # Sorbet does not understand the ClassMethods modules are actually defining
+  # class methods. Hence this module redefines some top level class methods as
+  # instance methods. Sigs are copied from
+  # https://github.com/sorbet/sorbet/blob/f9380ec833047a834bbaca1eb3502ae96a0e4394/rbi/core/module.rbi
+  include Kernel
+
+  sig do
+    params(
+        arg0: T.any(Symbol, String),
+    )
+    .returns(T.untyped)
+  end
+  def class_variable_get(arg0); end
+
+  sig do
+    params(
+        arg0: T.any(Symbol, String),
+        arg1: BasicObject,
+    )
+    .returns(T.untyped)
+  end
+  def class_variable_set(arg0, arg1); end
+
+  sig {returns(String)}
+  def name(); end
+end
+
+module Redcord::RedisConnection::ClassMethods
+  include ModuleClassMethodsAsInstanceMethods
+end
+
+module Redcord::RedisConnection::InstanceMethods
+  include Kernel
+end
+
+module Redcord::Attribute::ClassMethods
+  include Redcord::Serializer::ClassMethods
+  # from inherenting T::Struct
+  def prop(name, type, options={}); end
+end
+
+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
+  include Redcord::Serializer::ClassMethods
+end
+
+module Redcord::Actions::InstanceMethods
+  include Kernel
+  include Redcord::RedisConnection::InstanceMethods
+
+  sig {returns(String)}
+  def to_json; end
+
+  sig {returns(T::Hash[String, T.untyped])}
+  def serialize; end
+end
+
+module Redcord::Base
+  include Redcord::Actions::InstanceMethods
+  extend Redcord::Serializer::ClassMethods
+
+  mixes_in_class_methods(Redcord::TTL::ClassMethods)
+end
+
+module Redcord::Serializer::ClassMethods
+  include ModuleClassMethodsAsInstanceMethods
+
+    # from inherenting T::Struct
+    def from_hash(args); end
+    def props; end
+end

data/lib/redcord/actions.rb

@@ -0,0 +1,135 @@
+# typed: strict
+require 'sorbet-coerce'
+
+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
+end
+
+module Redcord::Actions
+  extend T::Sig
+  extend T::Helpers
+
+  sig { params(klass: T.class_of(T::Struct)).void }
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.include(InstanceMethods)
+  end
+
+  module ClassMethods
+    extend T::Sig
+
+    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
+    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}"
+        )
+      end
+      coerce_and_set_id(args, id)
+    end
+
+    sig { params(args: T::Hash[Symbol, T.untyped]).returns(Redcord::Relation) }
+    def where(args)
+      Redcord::Relation.new(T.let(self, T.untyped)).where(args)
+    end
+
+    sig { params(id: T.untyped).returns(T::Boolean) }
+    def destroy(id)
+      return redis.delete_hash(model_key, id) == 1
+    end
+  end
+
+  module InstanceMethods
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { abstract.returns(T.nilable(ActiveSupport::TimeWithZone)) }
+    def created_at; end
+
+    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)) }
+    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))
+      end
+    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))
+      end
+    end
+
+    sig { returns(T::Boolean) }
+    def destroy
+      return false if id.nil?
+      self.class.destroy(T.must(id))
+    end
+
+    sig { returns(String) }
+    def instance_key
+      "#{self.class.model_key}:id:#{T.must(id)}"
+    end
+
+    sig { params(args: T::Hash[Symbol, T.untyped]).void }
+    def _set_args!(args)
+      args.each do |key, value|
+        send(:"#{key}=", value)
+      end
+    end
+
+    sig { returns(T.nilable(Integer)) }
+    def id
+      instance_variable_get(:@_id)
+    end
+
+  private
+
+    sig { params(id: Integer).returns(Integer) }
+    def id=(id)
+      instance_variable_set(:@_id, id)
+    end
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end

data/lib/redcord/attribute.rb

@@ -0,0 +1,75 @@
+# typed: strict
+module Redcord::Attribute
+  extend T::Sig
+  extend T::Helpers
+
+  # 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))
+  }
+
+  sig { params(klass: T.class_of(T::Struct)).void }
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.class_variable_set(:@@index_attributes, Set.new)
+    klass.class_variable_set(:@@range_index_attributes, Set.new)
+    klass.class_variable_set(:@@ttl, nil)
+  end
+
+  module ClassMethods
+    extend T::Sig
+
+    sig do
+      params(
+        name: Symbol,
+        type: T.untyped, # until smth better is proposed
+        options: T::Hash[Symbol, T.untyped],
+      ).void
+    end
+    def attribute(name, type, options={})
+      # TODO: support uniq options
+      prop(name, type)
+      if options[:index]
+        index_attribute(name, type)
+      end
+    end
+    
+
+    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(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)
+      end
+    end
+
+    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)
+      end
+      return type.subtype_of?(RangeIndexType)
+    end
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end

data/lib/redcord/base.rb

@@ -0,0 +1,59 @@
+# typed: strict
+#
+# A Redis ORM API inspired by ActiveRecord:
+# - It provides atomic CRUD operations
+#   - One round trip per operation
+# - Model attributes are type-checked by sorbet
+#
+require 'redcord/actions'
+require 'redcord/attribute'
+require 'redcord/configurations'
+require 'redcord/logger'
+require 'redcord/redis_connection'
+require 'redcord/serializer'
+
+module Redcord::Base
+  extend T::Sig
+  extend T::Helpers
+
+  # Base level methods
+  #   Redis logger can be configured at the baes level. Redis connections can
+  #   be configured at the base-level, the model level, and Rails environment
+  #   level.
+  include Redcord::Configurations
+  include Redcord::Logger
+  include Redcord::RedisConnection
+
+  abstract!
+
+  sig { params(klass: T.class_of(T::Struct)).void }
+  def self.included(klass)
+    # Redcord uses `T::Struct` to validate the attribute types. The
+    # Redcord models need to inherit `T::Struct` and include
+    # `Redcord::Base`, for example:
+    #
+    #   class MyRedisModel < T::Struct
+    #     include Redcord::Base
+    #
+    #     attribute :my_redis_value, Integer
+    #   end
+    #
+    # See more examples in spec/lib/redcord_spec.rb.
+
+    klass.class_eval do
+      # Redcord Model level methods
+      include Redcord::Serializer
+      include Redcord::Actions
+      include Redcord::Attribute
+      include Redcord::RedisConnection
+
+      # Redcord stores the serialized model as a hash on Redis. When
+      # reading a model from Redis, the hash fields are deserialized and
+      # coerced to the specified attribute types. Like ActiveRecord,
+      # Redcord manages the created_at and updated_at fields behind the
+      # scene.
+      prop :created_at, T.nilable(Time)
+      prop :updated_at, T.nilable(Time)
+    end
+  end
+end

data/lib/redcord/configurations.rb

@@ -0,0 +1,72 @@
+# typed: strict
+#
+#  This allows us to configure Redis connections for Redcord. Redis
+#  connections can be set at the base level or model level.
+#
+#  Connections are established by reading the connection configurations for the
+#  current Rails environment (development, test, or production). When a model
+#  level connection config is not found, the base level config will be used (which
+#  is a common case in the test environment).
+#
+#  For example, in with yaml file:
+#  ```
+#  my_env:
+#    default:
+#      url: redis_url_1
+#    my_model:
+#      url: redis_url_2
+#  ```
+#
+#  All models other than my model will connect to redis_url_1. My_model connects
+#  to redis_url_2.
+#
+#  It is also possible to change the connection in runtime by setting the new
+#  configuration and call `establish_connection`. `establish_connection` clears
+#  out the current connection at the mode or base level, and make a new based on
+#  the latest connection config, which is similar to ActiveRecord.
+#
+#  Unlike `ActiveRecord::Base.establish_connection`, it does not take any
+#  arguments and only uses the current configuration. We can change the
+#  connection config anytime we want, however, the connection won't actually
+#  change until we call establish_connection.
+#
+#  For example,
+#  ```
+#  Redcord::Base.configurations = {env => {'spec_model' => {'url' => fake_url}}}
+#  Model_class.redis # the same connection
+#
+#  model_class.establish_connection
+#  Model_class.redis # using the connection to fake_url
+#  ```
+#
+require 'redcord/redis_connection'
+module Redcord::Configurations
+  extend T::Sig
+  extend T::Helpers
+
+  sig { params(klass: Module).void }
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    extend T::Sig
+
+    @@configurations = T.let(
+      Redcord::RedisConnection.merge_and_resolve_default({}),
+      T::Hash[String, T.untyped]
+    )
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    def configurations
+      @@configurations
+    end
+
+    sig { params(config: T::Hash[String, T.untyped]).void }
+    def configurations=(config)
+      @@configurations = Redcord::RedisConnection.merge_and_resolve_default(config)
+    end
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end