stream-chat-ruby 2.22.0 → 2.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0493f781c7cda5a16174cd56949d41ebf9234a9903d94dfcaf8826e90778d1c4'
-  data.tar.gz: 0b81431fb6fce8e3d230ad0838d5b666696c1368ec00c7417f37789218d20847
+  metadata.gz: 0bfc513b8901c9efe810c00bb59d9aa23b3e12e0816af1896c31a54b69614053
+  data.tar.gz: ad8e9b4f3b2e4f1a4515226382e8fbf243acfdb46bbab93ba0c9a5c27d8208de
 SHA512:
-  metadata.gz: f2cb64ead68735919747ca939dbd4185440d44a5f52164524d874ec98765a37207b3126a63afa30a6de0eb3faadac0f93561c4ecd246add31eb69e6bab6add52
-  data.tar.gz: f6bdf47417e6ed4af0d2a0ed2eb9c775bdb7a4ea5bff3b89bff69c7b702edf892d4009e8e521e067c3a65eb9251e3728e76cbbf9f72e6a90e169907920e65bc0
+  metadata.gz: 8189c936e8c1df17285a51e5410be20f1c6852f92f688a8b1292a971550399404848739772099cfd6e506c89fa5911063793ba46859d757160aa7fe000c8ed8d
+  data.tar.gz: 47de88506b215de1098ae643e7f08cd3636a71709470057a7d672849479f28351f66851e22508e31a59e888bb10b71cf1af99521f15884e1bf385f6b1b760d72

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 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.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)
 
 

data/Gemfile

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

data/lib/stream-chat/channel.rb

@@ -43,29 +43,34 @@ module StreamChat
       "channels/#{@channel_type}/#{@id}"
     end
 
+    # Gets multiple messages from the channel.
     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
 
+    # Sends a message to this channel.
     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
 
+    # Sends an event on this channel.
     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
 
+    # Sends a new reaction to a given message.
     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
 
+    # Delete a reaction from a message.
     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(
@@ -74,12 +79,14 @@ module StreamChat
       )
     end
 
+    # Creates a channel with the given creator user.
     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
 
+    # Creates or returns a channel.
     sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def query(**options)
       payload = { state: true, data: @custom_data }.merge(options)
@@ -91,6 +98,12 @@ module StreamChat
       state
     end
 
+    # 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.
     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({
@@ -110,12 +123,14 @@ module StreamChat
       @client.get('members', params: { payload: params.to_json })
     end
 
+    # Updates a channel.
     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
 
+    # Updates a channel partially.
     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,16 +139,24 @@ module StreamChat
       @client.patch(url, data: payload)
     end
 
+    # Deletes a channel.
     sig { returns(StreamChat::StreamResponse) }
     def delete
       @client.delete(url)
     end
 
+    # Removes all messages from the channel.
     sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def truncate(**options)
       @client.post("#{url}/truncate", data: options)
     end
 
+    # 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.
     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 }
@@ -141,106 +164,136 @@ module StreamChat
       @client.post('moderation/mute/channel', data: data)
     end
 
+    # Unmutes a channel.
     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
 
+    # Adds members to the channel.
     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
 
+    # Invites users to the channel.
     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
 
+    # Accepts an invitation to the channel.
     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
 
+    # Rejects an invitation to the channel.
     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
 
+    # Adds moderators to the channel.
     sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def add_moderators(user_ids)
       update(nil, nil, add_moderators: user_ids)
     end
 
+    # Removes members from the channel.
     sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def remove_members(user_ids)
       update(nil, nil, remove_members: user_ids)
     end
 
+    # Assigns roles to members in the channel.
     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
 
+    # Demotes moderators in the channel.
     sig { params(user_ids: T::Array[String]).returns(StreamChat::StreamResponse) }
     def demote_moderators(user_ids)
       update(nil, nil, demote_moderators: user_ids)
     end
 
+    # Sends the mark read event for this user, only works if the `read_events` setting is enabled.
     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
 
+    # List the message replies for a parent message.
     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
 
+    # List the reactions, supports pagination.
     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
 
+    # Bans a user from this channel.
     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
 
+    # 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)
     end
 
+    # Removes a channel from query channel requests for that user until a new message is added.
+    # Use `show` to cancel this operation.
     sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def hide(user_id)
       @client.post("#{url}/hide", data: { user_id: user_id })
     end
 
+    # Shows a previously hidden channel.
+    # Use `hide` to hide a channel.
     sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def show(user_id)
       @client.post("#{url}/show", data: { user_id: user_id })
     end
 
+    # 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.
     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
 
+    # 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.
     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
 
+    # Deletes a file by file url.
     sig { params(url: String).returns(StreamChat::StreamResponse) }
     def delete_file(url)
       @client.delete("#{self.url}/file", params: { url: url })
     end
 
+    # Deletes an image by image url.
     sig { params(url: String).returns(StreamChat::StreamResponse) }
     def delete_image(url)
       @client.delete("#{self.url}/image", params: { url: url })

data/lib/stream-chat/client.rb

@@ -90,6 +90,12 @@ module StreamChat
       @conn = client
     end
 
+    # Creates a JWT for a user.
+    #
+    # Stream uses JWT (JSON Web Tokens) to authenticate chat users, enabling them to login.
+    # Knowing whether a user is authorized to perform certain actions is managed
+    # separately via a role based permissions system.
+    # You can set an `exp` (expires at) or `iat` (issued at) claim as well.
     sig { params(user_id: String, exp: T.nilable(Integer), iat: T.nilable(Integer)).returns(String) }
     def create_token(user_id, exp = nil, iat = nil)
       payload = { user_id: user_id }
@@ -98,28 +104,41 @@ module StreamChat
       JWT.encode(payload, @api_secret, 'HS256')
     end
 
+    # Updates application settings.
     sig { params(settings: T.untyped).returns(StreamChat::StreamResponse) }
     def update_app_settings(**settings)
       patch('app', data: settings)
     end
 
+    # Returns application settings.
     sig { returns(StreamChat::StreamResponse) }
     def get_app_settings
       get('app')
     end
 
+    # Flags a message.
+    #
+    # Any user is allowed to flag a message. This triggers the message.flagged
+    # webhook event and adds the message to the inbox of your
+    # Stream Dashboard Chat Moderation view.
     sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def flag_message(id, **options)
       payload = { target_message_id: id }.merge(options)
       post('moderation/flag', data: payload)
     end
 
+    # Unflags a message.
     sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def unflag_message(id, **options)
       payload = { target_message_id: id }.merge(options)
       post('moderation/unflag', data: payload)
     end
 
+    # Queries message flags.
+    #
+    # If you prefer to build your own in app moderation dashboard, rather than use the Stream
+    # dashboard, then the query message flags endpoint lets you get flagged messages. Similar
+    # to other queries in Stream Chat, you can filter the flags using query operators.
     sig { params(filter_conditions: StringKeyHash, options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_message_flags(filter_conditions, **options)
       params = options.merge({
@@ -128,24 +147,28 @@ module StreamChat
       get('moderation/flags/message', params: { payload: params.to_json })
     end
 
+    # Flags a user.
     sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def flag_user(id, **options)
       payload = { target_user_id: id }.merge(options)
       post('moderation/flag', data: payload)
     end
 
+    # Unflags a user.
     sig { params(id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def unflag_user(id, **options)
       payload = { target_user_id: id }.merge(options)
       post('moderation/unflag', data: payload)
     end
 
+    # Queries flag reports.
     sig { params(options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_flag_reports(**options)
       data = { filter_conditions: options }
       post('moderation/reports', data: data)
     end
 
+    # Sends a flag report review.
     sig { params(report_id: String, review_result: String, user_id: String, details: T.untyped).returns(StreamChat::StreamResponse) }
     def review_flag_report(report_id, review_result, user_id, **details)
       data = {
@@ -156,11 +179,16 @@ module StreamChat
       patch("moderation/reports/#{report_id}", data: data)
     end
 
+    # Returns a message.
     sig { params(id: String).returns(StreamChat::StreamResponse) }
     def get_message(id)
       get("messages/#{id}")
     end
 
+    # Searches for messages.
+    #
+    # You can enable and/or disable the search indexing on a per channel basis
+    # type through the Stream Dashboard.
     sig { params(filter_conditions: StringKeyHash, query: T.any(String, StringKeyHash), sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def search(filter_conditions, query, sort: nil, **options)
       offset = T.cast(options[:offset], T.nilable(Integer))
@@ -193,6 +221,7 @@ module StreamChat
       upsert_user(user)
     end
 
+    # Creates or updates users.
     sig { params(users: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
     def upsert_users(users)
       payload = {}
@@ -205,83 +234,115 @@ module StreamChat
       post('users', data: { users: payload })
     end
 
+    # Creates or updates a user.
     sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
     def upsert_user(user)
       upsert_users([user])
     end
 
+    # Updates multiple users partially.
     sig { params(updates: T::Array[StringKeyHash]).returns(StreamChat::StreamResponse) }
     def update_users_partial(updates)
       patch('users', data: { users: updates })
     end
 
+    # Updates a single user partially.
     sig { params(update: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_user_partial(update)
       update_users_partial([update])
     end
 
+    # Deletes a user synchronously.
     sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def delete_user(user_id, **options)
       delete("users/#{user_id}", params: options)
     end
 
+    # Deactivates a user.
+    # Deactivated users cannot connect to Stream Chat, and can't send or receive messages.
+    # To reactivate a user, use `reactivate_user` method.
     sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def deactivate_user(user_id, **options)
       post("users/#{user_id}/deactivate", params: options)
     end
 
+    # Reactivates a deactivated user. Use deactivate_user to deactivate a user.
     sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def reactivate_user(user_id, **options)
       post("users/#{user_id}/reactivate", params: options)
     end
 
+    # Exports a user. It exports a user and returns an object
+    # containing all of it's data.
     sig { params(user_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def export_user(user_id, **options)
       get("users/#{user_id}/export", params: options)
     end
 
+    # Bans a user. Users can be banned from an app entirely or from a channel.
+    # When a user is banned, they will not be allowed to post messages until the
+    # ban is removed or expired but will be able to connect to Chat and to channels as before.
+    # To unban a user, use `unban_user` method.
     sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def ban_user(target_id, **options)
       payload = { target_user_id: target_id }.merge(options)
       post('moderation/ban', data: payload)
     end
 
+    # Unbans a user.
+    # To ban a user, use `ban_user` method.
     sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def unban_user(target_id, **options)
       params = { target_user_id: target_id }.merge(options)
       delete('moderation/ban', params: params)
     end
 
+    # Shadow ban a user.
+    # When a user is shadow banned, they will still be allowed to post messages,
+    # but any message sent during the will only be visible to the messages author
+    # and invisible to other users of the App.
+    # To remove a shadow ban, use `remove_shadow_ban` method.
     sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def shadow_ban(target_id, **options)
       payload = { target_user_id: target_id, shadow: true }.merge(options)
       post('moderation/ban', data: payload)
     end
 
+    # Removes a shadow ban of a user.
+    # To shadow ban a user, use `shadow_ban` method.
     sig { params(target_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def remove_shadow_ban(target_id, **options)
       params = { target_user_id: target_id, shadow: true }.merge(options)
       delete('moderation/ban', params: params)
     end
 
+    # Mutes a user.
     sig { params(target_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def mute_user(target_id, user_id)
       payload = { target_id: target_id, user_id: user_id }
       post('moderation/mute', data: payload)
     end
 
+    # Unmutes a user.
     sig { params(target_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def unmute_user(target_id, user_id)
       payload = { target_id: target_id, user_id: user_id }
       post('moderation/unmute', data: payload)
     end
 
+    # Marks all messages as read for a user.
     sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def mark_all_read(user_id)
       payload = { user: { id: user_id } }
       post('channels/read', data: payload)
     end
 
+    # Pins a message.
+    #
+    # Pinned messages allow users to highlight important messages, make announcements, or temporarily
+    # promote content. Pinning a message is, by default, restricted to certain user roles,
+    # but this is flexible. Each channel can have multiple pinned messages and these can be created
+    # or updated with or without an expiration.
     sig { params(message_id: String, user_id: String, expiration: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def pin_message(message_id, user_id, expiration: nil)
       updates = {
@@ -293,6 +354,7 @@ module StreamChat
       update_message_partial(message_id, updates, user_id: user_id)
     end
 
+    # Unpins a message.
     sig { params(message_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def unpin_message(message_id, user_id)
       updates = {
@@ -303,6 +365,8 @@ module StreamChat
       update_message_partial(message_id, updates, user_id: user_id)
     end
 
+    # Updates a message. Fully overwrites a message.
+    # For partial update, use `update_message_partial` method.
     sig { params(message: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_message(message)
       raise ArgumentError, 'message must have an id' unless message.key? 'id'
@@ -310,6 +374,9 @@ module StreamChat
       post("messages/#{message['id']}", data: { message: message })
     end
 
+    # Updates a message partially.
+    # A partial update can be used to set and unset specific fields when
+    # it is necessary to retain additional data fields on the object. AKA a patch style update.
     sig { params(message_id: String, updates: StringKeyHash, user_id: T.nilable(String), options: T.untyped).returns(StreamChat::StreamResponse) }
     def update_message_partial(message_id, updates, user_id: nil, **options)
       params = updates.merge(options)
@@ -317,11 +384,19 @@ module StreamChat
       put("messages/#{message_id}", data: params)
     end
 
+    # Deletes a message.
     sig { params(message_id: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def delete_message(message_id, **options)
       delete("messages/#{message_id}", params: options)
     end
 
+    # Queries banned users.
+    #
+    # Banned users can be retrieved in different ways:
+    # 1) Using the dedicated query bans endpoint
+    # 2) User Search: you can add the banned:true condition to your search. Please note that
+    # this will only return users that were banned at the app-level and not the ones
+    # that were banned only on channels.
     sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_banned_users(filter_conditions, sort: nil, **options)
       params = options.merge({
@@ -331,6 +406,8 @@ module StreamChat
       get('query_banned_users', params: { payload: params.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) }
     def query_users(filter_conditions, sort: nil, **options)
       params = options.merge({
@@ -340,6 +417,12 @@ module StreamChat
       get('users', params: { payload: params.to_json })
     end
 
+    # Queries channels.
+    #
+    # You can query channels based on built-in fields as well as any custom field you add to channels.
+    # Multiple filters can be combined using AND, OR logical operators, each filter can use its
+    # comparison (equality, inequality, greater than, greater or equal, etc.).
+    # You can find the complete list of supported operators in the query syntax section of the docs.
     sig { params(filter_conditions: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
     def query_channels(filter_conditions, sort: nil, **options)
       data = { state: true, watch: false, presence: false }
@@ -350,27 +433,32 @@ module StreamChat
       post('channels', data: data)
     end
 
+    # Creates a new channel type.
     sig { params(data: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_channel_type(data)
       data['commands'] = ['all'] unless data.key?('commands') || data['commands'].nil? || data['commands'].empty?
       post('channeltypes', data: data)
     end
 
+    # Returns a channel types.
     sig { params(channel_type: String).returns(StreamChat::StreamResponse) }
     def get_channel_type(channel_type)
       get("channeltypes/#{channel_type}")
     end
 
+    # Returns a list of channel types.
     sig { returns(StreamChat::StreamResponse) }
     def list_channel_types
       get('channeltypes')
     end
 
+    # Updates a channel type.
     sig { params(channel_type: String, options: T.untyped).returns(StreamChat::StreamResponse) }
     def update_channel_type(channel_type, **options)
       put("channeltypes/#{channel_type}", data: options)
     end
 
+    # Deletes a channel type.
     sig { params(channel_type: String).returns(StreamChat::StreamResponse) }
     def delete_channel_type(channel_type)
       delete("channeltypes/#{channel_type}")
@@ -389,6 +477,7 @@ module StreamChat
       StreamChat::Channel.new(self, channel_type, channel_id, 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)
       post('devices', data: {
@@ -399,16 +488,20 @@ module StreamChat
            })
     end
 
+    # Delete a device.
     sig { params(device_id: String, user_id: String).returns(StreamChat::StreamResponse) }
     def delete_device(device_id, user_id)
       delete('devices', params: { id: device_id, user_id: user_id })
     end
 
+    # Returns a list of devices.
     sig { params(user_id: String).returns(StreamChat::StreamResponse) }
     def get_devices(user_id)
       get('devices', params: { user_id: user_id })
     end
 
+    # Get rate limit quotas and usage.
+    # If no params are toggled, all limits for all endpoints are returned.
     sig { params(server_side: T::Boolean, android: T::Boolean, ios: T::Boolean, web: T::Boolean, endpoints: T::Array[String]).returns(StreamChat::StreamResponse) }
     def get_rate_limits(server_side: false, android: false, ios: false, web: false, endpoints: [])
       params = {}
@@ -421,93 +514,153 @@ module StreamChat
       get('rate_limits', params: params)
     end
 
+    # Verify the signature added to a webhook event.
     sig { params(request_body: String, x_signature: String).returns(T::Boolean) }
     def verify_webhook(request_body, x_signature)
       signature = OpenSSL::HMAC.hexdigest('SHA256', @api_secret, request_body)
       signature == x_signature
     end
 
+    # Allows you to send custom events to a connected user.
     sig { params(user_id: String, event: StringKeyHash).returns(StreamChat::StreamResponse) }
     def send_user_event(user_id, event)
       post("users/#{user_id}/event", data: event)
     end
 
+    # Translates an existing message to another language. The source language
+    # is inferred from the user language or detected automatically by analyzing its text.
+    # If possible it is recommended to store the user language. See the documentation.
     sig { params(message_id: String, language: String).returns(StreamChat::StreamResponse) }
     def translate_message(message_id, language)
       post("messages/#{message_id}/translate", data: { language: language })
     end
 
+    # Runs a message command action.
     sig { params(message_id: String, data: StringKeyHash).returns(StreamChat::StreamResponse) }
     def run_message_action(message_id, data)
       post("messages/#{message_id}/action", data: data)
     end
 
+    # Creates a guest user.
+    #
+    # Guest sessions can be created client-side and do not require any server-side authentication.
+    # Support and livestreams are common use cases for guests users because really
+    # often you want a visitor to be able to use chat on your application without (or before)
+    # they have a regular user account.
     sig { params(user: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_guest(user)
       post('guests', data: user)
     end
 
+    # Returns all blocklists.
+    #
+    # A Block List is a list of words that you can use to moderate chat messages. Stream Chat
+    # comes with a built-in Block List called profanity_en_2020_v1 which contains over a thousand
+    # of the most common profane words.
+    # You can manage your own block lists via the Stream dashboard or APIs to a manage
+    # blocklists and configure your channel types to use them.
     sig { returns(StreamChat::StreamResponse) }
     def list_blocklists
       get('blocklists')
     end
 
+    # Returns a blocklist.
+    #
+    # A Block List is a list of words that you can use to moderate chat messages. Stream Chat
+    # comes with a built-in Block List called profanity_en_2020_v1 which contains over a thousand
+    # of the most common profane words.
+    # You can manage your own block lists via the Stream dashboard or APIs to a manage
+    # blocklists and configure your channel types to use them.
     sig { params(name: String).returns(StreamChat::StreamResponse) }
     def get_blocklist(name)
       get("blocklists/#{name}")
     end
 
+    # Creates a blocklist.
+    #
+    # A Block List is a list of words that you can use to moderate chat messages. Stream Chat
+    # comes with a built-in Block List called profanity_en_2020_v1 which contains over a thousand
+    # of the most common profane words.
+    # You can manage your own block lists via the Stream dashboard or APIs to a manage
+    # blocklists and configure your channel types to use them.
     sig { params(name: String, words: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_blocklist(name, words)
       post('blocklists', data: { name: name, words: words })
     end
 
+    # Updates a blocklist.
+    #
+    # A Block List is a list of words that you can use to moderate chat messages. Stream Chat
+    # comes with a built-in Block List called profanity_en_2020_v1 which contains over a thousand
+    # of the most common profane words.
+    # You can manage your own block lists via the Stream dashboard or APIs to a manage
+    # blocklists and configure your channel types to use them.
     sig { params(name: String, words: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_blocklist(name, words)
       put("blocklists/#{name}", data: { words: words })
     end
 
+    # Deletes a blocklist.
+    #
+    # A Block List is a list of words that you can use to moderate chat messages. Stream Chat
+    # comes with a built-in Block List called profanity_en_2020_v1 which contains over a thousand
+    # of the most common profane words.
+    # You can manage your own block lists via the Stream dashboard or APIs to a manage
+    # blocklists and configure your channel types to use them.
     sig { params(name: String).returns(StreamChat::StreamResponse) }
     def delete_blocklist(name)
       delete("blocklists/#{name}")
     end
 
+    # Requests a channel export.
+    #
+    # Channel exports are created asynchronously, you can use the Task ID returned by
+    # the APIs to keep track of the status and to download the final result when it is ready.
+    # Use `get_task` to check the status of the export.
     sig { params(channels: StringKeyHash, options: T.untyped).returns(StreamChat::StreamResponse) }
     def export_channels(*channels, **options)
       post('export_channels', data: { channels: channels, **options })
     end
 
+    # Returns the status of a channel export. It contains the URL to the JSON file.
     sig { params(task_id: String).returns(StreamChat::StreamResponse) }
     def get_export_channel_status(task_id)
       get("export_channels/#{task_id}")
     end
 
+    # Returns the status of a task.
     sig { params(task_id: String).returns(StreamChat::StreamResponse) }
     def get_task(task_id)
       get("tasks/#{task_id}")
     end
 
+    # Delete users asynchronously. Use `get_task` to check the status of the task.
     sig { params(user_ids: T::Array[String], user: String, messages: T.nilable(StringKeyHash), conversations: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def delete_users(user_ids, user: SOFT_DELETE, messages: nil, conversations: nil)
       post('users/delete', data: { user_ids: user_ids, user: user, messages: messages, conversations: conversations })
     end
 
+    # Deletes multiple channels. This is an asynchronous operation and the returned value is a task Id.
+    # You can use `get_task` method to check the status of the task.
     sig { params(cids: T::Array[String], hard_delete: T::Boolean).returns(StreamChat::StreamResponse) }
     def delete_channels(cids, hard_delete: false)
       post('channels/delete', data: { cids: cids, hard_delete: hard_delete })
     end
 
+    # Revoke tokens for an application issued since the given date.
     sig { params(before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
     def revoke_tokens(before)
       before = T.cast(before, DateTime).rfc3339 if before.instance_of?(DateTime)
       update_app_settings({ 'revoke_tokens_issued_before' => before })
     end
 
+    # Revoke tokens for a user issued since the given date.
     sig { params(user_id: String, before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
     def revoke_user_token(user_id, before)
       revoke_users_token([user_id], before)
     end
 
+    # Revoke tokens for users issued since.
     sig { params(user_ids: T::Array[String], before: T.any(DateTime, String)).returns(StreamChat::StreamResponse) }
     def revoke_users_token(user_ids, before)
       before = T.cast(before, DateTime).rfc3339 if before.instance_of?(DateTime)
@@ -549,6 +702,10 @@ module StreamChat
       make_http_request(:patch, relative_url, params: params, data: data)
     end
 
+    # 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.
     sig { params(relative_url: String, file_url: String, user: StringKeyHash, content_type: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def send_file(relative_url, file_url, user, content_type = nil)
       url = [@base_url, relative_url].join('/')
@@ -568,91 +725,111 @@ module StreamChat
       parse_response(response)
     end
 
+    # Check push notification settings.
     sig { params(push_data: StringKeyHash).returns(StreamChat::StreamResponse) }
     def check_push(push_data)
       post('check_push', data: push_data)
     end
 
+    # Check SQS Push settings
+    #
+    # When no parameters are given, the current SQS app settings are used.
     sig { params(sqs_key: T.nilable(String), sqs_secret: T.nilable(String), sqs_url: T.nilable(String)).returns(StreamChat::StreamResponse) }
     def check_sqs(sqs_key = nil, sqs_secret = nil, sqs_url = nil)
       post('check_sqs', data: { sqs_key: sqs_key, sqs_secret: sqs_secret, sqs_url: sqs_url })
     end
 
+    # Creates a new command.
     sig { params(command: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_command(command)
       post('commands', data: command)
     end
 
+    # Gets a comamnd.
     sig { params(name: String).returns(StreamChat::StreamResponse) }
     def get_command(name)
       get("commands/#{name}")
     end
 
+    # Updates a command.
     sig { params(name: String, command: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_command(name, command)
       put("commands/#{name}", data: command)
     end
 
+    # Deletes a command.
     sig { params(name: String).returns(StreamChat::StreamResponse) }
     def delete_command(name)
       delete("commands/#{name}")
     end
 
+    # Lists all commands.
     sig { returns(StreamChat::StreamResponse) }
     def list_commands
       get('commands')
     end
 
+    # Lists all permissions.
     sig { returns(StreamChat::StreamResponse) }
     def list_permissions
       get('permissions')
     end
 
+    # Gets a permission.
     sig { params(id: String).returns(StreamChat::StreamResponse) }
     def get_permission(id)
       get("permissions/#{id}")
     end
 
+    # Creates a new permission.
     sig { params(permission: StringKeyHash).returns(StreamChat::StreamResponse) }
     def create_permission(permission)
       post('permissions', data: permission)
     end
 
+    # Updates a permission.
     sig { params(id: String, permission: StringKeyHash).returns(StreamChat::StreamResponse) }
     def update_permission(id, permission)
       put("permissions/#{id}", data: permission)
     end
 
+    # Deletes a permission by id.
     sig { params(id: String).returns(StreamChat::StreamResponse) }
     def delete_permission(id)
       delete("permissions/#{id}")
     end
 
+    # Create a new role.
     sig { params(name: String).returns(StreamChat::StreamResponse) }
     def create_role(name)
       post('roles', data: { name: name })
     end
 
+    # Delete a role by name.
     sig { params(name: String).returns(StreamChat::StreamResponse) }
     def delete_role(name)
       delete("roles/#{name}")
     end
 
+    # List all roles.
     sig { returns(StreamChat::StreamResponse) }
     def list_roles
       get('roles')
     end
 
+    # Create or update a push provider.
     sig { params(push_provider: StringKeyHash).returns(StreamChat::StreamResponse) }
     def upsert_push_provider(push_provider)
       post('push_providers', data: { push_provider: push_provider })
     end
 
+    # Delete a push provider by type and name.
     sig { params(type: String, name: String).returns(StreamChat::StreamResponse) }
     def delete_push_provider(type, name)
       delete("push_providers/#{type}/#{name}")
     end
 
+    # Lists all push providers.
     sig { returns(StreamChat::StreamResponse) }
     def list_push_providers
       get('push_providers')

data/lib/stream-chat/version.rb

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

data/stream-chat.gemspec

@@ -35,4 +35,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'simplecov-console'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stream-chat-ruby
 version: !ruby/object:Gem::Version
-  version: 2.22.0
+  version: 2.22.1
 platform: ruby
 authors:
 - getstream.io
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-11 00:00:00.000000000 Z
+date: 2022-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby client for Stream Chat.
 email: support@getstream.io
 executables: []