stream-chat-ruby 3.21.0 → 3.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04f9d9c833c0a76e5028a2ab0cf93b8825901500e56f6956276d6308e80644da
-  data.tar.gz: ac0c1c38c99ad7d1ab32f7f80c7a8becb9e22f41ecd96e5b4ae11538b5a73313
+  metadata.gz: 9b7896b214aa6d889a30c567056fdf2d0f6d4b6220d83a17acee469ba2b88aca
+  data.tar.gz: 4d7127a19485858f8ff18eef48996adc46dc4f6ae5661c6813a984a38017dd4b
 SHA512:
-  metadata.gz: c372e48ee5d7889c9d8931c57524aa6bb9e9465828dee77a52ec1f2cabfe1bc32392aebf15230cb87427dbf4dff12569569f6b269cfe1d61ba39760763311657
-  data.tar.gz: 5fbaf82414b47e6f1b647280deb88ed07c62c38d833bb5698c1345326bfadc907d40112235815ce98b7a82df5b117ca7de816dc64701579dc8cd110a4f7e5859
+  metadata.gz: 152671fd7190cb2762c3499996ade2c7fd4d4e1dfa823a05214da862d399ae39bcef64183b6ebd6e23912cba9b1685e93b8a1b7e4a06a43f8248d129bd460de4
+  data.tar.gz: 5f92a082a28faedd95b017fcc5f70f43b7c82d386da8149e4d50b03a60486f63360588b9ae280e8c71aff086cdecf6a60209fd447156e1315a02fea983b447fa

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [3.23.0](https://github.com/GetStream/stream-chat-ruby/compare/v3.22.0...v3.23.0) (2026-01-29)
+
+## [3.22.0](https://github.com/GetStream/stream-chat-ruby/compare/v3.21.0...v3.22.0) (2026-01-15)
+
 ## [3.21.0](https://github.com/GetStream/stream-chat-ruby/compare/v3.20.0...v3.21.0) (2025-11-12)
 
 

data/lib/stream-chat/campaign.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'stream-chat/client'
+require 'stream-chat/errors'
+require 'stream-chat/util'
+require 'stream-chat/types'
+
+module StreamChat
+  class Campaign
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :campaign_id
+
+    sig { returns(T.nilable(StringKeyHash)) }
+    attr_reader :data
+
+    sig { params(client: StreamChat::Client, campaign_id: T.nilable(String), data: T.nilable(StringKeyHash)).void }
+    def initialize(client, campaign_id = nil, data = nil)
+      @client = client
+      @campaign_id = campaign_id
+      @data = data
+    end
+
+    # Creates a campaign.
+    #
+    # @param [String, nil] campaign_id Optional campaign ID. If provided, sets the campaign_id.
+    # @param [StringKeyHash, nil] data Optional campaign data to merge with existing data.
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: T.nilable(String), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    def create(campaign_id: nil, data: nil)
+      @campaign_id = campaign_id if campaign_id
+      @data = merge_campaign_data(@data, data) if data
+
+      state = @client.create_campaign(campaign_id: @campaign_id, data: @data)
+
+      @campaign_id = state['campaign']['id'] if @campaign_id.nil? && state.status_code >= 200 && state.status_code < 300 && state['campaign']
+      state
+    end
+
+    # Gets a campaign by ID.
+    #
+    # @return [StreamChat::StreamResponse] API response
+    sig { returns(StreamChat::StreamResponse) }
+    def get
+      raise StreamChannelException, 'campaign does not have an id' if @campaign_id.nil?
+
+      @client.get_campaign(@campaign_id)
+    end
+
+    # Updates a campaign.
+    #
+    # @param [StringKeyHash] data Campaign data to update
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(data: StringKeyHash).returns(StreamChat::StreamResponse) }
+    def update(data)
+      raise StreamChannelException, 'campaign does not have an id' if @campaign_id.nil?
+
+      @client.update_campaign(@campaign_id, data)
+    end
+
+    # Deletes a campaign.
+    #
+    # @param [Hash] options Optional deletion options
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
+    def delete(**options)
+      raise StreamChannelException, 'campaign does not have an id' if @campaign_id.nil?
+
+      @client.delete_campaign(@campaign_id, **options)
+    end
+
+    # Starts a campaign.
+    #
+    # @param [DateTime, Time, String, nil] scheduled_for Optional scheduled start time
+    # @param [DateTime, Time, String, nil] stop_at Optional scheduled stop time
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(scheduled_for: T.nilable(T.any(DateTime, Time, String)), stop_at: T.nilable(T.any(DateTime, Time, String))).returns(StreamChat::StreamResponse) }
+    def start(scheduled_for: nil, stop_at: nil)
+      raise StreamChannelException, 'campaign does not have an id' if @campaign_id.nil?
+
+      @client.start_campaign(@campaign_id, scheduled_for: scheduled_for, stop_at: stop_at)
+    end
+
+    # Stops a campaign.
+    #
+    # @return [StreamChat::StreamResponse] API response
+    sig { returns(StreamChat::StreamResponse) }
+    def stop
+      raise StreamChannelException, 'campaign does not have an id' if @campaign_id.nil?
+
+      @client.stop_campaign(@campaign_id)
+    end
+
+    private
+
+    # Merges two campaign data hashes.
+    #
+    # @param [StringKeyHash, nil] data1 First campaign data hash
+    # @param [StringKeyHash, nil] data2 Second campaign data hash
+    # @return [StringKeyHash] Merged campaign data
+    sig { params(data1: T.nilable(StringKeyHash), data2: T.nilable(StringKeyHash)).returns(StringKeyHash) }
+    def merge_campaign_data(data1, data2)
+      return T.must(data2) if data1.nil?
+      return data1 if data2.nil?
+
+      data1.merge(data2)
+    end
+  end
+end

data/lib/stream-chat/channel.rb

@@ -97,6 +97,22 @@ module StreamChat
       state
     end
 
+    # Refreshes the channel state from the server.
+    # Updates the channel's members attribute with fresh data.
+    sig { returns(StreamChat::StreamResponse) }
+    def refresh_state
+      url = "channels/#{@channel_type}/#{@id}/query"
+      state = @client.post(url, data: { state: true })
+
+      # Members can be at top level or inside channel object (like Go's updateChannel)
+      if state['members'] && !state['members'].empty?
+        @members = state['members']
+      elsif state['channel'] && state['channel']['members']
+        @members = state['channel']['members']
+      end
+      state
+    end
+
     # Queries members of a channel.
     #
     # The queryMembers endpoint allows you to list and paginate members from a channel. The
@@ -323,9 +339,9 @@ module StreamChat
     end
 
     # Removes the ban for a user on this channel.
-    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
-    def unban_user(user_id)
-      @client.unban_user(user_id, type: @channel_type, id: @id)
+    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    def unban_user(user_id, **options)
+      @client.unban_user(user_id, type: @channel_type, id: @id, **options)
     end
 
     # Removes a channel from query channel requests for that user until a new message is added.

data/lib/stream-chat/channel_batch_updater.rb

@@ -0,0 +1,214 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'stream-chat/client'
+require 'stream-chat/stream_response'
+require 'stream-chat/types'
+
+module StreamChat
+  class ChannelBatchUpdater
+    extend T::Sig
+
+    sig { params(client: StreamChat::Client).void }
+    def initialize(client)
+      @client = client
+    end
+
+    # Member operations
+
+    # addMembers - Add members to channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T.any(T::Array[String], T::Array[StringKeyHash])] Members to add
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T.any(T::Array[String], T::Array[StringKeyHash])).returns(StreamChat::StreamResponse) }
+    def add_members(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'addMembers',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # removeMembers - Remove members from channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T::Array[StringKeyHash]] Members to remove (each with user_id key)
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    def remove_members(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'removeMembers',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # inviteMembers - Invite members to channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T.any(T::Array[String], T::Array[StringKeyHash])] Members to invite
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T.any(T::Array[String], T::Array[StringKeyHash])).returns(StreamChat::StreamResponse) }
+    def invite_members(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'invites',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # addModerators - Add moderators to channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T::Array[String]] Member IDs to promote to moderator
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T::Array[String]).returns(StreamChat::StreamResponse) }
+    def add_moderators(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'addModerators',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # demoteModerators - Remove moderator role from members in channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T::Array[String]] Member IDs to demote
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T::Array[String]).returns(StreamChat::StreamResponse) }
+    def demote_moderators(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'demoteModerators',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # assignRoles - Assign roles to members in channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T::Array[StringKeyHash]] Members with role assignments
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    def assign_roles(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'assignRoles',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # Visibility operations
+
+    # hide - Hide channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash).returns(StreamChat::StreamResponse) }
+    def hide(filter)
+      @client.update_channels_batch(
+        {
+          operation: 'hide',
+          filter: filter
+        }
+      )
+    end
+
+    # show - Show channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash).returns(StreamChat::StreamResponse) }
+    def show(filter)
+      @client.update_channels_batch(
+        {
+          operation: 'show',
+          filter: filter
+        }
+      )
+    end
+
+    # archive - Archive channels matching the filter for specified members
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T::Array[StringKeyHash]] Members to archive channels for (each with user_id key)
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    def archive(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'archive',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # unarchive - Unarchive channels matching the filter for specified members
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param members [T::Array[StringKeyHash]] Members to unarchive channels for (each with user_id key)
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, members: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
+    def unarchive(filter, members)
+      @client.update_channels_batch(
+        {
+          operation: 'unarchive',
+          filter: filter,
+          members: members
+        }
+      )
+    end
+
+    # Data operations
+
+    # updateData - Update data on channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param data [StringKeyHash] Data to update
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, data: StringKeyHash).returns(StreamChat::StreamResponse) }
+    def update_data(filter, data)
+      @client.update_channels_batch(
+        {
+          operation: 'updateData',
+          filter: filter,
+          data: data
+        }
+      )
+    end
+
+    # addFilterTags - Add filter tags to channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param tags [T::Array[String]] Tags to add
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, tags: T::Array[String]).returns(StreamChat::StreamResponse) }
+    def add_filter_tags(filter, tags)
+      @client.update_channels_batch(
+        {
+          operation: 'addFilterTags',
+          filter: filter,
+          filter_tags_update: tags
+        }
+      )
+    end
+
+    # removeFilterTags - Remove filter tags from channels matching the filter
+    # @param filter [StringKeyHash] Filter to select channels
+    # @param tags [T::Array[String]] Tags to remove
+    # @return [StreamChat::StreamResponse] The server response
+    sig { params(filter: StringKeyHash, tags: T::Array[String]).returns(StreamChat::StreamResponse) }
+    def remove_filter_tags(filter, tags)
+      @client.update_channels_batch(
+        {
+          operation: 'removeFilterTags',
+          filter: filter,
+          filter_tags_update: tags
+        }
+      )
+    end
+  end
+end

data/lib/stream-chat/client.rb

@@ -10,12 +10,14 @@ require 'time'
 require 'date'
 require 'sorbet-runtime'
 require 'stream-chat/channel'
+require 'stream-chat/campaign'
 require 'stream-chat/errors'
 require 'stream-chat/stream_response'
 require 'stream-chat/version'
 require 'stream-chat/util'
 require 'stream-chat/types'
 require 'stream-chat/moderation'
+require 'stream-chat/channel_batch_updater'
 
 module StreamChat
   DEFAULT_BLOCKLIST = 'profanity_en_2020_v1'
@@ -484,6 +486,15 @@ module StreamChat
       get('query_banned_users', params: { payload: params.to_json })
     end
 
+    # Queries future channel bans.
+    #
+    # Future channel bans are automatically applied when a user creates a new channel
+    # or adds a member to an existing channel.
+    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
+    def query_future_channel_bans(**options)
+      get('query_future_channel_bans', params: { payload: options.to_json })
+    end
+
     # Allows you to search for users and see if they are online/offline.
     # You can filter and sort on the custom fields you've set for your user, the user id, and when the user was last active.
     sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
@@ -555,6 +566,101 @@ module StreamChat
       StreamChat::Channel.new(self, channel_type, channel_id, data)
     end
 
+    # Creates a campaign instance
+    #
+    # @param [String, nil] campaign_id the campaign identifier
+    # @param [StringKeyHash, nil] data additional campaign data
+    #
+    # @return [StreamChat::Campaign]
+    #
+    sig { params(campaign_id: T.nilable(String), data: T.nilable(StringKeyHash)).returns(StreamChat::Campaign) }
+    def campaign(campaign_id: nil, data: nil)
+      StreamChat::Campaign.new(self, campaign_id, data)
+    end
+
+    # Creates a campaign.
+    #
+    # @param [String, nil] campaign_id Optional campaign ID
+    # @param [StringKeyHash, nil] data Campaign data including message_template, sender_id, segment_ids or user_ids, etc.
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: T.nilable(String), data: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    def create_campaign(campaign_id: nil, data: nil)
+      payload = {}
+      payload['id'] = campaign_id if campaign_id
+      payload.merge!(data) if data
+      post('campaigns', data: payload)
+    end
+
+    # Gets a campaign by ID.
+    #
+    # @param [String] campaign_id The campaign ID
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
+    def get_campaign(campaign_id)
+      get("campaigns/#{campaign_id}")
+    end
+
+    # Updates a campaign.
+    #
+    # @param [String] campaign_id The campaign ID
+    # @param [StringKeyHash] data Campaign data to update
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: String, data: StringKeyHash).returns(StreamChat::StreamResponse) }
+    def update_campaign(campaign_id, data)
+      put("campaigns/#{campaign_id}", data: data)
+    end
+
+    # Deletes a campaign.
+    #
+    # @param [String] campaign_id The campaign ID
+    # @param [Hash] options Optional deletion options (e.g., gdpr: true)
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    def delete_campaign(campaign_id, **options)
+      delete("campaigns/#{campaign_id}", params: options)
+    end
+
+    # Starts a campaign.
+    #
+    # @param [String] campaign_id The campaign ID
+    # @param [DateTime, Time, String, nil] scheduled_for Optional scheduled start time
+    # @param [DateTime, Time, String, nil] stop_at Optional scheduled stop time
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: String, scheduled_for: T.nilable(T.any(DateTime, Time, String)), stop_at: T.nilable(T.any(DateTime, Time, String))).returns(StreamChat::StreamResponse) }
+    def start_campaign(campaign_id, scheduled_for: nil, stop_at: nil)
+      payload = {}
+      payload['scheduled_for'] = StreamChat.normalize_timestamp(scheduled_for) if scheduled_for
+      payload['stop_at'] = StreamChat.normalize_timestamp(stop_at) if stop_at
+      post("campaigns/#{campaign_id}/start", data: payload)
+    end
+
+    # Stops a campaign.
+    #
+    # @param [String] campaign_id The campaign ID
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(campaign_id: String).returns(StreamChat::StreamResponse) }
+    def stop_campaign(campaign_id)
+      post("campaigns/#{campaign_id}/stop")
+    end
+
+    # Queries campaigns.
+    #
+    # You can query campaigns based on built-in fields as well as any custom field you add to campaigns.
+    # Multiple filters can be combined using AND, OR logical operators, each filter can use its
+    # comparison (equality, inequality, greater than, greater or equal, etc.).
+    # @param [StringKeyHash] filter_conditions Filter conditions for the query
+    # @param [Hash, nil] sort Optional sort parameters (e.g., { 'created_at' => -1 })
+    # @param [Hash] options Additional query options (limit, offset, etc.)
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    def query_campaigns(filter_conditions, sort: nil, **options)
+      data = options.merge({
+                             filter: filter_conditions,
+                             sort: StreamChat.get_sort_fields(sort)
+                           })
+      post('campaigns/query', data: data)
+    end
+
     # Adds a device to a user.
     sig { params(device_id: String, push_provider: String, user_id: String, push_provider_name: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def add_device(device_id, push_provider, user_id, push_provider_name = nil)
@@ -1058,7 +1164,7 @@ module StreamChat
     sig { params(user_id: String, filter_conditions: T::Hash[T.untyped, T.untyped], sort: T.nilable(T::Array[T::Hash[T.untyped, T.untyped]]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_reminders(user_id, filter_conditions = {}, sort: nil, **options)
       params = options.merge({
-                               filter_conditions: filter_conditions,
+                               filter: filter_conditions,
                                sort: sort || [{ field: 'remind_at', direction: 1 }],
                                user_id: user_id
                              })
@@ -1074,6 +1180,21 @@ module StreamChat
       post('channels/delivered', data: data || {}, params: { user_id: user_id })
     end
 
+    # Update channels in batch.
+    # @param payload [StringKeyHash] Payload containing operation, filter, and optional members/data/filter_tags_update
+    # @return [StreamChat::StreamResponse] API response
+    sig { params(payload: StringKeyHash).returns(StreamChat::StreamResponse) }
+    def update_channels_batch(payload)
+      put('channels/batch', data: payload)
+    end
+
+    # Returns a ChannelBatchUpdater instance for batch channel operations.
+    # @return [StreamChat::ChannelBatchUpdater] A ChannelBatchUpdater instance
+    sig { returns(StreamChat::ChannelBatchUpdater) }
+    def channel_batch_updater
+      ChannelBatchUpdater.new(self)
+    end
+
     private
 
     sig { returns(T::Hash[String, String]) }

data/lib/stream-chat/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module StreamChat
-  VERSION = '3.21.0'
+  VERSION = '3.23.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stream-chat-ruby
 version: !ruby/object:Gem::Version
-  version: 3.21.0
+  version: 3.23.0
 platform: ruby
 authors:
 - getstream.io
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-12 00:00:00.000000000 Z
+date: 2026-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -113,7 +113,9 @@ files:
 - Rakefile
 - SECURITY.md
 - lib/stream-chat.rb
+- lib/stream-chat/campaign.rb
 - lib/stream-chat/channel.rb
+- lib/stream-chat/channel_batch_updater.rb
 - lib/stream-chat/client.rb
 - lib/stream-chat/errors.rb
 - lib/stream-chat/moderation.rb