supabase-rb 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c6d9216ec9407182b784f962757533f0dcb4bff3be7c7b04a4b2e3ff708878f
-  data.tar.gz: cd2aa70a2e15fdb624d0891d23ea5fdcd018eb258f3585a22e70b5736b6e03d1
+  metadata.gz: 7490edd0417af9cdc03db6da250e89db6117ff7e8b2e0e57981c993a77e11ad8
+  data.tar.gz: dfca661ce05dac328aea1aaaec095c8ee1d82365185c6a6ef3e25383361872ba
 SHA512:
-  metadata.gz: 595191ce59fb0c18028b0dc32d4b87fcc3c8a83ba4039cd3bd104c78653935c00ec234c6da85dcda2d173856465270262e2ddce8dc1b3cb8af105259b3727a15
-  data.tar.gz: b494cdfd89a8ac25eddc59434545bc705116ff01ea97d06e279c5c88555e35ecea638ab88ac6f3c3381b1ed9f7a3d6276af85e87b4f67f8fe02ce0c20ee89c1d
+  metadata.gz: e8156e656365854825396e52643c1055ca0b5c608b8365c260cdfbe89f4e71923771eb9b1cb0d73eefd8f9e7bf7b350948edfda829cff331ed5972fd467b4293
+  data.tar.gz: 042a0c5e2132027ffbb2dab37fda4e93aae88aca605fba711bade4ca4765d5a269366bfc947ab1ad674462b25562920662fe1c053aebc6b55377688e769df9c6

data/lib/supabase/auth/client.rb

@@ -67,6 +67,11 @@ module Supabase
       end
 
       # Initialize the client, optionally from a URL or from storage.
+      # Equivalent to supabase-py's `client.initialize(url=...)` — `initialize`
+      # is the Ruby constructor name, so this rb port uses `#init` instead.
+      # An alias `bootstrap` is provided for callers who prefer a verb that
+      # doesn't read as a constructor.
+      #
       # @param url [String, nil] optional redirect URL to initialize from
       def init(url: nil)
         if url && _is_implicit_grant_flow(url)
@@ -75,6 +80,7 @@ module Supabase
           initialize_from_storage
         end
       end
+      alias bootstrap init
 
       # Recover session from storage and refresh if needed.
       def initialize_from_storage
@@ -904,51 +910,29 @@ module Supabase
         end
 
         if @persist_session && session.expires_at
-          session_data = {
-            access_token: session.access_token,
-            refresh_token: session.refresh_token,
-            token_type: session.token_type,
-            expires_in: session.expires_in,
-            expires_at: session.expires_at,
-            provider_token: session.provider_token,
-            provider_refresh_token: session.provider_refresh_token
-          }
-          if session.user
-            user = session.user
-            session_data[:user] = {
-              id: user.id, aud: user.aud, role: user.role,
-              email: user.email, phone: user.phone,
-              email_confirmed_at: user.email_confirmed_at&.iso8601,
-              phone_confirmed_at: user.phone_confirmed_at&.iso8601,
-              confirmed_at: user.confirmed_at&.iso8601,
-              last_sign_in_at: user.last_sign_in_at&.iso8601,
-              app_metadata: user.app_metadata, user_metadata: user.user_metadata,
-              identities: user.identities&.map { |i|
-                {
-                  id: i.id, identity_id: i.identity_id, user_id: i.user_id,
-                  identity_data: i.identity_data, provider: i.provider,
-                  last_sign_in_at: i.last_sign_in_at&.iso8601,
-                  created_at: i.created_at&.iso8601, updated_at: i.updated_at&.iso8601
-                }
-              },
-              factors: user.factors&.map { |f|
-                {
-                  id: f.id, friendly_name: f.friendly_name, factor_type: f.factor_type,
-                  status: f.status,
-                  created_at: f.created_at&.iso8601, updated_at: f.updated_at&.iso8601
-                }
-              },
-              created_at: user.created_at&.iso8601, updated_at: user.updated_at&.iso8601,
-              new_email: user.new_email, new_phone: user.new_phone,
-              invited_at: user.invited_at&.iso8601,
-              is_anonymous: user.is_anonymous,
-              confirmation_sent_at: user.confirmation_sent_at&.iso8601,
-              recovery_sent_at: user.recovery_sent_at&.iso8601,
-              email_change_sent_at: user.email_change_sent_at&.iso8601,
-              action_link: user.action_link
-            }
+          @storage.set_item(@storage_key, JSON.generate(_serialize_session(session)))
+        end
+      end
+
+      # Recursively dump a Session (and nested User / Identity / Factor structs)
+      # to a Hash that JSON.generate accepts. Mirrors py's
+      # `session.model_dump_json()` — every Struct member is preserved (not
+      # just a hand-picked allow-list), so custom upstream fields round-trip
+      # through storage without being silently dropped.
+      def _serialize_session(value)
+        case value
+        when Struct
+          value.to_h.each_with_object({}) do |(key, member_value), acc|
+            acc[key] = _serialize_session(member_value)
           end
-          @storage.set_item(@storage_key, JSON.generate(session_data))
+        when Hash
+          value.each_with_object({}) { |(k, v), acc| acc[k] = _serialize_session(v) }
+        when Array
+          value.map { |item| _serialize_session(item) }
+        when Time, Date, DateTime
+          value.iso8601
+        else
+          value
         end
       end
 

data/lib/supabase/client.rb

@@ -30,6 +30,37 @@ module Supabase
   class Client
     attr_reader :supabase_url, :supabase_key, :options, :headers
 
+    # Mirrors supabase-py's `Client.create(...)`: builds a client, then — if
+    # no explicit Authorization was supplied via options — tries to pull a
+    # persisted session via the auth client and applies its access_token as
+    # the bearer token. Useful when bootstrapping from a session file the
+    # user previously signed into. Any error from get_session is swallowed
+    # so the client always returns successfully.
+    def self.create(supabase_url:, supabase_key:, options: nil, async: false)
+      configured_auth = nil
+      if options.is_a?(Supabase::ClientOptions)
+        configured_auth = options.headers["Authorization"] || options.headers[:Authorization]
+      elsif options.is_a?(Hash)
+        global_headers = options[:global]&.dig(:headers) || options.dig("global", "headers") || {}
+        configured_auth = global_headers["Authorization"] || global_headers[:Authorization]
+      end
+
+      client = new(supabase_url: supabase_url, supabase_key: supabase_key,
+                   options: options || {}, async: async)
+
+      if configured_auth.nil?
+        begin
+          session = client.auth.get_session
+          client.set_auth(session.access_token) if session&.access_token
+        rescue StandardError
+          # No persisted session, or auth storage unavailable — fall back to
+          # the apikey-only bearer that initialize set up.
+        end
+      end
+
+      client
+    end
+
     def initialize(supabase_url:, supabase_key:, options: {}, async: false)
       # Use Supabase::SupabaseException once defined; fall back to ArgumentError
       # during early require cycles. Matches supabase-py's contract.
@@ -63,7 +94,19 @@ module Supabase
     # --- Sub-clients ---------------------------------------------------------
 
     def auth
-      @auth ||= auth_class.new(url: rest_url_for("auth/v1"), headers: @headers, **sub_options(:auth))
+      return @auth if @auth
+
+      @auth = auth_class.new(url: rest_url_for("auth/v1"), headers: @headers, **sub_options(:auth))
+      # Mirror supabase-py's `self.auth.on_auth_state_change(self._listen_to_auth_events)`:
+      # when the auth client emits SIGNED_IN / TOKEN_REFRESHED / SIGNED_OUT,
+      # propagate the new token to every other sub-client.
+      @auth.on_auth_state_change do |event, session|
+        next unless %w[SIGNED_IN TOKEN_REFRESHED SIGNED_OUT].include?(event)
+
+        token = session&.access_token || @supabase_key
+        propagate_auth(token)
+      end
+      @auth
     end
 
     def storage
@@ -126,6 +169,17 @@ module Supabase
 
     private
 
+    # Refresh the Authorization header (used by every sub-client other than
+    # auth itself, which manages its own headers) and reset the memoized
+    # sub-clients so they pick up the new token on next access.
+    def propagate_auth(token)
+      @headers["Authorization"] = "Bearer #{token}"
+      @storage   = nil
+      @functions = nil
+      @postgrest = nil
+      @realtime&.set_auth(token)
+    end
+
     def auth_class
       @async ? require_async_class("auth", "Async::Client") : Auth::Client
     end

data/lib/supabase/postgrest/client.rb

@@ -45,6 +45,54 @@ module Supabase
         @timeout = timeout
       end
 
+      # Set the Authorization header to either Bearer (token) or Basic
+      # (username/password) authentication. Bearer wins if both are supplied.
+      # Mirrors supabase-py's BasePostgrestClient.auth().
+      #
+      # @param token    [String, nil]
+      # @param username [String, nil]
+      # @param password [String]
+      # @return [Client] self, so callers can chain.
+      def auth(token, username: nil, password: "")
+        if token && !token.empty?
+          @headers["Authorization"] = "Bearer #{token}"
+        elsif username
+          credentials = ["#{username}:#{password}"].pack("m0")
+          @headers["Authorization"] = "Basic #{credentials}"
+        else
+          raise ArgumentError, "Neither bearer token nor basic authentication credentials were provided"
+        end
+        self
+      end
+
+      # Release the underlying HTTP connection. After close, subsequent requests
+      # will lazily rebuild the connection on the next call. Mirrors
+      # supabase-py's BasePostgrestClient.aclose() / __exit__ hook — Ruby
+      # callers use it via `client.close` or `Postgrest::Client.new(...) { |c|
+      # ... }` (see ::open below).
+      def close
+        # Faraday connections own a sub-connection per host through their
+        # adapter. We can't force a hard close on most adapters, but dropping
+        # our reference frees the connection for GC and ensures the next call
+        # rebuilds.
+        @session = nil
+        @http_client = nil
+        self
+      end
+
+      # Block form: yields the client, then closes it. Use to scope a client
+      # to a discrete unit of work (matches py's `with SyncPostgrestClient(...)`).
+      def self.open(**kwargs)
+        client = new(**kwargs)
+        return client unless block_given?
+
+        begin
+          yield client
+        ensure
+          client.close
+        end
+      end
+
       # Switch schemas. Returns a new client that points at a different postgres schema.
       # @param name [String]
       # @return [Client]

data/lib/supabase/realtime/channel.rb

@@ -195,6 +195,22 @@ module Supabase
         self
       end
 
+      # Public low-level push for arbitrary Phoenix events. Mirrors
+      # `supabase-py`'s `channel.push(event, payload, timeout)`. Returns the
+      # {Push} instance so callers can attach receive() handlers and observe the
+      # reply / timeout. Raises if called before {#subscribe}.
+      def push_event(event, payload = {}, timeout: nil)
+        unless @joined_once
+          raise Errors::RealtimeError,
+                "tried to push '#{event}' to '#{@topic}' before joining. Call subscribe() first."
+        end
+
+        ref = @socket&.next_ref
+        push = Push.new(self, event, payload, ref: ref, timeout: timeout || Types::DEFAULT_TIMEOUT_SECONDS)
+        send_push(push, register_pending: true)
+        push
+      end
+
       # ----- Inbound dispatch (called by Client) -----
 
       # Route a parsed Message to the appropriate listeners. Returns true if the

data/lib/supabase/realtime/client.rb

@@ -4,7 +4,9 @@ require "json"
 require "uri"
 
 require_relative "channel"
+require_relative "errors"
 require_relative "message"
+require_relative "transformers"
 require_relative "types"
 require_relative "version"
 
@@ -43,6 +45,11 @@ module Supabase
       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)
+        unless Transformers.is_ws_url(url)
+          raise ArgumentError,
+                "Invalid Realtime URL #{url.inspect}: expected ws://, wss://, http://, or https://"
+        end
+
         @url     = normalize_url(url, params)
         @params  = params
         @access_token = params[:access_token] || params["access_token"]

data/lib/supabase/realtime/errors.rb

@@ -14,6 +14,16 @@ module Supabase
 
       # Raised when a non-JSON or malformed frame arrives on the WebSocket.
       class ProtocolError < RealtimeError; end
+
+      # Raised when an operation requires an active WebSocket connection but
+      # the client hasn't connected (or has been closed). Mirrors py
+      # NotConnectedError so call sites can rescue the same class name.
+      class NotConnectedError < RealtimeError; end
+
+      # Raised when the server rejects a join push for authentication reasons
+      # (typical case: missing/invalid apikey or access_token). Mirrors py
+      # AuthorizationError.
+      class AuthorizationError < RealtimeError; end
     end
   end
 end

data/lib/supabase/realtime/transformers.rb

@@ -21,6 +21,16 @@ module Supabase
         url = url.sub(%r{(/socket/websocket|/socket|/websocket)/?\z}i, "")
         url.sub(%r{/+\z}, "")
       end
+
+      # Mirrors supabase-py's utils.is_ws_url: accepts ws/wss and http/https
+      # (which Client#normalize_url upgrades to ws/wss). Any other scheme — or
+      # an unparseable string — returns false.
+      def is_ws_url(url)
+        scheme = URI.parse(url.to_s).scheme&.downcase
+        %w[ws wss http https].include?(scheme)
+      rescue URI::InvalidURIError
+        false
+      end
     end
   end
 end

data/lib/supabase/storage/types.rb

@@ -55,6 +55,10 @@ module Supabase
       # Returned by create_signed_upload_url.
       SignedUploadURL = Struct.new(:signed_url, :token, :path, keyword_init: true) do
         alias_method :signedUrl, :signed_url # rubocop:disable Naming/MethodName
+        # supabase-py exposes this key as `signedURL` (all-caps URL) in its
+        # TypedDict. Keep the alias so dictionary-style indexing from
+        # py-ported code (`result[:signedURL]`) works.
+        alias_method :signedURL, :signed_url # rubocop:disable Naming/MethodName
       end
 
       # --- list_v2 -----------------------------------------------------------

data/lib/supabase/version.rb

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

metadata

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