activematrix 0.0.0 → 0.0.2

data/lib/{matrix_sdk → active_matrix}/room.rb

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-require 'matrix_sdk'
-require 'matrix_sdk/util/events'
-require 'matrix_sdk/util/tinycache'
-
-module MatrixSdk
+module ActiveMatrix
   # A class for tracking the information about a room on Matrix
   class Room
-    extend MatrixSdk::Extensions
-    extend MatrixSdk::Util::Tinycache
-    include MatrixSdk::Logging
+    extend ActiveMatrix::Extensions
+    include ActiveMatrix::Logging
+    include ActiveMatrix::Util::Cacheable
 
     # @!attribute [rw] event_history_limit
     #   @return [Fixnum] the limit of events to keep in the event log
@@ -28,17 +24,9 @@ module MatrixSdk
     #   An inspect method that skips a handful of instance variables to avoid
     #   flooding the terminal with debug data.
     #   @return [String] a regular inspect string without the data for some variables
-    ignore_inspect :client, :events, :prev_batch, :logger, :tinycache_adapter
-
-    # Requires heavy lookups, so they're cached for an hour
-    cached :joined_members, cache_level: :all, expires_in: 60 * 60
-
-    # Only cache unfiltered requests for aliases and members
-    cached :aliases, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 60 * 60
-    cached :all_members, unless: proc { |args| args.any? }, cache_level: :all, expires_in: 60 * 60
+    ignore_inspect :client, :events, :prev_batch, :logger
 
     alias room_id id
-    alias members joined_members
 
     # Create a new room instance
     #
@@ -78,23 +66,22 @@ module MatrixSdk
       @events = []
       @event_history_limit = 10
       @room_type = nil
+      @pre_populated_members = nil # For pre-populated members from tests
+      @cached_joined_members = nil # Instance cache for joined members
+      @cached_all_members = nil    # Instance cache for all members
 
       @prev_batch = nil
 
       %i[name topic canonical_alias avatar_url].each do |type|
-        room_state.tinycache_adapter.write("m.room.#{type}", { type => data.delete(type) }) if data.key? type
+        room_state.write("m.room.#{type}", { type => data.delete(type) }) if data.key? type
       end
-      room_state.tinycache_adapter.write('m.room.join_rules', { join_rule: data.delete(:join_rule) }) if data.key? :join_rule
-      room_state.tinycache_adapter.write('m.room.history_visibility', { history_visibility: data.delete(:world_readable) ? :world_readable : nil }) if data.key? :world_readable
+      room_state.write('m.room.join_rules', { join_rule: data.delete(:join_rule) }) if data.key? :join_rule
+      room_state.write('m.room.history_visibility', { history_visibility: data.delete(:world_readable) ? :world_readable : nil }) if data.key? :world_readable
 
       data.each do |k, v|
         next if %i[client].include? k
 
-        if respond_to?("#{k}_cached?".to_sym) && send("#{k}_cached?".to_sym)
-          tinycache_adapter.write(k, v)
-        elsif instance_variable_defined? "@#{k}"
-          instance_variable_set("@#{k}", v)
-        end
+        instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
       end
 
       @id = room_id.to_s
@@ -178,7 +165,7 @@ module MatrixSdk
     # @return [String, nil] the canonical alias of the room
     def canonical_alias
       get_state('m.room.canonical_alias')[:alias]
-    rescue MatrixSdk::MatrixNotFoundError
+    rescue ActiveMatrix::MatrixNotFoundError
       nil
     end
 
@@ -186,6 +173,36 @@ module MatrixSdk
     #
     # @return [Array(User)] The list of members in the room
     def joined_members
+      # Return pre-populated members if they exist (for testing)
+      return @pre_populated_members if @pre_populated_members
+
+      # Return cached instance if available
+      return @cached_joined_members if @cached_joined_members
+
+      return fetch_joined_members unless cache_available?
+
+      # Cache the raw data that can be used to reconstruct User objects
+      members_data = cache.fetch(cache_key(:joined_members), expires_in: 1.hour) do
+        # Convert API response to cacheable format
+        api_response = client.api.get_room_joined_members(id)[:joined]
+        api_response.map do |mxid, data|
+          {
+            mxid: mxid.to_s,
+            display_name: data[:display_name],
+            avatar_url: data[:avatar_url]
+          }
+        end
+      end
+
+      # Reconstruct User objects from cached data and cache at instance level
+      @cached_joined_members = members_data.map do |member|
+        User.new(client, member[:mxid],
+                 display_name: member[:display_name],
+                 avatar_url: member[:avatar_url])
+      end
+    end
+
+    def fetch_joined_members
       client.api.get_room_joined_members(id)[:joined].map do |mxid, data|
         User.new(client, mxid.to_s,
                  display_name: data.fetch(:display_name, nil),
@@ -193,6 +210,8 @@ module MatrixSdk
       end
     end
 
+    alias members joined_members
+
     # Get all members (member events) in the room
     #
     # @note This will also count members who've knocked, been invited, have left, or have been banned.
@@ -201,6 +220,24 @@ module MatrixSdk
     #
     # @return [Array(User)] The complete list of members in the room, regardless of membership state
     def all_members(**params)
+      # Return pre-populated members if they exist and no filtering params (for testing)
+      return @pre_populated_members if @pre_populated_members && params.empty?
+
+      # Return cached instance if available and no params
+      return @cached_all_members if @cached_all_members && params.empty?
+
+      return fetch_all_members(**params) if !params.empty? || client.cache == :none || !cache_available?
+
+      # Cache the raw member state keys, not User objects
+      members_data = cache.fetch(cache_key(:all_members), expires_in: 1.hour) do
+        client.api.get_room_members(id, **params)[:chunk].map { |ch| ch[:state_key] }
+      end
+
+      # Reconstruct User objects from cached data and cache at instance level
+      @cached_all_members = members_data.map { |state_key| client.get_user(state_key) }
+    end
+
+    def fetch_all_members(**params)
       client.api.get_room_members(id, **params)[:chunk].map { |ch| client.get_user(ch[:state_key]) }
     end
 
@@ -210,7 +247,8 @@ module MatrixSdk
     #
     # @return [String,nil] The room name - if any
     def name
-      get_state('m.room.name')[:name]
+      state = get_state('m.room.name')
+      state&.dig(:name)
     rescue MatrixNotFoundError
       # No room name has been specified
       nil
@@ -292,9 +330,9 @@ module MatrixSdk
     end
 
     def room_state
-      return MatrixSdk::Util::StateEventCache.new self if client.cache == :none
+      return ActiveMatrix::Util::StateEventCache.new self if client.cache == :none
 
-      @room_state ||= MatrixSdk::Util::StateEventCache.new self
+      @room_state ||= ActiveMatrix::Util::StateEventCache.new self
     end
 
     # Gets a state object in the room
@@ -327,8 +365,20 @@ module MatrixSdk
     # @param canonical_only [Boolean] Should the list of aliases only contain the canonical ones
     # @return [Array[String]] The assigned room aliases
     def aliases(canonical_only: true)
+      return fetch_aliases(canonical_only: canonical_only) if !canonical_only || client.cache == :none || !cache_available?
+
+      cache.fetch(cache_key(:aliases), expires_in: 1.hour) do
+        fetch_aliases(canonical_only: true)
+      end
+    end
+
+    def fetch_aliases(canonical_only: true)
       canonical = get_state('m.room.canonical_alias') rescue {}
-      aliases = ([canonical[:alias]].compact + (canonical[:alt_aliases] || [])).uniq.sort
+      # Handle both hash-like and Response objects
+      alias_value = canonical.respond_to?(:alias) ? canonical.alias : canonical[:alias]
+      alt_aliases = canonical.respond_to?(:alt_aliases) ? canonical.alt_aliases : canonical[:alt_aliases]
+
+      aliases = ([alias_value].compact + (alt_aliases || [])).uniq.sort
       return aliases if canonical_only
 
       (aliases + client.api.get_room_aliases(id).aliases).uniq.sort
@@ -525,7 +575,7 @@ module MatrixSdk
     # @param user_id [String,User] the MXID of the user
     # @return [Boolean] wether the action succeeded
     def invite_user(user_id)
-      user_id = user_id.id if user_id.is_a? MatrixSdk::User
+      user_id = user_id.id if user_id.is_a? ActiveMatrix::User
       client.api.invite_user(id, user_id)
       true
     end
@@ -536,7 +586,7 @@ module MatrixSdk
     # @param reason [String] the reason for the kick
     # @return [Boolean] wether the action succeeded
     def kick_user(user_id, reason = '')
-      user_id = user_id.id if user_id.is_a? MatrixSdk::User
+      user_id = user_id.id if user_id.is_a? ActiveMatrix::User
       client.api.kick_user(id, user_id, reason: reason)
       true
     end
@@ -547,7 +597,7 @@ module MatrixSdk
     # @param reason [String] the reason for the ban
     # @return [Boolean] wether the action succeeded
     def ban_user(user_id, reason = '')
-      user_id = user_id.id if user_id.is_a? MatrixSdk::User
+      user_id = user_id.id if user_id.is_a? ActiveMatrix::User
       client.api.ban_user(id, user_id, reason: reason)
       true
     end
@@ -557,7 +607,7 @@ module MatrixSdk
     # @param user_id [String,User] the MXID of the user
     # @return [Boolean] wether the action succeeded
     def unban_user(user_id)
-      user_id = user_id.id if user_id.is_a? MatrixSdk::User
+      user_id = user_id.id if user_id.is_a? ActiveMatrix::User
       client.api.unban_user(id, user_id)
       true
     end
@@ -572,9 +622,9 @@ module MatrixSdk
     end
 
     def account_data
-      return MatrixSdk::Util::AccountDataCache.new client, room: self if client.cache == :none
+      return ActiveMatrix::Util::AccountDataCache.new client, room: self if client.cache == :none
 
-      @account_data ||= MatrixSdk::Util::AccountDataCache.new client, room: self
+      @account_data ||= ActiveMatrix::Util::AccountDataCache.new client, room: self
     end
 
     # Retrieves a custom entry from the room-specific account data
@@ -640,7 +690,7 @@ module MatrixSdk
     # @return [Boolean,nil] True if the room is a space
     def space?
       room_type == 'm.space'
-    rescue MatrixSdk::MatrixForbiddenError, MatrixSdk::MatrixNotFoundError
+    rescue ActiveMatrix::MatrixForbiddenError, ActiveMatrix::MatrixNotFoundError
       nil
     end
 
@@ -739,7 +789,8 @@ module MatrixSdk
     # @return [Boolean] if the addition was successful or not
     def add_alias(room_alias)
       client.api.set_room_alias(id, room_alias)
-      tinycache_adapter.read(:aliases) << room_alias if tinycache_adapter.exist?(:aliases)
+      # Clear the cache to force refresh
+      cache.delete(cache_key(:aliases)) if cache_available?
       true
     end
 
@@ -750,7 +801,7 @@ module MatrixSdk
     #       alias list updates.
     def reload_aliases!
       room_state.expire('m.room.canonical_alias')
-      clear_aliases_cache
+      cache.delete(cache_key(:aliases)) if cache_available?
     end
     alias refresh_aliases! reload_aliases!
 
@@ -900,7 +951,7 @@ module MatrixSdk
     def modify_user_power_levels(users = nil, users_default = nil)
       return false if users.nil? && users_default.nil?
 
-      room_state.tinycache_adapter.expire 'm.room.power_levels'
+      room_state.expire 'm.room.power_levels'
 
       data = power_levels
       data[:users_default] = users_default unless users_default.nil?
@@ -932,7 +983,7 @@ module MatrixSdk
     def modify_required_power_levels(events = nil, params = {})
       return false if events.nil? && (params.nil? || params.empty?)
 
-      room_state.tinycache_adapter.expire 'm.room.power_levels'
+      room_state.expire 'm.room.power_levels'
 
       data = power_levels
       data.merge!(params)
@@ -950,38 +1001,52 @@ module MatrixSdk
 
     private
 
+    def cache_key(method_name)
+      "activematrix:room:#{id}:#{method_name}"
+    end
+
+    def cache_available?
+      defined?(::Rails) && ::Rails.respond_to?(:cache) && ::Rails.cache
+    end
+
+    def cache
+      ::Rails.cache
+    end
+
     def ensure_member(member)
       return unless client.cache == :all
 
-      tinycache_adapter.write(:joined_members, []) unless tinycache_adapter.exist? :joined_members
-
-      members = tinycache_adapter.read(:joined_members) || []
-      members << member unless members.any? { |m| m.id == member.id }
+      # Add member to pre-populated list
+      @pre_populated_members ||= []
+      @pre_populated_members << member unless @pre_populated_members.include?(member)
 
-      tinycache_adapter.write(:joined_members, members)
+      # Clear the cache to force a refresh on next access
+      cache.delete(cache_key(:joined_members)) if cache_available?
     end
 
     def handle_room_member(event)
       return unless client.cache == :all
 
-      if event.dig(*%i[content membership]) == 'join'
-        ensure_member(client.get_user(event[:state_key]).dup.tap do |u|
-          u.instance_variable_set(:@display_name, event.dig(*%i[content displayname]))
-        end)
-      elsif tinycache_adapter.exist? :joined_members
-        members = tinycache_adapter.read(:joined_members)
-        members.delete_if { |m| m.id == event[:state_key] }
-      end
+      # Cache the user if it's a join event
+      client.get_user(event[:state_key]) if event.dig(:content, :membership) == 'join' && event[:state_key]
+
+      # Clear pre-populated members when membership changes
+      @pre_populated_members = nil
+
+      # Clear instance caches when membership changes
+      @cached_joined_members = nil
+      @cached_all_members = nil
+
+      # Clear the cache when membership changes
+      cache.delete(cache_key(:joined_members)) if cache_available?
+      cache.delete(cache_key(:all_members)) if cache_available?
     end
 
     def handle_room_canonical_alias(event)
-      room_state.tinycache_adapter.write('m.room.canonical_alias', event[:content], expires_in: room_state.cache_time)
-      canonical_alias = event.dig(*%i[content alias])
+      room_state.write('m.room.canonical_alias', event[:content])
 
-      data = tinycache_adapter.read(:aliases) || []
-      data << canonical_alias
-      data += event.dig(*%i[content alt_aliases]) || []
-      tinycache_adapter.write(:aliases, data.uniq.sort)
+      # Clear the aliases cache
+      cache.delete(cache_key(:aliases)) if cache_available?
     end
 
     def room_handlers?
@@ -990,10 +1055,10 @@ module MatrixSdk
 
     def ensure_room_handlers
       client.instance_variable_get(:@room_handlers)[id] ||= {
-        account_data: MatrixSdk::EventHandlerArray.new,
-        event: MatrixSdk::EventHandlerArray.new,
-        state_event: MatrixSdk::EventHandlerArray.new,
-        ephemeral_event: MatrixSdk::EventHandlerArray.new
+        account_data: ActiveMatrix::EventHandlerArray.new,
+        event: ActiveMatrix::EventHandlerArray.new,
+        state_event: ActiveMatrix::EventHandlerArray.new,
+        ephemeral_event: ActiveMatrix::EventHandlerArray.new
       }
     end
 
@@ -1005,10 +1070,8 @@ module MatrixSdk
     end
 
     def put_account_data(event)
-      if client.cache != :none
-        adapter = account_data.tinycache_adapter
-        adapter.write(event[:type], event[:content], expires_in: account_data.cache_time)
-      end
+      # Store the account data in cache
+      account_data.write(event[:type], event[:content]) if event[:type]
 
       return unless room_handlers?
 
@@ -1030,15 +1093,28 @@ module MatrixSdk
       if INTERNAL_HANDLERS.key? event[:type]
         send(INTERNAL_HANDLERS[event[:type]], event)
       elsif client.cache != :none
-        adapter = room_state.tinycache_adapter
-        key = event[:type]
-        key += "|#{event[:state_key]}" unless event[:state_key].nil? || event[:state_key].empty?
-        adapter.write(key, event[:content], expires_in: room_state.cache_time)
+        # StateEventCache will handle caching internally
+        room_state.write(event[:type], event[:content], event[:state_key])
       end
 
       return unless room_handlers?
 
       ensure_room_handlers[:state_event].fire(MatrixEvent.new(self, event), event[:type])
     end
+
+    # Define what attributes to cache
+    def cache_attributes
+      {
+        id: @id,
+        room_type: @room_type,
+        prev_batch: @prev_batch,
+        event_history_limit: @event_history_limit
+      }
+    end
+
+    # Override cache_id to use room ID
+    def cache_id
+      @id
+    end
   end
 end

data/lib/{matrix_sdk → active_matrix}/rooms/space.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module MatrixSdk::Rooms
-  class Space < MatrixSdk::Room
+module ActiveMatrix::Rooms
+  class Space < ActiveMatrix::Room
     TYPE = 'm.space'
 
     def tree(suggested_only: nil, max_rooms: nil)
@@ -26,11 +26,7 @@ module MatrixSdk::Rooms
 
         # Inject available room information
         r.each do |k, v|
-          if room.respond_to?("#{k}_cached?".to_sym) && send("#{k}_cached?".to_sym)
-            room.send(:tinycache_adapter).write(k, v)
-          elsif room.instance_variable_defined? "@#{k}"
-            room.instance_variable_set("@#{k}", v)
-          end
+          room.instance_variable_set("@#{k}", v) if room.instance_variable_defined? "@#{k}"
         end
         room
       end

data/lib/{matrix_sdk → active_matrix}/user.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
-require 'matrix_sdk'
-
-module MatrixSdk
+module ActiveMatrix
   # A class for tracking information about a user on Matrix
   class User
-    extend MatrixSdk::Extensions
+    extend ActiveMatrix::Extensions
+    include ActiveMatrix::Util::Cacheable
 
     attr_reader :id, :client
     alias user_id :id
@@ -35,13 +34,13 @@ module MatrixSdk
     end
 
     # @return [String] the display name
-    # @see MatrixSdk::Protocols::CS#get_display_name
+    # @see ActiveMatrix::Protocols::CS#get_display_name
     def display_name
       @display_name ||= client.api.get_display_name(id)[:displayname]
     end
 
     # @param name [String] the display name to set
-    # @see MatrixSdk::Protocols::CS#set_display_name
+    # @see ActiveMatrix::Protocols::CS#set_display_name
     def display_name=(name)
       client.api.set_display_name(id, name)
       @display_name = name
@@ -55,7 +54,7 @@ module MatrixSdk
 
     # Gets the avatar for the user
     #
-    # @see MatrixSdk::Protocols::CS#get_avatar_url
+    # @see ActiveMatrix::Protocols::CS#get_avatar_url
     def avatar_url
       @avatar_url ||= client.api.get_avatar_url(id)[:avatar_url]
     end
@@ -67,8 +66,8 @@ module MatrixSdk
     #
     # @param url [String,URI::MXC] the new avatar URL
     # @note Requires a mxc:// URL, check example on
-    #   {MatrixSdk::Protocols::CS#set_avatar_url} for how this can be done
-    # @see MatrixSdk::Protocols::CS#set_avatar_url
+    #   {ActiveMatrix::Protocols::CS#set_avatar_url} for how this can be done
+    # @see ActiveMatrix::Protocols::CS#set_avatar_url
     def avatar_url=(url)
       client.api.set_avatar_url(id, url)
       @avatar_url = url
@@ -93,7 +92,7 @@ module MatrixSdk
     # Get the user's current presence status
     #
     # @return [Symbol] One of :online, :offline, :unavailable
-    # @see MatrixSdk::Protocols::CS#get_presence_status
+    # @see ActiveMatrix::Protocols::CS#get_presence_status
     # @note This information is not cached in the abstraction layer
     def presence
       raw_presence[:presence]&.to_sym
@@ -103,7 +102,7 @@ module MatrixSdk
     # Should be one of :online, :offline, or :unavailable
     #
     # @param new_presence [:online,:offline,:unavailable] The new presence status to set
-    # @see MatrixSdk::Protocols::CS#set_presence_status
+    # @see ActiveMatrix::Protocols::CS#set_presence_status
     def presence=(new_presence)
       raise ArgumentError, 'Presence must be one of :online, :offline, :unavailable' unless %i[online offline unavailable].include?(presence)
 
@@ -118,7 +117,7 @@ module MatrixSdk
 
     # Gets the user-specified status message - if any
     #
-    # @see MatrixSdk::Protocols::CS#get_presence_status
+    # @see ActiveMatrix::Protocols::CS#get_presence_status
     # @note This information is not cached in the abstraction layer
     def status_msg
       raw_presence[:status_msg]
@@ -127,7 +126,7 @@ module MatrixSdk
     # Sets the user-specified status message
     #
     # @param message [String,nil] The message to set, or nil for no message
-    # @see MatrixSdk::Protocols::CS#set_presence_status
+    # @see ActiveMatrix::Protocols::CS#set_presence_status
     def status_msg=(message)
       client.api.set_presence_status(id, presence, message: message)
     end
@@ -135,7 +134,7 @@ module MatrixSdk
     # Gets the last time the user was active at, from the server's side
     #
     # @return [Time] when the user was last active
-    # @see MatrixSdk::Protocols::CS#get_presence_status
+    # @see ActiveMatrix::Protocols::CS#get_presence_status
     # @note This information is not cached in the abstraction layer
     def last_active
       since = raw_presence[:last_active_ago]
@@ -147,7 +146,7 @@ module MatrixSdk
     # Gets a direct message room with the user if one exists
     #
     # @return [Room,nil] A direct message room if one exists
-    # @see MatrixSdk::Client#direct_room
+    # @see ActiveMatrix::Client#direct_room
     def direct_room
       client.direct_room(id)
     end
@@ -159,6 +158,15 @@ module MatrixSdk
       end
     end
 
+    # Define what attributes to cache
+    def cache_attributes
+      {
+        id: @id,
+        display_name: @display_name,
+        avatar_url: @avatar_url
+      }
+    end
+
     private
 
     def raw_presence

data/lib/active_matrix/util/account_data_cache.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module ActiveMatrix::Util
+  class AccountDataCache
+    extend ActiveMatrix::Extensions
+    include Enumerable
+
+    attr_reader :client, :room
+
+    attr_accessor :cache_time
+
+    ignore_inspect :client, :room
+
+    def initialize(client, room: nil, cache_time: 1 * 60 * 60, **_params)
+      raise ArgumentError, 'Must be given a Client instance' unless client.is_a? ActiveMatrix::Client
+
+      @client = client
+      @cache_time = cache_time
+      @tracked_keys = Set.new
+
+      return unless room
+
+      @room = room
+      @room = client.ensure_room room unless @room.is_a? ActiveMatrix::Room
+    end
+
+    def reload!
+      # Clear all cache entries for this account data
+      return unless cache_available?
+
+      if room
+        cache.delete_matched("activematrix:account_data:#{client.mxid}:room:#{room.id}:*")
+      else
+        cache.delete_matched("activematrix:account_data:#{client.mxid}:global:*")
+      end
+    end
+
+    def keys
+      @tracked_keys.to_a.sort
+    end
+
+    def values
+      []
+    end
+
+    def size
+      keys.count
+    end
+
+    def key?(key)
+      cache_available? && cache.exist?(cache_key(key))
+    end
+
+    def each(live: false)
+      to_enum(__method__, live: live) { 0 } unless block_given?
+      # Not enumerable with Rails.cache
+    end
+
+    def delete(key)
+      key = key.to_s unless key.is_a? String
+      if room
+        client.api.set_room_account_data(client.mxid, room.id, key, {})
+      else
+        client.api.set_account_data(client.mxid, key, {})
+      end
+      cache.delete(cache_key(key)) if cache_available?
+    end
+
+    def [](key)
+      key = key.to_s unless key.is_a? String
+
+      # Track the key whenever it's accessed
+      @tracked_keys.add(key)
+
+      return fetch_account_data(key) unless cache_available?
+
+      cache.fetch(cache_key(key), expires_in: @cache_time) do
+        fetch_account_data(key)
+      end
+    end
+
+    def fetch_account_data(key)
+      if room
+        client.api.get_room_account_data(client.mxid, room.id, key)
+      else
+        client.api.get_account_data(client.mxid, key)
+      end
+    rescue ActiveMatrix::MatrixNotFoundError
+      {}
+    end
+
+    def []=(key, value)
+      key = key.to_s unless key.is_a? String
+      if room
+        client.api.set_room_account_data(client.mxid, room.id, key, value)
+      else
+        client.api.set_account_data(client.mxid, key, value)
+      end
+
+      @tracked_keys.add(key)
+      cache.write(cache_key(key), value, expires_in: @cache_time) if cache_available?
+    end
+
+    # Write data without making API call (for sync responses)
+    def write(key, value)
+      key = key.to_s unless key.is_a? String
+      @tracked_keys.add(key)
+      cache.write(cache_key(key), value, expires_in: @cache_time) if cache_available?
+    end
+
+    private
+
+    def cache_key(key)
+      if room
+        "activematrix:account_data:#{client.mxid}:room:#{room.id}:#{key}"
+      else
+        "activematrix:account_data:#{client.mxid}:global:#{key}"
+      end
+    end
+
+    def cache_available?
+      defined?(::Rails) && ::Rails.respond_to?(:cache) && ::Rails.cache
+    end
+
+    def cache
+      ::Rails.cache
+    end
+  end
+end