apify 4.0.0-beta.30 → 4.0.0-beta.32

package/dist/actor.d.ts

@@ -11,7 +11,7 @@ import type { ConfigurationOptions } from './configuration.js';
 import { Configuration } from './configuration.js';
 import type { ProxyConfigurationOptions } from './proxy_configuration.js';
 import { ProxyConfiguration } from './proxy_configuration.js';
-import type { OpenStorageOptions, StorageIdentifier, StorageIdentifierWithoutAlias } from './storage.js';
+import type { OpenStorageOptions, StorageIdentifier } from './storage.js';
 export interface InitOptions {
     storage?: StorageBackend;
     /**
@@ -319,8 +319,6 @@ export declare const EXIT_CODES: {
  */
 export declare class Actor<Data extends Dictionary = Dictionary> {
     #private;
-    /** @internal */
-    static _instance: Actor;
     /**
      * Configuration of this SDK instance (provided to its constructor). See {@link Configuration} for details.
      * @internal
@@ -340,32 +338,6 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * Whether the Actor instance was initialized. This is set by calling {@link Actor.init}.
      */
     initialized: boolean;
-    /**
-     * Set if the Actor called a method that requires the instance to be initialized, but did not do so.
-     * A call to `init` after this warning is emitted is considered  an invalid state and will throw an error.
-     */
-    private warnedAboutMissingInitCall;
-    /**
-     * Set if the Actor is currently rebooting.
-     */
-    private isRebooting;
-    /**
-     * Set if the Actor is currently exiting. Prevents double-exit from graceful shutdown handlers.
-     */
-    private isExiting;
-    /**
-     * References to graceful shutdown handlers so they can be removed during cleanup.
-     */
-    private gracefulShutdownHandlers;
-    private chargingManager;
-    /**
-     * Tracks which aliased storages have been purged during this session,
-     * so we only purge them once (on first open) when running locally.
-     * @internal
-     */
-    purgedStorageAliases: Set<string>;
-    /** How Apify platform request queues are consumed; set from {@link InitOptions.requestQueueAccess}. */
-    private requestQueueAccess;
     constructor(options?: ActorOptions);
     /**
      * Runs the main user function that performs the job of the Actor
@@ -623,8 +595,8 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * @param [datasetIdOrName]
      *   ID, name, or alias of the dataset to be opened. If `null` or `undefined`,
      *   the function returns the default dataset associated with the Actor run.
-     *   You can also pass `{ alias: 'name' }` to open a dataset defined in the Actor's schema storages,
-     *   `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      * @ignore
      */
@@ -735,13 +707,14 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * For more details and code examples, see the {@link KeyValueStore} class.
      *
      * @param [storeIdOrName]
-     *   ID or name of the key-value store to be opened. If `null` or `undefined`,
+     *   ID, name, or alias of the key-value store to be opened. If `null` or `undefined`,
      *   the function returns the default key-value store associated with the Actor run.
-     *   You can also pass `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      * @ignore
      */
-    openKeyValueStore(storeIdOrName?: StorageIdentifierWithoutAlias | null, options?: OpenStorageOptions): Promise<KeyValueStore>;
+    openKeyValueStore(storeIdOrName?: StorageIdentifier | null, options?: OpenStorageOptions): Promise<KeyValueStore>;
     /**
      * Opens a request queue and returns a promise resolving to an instance
      * of the {@link RequestQueue} class.
@@ -754,13 +727,14 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * For more details and code examples, see the {@link RequestQueue} class.
      *
      * @param [queueIdOrName]
-     *   ID or name of the request queue to be opened. If `null` or `undefined`,
+     *   ID, name, or alias of the request queue to be opened. If `null` or `undefined`,
      *   the function returns the default request queue associated with the Actor run.
-     *   You can also pass `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      * @ignore
      */
-    openRequestQueue(queueIdOrName?: StorageIdentifierWithoutAlias | null, options?: OpenStorageOptions): Promise<RequestQueue>;
+    openRequestQueue(queueIdOrName?: StorageIdentifier | null, options?: OpenStorageOptions): Promise<RequestQueue>;
     /**
      * Creates a proxy configuration and returns a promise resolving to an instance
      * of the {@link ProxyConfiguration} class that is already initialized.
@@ -1168,8 +1142,8 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      * @param [datasetIdOrName]
      *   ID, name, or alias of the dataset to be opened. If `null` or `undefined`,
      *   the function returns the default dataset associated with the Actor run.
-     *   You can also pass `{ alias: 'name' }` to open a dataset defined in the Actor's schema storages,
-     *   `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      */
     static openDataset<Data extends Dictionary = Dictionary>(datasetIdOrName?: StorageIdentifier | null, options?: OpenStorageOptions): Promise<Dataset<Data>>;
@@ -1280,7 +1254,7 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      *   You can also pass `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      */
-    static openKeyValueStore(storeIdOrName?: StorageIdentifierWithoutAlias | null, options?: OpenStorageOptions): Promise<KeyValueStore>;
+    static openKeyValueStore(storeIdOrName?: StorageIdentifier | null, options?: OpenStorageOptions): Promise<KeyValueStore>;
     /**
      * Opens a request queue and returns a promise resolving to an instance
      * of the {@link RequestQueue} class.
@@ -1298,7 +1272,7 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
      *   You can also pass `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      */
-    static openRequestQueue(queueIdOrName?: StorageIdentifierWithoutAlias | null, options?: OpenStorageOptions): Promise<RequestQueue>;
+    static openRequestQueue(queueIdOrName?: StorageIdentifier | null, options?: OpenStorageOptions): Promise<RequestQueue>;
     /**
      * Creates a proxy configuration and returns a promise resolving to an instance
      * of the {@link ProxyConfiguration} class that is already initialized.
@@ -1387,12 +1361,16 @@ export declare class Actor<Data extends Dictionary = Dictionary> {
     static get configuration(): Configuration;
     /** @internal */
     static getDefaultInstance(): Actor;
+    /**
+     * Replaces or clears the cached default instance returned by {@link Actor.getDefaultInstance}.
+     * @internal
+     */
+    static setDefaultInstance(instance?: Actor): void;
     private usesPushDataInterception;
     private pushDataViaInterceptedClient;
     private pushDataWithExplicitCharging;
-    private _openStorage;
     private createApifyStorageBackend;
-    private _ensureActorInit;
+    private ensureActorInit;
     /**
      * Get time remaining from the Actor run timeout in seconds, rounded up to whole seconds with minimum value of 1 second.
      *

package/dist/actor.js

@@ -14,7 +14,6 @@ import { Configuration } from './configuration.js';
 import { getDefaultsFromInputSchema, noActorInputSchemaDefinedMarker, readInputSchema } from './input-schemas.js';
 import { PlatformEventManager } from './platform_event_manager.js';
 import { ProxyConfiguration } from './proxy_configuration.js';
-import { openStorage } from './storage.js';
 import { checkCrawleeVersion, getSystemInfo, isNonEmptyObject, printOutdatedSdkWarning, snakeCaseToCamelCase, } from './utils.js';
 /**
  * Exit codes for the Actor process.
@@ -34,7 +33,7 @@ export const EXIT_CODES = {
  */
 export class Actor {
     /** @internal */
-    static _instance;
+    static #instance;
     /**
      * Configuration of this SDK instance (provided to its constructor). See {@link Configuration} for details.
      * @internal
@@ -58,32 +57,26 @@ export class Actor {
      * Set if the Actor called a method that requires the instance to be initialized, but did not do so.
      * A call to `init` after this warning is emitted is considered  an invalid state and will throw an error.
      */
-    warnedAboutMissingInitCall = false;
+    #warnedAboutMissingInitCall = false;
     /**
      * Set if the Actor is currently rebooting.
      */
-    isRebooting = false;
+    #isRebooting = false;
     /**
      * Set if the Actor is currently exiting. Prevents double-exit from graceful shutdown handlers.
      */
-    isExiting = false;
+    #isExiting = false;
     /**
      * References to graceful shutdown handlers so they can be removed during cleanup.
      */
-    gracefulShutdownHandlers = {};
+    #gracefulShutdownHandlers = {};
     /**
      * Reference to the crawlee status message forwarder, so it can be removed during cleanup.
      */
     #statusMessageForwarder;
-    chargingManager;
-    /**
-     * Tracks which aliased storages have been purged during this session,
-     * so we only purge them once (on first open) when running locally.
-     * @internal
-     */
-    purgedStorageAliases = new Set();
+    #chargingManager;
     /** How Apify platform request queues are consumed; set from {@link InitOptions.requestQueueAccess}. */
-    requestQueueAccess = 'single';
+    #requestQueueAccess = 'single';
     constructor(options = {}) {
         const { configuration, ...configOptions } = options;
         if (configuration) {
@@ -108,7 +101,7 @@ export class Actor {
         }
         this.apifyClient = this.newClient();
         this.eventManager = new PlatformEventManager(this.configuration);
-        this.chargingManager = new ChargingManager(this.configuration, this.apifyClient);
+        this.#chargingManager = new ChargingManager(this.configuration, this.apifyClient);
     }
     /**
      * Runs the main user function that performs the job of the Actor
@@ -199,7 +192,7 @@ export class Actor {
             return;
         }
         // If the warning about forgotten init call was emitted, we will not continue the init procedure.
-        if (this.warnedAboutMissingInitCall) {
+        if (this.#warnedAboutMissingInitCall) {
             throw new Error([
                 'Actor.init() was called after a method that would access a storage client was used.',
                 'This in an invalid state. Please make sure to call Actor.init() before such methods are called.',
@@ -213,7 +206,7 @@ export class Actor {
         // the event manager resolve the same instance (`availableMemoryRatio` /
         // `disableBrowserSandbox` at-home defaults now live in `Configuration`).
         serviceLocator.setConfiguration(this.configuration);
-        this.requestQueueAccess = options.requestQueueAccess ?? 'single';
+        this.#requestQueueAccess = options.requestQueueAccess ?? 'single';
         if (this.isAtHome()) {
             serviceLocator.setStorageBackend(this.createApifyStorageBackend());
             serviceLocator.setEventManager(this.eventManager);
@@ -230,22 +223,22 @@ export class Actor {
         // Using setTimeout to avoid deadlock with waitForAllListenersToComplete() in exit()/reboot()
         if (options.gracefulShutdown !== false) {
             const delay = options.gracefulShutdownDelayMillis ?? 0;
-            this.gracefulShutdownHandlers.aborting = () => {
+            this.#gracefulShutdownHandlers.aborting = () => {
                 setTimeout(() => {
                     this.exit().catch((err) => {
                         log.exception(err, 'Failed to exit gracefully');
                     });
                 }, delay);
             };
-            this.on(ACTOR_EVENT_NAMES.ABORTING, this.gracefulShutdownHandlers.aborting);
-            this.gracefulShutdownHandlers.migrating = () => {
+            this.on(ACTOR_EVENT_NAMES.ABORTING, this.#gracefulShutdownHandlers.aborting);
+            this.#gracefulShutdownHandlers.migrating = () => {
                 setTimeout(() => {
                     this.reboot().catch((err) => {
                         log.exception(err, 'Failed to reboot on migration');
                     });
                 }, delay);
             };
-            this.on(ACTOR_EVENT_NAMES.MIGRATING, this.gracefulShutdownHandlers.migrating);
+            this.on(ACTOR_EVENT_NAMES.MIGRATING, this.#gracefulShutdownHandlers.migrating);
         }
         // Crawlee crawlers, for instance, broadcast their status messages as `statusMessage` events.
         this.#statusMessageForwarder = async ({ message, isStatusMessageTerminal }) => this.#updateRunStatusMessage(message, isStatusMessageTerminal);
@@ -255,19 +248,19 @@ export class Actor {
             onlyPurgeOnce: true,
         });
         log.debug(`Default storages purged`);
-        await this.chargingManager.init();
-        log.debug(`ChargingManager initialized`, this.chargingManager.getPricingInfo());
+        await this.#chargingManager.init();
+        log.debug(`ChargingManager initialized`, this.#chargingManager.getPricingInfo());
     }
     /**
      * @ignore
      */
     async exit(messageOrOptions, options = {}) {
         // Prevent double-exit from graceful shutdown handlers
-        if (this.isExiting) {
+        if (this.#isExiting) {
             log.debug('Actor.exit() called while already exiting, skipping');
             return;
         }
-        this.isExiting = true;
+        this.#isExiting = true;
         options =
             typeof messageOrOptions === 'string'
                 ? { ...options, statusMessage: messageOrOptions }
@@ -275,15 +268,15 @@ export class Actor {
         options.exit ??= true;
         options.exitCode ??= EXIT_CODES.SUCCESS;
         options.timeoutSecs ??= 30;
-        this._ensureActorInit('exit');
+        this.ensureActorInit('exit');
         const client = serviceLocator.getStorageBackend();
         const events = serviceLocator.getEventManager();
         // Remove graceful shutdown handlers to prevent them from interfering with exit
-        if (this.gracefulShutdownHandlers.aborting) {
-            this.off(ACTOR_EVENT_NAMES.ABORTING, this.gracefulShutdownHandlers.aborting);
+        if (this.#gracefulShutdownHandlers.aborting) {
+            this.off(ACTOR_EVENT_NAMES.ABORTING, this.#gracefulShutdownHandlers.aborting);
         }
-        if (this.gracefulShutdownHandlers.migrating) {
-            this.off(ACTOR_EVENT_NAMES.MIGRATING, this.gracefulShutdownHandlers.migrating);
+        if (this.#gracefulShutdownHandlers.migrating) {
+            this.off(ACTOR_EVENT_NAMES.MIGRATING, this.#gracefulShutdownHandlers.migrating);
         }
         // Close the event manager and emit the final PERSIST_STATE event
         await events.close();
@@ -331,7 +324,7 @@ export class Actor {
         });
         // Reset the flag so the instance can be reused (e.g., in tests or when exit is false).
         // When process.exit() actually terminates the process, this line is never reached - which is fine.
-        this.isExiting = false;
+        this.#isExiting = false;
         if (!options.exit) {
             return;
         }
@@ -505,16 +498,16 @@ export class Actor {
      * @ignore
      */
     async reboot(options = {}) {
-        this._ensureActorInit('reboot');
+        this.ensureActorInit('reboot');
         if (!this.isAtHome()) {
             log.warning('Actor.reboot() is only supported when running on the Apify platform.');
             return;
         }
-        if (this.isRebooting) {
+        if (this.#isRebooting) {
             log.debug('Actor is already rebooting, skipping the additional reboot call.');
             return;
         }
-        this.isRebooting = true;
+        this.#isRebooting = true;
         // Waiting for all the listeners to finish, as `.reboot()` kills the container.
         await Promise.all([
             // `persistState` for individual RequestLists, RequestQueue... instances to be persisted
@@ -588,7 +581,7 @@ export class Actor {
         const { isStatusMessageTerminal, level } = options || {};
         parseArgument(statusMessage, z.string());
         parseArgument(isStatusMessageTerminal, z.boolean().optional());
-        this._ensureActorInit('setStatusMessage');
+        this.ensureActorInit('setStatusMessage');
         const loggedStatusMessage = `[Status message]: ${statusMessage}`;
         switch (level) {
             case 'DEBUG':
@@ -646,7 +639,7 @@ export class Actor {
      * @ignore
      */
     async pushData(item, eventName) {
-        this._ensureActorInit('pushData');
+        this.ensureActorInit('pushData');
         if (eventName?.startsWith('apify-')) {
             throw new Error(`Cannot charge for synthetic event '${eventName}' manually`);
         }
@@ -674,15 +667,17 @@ export class Actor {
      * @param [datasetIdOrName]
      *   ID, name, or alias of the dataset to be opened. If `null` or `undefined`,
      *   the function returns the default dataset associated with the Actor run.
-     *   You can also pass `{ alias: 'name' }` to open a dataset defined in the Actor's schema storages,
-     *   `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      * @ignore
      */
     async openDataset(datasetIdOrName, options = {}) {
         parseArgument(options, z.object({ forceCloud: z.boolean().optional() }).strict());
-        this._ensureActorInit('openDataset');
-        return this._openStorage(Dataset, datasetIdOrName, options);
+        this.ensureActorInit('openDataset');
+        return Dataset.open(datasetIdOrName ?? null, {
+            storageBackend: options.forceCloud ? this.createApifyStorageBackend() : undefined,
+        });
     }
     /**
      * Gets a value from the default {@link KeyValueStore} associated with the current Actor run.
@@ -713,7 +708,7 @@ export class Actor {
      * @ignore
      */
     async getValue(key) {
-        this._ensureActorInit('getValue');
+        this.ensureActorInit('getValue');
         const store = await this.openKeyValueStore();
         return store.getValue(key);
     }
@@ -749,7 +744,7 @@ export class Actor {
      * @ignore
      */
     async setValue(key, value, options = {}) {
-        this._ensureActorInit('setValue');
+        this.ensureActorInit('setValue');
         const store = await this.openKeyValueStore();
         return store.setValue(key, value, options);
     }
@@ -783,7 +778,7 @@ export class Actor {
      * @ignore
      */
     async getInput() {
-        this._ensureActorInit('getInput');
+        this.ensureActorInit('getInput');
         const { inputSecretsPrivateKeyFile, inputSecretsPrivateKeyPassphrase } = this.configuration;
         const rawInput = await this.getValue(this.configuration.inputKey);
         let input = rawInput;
@@ -820,16 +815,19 @@ export class Actor {
      * For more details and code examples, see the {@link KeyValueStore} class.
      *
      * @param [storeIdOrName]
-     *   ID or name of the key-value store to be opened. If `null` or `undefined`,
+     *   ID, name, or alias of the key-value store to be opened. If `null` or `undefined`,
      *   the function returns the default key-value store associated with the Actor run.
-     *   You can also pass `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      * @ignore
      */
     async openKeyValueStore(storeIdOrName, options = {}) {
         parseArgument(options, z.object({ forceCloud: z.boolean().optional() }).strict());
-        this._ensureActorInit('openKeyValueStore');
-        return this._openStorage(KeyValueStore, storeIdOrName, options);
+        this.ensureActorInit('openKeyValueStore');
+        return KeyValueStore.open(storeIdOrName ?? null, {
+            storageBackend: options.forceCloud ? this.createApifyStorageBackend() : undefined,
+        });
     }
     /**
      * Opens a request queue and returns a promise resolving to an instance
@@ -843,17 +841,19 @@ export class Actor {
      * For more details and code examples, see the {@link RequestQueue} class.
      *
      * @param [queueIdOrName]
-     *   ID or name of the request queue to be opened. If `null` or `undefined`,
+     *   ID, name, or alias of the request queue to be opened. If `null` or `undefined`,
      *   the function returns the default request queue associated with the Actor run.
-     *   You can also pass `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      * @ignore
      */
     async openRequestQueue(queueIdOrName, options = {}) {
         parseArgument(options, z.object({ forceCloud: z.boolean().optional() }).strict());
-        this._ensureActorInit('openRequestQueue');
-        const queue = await this._openStorage(RequestQueue, queueIdOrName, options);
-        return queue;
+        this.ensureActorInit('openRequestQueue');
+        return RequestQueue.open(queueIdOrName ?? null, {
+            storageBackend: options.forceCloud ? this.createApifyStorageBackend() : undefined,
+        });
     }
     /**
      * Creates a proxy configuration and returns a promise resolving to an instance
@@ -928,16 +928,16 @@ export class Actor {
      * @ignore
      */
     async charge(options) {
-        this._ensureActorInit('charge');
-        return this.chargingManager.charge(options);
+        this.ensureActorInit('charge');
+        return this.#chargingManager.charge(options);
     }
     /**
      * Retrieve the charging manager to access granular pricing information.
      * @ignore
      */
     getChargingManager() {
-        this._ensureActorInit('getChargingManager');
-        return this.chargingManager;
+        this.ensureActorInit('getChargingManager');
+        return this.#chargingManager;
     }
     /**
      * Modifies Actor env vars so parsing respects the structure of {@link ApifyEnv} interface.
@@ -1022,7 +1022,7 @@ export class Actor {
      * @param options An optional object parameter where a custom `keyValueStoreName` and `config` can be passed in.
      */
     async useState(name, defaultValue = {}, options) {
-        this._ensureActorInit('useState');
+        this.ensureActorInit('useState');
         const kvStore = await KeyValueStore.open(options?.keyValueStoreName, {
             configuration: options?.configuration || Configuration.getGlobalConfiguration(),
         });
@@ -1343,8 +1343,8 @@ export class Actor {
      * @param [datasetIdOrName]
      *   ID, name, or alias of the dataset to be opened. If `null` or `undefined`,
      *   the function returns the default dataset associated with the Actor run.
-     *   You can also pass `{ alias: 'name' }` to open a dataset defined in the Actor's schema storages,
-     *   `{ id: 'abc' }` to open by explicit ID, or `{ name: 'abc' }` to open by explicit name.
+     *   You can also pass `{ alias: 'abc' }` to open a run-scoped storage, `{ id: 'abc' }` to open by
+     *   explicit ID, or `{ name: 'abc' }` to open by explicit name.
      * @param [options]
      */
     static async openDataset(datasetIdOrName, options = {}) {
@@ -1590,8 +1590,15 @@ export class Actor {
     }
     /** @internal */
     static getDefaultInstance() {
-        this._instance ??= new Actor();
-        return this._instance;
+        Actor.#instance ??= new Actor();
+        return Actor.#instance;
+    }
+    /**
+     * Replaces or clears the cached default instance returned by {@link Actor.getDefaultInstance}.
+     * @internal
+     */
+    static setDefaultInstance(instance) {
+        Actor.#instance = instance;
     }
     usesPushDataInterception(dataset) {
         return Boolean(dataset.backend[USES_PUSH_DATA_INTERCEPTION]);
@@ -1624,36 +1631,29 @@ export class Actor {
         }
         const isDefaultDataset = dataset.id === this.configuration.defaultDatasetId;
         return pushDataAndCharge({
-            chargingManager: this.chargingManager,
+            chargingManager: this.#chargingManager,
             items,
             eventName: explicitEventName,
             isDefaultDataset,
             pushFn: async (limitedItems) => dataset.pushData(limitedItems),
         });
     }
-    async _openStorage(storageClass, identifier, options = {}) {
-        return openStorage(storageClass, identifier, {
-            config: this.configuration,
-            backend: options.forceCloud ? this.createApifyStorageBackend() : undefined,
-            purgedStorageAliases: this.purgedStorageAliases,
-        });
-    }
     createApifyStorageBackend() {
         return new ApifyStorageBackend(this.apifyClient, {
             configuration: this.configuration,
-            requestQueueAccess: this.requestQueueAccess,
-            getChargingManager: () => this.chargingManager,
+            requestQueueAccess: this.#requestQueueAccess,
+            getChargingManager: () => this.#chargingManager,
         });
     }
-    _ensureActorInit(methodCalled) {
+    ensureActorInit(methodCalled) {
         // If we already warned the user once, don't do it again to prevent spam
-        if (this.warnedAboutMissingInitCall) {
+        if (this.#warnedAboutMissingInitCall) {
             return;
         }
         if (this.initialized) {
             return;
         }
-        this.warnedAboutMissingInitCall = true;
+        this.#warnedAboutMissingInitCall = true;
         log.warning([
             `Actor.${methodCalled}() was called but the Actor instance was not initialized.`,
             'Did you forget to call Actor.init()?',

package/dist/apify_dataset_backend.d.ts

@@ -9,7 +9,7 @@ import type { DatasetClient } from 'apify-client';
  * @internal
  */
 export declare class ApifyDatasetBackend implements DatasetBackend {
-    private readonly client;
+    #private;
     constructor(client: DatasetClient);
     getMetadata(): Promise<DatasetInfo>;
     drop(): Promise<void>;

package/dist/apify_dataset_backend.js

@@ -13,19 +13,19 @@ const MAX_ITEM_BYTES = EFFECTIVE_LIMIT_BYTES - 2;
  * @internal
  */
 export class ApifyDatasetBackend {
-    client;
+    #client;
     constructor(client) {
-        this.client = client;
+        this.#client = client;
     }
     async getMetadata() {
-        const metadata = await this.client.get();
+        const metadata = await this.#client.get();
         if (!metadata) {
             throw new Error('Dataset not found or has been deleted.');
         }
         return metadata;
     }
     async drop() {
-        await this.client.delete();
+        await this.#client.delete();
     }
     async purge() {
         throw new Error('Purging a dataset is not supported on the Apify platform. ' +
@@ -36,11 +36,11 @@ export class ApifyDatasetBackend {
         // that fit, pushed sequentially to preserve item order.
         const payloads = items.map((item, index) => serializeToSizeLimit(item, index));
         for (const chunk of chunkBySize(payloads, EFFECTIVE_LIMIT_BYTES)) {
-            await this.client.pushItems(chunk);
+            await this.#client.pushItems(chunk);
         }
     }
     async getData(options) {
-        return await this.client.listItems(options);
+        return await this.#client.listItems(options);
     }
 }
 /** Serializes a dataset item, throwing if it alone exceeds the payload size limit. */

package/dist/apify_key_value_store_backend.d.ts

@@ -9,7 +9,7 @@ import type { KeyValueStoreClient } from 'apify-client';
  * @internal
  */
 export declare class ApifyKeyValueStoreBackend implements KeyValueStoreBackend {
-    private readonly client;
+    #private;
     constructor(client: KeyValueStoreClient);
     getMetadata(): Promise<KeyValueStoreInfo>;
     drop(): Promise<void>;

package/dist/apify_key_value_store_backend.js

@@ -7,19 +7,19 @@
  * @internal
  */
 export class ApifyKeyValueStoreBackend {
-    client;
+    #client;
     constructor(client) {
-        this.client = client;
+        this.#client = client;
     }
     async getMetadata() {
-        const metadata = await this.client.get();
+        const metadata = await this.#client.get();
         if (!metadata) {
             throw new Error('Key-value store not found or has been deleted.');
         }
         return metadata;
     }
     async drop() {
-        await this.client.delete();
+        await this.#client.delete();
     }
     async purge() {
         throw new Error('Purging a key-value store is not supported on the Apify platform. ' +
@@ -28,16 +28,16 @@ export class ApifyKeyValueStoreBackend {
     async getValue(key) {
         // Storage backends are byte transports — the KeyValueStore frontend parses values
         // according to their content type, so the record must be returned unparsed.
-        return this.client.getRecord(key, { buffer: true });
+        return this.#client.getRecord(key, { buffer: true });
     }
     async setValue(record) {
-        await this.client.setRecord(record);
+        await this.#client.setRecord(record);
     }
     async deleteValue(key) {
-        await this.client.deleteRecord(key);
+        await this.#client.deleteRecord(key);
     }
     async listKeys(options) {
-        const result = await this.client.listKeys(options);
+        const result = await this.#client.listKeys(options);
         // The API does not report a content type for listed keys; crawlee's item shape
         // requires the field, so it is left undefined via the cast.
         return {
@@ -46,9 +46,9 @@ export class ApifyKeyValueStoreBackend {
         };
     }
     async getPublicUrl(key) {
-        return this.client.getRecordPublicUrl(key);
+        return this.#client.getRecordPublicUrl(key);
     }
     async recordExists(key) {
-        return this.client.recordExists(key);
+        return this.#client.recordExists(key);
     }
 }