typed_cache 0.2.0 → 0.3.0

data/rbi/typed_cache/errors.rbi

@@ -0,0 +1,20 @@
+# typed: strict
+
+module TypedCache
+  class Error < StandardError; end
+
+  class StoreError < ::TypedCache::Error
+    sig { params(operation: Symbol, key: ::TypedCache::CacheKey, message: String, original_error: T.nilable(Error)).void }
+    def initialize(operation, key, message, original_error = nil); end
+  end
+
+  class TypeError < ::TypedCache::Error
+    sig { params(expected_type: String, actual_type: String, value: T.untyped, message: String).void }
+    def initialize(expected_type, actual_type, value, message); end
+  end
+
+  class CacheMissError < ::TypedCache::Error
+    sig { params(key: ::TypedCache::CacheKey).void }
+    def initialize(key); end
+  end
+end

data/rbi/typed_cache/instrumenter.rbi

@@ -0,0 +1,45 @@
+# typed: strict
+
+module TypedCache
+  module Instrumenter
+    abstract!
+
+    sig do
+      abstract.type_parameters(:R)
+        .params(
+          event_name: String,
+          key: String,
+          payload: T::Hash[Symbol, T.untyped],
+          blk: T.proc.returns(T.type_parameter(:R)),
+        ).returns(T.type_parameter(:R))
+    end
+    def instrument(event_name, key, **payload, &blk); end
+
+    sig do
+      abstract.type_parameters(:R)
+        .params(
+          event_name: String,
+          filters: T::Hash[Symbol, T.untyped],
+          blk: T.proc.void,
+        ).returns(T.type_parameter(:R))
+    end
+    def subscribe(event_name, **filters, &blk); end
+
+    sig { overridable.returns(String) }
+    def namespace; end
+
+    sig { overridable.returns(T::Boolean) }
+    def enabled?; end
+
+    private
+
+    sig { overridable.params(operation: String, key: String, payload: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def build_payload(operation, key, **payload); end
+
+    sig(:final) { params(operation: String).returns(String) }
+    def event_name(operation); end
+
+    sig(:final) { returns(::TypedCache::Private::Configuration::Instrumentation) }
+    def config; end
+  end
+end

data/rbi/typed_cache/instrumenters/mixins/namedspaced_singleton.rbi

@@ -0,0 +1,33 @@
+# typed: strict
+
+module TypedCache
+  module Instrumenters
+    module Mixins
+      module NamedspacedSingleton
+        requires_ancestor { ::TypedCache::Instrumenter }
+
+        class << self
+          sig { returns(T::Array[T::Class[T.all(::TypedCache::Instrumenter, ::TypedCache::Instrumenters::Mixins::NamedspacedSingleton)]]) }
+          def all; end
+        end
+
+        sig { params(namespace: ::TypedCache::Namespace).void }
+        def initialize(namespace); end
+
+        sig { returns(::TypedCache::Namespace) }
+        def namespace; end
+
+        module ClassMethods
+          sig { params(namespace: ::TypedCache::Namespace).returns(T::Class[T.all(::TypedCache::Instrumenter, ::TypedCache::Instrumenters::Mixins::NamedspacedSingleton)]) }
+          def new(namespace: T.unsafe(nil)); end
+
+          sig { params(namespace: ::TypedCache::Namespace).returns(T::Class[T.all(::TypedCache::Instrumenter, ::TypedCache::Instrumenters::Mixins::NamedspacedSingleton)]) }
+          def get(namespace); end
+
+          sig { void }
+          def clear_namespace_cache; end
+        end
+      end
+    end
+  end
+end

data/rbi/typed_cache/instrumenters.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+
+module TypedCache
+  module Instrumenters
+    class << self
+      sig { params(name: Symbol, klass: T::Class[::TypedCache::Instrumenter]).returns(T.self_type) }
+      def register(name, klass); end
+
+      sig { params(name: Symbol, args: T::Array[T.anything], options: T::Hash[Symbol, T.anything]).returns(T.self_type) }
+      def resolve(name, *args, **options); end
+
+      sig { returns(T::Array[T::Class[::TypedCache::Instrumenter]]) }
+      def available; end
+
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def registered?(name); end
+    end
+  end
+end

data/rbi/typed_cache/maybe.rbi

@@ -0,0 +1,108 @@
+# typed: strict
+
+module TypedCache
+  module Maybe
+    include Kernel
+    extend T::Generic
+
+    mixes_in_class_methods(T::Generic)
+
+    sealed!
+    interface!
+
+    V = type_member(:out)
+
+    sig { abstract.returns(T::Boolean) }
+    def some?; end
+
+    sig { abstract.returns(T::Boolean) }
+    def nothing?; end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: V).returns(T.type_parameter(:T))).returns(::TypedCache::Maybe[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.params(value: V).returns(::TypedCache::Maybe[T.type_parameter(:T)])).returns(::TypedCache::Maybe[T.type_parameter(:T)]) }
+    def bind(&block); end
+
+    alias flat_map bind
+
+    sig { abstract.type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.any(T.type_parameter(:T), V)) }
+    def value_or_else(&block); end
+
+    sig { abstract.type_parameters(:T).params(value: T.type_parameter(:T)).returns(T.any(T.type_parameter(:T), V)) }
+    def value_or(value); end
+
+    sig { abstract.returns(V) }
+    def value_or_raise!; end
+
+    class << self
+      sig { type_parameters(:T).params(value: T.type_parameter(:T)).returns(::TypedCache::Some[T.type_parameter(:T)]) }
+      def some(value); end
+
+      sig { returns(::TypedCache::Nothing) }
+      def none; end
+
+      sig { params(value: NilClass).returns(::TypedCache::Nothing) }
+      sig { params(value: ::TypedCache::Nothing).returns(::TypedCache::Nothing) }
+      sig { type_parameters(:T).params(value: ::TypedCache::Some[T.type_parameter(:T)]).returns(::TypedCache::Some[T.type_parameter(:T)]) }
+      sig { type_parameters(:T).params(value: T.type_parameter(:T)).returns(::TypedCache::Some[T.type_parameter(:T)]) }
+      def wrap(value); end
+
+      alias [] some
+    end
+  end
+
+  class Some
+    sealed!
+
+    include ::TypedCache::Maybe
+    extend T::Generic
+
+    V = type_member(:out)
+
+    sig { override.returns(TrueClass) }
+    def some?; end
+
+    sig { override.returns(FalseClass) }
+    def nothing?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(T.type_parameter(:T))).returns(Some[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(::TypedCache::Maybe[T.type_parameter(:T)])).returns(::TypedCache::Maybe[T.type_parameter(:T)]) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(value: T.type_parameter(:T)).returns(V) }
+    def value_or(value); end
+
+    sig { override.returns(V) }
+    def value_or_raise!; end
+  end
+
+  class Nothing
+    sealed!
+
+    include ::TypedCache::Maybe
+    extend T::Generic
+
+    V = type_member(:out) { { fixed: T.noreturn } }
+
+    sig { override.returns(FalseClass) }
+    def some?; end
+
+    sig { override.returns(TrueClass) }
+    def nothing?; end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(T.type_parameter(:T))).returns(T.self_type) }
+    def map(&block); end
+
+    sig { override.type_parameters(:T).params(block: T.proc.params(value: V).returns(::TypedCache::Maybe[T.type_parameter(:T)])).returns(T.self_type) }
+    def bind(&block); end
+
+    sig { override.type_parameters(:T).params(value: T.type_parameter(:T)).returns(T.type_parameter(:T)) }
+    def value_or(value); end
+
+    sig { override.returns(T.noreturn) }
+    def value_or_raise!; end
+  end
+end

data/rbi/typed_cache/namespace.rbi

@@ -0,0 +1,30 @@
+# typed: strict
+
+module TypedCache
+  class Namespace
+    sealed!
+
+    class << self
+      sig { returns(T.attached_class) }
+      def root; end
+
+      sig { params(namespace: String, namespaces: String).returns(T.attached_class) }
+      def at(namespace, *namespaces); end
+    end
+
+    sig { params(namespace: String, key_factory: T.nilable(T.proc.params(namespace: ::TypedCache::Namespace, key: String).returns(::TypedCache::CacheKey))).returns(::TypedCache::Namespace) }
+    def nested(namespace, &key_factory); end
+
+    sig { params(namespaces: String, key_factory: T.nilable(T.proc.params(namespace: ::TypedCache::Namespace, key: String).returns(::TypedCache::CacheKey))).returns(::TypedCache::Namespace) }
+    def join(*namespaces, &key_factory); end
+
+    sig { returns(::TypedCache::Namespace) }
+    def parent_namespace; end
+
+    sig { params(key: String).returns(::TypedCache::CacheKey) }
+    def key(key); end
+
+    sig { returns(String) }
+    def to_s; end
+  end
+end

data/rbi/typed_cache/snapshot.rbi

@@ -0,0 +1,54 @@
+# typed: strict
+
+module TypedCache
+  class Snapshot
+    extend T::Generic
+
+    sealed!
+
+    ValueType = type_member(:out)
+
+    sig { returns(::TypedCache::CacheKey) }
+    def key; end
+
+    sig { returns(ValueType) }
+    def value; end
+
+    sig { returns(Time) }
+    def retrieved_at; end
+
+    sig { returns(Symbol) }
+    def source; end
+
+    sig { returns(Float) }
+    def age; end
+
+    sig { returns(T::Boolean) }
+    def from_cache?; end
+
+    sig { returns(T::Boolean) }
+    def computed?; end
+
+    sig { returns(T::Boolean) }
+    def updated?; end
+
+    sig { type_parameters(:T).params(block: T.proc.params(value: ValueType).returns(T.type_parameter(:T))).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+    def map(&block); end
+
+    sig { type_parameters(:T).params(block: T.proc.params(value: ValueType).returns(::TypedCache::Either[Error, T.type_parameter(:T)])).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[T.type_parameter(:T)]]) }
+    def bind(&block); end
+
+    alias flat_map bind
+
+    class << self
+      sig { type_parameters(:T).params(key: ::TypedCache::CacheKey, value: T.type_parameter(:T)).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+      def cached(key, value); end
+
+      sig { type_parameters(:T).params(key: ::TypedCache::CacheKey, value: T.type_parameter(:T)).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+      def computed(key, value); end
+
+      sig { type_parameters(:T).params(key: ::TypedCache::CacheKey, value: T.type_parameter(:T)).returns(::TypedCache::Snapshot[T.type_parameter(:T)]) }
+      def updated(key, value); end
+    end
+  end
+end

data/rbi/typed_cache/store.rbi

@@ -0,0 +1,71 @@
+# typed: strict
+
+module TypedCache
+  module Store
+    extend T::Generic
+
+    abstract!
+
+    CachedType = type_member
+
+    Error = T.type_alias { TypedCache::Error }
+    Key = T.type_alias { T.any(String, ::TypedCache::CacheKey) }
+    private_constant :Error, :Key
+
+    sig { params(key: Key).returns(::TypedCache::Either[Error, CachedType]) }
+    def read(key); end
+
+    sig { params(keys: T::Array[Key]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def read_all(keys); end
+
+    sig { params(key: Key, value: CachedType).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def write(key, value); end
+
+    sig { params(values: T::Hash[Key, CachedType]).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def write_all(values); end
+
+    sig { params(key: Key).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[CachedType]]) }
+    def delete(key); end
+
+    sig { params(key: Key).returns(::TypedCache::CacheRef[CachedType]) }
+    def ref(key); end
+
+    sig { void }
+    def clear; end
+
+    sig { params(key: Key).returns(T::Boolean) }
+    def key?(key); end
+
+    sig { params(key: Key, block: T.proc.returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, ::TypedCache::Snapshot[::TypedCache::Maybe[CachedType]]]) }
+    def fetch(key, &block); end
+
+    sig { params(keys: T::Array[Key], block: T.proc.params(key: ::TypedCache::CacheKey).returns(T.nilable(CachedType))).returns(::TypedCache::Either[Error, T::Array[::TypedCache::Snapshot[CachedType]]]) }
+    def fetch_all(keys, &block); end
+
+    sig { returns(::TypedCache::Namespace) }
+    def namespace; end
+
+    sig { params(ns: T.any(::TypedCache::Namespace, String, T::Array[String])).returns(::TypedCache::Store[CachedType]) }
+    def with_namespace(ns); end
+
+    sig { returns(String) }
+    def store_type; end
+
+    sig { returns(T.self_type) }
+    def clone; end
+
+    sig { params(key: Key).returns(::TypedCache::CacheKey) }
+    def namespaced_key(key); end
+
+    sig { returns(::TypedCache::Instrumenter) }
+    def instrumenter; end
+
+    protected
+
+    sig { params(string: String).returns(String) }
+    def snake_case(string); end
+
+    sig { params(namespace: ::TypedCache::Namespace).returns(::TypedCache::Namespace) }
+    def nested_namespace(namespace); end
+  end
+end

data/rbi/typed_cache/version.rbi

@@ -0,0 +1,5 @@
+# typed: strict
+
+module TypedCache
+  VERSION = T.let(T.unsafe(nil), String)
+end

data/rbi/typed_cache.rbi

@@ -0,0 +1,49 @@
+# typed: strict
+
+module TypedCache
+  module Private
+    class Configuration < BasicObject
+      class Instrumentation < BasicObject
+        sig { returns(T::Boolean) }
+        attr_accessor :enabled
+
+        sig { returns(String) }
+        attr_accessor :namespace
+
+        sig { returns(Symbol) }
+        attr_accessor :instrumenter
+      end
+
+      sig { returns(String) }
+      attr_accessor :namespace
+
+      sig { returns(String) }
+      attr_accessor :cache_delimiter
+
+      sig { returns(::TypedCache::Private::Configuration::Instrumentation) }
+      def instrumentation; end
+    end
+  end
+
+  class << self
+    sig { params(block: T.proc.params(config: ::TypedCache::Private::Configuration).void).void }
+    def configure(&block); end
+
+    sig { returns(::TypedCache::Private::Configuration) }
+    def config; end
+
+    sig { returns(::TypedCache::CacheBuilder) }
+    def builder; end
+
+    sig { returns(T.class_of(::TypedCache::Backends)) }
+    def backends; end
+
+    sig { returns(T.class_of(::TypedCache::Decorators)) }
+    def decorators; end
+
+    sig { returns(T.class_of(::TypedCache::Instrumenters)) }
+    def instrumenters; end
+  end
+
+  private_constant :Backends, :Decorators, :Instrumenters
+end

data/sig/generated/typed_cache/backends/active_support.rbs

@@ -18,16 +18,28 @@ module TypedCache
 
       # @rbs override
       # : (cache_key) -> either[Error, Snapshot[V]]
-      def get: ...
+      def read: ...
 
       # @rbs override
       # : (cache_key, V) -> either[Error, Snapshot[V]]
-      def set: ...
+      def write: ...
+
+      # @rbs override
+      # : (Hash[cache_key, V]) -> either[Error, Array[Snapshot[V]]]
+      def write_all: ...
 
       # @rbs override
       # : (cache_key) -> either[Error, Snapshot[V]]
       def delete: ...
 
+      # @rbs override
+      # : (Array[cache_key]) -> either[Error, Array[Snapshot[V]]]
+      def read_all: ...
+
+      # @rbs override
+      # : (Array[cache_key]) { (CacheKey) -> V? } -> either[Error, Array[Snapshot[V]]]
+      def fetch_all: ...
+
       # @rbs override
       # : (cache_key) -> bool
       def key?: ...

data/sig/generated/typed_cache/backends/memory.rbs

@@ -55,11 +55,11 @@ module TypedCache
 
       # @rbs override
       # : (cache_key) -> either[Error, Snapshot[V]]
-      def get: ...
+      def read: ...
 
       # @rbs override
       # : (cache_key, V) -> either[Error, Snapshot[V]]
-      def set: ...
+      def write: ...
 
       # @rbs override
       # : (cache_key) -> either[Error, Snapshot[V]]

data/sig/generated/typed_cache/cache_key.rbs

@@ -29,5 +29,10 @@ module TypedCache
     def ==: (Object) -> bool
 
     alias eql? ==
+
+    private
+
+    # @rbs (String) -> String
+    def delimiter: (String) -> String
   end
 end

data/sig/generated/typed_cache/cache_ref.rbs

@@ -16,11 +16,11 @@ module TypedCache
 
     # Gets a value from the cache as a snapshot
     # : -> either[Error, Snapshot[V]]
-    def get: () -> either[Error, Snapshot[V]]
+    def read: () -> either[Error, Snapshot[V]]
 
     # Sets a value in the cache and returns it as an updated snapshot
     # : (V) -> either[Error, Snapshot[V]]
-    def set: (V) -> either[Error, Snapshot[V]]
+    def write: (V) -> either[Error, Snapshot[V]]
 
     # Deletes the value from the cache and returns the deleted value as a snapshot
     # : -> either[Error, Snapshot[V]]
@@ -77,8 +77,8 @@ module TypedCache
     def scope: [R] (String) -> CacheRef[R]
 
     # Pattern matching support for Either[Error, Snapshot[V]] results
-    # : [R] () { (Error) -> R } () { (Snapshot[V]) -> R } -> R
-    def fold: (untyped left_fn, untyped right_fn) -> untyped
+    # : [R] (^(Error) -> R, ^(Snapshot[V]) -> R) -> R
+    def fold: [R] (^(Error) -> R, ^(Snapshot[V]) -> R) -> R
 
     # Convenience method to work with the snapshot directly
     # : [R] () { (Snapshot[V]) -> R } -> either[Error, R]

data/sig/generated/typed_cache/decorator.rbs

@@ -18,5 +18,9 @@ module TypedCache
     # @rbs override
     # : (cache_key) -> either[Error, CacheRef[V]]
     def ref: ...
+
+    # @rbs override
+    # : (self) -> void
+    def initialize_copy: ...
   end
 end

data/sig/generated/typed_cache/decorators/instrumented.rbs

@@ -20,12 +20,12 @@ module TypedCache
     def initialize: (TypedCache::Store[V], instrumenter: Instrumenter) -> void
 
     # @rbs override
-    # : -> String
-    def store_type: ...
+    # : (self) -> self
+    def initialize_copy: ...
 
     # @rbs override
-    # @rbs (key) -> CacheRef[V]
-    def ref: ...
+    # : -> String
+    def store_type: ...
 
     # Additional methods that might exist on the wrapped store
     def respond_to_missing?: (untyped method_name, ?untyped include_private) -> untyped

data/sig/generated/typed_cache/either.rbs

@@ -21,6 +21,10 @@ module TypedCache
 
     def right?: () -> bool
 
+    def right_or_else: (^(E) -> void) -> R
+
+    def right_or_raise!: () -> R
+
     def map: [T] () { (R) -> T } -> either[E, T]
 
     def bind: [E2, R2] () { (R) -> either[E2, R2] } -> either[E | E2, R2]
@@ -36,6 +40,8 @@ module TypedCache
 
     attr_reader error: E
 
+    alias value error
+
     # : (E) -> void
     def initialize: (E) -> void
 
@@ -47,6 +53,14 @@ module TypedCache
     # : -> false
     def right?: ...
 
+    # @rbs override
+    # : (^(E) -> void) -> bot
+    def right_or_else: ...
+
+    # @rbs override
+    # : -> bot
+    def right_or_raise!: ...
+
     # @rbs override
     # : [T] () { (R) -> T } -> either[E, T]
     def map: ...
@@ -73,6 +87,8 @@ module TypedCache
 
     attr_reader value: R
 
+    alias result value
+
     # : (R) -> void
     def initialize: (R) -> void
 
@@ -84,6 +100,14 @@ module TypedCache
     # : -> true
     def right?: ...
 
+    # @rbs override
+    # : (^(E) -> void) -> R
+    def right_or_else: ...
+
+    # @rbs override
+    # : -> R
+    def right_or_raise!: ...
+
     # @rbs override
     # : [T] () { (R) -> T } -> either[E, T]
     def map: ...

data/sig/generated/typed_cache/instrumenter.rbs

@@ -14,17 +14,17 @@ module TypedCache
     # : -> String
     def namespace: () -> String
 
-    # @rbs (String, String, **untyped) -> Hash[Symbol, untyped]
-    def build_payload: (String, String, **untyped) -> Hash[Symbol, untyped]
-
     # @rbs () -> bool
     def enabled?: () -> bool
 
+    private
+
+    # @rbs (String, String, **untyped) -> Hash[Symbol, untyped]
+    def build_payload: (String, String, **untyped) -> Hash[Symbol, untyped]
+
     # @rbs (String) -> String
     def event_name: (String) -> String
 
-    private
-
     # @rbs () -> TypedCache::_TypedCacheInstrumentationConfig
     def config: () -> TypedCache::_TypedCacheInstrumentationConfig
   end

data/sig/generated/typed_cache/instrumenters/mixins/namespaced_singleton.rbs

@@ -24,6 +24,9 @@ module TypedCache
           # @rbs (String) -> maybe[class]
           def get: (String) -> maybe[class]
 
+          # @rbs () -> void
+          def clear_namespace_cache: () -> void
+
           # @rbs () -> Concurrent::Map[String, Class[Instrumenter & NamespacedSingleton]]
           def namespace_cache: () -> Concurrent::Map[String, Class[Instrumenter & NamespacedSingleton]]
         end

data/sig/generated/typed_cache/instrumenters.rbs

@@ -15,6 +15,8 @@ module TypedCache
     # @rbs () -> Registry[Symbol, Class[Instrumenter]]
     def self.registry: () -> Registry[Symbol, Class[Instrumenter]]
 
+    def register: (Symbol, Class[Instrumenter]) -> void
+
     def resolve: (Symbol, **untyped) -> either[Error, Instrumenter]
 
     def available: () -> Array[Symbol]