typed_cache 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dadf4193084b314da94b9144bbef5766f8898a443404ef10f66202685394622
-  data.tar.gz: faaa5d4542bbe2ca5716a309f4361c885217633a02b68109d6b402741516494f
+  metadata.gz: f4ce9735b042027d3a74d3d5b624c916dade1673855d906503c843e214ab08f7
+  data.tar.gz: 1e448a580e62f8889edd6520066d3ef212bf3ad8892e58ce79ba1d3eaec94fbf
 SHA512:
-  metadata.gz: c82b0271eadd1415e9064f90d7093cff83d38e27c611f634efdd4abf4b96f8b05cd878102d98320acbb2c93dd6b3932ff15bdd841e66b8a9bbe0097460cf9a2b
-  data.tar.gz: 895344cc495dbf7aacc384e8bcb3a89f39fc928472b7ab013421f5c3ab35565c1c84c7beb054ec09528d6a61bc7ade3d3b1c30fd948adb47177ec9c909ad18ed
+  metadata.gz: 7173225ff902a77ac9083483a005238ac7b54301943a75c4179e52ccaaaaff12923f17a0d427f6f7a07da56d183e588c4fe8922af64b4a0c7077e1042f786805
+  data.tar.gz: 5b9e1fefd5b4e82e5cb24f126336a69d92c91e2b2d0312b19e1ad82e3af5967721224d47bd1960dfcf2637dc50c92da1d290fa9783a3b6a2f320d9ee7b9e4acd

data/lib/typed_cache/backend.rb

@@ -10,7 +10,77 @@ module TypedCache
   # that actually persist data.
   # @rbs generic V
   module Backend
-    include Store #[V]
-    # @rbs! include Store::_Store[V]
+    # @rbs! type cache_key = String | CacheKey
+
+    # @rbs!
+    #   interface _Backend[V]
+    #     def read: (cache_key, **top) -> V?
+    #     def read_multi: (Array[cache_key], **top) -> Hash[cache_key, V]
+    #     def write: (cache_key, V, **top) -> V
+    #     def write_multi: (Hash[cache_key, V], **top) -> Hash[cache_key, V]
+    #     def delete: (cache_key, **top) -> V?
+    #     def key?: (cache_key) -> bool
+    #     def clear: () -> void
+    #     def fetch: (cache_key, **top) { () -> V? } -> V?
+    #     def fetch_multi: (Array[cache_key], **top) { (cache_key) -> V? } -> Hash[cache_key, V]
+    #   end
+
+    # @rbs! include _Backend[V]
+
+    # @rbs override
+    # @rbs (cache_key, **top) -> V?
+    def read(key, **opts)
+      raise NotImplementedError, "#{self.class} must implement #read"
+    end
+
+    # @rbs override
+    # @rbs (Array[cache_key], **top) -> Hash[cache_key, V]
+    def read_multi(keys, **opts)
+      keys.to_h { |key| [key, read(key, **opts)] }
+    end
+
+    # @rbs override
+    # @rbs (cache_key, V, **top) -> V
+    def write(key, value, **opts)
+      raise NotImplementedError, "#{self.class} must implement #write"
+    end
+
+    # @rbs override
+    # @rbs (Hash[cache_key, V], **top) -> Hash[cache_key, V]
+    def write_multi(values, **opts)
+      values.transform_values { |value| write(value, **opts) }
+    end
+
+    # @rbs override
+    # @rbs (cache_key, **top) -> V?
+    def delete(key, **opts)
+      raise NotImplementedError, "#{self.class} must implement #delete"
+    end
+
+    # @rbs override
+    # @rbs (cache_key) -> bool
+    def key?(key)
+      raise NotImplementedError, "#{self.class} must implement #key?"
+    end
+
+    # @rbs override
+    # @rbs (**top) -> void
+    def clear(**opts)
+      raise NotImplementedError, "#{self.class} must implement #clear"
+    end
+
+    # @rbs override
+    # @rbs (cache_key, **top) { () -> V? } -> V?
+    def fetch(key, **opts, &block)
+      raise NotImplementedError, "#{self.class} must implement #fetch"
+    end
+
+    # @rbs override
+    # @rbs (Array[cache_key], **top) { (cache_key) -> V? } -> Hash[cache_key, V]
+    def fetch_multi(keys, **opts, &block)
+      keys.to_h { |key| [key, fetch(key, **opts, &block)] }
+    end
   end
+
+  # @rbs! type backend[V] = Backend::_Backend[V]
 end

data/lib/typed_cache/backends/active_support.rb

@@ -7,152 +7,78 @@ module TypedCache
     class ActiveSupport
       include Backend #[V]
 
-      attr_reader :namespace #: Namespace
       attr_reader :cache_store #: ::ActiveSupport::Cache::Store
       attr_reader :default_options #: Hash[Symbol, top]
 
-      #: (Namespace, ::ActiveSupport::Cache::Store, ?Hash[Symbol, top]) -> void
-      def initialize(namespace, cache_store, default_options = {})
-        @namespace = namespace
+      #: (::ActiveSupport::Cache::Store, ?Hash[Symbol, top]) -> void
+      def initialize(cache_store, default_options = {})
         @cache_store = cache_store
         @default_options = default_options
       end
 
       # @rbs override
-      #: (cache_key, **top) -> either[Error, Snapshot[V]]
+      #: (cache_key, **top) -> V?
       def read(key, **kwargs)
-        cache_key_str = namespaced_key(key).to_s
-        raw_value = cache_store.read(cache_key_str, default_options.merge(**kwargs))
-        return Either.left(CacheMissError.new(key)) if raw_value.nil?
-
-        Either.right(Snapshot.cached(key, raw_value))
-      rescue => e
-        Either.left(StoreError.new(:get, key, "Failed to read from cache: #{e.message}", e))
+        cache_store.read(key, default_options.merge(kwargs))
       end
 
       # @rbs override
-      #: (cache_key, V, **top) -> either[Error, Snapshot[V]]
+      #: (cache_key, V, **top) -> V
       def write(key, value, **kwargs)
-        cache_key_str = namespaced_key(key).to_s
-        success = cache_store.write(cache_key_str, value, default_options.merge(**kwargs))
-
-        if success
-          Either.right(Snapshot.cached(key, value))
-        else
-          Either.left(StoreError.new(:set, key, 'Failed to write to cache', nil))
-        end
-      rescue => e
-        Either.left(StoreError.new(:set, key, "Failed to write to cache: #{e.message}", e))
+        cache_store.write(key, value, default_options.merge(kwargs))
       end
 
       # @rbs override
-      #: (Hash[cache_key, V], **top) -> either[Error, Array[Snapshot[V]]]
+      #: (Hash[cache_key, V], **top) -> Array[V]
       def write_all(values, **kwargs)
-        results = cache_store.write_multi(values.map { |key, value| [namespaced_key(key).to_s, value] }.to_h, default_options.merge(**kwargs))
-        Either.right(results.map { |key, value| Snapshot.cached(key, value) })
-      rescue => e
-        Either.left(StoreError.new(:set_all, values, "Failed to write to cache: #{e.message}", e))
+        cache_store.write_multi(values, default_options.merge(kwargs))
       end
 
       # @rbs override
-      #: (cache_key) -> either[Error, Snapshot[V]]
+      #: (cache_key) -> V?
       def delete(key)
-        read(key).fold(
-          ->(error) { Either.left(error) },
-          ->(snapshot) {
-            cache_key_str = namespaced_key(key).to_s
-            cache_store.delete(cache_key_str, default_options)
-            Either.right(snapshot)
-          },
-        )
-      rescue => e
-        Either.left(StoreError.new(:delete, key, "Failed to delete from cache: #{e.message}", e))
+        cache_store.delete(key, default_options)
       end
 
       # @rbs override
-      #: (Array[cache_key], **top) -> either[Error, Array[Snapshot[V]]]
+      #: (Array[cache_key], **top) -> Hash[cache_key, V]
       def read_all(keys, **kwargs)
-        results = cache_store.read_multi(*keys.map { |key| namespaced_key(key).to_s }, default_options.merge(**kwargs))
-        Either.right(results.map { |key, value| [key, Snapshot.cached(key, value)] }.to_h)
+        cache_store.read_multi(*keys, default_options.merge(kwargs))
       end
 
       # @rbs override
-      #: (Array[cache_key], **top) { (CacheKey) -> V? } -> either[Error, Array[Snapshot[V]]]
-      def fetch_all(keys, **kwargs, &block)
-        cache_keys = keys.map { |key| namespaced_key(key) }
-        key_map = cache_keys.index_by(&:to_s)
-
-        computed_keys = Set.new #: Set[String]
-        results = cache_store.fetch_multi(*key_map.keys, default_options.merge(**kwargs)) do |key|
-          computed_keys << key
-          yield(key_map[key])
-        end
-
-        snapshots = [] #: Array[Snapshot[V]]
-
-        results.each do |key, value|
-          maybe_value = Maybe.wrap(value)
-          snapshots <<
-            if computed_keys.include?(key)
-              Snapshot.computed(key, maybe_value)
-            else
-              Snapshot.cached(key, maybe_value)
-            end
-        end
+      #: (cache_key, **top) { () -> V? } -> V?
+      def fetch(key, **kwargs, &block)
+        cache_store.fetch(key, default_options.merge(kwargs), &block)
+      end
 
-        Either.right(snapshots)
-      rescue StandardError => e
-        Either.left(StoreError.new(:fetch_all, keys, "Failed to fetch from cache: #{e.message}", e))
+      # @rbs override
+      #: (Array[cache_key], **top) { (CacheKey) -> V? } -> Hash[cache_key, V]
+      def fetch_all(keys, **kwargs, &block)
+        cache_store.fetch_multi(*keys, default_options.merge(kwargs), &block)
       end
 
       # @rbs override
       #: (cache_key) -> bool
       def key?(key)
-        cache_store.exist?(namespaced_key(key).to_s, default_options)
-      rescue => _e
-        false
+        cache_store.exist?(key, default_options)
       end
 
       # @rbs override
-      #: -> maybe[Error]
+      #: -> void
       def clear
-        if cache_store.respond_to?(:delete_matched)
-          namespace_prefix_patterns.each do |pattern|
-            cache_store.delete_matched(pattern, default_options)
-          end
-        elsif cache_store.respond_to?(:clear)
-          cache_store.clear(default_options)
-        end
-        Maybe.none
-      rescue => e
-        Maybe.some(e)
-      end
-
-      # @rbs override
-      #: -> String
-      def store_type
-        'active_support'
+        cache_store.clear(default_options)
       end
 
       #: (Hash[Symbol, top]) -> ActiveSupport[V]
       def with_options(new_options)
-        self.class.new(namespace, cache_store, new_options)
+        self.class.new(cache_store, new_options)
       end
 
       #: -> ::ActiveSupport::Cache::Store
       def raw_cache
         cache_store
       end
-
-      private
-
-      # Regex patterns that match keys for this namespace (with trailing colon)
-      #: -> Array[Regexp]
-      def namespace_prefix_patterns
-        [
-          /\A#{Regexp.escape(namespace.to_s)}:/,
-        ]
-      end
     end
   end
 end

data/lib/typed_cache/backends/memory.rb

@@ -5,18 +5,6 @@ require 'singleton'
 require 'concurrent/map'
 
 module TypedCache
-  class MemoryStoreRegistry
-    include Singleton
-    extend Forwardable
-
-    def_delegators :@backing_store, :[], :[]=, :delete, :key?, :keys
-
-    #: -> void
-    def initialize
-      @backing_store = Concurrent::Map.new
-    end
-  end
-
   module Backends
     # A type-safe memory store implementation with built-in namespacing
     # @rbs generic V
@@ -57,109 +45,70 @@ module TypedCache
       end
       private_constant :Entry
 
-      attr_reader :namespace, :ttl #: Namespace, Integer
-      attr_reader :backing_store #: hash_like[CacheKey, Entry[V]]
+      attr_reader :ttl #: Integer
+      attr_reader :backing_store #: hash_like[String, Entry[V]]
 
-      #: (Namespace, shared: bool, ttl: Integer) -> void
-      def initialize(namespace, shared: false, ttl: 600)
-        @namespace = namespace
+      #: (ttl: Integer) -> void
+      def initialize(ttl: 600)
         @ttl = ttl
-        @backing_store = shared ? MemoryStoreRegistry.instance : {}
+        @backing_store = Concurrent::Map.new
       end
 
       # @rbs override
-      #: (cache_key, **top) -> either[Error, Snapshot[V]]
+      #: (cache_key, **top) -> V?
       def read(key, **kwargs)
-        key = namespaced_key(key)
-        return Either.left(CacheMissError.new(key)) unless backing_store.key?(key)
+        purge_expired_keys
 
         entry = backing_store[key]
-
-        if entry.expired?
-          backing_store.delete(key)
-          return Either.left(CacheMissError.new(key))
-        end
-
-        Either.right(Snapshot.cached(key, entry.value))
+        entry&.value
       end
 
       # @rbs override
-      #: (cache_key, V, expires_in: Integer, expires_at: Time, **top) -> either[Error, Snapshot[V]]
+      #: (cache_key, V, expires_in: Integer, expires_at: Time, **top) -> V
       def write(key, value, expires_in: @ttl, expires_at: Clock.now + expires_in, **kwargs)
-        key = namespaced_key(key)
         entry = Entry.new(value: value, expires_at: expires_at)
         backing_store[key] = entry
-        Either.right(Snapshot.cached(key, value))
-      rescue => e
-        Either.left(StoreError.new(
-          :set,
-          key,
-          "Failed to store value for key '#{key}': #{e.message}",
-          e,
-        ))
+        value
       end
 
       # @rbs override
-      #: (cache_key) -> either[Error, Snapshot[V]]
+      #: (cache_key) -> V?
       def delete(key)
-        key = namespaced_key(key)
         entry = backing_store.delete(key)
-        if entry.nil?
-          Either.left(CacheMissError.new(key))
-        else
-          Either.right(Snapshot.cached(key, entry.value))
-        end
+        entry&.value
       end
 
       # @rbs override
       #: (cache_key) -> bool
       def key?(key)
-        key = namespaced_key(key)
-        return false unless backing_store.key?(key) && key.belongs_to?(namespace)
+        return false unless backing_store.key?(key)
 
         entry = backing_store[key]
         !entry.expired?
       end
 
       # @rbs override
-      #: -> maybe[Error]
+      #: -> void
       def clear
-        keys_to_delete = backing_store.keys.select { |k| k.belongs_to?(namespace) }
-        keys_to_delete.each { |key| backing_store.delete(key) }
-        Maybe.none
-      rescue => e
-        Maybe.some(e)
+        backing_store.clear
       end
 
       # @rbs override
-      #: -> String
-      def store_type
-        'memory'
-      end
-
-      #: -> Integer
-      def size
+      #: (cache_key, ttl: Integer, **top) { () -> V? } -> V?
+      def fetch(key, ttl: @ttl, **opts, &block)
         purge_expired_keys
-        backing_store.keys.count { |k| k.belongs_to?(namespace) }
-      end
+        result = backing_store.compute_if_absent(key) do
+          Entry.new(value: yield(key), expires_at: Clock.now + ttl)
+        end
 
-      #: -> Array[CacheKey]
-      def keys
-        purge_expired_keys
-        backing_store.keys
-          .select { |k| k.belongs_to?(namespace) }
+        result.value
       end
 
       private
 
-      #: -> Hash[CacheKey, Entry[V]]
-      def namespaced_entries
-        backing_store.select { |key, _entry| key.belongs_to?(namespace) }
-      end
-
       #: -> void
       def purge_expired_keys
-        namespaced_entries.each do |key, entry|
+        backing_store.each do |key, entry|
           backing_store.delete(key) if entry.expired?
         end
       end

data/lib/typed_cache/backends.rb

@@ -11,7 +11,7 @@ module TypedCache
     # Backend registry using composition
     REGISTRY = Registry.new('backend', {
       memory: Memory,
-    }).freeze
+    }).freeze #: Registry[Backend]
 
     class << self
       extend Forwardable
@@ -23,7 +23,7 @@ module TypedCache
 
       # Convenience method delegating to registry
       # @rbs!
-      #   def resolve: (Symbol, *untyped, **untyped) -> either[Error, Store[untyped]]
+      #   def resolve: (Symbol, *untyped, **untyped) -> either[Error, Backend[untyped]]
       #   def available: -> Array[Symbol]
       #   def register: (Symbol, Class) -> either[Error, void]
       #   def registered?: (Symbol) -> bool