stream-chat-ruby 2.21.0 → 2.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 800770eb3b23adf3a433b13784d19cd0d35c6bcc24d46e05687926d3e646fcad
-  data.tar.gz: 77c2fa8401f2d16e5aaaff3ba5e00b83f35388abc7875ba1bbd301fdf8e0f910
+  metadata.gz: 38d1012ba93c094b6a28185368ae809b0c6ef9bd67d9b88fc7731261c53e25b5
+  data.tar.gz: 04113551dd54cbd418e289f024213bfa3d388168711266a40bd8678d5b59284b
 SHA512:
-  metadata.gz: e76da1cf10fb1f0a8d25f56eb77a0ad29898691a7cd9402efab643f483015adae91ba9344a21ff0d4e7ea233fda16ae2a73596afe8e52e9c342d86c9e62e4515
-  data.tar.gz: 7a898a5e6916344cecc340b175dbfb7e9e1884d3963465b593250320aad5b994213521932cb93e2e79f033f302d0f8748e2062ef494cb503c4979d0182db72a3
+  metadata.gz: 15dca07dcf3d295ac549a2f7d7ddc28663d21c24afa1cd9d4fca89d7a129b00f49594da4713757349903e61b1b2c2b5b32c70e0af1d3827dfd42523ad108c765
+  data.tar.gz: 0d1c5dc9a6ccab2ef2db44fc6eeb221ccf62d16c8779554831784525e2ed375b53f7086f27e02dd22d9a57c77fec1b80e3930cad65a19c898dca2591e3699e6b

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 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.
 
+### [2.22.2](https://github.com/GetStream/stream-chat-ruby/compare/v2.22.1...v2.22.2) (2022-04-21)
+
+
+### Bug Fixes
+
+* **sorbet:** turn off runtime checks properly ([#98](https://github.com/GetStream/stream-chat-ruby/issues/98)) ([29e9e73](https://github.com/GetStream/stream-chat-ruby/commit/29e9e73ac07d163e8c1ca7b24516cb7ac61e93cd))
+
+### [2.22.1](https://github.com/GetStream/stream-chat-ruby/compare/v2.22.0...v2.22.1) (2022-04-20)
+
+### Features
+
+* added comments to public methods ([#93](https://github.com/GetStream/stream-chat-ruby/issues/93)) ([3843fe4](https://github.com/GetStream/stream-chat-ruby/commit/3843fe41ea7716d2b6a787d695bbe54981b2b35e))
+
+## [2.22.0](https://github.com/GetStream/stream-chat-ruby/compare/v2.21.0...v2.22.0) (2022-04-01)
+
+
+### Features
+
+* add new device field ([#90](https://github.com/GetStream/stream-chat-ruby/issues/90)) ([aa6723c](https://github.com/GetStream/stream-chat-ruby/commit/aa6723cd54e58aab0f1b8c55bc4e54211ab39f3c))
+* add new moderation apis ([#88](https://github.com/GetStream/stream-chat-ruby/issues/88)) ([573c586](https://github.com/GetStream/stream-chat-ruby/commit/573c58650392eaa5a6d38b4423e170e30b3e98df))
+* add push provider apis ([#89](https://github.com/GetStream/stream-chat-ruby/issues/89)) ([d592fba](https://github.com/GetStream/stream-chat-ruby/commit/d592fba4c0041102fa18d0fee11961f881414337))
+* **update_user:** deprecate update in favor of upsert ([#91](https://github.com/GetStream/stream-chat-ruby/issues/91)) ([74d3163](https://github.com/GetStream/stream-chat-ruby/commit/74d316339b277b0f9cf0f94f40f11aae30fd7644))
+
 ## [2.21.0](https://github.com/GetStream/stream-chat-ruby/compare/v2.20.0...v2.21.0) (2022-03-03)
 
 

data/Gemfile

@@ -15,4 +15,5 @@ end
 group :test do
   gem 'rack'
   gem 'simplecov'
+  gem 'simplecov-console'
 end

data/README.md

@@ -67,7 +67,7 @@ client.create_token('bob-1')
 ### Create/Update users
 
 ```ruby
-client.update_user({
+client.upsert_user({
     :id => 'bob-1',
     :role => 'admin',
     :name => 'Robert Tables'
@@ -76,7 +76,7 @@ client.update_user({
 # Batch update is also supported
 jane = {:id => 'jane-1'}
 june = {:id => 'june-1'}
-client.update_users([jane, june])
+client.upsert_users([jane, june])
 ```
 
 ### Channel types

data/lib/stream-chat/channel.rb

@@ -9,24 +9,23 @@ require 'stream-chat/types'
 module StreamChat
   class Channel
     extend T::Sig
-    T::Configuration.default_checked_level = :never
     # For now we disable runtime type checks.
     # We will enable it with a major bump in the future,
     # but for now, let's just run a static type check.
 
-    sig { returns(T.nilable(String)) }
+    T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
     attr_reader :id
 
-    sig { returns(String) }
+    T::Sig::WithoutRuntime.sig { returns(String) }
     attr_reader :channel_type
 
-    sig { returns(StringKeyHash) }
+    T::Sig::WithoutRuntime.sig { returns(StringKeyHash) }
     attr_reader :custom_data
 
-    sig { returns(T::Array[StringKeyHash]) }
+    T::Sig::WithoutRuntime.sig { returns(T::Array[StringKeyHash]) }
     attr_reader :members
 
-    sig { params(client: StreamChat::Client, channel_type: String, channel_id: T.nilable(String), custom_data: T.nilable(StringKeyHash)).void }
+    T::Sig::WithoutRuntime.sig { params(client: StreamChat::Client, channel_type: String, channel_id: T.nilable(String), custom_data: T.nilable(StringKeyHash)).void }
     def initialize(client, channel_type, channel_id = nil, custom_data = nil)
       @channel_type = channel_type
       @id = channel_id
@@ -36,37 +35,42 @@ module StreamChat
       @members = T.let([], T::Array[StringKeyHash])
     end
 
-    sig { returns(String) }
+    T::Sig::WithoutRuntime.sig { returns(String) }
     def url
       raise StreamChannelException, 'channel does not have an id' if @id.nil?
 
       "channels/#{@channel_type}/#{@id}"
     end
 
-    sig { params(message_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
+    # Gets multiple messages from the channel.
+    T::Sig::WithoutRuntime.sig { params(message_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def get_messages(message_ids)
       @client.get("#{url}/messages", params: { 'ids' => message_ids.join(',') })
     end
 
-    sig { params(message: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
+    # Sends a message to this channel.
+    T::Sig::WithoutRuntime.sig { params(message: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
     def send_message(message, user_id)
       payload = { message: add_user_id(message, user_id) }
       @client.post("#{url}/message", data: payload)
     end
 
-    sig { params(event: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
+    # Sends an event on this channel.
+    T::Sig::WithoutRuntime.sig { params(event: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
     def send_event(event, user_id)
       payload = { 'event' => add_user_id(event, user_id) }
       @client.post("#{url}/event", data: payload)
     end
 
-    sig { params(message_id: String, reaction: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
+    # Sends a new reaction to a given message.
+    T::Sig::WithoutRuntime.sig { params(message_id: String, reaction: StringKeyHash, user_id: String).returns(StreamChat::StreamResponse) }
     def send_reaction(message_id, reaction, user_id)
       payload = { reaction: add_user_id(reaction, user_id) }
       @client.post("messages/#{message_id}/reaction", data: payload)
     end
 
-    sig { params(message_id: String, reaction_type: String, user_id: String).returns(StreamChat::StreamResponse) }
+    # Delete a reaction from a message.
+    T::Sig::WithoutRuntime.sig { params(message_id: String, reaction_type: String, user_id: String).returns(StreamChat::StreamResponse) }
     def delete_reaction(message_id, reaction_type, user_id)
       @client.delete(
         "messages/#{message_id}/reaction/#{reaction_type}",
@@ -74,13 +78,15 @@ module StreamChat
       )
     end
 
-    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    # Creates a channel with the given creator user.
+    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def create(user_id)
       @custom_data['created_by'] = { id: user_id }
       query(watch: false, state: false, presence: false)
     end
 
-    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Creates or returns a channel.
+    T::Sig::WithoutRuntime.sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def query(**options)
       payload = { state: true, data: @custom_data }.merge(options)
       url = "channels/#{@channel_type}"
@@ -91,7 +97,13 @@ module StreamChat
       state
     end
 
-    sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Queries members of a channel.
+    #
+    # The queryMembers endpoint allows you to list and paginate members from a channel. The
+    # endpoint supports filtering on numerous criteria to efficiently return members information.
+    # This endpoint is useful for channels that have large lists of members and
+    # you want to search members or if you want to display the full list of members for a channel.
+    T::Sig::WithoutRuntime.sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_members(filter_conditions = {}, sort: nil, **options)
       params = {}.merge(options).merge({
                                          id: @id,
@@ -110,13 +122,15 @@ module StreamChat
       @client.get('members', params: { payload: params.to_json })
     end
 
-    sig { params(channel_data: T.nilable(StringKeyHash), update_message: T.nilable(StringKeyHash), options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Updates a channel.
+    T::Sig::WithoutRuntime.sig { params(channel_data: T.nilable(StringKeyHash), update_message: T.nilable(StringKeyHash), options: T.untyped).returns(StreamChat::StreamResponse) }
     def update(channel_data, update_message = nil, **options)
       payload = { data: channel_data, message: update_message }.merge(options)
       @client.post(url, data: payload)
     end
 
-    sig { params(set: T.nilable(StringKeyHash), unset: T.nilable(T::Array[String])).returns(StreamChat::StreamResponse) }
+    # Updates a channel partially.
+    T::Sig::WithoutRuntime.sig { params(set: T.nilable(StringKeyHash), unset: T.nilable(T::Array[String])).returns(StreamChat::StreamResponse) }
     def update_partial(set = nil, unset = nil)
       raise StreamChannelException, 'set or unset is needed' if set.nil? && unset.nil?
 
@@ -124,131 +138,169 @@ module StreamChat
       @client.patch(url, data: payload)
     end
 
-    sig { returns(StreamChat::StreamResponse) }
+    # Deletes a channel.
+    T::Sig::WithoutRuntime.sig { returns(StreamChat::StreamResponse) }
     def delete
       @client.delete(url)
     end
 
-    sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Removes all messages from the channel.
+    T::Sig::WithoutRuntime.sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def truncate(**options)
       @client.post("#{url}/truncate", data: options)
     end
 
-    sig { params(user_id: String, expiration: T.nilable(Integer)).returns(StreamChat::StreamResponse) }
+    # Mutes a channel.
+    #
+    # Messages added to a muted channel will not trigger push notifications, nor change the
+    # unread count for the users that muted it. By default, mutes stay in place indefinitely
+    # until the user removes it; however, you can optionally set an expiration time. The list
+    # of muted channels and their expiration time is returned when the user connects.
+    T::Sig::WithoutRuntime.sig { params(user_id: String, expiration: T.nilable(Integer)).returns(StreamChat::StreamResponse) }
     def mute(user_id, expiration = nil)
       data = { user_id: user_id, channel_cid: @cid }
       data['expiration'] = expiration if expiration
       @client.post('moderation/mute/channel', data: data)
     end
 
-    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    # Unmutes a channel.
+    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def unmute(user_id)
       @client.post('moderation/unmute/channel', data: { 'user_id' => user_id, 'channel_cid' => @cid })
     end
 
-    sig { params(user_ids: T::Array[String], options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Adds members to the channel.
+    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String], options: T.untyped).returns(StreamChat::StreamResponse) }
     def add_members(user_ids, **options)
       payload = options.merge({ add_members: user_ids })
       update(nil, nil, **payload)
     end
 
-    sig { params(user_ids: T::Array[String], options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Invites users to the channel.
+    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String], options: T.untyped).returns(StreamChat::StreamResponse) }
     def invite_members(user_ids, **options)
       payload = options.merge({ invites: user_ids })
       update(nil, nil, **payload)
     end
 
-    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Accepts an invitation to the channel.
+    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def accept_invite(user_id, **options)
       payload = options.merge({ user_id: user_id, accept_invite: true })
       update(nil, nil, **payload)
     end
 
-    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Rejects an invitation to the channel.
+    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def reject_invite(user_id, **options)
       payload = options.merge({ user_id: user_id, reject_invite: true })
       update(nil, nil, **payload)
     end
 
-    sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
+    # Adds moderators to the channel.
+    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def add_moderators(user_ids)
       update(nil, nil, add_moderators: user_ids)
     end
 
-    sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
+    # Removes members from the channel.
+    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def remove_members(user_ids)
       update(nil, nil, remove_members: user_ids)
     end
 
-    sig { params(members: T::Array[StringKeyHash], message: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
+    # Assigns roles to members in the channel.
+    T::Sig::WithoutRuntime.sig { params(members: T::Array[StringKeyHash], message: T.nilable(StringKeyHash)).returns(StreamChat::StreamResponse) }
     def assign_roles(members, message = nil)
       update(nil, message, assign_roles: members)
     end
 
-    sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
+    # Demotes moderators in the channel.
+    T::Sig::WithoutRuntime.sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def demote_moderators(user_ids)
       update(nil, nil, demote_moderators: user_ids)
     end
 
-    sig { params(user_id: String, options: StringKeyHash).returns(StreamChat::StreamResponse) }
+    # Sends the mark read event for this user, only works if the `read_events` setting is enabled.
+    T::Sig::WithoutRuntime.sig { params(user_id: String, options: StringKeyHash).returns(StreamChat::StreamResponse) }
     def mark_read(user_id, **options)
       payload = add_user_id(options, user_id)
       @client.post("#{url}/read", data: payload)
     end
 
-    sig { params(parent_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    # List the message replies for a parent message.
+    T::Sig::WithoutRuntime.sig { params(parent_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def get_replies(parent_id, **options)
       @client.get("messages/#{parent_id}/replies", params: options)
     end
 
-    sig { params(message_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    # List the reactions, supports pagination.
+    T::Sig::WithoutRuntime.sig { params(message_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def get_reactions(message_id, **options)
       @client.get("messages/#{message_id}/reactions", params: options)
     end
 
-    sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
+    # Bans a user from this channel.
+    T::Sig::WithoutRuntime.sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def ban_user(user_id, **options)
       @client.ban_user(user_id, type: @channel_type, id: @id, **options)
     end
 
-    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    # Removes the ban for a user on this channel.
+    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def unban_user(user_id)
       @client.unban_user(user_id, type: @channel_type, id: @id)
     end
 
-    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    # Removes a channel from query channel requests for that user until a new message is added.
+    # Use `show` to cancel this operation.
+    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def hide(user_id)
       @client.post("#{url}/hide", data: { user_id: user_id })
     end
 
-    sig { params(user_id: String).returns(StreamChat::StreamResponse) }
+    # Shows a previously hidden channel.
+    # Use `hide` to hide a channel.
+    T::Sig::WithoutRuntime.sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def show(user_id)
       @client.post("#{url}/show", data: { user_id: user_id })
     end
 
-    sig { params(url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    # Uploads a file.
+    #
+    # This functionality defaults to using the Stream CDN. If you would like, you can
+    # easily change the logic to upload to your own CDN of choice.
+    T::Sig::WithoutRuntime.sig { params(url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def send_file(url, user, content_type = nil)
       @client.send_file("#{self.url}/file", url, user, content_type)
     end
 
-    sig { params(url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
+    # Uploads an image.
+    #
+    # Stream supported image types are: image/bmp, image/gif, image/jpeg, image/png, image/webp,
+    # image/heic, image/heic-sequence, image/heif, image/heif-sequence, image/svg+xml.
+    # You can set a more restrictive list for your application if needed.
+    # The maximum file size is 100MB.
+    T::Sig::WithoutRuntime.sig { params(url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def send_image(url, user, content_type = nil)
       @client.send_file("#{self.url}/image", url, user, content_type)
     end
 
-    sig { params(url: String).returns(StreamChat::StreamResponse) }
+    # Deletes a file by file url.
+    T::Sig::WithoutRuntime.sig { params(url: String).returns(StreamChat::StreamResponse) }
     def delete_file(url)
       @client.delete("#{self.url}/file", params: { url: url })
     end
 
-    sig { params(url: String).returns(StreamChat::StreamResponse) }
+    # Deletes an image by image url.
+    T::Sig::WithoutRuntime.sig { params(url: String).returns(StreamChat::StreamResponse) }
     def delete_image(url)
       @client.delete("#{self.url}/image", params: { url: url })
     end
 
     private
 
-    sig { params(payload: StringKeyHash, user_id: String).returns(StringKeyHash) }
+    T::Sig::WithoutRuntime.sig { params(payload: StringKeyHash, user_id: String).returns(StringKeyHash) }
     def add_user_id(payload, user_id)
       payload.merge({ user: { id: user_id } })
     end