Add Query Threads

Author: adityaalifn

lib/stream-chat/client.rb

@@ -15,6 +15,7 @@
 require 'stream-chat/util'
 require 'stream-chat/types'
 require 'stream-chat/moderation'
+require 'stream-chat/thread'
 
 module StreamChat
   DEFAULT_BLOCKLIST = 'profanity_en_2020_v1'
@@ -39,6 +40,9 @@ class Client
     sig { returns(Moderation) }
     attr_reader :moderation
 
+    sig { returns(Thread) }
+    attr_reader :thread
+
     # initializes a Stream Chat API Client
     #
     # @param [string] api_key your application api_key
@@ -69,6 +73,7 @@ def initialize(api_key, api_secret, timeout = nil, **options)
       end
       @conn = T.let(conn, Faraday::Connection)
       @moderation = T.let(Moderation.new(self), Moderation)
+      @thread = T.let(Thread.new(self), Thread)
     end
 
     # initializes a Stream Chat API Client from STREAM_KEY and STREAM_SECRET
@@ -929,6 +934,11 @@ def list_imports(options)
       get('imports', params: options)
     end
 
+    sig { params(filter: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    def query_threads(filter, sort, **options)
+      @thread.query_threads(filter, sort, **options)
+    end
+
     private
 
     sig { returns(T::Hash[String, String]) }

lib/stream-chat/thread.rb

@@ -0,0 +1,41 @@
+# 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 Thread
+    extend T::Sig
+
+    sig { returns(StreamChat::Client) }
+    attr_reader :client
+
+    sig { params(client: StreamChat::Client).void }
+    def initialize(client)
+      @client = client
+    end
+
+    # Queries threads based on filter conditions and sort parameters.
+    #
+    # The queryThreads endpoint allows you to list and paginate threads. The
+    # endpoint supports filtering on numerous criteria and sorting by various fields.
+    # This endpoint is useful for displaying threads in a chat application.
+    #
+    # @param [StringKeyHash] filter MongoDB-style filter conditions
+    # @param [T.nilable(T::Hash[String, Integer])] sort Sort parameters
+    # @param [T.untyped] options Additional options like limit, offset, next, etc.
+    # @return [StreamChat::StreamResponse]
+    sig { params(filter: StringKeyHash, sort: T.nilable(T::Hash[String, Integer]), options: T.untyped).returns(StreamChat::StreamResponse) }
+    def query_threads(filter = {}, sort: nil, **options)
+      params = {}.merge(options).merge({
+        filter: filter,
+        sort: StreamChat.get_sort_fields(sort)
+      })
+
+      @client.post('threads', data: params)
+    end
+  end
+end 

spec/thread_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'stream-chat'
+require 'faraday'
+require 'securerandom'
+
+describe StreamChat::Thread do
+  before(:all) do
+    @client = StreamChat::Client.from_env
+    @created_users = []
+  end
+
+  before(:each) do
+    @random_user = { id: SecureRandom.uuid }
+    @created_users.push(@random_user[:id])
+    @client.upsert_users([@random_user])
+  end
+
+  after(:all) do
+    curr_idx = 0
+    batch_size = 25
+
+    slice = @created_users.slice(0, batch_size)
+
+    while !slice.nil? && !slice.empty?
+      @client.delete_users(slice, user: StreamChat::HARD_DELETE, messages: StreamChat::HARD_DELETE)
+
+      curr_idx += batch_size
+      slice = @created_users.slice(curr_idx, batch_size)
+    end
+  end
+
+  describe '#query_threads' do
+    it 'queries threads with filter' do
+      # Create a channel and send a message to create a thread
+      channel = @client.channel('messaging', channel_id: SecureRandom.uuid, data: { test: true })
+      channel.create(@random_user[:id])
+      
+      # Send a message to create a thread
+      message = channel.send_message({ text: 'Thread parent message' }, @random_user[:id])
+      
+      # Send a reply to create a thread
+      channel.send_message({ text: 'Thread reply', parent_id: message['message']['id'] }, @random_user[:id])
+      
+      # Query threads with filter
+      filter = {
+        'created_by_user_id' => { '$eq' => @random_user[:id] }
+      }
+      
+      response = @client.thread.query_threads(filter, user_id: @random_user[:id])
+      
+      # Verify the response
+      expect(response).to include 'threads'
+      expect(response['threads'].length).to be >= 1
+      
+      # Clean up
+      channel.delete
+    end
+
+    it 'queries threads with sort' do
+      # Create a channel and send a message to create a thread
+      channel = @client.channel('messaging', channel_id: SecureRandom.uuid, data: { test: true })
+      channel.create(@random_user[:id])
+      
+      # Send a message to create a thread
+      message = channel.send_message({ text: 'Thread parent message' }, @random_user[:id])
+      
+      # Send a reply to create a thread
+      channel.send_message({ text: 'Thread reply', parent_id: message['message']['id'] }, @random_user[:id])
+      
+      # Query threads with sort
+      sort = {
+        'created_at' => -1
+      }
+      
+      response = @client.thread.query_threads(sort: sort, user_id: @random_user[:id])
+      
+      # Verify the response
+      expect(response).to include 'threads'
+      expect(response['threads'].length).to be >= 1
+      
+      # Clean up
+      channel.delete
+    end
+
+    it 'queries threads with both filter and sort' do
+      # Create a channel and send a message to create a thread
+      channel = @client.channel('messaging', channel_id: SecureRandom.uuid, data: { test: true })
+      channel.create(@random_user[:id])
+      
+      # Send a message to create a thread
+      message = channel.send_message({ text: 'Thread parent message' }, @random_user[:id])
+      
+      # Send a reply to create a thread
+      channel.send_message({ text: 'Thread reply', parent_id: message['message']['id'] }, @random_user[:id])
+      
+      # Query threads with both filter and sort
+      filter = {
+        'created_by_user_id' => { '$eq' => @random_user[:id] }
+      }
+      
+      sort = {
+        'created_at' => -1
+      }
+      
+      response = @client.thread.query_threads(filter, sort: sort, user_id: @random_user[:id])
+      
+      # Verify the response
+      expect(response).to include 'threads'
+      expect(response['threads'].length).to be >= 1
+      
+      # Clean up
+      channel.delete
+    end
+  end
+end