typed_cache 0.3.1 → 0.4.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68662a3e64b70950b86c466f7435aa4dc0ba5c31a87637244ece41685aa2cc00
-  data.tar.gz: 07fae7547c15ca5e7bfd900f9f74bb2f40443102bca143ce0f8cee8dc79c4069
+  metadata.gz: 6ec41a8981323affe19dcf95567cd004f58c744e6bada1e4b629678eda393f7d
+  data.tar.gz: 35cc676a0564191003dec33b91c53e98fea1e1f90bdc89269fbbfa35c395b2eb
 SHA512:
-  metadata.gz: f81441fdceb975a4251d9f9d816cf71a40847e8ad1f9a3adea0d92075617ef0c9c85ed980b7707b9327221a75dc385459b954bd492e82ff08416fdb835fd6ba6
-  data.tar.gz: ef41b5392bb1f6adb0b2ccbf7f73ea6363c562b3e0621990f94c52445c048c598b9a0c875ad1d4ffaa03907576f68673614098281620d220ba96d6812b70531a
+  metadata.gz: 51a2c6dd90dcf5757d8058021cae3eb1d3002c0441673f008ed1c0a1302b8b3b32ad21981cf21c909ee0bf2f6a67f59827397bb0169d0f33e9fd536d9a468cac
+  data.tar.gz: 5f9a98912d940cbc4fb357f65d273ad030b7f97200a374b31b7b246c66ac85a733cd4b9332b545ea03fe7f25053271dcc19a4919e9312c2e0f85ea348a7eefce

data/lib/typed_cache/backend.rb

@@ -10,7 +10,85 @@ 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) -> 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) -> V?
+    def delete(key, **opts)
+      raise NotImplementedError, "#{self.class} must implement #delete"
+    end
+
+    # @rbs override
+    # @rbs (cache_key) -> bool
+    def key?(key, **opts)
+      raise NotImplementedError, "#{self.class} must implement #key?"
+    end
+
+    # @rbs override
+    # @rbs () -> 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
+
+    # @rbs override
+    # @rbs () -> String
+    def to_s = self.class.name
+
+    # @rbs override
+    # @rbs () -> String
+    def inspect = self.class.inspect
   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