apify 4.0.0-beta.18 → 4.0.0-beta.20

package/dist/proxy_configuration.js

@@ -1,7 +1,10 @@
+import { once } from 'node:events';
+import { request as httpRequest } from 'node:http';
+import { json } from 'node:stream/consumers';
 import { ProxyConfiguration as CoreProxyConfiguration } from '@crawlee/core';
-import { fetch, ProxyAgent } from 'undici';
 import { z } from 'zod';
 import { APIFY_ENV_VARS, APIFY_PROXY_VALUE_REGEX } from '@apify/consts';
+import defaultLog from '@apify/log';
 import { cryptoRandomObjectId } from '@apify/utilities';
 import { Actor } from './actor.js';
 import { Configuration } from './configuration.js';
@@ -49,7 +52,7 @@ const SESSION_ID_LENGTH = 12;
  * @category Scaling
  */
 export class ProxyConfiguration extends CoreProxyConfiguration {
-    config;
+    configuration;
     groups;
     countryCode;
     subdivisionCode;
@@ -57,17 +60,18 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
     hostname;
     port;
     usesApifyProxy;
+    log = defaultLog.child({ prefix: 'ProxyConfiguration' });
     /**
      * @internal
      */
-    constructor(options = {}, config = Configuration.getGlobalConfig()) {
+    constructor(options = {}, configuration = Configuration.getGlobalConfiguration()) {
         const { proxyUrls, newUrlFunction, ...rest } = options;
         super({
             proxyUrls,
             newUrlFunction,
             ['validateRequired']: false,
         });
-        this.config = config;
+        this.configuration = configuration;
         validate(z
             .object({
             groups: z.array(z.string().regex(APIFY_PROXY_VALUE_REGEX)).optional(),
@@ -79,12 +83,12 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
             password: z.string().optional(),
         })
             .strict(), rest);
-        const { groups = [], apifyProxyGroups = [], countryCode, apifyProxyCountry, subdivisionCode, apifyProxySubdivision, password = config.proxyPassword, } = options;
+        const { groups = [], apifyProxyGroups = [], countryCode, apifyProxyCountry, subdivisionCode, apifyProxySubdivision, password = configuration.proxyPassword, } = options;
         const groupsToUse = groups.length ? groups : apifyProxyGroups;
         const countryCodeToUse = countryCode || apifyProxyCountry;
         const subdivisionCodeToUse = subdivisionCode || apifyProxySubdivision;
-        const hostname = config.proxyHostname;
-        const port = config.proxyPort;
+        const hostname = configuration.proxyHostname;
+        const port = configuration.proxyPort;
         // The Apify Proxy subdivision is expressed as part of the country
         // username parameter (`country-US_CA`), so a country is required.
         if (subdivisionCodeToUse && !countryCodeToUse) {
@@ -102,7 +106,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
         this.password = password;
         this.hostname = hostname;
         this.port = port;
-        this.usesApifyProxy = !this.proxyUrls && !this.newUrlFunction;
+        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');
@@ -172,7 +176,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * `proxyUrls`, the URLs are rotated round-robin.
      */
     async newUrl(options) {
-        if (this.newUrlFunction || this.proxyUrls) {
+        if (!this.usesApifyProxy) {
             return super.newUrl(options);
         }
         return this.composeDefaultUrl(cryptoRandomObjectId(SESSION_ID_LENGTH));
@@ -208,7 +212,7 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      */
     // TODO: Make this private
     async _setPasswordIfToken() {
-        const { token } = this.config;
+        const { token } = this.configuration;
         if (!token)
             return;
         try {
@@ -239,6 +243,8 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
             return true;
         }
         const { connected, connectionError, isManInTheMiddle } = status;
+        // Declared `readonly false` on the base class; the status check is the one place that
+        // learns the actual value, so bypass the readonly marker.
         this.isManInTheMiddle = isManInTheMiddle;
         if (connected) {
             return true;
@@ -256,38 +262,56 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
      * Apify Proxy can be down for a second or a minute, but this should not crash processes.
      */
     async _fetchStatus() {
-        const { proxyStatusUrl } = this.config;
-        const url = `${proxyStatusUrl}/?format=json`;
-        // The status endpoint (`proxy.apify.com`) is requested *through* the proxy
-        // so it can report on this exact connection (auth + man-in-the-middle).
-        // `undici`'s `fetch` + `ProxyAgent` come from the same package, so the
-        // dispatcher is recognized (Node's global `fetch` uses a separate internal
-        // copy of undici that would reject this dispatcher instance).
+        const { proxyStatusUrl } = this.configuration;
+        const statusUrl = `${proxyStatusUrl}/?format=json`;
         const proxyUrl = await this.newUrl();
         // Without a proxy URL we can't perform the (proxied) status check.
         if (!proxyUrl)
             return undefined;
-        const dispatcher = new ProxyAgent(proxyUrl);
-        try {
-            for (let attempt = 1; attempt <= CHECK_ACCESS_MAX_ATTEMPTS; attempt++) {
-                try {
-                    const response = await fetch(url, {
-                        dispatcher,
-                        signal: AbortSignal.timeout(CHECK_ACCESS_REQUEST_TIMEOUT_MILLIS),
-                    });
-                    if (!response.ok)
-                        continue;
-                    return (await response.json());
-                }
-                catch {
-                    // retry connection errors
-                }
+        for (let attempt = 1; attempt <= CHECK_ACCESS_MAX_ATTEMPTS; attempt++) {
+            try {
+                return await this._requestStatus(statusUrl, proxyUrl);
+            }
+            catch {
+                // retry connection errors
             }
-            return undefined;
         }
-        finally {
-            await dispatcher.close();
+        return undefined;
+    }
+    /**
+     * Fetches the Apify Proxy status endpoint once, *through* the proxy, so the
+     * response reports on this exact connection (auth + man-in-the-middle).
+     *
+     * Uses a native `node:http` forward-proxy request — an absolute request URL
+     * 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) {
+        const target = new URL(statusUrl);
+        const proxy = new URL(proxyUrl);
+        const headers = { host: target.host };
+        if (proxy.username) {
+            const credentials = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+            headers['proxy-authorization'] = `Basic ${Buffer.from(credentials).toString('base64')}`;
+        }
+        const request = httpRequest({
+            host: proxy.hostname,
+            port: proxy.port,
+            // Absolute-form request URI tells the proxy to forward the request.
+            path: target.href,
+            headers,
+            signal: AbortSignal.timeout(CHECK_ACCESS_REQUEST_TIMEOUT_MILLIS),
+        });
+        request.end();
+        // `once` rejects if the request emits `error` first (connection refused,
+        // 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) {
+            response.resume(); // drain so the socket can be freed
+            throw new Error(`Apify Proxy status check responded with status code ${statusCode}.`);
         }
+        return (await json(response));
     }
     /**
      * Throws cannot combine custom proxies with Apify Proxy
@@ -299,4 +323,11 @@ export class ProxyConfiguration extends CoreProxyConfiguration {
             '"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,5 +1,5 @@
-import type { Constructor, IStorage, StorageOpenOptions } from '@crawlee/core';
-import type { StorageClient } from '@crawlee/types';
+import type { IStorage, StorageOpenOptions } from '@crawlee/core';
+import type { Constructor, StorageBackend } from '@crawlee/types';
 import type { Configuration } from './configuration.js';
 export interface OpenStorageOptions {
     /**
@@ -47,7 +47,7 @@ export type StorageIdentifier = string | StorageAlias | StorageId | StorageName;
 export type StorageIdentifierWithoutAlias = string | StorageId | StorageName;
 export interface OpenStorageContext {
     config: Configuration;
-    client?: StorageClient;
+    backend?: StorageBackend;
     purgedStorageAliases: Set<string>;
 }
 /**

package/dist/storage.js

@@ -1,4 +1,4 @@
-import { ApifyStorageClient } from './apify_storage_client.js';
+import { ApifyStorageBackend } from './apify_storage_backend.js';
 const STORAGE_TYPE_KEYS = {
     Dataset: 'datasets',
     KeyValueStore: 'keyValueStores',
@@ -57,7 +57,7 @@ function resolveStorageIdentifier(storageType, identifier, config) {
  */
 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.client instanceof ApifyStorageClient) {
+    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);
@@ -69,11 +69,11 @@ export async function openStorage(storageClass, identifier, context) {
         !context.purgedStorageAliases.has(identifier.alias)) {
         context.purgedStorageAliases.add(identifier.alias);
         const existingStorage = await storageClass.open(resolvedIdOrName ?? null, {
-            storageClient: context.client,
+            storageBackend: context.backend,
         });
         await existingStorage.drop();
     }
     return storageClass.open(resolvedIdOrName ?? null, {
-        storageClient: context.client,
+        storageBackend: context.backend,
     });
 }

package/dist/utils.d.ts

@@ -5,6 +5,11 @@ import type { z } from 'zod';
  * @internal
  */
 export declare function isNonEmptyObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Converts a `SNAKE_CASE` string to `camelCase` (previously provided by `@crawlee/utils`).
+ * @internal
+ */
+export declare function snakeCaseToCamelCase(snakeCaseStr: string): string;
 /**
  * Error thrown when an argument fails validation (e.g. by `Actor.addWebhook()`
  * or the `ProxyConfiguration` constructor).

package/dist/utils.js

@@ -20,6 +20,17 @@ const require = createRequire(import.meta.url);
 export function isNonEmptyObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
 }
+/**
+ * Converts a `SNAKE_CASE` string to `camelCase` (previously provided by `@crawlee/utils`).
+ * @internal
+ */
+export function snakeCaseToCamelCase(snakeCaseStr) {
+    return snakeCaseStr
+        .toLowerCase()
+        .split('_')
+        .map((part, index) => (index > 0 ? part.charAt(0).toUpperCase() + part.slice(1) : part))
+        .join('');
+}
 /** Formats a zod issue path like `groups[0]` or `countryCode`. */
 function formatIssuePath(path) {
     let out = '';

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "apify",
-  "version": "4.0.0-beta.18",
+  "version": "4.0.0-beta.20",
   "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.19.0"
+    "node": ">=22.0.0"
   },
   "type": "module",
   "main": "./dist/index.js",
@@ -54,17 +54,17 @@
   },
   "dependencies": {
     "@apify/consts": "^2.51.0",
+    "@apify/datastructures": "^2.0.3",
     "@apify/input_secrets": "^1.2.0",
     "@apify/log": "^2.4.3",
     "@apify/timeout": "^0.3.0",
     "@apify/utilities": "^2.13.0",
-    "@crawlee/core": "^4.0.0-beta.61",
-    "@crawlee/types": "^4.0.0-beta.61",
-    "@crawlee/utils": "^4.0.0-beta.61",
+    "@crawlee/core": "^4.0.0-beta.105",
+    "@crawlee/types": "^4.0.0-beta.105",
+    "@crawlee/utils": "^4.0.0-beta.105",
     "apify-client": "^2.23.4",
     "semver": "^7.5.4",
     "tslib": "^2.6.2",
-    "undici": "^8.0.0",
     "ws": "^8.18.0",
     "zod": "^4.0.0"
   },
@@ -72,7 +72,6 @@
     "@apify/oxlint-config": "^0.2.5",
     "@apify/tsconfig": "^0.1.2",
     "@commitlint/config-conventional": "^21.0.0",
-    "@crawlee/memory-storage": "^4.0.0-beta.61",
     "@playwright/browser-chromium": "^1.60.0",
     "@types/content-type": "^1.1.8",
     "@types/node": "^24.0.0",
@@ -80,7 +79,7 @@
     "@types/tough-cookie": "^4.0.5",
     "@types/ws": "^8.5.12",
     "commitlint": "^21.0.0",
-    "crawlee": "^4.0.0-beta.61",
+    "crawlee": "^4.0.0-beta.105",
     "globby": "^16.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.0",

package/dist/apify_storage_client.d.ts

@@ -1,66 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import type { CreateDatasetClientOptions, CreateKeyValueStoreClientOptions, CreateRequestQueueClientOptions, DatasetClient, KeyValueStoreClient, RequestQueueClient, StorageClient } from '@crawlee/types';
-import type { ApifyClient } from 'apify-client';
-import { type ChargeResult, type ChargingManager } from './charging.js';
-import type { Configuration } from './configuration.js';
-type StorageType = 'Dataset' | 'KeyValueStore' | 'RequestQueue';
-/** Marks a dataset client whose `pushItems` charges for pay-per-event. @internal */
-export declare const USES_PUSH_DATA_INTERCEPTION: unique symbol;
-/**
- * Context of a single `Actor.pushData()` call, shared with the intercepted
- * `pushItems()` calls so they can (1) know which event to charge and
- * (2) aggregate the {@link ChargeResult} across the multiple `pushItems()`
- * calls a single `pushData()` may trigger (Crawlee batches large pushes).
- */
-export interface PpeAwarePushDataContext {
-    eventName: string | undefined;
-    chargeResult?: ChargeResult;
-}
-export declare const pushDataChargingContext: AsyncLocalStorage<PpeAwarePushDataContext>;
-/**
- * Bridges `apify-client`'s synchronous resource accessors (`dataset(id)`,
- * `keyValueStore(id)`, `requestQueue(id, options?)`) to crawlee v4's
- * `StorageClient` interface (async factory methods accepting either an `id`
- * or a `name`).
- *
- * For the run's default dataset it transparently swaps in a charging-aware
- * dataset client (pay-per-event on `Actor.pushData()`), provided a charging
- * manager is supplied and a default-dataset-item price is configured.
- *
- * `storageExists()` lets `Dataset.open(idOrName)` resolve a string to an id
- * first (when one exists on the platform) and fall back to a name otherwise —
- * otherwise crawlee's `resolveStorageIdentifier` treats every string as a name
- * and the SDK would silently create a new storage named like the passed id.
- *
- * `Actor` wires this up automatically; construct it directly only to use Apify
- * platform storage with crawlee's storage classes outside of `Actor` — e.g. to
- * read another run's output with an explicit token:
- *
- * ```ts
- * import { ApifyClient, ApifyStorageClient, Dataset } from 'apify';
- *
- * const client = new ApifyClient({ token });
- * const dataset = await Dataset.open(datasetId, { storageClient: new ApifyStorageClient(client) });
- * const { items } = await dataset.getData();
- * ```
- */
-export declare class ApifyStorageClient implements StorageClient {
-    private readonly client;
-    private readonly config?;
-    private readonly getChargingManager?;
-    constructor(client: ApifyClient, config?: Configuration | undefined, getChargingManager?: (() => ChargingManager) | undefined);
-    storageExists(id: string, type: StorageType): Promise<boolean>;
-    createDatasetClient(options?: CreateDatasetClientOptions): Promise<DatasetClient>;
-    createKeyValueStoreClient(options?: CreateKeyValueStoreClientOptions): Promise<KeyValueStoreClient>;
-    createRequestQueueClient(options?: CreateRequestQueueClientOptions): Promise<RequestQueueClient>;
-    /**
-     * Returns a charging-aware dataset client when `id` is the run's default
-     * dataset and a default-dataset-item price is configured; otherwise
-     * `undefined` (caller uses the plain client).
-     */
-    private chargingDatasetClient;
-    private resolveId;
-    private resourceClient;
-    private collectionClient;
-}
-export {};

package/dist/apify_storage_client.js

@@ -1,200 +0,0 @@
-/* eslint-disable max-classes-per-file */
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { DatasetClient as ApifyDatasetClient } from 'apify-client';
-import { DEFAULT_DATASET_ITEM_EVENT, mergeChargeResults, pushDataAndCharge, } from './charging.js';
-const DEFAULT_ID_CONFIG_KEY = {
-    Dataset: 'defaultDatasetId',
-    KeyValueStore: 'defaultKeyValueStoreId',
-    RequestQueue: 'defaultRequestQueueId',
-};
-/** Marks a dataset client whose `pushItems` charges for pay-per-event. @internal */
-export const USES_PUSH_DATA_INTERCEPTION = Symbol('apify:uses-push-data-interception');
-export const pushDataChargingContext = new AsyncLocalStorage();
-/**
- * Default `DatasetClient` that charges for pushed items (pay-per-event). Used
- * only for the run's default dataset when a `apify-default-dataset-item` price
- * is configured; for everything else the plain `apify-client` dataset client is
- * used.
- */
-class PpeAwareDatasetClient extends ApifyDatasetClient {
-    getChargingManager;
-    constructor(options, getChargingManager) {
-        super(options);
-        this.getChargingManager = getChargingManager;
-    }
-    normalizeItems(items) {
-        if (typeof items === 'string') {
-            const parsed = JSON.parse(items);
-            return Array.isArray(parsed) ? parsed : [parsed];
-        }
-        if (Array.isArray(items)) {
-            return items.flatMap((item) => typeof item === 'string' ? JSON.parse(item) : item);
-        }
-        return [items];
-    }
-    async pushItems(items) {
-        const context = pushDataChargingContext.getStore();
-        // A single JSON string may encode multiple items (e.g. '[{...},{...}]'),
-        // which the charging logic would miscount — parse strings into arrays so
-        // each logical item is counted individually.
-        const normalizedItems = this.normalizeItems(items);
-        const result = await pushDataAndCharge({
-            chargingManager: this.getChargingManager(),
-            items: normalizedItems,
-            eventName: context?.eventName,
-            isDefaultDataset: true,
-            // stringify for faster validation in the Apify client
-            pushFn: async (limitedItems) => super.pushItems(JSON.stringify(limitedItems)),
-        });
-        if (!context)
-            return;
-        // One `Actor.pushData()` may map to several `pushItems()` calls — aggregate.
-        context.chargeResult =
-            context.chargeResult === undefined ? result : mergeChargeResults(context.chargeResult, result);
-    }
-}
-// crawlee v4's `StorageClient` sub-client interfaces use different method names
-// than `apify-client`'s resource clients (`getValue`/`getRecord`,
-// `pushData`/`pushItems`, `getData`/`listItems`, `getMetadata`/`get`,
-// `drop`/`delete`). `adapt` wraps a client in a name-remapping proxy: `renames`
-// aliases the differing methods and `overrides` replaces the few whose return
-// shape differs; everything else — identically-named methods and the
-// pay-per-event marker symbol — passes straight through.
-//
-// `purge()` has no apify-client equivalent and isn't needed on the platform
-// (a run's storages are already fresh), so it's a no-op.
-const noPurge = { purge: async () => { } };
-function adapt(client, renames, overrides = {}) {
-    return new Proxy(client, {
-        get(target, prop) {
-            if (typeof prop === 'string' && prop in overrides)
-                return overrides[prop];
-            const value = Reflect.get(target, (typeof prop === 'string' && renames[prop]) || prop, target);
-            return typeof value === 'function' ? value.bind(target) : value;
-        },
-    });
-}
-/**
- * Bridges `apify-client`'s synchronous resource accessors (`dataset(id)`,
- * `keyValueStore(id)`, `requestQueue(id, options?)`) to crawlee v4's
- * `StorageClient` interface (async factory methods accepting either an `id`
- * or a `name`).
- *
- * For the run's default dataset it transparently swaps in a charging-aware
- * dataset client (pay-per-event on `Actor.pushData()`), provided a charging
- * manager is supplied and a default-dataset-item price is configured.
- *
- * `storageExists()` lets `Dataset.open(idOrName)` resolve a string to an id
- * first (when one exists on the platform) and fall back to a name otherwise —
- * otherwise crawlee's `resolveStorageIdentifier` treats every string as a name
- * and the SDK would silently create a new storage named like the passed id.
- *
- * `Actor` wires this up automatically; construct it directly only to use Apify
- * platform storage with crawlee's storage classes outside of `Actor` — e.g. to
- * read another run's output with an explicit token:
- *
- * ```ts
- * import { ApifyClient, ApifyStorageClient, Dataset } from 'apify';
- *
- * const client = new ApifyClient({ token });
- * const dataset = await Dataset.open(datasetId, { storageClient: new ApifyStorageClient(client) });
- * const { items } = await dataset.getData();
- * ```
- */
-export class ApifyStorageClient {
-    client;
-    config;
-    getChargingManager;
-    constructor(client, config, getChargingManager) {
-        this.client = client;
-        this.config = config;
-        this.getChargingManager = getChargingManager;
-    }
-    async storageExists(id, type) {
-        // Apify's `GET /v2/{kind}/{idOrName}` matches by either id or name;
-        // confirm it was an *id* match so crawlee can fall through to `{ name }`.
-        const info = await this.resourceClient(id, type).get();
-        return info?.id === id;
-    }
-    async createDatasetClient(options) {
-        const id = await this.resolveId(options, 'Dataset');
-        const client = this.chargingDatasetClient(id) ?? this.client.dataset(id);
-        return adapt(client, {
-            getMetadata: 'get',
-            drop: 'delete',
-            pushData: 'pushItems',
-            getData: 'listItems',
-        }, noPurge);
-    }
-    async createKeyValueStoreClient(options) {
-        const id = await this.resolveId(options, 'KeyValueStore');
-        const client = this.client.keyValueStore(id);
-        return adapt(client, {
-            getMetadata: 'get',
-            getValue: 'getRecord',
-            setValue: 'setRecord',
-            deleteValue: 'deleteRecord',
-            drop: 'delete',
-            getPublicUrl: 'getRecordPublicUrl',
-        }, {
-            ...noPurge,
-            // crawlee expects an array; apify-client returns `{ items }`.
-            listKeys: async (opts) => (await client.listKeys(opts)).items,
-        });
-    }
-    async createRequestQueueClient(options) {
-        const id = await this.resolveId(options, 'RequestQueue');
-        const client = this.client.requestQueue(id, options?.clientKey ? { clientKey: options.clientKey } : undefined);
-        return adapt(client, { getMetadata: 'get', drop: 'delete' }, noPurge);
-    }
-    /**
-     * Returns a charging-aware dataset client when `id` is the run's default
-     * dataset and a default-dataset-item price is configured; otherwise
-     * `undefined` (caller uses the plain client).
-     */
-    chargingDatasetClient(id) {
-        const { getChargingManager } = this;
-        if (!getChargingManager)
-            return undefined;
-        if (id !== this.config?.defaultDatasetId)
-            return undefined;
-        const hasDefaultDatasetItemEvent = DEFAULT_DATASET_ITEM_EVENT in getChargingManager().getPricingInfo().perEventPrices;
-        if (!hasDefaultDatasetItemEvent)
-            return undefined;
-        const datasetClient = new PpeAwareDatasetClient({
-            id,
-            baseUrl: this.client.baseUrl,
-            publicBaseUrl: this.client.publicBaseUrl,
-            apifyClient: this.client,
-            httpClient: this.client.httpClient,
-        }, getChargingManager);
-        Object.assign(datasetClient, {
-            [USES_PUSH_DATA_INTERCEPTION]: true,
-        });
-        return datasetClient;
-    }
-    async resolveId(options, type) {
-        if (options?.id)
-            return options.id;
-        if (options?.name) {
-            return (await this.collectionClient(type).getOrCreate(options.name)).id;
-        }
-        // No id/name (crawlee's `__default__` alias): use the default storage
-        // id from the run's environment. apify-client rejects an empty id.
-        return this.config?.[DEFAULT_ID_CONFIG_KEY[type]] ?? '';
-    }
-    resourceClient(id, type) {
-        if (type === 'Dataset')
-            return this.client.dataset(id);
-        if (type === 'KeyValueStore')
-            return this.client.keyValueStore(id);
-        return this.client.requestQueue(id);
-    }
-    collectionClient(type) {
-        if (type === 'Dataset')
-            return this.client.datasets();
-        if (type === 'KeyValueStore')
-            return this.client.keyValueStores();
-        return this.client.requestQueues();
-    }
-}