@crawlee/core 4.0.0-beta.98 → 4.0.0-rc.0

package/request.js

@@ -1,32 +1,13 @@
 import crypto from 'node:crypto';
 import util from 'node:util';
-import ow from 'ow';
+import { z } from 'zod';
 import { cryptoRandomObjectId, normalizeUrl } from '@apify/utilities';
 import { serviceLocator } from './service_locator.js';
 import { keys } from './typedefs.js';
-// new properties on the Request object breaks serialization
-const requestOptionalPredicates = {
-    id: ow.optional.string,
-    loadedUrl: ow.optional.string.url,
-    uniqueKey: ow.optional.string,
-    method: ow.optional.string,
-    payload: ow.optional.any(ow.string, ow.uint8Array),
-    noRetry: ow.optional.boolean,
-    retryCount: ow.optional.number,
-    sessionId: ow.optional.string,
-    maxRetries: ow.optional.number,
-    errorMessages: ow.optional.array.ofType(ow.string),
-    headers: ow.optional.object,
-    userData: ow.optional.object,
-    label: ow.optional.string,
-    handledAt: ow.optional.any(ow.string.date, ow.date),
-    keepUrlFragment: ow.optional.boolean,
-    useExtendedUniqueKey: ow.optional.boolean,
-    alwaysEnqueue: ow.optional.boolean,
-    skipNavigation: ow.optional.boolean,
-    crawlDepth: ow.optional.number.greaterThanOrEqual(0),
-    state: ow.optional.number.greaterThanOrEqual(0).lessThanOrEqual(6),
-};
+import { parseArgument, schemas } from './validators.js';
+const dateString = z.string().refine((value) => !Number.isNaN(Date.parse(value)), {
+    message: 'Invalid input: expected a date string',
+});
 export var RequestState;
 (function (RequestState) {
     RequestState[RequestState["UNPROCESSED"] = 0] = "UNPROCESSED";
@@ -38,6 +19,34 @@ export var RequestState;
     RequestState[RequestState["ERROR"] = 6] = "ERROR";
     RequestState[RequestState["SKIPPED"] = 7] = "SKIPPED";
 })(RequestState || (RequestState = {}));
+const requestUrlSchema = z.object({ url: z.string() });
+// new properties on the Request object breaks serialization
+const requestOptionalSchemaShapes = {
+    id: z.string().optional(),
+    loadedUrl: z.url().optional(),
+    uniqueKey: z.string().optional(),
+    method: z.string().optional(),
+    payload: z.union([z.string(), z.instanceof(Uint8Array)]).optional(),
+    noRetry: z.boolean().optional(),
+    retryCount: schemas.anyNumber.optional(),
+    sessionId: z.string().optional(),
+    maxRetries: schemas.anyNumber.optional(),
+    errorMessages: schemas.arrayOf(z.string(), 'strings').optional(),
+    headers: z.looseObject({}).optional(),
+    userData: z.looseObject({}).optional(),
+    label: z.string().optional(),
+    handledAt: z.union([dateString, z.date()]).optional(),
+    keepUrlFragment: z.boolean().optional(),
+    useExtendedUniqueKey: z.boolean().optional(),
+    alwaysEnqueue: z.boolean().optional(),
+    skipNavigation: z.boolean().optional(),
+    crawlDepth: schemas.anyNumber
+        .refine((value) => value >= 0, 'Expected a number greater than or equal to 0')
+        .optional(),
+    state: z.enum(RequestState).optional(),
+};
+// Each schema is wrapped in a single-key object so validation errors carry the property name.
+const requestOptionalSchemas = Object.fromEntries(Object.entries(requestOptionalSchemaShapes).map(([key, schema]) => [key, z.object({ [key]: schema })]));
 /**
  * Represents a URL to be crawled, optionally including HTTP method, headers, payload and other metadata.
  * The `Request` object also stores information about errors that occurred during processing of the request.
@@ -101,7 +110,7 @@ class CrawleeRequest {
     /** Object with HTTP headers. Key is header name, value is the value. */
     headers;
     /** Private store for the custom user data assigned to the request. */
-    _userData = {};
+    #userData = {};
     /**
      * Custom user data assigned to the request.
      *
@@ -118,22 +127,26 @@ class CrawleeRequest {
      * `Request` parameters including the URL, HTTP method and headers, and others.
      */
     constructor(options) {
-        ow(options, 'RequestOptions', ow.object);
-        ow(options.url, 'RequestOptions.url', ow.string);
-        // 'ow' validation is slow, because it checks all predicates
+        // A bare URL is a common slip — point at the object form instead of a generic type error.
+        if (typeof options === 'string') {
+            throw new TypeError(`\`Request\` options must be an object, got the string '${options}'. ` +
+                'Did you mean `new Request({ url })`?');
+        }
+        parseArgument(options, schemas.anyObject, 'RequestOptions');
+        parseArgument(options, requestUrlSchema, 'RequestOptions');
+        // Full-shape validation is slow, because it checks all predicates
         // even if the validated object has only 1 property.
         // This custom validation loop iterates only over existing
         // properties and speeds up the validation cca 3-fold.
-        // See https://github.com/sindresorhus/ow/issues/193
         keys(options).forEach((prop) => {
             // skip url, because it is validated above
             if (prop === 'url') {
                 return;
             }
-            const predicate = requestOptionalPredicates[prop];
+            const schema = requestOptionalSchemas[prop];
             const value = options[prop];
-            if (predicate) {
-                ow(value, `RequestOptions.${prop}`, predicate);
+            if (schema) {
+                parseArgument({ [prop]: value }, schema, 'RequestOptions');
             }
         });
         const { id, url, loadedUrl, uniqueKey, payload, noRetry = false, retryCount = 0, sessionId, maxRetries, errorMessages = [], headers = {}, userData = {}, label, handledAt, keepUrlFragment = false, useExtendedUniqueKey = false, alwaysEnqueue = false, skipNavigation, enqueueStrategy, crawlDepth, } = options;
@@ -167,36 +180,36 @@ class CrawleeRequest {
         if (label) {
             userData.label = label;
         }
+        // Read `__crawlee` explicitly - on a `userData` coming from another Request instance the
+        // bag is non-enumerable, so the spread alone would silently drop the internal state
+        // (e.g. `skipNavigation`) when a request is re-wrapped after a storage round trip.
+        this.#userData = { __crawlee: userData.__crawlee ?? {}, ...userData };
+        // `userData` must stay an enumerable own accessor — serialization in the storages relies on it
         Object.defineProperties(this, {
-            _userData: {
-                value: { __crawlee: {}, ...userData },
-                enumerable: false,
-                writable: true,
-            },
             userData: {
-                get: () => this._userData,
+                get: () => this.#userData,
                 set: (value) => {
                     Object.defineProperties(value, {
                         __crawlee: {
-                            value: this._userData.__crawlee,
+                            value: this.#userData.__crawlee,
                             enumerable: false,
                             writable: true,
                         },
                         toJSON: {
                             value: () => {
-                                if (Object.keys(this._userData.__crawlee).length > 0) {
+                                if (Object.keys(this.#userData.__crawlee).length > 0) {
                                     return {
-                                        ...this._userData,
-                                        __crawlee: this._userData.__crawlee,
+                                        ...this.#userData,
+                                        __crawlee: this.#userData.__crawlee,
                                     };
                                 }
-                                return this._userData;
+                                return this.#userData;
                             },
                             enumerable: false,
                             writable: true,
                         },
                     });
-                    this._userData = value;
+                    this.#userData = value;
                 },
                 enumerable: true,
             },

package/router.d.ts

@@ -48,7 +48,6 @@ export type RoutesFromSchemas<Schemas extends RouteSchemas> = {
 /**
  * The `userData` type of the default route: inferred from the {@link defaultRoute} schema when the route map
  * carries one, otherwise the provided `Fallback`.
- * @internal
  */
 export type DefaultRouteUserData<Routes, Fallback extends Dictionary> = Routes extends {
     [defaultRoute]: infer DefaultUserData extends Dictionary;
@@ -66,7 +65,7 @@ export declare function validateUserData(label: string | symbol, schema: Standar
  * `Record<string, ...>`), any string or symbol label is accepted, preserving the original behaviour.
  */
 export type RouterLabel<Routes extends Record<keyof Routes, Dictionary>> = string extends keyof Routes ? string | symbol : (keyof Routes & string) | symbol;
-export interface RouterHandler<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>> extends Router<Context, Routes> {
+export interface RouterHandler<Context extends RestrictedCrawlingContext = CrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>> extends Router<Context, Routes> {
     (ctx: Context): Awaitable<void>;
 }
 export type GetUserDataFromRequest<T> = T extends Request<infer Y> ? Y : never;
@@ -215,11 +214,8 @@ export type RouterRoutes<Context, Routes extends Record<keyof Routes, Dictionary
  * });
  * ```
  */
-export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'>, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>> {
-    private readonly routes;
-    private readonly schemas;
-    private readonly timeouts;
-    private readonly middlewares;
+export declare class Router<Context extends RestrictedCrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>> {
+    #private;
     /**
      * use Router.create() instead!
      * @ignore
@@ -303,8 +299,8 @@ export declare class Router<Context extends Omit<RestrictedCrawlingContext, 'enq
      * await crawler.run();
      * ```
      */
-    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>>(routes?: RouterRoutes<Context, Routes>): RouterHandler<Context, Routes>;
-    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(routes?: RouterRoutes<Context, Record<string, UserData>>): RouterHandler<Context, Record<string, UserData>>;
-    static create<Context extends Omit<RestrictedCrawlingContext, 'enqueueLinks'> = CrawlingContext, const Schemas extends RouteSchemas = RouteSchemas>(schemas: Schemas): RouterHandler<Context, RoutesFromSchemas<Schemas>>;
+    static create<Context extends RestrictedCrawlingContext = CrawlingContext, Routes extends Record<keyof Routes, Dictionary> = Record<string, GetUserDataFromRequest<Context['request']>>>(routes?: RouterRoutes<Context, Routes>): RouterHandler<Context, Routes>;
+    static create<Context extends RestrictedCrawlingContext = CrawlingContext, UserData extends Dictionary = GetUserDataFromRequest<Context['request']>>(routes?: RouterRoutes<Context, Record<string, UserData>>): RouterHandler<Context, Record<string, UserData>>;
+    static create<Context extends RestrictedCrawlingContext = CrawlingContext, const Schemas extends RouteSchemas = RouteSchemas>(schemas: Schemas): RouterHandler<Context, RoutesFromSchemas<Schemas>>;
 }
 export {};

package/router.js

@@ -161,10 +161,10 @@ export async function validateUserData(label, schema, userData) {
  * ```
  */
 export class Router {
-    routes = new Map();
-    schemas = new Map();
-    timeouts = new Map();
-    middlewares = [];
+    #routes = new Map();
+    #schemas = new Map();
+    #timeouts = new Map();
+    #middlewares = [];
     /**
      * use Router.create() instead!
      * @ignore
@@ -172,9 +172,9 @@ export class Router {
     constructor() { }
     addHandler(label, handler, options = {}) {
         this.validate(label);
-        this.routes.set(label, handler);
+        this.#routes.set(label, handler);
         if (options.requestHandlerTimeoutSecs !== undefined) {
-            this.timeouts.set(label, options.requestHandlerTimeoutSecs);
+            this.#timeouts.set(label, options.requestHandlerTimeoutSecs);
         }
     }
     /**
@@ -187,9 +187,9 @@ export class Router {
      */
     addDefaultHandler(handler, options = {}) {
         this.validate(defaultRoute);
-        this.routes.set(defaultRoute, handler);
+        this.#routes.set(defaultRoute, handler);
         if (options.requestHandlerTimeoutSecs !== undefined) {
-            this.timeouts.set(defaultRoute, options.requestHandlerTimeoutSecs);
+            this.#timeouts.set(defaultRoute, options.requestHandlerTimeoutSecs);
         }
     }
     /**
@@ -199,25 +199,25 @@ export class Router {
      */
     getSchema(label) {
         if (label != null) {
-            const schema = this.schemas.get(label);
+            const schema = this.#schemas.get(label);
             if (schema) {
                 return schema;
             }
             // A label with its own route is fully specified; don't fall back to the default-route schema.
-            if (this.routes.has(label)) {
+            if (this.#routes.has(label)) {
                 return undefined;
             }
         }
         // Requests with no route of their own fall through to the default handler, so validate their
         // `userData` against the default-route schema, if one was registered.
-        return this.schemas.get(defaultRoute);
+        return this.#schemas.get(defaultRoute);
     }
     /**
      * Registers a middleware that will be fired before the matching route handler.
      * Multiple middlewares can be registered, they will be fired in the same order.
      */
     use(middleware) {
-        this.middlewares.push(middleware);
+        this.#middlewares.push(middleware);
     }
     /**
      * Returns the `requestHandlerTimeoutSecs` registered for a label, or `undefined` when the route did not
@@ -226,27 +226,27 @@ export class Router {
      * the default route asked for. Used by the crawler; not meant to be called directly.
      */
     getTimeoutSecs(label) {
-        if (label && this.routes.has(label)) {
-            return this.timeouts.get(label);
+        if (label && this.#routes.has(label)) {
+            return this.#timeouts.get(label);
         }
-        return this.timeouts.get(defaultRoute);
+        return this.#timeouts.get(defaultRoute);
     }
     /**
      * The longest `requestHandlerTimeoutSecs` any route asked for, or `undefined` when no route overrides it.
      * The crawler needs an upper bound up front, before it knows which routes a run will actually hit.
      */
     getMaxTimeoutSecs() {
-        return this.timeouts.size > 0 ? Math.max(...this.timeouts.values()) : undefined;
+        return this.#timeouts.size > 0 ? Math.max(...this.#timeouts.values()) : undefined;
     }
     /**
      * Returns route handler for given label. If no label is provided, the default request handler will be returned.
      */
     getHandler(label) {
-        if (label && this.routes.has(label)) {
-            return this.routes.get(label);
+        if (label && this.#routes.has(label)) {
+            return this.#routes.get(label);
         }
-        if (this.routes.has(defaultRoute)) {
-            return this.routes.get(defaultRoute);
+        if (this.#routes.has(defaultRoute)) {
+            return this.#routes.get(defaultRoute);
         }
         throw new MissingRouteError(`Route not found for label '${String(label)}'.` +
             ' You must set up a route for this label or a default route.' +
@@ -267,7 +267,7 @@ export class Router {
      * Throws when the label already exists in our registry.
      */
     validate(label) {
-        if (this.routes.has(label)) {
+        if (this.#routes.has(label)) {
             const message = label === defaultRoute
                 ? `Default route is already defined!`
                 : `Route for label '${String(label)}' is already defined!`;
@@ -291,14 +291,14 @@ export class Router {
                 router.addHandler(label, value);
             }
             else {
-                router.schemas.set(label, value);
+                router.#schemas.set(label, value);
             }
         }
         const func = async function (context) {
             const { url, loadedUrl, label } = context.request;
             context.log.debug('Page opened.', { label, url: loadedUrl ?? url });
             await router.validateRequest(context);
-            for (const middleware of router.middlewares) {
+            for (const middleware of router.#middlewares) {
                 await middleware(context);
             }
             return router.getHandler(label)(context);

package/serialization.js

@@ -1,9 +1,11 @@
 import { pipeline as streamPipeline, Readable, Writable } from 'node:stream';
 import util from 'node:util';
 import zlib from 'node:zlib';
-import ow from 'ow';
 import StreamArray from 'stream-json/streamers/StreamArray.js';
+import { z } from 'zod';
+import { parseArgument, schemas } from './validators.js';
 const pipeline = util.promisify(streamPipeline);
+const uint8ArraySchema = z.instanceof(Uint8Array);
 /**
  * Transforms an array of items to a JSON in a streaming
  * fashion to save memory. It operates in batches to speed
@@ -11,32 +13,31 @@ const pipeline = util.promisify(streamPipeline);
  * @internal
  */
 class ArrayToJson extends Readable {
-    data;
-    offset = 0;
-    batchSize;
+    #offset = 0;
+    #batchSize;
+    #data;
     constructor(data, options = {}) {
         super({
             ...options,
             autoDestroy: true,
             emitClose: true,
         });
-        this.data = data;
         const { batchSize = 10000 } = options;
-        this.batchSize = batchSize;
-        this.data = data;
+        this.#batchSize = batchSize;
+        this.#data = data;
         this.push('[');
     }
     _read() {
         try {
-            const items = this.data.slice(this.offset, this.offset + this.batchSize);
+            const items = this.#data.slice(this.#offset, this.#offset + this.#batchSize);
             if (items.length) {
                 const json = JSON.stringify(items);
                 // Strip brackets to flatten the batch.
                 const itemString = json.substring(1, json.length - 1);
-                if (this.offset > 0)
+                if (this.#offset > 0)
                     this.push(',', 'utf8');
                 this.push(itemString, 'utf8');
-                this.offset += this.batchSize;
+                this.#offset += this.#batchSize;
             }
             else {
                 this.push(']');
@@ -58,7 +59,7 @@ class ArrayToJson extends Readable {
  * @internal
  */
 export async function serializeArray(data) {
-    ow(data, ow.array);
+    parseArgument(data, schemas.anyArray);
     const { chunks, collector } = createChunkCollector();
     await pipeline(new ArrayToJson(data), zlib.createGzip(), collector);
     return Buffer.concat(chunks);
@@ -73,7 +74,7 @@ export async function serializeArray(data) {
  * @internal
  */
 export async function deserializeArray(compressedData) {
-    ow(compressedData, ow.uint8Array);
+    parseArgument(compressedData, uint8ArraySchema);
     const { chunks, collector } = createChunkCollector({ fromValuesStream: true });
     await pipeline(Readable.from([compressedData]), zlib.createGunzip(), StreamArray.withParser(), collector);
     return chunks;
@@ -88,7 +89,7 @@ export async function deserializeArray(compressedData) {
  * @internal
  */
 export function createDeserialize(compressedData) {
-    ow(compressedData, ow.uint8Array);
+    parseArgument(compressedData, uint8ArraySchema);
     const streamArray = StreamArray.withParser();
     const destination = pluckValue(streamArray);
     streamPipeline(Readable.from([compressedData]), zlib.createGunzip(), destination, (err) => destination.emit(err));

package/service_locator.d.ts

@@ -62,6 +62,17 @@ interface ServiceLocatorInterface {
      * Get the storage instance manager (shared across all storage types).
      */
     getStorageInstanceManager(): StorageInstanceManager;
+    /**
+     * Returns the currently set services without triggering the implicit creation of defaults.
+     * Used to inherit already-materialized services into crawler-scoped service locators.
+     * @internal
+     */
+    getServicesIfSet(): {
+        configuration?: Configuration;
+        eventManager?: EventManager;
+        storageBackend?: StorageBackend;
+        logger?: CrawleeLogger;
+    };
     /**
      * Resets the service locator to its initial state.
      * Used mainly for testing purposes.
@@ -101,16 +112,7 @@ interface ServiceLocatorInterface {
  * ```
  */
 export declare class ServiceLocator implements ServiceLocatorInterface {
-    private configuration?;
-    private eventManager?;
-    private storageBackend?;
-    private logger?;
-    /**
-     * Unified storage instance manager for Dataset, KeyValueStore, and RequestQueue.
-     * Shared across all ServiceLocator instances (global singleton), matching crawlee-python.
-     * Per-crawler isolation is achieved via `clientCacheKey`, not separate manager instances.
-     */
-    private static storageInstanceManager?;
+    #private;
     /**
      * Creates a new ServiceLocator instance.
      *
@@ -120,6 +122,13 @@ export declare class ServiceLocator implements ServiceLocatorInterface {
      * @param logger Optional logger instance to use
      */
     constructor(configuration?: Configuration, eventManager?: EventManager, storageBackend?: StorageBackend, logger?: CrawleeLogger);
+    /** @internal */
+    getServicesIfSet(): {
+        configuration?: Configuration;
+        eventManager?: EventManager;
+        storageBackend?: StorageBackend;
+        logger?: CrawleeLogger;
+    };
     getConfiguration(): Configuration;
     setConfiguration(configuration: Configuration): void;
     getEventManager(): EventManager;

package/service_locator.js

@@ -39,16 +39,16 @@ import { StorageInstanceManager } from './storages/storage_instance_manager.js';
  * ```
  */
 export class ServiceLocator {
-    configuration;
-    eventManager;
-    storageBackend;
-    logger;
+    #configuration;
+    #eventManager;
+    #storageBackend;
+    #logger;
     /**
      * Unified storage instance manager for Dataset, KeyValueStore, and RequestQueue.
      * Shared across all ServiceLocator instances (global singleton), matching crawlee-python.
      * Per-crawler isolation is achieved via `clientCacheKey`, not separate manager instances.
      */
-    static storageInstanceManager;
+    static #storageInstanceManager;
     /**
      * Creates a new ServiceLocator instance.
      *
@@ -58,61 +58,70 @@ export class ServiceLocator {
      * @param logger Optional logger instance to use
      */
     constructor(configuration, eventManager, storageBackend, logger) {
-        this.configuration = configuration;
-        this.eventManager = eventManager;
-        this.storageBackend = storageBackend;
-        this.logger = logger;
+        this.#configuration = configuration;
+        this.#eventManager = eventManager;
+        this.#storageBackend = storageBackend;
+        this.#logger = logger;
+    }
+    /** @internal */
+    getServicesIfSet() {
+        return {
+            configuration: this.#configuration,
+            eventManager: this.#eventManager,
+            storageBackend: this.#storageBackend,
+            logger: this.#logger,
+        };
     }
     getConfiguration() {
-        if (!this.configuration) {
+        if (!this.#configuration) {
             this.getLogger().debug('No configuration set, implicitly creating and using default Configuration.');
-            this.configuration = new Configuration();
+            this.#configuration = new Configuration();
         }
-        return this.configuration;
+        return this.#configuration;
     }
     setConfiguration(configuration) {
         // Same instance, no need to do anything
-        if (this.configuration === configuration) {
+        if (this.#configuration === configuration) {
             return;
         }
         // Already have a different configuration that was retrieved
-        if (this.configuration) {
-            throw new ServiceConflictError('Configuration', configuration, this.configuration);
+        if (this.#configuration) {
+            throw new ServiceConflictError('Configuration', configuration, this.#configuration);
         }
-        this.configuration = configuration;
+        this.#configuration = configuration;
     }
     getEventManager() {
-        if (!this.eventManager) {
+        if (!this.#eventManager) {
             this.getLogger().debug('No event manager set, implicitly creating and using default LocalEventManager.');
-            if (!this.configuration) {
+            if (!this.#configuration) {
                 this.getLogger().warning('Implicit creation of event manager will implicitly set configuration as side effect. ' +
                     'It is advised to explicitly first set the configuration instead.');
             }
-            this.eventManager = LocalEventManager.fromConfiguration(this.getConfiguration());
+            this.#eventManager = LocalEventManager.fromConfiguration(this.getConfiguration());
         }
-        return this.eventManager;
+        return this.#eventManager;
     }
     setEventManager(eventManager) {
         // Same instance, no need to do anything
-        if (this.eventManager === eventManager) {
+        if (this.#eventManager === eventManager) {
             return;
         }
         // Already have a different event manager that was retrieved
-        if (this.eventManager) {
-            throw new ServiceConflictError('EventManager', eventManager, this.eventManager);
+        if (this.#eventManager) {
+            throw new ServiceConflictError('EventManager', eventManager, this.#eventManager);
         }
-        this.eventManager = eventManager;
+        this.#eventManager = eventManager;
     }
     getStorageBackend() {
-        if (!this.storageBackend) {
+        if (!this.#storageBackend) {
             this.getLogger().debug('No storage backend set, implicitly creating and using the default storage backend ' +
                 '(FileSystemStorageBackend when persistStorage is enabled, MemoryStorageBackend otherwise).');
-            if (!this.configuration) {
+            if (!this.#configuration) {
                 this.getLogger().warning('Implicit creation of storage backend will implicitly set configuration as side effect. ' +
                     'It is advised to explicitly first set the configuration instead.');
             }
             const configuration = this.getConfiguration();
-            this.storageBackend = configuration.persistStorage
+            this.#storageBackend = configuration.persistStorage
                 ? new FileSystemStorageBackend({
                     localDataDirectory: configuration.storageDir,
                     logger: this.getLogger().child({ prefix: 'FileSystemStorageBackend' }),
@@ -121,50 +130,50 @@ export class ServiceLocator {
                     logger: this.getLogger().child({ prefix: 'MemoryStorageBackend' }),
                 });
         }
-        return this.storageBackend;
+        return this.#storageBackend;
     }
     setStorageBackend(storageBackend) {
         // Same instance, no need to do anything
-        if (this.storageBackend === storageBackend) {
+        if (this.#storageBackend === storageBackend) {
             return;
         }
         // Already have a different storage backend that was retrieved
-        if (this.storageBackend) {
-            throw new ServiceConflictError('StorageBackend', storageBackend, this.storageBackend);
+        if (this.#storageBackend) {
+            throw new ServiceConflictError('StorageBackend', storageBackend, this.#storageBackend);
         }
-        this.storageBackend = storageBackend;
+        this.#storageBackend = storageBackend;
     }
     getLogger() {
-        if (!this.logger) {
-            this.logger = new ApifyLogAdapter(log);
+        if (!this.#logger) {
+            this.#logger = new ApifyLogAdapter(log);
         }
-        return this.logger;
+        return this.#logger;
     }
     setLogger(logger) {
-        if (this.logger === logger) {
+        if (this.#logger === logger) {
             return;
         }
-        if (this.logger) {
-            throw new ServiceConflictError('Logger', logger, this.logger);
+        if (this.#logger) {
+            throw new ServiceConflictError('Logger', logger, this.#logger);
         }
-        this.logger = logger;
+        this.#logger = logger;
     }
     getChildLog(prefix) {
         return this.getLogger().child({ prefix });
     }
     getStorageInstanceManager() {
-        if (!ServiceLocator.storageInstanceManager) {
-            ServiceLocator.storageInstanceManager = new StorageInstanceManager();
+        if (!ServiceLocator.#storageInstanceManager) {
+            ServiceLocator.#storageInstanceManager = new StorageInstanceManager();
         }
-        return ServiceLocator.storageInstanceManager;
+        return ServiceLocator.#storageInstanceManager;
     }
     reset() {
-        this.configuration = undefined;
-        this.eventManager = undefined;
-        this.storageBackend = undefined;
-        this.logger = undefined;
-        ServiceLocator.storageInstanceManager?.clearCache();
-        ServiceLocator.storageInstanceManager = undefined;
+        this.#configuration = undefined;
+        this.#eventManager = undefined;
+        this.#storageBackend = undefined;
+        this.#logger = undefined;
+        ServiceLocator.#storageInstanceManager?.clearCache();
+        ServiceLocator.#storageInstanceManager = undefined;
     }
 }
 /**