@crawlee/core 4.0.0-beta.9 → 4.0.0-beta.91

package/storages/dataset.js

@@ -1,80 +1,35 @@
 import { stringify } from 'csv-stringify/sync';
 import ow from 'ow';
-import { MAX_PAYLOAD_SIZE_BYTES } from '@apify/consts';
 import { Configuration } from '../configuration.js';
-import { log } from '../log.js';
+import { serviceLocator } from '../service_locator.js';
 import { checkStorageAccess } from './access_checking.js';
 import { KeyValueStore } from './key_value_store.js';
-import { StorageManager } from './storage_manager.js';
-import { purgeDefaultStorages } from './utils.js';
+import { StorageStatsTracker } from './storage_stats.js';
+import { resolveStorageIdentifier } from './storage_instance_manager.js';
+import { createDualIterable, purgeDefaultStorages } from './utils.js';
 /** @internal */
 export const DATASET_ITERATORS_DEFAULT_LIMIT = 10000;
-const SAFETY_BUFFER_PERCENT = 0.01 / 100; // 0.01%
 /**
- * Accepts a JSON serializable object as an input, validates its serializability,
- * and validates its serialized size against limitBytes. Optionally accepts its index
- * in an array to provide better error messages. Returns serialized object.
+ * Validates that the given value is a plain JSON-serializable object
+ * (not an array, not a primitive, not circular).
+ *
+ * @param item The value to validate.
+ * @param index Optional index for error messages when validating inside an array.
  * @ignore
  */
-export function checkAndSerialize(item, limitBytes, index) {
+export function assertJsonSerializable(item, index) {
     const s = typeof index === 'number' ? ` at index ${index} ` : ' ';
     const isItemObject = item && typeof item === 'object' && !Array.isArray(item);
     if (!isItemObject) {
         throw new Error(`Data item${s}is not an object. You can push only objects into a dataset.`);
     }
-    let payload;
     try {
-        payload = JSON.stringify(item);
+        JSON.stringify(item);
     }
     catch (e) {
         const err = e;
         throw new Error(`Data item${s}is not serializable to JSON.\nCause: ${err.message}`);
     }
-    const bytes = Buffer.byteLength(payload);
-    if (bytes > limitBytes) {
-        throw new Error(`Data item${s}is too large (size: ${bytes} bytes, limit: ${limitBytes} bytes)`);
-    }
-    return payload;
-}
-/**
- * Takes an array of JSONs (payloads) as input and produces an array of JSON strings
- * where each string is a JSON array of payloads with a maximum size of limitBytes per one
- * JSON array. Fits as many payloads as possible into a single JSON array and then moves
- * on to the next, preserving item order.
- *
- * The function assumes that none of the items is larger than limitBytes and does not validate.
- * @ignore
- */
-export function chunkBySize(items, limitBytes) {
-    if (!items.length)
-        return [];
-    if (items.length === 1)
-        return items;
-    // Split payloads into buckets of valid size.
-    let lastChunkBytes = 2; // Add 2 bytes for [] wrapper.
-    const chunks = [];
-    for (const payload of items) {
-        const bytes = Buffer.byteLength(payload);
-        if (bytes <= limitBytes && bytes + 2 > limitBytes) {
-            // Handle cases where wrapping with [] would fail, but solo object is fine.
-            chunks.push(payload);
-            lastChunkBytes = bytes;
-        }
-        else if (lastChunkBytes + bytes <= limitBytes) {
-            // ensure array
-            if (!Array.isArray(chunks[chunks.length - 1])) {
-                chunks.push([]);
-            }
-            chunks[chunks.length - 1].push(payload);
-            lastChunkBytes += bytes + 1; // Add 1 byte for ',' separator.
-        }
-        else {
-            chunks.push([payload]);
-            lastChunkBytes = bytes + 2; // Add 2 bytes for [] wrapper.
-        }
-    }
-    // Stringify array chunks.
-    return chunks.map((chunk) => (typeof chunk === 'string' ? chunk : `[${chunk.join(',')}]`));
 }
 /**
  * The `Dataset` class represents a store for structured data where each object stored has the same attributes,
@@ -128,19 +83,31 @@ export function chunkBySize(items, limitBytes) {
  * @category Result Stores
  */
 export class Dataset {
-    config;
+    configuration;
     id;
     name;
-    client;
-    log = log.child({ prefix: 'Dataset' });
+    backend;
+    log;
+    statsTracker = new StorageStatsTracker({
+        readCount: 0,
+        writeCount: 0,
+    });
     /**
      * @internal
      */
-    constructor(options, config = Configuration.getGlobalConfig()) {
-        this.config = config;
-        this.id = options.id;
-        this.name = options.name;
-        this.client = options.client.dataset(this.id);
+    constructor(options, configuration = Configuration.getGlobalConfiguration()) {
+        this.configuration = configuration;
+        this.id = options.metadata.id;
+        this.name = options.metadata.name;
+        this.backend = options.backend;
+        this.log = serviceLocator.getLogger().child({ prefix: 'Dataset' });
+    }
+    /**
+     * Backend-independent usage counters tracked for this dataset (read / write operations issued to
+     * the underlying storage backend). Counted per backend call.
+     */
+    get stats() {
+        return this.statsTracker.current;
     }
     /**
      * Stores an object or an array of objects to the dataset.
@@ -150,40 +117,19 @@ export class Dataset {
      * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
      * otherwise the crawler process might finish before the data is stored!
      *
-     * The size of the data is limited by the receiving API and therefore `pushData()` will only
-     * allow objects whose JSON representation is smaller than 9MB. When an array is passed,
-     * none of the included objects
-     * may be larger than 9MB, but the array itself may be of any size.
-     *
-     * The function internally
-     * chunks the array into separate items and pushes them sequentially.
-     * The chunking process is stable (keeps order of data), but it does not provide a transaction
-     * safety mechanism. Therefore, in the event of an uploading error (after several automatic retries),
-     * the function's Promise will reject and the dataset will be left in a state where some of
-     * the items have already been saved to the dataset while other items from the source array were not.
-     * To overcome this limitation, the developer may, for example, read the last item saved in the dataset
-     * and re-attempt the save of the data from this item onwards to prevent duplicates.
      * @param data Object or array of objects containing data to be stored in the default dataset.
-     *   The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
+     *   The objects must be serializable to JSON.
      */
     async pushData(data) {
         checkStorageAccess();
         ow(data, 'data', ow.object);
-        const dispatch = async (payload) => this.client.pushItems(payload);
-        const limit = MAX_PAYLOAD_SIZE_BYTES - Math.ceil(MAX_PAYLOAD_SIZE_BYTES * SAFETY_BUFFER_PERCENT);
-        // Handle singular Objects
-        if (!Array.isArray(data)) {
-            const payload = checkAndSerialize(data, limit);
-            await dispatch(payload);
-            return;
-        }
-        // Handle Arrays
-        const payloads = data.map((item, index) => checkAndSerialize(item, limit, index));
-        const chunks = chunkBySize(payloads, limit);
-        // Invoke client in series to preserve order of data
-        for (const chunk of chunks) {
-            await dispatch(chunk);
+        // Normalize to array and validate each item
+        const items = Array.isArray(data) ? data : [data];
+        for (let i = 0; i < items.length; i++) {
+            assertJsonSerializable(items[i], i);
         }
+        this.statsTracker.add('writeCount');
+        await this.backend.pushData(items);
     }
     /**
      * Returns {@link DatasetContent} object holding the items in the dataset based on the provided parameters.
@@ -191,7 +137,8 @@ export class Dataset {
     async getData(options = {}) {
         checkStorageAccess();
         try {
-            return await this.client.listItems(options);
+            this.statsTracker.add('readCount');
+            return await this.backend.getData(options);
         }
         catch (e) {
             const error = e;
@@ -208,18 +155,9 @@ export class Dataset {
     async export(options = {}) {
         checkStorageAccess();
         const items = [];
-        const fetchNextChunk = async (offset = 0) => {
-            const limit = 1000;
-            const value = await this.client.listItems({ offset, limit, ...options });
-            if (value.count === 0) {
-                return;
-            }
-            items.push(...value.items);
-            if (value.total > offset + value.count) {
-                await fetchNextChunk(offset + value.count);
-            }
-        };
-        await fetchNextChunk();
+        for await (const page of this.fetchPages(options)) {
+            items.push(...page.items);
+        }
         return items;
     }
     /**
@@ -230,10 +168,17 @@ export class Dataset {
      * @param [contentType] Only JSON and CSV are supported currently, defaults to JSON.
      */
     async exportTo(key, options, contentType) {
-        const kvStore = await KeyValueStore.open(options?.toKVS ?? null, { config: this.config });
+        const kvStore = await KeyValueStore.open(options?.toKVS ?? null, { configuration: this.configuration });
         const items = await this.export(options);
         if (contentType === 'text/csv') {
-            const keys = Object.keys(items[0]);
+            // To handle empty dataset exports gracefully.
+            if (items.length === 0) {
+                await kvStore.setValue(key, '', { contentType });
+                return items;
+            }
+            const keys = options?.collectAllKeys
+                ? Array.from(new Set(items.flatMap(Object.keys)))
+                : Object.keys(items[0]);
             const value = stringify([
                 keys,
                 ...items.map((item) => {
@@ -248,7 +193,6 @@ export class Dataset {
             return items;
         }
         throw new Error(`Unsupported content type: ${contentType}`);
-        return items;
     }
     /**
      * Save entire default dataset's contents into one JSON file within a key-value store.
@@ -293,28 +237,23 @@ export class Dataset {
     /**
      * Returns an object containing general information about the dataset.
      *
-     * The function returns the same object as the Apify API Client's
-     * [getDataset](https://docs.apify.com/api/apify-client-js/latest#ApifyClient-datasets-getDataset)
-     * function, which in turn calls the
-     * [Get dataset](https://apify.com/docs/api/v2#/reference/datasets/dataset/get-dataset)
-     * API endpoint.
-     *
      * **Example:**
      * ```
      * {
      *   id: "WkzbQMuFYuamGv3YF",
      *   name: "my-dataset",
-     *   userId: "wRsJZtadYvn4mBZmm",
      *   createdAt: new Date("2015-12-12T07:34:14.202Z"),
      *   modifiedAt: new Date("2015-12-13T08:36:13.202Z"),
      *   accessedAt: new Date("2015-12-14T08:36:13.202Z"),
      *   itemCount: 14,
      * }
      * ```
+     *
+     * @throws If the underlying storage no longer exists (e.g. it was deleted externally).
      */
     async getInfo() {
         checkStorageAccess();
-        return this.client.get();
+        return this.backend.getMetadata();
     }
     /**
      * Iterates over dataset items, yielding each in turn to an `iteratee` function.
@@ -388,15 +327,115 @@ export class Dataset {
         await this.forEach(wrappedFunc, options);
         return currentMemo;
     }
+    async *fetchEntryPages(options) {
+        let index = options.offset ?? 0;
+        for await (const page of this.fetchPages(options)) {
+            yield {
+                ...page,
+                items: page.items.map((item) => [index++, item]),
+            };
+        }
+    }
+    async *fetchPages(options, pageSize = DATASET_ITERATORS_DEFAULT_LIMIT) {
+        let offset = options.offset ?? 0;
+        const totalLimit = options.limit;
+        let yielded = 0;
+        while (true) {
+            const fetchLimit = totalLimit !== undefined ? Math.min(pageSize, totalLimit - yielded) : pageSize;
+            if (fetchLimit <= 0)
+                break;
+            this.statsTracker.add('readCount');
+            const page = await this.backend.getData({ ...options, offset, limit: fetchLimit });
+            yield page;
+            yielded += page.items.length;
+            if (page.items.length < fetchLimit || offset + page.items.length >= page.total)
+                break;
+            offset += page.items.length;
+        }
+    }
+    /**
+     * Returns dataset items.
+     *
+     * When awaited (`await dataset.values()`), returns all items as a flat `Data[]` array.
+     * When used as an async iterable (`for await...of`), iterates over all items across pages
+     * without loading everything into memory at once.
+     *
+     * **Example usage:**
+     * ```javascript
+     * const dataset = await Dataset.open('my-results');
+     *
+     * // Iterate over all items (memory-efficient for large datasets)
+     * for await (const item of dataset.values()) {
+     *   console.log(item);
+     * }
+     *
+     * // Or fetch all items at once
+     * const items = await dataset.values();
+     * console.log(items);
+     * ```
+     *
+     * @param options Options for the iteration.
+     */
+    values(options = {}) {
+        checkStorageAccess();
+        return createDualIterable({
+            createPages: () => this.fetchPages(options),
+            extractItems: (page) => page.items,
+        });
+    }
+    /**
+     * Returns dataset entries (index-value pairs).
+     *
+     * When awaited (`await dataset.entries()`), returns all entries as a flat `[index, item][]` array.
+     * When used as an async iterable (`for await...of`), iterates over all entries across pages
+     * without loading everything into memory at once.
+     *
+     * **Example usage:**
+     * ```javascript
+     * const dataset = await Dataset.open('my-results');
+     *
+     * // Iterate over all entries
+     * for await (const [index, item] of dataset.entries()) {
+     *   console.log(`Item at ${index}: ${JSON.stringify(item)}`);
+     * }
+     *
+     * // Or fetch all at once
+     * const entries = await dataset.entries();
+     * console.log(entries);
+     * ```
+     *
+     * @param options Options for the iteration.
+     */
+    entries(options = {}) {
+        checkStorageAccess();
+        return createDualIterable({
+            createPages: () => this.fetchEntryPages(options),
+            extractItems: (page) => page.items,
+        });
+    }
+    /**
+     * Default async iterator for the dataset, iterating over items.
+     * Allows using the dataset directly in a `for await...of` loop.
+     *
+     * **Example usage:**
+     * ```javascript
+     * const dataset = await Dataset.open('my-results');
+     * for await (const item of dataset) {
+     *   console.log(item);
+     * }
+     * ```
+     */
+    async *[Symbol.asyncIterator]() {
+        yield* this.values();
+    }
     /**
      * Removes the dataset either from the Apify cloud storage or from the local directory,
      * depending on the mode of operation.
      */
     async drop() {
         checkStorageAccess();
-        await this.client.delete();
-        const manager = StorageManager.getManager(Dataset, this.config);
-        manager.closeStorage(this);
+        await this.backend.drop();
+        serviceLocator.getStorageInstanceManager().removeFromCache(this);
     }
     /**
      * Opens a dataset and returns a promise resolving to an instance of the {@link Dataset} class.
@@ -407,23 +446,27 @@ export class Dataset {
      *
      * For more details and code examples, see the {@link Dataset} class.
      *
-     * @param [datasetIdOrName]
-     *   ID or name of the dataset to be opened. If `null` or `undefined`,
-     *   the function returns the default dataset associated with the crawler run.
+     * @param [identifier]
+     *   ID or name of the dataset to be opened. If a string is provided, it will first be
+     *   looked up as an ID; if no such storage exists, it will be treated as a name.
+     *   If `null` or `undefined`, the function returns the default dataset associated with the crawler run.
      * @param [options] Storage manager options.
      */
-    static async open(datasetIdOrName, options = {}) {
+    static async open(identifier, options = {}) {
         checkStorageAccess();
-        ow(datasetIdOrName, ow.optional.string);
         ow(options, ow.object.exactShape({
-            config: ow.optional.object.instanceOf(Configuration),
-            storageClient: ow.optional.object,
+            configuration: ow.optional.object.instanceOf(Configuration),
+            storageBackend: ow.optional.object,
         }));
-        options.config ??= Configuration.getGlobalConfig();
-        options.storageClient ??= options.config.getStorageClient();
-        await purgeDefaultStorages({ onlyPurgeOnce: true, client: options.storageClient, config: options.config });
-        const manager = StorageManager.getManager(this, options.config);
-        return manager.openStorage(datasetIdOrName, options.storageClient);
+        options.configuration ??= Configuration.getGlobalConfiguration();
+        const storageBackend = options.storageBackend ?? serviceLocator.getStorageBackend();
+        await purgeDefaultStorages({ onlyPurgeOnce: true, storageBackend, configuration: options.configuration });
+        const resolved = await resolveStorageIdentifier(identifier, storageBackend, 'Dataset');
+        return serviceLocator.getStorageInstanceManager().openStorage(this, {
+            ...resolved,
+            backendOpener: () => storageBackend.createDatasetBackend(resolved),
+            backendCacheKey: storageBackend.getStorageBackendCacheKey?.() ?? storageBackend.constructor.name,
+        });
     }
     /**
      * Stores an object or an array of objects to the default {@link Dataset} of the current crawler run.
@@ -461,4 +504,3 @@ export class Dataset {
         return dataset.getData(options);
     }
 }
-//# sourceMappingURL=dataset.js.map

package/storages/index.d.ts

@@ -1,12 +1,13 @@
 export * from './dataset.js';
 export * from './key_value_store.js';
+export * from './key_value_store_codec.js';
 export * from './request_list.js';
-export * from './request_provider.js';
-export { RequestQueueV1 } from './request_queue.js';
-export { RequestQueue } from './request_queue_v2.js';
-export { RequestQueue as RequestQueueV2 } from './request_queue_v2.js';
-export * from './storage_manager.js';
+export type * from './request_loader.js';
+export type * from './request_manager.js';
+export * from './request_queue.js';
+export * from './storage_instance_manager.js';
+export * from './storage_stats.js';
 export * from './utils.js';
 export * from './access_checking.js';
-export * from './sitemap_request_list.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './sitemap_request_loader.js';
+export * from './request_manager_tandem.js';

package/storages/index.js

@@ -1,12 +1,11 @@
 export * from './dataset.js';
 export * from './key_value_store.js';
+export * from './key_value_store_codec.js';
 export * from './request_list.js';
-export * from './request_provider.js';
-export { RequestQueueV1 } from './request_queue.js';
-export { RequestQueue } from './request_queue_v2.js';
-export { RequestQueue as RequestQueueV2 } from './request_queue_v2.js';
-export * from './storage_manager.js';
+export * from './request_queue.js';
+export * from './storage_instance_manager.js';
+export * from './storage_stats.js';
 export * from './utils.js';
 export * from './access_checking.js';
-export * from './sitemap_request_list.js';
-//# sourceMappingURL=index.js.map
+export * from './sitemap_request_loader.js';
+export * from './request_manager_tandem.js';