Struct KeyValueStoreClient 

pub struct KeyValueStoreClient { /* private fields */ }

Client for a specific key-value store.

Implementations

impl KeyValueStoreClient

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

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

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

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

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

Deletes the store.

pub async fn list_keys( &self, options: ListKeysOptions, ) -> ApifyClientResult<KeyValueStoreKeysPage>

Lists the keys in the store (key-based pagination).

pub fn iterate_keys( &self, options: ListKeysOptions, ) -> KeyValueStoreKeysIterator

Lazily iterates over every key in the store, fetching pages on demand.

Returns a KeyValueStoreKeysIterator; call its next() to get one key at a time, transparently fetching the following page once the local buffer drains, until the store is exhausted. This is the auto-paginating counterpart to the single-page list_keys, matching the reference client’s listKeys() AsyncIterable.

Key-value stores use cursor-based (not offset) pagination: each page is anchored by the previous page’s nextExclusiveStartKey, so the iterator threads that cursor through automatically. The prefix, collection and signature filters from options are carried into every page.

options.limit caps the total number of keys yielded across all pages; leaving it unset (or 0) iterates the entire store, matching the reference client. It is honoured across as many pages as needed — each individual request is bounded to the endpoint’s maximum page size (KEY_LIST_MAX_LIMIT), so a cap larger than one page still works. options.exclusive_start_key, when set, resumes iteration after that key.

pub async fn record_exists(&self, key: &str) -> ApifyClientResult<bool>

Returns true if a record with the given key exists.

pub async fn get_record( &self, key: &str, ) -> ApifyClientResult<Option<KeyValueStoreRecord>>

Gets a record’s raw value (and content type), or None if it does not exist.

Like the reference client’s getRecord, this sends attachment=true. Use get_record_with_options to override the attachment behaviour or to pass a URL-signing signature for a private store.

pub async fn get_record_with_options( &self, key: &str, options: GetRecordOptions, ) -> ApifyClientResult<Option<KeyValueStoreRecord>>

Gets a record with explicit options.

The attachment option controls the Content-Disposition: attachment response header; when unset it defaults to true, matching the reference client’s unconditional behaviour. signature supplies a URL-signing signature for accessing a record in a private store.

pub async fn set_record_raw( &self, key: &str, value: Vec<u8>, content_type: &str, ) -> ApifyClientResult<()>

Stores a record with raw bytes and an explicit content type.

pub async fn set_record_raw_with_content_encoding( &self, key: &str, value: Vec<u8>, content_type: &str, content_encoding: &str, ) -> ApifyClientResult<()>

Stores a record with raw, already-compressed bytes, sending content_encoding as the Content-Encoding header so it is uploaded (and later served) exactly as given, without the client compressing it again.

The API accepts gzip, br, deflate, and identity. Unlike the reference client’s setRecord({ contentEncoding }), there is no separate runtime check rejecting a non-identity encoding on a string or JSON value: this method, like set_record_raw, only ever accepts bytes that are already the wire payload, so that case cannot arise here — pass pre-serialized/pre-compressed bytes, not a value for the client to serialize. For plain (uncompressed) raw bytes, use set_record_raw; for a JSON value, use set_record_json.

pub async fn set_record_json<T: Serialize>( &self, key: &str, value: &T, ) -> ApifyClientResult<()>

Stores a record as JSON (the value is serialized and content type set to JSON).

pub async fn get_record_public_url( &self, key: &str, ) -> ApifyClientResult<String>

Builds a public URL for reading the record with the given key.

Mirrors the reference client’s getRecordPublicUrl: it fetches the store, and if the store exposes a URL-signing secret key (private store), appends an HMAC-SHA256 signature over the record key so the URL works without an API token. The URL is built from the configured public base URL.

pub async fn create_keys_public_url( &self, expires_in_secs: Option<i64>, ) -> ApifyClientResult<String>

Builds a public URL for listing this store’s keys.

Like get_record_public_url, signs the URL with an HMAC-SHA256 signature for private stores. expires_in_secs optionally bounds a signed URL’s validity.

pub async fn delete_record(&self, key: &str) -> ApifyClientResult<()>

Deletes the record with the given key.

Trait Implementations

impl Clone for KeyValueStoreClient

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 KeyValueStoreClient

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

Formats the value using the given formatter.