supabase-rb 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1640366f383a39fbba5df993fe27d204981f99672377fc6982403b4259f6cd81
-  data.tar.gz: d332d7b5a8c3bd0f698263988a8c949c132dbbe51908007b7bf5321d8e53a22b
+  metadata.gz: 2589d2d48421b3667b8db24781d8f09d1d3919846e8c08512561c6b9fecd69b7
+  data.tar.gz: 227b035cb0da6d059a5c43886c8d31801b26ce88b16d3178357c166ceb8c1288
 SHA512:
-  metadata.gz: 11f501920c972f3dde5fee01049df4f95fd2aaff1ff6bc2e29c093e8f4c61671900e9caab52e9b870fa86a430a05d0cdbfaf5c4e957e418a389397cfd4ec941f
-  data.tar.gz: 582991118f05d8171764efa5788d97234c013f8f7eacc84eefe903959068f20a7d083eaf09ead84a4dc76d225a318c6d69e70b96654f97e0254d184a13bbec39
+  metadata.gz: be23970a53045e60aa4ec5dc8de14731013ddbf08f38c1a0a43694337aefe0d380339c877b773a9e93cbfc4713334abe47da12f4b51948b48f1ea0a0c2355072
+  data.tar.gz: d533a8d6ad8ef5563ead20e71cf9dfeabeb0d7403a4032330b602135145c440d5c841482ca8c5dba934ed73adb6ccaafdd66c4945c58c30613d12c8051480632

data/lib/supabase/auth/client.rb

@@ -335,6 +335,8 @@ module Supabase
           session = response.session
         else
           user_response = get_user(access_token)
+          raise Errors::UserDoesntExist, access_token if user_response.nil?
+
           session = Types::Session.new(
             access_token: access_token,
             refresh_token: refresh_token,
@@ -1021,6 +1023,8 @@ module Supabase
         expires_at = time_now + expires_in
 
         user_response = get_user(access_token)
+        raise Errors::UserDoesntExist, access_token if user_response.nil?
+
         session = Types::Session.new(
           provider_token: provider_token,
           provider_refresh_token: provider_refresh_token,

data/lib/supabase/auth/errors.rb

@@ -112,6 +112,16 @@ module Supabase
         end
       end
 
+      # Raised when an access token references a user that no longer exists.
+      class UserDoesntExist < StandardError
+        attr_reader :access_token
+
+        def initialize(access_token)
+          super("User from access_token does not exist")
+          @access_token = access_token
+        end
+      end
+
       # Alias for AuthSessionMissing (matches Python's AuthSessionMissingError)
       AuthSessionMissingError = AuthSessionMissing
       # Alias for AuthWeakPassword (matches Python's AuthWeakPasswordError)

data/lib/supabase/auth/helpers.rb

@@ -105,7 +105,7 @@ module Supabase
           response = exception.response
           status = response[:status]
 
-          if [502, 503, 504].include?(status)
+          if [502, 503, 504, 520, 521, 522, 523, 524, 530].include?(status)
             return Errors::AuthRetryableError.new(exception.message, status: status)
           end
 

data/lib/supabase/realtime/channel.rb

@@ -39,7 +39,7 @@ module Supabase
         @subscribe_callback = nil
 
         @join_push
-          .receive(Types::AckStatus::OK)      { |_| on_join_ok }
+          .receive(Types::AckStatus::OK)      { |p| on_join_ok(p) }
           .receive(Types::AckStatus::ERROR)   { |p| on_join_error(p) }
           .receive(Types::AckStatus::TIMEOUT) { |_| on_join_timeout }
       end
@@ -63,18 +63,42 @@ module Supabase
         @subscribe_callback = block
         @state = Types::ChannelStates::JOINING
 
+        inject_postgres_changes_bindings
         @join_push.instance_variable_set(:@ref, @socket&.next_ref)
         send_push(@join_push, register_pending: true)
         self
       end
 
-      # Tear down the subscription with a phx_leave push.
+      # Re-issue the join push without resetting @joined_once. Used by the
+      # client after a socket reconnect to restore channel subscriptions.
+      def rejoin
+        return unless @joined_once
+
+        @state = Types::ChannelStates::JOINING
+        inject_postgres_changes_bindings
+        @join_push.instance_variable_set(:@ref, @socket&.next_ref)
+        @join_push.instance_variable_set(:@received_status, nil)
+        send_push(@join_push, register_pending: true)
+        self
+      end
+
+      # Tear down the subscription with a phx_leave push. State stays in LEAVING
+      # until the server acks (or errors / times out) — mirrors phoenix.js and
+      # supabase-py so a fast unsubscribe→resubscribe cycle doesn't race with the
+      # server's reply for the previous join.
       def unsubscribe
+        return self if closed?
+
         @state = Types::ChannelStates::LEAVING
         ref = @socket&.next_ref
         leave_push = Push.new(self, Types::ChannelEvents::LEAVE, {}, ref: ref)
-        send_push(leave_push, register_pending: false)
-        @state = Types::ChannelStates::CLOSED
+
+        leave_push
+          .receive(Types::AckStatus::OK)      { |_| on_leave_ack }
+          .receive(Types::AckStatus::ERROR)   { |_| on_leave_ack }
+          .receive(Types::AckStatus::TIMEOUT) { |_| on_leave_ack }
+
+        send_push(leave_push, register_pending: true)
         self
       end
 
@@ -187,6 +211,21 @@ module Supabase
         }
       end
 
+      # Mirrors phoenix.js / supabase-py: every registered on_postgres_changes
+      # listener is serialized into config.postgres_changes on the join payload
+      # so the server filters before sending, instead of shipping every change
+      # for the topic and forcing the client to drop most of them.
+      def inject_postgres_changes_bindings
+        config = (@join_push.payload["config"] ||= {})
+        config["postgres_changes"] = @postgres_changes_callbacks.map do |binding|
+          entry = { "event" => binding[:event] }
+          entry["schema"] = binding[:schema] if binding[:schema]
+          entry["table"]  = binding[:table]  if binding[:table]
+          entry["filter"] = binding[:filter] if binding[:filter]
+          entry
+        end
+      end
+
       def send_push(push, register_pending:)
         message = Message.new(
           event:    push.event,
@@ -197,13 +236,23 @@ module Supabase
         )
 
         if can_send?
-          @pending_pushes[push.ref] = push if register_pending && push.ref
+          if register_pending && push.ref
+            @pending_pushes[push.ref] = push
+            # Arm the timeout only once the push is actually on the wire — if it
+            # gets buffered (channel not yet joined) we leave it untimed until
+            # the buffer is flushed.
+            push.start_timeout
+          end
           @socket&.push(message)
         else
           @push_buffer << [push, register_pending]
         end
       end
 
+      def remove_pending(ref)
+        @pending_pushes.delete(ref)
+      end
+
       def can_send?
         # The join push flushes while joining; the leave push flushes while leaving.
         # Everything else (broadcasts, presence, custom pushes) only sends once joined.
@@ -248,7 +297,46 @@ module Supabase
         end
       end
 
-      def on_join_ok
+      def on_join_ok(payload = nil)
+        # phoenix replies for postgres_changes echo back the bindings the server
+        # actually registered. Compare them index-wise with our local callbacks:
+        # if any client binding doesn't match the server's, the subscription is
+        # silently going to miss events — abort the subscription and surface a
+        # CHANNEL_ERROR so the caller can react instead of waiting forever for
+        # rows that will never arrive.
+        server_postgres_changes = payload.is_a?(Hash) ? payload["postgres_changes"] : nil
+
+        if server_postgres_changes && !@postgres_changes_callbacks.empty?
+          new_bindings = []
+          mismatch = false
+
+          @postgres_changes_callbacks.each_with_index do |binding, i|
+            server_binding = server_postgres_changes[i]
+
+            if server_binding &&
+               server_binding["event"] == binding[:event] &&
+               server_binding["schema"] == binding[:schema] &&
+               server_binding["table"] == binding[:table] &&
+               server_binding["filter"] == binding[:filter]
+              new_bindings << binding.merge(id: server_binding["id"])
+            else
+              mismatch = true
+              break
+            end
+          end
+
+          if mismatch
+            unsubscribe
+            err = Errors::RealtimeError.new(
+              "mismatch between server and client bindings for postgres changes"
+            )
+            @subscribe_callback&.call(Types::SubscribeStates::CHANNEL_ERROR, err)
+            return
+          end
+
+          @postgres_changes_callbacks = new_bindings
+        end
+
         @state = Types::ChannelStates::JOINED
         flush_push_buffer
         @subscribe_callback&.call(Types::SubscribeStates::SUBSCRIBED, nil)
@@ -269,6 +357,11 @@ module Supabase
         @push_buffer = []
         buffered.each { |push, register_pending| send_push(push, register_pending: register_pending) }
       end
+
+      def on_leave_ack
+        @state = Types::ChannelStates::CLOSED
+        @close_callbacks.each { |cb| cb.call({}) }
+      end
     end
   end
 end

data/lib/supabase/realtime/client.rb

@@ -28,13 +28,21 @@ module Supabase
     #   channel.on_postgres_changes("*", schema: "public", table: "users") { |p| puts p }
     #   channel.subscribe
     class Client
-      attr_reader :url, :params, :access_token, :channels, :socket, :timeout
+      attr_reader :url, :params, :access_token, :channels, :socket, :timeout,
+                  :heartbeat_interval, :auto_reconnect, :max_retries, :initial_backoff
 
       # @param url    [String] WebSocket endpoint (ws:// or wss://). Plain http(s) are upgraded.
       # @param params [Hash]   query-string params merged onto the URL (e.g. apikey/access_token)
       # @param socket [Socket, nil] inject your own transport (defaults to nil — caller wires it up)
       # @param timeout [Numeric] default per-push timeout (seconds)
-      def initialize(url:, params: {}, socket: nil, timeout: Types::DEFAULT_TIMEOUT_SECONDS)
+      # @param heartbeat_interval [Numeric] seconds between automatic heartbeat pushes (0 disables)
+      # @param auto_reconnect [Boolean] reconnect on unexpected socket close
+      # @param max_retries [Integer] maximum reconnect attempts before giving up
+      # @param initial_backoff [Numeric] seconds of delay before the first reconnect attempt;
+      #   doubles each attempt up to a 60s cap (matches supabase-py)
+      def initialize(url:, params: {}, socket: nil, timeout: Types::DEFAULT_TIMEOUT_SECONDS,
+                     heartbeat_interval: Types::DEFAULT_HEARTBEAT_INTERVAL_SECONDS,
+                     auto_reconnect: true, max_retries: 5, initial_backoff: 1.0)
         @url     = normalize_url(url, params)
         @params  = params
         @access_token = params[:access_token] || params["access_token"]
@@ -43,6 +51,16 @@ module Supabase
         @timeout  = timeout
         @ref      = 0
 
+        @heartbeat_interval = heartbeat_interval
+        @auto_reconnect     = auto_reconnect
+        @max_retries        = max_retries
+        @initial_backoff    = initial_backoff
+        @heartbeat_thread   = nil
+        @reconnect_thread   = nil
+        @intentionally_closed = false
+        @send_buffer        = [] # frames queued while no socket / not connected
+        @send_buffer_mutex  = Mutex.new
+
         attach_socket if @socket
       end
 
@@ -56,11 +74,15 @@ module Supabase
       def connect
         raise Errors::RealtimeError, "no socket attached — call #use_socket(socket) first" unless @socket
 
+        @intentionally_closed = false
         @socket.connect
         self
       end
 
       def disconnect
+        @intentionally_closed = true
+        stop_reconnect
+        stop_heartbeat
         @socket&.close
         @channels.each_value { |ch| ch.instance_variable_set(:@state, Types::ChannelStates::CLOSED) }
         self
@@ -135,24 +157,127 @@ module Supabase
         @ref.to_s
       end
 
-      # Used by Channel#send_push.
+      # Used by Channel#send_push. If the socket isn't connected yet, the frame
+      # is buffered and flushed automatically when the socket opens — matches
+      # supabase-py's send_buffer so offline pushes aren't silently dropped.
       def push(message)
-        return unless @socket
-
-        @socket.send(JSON.generate(
+        frame = JSON.generate(
           "event"    => message.event,
           "topic"    => message.topic,
           "payload"  => message.payload,
           "ref"      => message.ref,
           "join_ref" => message.join_ref
-        ))
+        )
+
+        if connected?
+          @socket.send(frame)
+        else
+          @send_buffer_mutex.synchronize { @send_buffer << frame }
+        end
       end
 
       private
 
       def attach_socket
-        @socket.on_message do |raw|
-          handle_inbound(raw)
+        @socket.on_message { |raw| handle_inbound(raw) }
+        @socket.on_open    { handle_socket_open }
+        @socket.on_close   { handle_socket_close }
+      end
+
+      def handle_socket_open
+        flush_send_buffer
+        start_heartbeat
+        rejoin_channels
+      end
+
+      def flush_send_buffer
+        buffered = @send_buffer_mutex.synchronize do
+          frames = @send_buffer
+          @send_buffer = []
+          frames
+        end
+        buffered.each do |frame|
+          begin
+            @socket.send(frame)
+          rescue StandardError
+            # Drop on send-error — re-queueing would risk a tight loop if the
+            # socket closes immediately. The push's own timeout will surface
+            # the failure to the caller.
+          end
+        end
+      end
+
+      def handle_socket_close
+        stop_heartbeat
+        return if @intentionally_closed || !@auto_reconnect
+
+        schedule_reconnect
+      end
+
+      def start_heartbeat
+        return if @heartbeat_interval.nil? || @heartbeat_interval <= 0
+        return if @heartbeat_thread&.alive?
+
+        interval = @heartbeat_interval
+        @heartbeat_thread = Thread.new do
+          Thread.current.report_on_exception = false
+          loop do
+            sleep interval
+            break unless connected?
+
+            begin
+              send_heartbeat
+            rescue StandardError
+              # Swallow — a transient send error shouldn't kill the heartbeat loop.
+            end
+          end
+        end
+      end
+
+      def stop_heartbeat
+        thread = @heartbeat_thread
+        @heartbeat_thread = nil
+        thread.kill if thread && thread != Thread.current
+      end
+
+      def schedule_reconnect
+        return if @reconnect_thread&.alive?
+
+        initial   = @initial_backoff
+        max_tries = @max_retries
+
+        @reconnect_thread = Thread.new do
+          Thread.current.report_on_exception = false
+          retries = 0
+          while retries < max_tries
+            retries += 1
+            wait = [initial * (2**(retries - 1)), 60.0].min
+            sleep wait
+            break if @intentionally_closed
+
+            begin
+              @socket.connect
+              break # on_open will fire and restart heartbeat + rejoin channels
+            rescue StandardError
+              # Try again until max_retries is hit.
+            end
+          end
+          @reconnect_thread = nil
+        end
+      end
+
+      def stop_reconnect
+        thread = @reconnect_thread
+        @reconnect_thread = nil
+        thread.kill if thread && thread != Thread.current
+      end
+
+      def rejoin_channels
+        @channels.each_value do |channel|
+          next unless channel.instance_variable_get(:@joined_once)
+          next if channel.joining?
+
+          channel.rejoin
         end
       end
 

data/lib/supabase/realtime/presence.rb

@@ -3,11 +3,11 @@
 module Supabase
   module Realtime
     # Tracks presence state for one channel and implements the Phoenix Presence
-    # sync algorithm: presence_state replaces the local snapshot, presence_diff
-    # applies joins/leaves on top of it.
-    #
-    # The algorithm mirrors phoenix.js's Presence.syncState / Presence.syncDiff so
-    # callers porting from JS/Python see identical behavior.
+    # sync algorithm. Mirrors supabase-py's AsyncRealtimePresence: raw
+    # `{ key => { "metas" => [{ "phx_ref" => ..., ... }] } }` wire payloads are
+    # transformed to a flat `{ key => [{ "presence_ref" => ..., ... }, ...] }`
+    # shape before being stored or emitted, so listener callbacks receive
+    # `(key, current_presences, new_presences)` with `presence_ref` keys.
     class Presence
       attr_reader :state
 
@@ -18,77 +18,47 @@ module Supabase
         @on_leave_callbacks = []
       end
 
-      # The first presence_state message after joining sends the full state. Any
-      # local metas we already have for a key but the server doesn't are emitted
-      # as leaves; anything new is emitted as a join.
-      def sync_state(new_state)
-        joins  = {}
-        leaves = {}
-
-        @state.each do |key, presence|
-          leaves[key] = presence unless new_state.key?(key)
-        end
-
-        new_state.each do |key, new_presence|
-          current = @state[key]
-          if current
-            joined = []
-            left   = []
-            current_refs = metas(current).map { |m| m["phx_ref"] }
-            new_refs     = metas(new_presence).map { |m| m["phx_ref"] }
-            joined = metas(new_presence).reject { |m| current_refs.include?(m["phx_ref"]) }
-            left   = metas(current).reject     { |m| new_refs.include?(m["phx_ref"]) }
-            joins[key]  = { "metas" => joined } unless joined.empty?
-            leaves[key] = { "metas" => left }   unless left.empty?
+      # First snapshot after joining: diff against the (possibly empty) local
+      # state and apply the joins/leaves through the same code path as
+      # `sync_diff`.
+      def sync_state(raw_state)
+        new_state = self.class.transform_state(raw_state)
+        joins = {}
+        leaves = @state.reject { |k, _| new_state.key?(k) }
+
+        new_state.each do |key, presences|
+          current = @state[key] || []
+
+          if current.any?
+            current_refs = current.map { |p| p["presence_ref"] }
+            new_refs = presences.map { |p| p["presence_ref"] }
+            joined_presences = presences.reject { |p| current_refs.include?(p["presence_ref"]) }
+            left_presences = current.reject { |p| new_refs.include?(p["presence_ref"]) }
+            joins[key] = joined_presences if joined_presences.any?
+            leaves[key] = left_presences if left_presences.any?
           else
-            joins[key] = new_presence
+            joins[key] = presences
           end
         end
 
-        @state = deep_copy(new_state)
-        emit_joins(joins)
-        emit_leaves(leaves)
+        sync_diff_internal(joins, leaves)
         @on_sync_callbacks.each(&:call)
         @state
       end
 
-      # Subsequent presence_diff messages carry only joins/leaves to apply.
-      def sync_diff(diff)
-        joins  = diff["joins"]  || {}
-        leaves = diff["leaves"] || {}
-
-        joins.each do |key, presence|
-          if @state[key]
-            existing_refs = metas(@state[key]).map { |m| m["phx_ref"] }
-            new_metas     = metas(presence).reject { |m| existing_refs.include?(m["phx_ref"]) }
-            @state[key]   = { "metas" => metas(@state[key]) + new_metas }
-          else
-            @state[key] = presence
-          end
-        end
-
-        leaves.each do |key, presence|
-          next unless @state[key]
-
-          leaving_refs   = metas(presence).map { |m| m["phx_ref"] }
-          remaining      = metas(@state[key]).reject { |m| leaving_refs.include?(m["phx_ref"]) }
-          if remaining.empty?
-            @state.delete(key)
-          else
-            @state[key] = { "metas" => remaining }
-          end
-        end
-
-        emit_joins(joins)
-        emit_leaves(leaves)
+      # Subsequent presence_diff messages: apply joins/leaves to the local state.
+      # Raw input is transformed before being applied.
+      def sync_diff(raw_diff)
+        joins = self.class.transform_state(raw_diff["joins"] || {})
+        leaves = self.class.transform_state(raw_diff["leaves"] || {})
+        sync_diff_internal(joins, leaves)
         @on_sync_callbacks.each(&:call)
         @state
       end
 
-      # List every meta currently tracked, flat. Useful when callers don't care
-      # about the per-key grouping.
+      # Flat list of every presence currently tracked.
       def list
-        @state.values.flat_map { |presence| metas(presence) }
+        @state.values.flatten
       end
 
       def on_sync(&block)
@@ -110,26 +80,60 @@ module Supabase
         [@on_sync_callbacks, @on_join_callbacks, @on_leave_callbacks].any? { |list| !list.empty? }
       end
 
-      private
-
-      def metas(presence)
-        Array(presence && presence["metas"])
+      # Convert raw Phoenix wire format `{ key => { "metas" => [{phx_ref, ...}] } }`
+      # to flat `{ key => [{presence_ref, ...}, ...] }`. Idempotent on already
+      # transformed input.
+      def self.transform_state(state)
+        new_state = {}
+        (state || {}).each do |key, presences|
+          new_state[key] = if presences.is_a?(Hash) && presences.key?("metas")
+                             presences["metas"].map { |meta| transform_meta(meta) }
+                           else
+                             Array(presences).map { |meta| transform_meta(meta) }
+                           end
+        end
+        new_state
       end
 
-      def emit_joins(joins)
-        joins.each do |key, presence|
-          @on_join_callbacks.each { |cb| cb.call(key, presence) }
+      def self.transform_meta(meta)
+        meta = meta.dup
+        meta.delete("phx_ref_prev")
+        if meta.key?("phx_ref")
+          ref = meta.delete("phx_ref")
+          { "presence_ref" => ref }.merge(meta)
+        else
+          meta
         end
       end
 
-      def emit_leaves(leaves)
-        leaves.each do |key, presence|
-          @on_leave_callbacks.each { |cb| cb.call(key, presence) }
+      private
+
+      def sync_diff_internal(joins, leaves)
+        joins.each do |key, new_presences|
+          current_presences = @state[key] || []
+          @state[key] = new_presences
+
+          if current_presences.any?
+            joined_refs = new_presences.map { |p| p["presence_ref"] }
+            keep_from_current = current_presences.reject { |p| joined_refs.include?(p["presence_ref"]) }
+            @state[key] = keep_from_current + @state[key]
+          end
+
+          @on_join_callbacks.each { |cb| cb.call(key, current_presences, new_presences) }
         end
-      end
 
-      def deep_copy(obj)
-        Marshal.load(Marshal.dump(obj))
+        leaves.each do |key, left_presences|
+          current_presences = @state[key] || []
+          next if current_presences.empty?
+
+          remove_refs = left_presences.map { |p| p["presence_ref"] }
+          remaining = current_presences.reject { |p| remove_refs.include?(p["presence_ref"]) }
+          @state[key] = remaining
+
+          @on_leave_callbacks.each { |cb| cb.call(key, remaining, left_presences) }
+
+          @state.delete(key) if remaining.empty?
+        end
       end
     end
   end

data/lib/supabase/realtime/push.rb

@@ -9,17 +9,24 @@ module Supabase
     #
     # `receive(:ok / :error / :timeout) { |payload| ... }` registers handlers
     # before the push is sent, mirroring phoenix.js's Push API.
+    #
+    # Pushes can be given a timeout via `start_timeout(seconds)`; if no reply is
+    # received within that window the push resolves with AckStatus::TIMEOUT and
+    # is removed from the channel's pending_pushes registry.
     class Push
       attr_reader :ref, :event, :payload, :received_status
 
-      def initialize(channel, event, payload = {}, ref: nil)
+      def initialize(channel, event, payload = {}, ref: nil, timeout: Types::DEFAULT_TIMEOUT_SECONDS)
         @channel  = channel
         @event    = event
         @payload  = payload
         @ref      = ref
+        @timeout  = timeout
         @handlers = Hash.new { |h, k| h[k] = [] }
         @received_status = nil
         @received_payload = nil
+        @timeout_thread = nil
+        @mutex = Mutex.new
       end
 
       def receive(status, &block)
@@ -34,14 +41,49 @@ module Supabase
 
       # Called by the Channel when a phx_reply with matching ref arrives.
       def resolve(status:, payload:)
-        @received_status  = status
-        @received_payload = payload
+        @mutex.synchronize do
+          # Idempotent: a late timeout firing after a real ack must not fire
+          # callbacks twice. First resolution wins.
+          return if @received_status
+
+          @received_status  = status
+          @received_payload = payload
+        end
+        cancel_timeout
         @handlers[status].each { |h| h.call(payload) }
       end
 
-      # Called by the Channel if no reply arrives within the timeout window.
+      # Schedule a TIMEOUT resolution if no reply arrives within `seconds`.
+      # Safe to call multiple times — only the first call schedules.
+      def start_timeout(seconds = @timeout)
+        @mutex.synchronize do
+          return if @timeout_thread
+          return if @received_status
+
+          @timeout_thread = Thread.new do
+            sleep(seconds)
+            time_out
+          end
+        end
+        self
+      end
+
+      # Called when no reply arrives in time, or as an explicit forced-timeout
+      # entry point.
       def time_out
         resolve(status: Types::AckStatus::TIMEOUT, payload: {})
+        # Pending registry lives on the channel — clean up so a late reply
+        # doesn't reach a push we've already given up on.
+        @channel.send(:remove_pending, @ref) if @channel.respond_to?(:remove_pending, true) && @ref
+      end
+
+      # Cancel the pending timeout (no-op if not started or already resolved).
+      def cancel_timeout
+        @mutex.synchronize do
+          thread = @timeout_thread
+          @timeout_thread = nil
+          thread&.kill if thread && thread != Thread.current
+        end
       end
     end
   end

data/lib/supabase/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Supabase
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: supabase-rb
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Supabase