apify-client 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/resource_clients/run.js

@@ -1,34 +1,52 @@
 import { z } from 'zod';
+import { ACT_JOB_TERMINAL_STATUSES } from '@apify/consts';
 import { LEVELS, Log } from '@apify/log';
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
-import { anyObjectSchema, isNode, parseArgument, parseResponse } from '../utils.js';
+import { optionalSignalSchema, optionalTimeoutSchema, timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
+import { runtime } from '#runtime';
+import { anyObjectSchema, paginationOptionsShape, parseArgument, parseResponse, SCANNED_COUNT } from '../utils.js';
 import { DatasetClient } from './dataset.js';
 import { KeyValueStoreClient } from './key_value_store.js';
 import { LogClient, LoggerActorRedirect, StreamedLog } from './log.js';
 import { RequestQueueClient } from './request_queue.js';
 const RUN_CHARGE_IDEMPOTENCY_HEADER = 'idempotency-key';
-const getOptionsSchema = z.strictObject({ waitForFinish: z.number().optional() });
-const abortOptionsSchema = z.strictObject({ gracefully: z.boolean().optional() });
+const getOptionsSchema = z.strictObject({ waitForFinish: z.number().optional(), ...timeoutOptionsShape });
+const abortOptionsSchema = z.strictObject({ gracefully: z.boolean().optional(), ...timeoutOptionsShape });
 const targetActorIdSchema = z.string();
 const metamorphOptionsSchema = z.strictObject({
     contentType: z.string().optional(),
     build: z.string().optional(),
+    ...timeoutOptionsShape,
 });
 const resurrectOptionsSchema = z.strictObject({
     build: z.string().optional(),
     memory: z.number().optional(),
-    timeout: z.number().optional(),
+    runTimeoutSecs: z.number().optional(),
     maxItems: z.number().optional(),
     maxTotalChargeUsd: z.number().optional(),
     restartOnError: z.boolean().optional(),
+    ...timeoutOptionsShape,
 });
 const chargeOptionsSchema = z.strictObject({
     eventName: z.string(),
     count: z.number().default(1),
     idempotencyKey: z.string().optional(),
+    ...timeoutOptionsShape,
 });
-const waitForFinishOptionsSchema = z.strictObject({ waitSecs: z.number().optional() });
+const waitForFinishOptionsSchema = z.strictObject({ waitSecs: z.number().optional(), ...timeoutOptionsShape });
+const iterateDatasetItemsOptionsSchema = z.strictObject({
+    clean: z.boolean().optional(),
+    fields: z.array(z.string()).optional(),
+    omit: z.array(z.string()).optional(),
+    ...paginationOptionsShape,
+    skipEmpty: z.boolean().optional(),
+    skipHidden: z.boolean().optional(),
+    unwind: z.array(z.string()).optional(),
+    pollIntervalSecs: z.number().min(0).optional(),
+    ...timeoutOptionsShape,
+});
+const DEFAULT_ITERATE_CHUNK_SIZE = 1000;
 /**
  * Client for managing a specific Actor run.
  *
@@ -67,6 +85,8 @@ export class RunClient extends ResourceClient {
      *
      * @param options - Get options
      * @param options.waitForFinish - Maximum time to wait (in seconds, max 60s) for the run to finish on the API side before returning. Default is 0 (returns immediately).
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`, extended to cover `waitForFinish`
+     * when the API is asked to hold the response.
      * @returns The ActorRun object, or `undefined` if it does not exist
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -81,14 +101,15 @@ export class RunClient extends ResourceClient {
      * ```
      */
     async get(options = {}) {
-        const parsed = parseArgument(options, getOptionsSchema, 'RunGetOptions');
-        return this._get(schemas.Run(), parsed);
+        const { timeoutSecs, signal, ...params } = parseArgument(options, getOptionsSchema, 'RunGetOptions');
+        return this.getResource(schemas.Run(), params, this.timeoutForWaitForFinish(timeoutSecs, 'short', params.waitForFinish), signal);
     }
     /**
      * Aborts the Actor run.
      *
      * @param options - Abort options
      * @param options.gracefully - If `true`, the Actor run will abort gracefully - it can send status messages and perform cleanup. Default is `false` (immediate abort).
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The updated ActorRun object with `ABORTING` or `ABORTED` status
      * @see https://docs.apify.com/api/v2/actor-run-abort-post
      *
@@ -102,22 +123,27 @@ export class RunClient extends ResourceClient {
      * ```
      */
     async abort(options = {}) {
-        const parsed = parseArgument(options, abortOptionsSchema, 'RunAbortOptions');
+        const { timeoutSecs = 'medium', signal, ...params } = parseArgument(options, abortOptionsSchema, 'RunAbortOptions');
         const response = await this.httpClient.call({
-            url: this._url('abort'),
+            url: this.buildUrl('abort'),
             method: 'POST',
-            params: this._params(parsed),
+            params: this.buildParams(params),
+            timeoutSecs,
+            signal,
         });
         return parseResponse(response, schemas.Run());
     }
     /**
      * Deletes the Actor run.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/actor-run-delete
      * @since Added in 2.8.1
      */
-    async delete() {
-        return this._delete();
+    async delete(options = {}) {
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.deleteResource(timeoutSecs, signal);
     }
     /**
      * Transforms the Actor run into a run of another Actor (metamorph).
@@ -127,10 +153,11 @@ export class RunClient extends ResourceClient {
      * This is useful for chaining Actor executions or implementing complex workflows.
      *
      * @param targetActorId - ID or username/name of the target Actor
-     * @param input - Input for the target Actor. Can be any JSON-serializable value.
+     * @param input - Input for the target Actor: an object or array serialized to JSON, or raw bytes sent as they
+     *                are. Omit it to metamorph without input.
      * @param options - Metamorph options
      * @param options.build - Tag or number of the target Actor's build to run. Default is the target Actor's default build.
-     * @param options.contentType - Content type of the input. If specified, input must be a string or Buffer.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The metamorphed ActorRun object (same ID, but now running the target Actor)
      * @see https://docs.apify.com/api/v2/actor-run-metamorph-post
      *
@@ -146,23 +173,21 @@ export class RunClient extends ResourceClient {
      */
     async metamorph(targetActorId, input, options = {}) {
         parseArgument(targetActorId, targetActorIdSchema);
-        // input can be anything, pointless to validate
         const parsed = parseArgument(options, metamorphOptionsSchema, 'RunMetamorphOptions');
-        const safeTargetActorId = this._toSafeId(targetActorId);
+        const safeTargetActorId = this.toSafeId(targetActorId);
         const params = {
             targetActorId: safeTargetActorId,
             build: parsed.build,
         };
         const request = {
-            url: this._url('metamorph'),
+            url: this.buildUrl('metamorph'),
             method: 'POST',
             data: input,
-            params: this._params(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
-            // TODO: remove this ts-expect-error once we have defined custom Apify axios configs
-            // @ts-expect-error Custom Apify property
+            params: this.buildParams(params),
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
+            timeoutSecs: parsed.timeoutSecs ?? 'medium',
+            signal: parsed.signal,
         };
         if (parsed.contentType) {
             request.headers = {
@@ -179,6 +204,8 @@ export class RunClient extends ResourceClient {
      * This can be useful to recover from certain errors or to force the Actor to restart
      * with a fresh environment.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The updated ActorRun object
      * @see https://docs.apify.com/api/v2/actor-run-reboot-post
      *
@@ -188,10 +215,13 @@ export class RunClient extends ResourceClient {
      * ```
      * @since Added in 2.8.0
      */
-    async reboot() {
+    async reboot(options = {}) {
+        const { timeoutSecs = 'medium', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
         const request = {
-            url: this._url('reboot'),
+            url: this.buildUrl('reboot'),
             method: 'POST',
+            timeoutSecs,
+            signal,
         };
         const response = await this.httpClient.call(request);
         return parseResponse(response, schemas.Run());
@@ -203,6 +233,8 @@ export class RunClient extends ResourceClient {
      * @param newFields.statusMessage - Custom status message to display (e.g., "Processing page 10/100")
      * @param newFields.isStatusMessageTerminal - If `true`, the status message is final and won't be overwritten. Default is `false`.
      * @param newFields.generalAccess - General resource access level ('FOLLOW_USER_SETTING', 'ANYONE_WITH_ID_CAN_READ' or 'RESTRICTED')
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated ActorRun object
      *
      * @example
@@ -214,9 +246,10 @@ export class RunClient extends ResourceClient {
      * ```
      * @since Added in 2.6.0
      */
-    async update(newFields) {
+    async update(newFields, options = {}) {
         parseArgument(newFields, anyObjectSchema);
-        return this._update(schemas.Run(), newFields);
+        const { timeoutSecs = 'short', signal } = parseArgument(options, timeoutOptionsSchema, 'TimeoutOptions');
+        return this.updateResource(schemas.Run(), newFields, timeoutSecs, signal);
     }
     /**
      * Resurrects a finished Actor run, starting it again with the same settings.
@@ -227,10 +260,11 @@ export class RunClient extends ResourceClient {
      * @param options - Resurrection options (override original run settings)
      * @param options.build - Tag or number of the build to use. If not provided, uses the original run's build.
      * @param options.memory - Memory in megabytes. If not provided, uses the original run's memory.
-     * @param options.timeout - Timeout in seconds. If not provided, uses the original run's timeout.
+     * @param options.runTimeoutSecs - Timeout for the resurrected run in seconds. If not provided, uses the original run's timeout.
      * @param options.maxItems - Maximum number of dataset items (pay-per-result Actors).
      * @param options.maxTotalChargeUsd - Maximum cost in USD (pay-per-event Actors).
      * @param options.restartOnError - Whether to restart on error.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
      * @returns The new (resurrected) ActorRun object
      * @see https://docs.apify.com/api/v2/post-resurrect-run
      *
@@ -242,11 +276,14 @@ export class RunClient extends ResourceClient {
      * ```
      */
     async resurrect(options = {}) {
-        const parsed = parseArgument(options, resurrectOptionsSchema, 'RunResurrectOptions');
+        const { timeoutSecs = 'medium', signal, runTimeoutSecs, ...params } = parseArgument(options, resurrectOptionsSchema, 'RunResurrectOptions');
         const response = await this.httpClient.call({
-            url: this._url('resurrect'),
+            url: this.buildUrl('resurrect'),
             method: 'POST',
-            params: this._params(parsed),
+            // The API's `timeout` parameter bounds the run, not the request.
+            params: this.buildParams({ ...params, timeout: runTimeoutSecs }),
+            timeoutSecs,
+            signal,
         });
         return parseResponse(response, schemas.Run());
     }
@@ -257,17 +294,18 @@ export class RunClient extends ResourceClient {
      * @param options.eventName - **Required.** Name of the event to charge for.
      * @param options.count - Number of times to charge the event. Default is 1.
      * @param options.idempotencyKey - Optional key to ensure the charge is not duplicated. If not provided, one is auto-generated.
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns Empty response object.
      * @see https://docs.apify.com/api/v2/post-charge-run
      * @since Added in 2.11.0
      */
     async charge(options) {
-        const { eventName, count, idempotencyKey: providedIdempotencyKey, } = parseArgument(options, chargeOptionsSchema, 'RunChargeOptions');
+        const { eventName, count, idempotencyKey: providedIdempotencyKey, timeoutSecs = 'short', signal, } = parseArgument(options, chargeOptionsSchema, 'RunChargeOptions');
         /** To avoid duplicates during the same milisecond, doesn't need to by crypto-secure. */
         const randomSuffix = (Math.random() + 1).toString(36).slice(3, 8);
         const idempotencyKey = providedIdempotencyKey ?? `${this.id}-${eventName}-${Date.now()}-${randomSuffix}`;
         const request = {
-            url: this._url('charge'),
+            url: this.buildUrl('charge'),
             method: 'POST',
             data: {
                 eventName,
@@ -276,6 +314,8 @@ export class RunClient extends ResourceClient {
             headers: {
                 [RUN_CHARGE_IDEMPOTENCY_HEADER]: idempotencyKey,
             },
+            timeoutSecs,
+            signal,
         };
         const response = await this.httpClient.call(request);
         return response;
@@ -293,7 +333,8 @@ export class RunClient extends ResourceClient {
      *
      * @param options - Wait options
      * @param options.waitSecs - Maximum time to wait for the run to finish, in seconds. If the limit is reached, the returned promise resolves to a run object that will have status `READY` or `RUNNING`. If omitted, waits indefinitely.
-     * @returns The ActorRun object (finished or still running if timeout was reached)
+     * @param options.timeoutSecs - Timeout for each polling API request. Default is `'noTimeout'`.
+     * @returns The ActorRun object (finished or still running if the timeout was reached)
      *
      * @example
      * ```javascript
@@ -310,11 +351,13 @@ export class RunClient extends ResourceClient {
      */
     async waitForFinish(options = {}) {
         const parsed = parseArgument(options, waitForFinishOptionsSchema, 'RunWaitForFinishOptions');
-        return this._waitForFinish(schemas.Run(), parsed);
+        return this.waitForJobFinish(schemas.Run(), parsed);
     }
     /**
      * Returns a client for the default dataset of this Actor run.
      *
+     * A 404 from this client throws an `ApifyApiError`, since the run itself may be what is missing.
+     *
      * @returns A client for accessing the run's default dataset
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -325,13 +368,16 @@ export class RunClient extends ResourceClient {
      * ```
      */
     dataset() {
-        return new DatasetClient(this._subResourceOptions({
+        return new DatasetClient(this.subResourceOptions({
             resourcePath: 'dataset',
         }));
     }
     /**
      * Returns a client for the default key-value store of this Actor run.
      *
+     * `get()` and `delete()` throw an `ApifyApiError` on a 404, since the run itself may be what is missing. Record
+     * lookups such as `getRecord()` read a 404 as a missing record.
+     *
      * @returns A client for accessing the run's default key-value store
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -342,13 +388,16 @@ export class RunClient extends ResourceClient {
      * ```
      */
     keyValueStore() {
-        return new KeyValueStoreClient(this._subResourceOptions({
+        return new KeyValueStoreClient(this.subResourceOptions({
             resourcePath: 'key-value-store',
         }));
     }
     /**
      * Returns a client for the default Request queue of this Actor run.
      *
+     * `get()` and `delete()` throw an `ApifyApiError` on a 404, since the run itself may be what is missing.
+     * `getRequest()` reads a 404 as a missing request.
+     *
      * @returns A client for accessing the run's default Request queue
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -359,13 +408,15 @@ export class RunClient extends ResourceClient {
      * ```
      */
     requestQueue() {
-        return new RequestQueueClient(this._subResourceOptions({
+        return new RequestQueueClient(this.subResourceOptions({
             resourcePath: 'request-queue',
         }));
     }
     /**
      * Returns a client for accessing the log of this Actor run.
      *
+     * A 404 from this client throws an `ApifyApiError`, since the run itself may be what is missing.
+     *
      * @returns A client for accessing the run's log
      * @see https://docs.apify.com/api/v2/actor-run-get
      *
@@ -377,32 +428,121 @@ export class RunClient extends ResourceClient {
      * ```
      */
     log() {
-        return new LogClient(this._subResourceOptions({
+        return new LogClient(this.subResourceOptions({
             resourcePath: 'log',
         }));
     }
     /**
      * Get StreamedLog for convenient streaming of the run log and their redirection.
+     *
+     * @param options - Streaming options
+     * @param options.toLog - Log instance to redirect the run log to. Use `'default'` for a preconfigured one, or `null` to disable the redirection.
+     * @param options.fromStart - If `true`, the log is streamed from its beginning. Default is `true`.
+     * @param options.timeoutSecs - Timeout for the API requests that fetch the run and its Actor. Default is `'long'`.
      * @since Added in 2.20.0
      */
     async getStreamedLog(options = {}) {
-        const { fromStart = true } = options;
+        parseArgument(options.timeoutSecs, optionalTimeoutSchema);
+        parseArgument(options.signal, optionalSignalSchema);
+        const { fromStart = true, timeoutSecs = 'long', signal } = options;
         let { toLog } = options;
-        if (toLog === null || !isNode()) {
+        if (toLog === null || !runtime.isNode) {
             // Explicitly no logging or not in Node.js
             return undefined;
         }
         if (toLog === undefined || toLog === 'default') {
             // Create default StreamedLog
             // Get actor name and run id
-            const runData = await this.get();
+            const runData = await this.get({ timeoutSecs, signal });
             const runId = runData?.id ?? '';
             const actorId = runData?.actId ?? '';
-            const actorData = (await this.apifyClient.actor(actorId).get()) || { name: '' };
+            // `apifyClient.actor()` rejects an empty ID, which is what a run that could not be read leaves here.
+            const actorData = actorId ? await this.apifyClient.actor(actorId).get({ timeoutSecs, signal }) : undefined;
             const actorName = actorData?.name ?? '';
             const name = [actorName, `runId:${runId}`].filter(Boolean).join(' ');
             toLog = new Log({ level: LEVELS.DEBUG, prefix: `${name} -> `, logger: new LoggerActorRedirect() });
         }
-        return new StreamedLog({ logClient: this.log(), toLog, fromStart });
+        return new StreamedLog({ logClient: this.log(), toLog, fromStart, signal });
+    }
+    /**
+     * Iterates over the items of the run's default dataset while the run is still producing them.
+     *
+     * While the run has not finished, each poll yields the rows below the dataset's `itemCount` and then waits up to
+     * `pollIntervalSecs` for the run to finish, so the last rows are read as soon as it does. Each page is requested
+     * with a `limit` that ends at `itemCount`, so it covers exactly the rows it asks for, whatever the filters or
+     * `unwind` do to the items. `itemCount` lags a few seconds behind
+     * the pushed items, so once the run reaches a terminal status, the rows past it are read a page at a time until
+     * none are left, and the iterator returns. On a `lastRun()` client, the iterator sticks to the run that its first
+     * request resolves to.
+     *
+     * @param options - Iteration options
+     * @param options.offset - Number of rows to skip from the beginning. Default is 0.
+     * @param options.limit - Maximum number of dataset rows to scan. Fewer items are yielded when filters drop some,
+     * more when `unwind` splits a row into several. Default is no limit.
+     * @param options.clean - If `true`, returns only non-empty items and skips hidden fields. Default is `false`.
+     * @param options.fields - Array of field names to include in the results. Omits all other fields.
+     * @param options.omit - Array of field names to exclude from the results.
+     * @param options.unwind - Array of field names to unwind. Each array value creates a separate item.
+     * @param options.skipEmpty - If `true`, skips empty items. Default is `false`.
+     * @param options.skipHidden - If `true`, skips hidden fields (fields starting with `#`). Default is `false`.
+     * @param options.chunkSize - Maximum number of dataset rows requested per API call. Default is 1000.
+     * @param options.pollIntervalSecs - How long to wait for the run to finish between polls, in seconds. Default is 5.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'long'`.
+     * @returns An async iterable of the dataset items
+     * @see https://docs.apify.com/api/v2/dataset-items-get
+     *
+     * @example
+     * ```javascript
+     * for await (const item of client.run('run-id').iterateDatasetItems()) {
+     *     console.log(item);
+     * }
+     * ```
+     */
+    async *iterateDatasetItems(options = {}) {
+        const { offset, limit, chunkSize, pollIntervalSecs = 5, timeoutSecs = 'long', signal, ...itemOptions } = parseArgument(options, iterateDatasetItemsOptionsSchema, 'RunIterateDatasetItemsOptions');
+        const pageSize = chunkSize || DEFAULT_ITERATE_CHUNK_SIZE;
+        let position = offset ?? 0;
+        const end = limit ? position + limit : undefined;
+        let run = await this.get({ timeoutSecs, signal });
+        // A `lastRun()` client resolves `runs/last` on each request, so a newer run would swap the dataset mid-iteration.
+        const runClient = run && run.id !== this.id ? this.apifyClient.run(run.id) : this;
+        const datasetClient = runClient.dataset();
+        const listPage = async (pageOffset, pageLimit) => datasetClient.listItems({ ...itemOptions, offset: pageOffset, limit: pageLimit, timeoutSecs, signal });
+        while (true) {
+            const isFinished = !run || ACT_JOB_TERMINAL_STATUSES.includes(run.status);
+            const dataset = await datasetClient.get({ timeoutSecs, signal });
+            let itemCount = dataset?.itemCount ?? 0;
+            if (end !== undefined)
+                itemCount = Math.min(itemCount, end);
+            while (position < itemCount) {
+                const pageLimit = Math.min(pageSize, itemCount - position);
+                const page = await listPage(position, pageLimit);
+                yield* page.items;
+                position += pageLimit;
+            }
+            if (end !== undefined && position >= end)
+                return;
+            if (isFinished)
+                break;
+            run = await runClient.waitForFinish({ waitSecs: pollIntervalSecs, timeoutSecs, signal });
+        }
+        const { clean, skipEmpty, unwind } = itemOptions;
+        while (true) {
+            const pageLimit = end !== undefined ? Math.min(pageSize, end - position) : pageSize;
+            const page = await listPage(position, pageLimit);
+            yield* page.items;
+            // Only an empty page marks the end, as filters can shorten a full one. A page that `clean`, `skipEmpty` or
+            // `unwind` emptied past a lagging `itemCount` reports no scanned rows either, so a plain read checks.
+            const isEmpty = page.items.length === 0 && !page[SCANNED_COUNT];
+            if (isEmpty &&
+                (!(clean || skipEmpty || unwind?.length) ||
+                    (await datasetClient.listItems({ offset: position, limit: 1, timeoutSecs, signal })).items
+                        .length === 0)) {
+                return;
+            }
+            position += pageLimit;
+            if (end !== undefined && position >= end)
+                return;
+        }
     }
 }

package/dist/resource_clients/run_collection.d.ts

@@ -1,6 +1,7 @@
 import { ACTOR_JOB_STATUSES } from '@apify/consts';
 import type { ApiClientOptionsWithOptionalResourcePath } from '../base/api_client.js';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { PaginatedIterator, PaginationOptions } from '../utils.js';
 import type { ActorRunListItem } from './actor.js';
 /**
@@ -46,12 +47,13 @@ export declare class RunCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and filtering options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of Actor runs.
      * @see https://docs.apify.com/api/v2/actor-runs-get
      */
     list(options?: RunCollectionListOptions): PaginatedIterator<ActorRunListItem>;
 }
-export interface RunCollectionListOptions extends PaginationOptions {
+export interface RunCollectionListOptions extends PaginationOptions, TimeoutOptions {
     desc?: boolean;
     status?: (typeof ACTOR_JOB_STATUSES)[keyof typeof ACTOR_JOB_STATUSES] | (typeof ACTOR_JOB_STATUSES)[keyof typeof ACTOR_JOB_STATUSES][];
     /**

package/dist/resource_clients/run_collection.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { ACTOR_JOB_STATUSES } from '@apify/consts';
 import { ResourceCollectionClient } from '../base/resource_collection_client.js';
 import * as schemas from '../schemas.js';
+import { timeoutOptionsShape } from '../timeouts.js';
 import { paginationOptionsShape, parseArgument } from '../utils.js';
 const jobStatusSchema = z.enum(ACTOR_JOB_STATUSES);
 const listOptionsSchema = z.strictObject({
@@ -10,6 +11,7 @@ const listOptionsSchema = z.strictObject({
     status: z.union([jobStatusSchema, z.array(jobStatusSchema)]).optional(),
     startedBefore: z.union([z.date(), z.string()]).optional(),
     startedAfter: z.union([z.date(), z.string()]).optional(),
+    ...timeoutOptionsShape,
 });
 /**
  * Client for managing the collection of Actor runs.
@@ -59,11 +61,12 @@ export class RunCollectionClient extends ResourceCollectionClient {
      * ```
      *
      * @param options - Pagination and filtering options.
+     * @param options.timeoutSecs - Timeout for each API request. Default is `'medium'`.
      * @returns A paginated iterator of Actor runs.
      * @see https://docs.apify.com/api/v2/actor-runs-get
      */
     list(options = {}) {
         const parsed = parseArgument(options, listOptionsSchema, 'RunCollectionListOptions');
-        return this._listPaginated(schemas.ListOfRuns(), parsed);
+        return this.listResourcesPaginated(schemas.ListOfRuns(), parsed, 'medium');
     }
 }

package/dist/resource_clients/schedule.d.ts

@@ -1,6 +1,7 @@
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
 import type { Schedule, ScheduleAction, ScheduleInvoked } from '../models.js';
+import type { TimeoutOptions } from '../timeouts.js';
 import type { DistributiveOptional } from '../utils.js';
 export type { Schedule, ScheduleAction, ScheduleActionRunActor, ScheduleActionRunActorTask, ScheduledActorRunInput, ScheduledActorRunOptions, ScheduleInvoked, } from '../models.js';
 export { ScheduleActions } from '../models.js';
@@ -35,31 +36,39 @@ export declare class ScheduleClient extends ResourceClient {
     /**
      * Retrieves the schedule.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The schedule object, or `undefined` if it does not exist.
      * @see https://docs.apify.com/api/v2/schedule-get
      */
-    get(): Promise<Schedule | undefined>;
+    get(options?: TimeoutOptions): Promise<Schedule | undefined>;
     /**
      * Updates the schedule with the specified fields.
      *
      * @param newFields - Fields to update.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @returns The updated schedule object.
      * @see https://docs.apify.com/api/v2/schedule-put
      */
-    update(newFields: ScheduleCreateOrUpdateData): Promise<Schedule>;
+    update(newFields: ScheduleCreateOrUpdateData, options?: TimeoutOptions): Promise<Schedule>;
     /**
      * Deletes the schedule.
      *
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'short'`.
      * @see https://docs.apify.com/api/v2/schedule-delete
      */
-    delete(): Promise<void>;
+    delete(options?: TimeoutOptions): Promise<void>;
     /**
      * Retrieves the schedule's log.
      *
-     * @returns The schedule log, one entry per invocation, or `undefined` if the schedule does not exist.
+     * @param options - Request options
+     * @param options.timeoutSecs - Timeout for the API request. Default is `'medium'`.
+     * @returns The schedule log, one entry per invocation.
      * @see https://docs.apify.com/api/v2/schedule-log-get
      */
-    getLog(): Promise<ScheduleInvoked[] | undefined>;
+    getLog(options?: TimeoutOptions): Promise<ScheduleInvoked[]>;
 }
 /**
  * Data for creating or updating a Schedule.