matrix_sdk 2.1.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5af1e7af0f473a5c44df1ede83655cdbdb120e215e42f125b6af576740b88aa6
-  data.tar.gz: cca80fe97ca22f0ddb0c5a2b39b24b70345baa25fb20bea305fa019f46ca7d3a
+  metadata.gz: b8fabc9c9f840753916f52925807e2b6282a9fd17fbeedd63f284bd60a1aab86
+  data.tar.gz: d0c2330e13f85036bbc0cecf1cde73fc2b960906c497b0cb7fdfe89b49499fd8
 SHA512:
-  metadata.gz: 0e4c694d8489dae1b2602d01f4aab08b20119c6697e83b41a2a463adb7ebcaf7b1afd439db04a6e54a0979c5a93be865c8afa3d2d03b4ca34b98f82afae87a5f
-  data.tar.gz: 8f52c12d1eb8af55ac5bc011852c9d5f648e9de1cc3241ea1ed76530036b02cff373cb69b8a4c721956add3df1359377d79b2fa2562e8dab8efe5ce877596e2d
+  metadata.gz: 709c402251e87cd3cb650a7081d121eda551fec86f46dde8c92f2799491810ddb16bd8e44280ced09c0a5daa343385958d8ab19640348cffc2f97eafcb14bcaf
+  data.tar.gz: 979fc101ef76e21023b9a6ce41649c0d144a2376429ff3ff6572b0384298d598a30f05ac64e0b2e98013180e7e4b0356a26da214df28ada4c5808e8ae02af331

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## 2.4.0 - 2021-07-19
+
+- Adds support for matrix: URI's according to MSC2312
+- Adds some basic support for detecting Spaces (MSC1772)
+- Fixes sync against Synapse 1.38.0 missing empty fields
+
+## 2.3.0 - 2021-03-26
+
+- Adds support for Ruby 3.0 (#15)
+- Adds support for requests against the Synapse admin API
+- Adds helper methods for checking and changing user power levels
+- Adds a proper caching system for room data
+- Fixes argument error in `#get_room_messages`
+- Removes unfinished and broken AS abstraction
+
+## 2.2.0 - 2020-11-20
+
+- Adds direct message (1:1) room mapping to client abstraction
+- Adds Api#get_room_event_context (#13)
+- Improves support for JRuby
+
+## 2.1.3 - 2020-09-18
+
+- Adds separate state event handler as Client#on_state_event
+- Changes Client sync interval to by-default run at full speed
+- Fixes state events being sent twice if included in both timeline and state of a sync
+- Improves error reporting of broken 200 responses
+- Improves event handlers for rooms, to not depend on a specific room object instance anymore
+
 ## 2.1.2 - 2020-09-10
 
 - Adds method for reading complete member lists for rooms, improves the CS spec adherence

data/README.md

@@ -4,7 +4,7 @@ A Ruby gem for easing the development of software that communicates with servers
 
 There is a Matrix room for the discussion about usage and development at [#ruby-matrix-sdk:kittenface.studio](https://matrix.to/#/#ruby-matrix-sdk:kittenface.studio).
 
-Live YARD documentation can be found at; http://aleol57.gitlab-pages.liu.se/ruby-matrix-sdk
+Live YARD documentation can be found at; https://ruby-sdk.ananace.dev
 
 ## Example usage
 

data/lib/matrix_sdk.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'matrix_sdk/extensions'
+require 'matrix_sdk/util/extensions'
+require 'matrix_sdk/util/uri'
 require 'matrix_sdk/version'
 
 require 'json'
@@ -22,6 +23,15 @@ module MatrixSdk
   autoload :MatrixTimeoutError, 'matrix_sdk/errors'
   autoload :MatrixUnexpectedResponseError, 'matrix_sdk/errors'
 
+  module Rooms
+    autoload :Space, 'matrix_sdk/rooms/space'
+  end
+
+  module Util
+    autoload :Tinycache, 'matrix_sdk/util/tinycache'
+    autoload :TinycacheAdapter, 'matrix_sdk/util/tinycache_adapter'
+  end
+
   module Protocols
     autoload :AS, 'matrix_sdk/protocols/as'
     autoload :CS, 'matrix_sdk/protocols/cs'

data/lib/matrix_sdk/api.rb

@@ -38,6 +38,7 @@ module MatrixSdk
     # @option params [Numeric] :read_timeout (240) The timeout in seconds for reading responses
     # @option params [Hash] :global_headers Additional headers to set for all requests
     # @option params [Boolean] :skip_login Should the API skip logging in if the HS URL contains user information
+    # @option params [Boolean] :synapse (true) Is the API connecting to a Synapse instance
     # @option params [Hash] :well_known The .well-known object that the server was discovered through, should not be set manually
     def initialize(homeserver, **params)
       @homeserver = homeserver
@@ -61,6 +62,7 @@ module MatrixSdk
       @well_known = params.fetch(:well_known, {})
       @global_headers = DEFAULT_HEADERS.dup
       @global_headers.merge!(params.fetch(:global_headers)) if params.key? :global_headers
+      @synapse = params.fetch(:synapse, true)
       @http = nil
 
       ([params.fetch(:protocols, [:CS])].flatten - protocols).each do |proto|
@@ -101,30 +103,30 @@ module MatrixSdk
       elsif target == :server
         # Attempt SRV record discovery
         target_uri = begin
-                       require 'resolv'
-                       resolver = Resolv::DNS.new
-                       srv = "_matrix._tcp.#{domain}"
-                       logger.debug "Trying DNS #{srv}..."
-                       d = resolver.getresource(srv, Resolv::DNS::Resource::IN::SRV)
-                       d
-                     rescue StandardError => e
-                       logger.debug "DNS lookup failed with #{e.class}: #{e.message}"
-                       nil
-                     end
+          require 'resolv'
+          resolver = Resolv::DNS.new
+          srv = "_matrix._tcp.#{domain}"
+          logger.debug "Trying DNS #{srv}..."
+          d = resolver.getresource(srv, Resolv::DNS::Resource::IN::SRV)
+          d
+        rescue StandardError => e
+          logger.debug "DNS lookup failed with #{e.class}: #{e.message}"
+          nil
+        end
 
         if target_uri.nil?
           # Attempt .well-known discovery for server-to-server
           well_known = begin
-                         wk_uri = URI("https://#{domain}/.well-known/matrix/server")
-                         logger.debug "Trying #{wk_uri}..."
-                         data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
-                           http.get(wk_uri.path).body
-                         end
-                         JSON.parse(data)
-                       rescue StandardError => e
-                         logger.debug "Well-known failed with #{e.class}: #{e.message}"
-                         nil
-                       end
+            wk_uri = URI("https://#{domain}/.well-known/matrix/server")
+            logger.debug "Trying #{wk_uri}..."
+            data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
+              http.get(wk_uri.path).body
+            end
+            JSON.parse(data)
+          rescue StandardError => e
+            logger.debug "Well-known failed with #{e.class}: #{e.message}"
+            nil
+          end
 
           target_uri = well_known['m.server'] if well_known&.key?('m.server')
         else
@@ -133,16 +135,16 @@ module MatrixSdk
       elsif %i[client identity].include? target
         # Attempt .well-known discovery
         well_known = begin
-                       wk_uri = URI("https://#{domain}/.well-known/matrix/client")
-                       logger.debug "Trying #{wk_uri}..."
-                       data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
-                         http.get(wk_uri.path).body
-                       end
-                       data = JSON.parse(data)
-                     rescue StandardError => e
-                       logger.debug "Well-known failed with #{e.class}: #{e.message}"
-                       nil
-                     end
+          wk_uri = URI("https://#{domain}/.well-known/matrix/client")
+          logger.debug "Trying #{wk_uri}..."
+          data = Net::HTTP.start(wk_uri.host, wk_uri.port, use_ssl: true, open_timeout: 5, read_timeout: 5, write_timeout: 5) do |http|
+            http.get(wk_uri.path).body
+          end
+          JSON.parse(data)
+        rescue StandardError => e
+          logger.debug "Well-known failed with #{e.class}: #{e.message}"
+          nil
+        end
 
         if well_known
           key = 'm.homeserver'
@@ -161,11 +163,13 @@ module MatrixSdk
 
       params[:well_known] = well_known if keep_wellknown
 
-      new(uri,
-          params.merge(
-            address: target_uri.host,
-            port: target_uri.port
-          ))
+      new(
+        uri,
+        **params.merge(
+          address: target_uri.host,
+          port: target_uri.port
+        )
+      )
     end
 
     # Get a list of enabled protocols on the API client
@@ -268,23 +272,6 @@ module MatrixSdk
         u.query = [u.query, URI.encode_www_form(options.fetch(:query))].flatten.compact.join('&') if options[:query]
         u.query = nil if u.query.nil? || u.query.empty?
       end
-      request = Net::HTTP.const_get(method.to_s.capitalize.to_sym).new url.request_uri
-      request.body = options[:body] if options.key? :body
-      request.body = request.body.to_json if options.key?(:body) && !request.body.is_a?(String)
-      request.body_stream = options[:body_stream] if options.key? :body_stream
-
-      global_headers.each { |h, v| request[h] = v }
-      if request.body || request.body_stream
-        request.content_type = 'application/json'
-        request.content_length = (request.body || request.body_stream).size
-      end
-
-      request['authorization'] = "Bearer #{access_token}" if access_token && !options.fetch(:skip_auth, false)
-      if options.key? :headers
-        options[:headers].each do |h, v|
-          request[h.to_s.downcase] = v
-        end
-      end
 
       failures = 0
       loop do
@@ -292,10 +279,11 @@ module MatrixSdk
 
         req_id = ('A'..'Z').to_a.sample(4).join
 
-        print_http(request, id: req_id)
+        req_obj = construct_request(url: url, method: method, **options)
+        print_http(req_obj, id: req_id)
         begin
           dur_start = Time.now
-          response = http.request request
+          response = http.request req_obj
           dur_end = Time.now
           duration = dur_end - dur_start
         rescue EOFError
@@ -304,7 +292,12 @@ module MatrixSdk
         end
         print_http(response, duration: duration, id: req_id)
 
-        data = JSON.parse(response.body, symbolize_names: true) rescue nil
+        begin
+          data = JSON.parse(response.body, symbolize_names: true)
+        rescue JSON::JSONError => e
+          logger.debug "#{e.class} error when parsing response. #{e}"
+          data = nil
+        end
 
         if response.is_a? Net::HTTPTooManyRequests
           raise MatrixRequestError.new_by_code(data, response.code) unless autoretry
@@ -315,7 +308,13 @@ module MatrixSdk
           next
         end
 
-        return MatrixSdk::Response.new self, data if response.is_a? Net::HTTPSuccess
+        if response.is_a? Net::HTTPSuccess
+          unless data
+            logger.error "Received non-parsable data in 200 response; #{response.body.inspect}"
+            raise MatrixConnectionError, response
+          end
+          return MatrixSdk::Response.new self, data
+        end
         raise MatrixRequestError.new_by_code(data, response.code) if data
 
         raise MatrixConnectionError.class_by_code(response.code), response
@@ -333,14 +332,38 @@ module MatrixSdk
 
     private
 
+    def construct_request(method:, url:, **options)
+      request = Net::HTTP.const_get(method.to_s.capitalize.to_sym).new url.request_uri
+
+      # FIXME: Handle bodies better, avoid duplicating work
+      request.body = options[:body] if options.key? :body
+      request.body = request.body.to_json if options.key?(:body) && !request.body.is_a?(String)
+      request.body_stream = options[:body_stream] if options.key? :body_stream
+
+      global_headers.each { |h, v| request[h] = v }
+      if request.body || request.body_stream
+        request.content_type = 'application/json'
+        request.content_length = (request.body || request.body_stream).size
+      end
+
+      request['authorization'] = "Bearer #{access_token}" if access_token && !options.fetch(:skip_auth, false)
+      if options.key? :headers
+        options[:headers].each do |h, v|
+          request[h.to_s.downcase] = v
+        end
+      end
+
+      request
+    end
+
     def print_http(http, body: true, duration: nil, id: nil)
       return unless logger.debug?
 
       if http.is_a? Net::HTTPRequest
-        dir = "#{id ? id + ' : ' : nil}>"
+        dir = "#{id ? "#{id} : " : nil}>"
         logger.debug "#{dir} Sending a #{http.method} request to `#{http.path}`:"
       else
-        dir = "#{id ? id + ' : ' : nil}<"
+        dir = "#{id ? "#{id} : " : nil}<"
         logger.debug "#{dir} Received a #{http.code} #{http.message} response:#{duration ? " [#{(duration * 1000).to_i}ms]" : nil}"
       end
       http.to_hash.map { |k, v| "#{k}: #{k == 'authorization' ? '[ REDACTED ]' : v.join(', ')}" }.each do |h|
@@ -349,7 +372,7 @@ module MatrixSdk
       logger.debug dir
       if body
         clean_body = JSON.parse(http.body) rescue nil if http.body
-        clean_body.keys.each { |k| clean_body[k] = '[ REDACTED ]' if %w[password access_token].include?(k) }.to_json if clean_body.is_a? Hash
+        clean_body.each_key { |k| clean_body[k] = '[ REDACTED ]' if %w[password access_token].include?(k) }.to_json if clean_body.is_a? Hash
         clean_body = clean_body.to_s if clean_body
         logger.debug "#{dir} #{clean_body.length < 200 ? clean_body : clean_body.slice(0..200) + "... [truncated, #{clean_body.length} Bytes]"}" if clean_body
       end
@@ -358,6 +381,8 @@ module MatrixSdk
     end
 
     def api_to_path(api)
+      return "/_synapse/#{api.to_s.split('_').join('/')}" if @synapse && api.to_s.start_with?('admin_')
+
       # TODO: <api>_current / <api>_latest
       "/_matrix/#{api.to_s.split('_').join('/')}"
     end

data/lib/matrix_sdk/client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'matrix_sdk'
+require 'matrix_sdk/util/events'
 
 require 'English'
 require 'forwardable'
@@ -23,7 +24,7 @@ module MatrixSdk
     attr_reader :api, :next_batch
     attr_accessor :cache, :sync_filter
 
-    events :error, :event, :presence_event, :invite_event, :leave_event, :ephemeral_event
+    events :error, :event, :presence_event, :invite_event, :leave_event, :ephemeral_event, :state_event
     ignore_inspect :api,
                    :on_event, :on_presence_event, :on_invite_event, :on_leave_event, :on_ephemeral_event
 
@@ -67,19 +68,17 @@ module MatrixSdk
           api.instance_variable_set("@#{k}", v) if api.instance_variable_defined? "@#{k}"
         end
       else
-        @api = Api.new hs_url, params
+        @api = Api.new hs_url, **params
       end
 
-      @rooms = {}
-      @users = {}
       @cache = client_cache
       @identity_server = nil
+      @mxid = nil
 
       @sync_token = nil
       @sync_thread = nil
       @sync_filter = { room: { timeline: { limit: params.fetch(:sync_filter_limit, 20) }, state: { lazy_load_members: true } } }
 
-      @should_listen = false
       @next_batch = nil
 
       @bad_sync_timeout_limit = 60 * 60
@@ -88,6 +87,11 @@ module MatrixSdk
         instance_variable_set("@#{k}", v) if instance_variable_defined? "@#{k}"
       end
 
+      @rooms = {}
+      @room_handlers = {}
+      @users = {}
+      @should_listen = false
+
       raise ArgumentError, 'Cache value must be one of of [:all, :some, :none]' unless %i[all some none].include? @cache
 
       return unless params[:user_id]
@@ -99,9 +103,8 @@ module MatrixSdk
     #
     # @return [MXID] The MXID of the current user
     def mxid
-      @mxid ||= begin
-        MXID.new api.whoami?[:user_id] if api&.access_token
-      end
+      @mxid ||= MXID.new api.whoami?[:user_id] if api&.access_token
+      @mxid
     end
 
     alias user_id mxid
@@ -154,6 +157,25 @@ module MatrixSdk
       rooms
     end
 
+    # Gets a list of all direct chat rooms (1:1 chats / direct message chats) for the currenct user
+    #
+    # @return [Hash[String,Array[String]]] A mapping of MXIDs to a list of direct rooms with that user
+    def direct_rooms
+      api.get_account_data(mxid, 'm.direct').transform_keys(&:to_s)
+    end
+
+    # Gets a direct message room for the given user if one exists
+    #
+    # @note Will return the oldest room if multiple exist
+    # @return [Room,nil] A direct message room if one exists
+    def direct_room(mxid)
+      mxid = MatrixSdk::MXID.new mxid.to_s unless mxid.is_a? MatrixSdk::MXID
+      raise ArgumentError, 'Must be a valid user ID' unless mxid.user?
+
+      room_id = direct_rooms[mxid.to_s]&.first
+      ensure_room room_id if room_id
+    end
+
     # Gets a list of all relevant rooms, either the ones currently handled by
     # the client, or the list of currently joined ones if no rooms are handled
     #
@@ -170,6 +192,19 @@ module MatrixSdk
       @rooms.values
     end
 
+    # Get a list of all joined Matrix Spaces
+    #
+    # @return [Array[Room]] All the currently joined Spaces
+    def spaces
+      rooms = if cache == :none
+                api.get_joined_rooms.joined_rooms.map { |id| Room.new(self, id) }
+              else
+                self.rooms
+              end
+
+      rooms.select(&:space?)
+    end
+
     # Refresh the list of currently handled rooms, replacing it with the user's
     # currently joined rooms.
     #
@@ -187,6 +222,7 @@ module MatrixSdk
       true
     end
     alias refresh_rooms! reload_rooms!
+    alias reload_spaces! reload_rooms!
 
     # Register - and log in - on the connected HS as a guest
     #
@@ -337,7 +373,7 @@ module MatrixSdk
     # @return [Room] The resulting room
     # @see Protocols::CS#create_room
     def create_room(room_alias = nil, **params)
-      data = api.create_room(params.merge(room_alias: room_alias))
+      data = api.create_room(**params.merge(room_alias: room_alias))
       ensure_room(data.room_id)
     end
 
@@ -405,13 +441,13 @@ module MatrixSdk
 
     # Upload a piece of data to the media repo
     #
-    # @return [URI::MATRIX] A Matrix content (mxc://) URL pointing to the uploaded data
+    # @return [URI::MXC] A Matrix content (mxc://) URL pointing to the uploaded data
     # @param content [String] The data to upload
     # @param content_type [String] The MIME type of the data
     # @see Protocols::CS#media_upload
     def upload(content, content_type)
       data = api.media_upload(content, content_type)
-      return data[:content_uri] if data.key? :content_uri
+      return URI(data[:content_uri]) if data.key? :content_uri
 
       raise MatrixUnexpectedResponseError, 'Upload succeeded, but no media URI returned'
     end
@@ -431,10 +467,11 @@ module MatrixSdk
         errors = 0
         thread, cancel_token = api.msc2108_sync_sse(params) do |data, event:, id:|
           @next_batch = id if id
-          if event.to_sym == :sync
+          case event.to_sym
+          when :sync
             handle_sync_response(data)
             errors = 0
-          elsif event.to_sym == :sync_error
+          when :sync_error
             logger.error "SSE Sync error received; #{data.type}: #{data.message}"
             errors += 1
 
@@ -445,7 +482,7 @@ module MatrixSdk
 
         @should_listen = cancel_token
       else
-        thread = Thread.new { listen_forever(params) }
+        thread = Thread.new { listen_forever(**params) }
       end
       @sync_thread = thread
       thread.run
@@ -493,11 +530,9 @@ module MatrixSdk
 
       attempts = 0
       data = loop do
-        begin
-          break api.sync extra_params
-        rescue MatrixSdk::MatrixTimeoutError => e
-          raise e if (attempts += 1) >= params.fetch(:allow_sync_retry, 0)
-        end
+        break api.sync(**extra_params)
+      rescue MatrixSdk::MatrixTimeoutError => e
+        raise e if (attempts += 1) >= params.fetch(:allow_sync_retry, 0)
       end
 
       @next_batch = data[:next_batch] unless skip_store_batch
@@ -524,11 +559,11 @@ module MatrixSdk
       end
     end
 
-    def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 30, **params)
+    def listen_forever(timeout: 30, bad_sync_timeout: 5, sync_interval: 0, **params)
       orig_bad_sync_timeout = bad_sync_timeout + 0
       while @should_listen
         begin
-          sync(params.merge(timeout: timeout))
+          sync(**params.merge(timeout: timeout))
 
           bad_sync_timeout = orig_bad_sync_timeout
           sleep(sync_interval) if sync_interval.positive?
@@ -560,71 +595,51 @@ module MatrixSdk
     def handle_state(room_id, state_event)
       return unless state_event.key? :type
 
+      on_state_event.fire(MatrixEvent.new(self, state_event), state_event[:type])
+
       room = ensure_room(room_id)
       room.send :put_state_event, state_event
-      content = state_event[:content]
-      case state_event[:type]
-      when 'm.room.name'
-        room.instance_variable_set '@name', content[:name]
-      when 'm.room.canonical_alias'
-        room.instance_variable_set '@canonical_alias', content[:alias]
-        # Also add as a regular alias
-        room.instance_variable_get('@aliases').concat [content[:alias]]
-      when 'm.room.topic'
-        room.instance_variable_set '@topic', content[:topic]
-      when 'm.room.aliases'
-        room.instance_variable_get('@aliases').concat content[:aliases]
-      when 'm.room.join_rules'
-        room.instance_variable_set '@join_rule', content[:join_rule].nil? ? nil : content[:join_rule].to_sym
-      when 'm.room.guest_access'
-        room.instance_variable_set '@guest_access', content[:guest_access].nil? ? nil : content[:guest_access].to_sym
-      when 'm.room.member'
-        return unless cache == :all
-
-        if content[:membership] == 'join'
-          room.send(:ensure_member, get_user(state_event[:state_key]).dup.tap do |u|
-            u.instance_variable_set :@display_name, content[:displayname]
-          end)
-        elsif %w[leave kick invite].include? content[:membership]
-          room.members.delete_if { |m| m.id == state_event[:state_key] }
-        end
-      end
     end
 
     def handle_sync_response(data)
-      data[:presence][:events].each do |presence_update|
+      data.dig(:presence, :events)&.each do |presence_update|
         fire_presence_event(MatrixEvent.new(self, presence_update))
       end
 
-      data[:rooms][:invite].each do |room_id, invite|
+      data.dig(:rooms, :invite)&.each do |room_id, invite|
         invite[:room_id] = room_id.to_s
         fire_invite_event(MatrixEvent.new(self, invite), room_id.to_s)
       end
 
-      data[:rooms][:leave].each do |room_id, left|
+      data.dig(:rooms, :leave)&.each do |room_id, left|
         left[:room_id] = room_id.to_s
         fire_leave_event(MatrixEvent.new(self, left), room_id.to_s)
       end
 
-      data[:rooms][:join].each do |room_id, join|
+      data.dig(:rooms, :join)&.each do |room_id, join|
         room = ensure_room(room_id)
-        room.instance_variable_set '@prev_batch', join[:timeline][:prev_batch]
+        room.instance_variable_set '@prev_batch', join.dig(:timeline, :prev_batch)
         room.instance_variable_set :@members_loaded, true unless sync_filter.fetch(:room, {}).fetch(:state, {}).fetch(:lazy_load_members, false)
 
-        join[:state][:events].each do |event|
+        join.dig(:state, :events)&.each do |event|
           event[:room_id] = room_id.to_s
           handle_state(room_id, event)
         end
 
-        join[:timeline][:events].each do |event|
+        join.dig(:timeline, :events)&.each do |event|
           event[:room_id] = room_id.to_s
-          handle_state(room_id, event) if event.key? :state_key
+          # Avoid sending two identical state events if it's both in state and timeline
+          if event.key?(:state_key)
+            state_event = join.dig(:state, :events)&.find { |ev| ev[:event_id] == event[:event_id] }
+
+            handle_state(room_id, event) unless event == state_event
+          end
           room.send :put_event, event
 
           fire_event(MatrixEvent.new(self, event), event[:type])
         end
 
-        join[:ephemeral][:events].each do |event|
+        join.dig(:ephemeral, :events)&.each do |event|
           event[:room_id] = room_id.to_s
           room.send :put_ephemeral_event, event
 
@@ -632,6 +647,14 @@ module MatrixSdk
         end
       end
 
+      unless cache == :none
+        @rooms.each do |_id, room|
+          # Clean up old cache data after every sync
+          # TODO Run this in a thread?
+          room.tinycache_adapter.cleanup
+        end
+      end
+
       nil
     end
   end