@crawlee/core 4.0.0-beta.120 → 4.0.0-beta.122

package/memory-storage/resource-clients/request-queue.js

@@ -1,23 +1,10 @@
 import { randomUUID } from 'node:crypto';
+import { parseArgument, schemas } from '@crawlee/utils/internal';
 import { AsyncQueue } from '@sapphire/async-queue';
-import { s } from '@sapphire/shapeshift';
+import { z } from 'zod';
 import { purgeNullsFromObject, uniqueKeyToRequestId } from '../utils.js';
 import { BaseClient } from './common/base-client.js';
-const requestShape = s
-    .object({
-    id: s.string(),
-    url: s.string().url({ allowedProtocols: ['http:', 'https:'] }),
-    uniqueKey: s.string(),
-    method: s.string().optional(),
-    retryCount: s.number().int().optional(),
-    handledAt: s.union([s.string(), s.date().valid()]).optional(),
-})
-    .passthrough();
-const requestShapeWithoutId = requestShape.omit(['id']);
-const batchRequestShapeWithoutId = requestShapeWithoutId.array();
-const requestOptionsShape = s.object({
-    forefront: s.boolean().optional(),
-});
+const uniqueKeySchema = z.string();
 export class RequestQueueBackend extends BaseClient {
     name;
     /**
@@ -183,8 +170,8 @@ export class RequestQueueBackend extends BaseClient {
         }
     }
     async addBatchOfRequests(requests, options = {}) {
-        batchRequestShapeWithoutId.parse(requests);
-        requestOptionsShape.parse(options);
+        parseArgument(requests, schemas.storageRequestBatch);
+        parseArgument(options, schemas.requestQueueOperationOptions);
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so that the
         // shared `requests` map, `forefrontRequestIds` array and request counts are not corrupted by a
         // concurrent operation interleaving at one of the `await` points below.
@@ -233,14 +220,14 @@ export class RequestQueueBackend extends BaseClient {
         }
     }
     async getRequest(uniqueKey) {
-        s.string().parse(uniqueKey);
+        parseArgument(uniqueKey, uniqueKeySchema);
         this.updateTimestamps(false);
         const id = uniqueKeyToRequestId(uniqueKey);
         const json = this.#requests.get(id)?.json;
         return this.jsonToRequest(json);
     }
     async markRequestAsHandled(request) {
-        requestShape.parse(request);
+        parseArgument(request, schemas.storageRequest);
         this.updateTimestamps(false);
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so the shared
         // `requests` map, `inProgressRequestIds` set and request counts stay consistent across the
@@ -278,8 +265,8 @@ export class RequestQueueBackend extends BaseClient {
         }
     }
     async reclaimRequest(request, options = {}) {
-        requestShape.parse(request);
-        requestOptionsShape.parse(options);
+        parseArgument(request, schemas.storageRequest);
+        parseArgument(options, schemas.requestQueueOperationOptions);
         this.updateTimestamps(false);
         // Serialize against other mutators (and the head scans in `isEmpty`/`isFinished`) so the shared
         // `requests` map, `forefrontRequestIds` array and `inProgressRequestIds` set stay consistent

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@crawlee/core",
-    "version": "4.0.0-beta.120",
+    "version": "4.0.0-beta.122",
     "description": "The scalable web crawling and scraping library for JavaScript/Node.js. Enables development of data extraction and web automation jobs (not only) with headless Chrome and Puppeteer.",
     "engines": {
         "node": ">=22.0.0"
@@ -52,24 +52,23 @@
         "@apify/log": "^2.5.18",
         "@apify/timeout": "^0.4.4",
         "@apify/utilities": "^2.15.5",
-        "@crawlee/fs-storage": "4.0.0-beta.120",
-        "@crawlee/types": "4.0.0-beta.120",
-        "@crawlee/utils": "4.0.0-beta.120",
+        "@crawlee/fs-storage": "4.0.0-beta.122",
+        "@crawlee/http-client": "4.0.0-beta.122",
+        "@crawlee/types": "4.0.0-beta.122",
+        "@crawlee/utils": "4.0.0-beta.122",
         "@sapphire/async-queue": "^1.5.5",
-        "@sapphire/shapeshift": "^4.0.0",
         "@vladfrangu/async_event_emitter": "^2.4.6",
         "content-type": "^1.0.5",
         "csv-stringify": "^6.5.2",
         "json5": "^2.2.3",
         "mime-types": "^3.0.1",
         "minimatch": "^10.0.1",
-        "ow": "^2.0.0",
         "stream-json": "^1.9.1",
         "tldts": "^7.0.6",
         "tough-cookie": "^6.0.0",
         "tslib": "^2.8.1",
         "type-fest": "^4.41.0",
-        "zod": "^4.1.0"
+        "zod": "^4.4.3"
     },
     "lerna": {
         "command": {
@@ -78,5 +77,5 @@
             }
         }
     },
-    "gitHead": "da5d427c4c1c9dcaea95b151e9c4c7310100885d"
+    "gitHead": "2c3e87fefdb9e1fca4c144f03167d8524cfdc2e5"
 }

package/proxy_configuration.js

@@ -1,4 +1,12 @@
-import ow from 'ow';
+import { z } from 'zod';
+import { parseArgument, schemas } from './validators.js';
+const proxyConfigurationOptionsSchema = z.strictObject({
+    proxyUrls: z
+        .array(z.union([z.url(), z.null()]))
+        .nonempty()
+        .optional(),
+    newUrlFunction: schemas.anyFunction.optional(),
+});
 /**
  * Configures connection to a proxy server with the provided options. Proxy servers are used to prevent target websites from blocking
  * your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
@@ -58,11 +66,7 @@ export class ProxyConfiguration {
             throw new Error('The `tieredProxyUrls` option has been removed in Crawlee v4. ' +
                 'See the v4 upgrading guide for the recommended migration to named sessions.');
         }
-        ow(rest, ow.object.exactShape({
-            proxyUrls: ow.optional.array.nonEmpty.ofType(ow.any(ow.string.url, ow.null)),
-            newUrlFunction: ow.optional.function,
-        }));
-        const { proxyUrls, newUrlFunction } = options;
+        const { proxyUrls, newUrlFunction } = parseArgument(rest, proxyConfigurationOptionsSchema);
         if (proxyUrls && newUrlFunction)
             this.throwCannotCombineCustomMethods();
         if (!proxyUrls && !newUrlFunction && validateRequired)

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.
@@ -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,7 +180,10 @@ class CrawleeRequest {
         if (label) {
             userData.label = label;
         }
-        this.#userData = { __crawlee: {}, ...userData };
+        // 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: {

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
@@ -57,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);
@@ -72,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;
@@ -87,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.
@@ -111,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

@@ -63,6 +63,15 @@ export class ServiceLocator {
         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) {
             this.getLogger().debug('No configuration set, implicitly creating and using default Configuration.');

package/session_pool/session.js

@@ -1,8 +1,28 @@
-import ow from 'ow';
 import { CookieJar } from 'tough-cookie';
+import { z } from 'zod';
 import { cryptoRandomObjectId } from '@apify/utilities';
 import { getDefaultCookieExpirationDate } from '../cookie_utils.js';
 import { serviceLocator } from '../service_locator.js';
+import { parseArgument, schemas, validators } from '../validators.js';
+// `schemas.anyObject` passes values through by reference (object schemas return a pruned plain
+// copy), so class instances like cookie jars and loggers keep their prototype.
+const sessionOptionsSchema = z.strictObject({
+    id: z.string().default(() => `session_${cryptoRandomObjectId(10)}`),
+    cookieJar: schemas.anyObject.default(() => new CookieJar()),
+    proxyInfo: schemas.anyObject.optional(),
+    maxAgeSecs: schemas.anyNumber.default(3000),
+    userData: schemas.anyObject.default(() => ({})),
+    maxErrorScore: schemas.anyNumber.default(3),
+    errorScoreDecrement: schemas.anyNumber.default(0.5),
+    createdAt: z.date().default(() => new Date()),
+    expiresAt: z.date().optional(),
+    usageCount: schemas.anyNumber.default(0),
+    errorScore: schemas.anyNumber.default(0),
+    maxUsageCount: schemas.anyNumber.default(50),
+    retired: z.boolean().default(false),
+    log: validators.logger.default(() => serviceLocator.getLogger()),
+    fingerprint: schemas.anyObject.optional(),
+});
 /**
  * Sessions are used to store information such as cookies and can be used for generating fingerprints and proxy sessions.
  * You can imagine each session as a specific user, with its own cookies, IP (via proxy) and potentially a unique browser fingerprint.
@@ -68,25 +88,7 @@ export class Session {
      * Session configuration.
      */
     constructor(options = {}) {
-        ow(options, ow.object.exactShape({
-            id: ow.optional.string,
-            cookieJar: ow.optional.object,
-            proxyInfo: ow.optional.object,
-            maxAgeSecs: ow.optional.number,
-            userData: ow.optional.object,
-            maxErrorScore: ow.optional.number,
-            errorScoreDecrement: ow.optional.number,
-            createdAt: ow.optional.date,
-            expiresAt: ow.optional.date,
-            usageCount: ow.optional.number,
-            errorScore: ow.optional.number,
-            maxUsageCount: ow.optional.number,
-            retired: ow.optional.boolean,
-            log: ow.optional.object,
-            fingerprint: ow.optional.object,
-        }));
-        const { id = `session_${cryptoRandomObjectId(10)}`, cookieJar = new CookieJar(), proxyInfo = undefined, maxAgeSecs = 3000, userData = {}, maxErrorScore = 3, errorScoreDecrement = 0.5, createdAt = new Date(), usageCount = 0, errorScore = 0, maxUsageCount = 50, retired = false, log = serviceLocator.getLogger(), fingerprint, } = options;
-        const { expiresAt = getDefaultCookieExpirationDate(maxAgeSecs) } = options;
+        const { id, cookieJar, proxyInfo, maxAgeSecs, userData, maxErrorScore, errorScoreDecrement, createdAt, usageCount, errorScore, maxUsageCount, retired, log, fingerprint, expiresAt = getDefaultCookieExpirationDate(maxAgeSecs), } = parseArgument(options, sessionOptionsSchema);
         this.#log = log.child({ prefix: 'Session' });
         this.#cookieJar = cookieJar.setCookie ? cookieJar : CookieJar.fromJSON(JSON.stringify(cookieJar));
         this.#proxyInfo = proxyInfo;

package/session_pool/session_pool.js

@@ -1,12 +1,29 @@
 import { AsyncQueue } from '@sapphire/async-queue';
-import ow from 'ow';
+import { z } from 'zod';
 import { EventType } from '../events/event_manager.js';
 import { serviceLocator } from '../service_locator.js';
 import { KeyValueStore } from '../storages/key_value_store.js';
+import { parseArgument, schemas, validators } from '../validators.js';
 import { MAX_POOL_SIZE, PERSIST_STATE_KEY } from './consts.js';
 import { createDefaultSessionFingerprint } from './fingerprint.js';
 import { Session } from './session.js';
 const SESSION_REUSE_STRATEGIES = ['random', 'round-robin', 'use-until-failure'];
+// `schemas.anyObject` passes values through by reference (object schemas return a pruned plain
+// copy), so class instances like loggers keep their prototype.
+const sessionPoolOptionsSchema = z.strictObject({
+    id: z.union([schemas.anyNumber, z.string()]).optional(),
+    maxPoolSize: schemas.anyNumber.default(MAX_POOL_SIZE),
+    persistStateKeyValueStoreId: z.string().optional(),
+    persistStateKey: z.string().optional(),
+    createSessionFunction: schemas.anyFunction.optional(),
+    sessionOptions: schemas.anyObject.default(() => ({})),
+    log: validators.logger.default(() => serviceLocator.getLogger()),
+    persistenceOptions: schemas.anyObject.default(() => ({ enable: true })),
+    sessionReuseStrategy: z.enum(SESSION_REUSE_STRATEGIES).default('random'),
+});
+const createSessionOptionsSchema = z.strictObject({
+    sessionOptions: schemas.anyObject.default(() => ({})),
+});
 /**
  * Handles the rotation, creation and persistence of user-like sessions.
  * Creates a pool of {@link Session} instances, that are randomly rotated.
@@ -81,20 +98,7 @@ export class SessionPool {
     #queue = new AsyncQueue();
     #roundRobinIndex = 0;
     constructor(options = {}) {
-        ow(options, ow.object.exactShape({
-            id: ow.optional.any(ow.number, ow.string),
-            maxPoolSize: ow.optional.number,
-            persistStateKeyValueStoreId: ow.optional.string,
-            persistStateKey: ow.optional.string,
-            createSessionFunction: ow.optional.function,
-            sessionOptions: ow.optional.object,
-            log: ow.optional.object,
-            persistenceOptions: ow.optional.object,
-            sessionReuseStrategy: ow.optional.string.oneOf([...SESSION_REUSE_STRATEGIES]),
-        }));
-        const { id, maxPoolSize = MAX_POOL_SIZE, persistStateKeyValueStoreId, persistStateKey, createSessionFunction, sessionOptions = {}, log = serviceLocator.getLogger(), persistenceOptions = {
-            enable: true,
-        }, sessionReuseStrategy = 'random', } = options;
+        const { id, maxPoolSize, persistStateKeyValueStoreId, persistStateKey, createSessionFunction, sessionOptions, log, persistenceOptions, sessionReuseStrategy, } = parseArgument(options, sessionPoolOptionsSchema);
         this.id = id != null ? String(id) : String(SessionPool.#nextId++);
         this.#sessionReuseStrategy = sessionReuseStrategy;
         this.#events = serviceLocator.getEventManager();
@@ -303,8 +307,7 @@ export class SessionPool {
      * @returns New session.
      */
     async defaultCreateSessionFunction(options = {}) {
-        ow(options, ow.object.exactShape({ sessionOptions: ow.optional.object }));
-        const { sessionOptions = {} } = options;
+        const { sessionOptions } = parseArgument(options, createSessionOptionsSchema);
         return new Session(sessionOptions);
     }
     /**

package/storages/dataset.js

@@ -1,12 +1,17 @@
-import ow from 'ow';
+import { z } from 'zod';
 import { tryCancel } from '@apify/timeout';
 import { Configuration } from '../configuration.js';
 import { serviceLocator } from '../service_locator.js';
+import { parseArgument, schemas, validators } from '../validators.js';
 import { activeStorageTransaction, rejectOperationInTransaction, snapshotValue } from './transaction.js';
 import { KeyValueStore } from './key_value_store.js';
 import { StorageStatsTracker } from './storage_stats.js';
 import { resolveStorageIdentifier } from './storage_instance_manager.js';
 import { createDualIterable, purgeDefaultStorages } from './utils.js';
+const openOptionsSchema = z.strictObject({
+    configuration: z.instanceof(Configuration).optional(),
+    storageBackend: validators.storageBackend.optional(),
+});
 /** @internal */
 export const DATASET_ITERATORS_DEFAULT_LIMIT = 10000;
 /**
@@ -122,7 +127,7 @@ export class Dataset {
      */
     async pushData(data) {
         const transaction = activeStorageTransaction();
-        ow(data, 'data', ow.object);
+        parseArgument(data, schemas.anyObject);
         // Normalize to array and validate each item
         const items = Array.isArray(data) ? data : [data];
         for (let i = 0; i < items.length; i++) {
@@ -553,13 +558,10 @@ export class Dataset {
      */
     static async open(identifier, options = {}) {
         tryCancel();
-        ow(options, ow.object.exactShape({
-            configuration: ow.optional.object.instanceOf(Configuration),
-            storageBackend: ow.optional.object,
-        }));
-        options.configuration ??= Configuration.getGlobalConfiguration();
-        const storageBackend = options.storageBackend ?? serviceLocator.getStorageBackend();
-        await purgeDefaultStorages({ onlyPurgeOnce: true, storageBackend, configuration: options.configuration });
+        const parsedOptions = parseArgument(options, openOptionsSchema);
+        const configuration = parsedOptions.configuration ?? Configuration.getGlobalConfiguration();
+        const storageBackend = parsedOptions.storageBackend ?? serviceLocator.getStorageBackend();
+        await purgeDefaultStorages({ onlyPurgeOnce: true, storageBackend, configuration });
         const resolved = await resolveStorageIdentifier(identifier, storageBackend, 'Dataset');
         return serviceLocator.getStorageInstanceManager().openStorage(this, {
             ...resolved,

package/storages/key_value_store.js

@@ -1,8 +1,9 @@
-import ow, { ArgumentError } from 'ow';
+import { z } from 'zod';
 import { KEY_VALUE_STORE_KEY_REGEX } from '@apify/consts';
 import { tryCancel } from '@apify/timeout';
 import { Configuration } from '../configuration.js';
 import { serviceLocator } from '../service_locator.js';
+import { parseArgument, schemas, validators } from '../validators.js';
 import { activeStorageTransaction, operationRejectedInTransaction, rejectOperationInTransaction, snapshotValue, withDirectStorageAccess, } from './transaction.js';
 import { parseValue, serializeValue } from './key_value_store_codec.js';
 import { StorageStatsTracker } from './storage_stats.js';
@@ -11,6 +12,20 @@ import { createDualIterable, purgeDefaultStorages } from './utils.js';
 import { isBuffer, isStream } from '../byte_utils.js';
 /** @internal */
 const KVS_KEYS_DEFAULT_LIMIT = 1000;
+const keySchema = z.string().nonempty();
+const setValueKeySchema = z.string().nonempty().regex(KEY_VALUE_STORE_KEY_REGEX, {
+    message: `The "key" argument must be at most 256 characters long and only contain the following characters: a-zA-Z0-9!-_.'()`,
+});
+const recordOptionsSchema = z.strictObject({
+    contentType: z.string().nonempty().optional(),
+});
+const iteratorOptionsSchema = z.strictObject({
+    prefix: z.string().optional(),
+});
+const openOptionsSchema = z.strictObject({
+    configuration: z.instanceof(Configuration).optional(),
+    storageBackend: validators.storageBackend.optional(),
+});
 /**
  * The `KeyValueStore` class represents a key-value store, a simple data storage that is used
  * for saving and reading data records or files. Each data record is
@@ -132,7 +147,7 @@ export class KeyValueStore {
      */
     async getValue(key, defaultValue) {
         tryCancel();
-        ow(key, ow.string.nonEmpty);
+        parseArgument(key, keySchema);
         const record = await this.readRecord(key);
         // A missing record falls back to the default; a record that parses to a falsy value (including
         // a stored literal `null`) is returned verbatim, so callers can tell "stored null" from "absent".
@@ -216,7 +231,7 @@ export class KeyValueStore {
      */
     async getRecord(key) {
         tryCancel();
-        ow(key, ow.string.nonEmpty);
+        parseArgument(key, keySchema);
         return this.readRecord(key);
     }
     /**
@@ -227,7 +242,7 @@ export class KeyValueStore {
      */
     async recordExists(key) {
         tryCancel();
-        ow(key, ow.string.nonEmpty);
+        parseArgument(key, keySchema);
         const entry = this.bufferedJournalEntries()?.get(key);
         if (entry) {
             return entry.value !== null;
@@ -362,19 +377,12 @@ export class KeyValueStore {
      */
     async setValue(key, value, options = {}) {
         const transaction = activeStorageTransaction();
-        ow(key, 'key', ow.string.nonEmpty);
-        ow(key, ow.string.validate((k) => ({
-            validator: ow.isValid(k, ow.string.matches(KEY_VALUE_STORE_KEY_REGEX)),
-            message: `The "key" argument "${key}" must be at most 256 characters long and only contain the following characters: a-zA-Z0-9!-_.'()`,
-        })));
+        parseArgument(key, setValueKeySchema);
         if (options.contentType && !(typeof value === 'string' || isBuffer(value) || isStream(value))) {
-            throw new ArgumentError('The "value" parameter must be a String, Buffer, ArrayBuffer, TypedArray, or Stream when "options.contentType" is specified.', this.setValue);
+            throw new Error('The "value" parameter must be a String, Buffer, ArrayBuffer, TypedArray, or Stream when "options.contentType" is specified.');
         }
-        ow(options, ow.object.exactShape({
-            contentType: ow.optional.string.nonEmpty,
-        }));
-        // Make copy of options, don't update what user passed.
-        const optionsCopy = { ...options };
+        // The parse result is a fresh copy, so we never update what user passed.
+        const optionsCopy = parseArgument(options, recordOptionsSchema);
         // The whole transaction branch sits *above* the auto-saved cache update below, so a buffered
         // write touches nothing outside the journal. That cache is shared, process-lifetime frontend
         // state, so mutating it here would survive a rollback and later be persisted by `persistState`.
@@ -480,12 +488,10 @@ export class KeyValueStore {
      */
     async forEachKey(iteratee, options = {}) {
         tryCancel();
-        ow(iteratee, ow.function);
-        ow(options, ow.object.exactShape({
-            prefix: ow.optional.string,
-        }));
+        parseArgument(iteratee, schemas.anyFunction);
+        const parsedOptions = parseArgument(options, iteratorOptionsSchema);
         let index = 0;
-        for await (const page of this.fetchKeyPages(options)) {
+        for await (const page of this.fetchKeyPages(parsedOptions)) {
             for (const item of page) {
                 await iteratee(item.key, index++, { size: item.size });
             }
@@ -623,13 +629,10 @@ export class KeyValueStore {
      */
     static async open(identifier, options = {}) {
         tryCancel();
-        ow(options, ow.object.exactShape({
-            configuration: ow.optional.object.instanceOf(Configuration),
-            storageBackend: ow.optional.object,
-        }));
-        options.configuration ??= Configuration.getGlobalConfiguration();
-        const storageBackend = options.storageBackend ?? serviceLocator.getStorageBackend();
-        await purgeDefaultStorages({ onlyPurgeOnce: true, storageBackend, configuration: options.configuration });
+        const parsedOptions = parseArgument(options, openOptionsSchema);
+        const configuration = parsedOptions.configuration ?? Configuration.getGlobalConfiguration();
+        const storageBackend = parsedOptions.storageBackend ?? serviceLocator.getStorageBackend();
+        await purgeDefaultStorages({ onlyPurgeOnce: true, storageBackend, configuration });
         const resolved = await resolveStorageIdentifier(identifier, storageBackend, 'KeyValueStore');
         return serviceLocator.getStorageInstanceManager().openStorage(this, {
             ...resolved,

package/storages/request_list.d.ts

@@ -1,4 +1,5 @@
-import type { BaseHttpClient, Dictionary } from '@crawlee/types';
+import type { BaseHttpClient } from '@crawlee/http-client';
+import type { Dictionary } from '@crawlee/types';
 import type { Configuration } from '../configuration.js';
 import type { IProxyConfiguration } from '../proxy_configuration.js';
 import { Request, type RequestOptions, type Source } from '../request.js';