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

package/dist/apify_storage_backend.js

@@ -2,14 +2,22 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { createHash } from 'node:crypto';
 import { DatasetClient as ApifyDatasetClient } from 'apify-client';
+import log from '@apify/log';
 import { cryptoRandomObjectId } from '@apify/utilities';
 import { ApifyDatasetBackend } from './apify_dataset_backend.js';
 import { ApifyKeyValueStoreBackend } from './apify_key_value_store_backend.js';
+import { AsyncLock } from './apify_request_queue_backend.js';
 import { ApifyRequestQueueSharedBackend } from './apify_request_queue_shared_backend.js';
 import { ApifyRequestQueueSingleBackend } from './apify_request_queue_single_backend.js';
 import { DEFAULT_DATASET_ITEM_EVENT, mergeChargeResults, pushDataAndCharge, } from './charging.js';
 /** The reserved alias crawlee uses for the default (unnamed) storage. */
 const DEFAULT_STORAGE_ALIAS = '__default__';
+/** The key of the default key-value store record holding this run's alias -> storage id mapping. */
+const ALIAS_MAPPING_RECORD_KEY = '__STORAGE_ALIASES_MAPPING';
+async function readAliasMapping(store) {
+    const record = await store.getRecord(ALIAS_MAPPING_RECORD_KEY);
+    return record?.value ?? {};
+}
 /** The maximum clientKey length accepted by the request queue API. */
 const MAX_CLIENT_KEY_LENGTH = 32;
 const DEFAULT_ID_CONFIG_KEY = {
@@ -32,10 +40,10 @@ export const pushDataChargingContext = new AsyncLocalStorage();
  * used.
  */
 class PpeAwareDatasetClient extends ApifyDatasetClient {
-    getChargingManager;
+    #getChargingManager;
     constructor(options, getChargingManager) {
         super(options);
-        this.getChargingManager = getChargingManager;
+        this.#getChargingManager = getChargingManager;
     }
     normalizeItems(items) {
         if (typeof items === 'string') {
@@ -54,7 +62,7 @@ class PpeAwareDatasetClient extends ApifyDatasetClient {
         // each logical item is counted individually.
         const normalizedItems = this.normalizeItems(items);
         const result = await pushDataAndCharge({
-            chargingManager: this.getChargingManager(),
+            chargingManager: this.#getChargingManager(),
             items: normalizedItems,
             eventName: context?.eventName,
             isDefaultDataset: true,
@@ -91,19 +99,23 @@ class PpeAwareDatasetClient extends ApifyDatasetClient {
  * ```
  */
 export class ApifyStorageBackend {
-    client;
-    config;
-    requestQueueAccess;
-    getChargingManager;
-    /** Unnamed storages created for aliases in this process, so an alias maps to one storage. */
-    aliasIdCache = new Map();
+    #client;
+    #config;
+    #requestQueueAccess;
+    #getChargingManager;
+    /** Unnamed storages resolved for aliases in this process, keyed like {@link AliasMapping}. */
+    #aliasIdCache = new Map();
+    /** The alias mapping read from the run's default key-value store; `undefined` until first read. */
+    #persistedAliasIds;
+    /** Serializes alias resolution — see `resolveAliasId`. */
+    #aliasLock = new AsyncLock();
     /** Fallback request queue client key when the run id is unavailable — one per backend. */
-    fallbackClientKey;
+    #fallbackClientKey;
     constructor(client, options = {}) {
-        this.client = client;
-        this.config = options.configuration;
-        this.requestQueueAccess = options.requestQueueAccess ?? 'single';
-        this.getChargingManager = options.getChargingManager;
+        this.#client = client;
+        this.#config = options.configuration;
+        this.#requestQueueAccess = options.requestQueueAccess ?? 'single';
+        this.#getChargingManager = options.getChargingManager;
     }
     /**
      * Partitions crawlee's storage-instance cache by API base URL and token, so the same storage
@@ -112,11 +124,14 @@ export class ApifyStorageBackend {
      * and `shared` mode at once is not supported, and whichever backend opens it first wins.
      */
     getStorageBackendCacheKey() {
-        const hash = createHash('sha256')
-            .update(`${this.client.publicBaseUrl}${this.client.token ?? ''}`)
+        return `ApifyStorageBackend:${this.credentialsHash()}`;
+    }
+    /** Short digest of the API base URL and token — identifies the credentials a storage was opened with. */
+    credentialsHash() {
+        return createHash('sha256')
+            .update(`${this.#client.publicBaseUrl}${this.#client.token ?? ''}`)
             .digest('hex')
             .slice(0, 8);
-        return `ApifyStorageBackend:${hash}`;
     }
     async storageExists(id, type) {
         // Lets `Dataset.open(idOrName)` and friends resolve a string to an id first (when one
@@ -130,7 +145,7 @@ export class ApifyStorageBackend {
     async createDatasetBackend(options) {
         const id = await this.resolveId(options, 'Dataset');
         const chargingClient = this.chargingDatasetClient(id);
-        const backend = new ApifyDatasetBackend(chargingClient ?? this.client.dataset(id));
+        const backend = new ApifyDatasetBackend(chargingClient ?? this.#client.dataset(id));
         if (chargingClient) {
             // `Actor.pushData()` looks for this marker on the dataset's backend to know the
             // pay-per-event charging happens inside the intercepted `pushItems()` calls.
@@ -140,12 +155,12 @@ export class ApifyStorageBackend {
     }
     async createKeyValueStoreBackend(options) {
         const id = await this.resolveId(options, 'KeyValueStore');
-        return new ApifyKeyValueStoreBackend(this.client.keyValueStore(id));
+        return new ApifyKeyValueStoreBackend(this.#client.keyValueStore(id));
     }
     async createRequestQueueBackend(options) {
         const id = await this.resolveId(options, 'RequestQueue');
-        const client = this.client.requestQueue(id, { clientKey: this.requestQueueClientKey() });
-        return this.requestQueueAccess === 'shared'
+        const client = this.#client.requestQueue(id, { clientKey: this.requestQueueClientKey() });
+        return this.#requestQueueAccess === 'shared'
             ? new ApifyRequestQueueSharedBackend(client)
             : new ApifyRequestQueueSingleBackend(client);
     }
@@ -154,7 +169,7 @@ export class ApifyStorageBackend {
      * migrated or resurrected run re-acquire the request locks of its previous incarnation.
      */
     requestQueueClientKey() {
-        const key = this.config?.actorRunId ?? (this.fallbackClientKey ??= cryptoRandomObjectId(MAX_CLIENT_KEY_LENGTH));
+        const key = this.#config?.actorRunId ?? (this.#fallbackClientKey ??= cryptoRandomObjectId(MAX_CLIENT_KEY_LENGTH));
         return key.slice(0, MAX_CLIENT_KEY_LENGTH);
     }
     /**
@@ -163,29 +178,30 @@ export class ApifyStorageBackend {
      * `undefined` (caller uses the plain client).
      */
     chargingDatasetClient(id) {
-        const { getChargingManager } = this;
+        const getChargingManager = this.#getChargingManager;
         if (!getChargingManager)
             return undefined;
-        if (id !== this.config?.defaultDatasetId)
+        if (id !== this.#config?.defaultDatasetId)
             return undefined;
         const hasDefaultDatasetItemEvent = DEFAULT_DATASET_ITEM_EVENT in getChargingManager().getPricingInfo().perEventPrices;
         if (!hasDefaultDatasetItemEvent)
             return undefined;
         return new PpeAwareDatasetClient({
             id,
-            baseUrl: this.client.baseUrl,
-            publicBaseUrl: this.client.publicBaseUrl,
-            apifyClient: this.client,
-            httpClient: this.client.httpClient,
+            baseUrl: this.#client.baseUrl,
+            publicBaseUrl: this.#client.publicBaseUrl,
+            apifyClient: this.#client,
+            httpClient: this.#client.httpClient,
         }, getChargingManager);
     }
     /**
      * Resolves a crawlee {@link StorageIdentifier} to a platform storage id.
      *
      * Aliases resolve to unnamed storages: the reserved `__default__` alias maps to the run's
-     * default storage, and other aliases to the storages declared in the Actor's schema (via the
-     * `ACTOR_STORAGES_JSON` environment variable, maintained by the platform). Outside the
-     * platform, an unnamed storage is created per alias instead (remembered for this process only).
+     * default storage, and an alias declared in the Actor's schema to the storage the platform
+     * created for it (via the `ACTOR_STORAGES_JSON` environment variable). Any other alias gets an
+     * unnamed storage of its own — crawlee mints aliases at runtime, one per extra crawler instance
+     * and one per throttled domain, so an undeclared alias is not an error.
      */
     async resolveId(options, type) {
         if (options?.id)
@@ -195,7 +211,7 @@ export class ApifyStorageBackend {
         }
         const alias = (options && 'alias' in options && options.alias) || DEFAULT_STORAGE_ALIAS;
         if (alias === DEFAULT_STORAGE_ALIAS) {
-            const defaultId = this.config?.[DEFAULT_ID_CONFIG_KEY[type]];
+            const defaultId = this.#config?.[DEFAULT_ID_CONFIG_KEY[type]];
             if (defaultId)
                 return defaultId;
         }
@@ -203,24 +219,61 @@ export class ApifyStorageBackend {
             const declaredId = this.aliasFromActorStorages(alias, type);
             if (declaredId)
                 return declaredId;
-            if (this.config?.isAtHome) {
-                throw new Error(`Storage alias "${alias}" cannot be resolved because it is not declared in the Actor's schema storages. ` +
-                    `Declare it in the Actor schema, or open the storage by name instead.`);
+        }
+        return this.resolveAliasId(alias, type);
+    }
+    /**
+     * Returns the unnamed storage backing `alias`, creating it on first use.
+     *
+     * On the platform the mapping is persisted, so a migrated run reopens the same storages rather
+     * than empty ones — aliased request queues hold live requests. Serialized, so one alias means
+     * one storage and the mapping's read-modify-write cannot drop entries.
+     */
+    async resolveAliasId(alias, type) {
+        // The credentials are part of the key, so the same alias opened through two
+        // differently-authenticated backends maps to two storages.
+        const key = [type, alias, this.credentialsHash()].join(',');
+        return this.#aliasLock.runExclusive(async () => {
+            const knownId = this.#aliasIdCache.get(key);
+            if (knownId)
+                return knownId;
+            const store = this.aliasMappingStore();
+            this.#persistedAliasIds ??= store ? await readAliasMapping(store) : {};
+            // A persisted id can point at a storage the user has since deleted.
+            const persistedId = this.#persistedAliasIds[key];
+            if (persistedId && (await this.resourceClient(persistedId, type).get())) {
+                this.#aliasIdCache.set(key, persistedId);
+                return persistedId;
             }
+            const { id } = await this.collectionClient(type).getOrCreate();
+            this.#aliasIdCache.set(key, id);
+            if (store)
+                await this.persistAliasId(store, key, id);
+            return id;
+        });
+    }
+    /**
+     * Re-reads the record first, so a second backend in this process does not drop its entries.
+     * Logged rather than thrown: a lost entry only costs a re-created storage after a migration.
+     */
+    async persistAliasId(store, key, id) {
+        try {
+            const mapping = await readAliasMapping(store);
+            mapping[key] = id;
+            await store.setRecord({ key: ALIAS_MAPPING_RECORD_KEY, value: mapping });
+            this.#persistedAliasIds = mapping;
+        }
+        catch (error) {
+            log.warning(`Failed to persist the storage alias mapping: ${error.message}`);
         }
-        // No platform-provided id for this alias (e.g. cloud storage used locally via an API
-        // token) — create an unnamed storage for it, one per alias per process.
-        const cacheKey = `${type}:${alias}`;
-        const cachedId = this.aliasIdCache.get(cacheKey);
-        if (cachedId)
-            return cachedId;
-        const created = await this.collectionClient(type).getOrCreate();
-        this.aliasIdCache.set(cacheKey, created.id);
-        return created.id;
+    }
+    /** The run's default key-value store, where the mapping lives — `undefined` off the platform. */
+    aliasMappingStore() {
+        return this.#config?.isAtHome ? this.#client.keyValueStore(this.#config.defaultKeyValueStoreId) : undefined;
     }
     /** Looks an alias up in the Actor's schema storages (the `ACTOR_STORAGES_JSON` env var). */
     aliasFromActorStorages(alias, type) {
-        const storagesJson = this.config?.actorStoragesJson;
+        const storagesJson = this.#config?.actorStoragesJson;
         if (!storagesJson)
             return undefined;
         let storages;
@@ -234,16 +287,16 @@ export class ApifyStorageBackend {
     }
     resourceClient(id, type) {
         if (type === 'Dataset')
-            return this.client.dataset(id);
+            return this.#client.dataset(id);
         if (type === 'KeyValueStore')
-            return this.client.keyValueStore(id);
-        return this.client.requestQueue(id);
+            return this.#client.keyValueStore(id);
+        return this.#client.requestQueue(id);
     }
     collectionClient(type) {
         if (type === 'Dataset')
-            return this.client.datasets();
+            return this.#client.datasets();
         if (type === 'KeyValueStore')
-            return this.client.keyValueStores();
-        return this.client.requestQueues();
+            return this.#client.keyValueStores();
+        return this.#client.requestQueues();
     }
 }

package/dist/charging.d.ts

@@ -54,20 +54,7 @@ export declare function mergeChargeResults(a: ChargeResult, b: ChargeResult): Ch
  * Handles pay-per-event charging.
  */
 export declare class ChargingManager {
-    private configuration;
-    private readonly LOCAL_CHARGING_LOG_DATASET_NAME;
-    private readonly PLATFORM_CHARGING_LOG_DATASET_ID_KEY;
-    private maxTotalChargeUsd;
-    private isAtHome;
-    private actorRunId?;
-    private pricingModel?;
-    private purgeChargingLogDataset;
-    private useChargingLogDataset;
-    private notPpeWarningPrinted;
-    private pricingInfo;
-    private chargingState?;
-    private chargingLogDataset?;
-    private apifyClient;
+    #private;
     constructor(configuration: Configuration, apifyClient: ApifyClient);
     private get isPayPerEvent();
     private fetchPricingInfo;

package/dist/charging.js

@@ -15,45 +15,45 @@ export function mergeChargeResults(a, b) {
  * Handles pay-per-event charging.
  */
 export class ChargingManager {
-    configuration;
-    LOCAL_CHARGING_LOG_DATASET_NAME = 'charging_log';
-    PLATFORM_CHARGING_LOG_DATASET_ID_KEY = 'CHARGING_LOG_DATASET_ID';
-    maxTotalChargeUsd;
-    isAtHome;
-    actorRunId;
-    pricingModel;
-    purgeChargingLogDataset;
-    useChargingLogDataset;
-    notPpeWarningPrinted = false;
-    pricingInfo = {};
-    chargingState;
-    chargingLogDataset;
-    apifyClient;
+    #LOCAL_CHARGING_LOG_DATASET_NAME = 'charging_log';
+    #PLATFORM_CHARGING_LOG_DATASET_ID_KEY = 'CHARGING_LOG_DATASET_ID';
+    #maxTotalChargeUsd;
+    #isAtHome;
+    #actorRunId;
+    #pricingModel;
+    #purgeChargingLogDataset;
+    #useChargingLogDataset;
+    #notPpeWarningPrinted = false;
+    #pricingInfo = {};
+    #chargingState;
+    #chargingLogDataset;
+    #apifyClient;
+    #configuration;
     constructor(configuration, apifyClient) {
-        this.configuration = configuration;
-        this.maxTotalChargeUsd = configuration.maxTotalChargeUsd || Infinity; // convert `0` to `Infinity` in case the value is an empty string
-        this.isAtHome = configuration.isAtHome;
-        this.actorRunId = configuration.actorRunId;
-        this.purgeChargingLogDataset = configuration.purgeOnStart;
-        this.useChargingLogDataset = configuration.useChargingLogDataset;
-        this.apifyClient = apifyClient;
+        this.#configuration = configuration;
+        this.#maxTotalChargeUsd = configuration.maxTotalChargeUsd || Infinity; // convert `0` to `Infinity` in case the value is an empty string
+        this.#isAtHome = configuration.isAtHome;
+        this.#actorRunId = configuration.actorRunId;
+        this.#purgeChargingLogDataset = configuration.purgeOnStart;
+        this.#useChargingLogDataset = configuration.useChargingLogDataset;
+        this.#apifyClient = apifyClient;
     }
     get isPayPerEvent() {
-        return this.pricingModel === 'PAY_PER_EVENT';
+        return this.#pricingModel === 'PAY_PER_EVENT';
     }
     async fetchPricingInfo() {
-        if (this.configuration.actorPricingInfo && this.configuration.chargedEventCounts) {
+        if (this.#configuration.actorPricingInfo && this.#configuration.chargedEventCounts) {
             return {
-                pricingInfo: JSON.parse(this.configuration.actorPricingInfo),
-                chargedEventCounts: JSON.parse(this.configuration.chargedEventCounts),
-                maxTotalChargeUsd: this.configuration.maxTotalChargeUsd || Infinity,
+                pricingInfo: JSON.parse(this.#configuration.actorPricingInfo),
+                chargedEventCounts: JSON.parse(this.#configuration.chargedEventCounts),
+                maxTotalChargeUsd: this.#configuration.maxTotalChargeUsd || Infinity,
             };
         }
-        if (this.isAtHome) {
-            if (this.actorRunId === undefined) {
+        if (this.#isAtHome) {
+            if (this.#actorRunId === undefined) {
                 throw new Error('Actor run ID not found even though the Actor is running on Apify');
             }
-            const run = await this.apifyClient.run(this.actorRunId).get();
+            const run = await this.#apifyClient.run(this.#actorRunId).get();
             if (run === undefined) {
                 throw new Error('Actor run not found');
             }
@@ -66,7 +66,7 @@ export class ChargingManager {
         return {
             pricingInfo: undefined,
             chargedEventCounts: {},
-            maxTotalChargeUsd: this.configuration.maxTotalChargeUsd || Infinity,
+            maxTotalChargeUsd: this.#configuration.maxTotalChargeUsd || Infinity,
         };
     }
     /**
@@ -74,63 +74,63 @@ export class ChargingManager {
      */
     async init() {
         // Validate config - it may have changed since the instantiation
-        if (this.useChargingLogDataset && this.isAtHome) {
+        if (this.#useChargingLogDataset && this.#isAtHome) {
             throw new Error('Using the ACTOR_USE_CHARGING_LOG_DATASET environment variable is only supported in a local development environment');
         }
-        if (this.configuration.testPayPerEvent) {
-            if (this.isAtHome) {
+        if (this.#configuration.testPayPerEvent) {
+            if (this.#isAtHome) {
                 throw new Error('Using the ACTOR_TEST_PAY_PER_EVENT environment variable is only supported in a local development environment');
             }
         }
         // Retrieve pricing information
         const { pricingInfo, chargedEventCounts, maxTotalChargeUsd } = await this.fetchPricingInfo();
-        if (this.configuration.testPayPerEvent) {
-            this.pricingModel = 'PAY_PER_EVENT';
+        if (this.#configuration.testPayPerEvent) {
+            this.#pricingModel = 'PAY_PER_EVENT';
         }
         else {
-            this.pricingModel ??= pricingInfo?.pricingModel;
+            this.#pricingModel ??= pricingInfo?.pricingModel;
         }
         // Load per-event pricing information
         if (pricingInfo?.pricingModel === 'PAY_PER_EVENT') {
             for (const [eventName, eventPricing] of Object.entries(pricingInfo.pricingPerEvent.actorChargeEvents)) {
-                this.pricingInfo[eventName] = {
+                this.#pricingInfo[eventName] = {
                     price: eventPricing.eventPriceUsd,
                     title: eventPricing.eventTitle,
                 };
             }
-            this.maxTotalChargeUsd = maxTotalChargeUsd;
+            this.#maxTotalChargeUsd = maxTotalChargeUsd;
         }
-        this.chargingState = {};
+        this.#chargingState = {};
         for (const [eventName, chargeCount] of Object.entries(chargedEventCounts ?? {})) {
-            this.chargingState[eventName] = {
+            this.#chargingState[eventName] = {
                 chargeCount,
-                totalChargedAmount: chargeCount * (this.pricingInfo[eventName]?.price ?? 0),
+                totalChargedAmount: chargeCount * (this.#pricingInfo[eventName]?.price ?? 0),
             };
         }
-        if (!this.isPayPerEvent || !this.useChargingLogDataset) {
+        if (!this.isPayPerEvent || !this.#useChargingLogDataset) {
             return;
         }
         // Set up charging log dataset
-        if (this.isAtHome) {
+        if (this.#isAtHome) {
             const datasetId = await this.ensureChargingLogDatasetOnPlatform();
-            this.chargingLogDataset = await Dataset.open(datasetId);
+            this.#chargingLogDataset = await Dataset.open(datasetId);
         }
         else {
-            if (this.purgeChargingLogDataset) {
-                const dataset = await Dataset.open(this.LOCAL_CHARGING_LOG_DATASET_NAME);
+            if (this.#purgeChargingLogDataset) {
+                const dataset = await Dataset.open(this.#LOCAL_CHARGING_LOG_DATASET_NAME);
                 await dataset.drop();
             }
-            this.chargingLogDataset = await Dataset.open(this.LOCAL_CHARGING_LOG_DATASET_NAME);
+            this.#chargingLogDataset = await Dataset.open(this.#LOCAL_CHARGING_LOG_DATASET_NAME);
         }
     }
     async ensureChargingLogDatasetOnPlatform() {
         const defaultStore = await KeyValueStore.open();
-        const storedDatasetId = await defaultStore.getValue(this.PLATFORM_CHARGING_LOG_DATASET_ID_KEY);
+        const storedDatasetId = await defaultStore.getValue(this.#PLATFORM_CHARGING_LOG_DATASET_ID_KEY);
         if (storedDatasetId !== null) {
             return storedDatasetId;
         }
-        const dataset = await this.apifyClient.datasets().getOrCreate();
-        await defaultStore.setValue(this.PLATFORM_CHARGING_LOG_DATASET_ID_KEY, dataset.id);
+        const dataset = await this.#apifyClient.datasets().getOrCreate();
+        await defaultStore.setValue(this.#PLATFORM_CHARGING_LOG_DATASET_ID_KEY, dataset.id);
         return dataset.id;
     }
     /**
@@ -138,20 +138,20 @@ export class ChargingManager {
      * {@link ChargingManager.getPricingInfo}) require an initialized manager.
      */
     get isInitialized() {
-        return this.chargingState !== undefined;
+        return this.#chargingState !== undefined;
     }
     /**
      * Get information about the pricing for this Actor.
      */
     getPricingInfo() {
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
         return {
-            pricingModel: this.pricingModel,
+            pricingModel: this.#pricingModel,
             isPayPerEvent: this.isPayPerEvent,
-            maxTotalChargeUsd: this.maxTotalChargeUsd,
-            perEventPrices: Object.fromEntries(Object.entries(this.pricingInfo).map(([eventName, { price }]) => [eventName, price])),
+            maxTotalChargeUsd: this.#maxTotalChargeUsd,
+            perEventPrices: Object.fromEntries(Object.entries(this.#pricingInfo).map(([eventName, { price }]) => [eventName, price])),
         };
     }
     /**
@@ -171,11 +171,14 @@ export class ChargingManager {
      * @param options The name of the event to charge for and the number of events to be charged.
      */
     async charge({ eventName, count = 1 }) {
-        const calculateChargeableWithinLimit = () => Object.fromEntries(Object.keys(this.pricingInfo).map((name) => [name, this.calculateMaxEventChargeCountWithinLimit(name)]));
+        const calculateChargeableWithinLimit = () => Object.fromEntries(Object.keys(this.#pricingInfo).map((name) => [
+            name,
+            this.calculateMaxEventChargeCountWithinLimit(name),
+        ]));
         if (!this.isPayPerEvent) {
-            if (!this.notPpeWarningPrinted) {
+            if (!this.#notPpeWarningPrinted) {
                 log.warning('Ignored attempt to charge for an event - the Actor does not use the pay-per-event pricing');
-                this.notPpeWarningPrinted = true;
+                this.#notPpeWarningPrinted = true;
             }
             return {
                 eventChargeLimitReached: false,
@@ -183,7 +186,7 @@ export class ChargingManager {
                 chargeableWithinLimit: calculateChargeableWithinLimit(),
             };
         }
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
         /* START OF CRITICAL SECTION - no awaits here */
@@ -195,7 +198,7 @@ export class ChargingManager {
             // If the caller tries to charge more than the budget allows, overcharge by one event
             // so that the Actor is detected by the platform and terminated.
             // But don't do this if already strictly over the budget - no point piling on charges.
-            if (this.calculateTotalChargedAmount() <= this.maxTotalChargeUsd) {
+            if (this.calculateTotalChargedAmount() <= this.#maxTotalChargeUsd) {
                 return maxEventChargeCount + 1;
             }
             return 0;
@@ -207,32 +210,32 @@ export class ChargingManager {
                 chargeableWithinLimit: calculateChargeableWithinLimit(),
             };
         }
-        const pricingInfo = this.pricingInfo[eventName] ?? {
-            price: this.isAtHome ? 0 : 1, // Use a nonzero price for local development so that the maximum budget can be reached
+        const pricingInfo = this.#pricingInfo[eventName] ?? {
+            price: this.#isAtHome ? 0 : 1, // Use a nonzero price for local development so that the maximum budget can be reached
             title: `Unknown event '${eventName}'`,
         };
-        this.chargingState[eventName] ??= {
+        this.#chargingState[eventName] ??= {
             chargeCount: 0,
             totalChargedAmount: 0,
         };
-        this.chargingState[eventName].chargeCount += chargedCount;
-        this.chargingState[eventName].totalChargedAmount += chargedCount * pricingInfo.price;
+        this.#chargingState[eventName].chargeCount += chargedCount;
+        this.#chargingState[eventName].totalChargedAmount += chargedCount * pricingInfo.price;
         /* END OF CRITICAL SECTION */
-        if (this.isAtHome) {
+        if (this.#isAtHome) {
             if (eventName.startsWith('apify-')) {
                 // Synthetic events (e.g. apify-default-dataset-item) are tracked locally only,
                 // the platform handles them automatically based on dataset writes.
             }
-            else if (this.pricingInfo[eventName] !== undefined) {
-                await this.apifyClient.run(this.actorRunId).charge({ eventName, count: chargedCount });
+            else if (this.#pricingInfo[eventName] !== undefined) {
+                await this.#apifyClient.run(this.#actorRunId).charge({ eventName, count: chargedCount });
             }
             else {
                 log.warning(`Attempting to charge for an unknown event '${eventName}'`);
             }
         }
         const timestamp = new Date().toISOString();
-        if (this.chargingLogDataset !== undefined) {
-            await this.chargingLogDataset.pushData({
+        if (this.#chargingLogDataset !== undefined) {
+            await this.#chargingLogDataset.pushData({
                 eventName,
                 eventTitle: pricingInfo.title,
                 eventPriceUsd: pricingInfo.price,
@@ -254,25 +257,25 @@ export class ChargingManager {
      * Get the number of events with given name that the Actor has charged for so far.
      */
     getChargedEventCount(eventName) {
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
-        return this.chargingState[eventName]?.chargeCount ?? 0;
+        return this.#chargingState[eventName]?.chargeCount ?? 0;
     }
     /**
      * Get the maximum amount of money that the Actor is allowed to charge.
      */
     getMaxTotalChargeUsd() {
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
-        return this.maxTotalChargeUsd;
+        return this.#maxTotalChargeUsd;
     }
     calculateTotalChargedAmount() {
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
-        const result = Object.values(this.chargingState)
+        const result = Object.values(this.#chargingState)
             .map(({ totalChargedAmount }) => totalChargedAmount)
             .reduce((sum, inc) => sum + inc, 0);
         // Keeping float precision issues at bay
@@ -283,7 +286,7 @@ export class ChargingManager {
      * If the event is not registered, returns Infinity (free of charge)
      */
     calculateMaxEventChargeCountWithinLimit(eventName) {
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
         const price = this.calculateEventPrice(eventName);
@@ -293,11 +296,11 @@ export class ChargingManager {
         return this.calculateMaxChargesByPrice(price);
     }
     calculateEventPrice(eventName) {
-        return this.isAtHome ? this.pricingInfo[eventName]?.price : 1; // Use a nonzero price for local development so that the maximum budget can be reached
+        return this.#isAtHome ? this.#pricingInfo[eventName]?.price : 1; // Use a nonzero price for local development so that the maximum budget can be reached
     }
     calculateMaxChargesByPrice(price) {
         // The raw number of events allowed by the budget
-        const unroundedResult = (this.maxTotalChargeUsd - this.calculateTotalChargedAmount()) / price;
+        const unroundedResult = (this.#maxTotalChargeUsd - this.calculateTotalChargedAmount()) / price;
         // First round as Math.floor(4.9999999999999999) will incorrectly return 5
         const roundedResult = Math.floor(Number(unroundedResult.toFixed(4)));
         return Math.max(0, roundedResult);
@@ -307,7 +310,7 @@ export class ChargingManager {
      * Returns the limited items and count to charge.
      */
     calculatePushDataLimits({ items, eventName, isDefaultDataset, }) {
-        if (this.chargingState === undefined) {
+        if (this.#chargingState === undefined) {
             throw new Error('ChargingManager is not initialized');
         }
         const itemsArray = Array.isArray(items) ? items : [items];
@@ -329,7 +332,7 @@ export class ChargingManager {
             // But don't do this if already strictly over the budget - no point piling on charges.
             if (itemsArray.length > 0 &&
                 maxChargedCount === 0 &&
-                this.calculateTotalChargedAmount() <= this.maxTotalChargeUsd) {
+                this.calculateTotalChargedAmount() <= this.#maxTotalChargeUsd) {
                 return 1;
             }
             return maxChargedCount;

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { ApifyStorageBackend, type ApifyStorageBackendOptions } from './apify_st
 export type { RequestQueueAccessMode } from './apify_request_queue_backend.js';
 export { ArgumentValidationError } from './utils.js';
 export { createTransformRequestFunction, type GlobInput, type PseudoUrlInput, type UrlPatternFilters, type UrlPatternRequestOptions, } from './enqueue_links_filters.js';
-export type { OpenStorageOptions, StorageAlias, StorageId, StorageName, StorageIdentifier, StorageIdentifierWithoutAlias, } from './storage.js';
+export type { OpenStorageOptions, StorageAlias, StorageId, StorageName, StorageIdentifier } from './storage.js';
 export { ChargeOptions, ChargeResult, ActorPricingInfo, ChargingManager } from './charging.js';
 export * from './configuration.js';
 export * from './proxy_configuration.js';