apify 4.0.0-beta.31 → 4.0.0-beta.32

package/dist/apify_request_queue_shared_backend.js

@@ -21,23 +21,23 @@ const HEAD_LOCK_LIMIT = 25;
  */
 export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
     /** Ids of requests locked by this client and waiting to be handed out by `fetchNextRequest`. */
-    headIds = [];
+    #headIds = [];
     /** Dedup records for requests known to exist on the platform, keyed by id. */
-    cachedRequestInfo = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
+    #cachedRequestInfo = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
     /** Ids of requests currently being processed by this client. */
-    inProgressIds = new Set();
+    #inProgressIds = new Set();
     /** Whether the last head read reported any locked requests left in the queue (any client's). */
-    queueHasLockedRequests;
+    #queueHasLockedRequests;
     /** Set after a forefront insert — the next head read starts fresh so the insert is honored. */
-    shouldCheckForefrontRequests = false;
+    #shouldCheckForefrontRequests = false;
     /** Lock duration applied to fetched requests; raised via `setExpectedRequestProcessingTimeSecs`. */
-    lockSecs = DEFAULT_REQUEST_LOCK_SECS;
+    #lockSecs = DEFAULT_REQUEST_LOCK_SECS;
     /** Serializes head reads and reclaims — both reorder the shared head state. */
-    headLock = new AsyncLock();
+    #headLock = new AsyncLock();
     async setExpectedRequestProcessingTimeSecs(secs) {
         // Only ever raise the lock duration — several consumers may share this client, and a
         // short-lived one must not cut the reservation of a long-running one short.
-        this.lockSecs = Math.max(this.lockSecs, secs);
+        this.#lockSecs = Math.max(this.#lockSecs, secs);
     }
     async addBatchOfRequests(requests, options = {}) {
         const { forefront = false } = options;
@@ -48,7 +48,7 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         const newRequests = [];
         for (const request of requests) {
             const id = this.requestIdFromUniqueKey(request.uniqueKey);
-            const cached = this.cachedRequestInfo.get(id);
+            const cached = this.#cachedRequestInfo.get(id);
             if (cached) {
                 alreadyPresent.push({
                     requestId: id,
@@ -70,7 +70,7 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
             // A forefront insert changes the head order — have the next head read re-fetch the
             // front of the queue instead of draining the local buffer first.
             if (forefront) {
-                this.shouldCheckForefrontRequests = true;
+                this.#shouldCheckForefrontRequests = true;
             }
         }
         result.processedRequests.push(...alreadyPresent);
@@ -83,9 +83,9 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         return this.getRequestById(this.requestIdFromUniqueKey(uniqueKey));
     }
     async fetchNextRequest() {
-        const id = await this.headLock.runExclusive(async () => {
+        const id = await this.#headLock.runExclusive(async () => {
             await this.ensureHeadIsNonEmpty();
-            return this.headIds.shift();
+            return this.#headIds.shift();
         });
         if (!id)
             return undefined;
@@ -103,7 +103,7 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
             this.cacheRequestInfo(id, { wasAlreadyHandled: true });
             return undefined;
         }
-        this.inProgressIds.add(id);
+        this.#inProgressIds.add(id);
         return request;
     }
     async markRequestAsHandled(request) {
@@ -111,12 +111,12 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         // Contract: marking a request that does not exist in the queue is a no-op — it must not be
         // added as a side effect (the platform update endpoint would upsert it).
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
         const handledAt = request.handledAt ?? new Date().toISOString();
         const info = await this.updateRequestOnPlatform({ ...request, id, handledAt });
-        this.inProgressIds.delete(id);
+        this.#inProgressIds.delete(id);
         this.cacheRequestInfo(id, { wasAlreadyHandled: true });
         if (!info.wasAlreadyHandled) {
             this.estimatedHandledRequestCount += 1;
@@ -128,10 +128,10 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         const id = this.requestIdFromUniqueKey(request.uniqueKey);
         // Same contract as `markRequestAsHandled` — never insert as a side effect.
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
-        return this.headLock.runExclusive(async () => {
+        return this.#headLock.runExclusive(async () => {
             const info = await this.updateRequestOnPlatform({ ...request, id, handledAt: undefined }, forefront);
             // Release the server-side lock so the request becomes fetchable again immediately —
             // by any consumer — rather than only after the lock expires.
@@ -141,10 +141,10 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
             catch (err) {
                 log.debug(`Failed to delete the lock of a reclaimed request (id: ${id}): ${err.message}`);
             }
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             this.cacheRequestInfo(id, { wasAlreadyHandled: false });
             if (forefront) {
-                this.shouldCheckForefrontRequests = true;
+                this.#shouldCheckForefrontRequests = true;
             }
             if (info.wasAlreadyHandled) {
                 this.estimatedHandledRequestCount -= 1;
@@ -153,25 +153,25 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         });
     }
     async isEmpty() {
-        return this.headLock.runExclusive(async () => {
-            if (this.headIds.length > 0)
+        return this.#headLock.runExclusive(async () => {
+            if (this.#headIds.length > 0)
                 return false;
             await this.listAndLockHead(1);
-            return this.headIds.length === 0;
+            return this.#headIds.length === 0;
         });
     }
     async isFinished() {
-        return this.headLock.runExclusive(async () => {
-            if (this.headIds.length > 0)
+        return this.#headLock.runExclusive(async () => {
+            if (this.#headIds.length > 0)
                 return false;
             // The head read also refreshes `queueHasLockedRequests`, so the order matters here.
             await this.listAndLockHead(1);
-            return this.headIds.length === 0 && !this.queueHasLockedRequests;
+            return this.#headIds.length === 0 && !this.#queueHasLockedRequests;
         });
     }
     /** Must be called with the head lock held. */
     async ensureHeadIsNonEmpty() {
-        if (this.headIds.length > 1 && !this.shouldCheckForefrontRequests) {
+        if (this.#headIds.length > 1 && !this.#shouldCheckForefrontRequests) {
             return;
         }
         await this.listAndLockHead(HEAD_LOCK_LIMIT);
@@ -181,31 +181,31 @@ export class ApifyRequestQueueSharedBackend extends ApifyRequestQueueBackend {
         // After a forefront insert the local buffer no longer starts at the true front of the
         // queue — re-fetch the front and keep the already-locked leftovers for afterwards.
         let leftoverIds = [];
-        if (this.shouldCheckForefrontRequests) {
-            leftoverIds = this.headIds.splice(0);
-            this.shouldCheckForefrontRequests = false;
+        if (this.#shouldCheckForefrontRequests) {
+            leftoverIds = this.#headIds.splice(0);
+            this.#shouldCheckForefrontRequests = false;
         }
-        const head = await this.client.listAndLockHead({ limit, lockSecs: this.lockSecs });
-        this.queueHasLockedRequests = head.queueHasLockedRequests;
+        const head = await this.client.listAndLockHead({ limit, lockSecs: this.#lockSecs });
+        this.#queueHasLockedRequests = head.queueHasLockedRequests;
         for (const item of head.items) {
-            if (this.inProgressIds.has(item.id))
+            if (this.#inProgressIds.has(item.id))
                 continue;
-            if (this.headIds.includes(item.id) || leftoverIds.includes(item.id))
+            if (this.#headIds.includes(item.id) || leftoverIds.includes(item.id))
                 continue;
             this.cacheRequestInfo(item.id, { wasAlreadyHandled: false });
-            this.headIds.push(item.id);
+            this.#headIds.push(item.id);
         }
-        this.headIds.push(...leftoverIds);
+        this.#headIds.push(...leftoverIds);
     }
     async isKnownOrExists(id) {
-        if (this.inProgressIds.has(id) || this.cachedRequestInfo.get(id)) {
+        if (this.#inProgressIds.has(id) || this.#cachedRequestInfo.get(id)) {
             return true;
         }
         return (await this.getRequestById(id)) !== undefined;
     }
     cacheRequestInfo(id, info) {
         // `LruCache.add` does not overwrite existing entries, so remove first.
-        this.cachedRequestInfo.remove(id);
-        this.cachedRequestInfo.add(id, info);
+        this.#cachedRequestInfo.remove(id);
+        this.#cachedRequestInfo.add(id, info);
     }
 }

package/dist/apify_request_queue_single_backend.d.ts

@@ -22,16 +22,7 @@ import { ApifyRequestQueueBackend } from './apify_request_queue_backend.js';
  * @internal
  */
 export declare class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
-    /** Local estimate of the queue head — request ids in the order they should be fetched. */
-    private readonly headIds;
-    /** Unhandled full request objects added by (or fetched through) this client, keyed by id. */
-    private readonly cachedRequests;
-    /** Ids of requests known to be already handled — cheap dedup without caching full objects. */
-    private readonly handledIds;
-    /** Ids of requests currently being processed by this client. */
-    private readonly inProgressIds;
-    /** Memoized one-time prefetch of existing queue contents into the local caches. */
-    private initCachesPromise?;
+    #private;
     addBatchOfRequests(requests: RequestSchema[], options?: RequestQueueOperationOptions): Promise<BatchAddRequestsResult>;
     getRequest(uniqueKey: string): Promise<UpdateRequestSchema | undefined>;
     fetchNextRequest(): Promise<UpdateRequestSchema | undefined>;

package/dist/apify_request_queue_single_backend.js

@@ -32,25 +32,25 @@ const INIT_CACHES_REQUEST_LIMIT = 10_000;
  */
 export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     /** Local estimate of the queue head — request ids in the order they should be fetched. */
-    headIds = [];
+    #headIds = [];
     /** Unhandled full request objects added by (or fetched through) this client, keyed by id. */
-    cachedRequests = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
+    #cachedRequests = new LruCache({ maxLength: MAX_CACHED_REQUESTS });
     /** Ids of requests known to be already handled — cheap dedup without caching full objects. */
-    handledIds = new Set();
+    #handledIds = new Set();
     /** Ids of requests currently being processed by this client. */
-    inProgressIds = new Set();
+    #inProgressIds = new Set();
     /** Memoized one-time prefetch of existing queue contents into the local caches. */
-    initCachesPromise;
+    #initCachesPromise;
     async addBatchOfRequests(requests, options = {}) {
         const { forefront = false } = options;
-        await (this.initCachesPromise ??= this.initCaches());
+        await (this.#initCachesPromise ??= this.initCaches());
         // Split the batch into requests we already know about (dedup them locally — a platform
         // write costs an API call and a paid write operation) and genuinely new ones.
         const alreadyPresent = [];
         const newRequests = [];
         for (const request of requests) {
             const id = this.requestIdFromUniqueKey(request.uniqueKey);
-            if (this.handledIds.has(id)) {
+            if (this.#handledIds.has(id)) {
                 alreadyPresent.push({
                     requestId: id,
                     uniqueKey: request.uniqueKey,
@@ -58,7 +58,7 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
                     wasAlreadyHandled: true,
                 });
             }
-            else if (this.cachedRequests.get(id)) {
+            else if (this.#cachedRequests.get(id)) {
                 alreadyPresent.push({
                     requestId: id,
                     uniqueKey: request.uniqueKey,
@@ -83,15 +83,15 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
                 if (!processed)
                     continue; // rejected by the platform, reported in `unprocessedRequests`
                 if (processed.wasAlreadyHandled) {
-                    this.handledIds.add(processed.requestId);
+                    this.#handledIds.add(processed.requestId);
                     continue;
                 }
                 this.cacheRequest({ ...request, id: processed.requestId });
                 if (forefront) {
-                    this.headIds.unshift(processed.requestId);
+                    this.#headIds.unshift(processed.requestId);
                 }
                 else {
-                    this.headIds.push(processed.requestId);
+                    this.#headIds.push(processed.requestId);
                 }
             }
         }
@@ -101,16 +101,16 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     }
     async getRequest(uniqueKey) {
         const id = this.requestIdFromUniqueKey(uniqueKey);
-        const cached = this.cachedRequests.get(id);
+        const cached = this.#cachedRequests.get(id);
         if (cached)
             return cached;
         const request = await this.getRequestById(id);
         if (!request)
             return undefined;
         // Requests already in progress are ones the client knows about — no caching needed.
-        if (!this.inProgressIds.has(id)) {
+        if (!this.#inProgressIds.has(id)) {
             if (request.handledAt) {
-                this.handledIds.add(id);
+                this.#handledIds.add(id);
             }
             else {
                 this.cacheRequest(request);
@@ -120,24 +120,24 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     }
     async fetchNextRequest() {
         await this.ensureHeadIsNonEmpty();
-        while (this.headIds.length > 0) {
-            const id = this.headIds.shift();
-            if (this.inProgressIds.has(id) || this.handledIds.has(id)) {
+        while (this.#headIds.length > 0) {
+            const id = this.#headIds.shift();
+            if (this.#inProgressIds.has(id) || this.#handledIds.has(id)) {
                 continue;
             }
-            this.inProgressIds.add(id);
+            this.#inProgressIds.add(id);
             // Requests added by this client are served straight from the cache; only requests
             // discovered via `listHead` (added by another producer) need a round-trip.
-            const request = this.cachedRequests.get(id) ?? (await this.getRequestById(id));
+            const request = this.#cachedRequests.get(id) ?? (await this.getRequestById(id));
             if (!request) {
-                this.inProgressIds.delete(id);
+                this.#inProgressIds.delete(id);
                 continue;
             }
             if (request.handledAt) {
                 // Handled elsewhere in the meantime — skip it and remember the outcome.
-                this.inProgressIds.delete(id);
-                this.handledIds.add(id);
-                this.cachedRequests.remove(id);
+                this.#inProgressIds.delete(id);
+                this.#handledIds.add(id);
+                this.#cachedRequests.remove(id);
                 continue;
             }
             return request;
@@ -149,14 +149,14 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
         // Contract: marking a request that does not exist in the queue is a no-op — it must not be
         // added as a side effect (the platform update endpoint would upsert it).
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
         const handledAt = request.handledAt ?? new Date().toISOString();
         const info = await this.updateRequestOnPlatform({ ...request, id, handledAt });
-        this.inProgressIds.delete(id);
-        this.handledIds.add(id);
-        this.cachedRequests.remove(id);
+        this.#inProgressIds.delete(id);
+        this.#handledIds.add(id);
+        this.#cachedRequests.remove(id);
         if (!info.wasAlreadyHandled) {
             this.estimatedHandledRequestCount += 1;
         }
@@ -167,24 +167,24 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
         const id = this.requestIdFromUniqueKey(request.uniqueKey);
         // Same contract as `markRequestAsHandled` — never insert as a side effect.
         if (!(await this.isKnownOrExists(id))) {
-            this.inProgressIds.delete(id);
+            this.#inProgressIds.delete(id);
             return undefined;
         }
         // Reclaiming returns the request to the queue for reprocessing.
         const reclaimed = { ...request, id, handledAt: undefined };
         const info = await this.updateRequestOnPlatform(reclaimed, forefront);
-        this.inProgressIds.delete(id);
-        this.handledIds.delete(id);
+        this.#inProgressIds.delete(id);
+        this.#handledIds.delete(id);
         this.cacheRequest(reclaimed);
         // Return the id to the local head estimate right away — the platform head read can lag a
         // few seconds behind the update, and `isFinished` must never report `true` while a
         // reclaimed request is still waiting to be reprocessed.
-        if (!this.headIds.includes(id)) {
+        if (!this.#headIds.includes(id)) {
             if (forefront) {
-                this.headIds.unshift(id);
+                this.#headIds.unshift(id);
             }
             else {
-                this.headIds.push(id);
+                this.#headIds.push(id);
             }
         }
         if (info.wasAlreadyHandled) {
@@ -194,28 +194,28 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
     }
     async isEmpty() {
         await this.ensureHeadIsNonEmpty();
-        return this.headIds.length === 0;
+        return this.#headIds.length === 0;
     }
     async isFinished() {
-        return (await this.isEmpty()) && this.inProgressIds.size === 0;
+        return (await this.isEmpty()) && this.#inProgressIds.size === 0;
     }
     async ensureHeadIsNonEmpty() {
-        if (this.headIds.length <= 1) {
+        if (this.#headIds.length <= 1) {
             await this.listHead();
         }
     }
     async listHead() {
         // The head read returns in-progress requests too, so fetch enough to find new ones.
-        const limit = Math.min(MAX_HEAD_ITEMS, DESIRED_NEW_HEAD_ITEMS + this.inProgressIds.size);
+        const limit = Math.min(MAX_HEAD_ITEMS, DESIRED_NEW_HEAD_ITEMS + this.#inProgressIds.size);
         const head = await this.client.listHead({ limit });
         for (const item of head.items) {
-            if (this.inProgressIds.has(item.id) || this.handledIds.has(item.id)) {
+            if (this.#inProgressIds.has(item.id) || this.#handledIds.has(item.id)) {
                 continue;
             }
             // `headIds` is nearly drained whenever this runs (see `ensureHeadIsNonEmpty`), so the
             // linear dedup scan stays cheap.
-            if (!this.headIds.includes(item.id)) {
-                this.headIds.push(item.id);
+            if (!this.#headIds.includes(item.id)) {
+                this.#headIds.push(item.id);
             }
         }
     }
@@ -229,7 +229,7 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
             const response = await this.client.listRequests({ limit: INIT_CACHES_REQUEST_LIMIT });
             for (const request of response.items) {
                 if (request.handledAt) {
-                    this.handledIds.add(request.id);
+                    this.#handledIds.add(request.id);
                 }
                 else {
                     this.cacheRequest(request);
@@ -243,14 +243,14 @@ export class ApifyRequestQueueSingleBackend extends ApifyRequestQueueBackend {
         }
     }
     async isKnownOrExists(id) {
-        if (this.inProgressIds.has(id) || this.handledIds.has(id) || this.cachedRequests.get(id)) {
+        if (this.#inProgressIds.has(id) || this.#handledIds.has(id) || this.#cachedRequests.get(id)) {
             return true;
         }
         return (await this.getRequestById(id)) !== undefined;
     }
     cacheRequest(request) {
         // `LruCache.add` does not overwrite existing entries, so remove first.
-        this.cachedRequests.remove(request.id);
-        this.cachedRequests.add(request.id, request);
+        this.#cachedRequests.remove(request.id);
+        this.#cachedRequests.add(request.id, request);
     }
 }

package/dist/apify_storage_backend.d.ts

@@ -62,18 +62,7 @@ export interface ApifyStorageBackendOptions {
  * ```
  */
 export declare class ApifyStorageBackend implements StorageBackend {
-    private readonly client;
-    private readonly config?;
-    private readonly requestQueueAccess;
-    private readonly getChargingManager?;
-    /** Unnamed storages resolved for aliases in this process, keyed like {@link AliasMapping}. */
-    private readonly aliasIdCache;
-    /** The alias mapping read from the run's default key-value store; `undefined` until first read. */
-    private persistedAliasIds?;
-    /** Serializes alias resolution — see `resolveAliasId`. */
-    private readonly aliasLock;
-    /** Fallback request queue client key when the run id is unavailable — one per backend. */
-    private fallbackClientKey?;
+    #private;
     constructor(client: ApifyClient, options?: ApifyStorageBackendOptions);
     /**
      * Partitions crawlee's storage-instance cache by API base URL and token, so the same storage

package/dist/apify_storage_backend.js

@@ -40,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') {
@@ -62,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,
@@ -99,23 +99,23 @@ class PpeAwareDatasetClient extends ApifyDatasetClient {
  * ```
  */
 export class ApifyStorageBackend {
-    client;
-    config;
-    requestQueueAccess;
-    getChargingManager;
+    #client;
+    #config;
+    #requestQueueAccess;
+    #getChargingManager;
     /** Unnamed storages resolved for aliases in this process, keyed like {@link AliasMapping}. */
-    aliasIdCache = new Map();
+    #aliasIdCache = new Map();
     /** The alias mapping read from the run's default key-value store; `undefined` until first read. */
-    persistedAliasIds;
+    #persistedAliasIds;
     /** Serializes alias resolution — see `resolveAliasId`. */
-    aliasLock = new AsyncLock();
+    #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
@@ -129,7 +129,7 @@ export class ApifyStorageBackend {
     /** 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 ?? ''}`)
+            .update(`${this.#client.publicBaseUrl}${this.#client.token ?? ''}`)
             .digest('hex')
             .slice(0, 8);
     }
@@ -145,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.
@@ -155,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);
     }
@@ -169,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);
     }
     /**
@@ -178,20 +178,20 @@ 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);
     }
     /**
@@ -211,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;
         }
@@ -233,20 +233,20 @@ export class ApifyStorageBackend {
         // 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);
+        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) : {};
+            this.#persistedAliasIds ??= store ? await readAliasMapping(store) : {};
             // A persisted id can point at a storage the user has since deleted.
-            const persistedId = this.persistedAliasIds[key];
+            const persistedId = this.#persistedAliasIds[key];
             if (persistedId && (await this.resourceClient(persistedId, type).get())) {
-                this.aliasIdCache.set(key, persistedId);
+                this.#aliasIdCache.set(key, persistedId);
                 return persistedId;
             }
             const { id } = await this.collectionClient(type).getOrCreate();
-            this.aliasIdCache.set(key, id);
+            this.#aliasIdCache.set(key, id);
             if (store)
                 await this.persistAliasId(store, key, id);
             return id;
@@ -261,7 +261,7 @@ export class ApifyStorageBackend {
             const mapping = await readAliasMapping(store);
             mapping[key] = id;
             await store.setRecord({ key: ALIAS_MAPPING_RECORD_KEY, value: mapping });
-            this.persistedAliasIds = mapping;
+            this.#persistedAliasIds = mapping;
         }
         catch (error) {
             log.warning(`Failed to persist the storage alias mapping: ${error.message}`);
@@ -269,11 +269,11 @@ export class ApifyStorageBackend {
     }
     /** 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;
+        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;
@@ -287,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();
     }
 }