Remove roles entirely, assume just writers

lib/solid_cache.rb

@@ -16,8 +16,4 @@ def self.all_shards_config
   def self.shard_config(shard)
     all_shards_config && all_shards_config[shard]
   end
-
-  def self.shard_first_role(shard)
-    shard_config(shard)&.first&.first
-  end
 end

lib/solid_cache/async_execution.rb

@@ -11,7 +11,7 @@ def async(&block)
         current_shard = Entry.current_shard
         @executor << ->() do
           wrap_in_rails_executor do
-            with_role_and_shard(role: ActiveRecord.writing_role, shard: current_shard) do
+            with_shard(current_shard) do
               block.call(current_shard)
             end
           end

lib/solid_cache/connection_handling.rb

@@ -11,7 +11,7 @@ def writing_all_shards
       return enum_for(:writing_all_shards) unless block_given?
 
       shards.each do |shard|
-        with_role_and_shard(role: ActiveRecord.writing_role, shard: shard) { yield }
+        with_shard(shard) { yield }
       end
     end
 
@@ -21,33 +21,28 @@ def shards
 
     private
       def writing_across_shards(list:)
-        across_shards(role: ActiveRecord.writing_role, list:) { |list| yield list }
+        across_shards(list:) { |list| yield list }
       end
 
       def reading_across_shards(list:)
-        across_shards(role: ActiveRecord.reading_role, list:) { |list| yield list }
+        across_shards(list:) { |list| yield list }
       end
 
-      def writing_shard(normalized_key:)
-        with_role_and_shard(role: ActiveRecord.writing_role, shard: shard_for_normalized_key(normalized_key)) { yield }
+      def with_shard_for_key(normalized_key:)
+        with_shard(shard_for_normalized_key(normalized_key)) { yield }
       end
 
-      def reading_shard(normalized_key:)
-        with_role_and_shard(role: ActiveRecord.reading_role, shard: shard_for_normalized_key(normalized_key)) { yield }
-      end
-
-      def with_role_and_shard(role:, shard:)
-        if role || shard
-          role ||= SolidCache.shard_first_role(shard)
-          Record.connected_to(role: role, shard: shard) { yield }
+      def with_shard(shard)
+        if shard
+          Record.connected_to(shard: shard) { yield }
         else
           yield
         end
       end
 
-      def across_shards(role:, list:)
+      def across_shards(list:)
         in_shards(list).map do |shard, list|
-          with_role_and_shard(role: role, shard: shard) { yield list }
+          with_shard(shard) { yield list }
         end
       end
 

lib/solid_cache/store.rb

@@ -53,7 +53,7 @@ def delete_matched(matcher, options = {})
     def increment(name, amount = 1, options = nil)
       options = merged_options(options)
       key = normalize_key(name, options)
-      writing_shard(normalized_key: key) do
+      with_shard_for_key(normalized_key: key) do
         failsafe :increment do
           Entry.increment(key, amount)
         end
@@ -63,7 +63,7 @@ def increment(name, amount = 1, options = nil)
     def decrement(name, amount = 1, options = nil)
       options = merged_options(options)
       key = normalize_key(name, options)
-      writing_shard(normalized_key: key) do
+      with_shard_for_key(normalized_key: key) do
         failsafe :increment do
           Entry.increment(key, -amount)
         end
@@ -88,7 +88,7 @@ def read_entry(key, **options)
       end
 
       def read_serialized_entry(key, raw: false, **options)
-        reading_shard(normalized_key: key) do
+        with_shard_for_key(normalized_key: key) do
           failsafe(:read_entry) do
             Entry.get(key)
           end
@@ -100,7 +100,7 @@ def write_entry(key, entry, raw: false, **options)
         payload = serialize_entry(entry, raw: raw, **options)
         write_serialized_entry(key, payload, raw: raw, **options)
 
-        writing_shard(normalized_key: key) do
+        with_shard_for_key(normalized_key: key) do
           failsafe(:write_entry, returning: false) do
             Entry.set(key, payload)
             trim(1)
@@ -162,7 +162,7 @@ def write_multi_entries(entries, expires_in: nil, **options)
       end
 
       def delete_entry(key, **options)
-        writing_shard(normalized_key: key) do
+        with_shard_for_key(normalized_key: key) do
           failsafe(:delete_entry, returning: false) do
             Entry.delete_by_key(key)
           end