Struct RequestQueueClient 

pub struct RequestQueueClient { /* private fields */ }

Client for a specific request queue.

Implementations

impl RequestQueueClient

pub fn with_client_key(self, client_key: impl Into<String>) -> Self

Sets the clientKey used to identify this client across requests (for locking).

pub async fn get(&self) -> ApifyClientResult<Option<RequestQueue>>

Fetches the queue metadata, or None if it does not exist.

pub async fn update<T: Serialize>( &self, new_fields: &T, ) -> ApifyClientResult<RequestQueue>

Updates the queue metadata (e.g. name, title).

pub async fn delete(&self) -> ApifyClientResult<()>

Deletes the queue.

pub async fn list_head( &self, limit: Option<i64>, ) -> ApifyClientResult<RequestQueueHead>

Lists requests from the head of the queue (without locking them).

pub async fn add_request( &self, request: &RequestQueueRequest, forefront: bool, ) -> ApifyClientResult<RequestQueueOperationInfo>

Adds a single request to the queue. If forefront is true, adds it to the front.

pub async fn get_request( &self, id: &str, ) -> ApifyClientResult<Option<RequestQueueRequest>>

Gets a request by ID, or None if it does not exist.

pub async fn update_request( &self, request: &RequestQueueRequest, forefront: bool, ) -> ApifyClientResult<RequestQueueOperationInfo>

Updates a request (which must include its id).

pub async fn delete_request(&self, id: &str) -> ApifyClientResult<()>

Deletes a request by ID.

pub async fn list_and_lock_head( &self, lock_secs: i64, limit: Option<i64>, ) -> ApifyClientResult<LockedRequestQueueHead>

Lists and locks requests from the head of the queue for lock_secs seconds.

pub async fn batch_add_requests( &self, requests: &[RequestQueueRequest], options: BatchAddRequestsOptions, ) -> ApifyClientResult<BatchRequestsOperationResult>

Adds multiple requests to the queue in a single logical operation.

This is significantly more efficient than calling add_request once per request, especially for large batches: the input is automatically split into chunks that respect both the API’s per-call request-count limit ([MAX_REQUESTS_PER_BATCH_OPERATION]) and its request-body byte-size limit ([MAX_PAYLOAD_SIZE_BYTES]), chunks are sent with up to options.max_parallel API calls in flight at once, and any request an API call reports as unprocessed (typically due to rate limiting) is retried with exponential backoff — matching the reference client’s batchAddRequests. Every request must be identifiable by RequestQueueRequest::unique_key (or, if left unset, by url, the API’s own fallback) so a retried request can be matched back to the original input.

Unlike most methods here, this does not propagate per-chunk API errors: a chunk that fails even after retries has its requests reported in the result’s unprocessed_requests instead, so a batch add of many requests never fails outright over one bad chunk (matching the reference client). It still returns ApifyClientError::InvalidArgument up front, before any request is sent, for an empty requests (matching batch_delete_requests and the reference client, which validates both as non-empty) or if a single request’s JSON is too large to ever fit in a chunk.

pub async fn batch_delete_requests<T: Serialize>( &self, requests: &[T], ) -> ApifyClientResult<BatchRequestsOperationResult>

Deletes multiple requests in a single batch operation.

Unlike batch_add_requests, this does not auto-chunk: the API accepts at most [MAX_REQUESTS_PER_BATCH_OPERATION] requests per call (matching the reference client, which validates rather than chunks), so a larger requests returns ApifyClientError::InvalidArgument before any request is sent.

pub async fn list_requests( &self, options: ListRequestsOptions, ) -> ApifyClientResult<RequestQueueRequestsPage>

Lists requests in the queue.

Supports pagination via limit/exclusive_start_id and the spec’s cursor/filter parameters (see ListRequestsOptions).

pub async fn prolong_request_lock( &self, id: &str, lock_secs: i64, forefront: bool, ) -> ApifyClientResult<RequestLockInfo>

Prolongs the lock on a request for another lock_secs seconds.

If forefront is true, the request moves to the front of the queue when its lock later expires.

pub async fn delete_request_lock( &self, id: &str, forefront: bool, ) -> ApifyClientResult<()>

Releases the lock on a request so other clients can process it.

If forefront is true, the request moves to the front of the queue.

pub fn paginate_requests( &self, page_limit: Option<i64>, ) -> RequestQueueRequestsIterator

Lazily paginates over all requests in the queue, fetching pages on demand.

Returns a RequestQueueRequestsIterator; call its next() to get one request at a time. Pagination uses the API’s opaque nextCursor token: the first page may be anchored with exclusiveStartId, but every subsequent page is fetched with cursor (matching the JS reference). cursor and exclusiveStartId are mutually exclusive.

pub async fn unlock_requests(&self) -> ApifyClientResult<UnlockRequestsResult>

Unlocks all requests currently locked by this client (identified by client_key).

Trait Implementations

impl Clone for RequestQueueClient

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RequestQueueClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.