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

package/dist/platform_event_manager.d.ts

@@ -39,9 +39,8 @@ import { Configuration } from './configuration.js';
  *   you can achieve the same effect using `setInterval()` and listening for the `migrating` event.
  */
 export declare class PlatformEventManager extends EventManager {
+    #private;
     readonly configuration: Configuration;
-    /** Websocket connection to Actor events. */
-    private eventsWs?;
     constructor(configuration?: Configuration);
     /**
      * Initializes `Actor.events` event emitter by creating a connection to a websocket that provides them.

package/dist/platform_event_manager.js

@@ -44,7 +44,7 @@ import { Configuration } from './configuration.js';
 export class PlatformEventManager extends EventManager {
     configuration;
     /** Websocket connection to Actor events. */
-    eventsWs;
+    #eventsWs;
     constructor(configuration = Configuration.getGlobalConfiguration()) {
         super({
             persistStateIntervalMillis: configuration.persistStateIntervalMillis,
@@ -69,8 +69,8 @@ export class PlatformEventManager extends EventManager {
         this.createWebSocketConnection(eventsWsUrl);
     }
     createWebSocketConnection(eventsWsUrl) {
-        this.eventsWs = new WebSocket(eventsWsUrl);
-        this.eventsWs.on('message', (message) => {
+        this.#eventsWs = new WebSocket(eventsWsUrl);
+        this.#eventsWs.on('message', (message) => {
             if (!message)
                 return;
             try {
@@ -87,15 +87,15 @@ export class PlatformEventManager extends EventManager {
                 this.log.exception(err, 'Cannot parse Actor event');
             }
         });
-        this.eventsWs.on('error', (err) => {
+        this.#eventsWs.on('error', (err) => {
             // Don't print this error as this happens in the case of very short Actor.main().
             if (err.message === 'WebSocket was closed before the connection was established')
                 return;
             this.log.exception(err, 'web socket connection failed');
         });
-        this.eventsWs.on('close', () => {
+        this.#eventsWs.on('close', () => {
             this.log.debug('web socket has been closed');
-            this.eventsWs = undefined;
+            this.#eventsWs = undefined;
         });
     }
     /**
@@ -108,6 +108,6 @@ export class PlatformEventManager extends EventManager {
             return;
         }
         await super.close();
-        this.eventsWs?.close();
+        this.#eventsWs?.close();
     }
 }

package/dist/proxy_configuration.d.ts

@@ -151,14 +151,8 @@ export interface ProxyInfo extends CoreProxyInfo {
  * @category Scaling
  */
 export declare class ProxyConfiguration extends CoreProxyConfiguration {
+    #private;
     readonly configuration: Configuration;
-    private groups;
-    private countryCode?;
-    private subdivisionCode?;
-    private password?;
-    private hostname;
-    private port?;
-    private usesApifyProxy?;
     protected readonly log: import("@apify/log").Log;
     /**
      * @internal
@@ -190,22 +184,22 @@ export declare class ProxyConfiguration extends CoreProxyConfiguration {
     /**
      * Returns proxy username.
      */
-    protected _getUsername(sessionId: string): string;
+    protected getUsername(sessionId: string): string;
     protected composeDefaultUrl(sessionId: string): string;
     /**
      * Fetch & set the proxy password from Apify API if an Apify token is provided.
      */
-    protected _setPasswordIfToken(): Promise<void>;
+    private setPasswordIfToken;
     /**
      * Checks whether the user has access to the proxies specified in the provided ProxyConfigurationOptions.
      * If the check can not be made, it only prints a warning and allows the program to continue. This is to
      * prevent program crashes caused by short downtimes of Proxy.
      */
-    protected _checkAccess(): Promise<boolean>;
+    protected checkAccess(): Promise<boolean>;
     /**
      * Apify Proxy can be down for a second or a minute, but this should not crash processes.
      */
-    protected _fetchStatus(): Promise<ProxyStatus | undefined>;
+    protected fetchStatus(): Promise<ProxyStatus | undefined>;
     /**
      * Fetches the Apify Proxy status endpoint once, *through* the proxy, so the
      * response reports on this exact connection (auth + man-in-the-middle).
@@ -214,16 +208,11 @@ export declare class ProxyConfiguration extends CoreProxyConfiguration {
      * plus a `Proxy-Authorization` header — so no proxy-agent dependency is
      * needed. The status endpoint (`http://proxy.apify.com`) is plain HTTP.
      */
-    protected _requestStatus(statusUrl: string, proxyUrl: string): Promise<ProxyStatus>;
+    protected requestStatus(statusUrl: string, proxyUrl: string): Promise<ProxyStatus>;
     /**
      * Throws cannot combine custom proxies with Apify Proxy
      * @internal
      */
-    protected _throwCannotCombineCustomWithApify(): void;
-    /**
-     * Throws cannot combine custom proxies with custom generating function
-     * @internal
-     */
-    protected _throwCannotCombineCustomMethods(): void;
+    protected throwCannotCombineCustomWithApify(): void;
 }
 export {};

package/dist/proxy_configuration.js

@@ -53,13 +53,13 @@ const SESSION_ID_LENGTH = 12;
  */
 export class ProxyConfiguration extends CoreProxyConfiguration {
     configuration;
-    groups;
-    countryCode;
-    subdivisionCode;
-    password;
-    hostname;
-    port;
-    usesApifyProxy;
+    #groups;
+    #countryCode;
+    #subdivisionCode;
+    #password;
+    #hostname;
+    #port;
+    #usesApifyProxy;
     log = defaultLog.child({ prefix: 'ProxyConfiguration' });
     /**
      * @internal
@@ -96,17 +96,15 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
         }
         // Validation
         if ((proxyUrls || newUrlFunction) && (groupsToUse.length || countryCodeToUse || subdivisionCodeToUse)) {
-            this._throwCannotCombineCustomWithApify();
+            this.throwCannotCombineCustomWithApify();
         }
-        if (proxyUrls && newUrlFunction)
-            this._throwCannotCombineCustomMethods();
-        this.groups = groupsToUse;
-        this.countryCode = countryCodeToUse;
-        this.subdivisionCode = subdivisionCodeToUse;
-        this.password = password;
-        this.hostname = hostname;
-        this.port = port;
-        this.usesApifyProxy = !proxyUrls && !newUrlFunction;
+        this.#groups = groupsToUse;
+        this.#countryCode = countryCodeToUse;
+        this.#subdivisionCode = subdivisionCodeToUse;
+        this.#password = password;
+        this.#hostname = hostname;
+        this.#port = port;
+        this.#usesApifyProxy = !proxyUrls && !newUrlFunction;
         if (proxyUrls && proxyUrls.some((url) => url?.includes('apify.com'))) {
             this.log.warning('Some Apify proxy features may work incorrectly. Please consider setting up Apify properties instead of `proxyUrls`.\n' +
                 'See https://docs.apify.com/sdk/js/docs/concepts/proxy-management#apify-proxy-configuration');
@@ -121,11 +119,11 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * `ProxyConfiguration` instance instead of calling this manually.
      */
     async initialize(options) {
-        if (this.usesApifyProxy) {
-            if (!this.password) {
-                await this._setPasswordIfToken();
+        if (this.#usesApifyProxy) {
+            if (!this.#password) {
+                await this.setPasswordIfToken();
             }
-            if (!this.password) {
+            if (!this.#password) {
                 if (Actor.isAtHome()) {
                     throw new Error(`Apify Proxy password must be provided using options.password or the "${APIFY_ENV_VARS.PROXY_PASSWORD}" environment variable. ` +
                         `You can also provide your Apify token via the "${APIFY_ENV_VARS.TOKEN}" environment variable, ` +
@@ -139,7 +137,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
                 }
             }
             if (options?.checkAccess !== false) {
-                return this._checkAccess();
+                return this.checkAccess();
             }
         }
         return true;
@@ -161,12 +159,12 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
             hostname: parsed.hostname,
             port: parsed.port,
         };
-        if (this.usesApifyProxy) {
-            result.groups = this.groups;
-            if (this.countryCode !== undefined)
-                result.countryCode = this.countryCode;
-            if (this.subdivisionCode !== undefined)
-                result.subdivisionCode = this.subdivisionCode;
+        if (this.#usesApifyProxy) {
+            result.groups = this.#groups;
+            if (this.#countryCode !== undefined)
+                result.countryCode = this.#countryCode;
+            if (this.#subdivisionCode !== undefined)
+                result.subdivisionCode = this.#subdivisionCode;
         }
         return result;
     }
@@ -176,7 +174,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * `proxyUrls`, the URLs are rotated round-robin.
      */
     async newUrl(options) {
-        if (!this.usesApifyProxy) {
+        if (!this.#usesApifyProxy) {
             return super.newUrl(options);
         }
         return this.composeDefaultUrl(cryptoRandomObjectId(SESSION_ID_LENGTH));
@@ -184,40 +182,38 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
     /**
      * Returns proxy username.
      */
-    _getUsername(sessionId) {
-        const { groups, countryCode, subdivisionCode } = this;
+    getUsername(sessionId) {
         const parts = [];
-        if (groups && groups.length) {
-            parts.push(`groups-${groups.join('+')}`);
+        if (this.#groups && this.#groups.length) {
+            parts.push(`groups-${this.#groups.join('+')}`);
         }
         parts.push(`session-${sessionId}`);
-        if (subdivisionCode) {
-            parts.push(`country-${countryCode}_${subdivisionCode}`);
+        if (this.#subdivisionCode) {
+            parts.push(`country-${this.#countryCode}_${this.#subdivisionCode}`);
         }
-        else if (countryCode) {
-            parts.push(`country-${countryCode}`);
+        else if (this.#countryCode) {
+            parts.push(`country-${this.#countryCode}`);
         }
         return parts.join(',');
     }
     composeDefaultUrl(sessionId) {
-        const username = this._getUsername(sessionId);
-        const url = new URL(`http://${this.hostname}:${this.port}`);
+        const username = this.getUsername(sessionId);
+        const url = new URL(`http://${this.#hostname}:${this.#port}`);
         url.username = `${username}`;
-        url.password = `${this.password}`;
+        url.password = `${this.#password}`;
         const urlString = url.toString();
         return urlString.substring(0, urlString.length - 1);
     }
     /**
      * Fetch & set the proxy password from Apify API if an Apify token is provided.
      */
-    // TODO: Make this private
-    async _setPasswordIfToken() {
+    async setPasswordIfToken() {
         const { token } = this.configuration;
         if (!token)
             return;
         try {
             const user = await Actor.apifyClient.user().get();
-            this.password = user.proxy?.password;
+            this.#password = user.proxy?.password;
         }
         catch (error) {
             if (Actor.isAtHome()) {
@@ -235,8 +231,8 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * If the check can not be made, it only prints a warning and allows the program to continue. This is to
      * prevent program crashes caused by short downtimes of Proxy.
      */
-    async _checkAccess() {
-        const status = await this._fetchStatus();
+    async checkAccess() {
+        const status = await this.fetchStatus();
         if (!status) {
             this.log.warning('Apify Proxy access check timed out. Watch out for errors with status code 407. ' +
                 "If you see some, it most likely means you don't have access to either all or some of the proxies you're trying to use.");
@@ -261,7 +257,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
     /**
      * Apify Proxy can be down for a second or a minute, but this should not crash processes.
      */
-    async _fetchStatus() {
+    async fetchStatus() {
         const { proxyStatusUrl } = this.configuration;
         const statusUrl = `${proxyStatusUrl}/?format=json`;
         const proxyUrl = await this.newUrl();
@@ -270,7 +266,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
             return undefined;
         for (let attempt = 1; attempt <= CHECK_ACCESS_MAX_ATTEMPTS; attempt++) {
             try {
-                return await this._requestStatus(statusUrl, proxyUrl);
+                return await this.requestStatus(statusUrl, proxyUrl);
             }
             catch {
                 // retry connection errors
@@ -286,7 +282,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * plus a `Proxy-Authorization` header — so no proxy-agent dependency is
      * needed. The status endpoint (`http://proxy.apify.com`) is plain HTTP.
      */
-    async _requestStatus(statusUrl, proxyUrl) {
+    async requestStatus(statusUrl, proxyUrl) {
         const target = new URL(statusUrl);
         const proxy = new URL(proxyUrl);
         const headers = { host: target.host };
@@ -304,7 +300,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
         });
         request.end();
         // `once` rejects if the request emits `error` first (connection refused,
-        // timeout/abort), so failures propagate to the retry loop in `_fetchStatus`.
+        // timeout/abort), so failures propagate to the retry loop in `fetchStatus`.
         const [response] = (await once(request, 'response'));
         const statusCode = response.statusCode ?? 0;
         if (statusCode < 200 || statusCode >= 300) {
@@ -317,17 +313,10 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * Throws cannot combine custom proxies with Apify Proxy
      * @internal
      */
-    _throwCannotCombineCustomWithApify() {
+    throwCannotCombineCustomWithApify() {
         throw new Error('Cannot combine custom proxies with Apify Proxy! ' +
             'It is not allowed to set "options.proxyUrls" or "options.newUrlFunction" combined with ' +
             '"options.groups", "options.apifyProxyGroups", "options.countryCode", "options.apifyProxyCountry", ' +
             '"options.subdivisionCode" or "options.apifyProxySubdivision".');
     }
-    /**
-     * Throws cannot combine custom proxies with custom generating function
-     * @internal
-     */
-    _throwCannotCombineCustomMethods() {
-        throw new Error('Cannot combine custom proxies "options.proxyUrls" with custom generating function "options.newUrlFunction".');
-    }
 }

package/dist/storage.d.ts

@@ -1,6 +1,3 @@
-import type { IStorage, StorageOpenOptions } from '@crawlee/core';
-import type { Constructor, StorageBackend } from '@crawlee/types';
-import type { Configuration } from './configuration.js';
 export interface OpenStorageOptions {
     /**
      * If set to `true` then the cloud storage is used even if the `CRAWLEE_STORAGE_DIR`
@@ -10,8 +7,11 @@ export interface OpenStorageOptions {
     forceCloud?: boolean;
 }
 /**
- * Identifies a storage by its alias from the Actor's schema storages
- * (resolved via the `ACTOR_STORAGES_JSON` environment variable).
+ * Identifies a run-scoped storage by its alias.
+ *
+ * An alias declared in the Actor's schema storages (the `ACTOR_STORAGES_JSON` environment variable)
+ * resolves to the storage the platform created for it; any other alias gets an unnamed storage of
+ * its own, for this run only.
  */
 export interface StorageAlias {
     alias: string;
@@ -31,28 +31,8 @@ export interface StorageName {
 /**
  * Identifies a storage to open. Can be:
  * - A plain `string` for backward compatibility (treated as ID or name)
- * - `{ alias: string }` to resolve from the Actor's schema storages (`ACTOR_STORAGES_JSON`)
+ * - `{ alias: string }` to open a run-scoped storage — see {@link StorageAlias}
  * - `{ id: string }` to open by explicit platform ID
  * - `{ name: string }` to open by explicit name
  */
 export type StorageIdentifier = string | StorageAlias | StorageId | StorageName;
-/**
- * Identifies a storage to open, without alias support.
- * Used for key-value stores and request queues, which do not support aliases.
- * Can be:
- * - A plain `string` for backward compatibility (treated as ID or name)
- * - `{ id: string }` to open by explicit platform ID
- * - `{ name: string }` to open by explicit name
- */
-export type StorageIdentifierWithoutAlias = string | StorageId | StorageName;
-export interface OpenStorageContext {
-    config: Configuration;
-    backend?: StorageBackend;
-    purgedStorageAliases: Set<string>;
-}
-/**
- * Opens a storage by its identifier, handling Apify alias resolution and local purging.
- */
-export declare function openStorage<T extends IStorage>(storageClass: Constructor<T> & {
-    open(id?: string | null, options?: StorageOpenOptions): Promise<T>;
-}, identifier: StorageIdentifier | null | undefined, context: OpenStorageContext): Promise<T>;

package/dist/storage.js

@@ -1,79 +1 @@
-import { ApifyStorageBackend } from './apify_storage_backend.js';
-const STORAGE_TYPE_KEYS = {
-    Dataset: 'datasets',
-    KeyValueStore: 'keyValueStores',
-    RequestQueue: 'requestQueues',
-};
-const parsedStoragesJson = new Map();
-/**
- * Resolves a {@link StorageIdentifier} to a plain string ID or name
- * that can be passed to crawlee v4's `<Storage>.open()`.
- */
-function resolveStorageIdentifier(storageType, identifier, config) {
-    if (identifier === null || identifier === undefined) {
-        return undefined;
-    }
-    if (typeof identifier === 'string') {
-        return identifier;
-    }
-    if ('id' in identifier) {
-        return identifier.id;
-    }
-    if ('name' in identifier) {
-        return identifier.name;
-    }
-    // { alias: string }
-    const storagesJson = config.actorStoragesJson;
-    if (config.isAtHome && storagesJson) {
-        let storages;
-        try {
-            if (!parsedStoragesJson.has(storagesJson)) {
-                parsedStoragesJson.set(storagesJson, JSON.parse(storagesJson));
-            }
-            storages = parsedStoragesJson.get(storagesJson);
-        }
-        catch {
-            throw new Error(`Failed to parse ACTOR_STORAGES_JSON environment variable: ${storagesJson}`);
-        }
-        const typeKey = STORAGE_TYPE_KEYS[storageType];
-        const resolvedId = storages[typeKey]?.[identifier.alias];
-        if (resolvedId) {
-            return resolvedId;
-        }
-        throw new Error(`Storage alias "${identifier.alias}" not found in ACTOR_STORAGES_JSON for storage type "${storageType}". ` +
-            `Available aliases: ${Object.keys(storages[typeKey] ?? {}).join(', ') || '(none)'}`);
-    }
-    // When using local storage, just use the alias as a name.
-    // When using platform storage, we can't just make up a name — the alias must be
-    // in ACTOR_STORAGES_JSON.
-    if (config.isAtHome) {
-        throw new Error(`Storage alias "${identifier.alias}" cannot be resolved because ACTOR_STORAGES_JSON is not set. ` +
-            `Aliases are only available for storages declared in the Actor's schema.`);
-    }
-    return identifier.alias;
-}
-/**
- * Opens a storage by its identifier, handling Apify alias resolution and local purging.
- */
-export async function openStorage(storageClass, identifier, context) {
-    const isAlias = identifier !== null && identifier !== undefined && typeof identifier === 'object' && 'alias' in identifier;
-    if (isAlias && !context.config.isAtHome && context.backend instanceof ApifyStorageBackend) {
-        throw new Error('The `alias` option is not allowed for Apify-based storages running outside of Apify');
-    }
-    const resolvedIdOrName = resolveStorageIdentifier(storageClass.name, identifier, context.config);
-    // When running locally, purge aliased storages on first open
-    // (similar to how crawlee purges default storages on start).
-    if (isAlias &&
-        !context.config.isAtHome &&
-        context.config.purgeOnStart &&
-        !context.purgedStorageAliases.has(identifier.alias)) {
-        context.purgedStorageAliases.add(identifier.alias);
-        const existingStorage = await storageClass.open(resolvedIdOrName ?? null, {
-            storageBackend: context.backend,
-        });
-        await existingStorage.drop();
-    }
-    return storageClass.open(resolvedIdOrName ?? null, {
-        storageBackend: context.backend,
-    });
-}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify",
-  "version": "4.0.0-beta.30",
+  "version": "4.0.0-beta.32",
   "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.0.0"