feat: add options object to specify custom params for feed.items()

src/core/feed.factory.ts

@@ -84,22 +84,29 @@ export class FeedFactory {
     return new BlockedUsersFeed(this.client);
   }
 
-  public directInbox(): DirectInboxFeed {
-    return new DirectInboxFeed(this.client);
+  public directInbox(options: { limit: number; thread_message_limit: number }): DirectInboxFeed {
+    const feed = new DirectInboxFeed(this.client);
+    feed.limit = options.limit;
+    feed.thread_message_limit = options?.thread_message_limit;
+    return feed;
   }
 
-  public directPending(): DirectPendingInboxFeed {
-    return new DirectPendingInboxFeed(this.client);
+  public directPending(options: { limit: number; thread_message_limit: number }): DirectPendingInboxFeed {
+    const feed = new DirectPendingInboxFeed(this.client);
+    feed.limit = options.limit;
+    feed.thread_message_limit = options?.thread_message_limit;
+    return feed;
   }
 
   public directThread(
-    options: Pick<DirectInboxFeedResponseThreadsItem, 'thread_id' | 'oldest_cursor'>,
+    options: Pick<DirectInboxFeedResponseThreadsItem, 'thread_id' | 'oldest_cursor'> & { limit: number },
     seqId?: number,
   ): DirectThreadFeed {
     const feed = new DirectThreadFeed(this.client);
     feed.id = options.thread_id;
     feed.cursor = options.oldest_cursor;
     feed.seqId = seqId;
+    feed.limit = options?.limit;
     return feed;
   }
 

src/feeds/direct-inbox.feed.ts

@@ -3,37 +3,47 @@ import { Feed } from '../core/feed';
 import { DirectInboxFeedResponse, DirectInboxFeedResponseThreadsItem } from '../responses';
 import { DirectThreadEntity } from '../entities';
 
+interface DirectInboxFeedItemsOptions {
+  cursor?: string;
+  thread_message_limit?: number;
+  limit?: number;
+}
+
 export class DirectInboxFeed extends Feed<DirectInboxFeedResponse, DirectInboxFeedResponseThreadsItem> {
   @Expose()
   private cursor: string;
   @Expose()
   private seqId: number;
 
+  public limit: number;
+  public defaultLimit = 20;
+  public thread_message_limit: number;
+  public defaultThreadMessageLimit: number;
   set state(body: DirectInboxFeedResponse) {
     this.moreAvailable = body.inbox.has_older;
     this.seqId = body.seq_id;
     this.cursor = body.inbox.oldest_cursor;
   }
 
-  async request() {
+  async request(opts?: DirectInboxFeedItemsOptions) {
     const { body } = await this.client.request.send<DirectInboxFeedResponse>({
       url: `/api/v1/direct_v2/inbox/`,
       qs: {
         visual_message_return_type: 'unseen',
-        cursor: this.cursor,
+        cursor: opts.cursor ?? this.cursor,
         direction: this.cursor ? 'older' : void 0,
         seq_id: this.seqId,
-        thread_message_limit: 10,
+        thread_message_limit: this.thread_message_limit ?? this.defaultThreadMessageLimit,
         persistentBadging: true,
-        limit: 20,
+        limit: opts.limit ?? this.limit,
       },
     });
     this.state = body;
     return body;
   }
 
-  async items() {
-    const response = await this.request();
+  async items(opts?: DirectInboxFeedItemsOptions) {
+    const response = await this.request(opts);
     return response.inbox.threads;
   }
 

src/feeds/direct-pending.feed.ts

@@ -3,37 +3,47 @@ import { Feed } from '../core/feed';
 import { DirectInboxFeedResponse, DirectInboxFeedResponseThreadsItem } from '../responses';
 import { DirectThreadEntity } from '../entities';
 
+interface DirectPendingInboxFeedItemsOptions {
+  cursor?: string;
+  thread_message_limit?: number;
+  limit?: number;
+}
+
 export class DirectPendingInboxFeed extends Feed<DirectInboxFeedResponse, DirectInboxFeedResponseThreadsItem> {
   @Expose()
   private cursor: string;
   @Expose()
   private seqId: number;
 
+  public limit: number;
+  public defaultLimit = 20;
+  public thread_message_limit: number;
+  public defaultThreadMessageLimit: number;
   set state(body: DirectInboxFeedResponse) {
     this.moreAvailable = body.inbox.has_older;
     this.seqId = body.seq_id;
     this.cursor = body.inbox.oldest_cursor;
   }
 
-  async request() {
+  async request(opts?: DirectPendingInboxFeedItemsOptions) {
     const { body } = await this.client.request.send<DirectInboxFeedResponse>({
       url: `/api/v1/direct_v2/pending_inbox/`,
       qs: {
         visual_message_return_type: 'unseen',
-        cursor: this.cursor,
+        cursor: this.cursor ?? this.cursor,
         direction: this.cursor ? 'older' : void 0,
         seq_id: this.seqId,
-        thread_message_limit: 10,
+        thread_message_limit: this.thread_message_limit ?? this.defaultThreadMessageLimit,
         persistentBadging: true,
-        limit: 20,
+        limit: this.limit ?? this.defaultLimit,
       },
     });
     this.state = body;
     return body;
   }
 
-  async items() {
-    const response = await this.request();
+  async items(opts?: DirectPendingInboxFeedItemsOptions) {
+    const response = await this.request(opts);
     return response.inbox.threads;
   }
 

src/feeds/direct-thread.feed.ts

@@ -2,32 +2,39 @@ import { Expose } from 'class-transformer';
 import { Feed } from '../core/feed';
 import { DirectThreadFeedResponse, DirectThreadFeedResponseItemsItem } from '../responses';
 
+interface DirectThreadFeedItemsOptions {
+  cursor?: string;
+  limit?: number;
+}
+
 export class DirectThreadFeed extends Feed<DirectThreadFeedResponse, DirectThreadFeedResponseItemsItem> {
   public id: string;
   public seqId: number;
   @Expose()
   public cursor: string;
+  public limit?: number;
+  public defaultLimit = 10;
   set state(body: DirectThreadFeedResponse) {
     this.cursor = body.thread.oldest_cursor;
     this.moreAvailable = body.thread.has_older;
   }
-  async request() {
+  async request(opts?: DirectThreadFeedItemsOptions) {
     const { body } = await this.client.request.send<DirectThreadFeedResponse>({
       url: `/api/v1/direct_v2/threads/${this.id}/`,
       qs: {
         visual_message_return_type: 'unseen',
-        cursor: this.cursor,
+        cursor: this.cursor ?? this.cursor,
         direction: 'older',
         seq_id: this.seqId,
-        limit: 10,
+        limit: this.limit ?? this.defaultLimit,
       },
     });
     this.state = body;
     return body;
   }
 
-  async items() {
-    const response = await this.request();
+  async items(opts?: DirectThreadFeedItemsOptions) {
+    const response = await this.request(opts);
     return response.thread.items;
   }
 }