apify 4.0.0-beta.58 → 4.0.0-beta.60

package/dist/actor.d.ts

@@ -1,7 +1,7 @@
 import type { EventManager, EventTypeName, RecordOptions, UseStateOptions } from '@crawlee/core';
 import { Dataset, KeyValueStore, RequestQueue } from '@crawlee/core';
 import type { Awaitable, Dictionary, StorageBackend } from '@crawlee/types';
-import type { ActorCallOptions, ActorInput, ActorStartOptions, ApifyClientOptions, RunAbortOptions, TaskCallOptions, WebhookResource, WebhookEventType } from 'apify-client';
+import type { ActorCallOptions, ActorInput, ActorStartOptions, ApifyClientOptions, RunAbortOptions, RunResurrectOptions, TaskCallOptions, TaskStartOptions, WebhookResource, WebhookEventType } from 'apify-client';
 import { ApifyClient, Run as ClientActorRun } from 'apify-client';
 import { type ACTOR_PERMISSION_LEVEL } from '@apify/consts';
 import type { RequestQueueAccessMode } from './apify_request_queue_backend.js';
@@ -228,6 +228,10 @@ export interface StartOptions extends Omit<ActorStartOptions, 'waitForFinish' |
 }
 export interface CallTaskOptions extends Omit<TaskCallOptions, 'runTimeoutSecs'>, Token, Timeout {
 }
+export interface ResurrectOptions extends Omit<RunResurrectOptions, 'runTimeoutSecs'>, Token, Timeout {
+}
+export interface StartTaskOptions extends Omit<TaskStartOptions, 'waitForFinish' | 'runTimeoutSecs'>, Token, Timeout {
+}
 export interface AbortOptions extends RunAbortOptions, Token {
     /** Exit with given status message */
     statusMessage?: string;
@@ -492,6 +496,25 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * @ignore
      */
     abort(runId: string, options?: AbortOptions): Promise<ClientActorRun>;
+    /**
+     * Resurrects a finished Actor run on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable).
+     *
+     * Only finished runs (SUCCEEDED, FAILED, ABORTED or TIMED-OUT) can be resurrected. The run goes back to the RUNNING
+     * status and keeps its default storages. Options you leave out keep the values of the original run.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actors, read the
+     * [documentation](https://docs.apify.com/actor).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.resurrect(runId);
+     * ```
+     * @ignore
+     */
+    resurrect(runId: string, options?: ResurrectOptions): Promise<ClientActorRun>;
     /**
      * Runs an actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable).
      *
@@ -519,6 +542,30 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * @ignore
      */
     callTask(taskId: string, input?: Dictionary, options?: CallTaskOptions): Promise<ClientActorRun>;
+    /**
+     * Runs an Actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * unlike `Actor.callTask`, this method just starts the run without waiting for finish.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actor tasks, read the [documentation](https://docs.apify.com/tasks).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.startTask('bob/some-task');
+     * ```
+     *
+     * @param taskId
+     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
+     * @param [input]
+     *  Input overrides for the Actor task. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Provided input will be merged with Actor task input.
+     * @param [options]
+     * @ignore
+     */
+    startTask(taskId: string, input?: Dictionary, options?: StartTaskOptions): Promise<ClientActorRun>;
     /**
      * Transforms this Actor run to an Actor run of a given Actor. The system stops the current container and starts
      * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key
@@ -1010,6 +1057,29 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * @param [options]
      */
     static callTask(taskId: string, input?: Dictionary, options?: CallTaskOptions): Promise<ClientActorRun>;
+    /**
+     * Runs an Actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * unlike `Actor.callTask`, this method just starts the run without waiting for finish.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actor tasks, read the [documentation](https://docs.apify.com/tasks).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.startTask('bob/some-task');
+     * ```
+     *
+     * @param taskId
+     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
+     * @param [input]
+     *  Input overrides for the Actor task. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Provided input will be merged with Actor task input.
+     * @param [options]
+     */
+    static startTask(taskId: string, input?: Dictionary, options?: StartTaskOptions): Promise<ClientActorRun>;
     /**
      * Runs an Actor on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
      * unlike `Actor.call`, this method just starts the run without waiting for finish.
@@ -1048,6 +1118,24 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * ```
      */
     static abort(runId: string, options?: AbortOptions): Promise<ClientActorRun>;
+    /**
+     * Resurrects a finished Actor run on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable).
+     *
+     * Only finished runs (SUCCEEDED, FAILED, ABORTED or TIMED-OUT) can be resurrected. The run goes back to the RUNNING
+     * status and keeps its default storages. Options you leave out keep the values of the original run.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actors, read the
+     * [documentation](https://docs.apify.com/actor).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.resurrect(runId);
+     * ```
+     */
+    static resurrect(runId: string, options?: ResurrectOptions): Promise<ClientActorRun>;
     /**
      * Transforms this Actor run to an Actor run of a given Actor. The system stops the current container and starts
      * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key

package/dist/actor.js

@@ -459,6 +459,30 @@ export class Actor {
         }
         return client.run(runId).abort(rest);
     }
+    /**
+     * Resurrects a finished Actor run on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable).
+     *
+     * Only finished runs (SUCCEEDED, FAILED, ABORTED or TIMED-OUT) can be resurrected. The run goes back to the RUNNING
+     * status and keeps its default storages. Options you leave out keep the values of the original run.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actors, read the
+     * [documentation](https://docs.apify.com/actor).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.resurrect(runId);
+     * ```
+     * @ignore
+     */
+    async resurrect(runId, options = {}) {
+        const runTimeoutSecs = options.timeout === 'inherit' ? this.getRemainingTimeSecs() : options.timeout;
+        const { token, timeout: _timeout, ...rest } = options;
+        const client = token ? this.newClient({ token }) : this.apifyClient;
+        return client.run(runId).resurrect({ ...rest, runTimeoutSecs });
+    }
     /**
      * Runs an actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable).
      *
@@ -491,6 +515,35 @@ export class Actor {
         const client = token ? this.newClient({ token }) : this.apifyClient;
         return client.task(taskId).call(input, { ...rest, runTimeoutSecs });
     }
+    /**
+     * Runs an Actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * unlike `Actor.callTask`, this method just starts the run without waiting for finish.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actor tasks, read the [documentation](https://docs.apify.com/tasks).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.startTask('bob/some-task');
+     * ```
+     *
+     * @param taskId
+     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
+     * @param [input]
+     *  Input overrides for the Actor task. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Provided input will be merged with Actor task input.
+     * @param [options]
+     * @ignore
+     */
+    async startTask(taskId, input, options = {}) {
+        const runTimeoutSecs = options.timeout === 'inherit' ? this.getRemainingTimeSecs() : options.timeout;
+        const { token, timeout: _timeout, ...rest } = options;
+        const client = token ? this.newClient({ token }) : this.apifyClient;
+        return client.task(taskId).start(input, { ...rest, runTimeoutSecs });
+    }
     /**
      * Transforms this Actor run to an Actor run of a given Actor. The system stops the current container and starts
      * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key
@@ -1313,6 +1366,31 @@ export class Actor {
     static async callTask(taskId, input, options = {}) {
         return Actor.getDefaultInstance().callTask(taskId, input, options);
     }
+    /**
+     * Runs an Actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * unlike `Actor.callTask`, this method just starts the run without waiting for finish.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actor tasks, read the [documentation](https://docs.apify.com/tasks).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.startTask('bob/some-task');
+     * ```
+     *
+     * @param taskId
+     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
+     * @param [input]
+     *  Input overrides for the Actor task. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Provided input will be merged with Actor task input.
+     * @param [options]
+     */
+    static async startTask(taskId, input, options = {}) {
+        return Actor.getDefaultInstance().startTask(taskId, input, options);
+    }
     /**
      * Runs an Actor on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
      * unlike `Actor.call`, this method just starts the run without waiting for finish.
@@ -1355,6 +1433,26 @@ export class Actor {
     static async abort(runId, options = {}) {
         return Actor.getDefaultInstance().abort(runId, options);
     }
+    /**
+     * Resurrects a finished Actor run on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable).
+     *
+     * Only finished runs (SUCCEEDED, FAILED, ABORTED or TIMED-OUT) can be resurrected. The run goes back to the RUNNING
+     * status and keeps its default storages. Options you leave out keep the values of the original run.
+     *
+     * The result of the function is an {@link ActorRun} object that contains details about the Actor run.
+     *
+     * For more information about Actors, read the
+     * [documentation](https://docs.apify.com/actor).
+     *
+     * **Example usage:**
+     *
+     * ```js
+     * const run = await Actor.resurrect(runId);
+     * ```
+     */
+    static async resurrect(runId, options = {}) {
+        return Actor.getDefaultInstance().resurrect(runId, options);
+    }
     /**
      * Transforms this Actor run to an Actor run of a given Actor. The system stops the current container and starts
      * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify",
-  "version": "4.0.0-beta.58",
+  "version": "4.0.0-beta.60",
   "description": "The scalable web crawling and scraping library for JavaScript/Node.js. Enables development of data extraction and web automation jobs (not only) with headless Chrome and Puppeteer.",
   "engines": {
     "node": ">=22.13.0"