apify-client 3.0.0-beta.6 → 3.0.0-beta.7

package/dist/resource_clients/actor_collection.d.ts

@@ -100,8 +100,6 @@ export interface ActorCollectionCreateOptions {
     isDeprecated?: boolean;
     isPublic?: boolean;
     name?: string;
-    /** @deprecated Use defaultRunOptions.restartOnError instead */
-    restartOnError?: boolean;
     /**
      * @since Added in 2.8.6
      */

package/dist/resource_clients/actor_env_var_collection.d.ts

@@ -1,6 +1,6 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
-import type { PaginatedList, PaginationOptions } from '../utils.js';
+import type { PaginatedList } from '../utils.js';
 import type { ActorEnvironmentVariable } from './actor_version.js';
 /**
  * Client for managing the collection of environment variables for an Actor version.
@@ -37,23 +37,22 @@ export declare class ActorEnvVarCollectionClient extends ResourceCollectionClien
     /**
      * Lists all environment variables of this Actor version.
      *
-     * Awaiting the return value (as you would with a Promise) will result in a single API call. The amount of fetched
-     * items in a single API call is limited.
+     * The endpoint returns every environment variable in one response, so awaiting the return value (as you would
+     * with a Promise) gets the whole list.
      * ```javascript
-     * const paginatedList = await client.list();
-     *```
+     * const { items } = await client.list();
+     * ```
      *
-     * Asynchronous iteration is also supported. This will fetch additional pages if needed until all items are
-     * retrieved.
+     * Asynchronous iteration is also supported, and yields the environment variables one by one.
      *
      * ```javascript
      * for await (const singleItem of client.list()) {...}
      * ```
      *
-     * @returns A paginated iterator of environment variables.
+     * @returns The environment variables, awaitable as a whole list or iterable one by one.
      * @see https://docs.apify.com/api/v2/act-version-env-vars-get
      */
-    list(_options?: ActorEnvVarCollectionListOptions): Promise<ActorEnvVarListResult> & AsyncIterable<ActorEnvironmentVariable>;
+    list(): Promise<ActorEnvVarListResult> & AsyncIterable<ActorEnvironmentVariable>;
     /**
      * Creates a new environment variable for this Actor version.
      *
@@ -63,14 +62,6 @@ export declare class ActorEnvVarCollectionClient extends ResourceCollectionClien
      */
     create(actorEnvVar: ActorEnvironmentVariable): Promise<ActorEnvironmentVariable>;
 }
-/**
- * @deprecated No options are used in the current API implementation.
- * https://github.com/apify/apify-client-js/issues/799
- * @since Added in 2.1.0
- */
-export interface ActorEnvVarCollectionListOptions extends PaginationOptions {
-    desc?: boolean;
-}
 /**
  * @since Added in 2.1.0
  */

package/dist/resource_clients/actor_env_var_collection.js

@@ -42,23 +42,22 @@ export class ActorEnvVarCollectionClient extends ResourceCollectionClient {
     /**
      * Lists all environment variables of this Actor version.
      *
-     * Awaiting the return value (as you would with a Promise) will result in a single API call. The amount of fetched
-     * items in a single API call is limited.
+     * The endpoint returns every environment variable in one response, so awaiting the return value (as you would
+     * with a Promise) gets the whole list.
      * ```javascript
-     * const paginatedList = await client.list();
-     *```
+     * const { items } = await client.list();
+     * ```
      *
-     * Asynchronous iteration is also supported. This will fetch additional pages if needed until all items are
-     * retrieved.
+     * Asynchronous iteration is also supported, and yields the environment variables one by one.
      *
      * ```javascript
      * for await (const singleItem of client.list()) {...}
      * ```
      *
-     * @returns A paginated iterator of environment variables.
+     * @returns The environment variables, awaitable as a whole list or iterable one by one.
      * @see https://docs.apify.com/api/v2/act-version-env-vars-get
      */
-    list(_options = {}) {
+    list() {
         return this._listPaginated(schemas.ListOfEnvVars());
     }
     /**

package/dist/resource_clients/actor_version_collection.d.ts

@@ -1,6 +1,6 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
-import type { PaginatedList, PaginationOptions } from '../utils.js';
+import type { PaginatedList } from '../utils.js';
 import type { ActorVersion, FinalActorVersion } from './actor_version.js';
 /**
  * Client for managing the collection of Actor versions.
@@ -34,23 +34,22 @@ export declare class ActorVersionCollectionClient extends ResourceCollectionClie
     /**
      * Lists all Actor versions.
      *
-     * Awaiting the return value (as you would with a Promise) will result in a single API call. The amount of fetched
-     * items in a single API call is limited.
+     * The endpoint returns every version in one response, so awaiting the return value (as you would with a Promise)
+     * gets the whole list.
      * ```javascript
-     * const paginatedList = await client.list();
-     *```
+     * const { items } = await client.list();
+     * ```
      *
-     * Asynchronous iteration is also supported. This will fetch additional pages if needed until all items are
-     * retrieved.
+     * Asynchronous iteration is also supported, and yields the versions one by one.
      *
      * ```javascript
      * for await (const singleItem of client.list()) {...}
      * ```
      *
-     * @returns A paginated iterator of Actor versions.
+     * @returns The Actor versions, awaitable as a whole list or iterable one by one.
      * @see https://docs.apify.com/api/v2/act-versions-get
      */
-    list(_options?: ActorVersionCollectionListOptions): Promise<ActorVersionListResult> & AsyncIterable<FinalActorVersion>;
+    list(): Promise<ActorVersionListResult> & AsyncIterable<FinalActorVersion>;
     /**
      * Creates a new Actor version.
      *
@@ -60,11 +59,4 @@ export declare class ActorVersionCollectionClient extends ResourceCollectionClie
      */
     create(actorVersion: ActorVersion): Promise<FinalActorVersion>;
 }
-/**
- * @deprecated No options are used in the current API implementation.
- * https://github.com/apify/apify-client-js/issues/799
- */
-export interface ActorVersionCollectionListOptions extends PaginationOptions {
-    desc?: boolean;
-}
 export type ActorVersionListResult = Pick<PaginatedList<FinalActorVersion>, 'total' | 'items'>;

package/dist/resource_clients/actor_version_collection.js

@@ -39,23 +39,22 @@ export class ActorVersionCollectionClient extends ResourceCollectionClient {
     /**
      * Lists all Actor versions.
      *
-     * Awaiting the return value (as you would with a Promise) will result in a single API call. The amount of fetched
-     * items in a single API call is limited.
+     * The endpoint returns every version in one response, so awaiting the return value (as you would with a Promise)
+     * gets the whole list.
      * ```javascript
-     * const paginatedList = await client.list();
-     *```
+     * const { items } = await client.list();
+     * ```
      *
-     * Asynchronous iteration is also supported. This will fetch additional pages if needed until all items are
-     * retrieved.
+     * Asynchronous iteration is also supported, and yields the versions one by one.
      *
      * ```javascript
      * for await (const singleItem of client.list()) {...}
      * ```
      *
-     * @returns A paginated iterator of Actor versions.
+     * @returns The Actor versions, awaitable as a whole list or iterable one by one.
      * @see https://docs.apify.com/api/v2/act-versions-get
      */
-    list(_options = {}) {
+    list() {
         return this._listPaginated(schemas.ListOfVersions());
     }
     /**

package/dist/resource_clients/request_queue.d.ts

@@ -346,11 +346,6 @@ export type RequestQueueListRequestsFilter = 'locked' | 'pending';
  */
 export interface RequestQueueClientListRequestsOptions {
     limit?: number;
-    /**
-     * Using id of request that does not exist in request queue leads to unpredictable results.
-     * @deprecated Use `cursor` for pagination instead.
-     */
-    exclusiveStartId?: string;
     /**
      * @since Added in 2.23.2
      */
@@ -367,8 +362,6 @@ export interface RequestQueueClientListRequestsOptions {
 export interface RequestQueueClientPaginateRequestsOptions {
     limit?: number;
     maxPageLimit?: number;
-    /** @deprecated Use `cursor` for pagination instead. */
-    exclusiveStartId?: string;
     /**
      * @since Added in 2.23.2
      */

package/dist/resource_clients/request_queue.js

@@ -4,7 +4,7 @@ import log from '@apify/log';
 import { MEDIUM_TIMEOUT_MILLIS, ResourceClient, SMALL_TIMEOUT_MILLIS } from '../base/resource_client.js';
 import { ResponseValidationError } from '../response_validation_error.js';
 import * as schemas from '../schemas.js';
-import { anyObjectSchema, cast, catchNotFoundOrThrow, isNonArrayObject, mutuallyExclusive, parseArgument, parseDateFields, parseResponse, RequestQueuePaginationIterator, sliceArrayByByteLength, } from '../utils.js';
+import { anyObjectSchema, cast, catchNotFoundOrThrow, isNonArrayObject, parseArgument, parseDateFields, parseResponse, RequestQueuePaginationIterator, sliceArrayByByteLength, } from '../utils.js';
 const DEFAULT_PARALLEL_BATCH_ADD_REQUESTS = 5;
 const DEFAULT_UNPROCESSED_RETRIES_BATCH_ADD_REQUESTS = 3;
 const DEFAULT_MIN_DELAY_BETWEEN_UNPROCESSED_REQUESTS_RETRIES_MILLIS = 500;
@@ -35,23 +35,17 @@ const prolongRequestLockOptionsSchema = z.strictObject({
     forefront: z.boolean().optional(),
 });
 const requestFilterSchema = z.array(z.enum(['locked', 'pending'])).min(1);
-const listRequestsOptionsSchema = z
-    .strictObject({
+const listRequestsOptionsSchema = z.strictObject({
     limit: z.number().min(0).optional(),
-    exclusiveStartId: z.string().optional(),
     cursor: z.string().optional(),
     filter: requestFilterSchema.optional(),
-})
-    .refine(...mutuallyExclusive('exclusiveStartId', 'cursor'));
-const paginateRequestsOptionsSchema = z
-    .strictObject({
+});
+const paginateRequestsOptionsSchema = z.strictObject({
     limit: z.number().min(0).optional(),
     maxPageLimit: z.number().default(DEFAULT_REQUEST_QUEUE_REQUEST_PAGE_LIMIT),
-    exclusiveStartId: z.string().optional(),
     cursor: z.string().optional(),
     filter: requestFilterSchema.optional(),
-})
-    .refine(...mutuallyExclusive('exclusiveStartId', 'cursor'));
+});
 /**
  * Client for managing a specific Request queue.
  *
@@ -589,8 +583,6 @@ export class RequestQueueClient extends ResourceClient {
                 const newOptions = {
                     ...parsed,
                     limit: remainingItems,
-                    // remove original exclusiveStartId, if there was any, and use cursor-based pagination
-                    exclusiveStartId: undefined,
                     cursor: currentPage.nextCursor,
                 };
                 currentPage = await getPaginatedList(newOptions);
@@ -644,11 +636,10 @@ export class RequestQueueClient extends ResourceClient {
      * @since Added in 2.5.1
      */
     paginateRequests(options = {}) {
-        const { limit, exclusiveStartId, cursor, filter, maxPageLimit } = parseArgument(options, paginateRequestsOptionsSchema, 'RequestQueueClientPaginateRequestsOptions');
+        const { limit, cursor, filter, maxPageLimit } = parseArgument(options, paginateRequestsOptionsSchema, 'RequestQueueClientPaginateRequestsOptions');
         return new RequestQueuePaginationIterator({
             getPage: async (pageOptions) => this.listRequests({ ...pageOptions, filter }),
             limit,
-            exclusiveStartId,
             cursor,
             maxPageLimit,
         });

package/dist/utils.d.ts

@@ -86,13 +86,12 @@ export declare function getVersionData(): {
     version: string;
 };
 /**
- * Helper class to create async iterators from paginated list endpoints with exclusive start key.
+ * Helper class to create async iterators from paginated list endpoints.
  */
 export declare class RequestQueuePaginationIterator {
     private readonly maxPageLimit;
     private readonly getPage;
     private readonly limit?;
-    private readonly exclusiveStartId?;
     private readonly cursor?;
     constructor(options: RequestQueuePaginationIteratorOptions);
     [Symbol.asyncIterator](): AsyncIterator<RequestQueueClientListRequestsResult>;
@@ -108,7 +107,6 @@ export interface RequestQueuePaginationIteratorOptions {
     maxPageLimit: number;
     getPage: (opts: RequestQueueClientListRequestsOptions) => Promise<RequestQueueClientListRequestsResult>;
     limit?: number;
-    exclusiveStartId?: string;
     cursor?: string;
 }
 /**
@@ -195,12 +193,6 @@ export type DistributiveOptional<T, K extends keyof T> = T extends any ? Omit<T,
  * Adds query parameters to a given URL based on the provided options object.
  */
 export declare function applyQueryParamsToUrl(url: URL, options?: Record<string, string | number | boolean | string[] | undefined>): URL;
-/**
- * Builds a `[check, message]` pair to spread into `.refine()`, asserting that at most one of `keys`
- * is present. Pass the options interface as `T`, so that a misspelled key is a type error.
- * @internal
- */
-export declare const mutuallyExclusive: <T extends object>(...keys: (keyof T & string)[]) => [(value: T) => boolean, string];
 /**
  * Percent-encodes a caller-supplied URL path segment so it cannot restructure the request path.
  *

package/dist/utils.js

@@ -231,25 +231,21 @@ export function getVersionData() {
     return packageJson;
 }
 /**
- * Helper class to create async iterators from paginated list endpoints with exclusive start key.
+ * Helper class to create async iterators from paginated list endpoints.
  */
 export class RequestQueuePaginationIterator {
     maxPageLimit;
     getPage;
     limit;
-    exclusiveStartId;
     cursor;
     constructor(options) {
         this.maxPageLimit = options.maxPageLimit;
         this.limit = options.limit;
-        this.exclusiveStartId = options.exclusiveStartId;
         this.cursor = options.cursor;
         this.getPage = options.getPage;
     }
     async *[Symbol.asyncIterator]() {
         let nextCursor = this.cursor;
-        // allow using exclusiveStartId for the first page, but then we'll delete it to avoid using it for any later page
-        let nextExclusiveStartId = this.exclusiveStartId;
         let iterateItemCount = 0;
         while (true) {
             const pageLimit = this.limit
@@ -258,7 +254,6 @@ export class RequestQueuePaginationIterator {
             const page = await this.getPage({
                 limit: pageLimit,
                 cursor: nextCursor,
-                exclusiveStartId: nextExclusiveStartId,
             });
             // There are no more pages to iterate
             if (page.items.length === 0)
@@ -269,7 +264,6 @@ export class RequestQueuePaginationIterator {
             if ((this.limit && iterateItemCount >= this.limit) || !page.nextCursor)
                 return;
             nextCursor = page.nextCursor;
-            nextExclusiveStartId = undefined; // see comment above - delete it for any page after the first one, and paginate with cursor
         }
     }
 }
@@ -309,15 +303,6 @@ export function applyQueryParamsToUrl(url, options) {
     }
     return url;
 }
-/**
- * Builds a `[check, message]` pair to spread into `.refine()`, asserting that at most one of `keys`
- * is present. Pass the options interface as `T`, so that a misspelled key is a type error.
- * @internal
- */
-export const mutuallyExclusive = (...keys) => [
-    (value) => keys.filter((key) => typeof value[key] !== 'undefined').length <= 1,
-    `At most one of the following fields is allowed: ${keys.join(', ')}`,
-];
 const pathSegmentSchema = z
     .string()
     .nonempty()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.6",
+  "version": "3.0.0-beta.7",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.0.0"