apify-client 3.0.0-beta.62 → 3.0.0-beta.64

package/dist/resource_clients/dataset.d.ts

@@ -1,3 +1,4 @@
+import type { Readable } from 'node:stream';
 import type { STORAGE_GENERAL_ACCESS } from '@apify/consts';
 import type { ApiClientSubResourceOptions } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
@@ -167,6 +168,34 @@ export declare class DatasetClient<Data extends Record<string | number, any> = R
      * ```
      */
     downloadItems(format: `${DownloadItemsFormat}`, options?: DatasetClientDownloadItemsOptions): Promise<Buffer>;
+    /**
+     * Downloads dataset items in a specific format as a Readable stream. Only works in Node.js.
+     *
+     * Takes the same arguments as {@link downloadItems}, but resolves to the response body as a stream, so a large
+     * export is processed in chunks without holding all of it in memory.
+     *
+     * The stream holds its connection open until you consume it to the end or destroy it. Iterating it with
+     * `for await` or passing it to `pipeline()` from `node:stream/promises` does either one for you.
+     *
+     * @param format - Output format: `'json'`, `'jsonl'`, `'csv'`, `'xlsx'`, `'xml'`, `'rss'`, or `'html'`
+     * @param options - Download and formatting options, the same as for {@link downloadItems}
+     * @param options.timeoutSecs - Timeout for the API to start responding. Default is `'long'`. Once the stream is
+     * returned, it only limits inactivity: the stream errors if no data arrives for that long. To stop the download
+     * early or cap its total duration, destroy the stream or abort `signal`.
+     * @returns Readable stream of the items serialized to the specified format
+     * @see https://docs.apify.com/api/v2/dataset-items-get
+     *
+     * @example
+     * ```javascript
+     * const { createWriteStream } = require('node:fs');
+     * const { pipeline } = require('node:stream/promises');
+     *
+     * // Write a CSV export straight to a file
+     * const stream = await client.dataset('my-dataset').streamItems('csv', { bom: true });
+     * await pipeline(stream, createWriteStream('output.csv'));
+     * ```
+     */
+    streamItems(format: `${DownloadItemsFormat}`, options?: DatasetClientDownloadItemsOptions): Promise<Readable>;
     /**
      * Stores one or more items into the dataset.
      *

package/dist/resource_clients/dataset.js

@@ -3,6 +3,7 @@ import { createStorageContentSignatureAsync } from '@apify/utilities';
 import { ResourceClient } from '../base/resource_client.js';
 import * as schemas from '../schemas.js';
 import { timeoutOptionsSchema, timeoutOptionsShape } from '../timeouts.js';
+import { runtime } from '#runtime';
 import { anyObjectSchema, applyQueryParamsToUrl, cast, isNonArrayObject, paginationOptionsShape, parseArgument, parseResponse, SCANNED_COUNT, } from '../utils.js';
 /**
  * Supported formats for downloading dataset items.
@@ -269,6 +270,52 @@ export class DatasetClient extends ResourceClient {
         });
         return cast(data);
     }
+    /**
+     * Downloads dataset items in a specific format as a Readable stream. Only works in Node.js.
+     *
+     * Takes the same arguments as {@link downloadItems}, but resolves to the response body as a stream, so a large
+     * export is processed in chunks without holding all of it in memory.
+     *
+     * The stream holds its connection open until you consume it to the end or destroy it. Iterating it with
+     * `for await` or passing it to `pipeline()` from `node:stream/promises` does either one for you.
+     *
+     * @param format - Output format: `'json'`, `'jsonl'`, `'csv'`, `'xlsx'`, `'xml'`, `'rss'`, or `'html'`
+     * @param options - Download and formatting options, the same as for {@link downloadItems}
+     * @param options.timeoutSecs - Timeout for the API to start responding. Default is `'long'`. Once the stream is
+     * returned, it only limits inactivity: the stream errors if no data arrives for that long. To stop the download
+     * early or cap its total duration, destroy the stream or abort `signal`.
+     * @returns Readable stream of the items serialized to the specified format
+     * @see https://docs.apify.com/api/v2/dataset-items-get
+     *
+     * @example
+     * ```javascript
+     * const { createWriteStream } = require('node:fs');
+     * const { pipeline } = require('node:stream/promises');
+     *
+     * // Write a CSV export straight to a file
+     * const stream = await client.dataset('my-dataset').streamItems('csv', { bom: true });
+     * await pipeline(stream, createWriteStream('output.csv'));
+     * ```
+     */
+    async streamItems(format, options = {}) {
+        parseArgument(format, itemFormatSchema);
+        const { timeoutSecs = 'long', signal, ...query } = parseArgument(options, downloadItemsOptionsSchema, 'DatasetClientDownloadItemsOptions');
+        if (!runtime.isNode) {
+            throw new Error('The streamItems() method can only be used in Node.js environment.');
+        }
+        const { data } = await this.httpClient.call({
+            url: this.buildUrl('items'),
+            method: 'GET',
+            params: this.buildParams({
+                format,
+                ...query,
+            }),
+            responseType: 'stream',
+            timeoutSecs,
+            signal,
+        });
+        return cast(data);
+    }
     /**
      * Stores one or more items into the dataset.
      *

package/dist/resource_clients/log.d.ts

@@ -19,6 +19,9 @@ import type { TimeoutOptions } from '../timeouts.js';
  * const log = await runClient.log().get();
  * console.log(log);
  *
+ * // Get the log content as raw bytes
+ * const logBuffer = await runClient.log().get({ buffer: true });
+ *
  * // Stream the log in real-time
  * const stream = await runClient.log().stream();
  * stream.on('line', (line) => console.log(line));
@@ -34,14 +37,26 @@ export declare class LogClient extends ResourceClient {
     /**
      * Retrieves the log as a string.
      *
+     * The `buffer` option only selects the return type: the bytes come back as a Buffer (Node.js) or ArrayBuffer
+     * (browser), not decoded to a string. Either way the whole log is downloaded in one response; to read it
+     * incrementally, use {@link LogClient.stream}.
+     *
      * @param options - Log retrieval options.
      * @param options.raw - If `true`, returns raw log content without any processing. Default is `false`.
+     * @param options.buffer - If `true`, the log is returned as a Buffer (Node.js) or ArrayBuffer (browser) instead of a
+     * string. It does not change how the log is fetched.
      * @param options.timeoutSecs - Timeout for the API request. Default is `'long'`.
-     * @returns The log content as a string, or `undefined` if it does not exist. A chained client such as
-     * `run.log()` throws an `ApifyApiError` on a 404, since the run itself may be what is missing.
+     * @returns The log content, or `undefined` if it does not exist. A chained client such as `run.log()` throws an
+     * `ApifyApiError` on a 404, since the run itself may be what is missing.
      * @see https://docs.apify.com/api/v2/log-get
      */
-    get(options?: LogOptions): Promise<string | undefined>;
+    get(options?: LogGetOptions & {
+        buffer?: false;
+    }): Promise<string | undefined>;
+    get(options: LogGetOptions & {
+        buffer: true;
+    }): Promise<Buffer | undefined>;
+    get(options?: LogGetOptions): Promise<string | Buffer | undefined>;
     /**
      * Retrieves the log as a Readable stream. Only works in Node.js.
      *
@@ -61,6 +76,17 @@ export interface LogOptions extends TimeoutOptions {
     /** @default false */
     raw?: boolean;
 }
+/**
+ * Options for {@link LogClient.get}.
+ */
+export interface LogGetOptions extends LogOptions {
+    /**
+     * If `true`, the log is returned as a Buffer (Node.js) or ArrayBuffer (browser) instead of a string. It only selects
+     * the return type; to read the log incrementally, use {@link LogClient.stream}.
+     * @default false
+     */
+    buffer?: boolean;
+}
 /**
  * Logger for redirected actor logs.
  * @since Added in 2.20.0

package/dist/resource_clients/log.js

@@ -13,6 +13,7 @@ const EMPTY_LOG_STREAM_RETRY_MILLIS = 500;
 /** Upper bound on the pause between reopens of an empty log stream. */
 const EMPTY_LOG_STREAM_MAX_RETRY_MILLIS = 5_000;
 const logOptionsSchema = z.strictObject({ raw: z.boolean().optional(), ...timeoutOptionsShape });
+const logGetOptionsSchema = logOptionsSchema.extend({ buffer: z.boolean().optional() });
 /** How long `StreamedLog.stop()` waits for lines already in flight before aborting the log stream request. */
 const STOP_GRACE_MILLIS = 1000;
 /**
@@ -30,6 +31,9 @@ const STOP_GRACE_MILLIS = 1000;
  * const log = await runClient.log().get();
  * console.log(log);
  *
+ * // Get the log content as raw bytes
+ * const logBuffer = await runClient.log().get({ buffer: true });
+ *
  * // Stream the log in real-time
  * const stream = await runClient.log().stream();
  * stream.on('line', (line) => console.log(line));
@@ -47,18 +51,8 @@ export class LogClient extends ResourceClient {
             ...options,
         });
     }
-    /**
-     * Retrieves the log as a string.
-     *
-     * @param options - Log retrieval options.
-     * @param options.raw - If `true`, returns raw log content without any processing. Default is `false`.
-     * @param options.timeoutSecs - Timeout for the API request. Default is `'long'`.
-     * @returns The log content as a string, or `undefined` if it does not exist. A chained client such as
-     * `run.log()` throws an `ApifyApiError` on a 404, since the run itself may be what is missing.
-     * @see https://docs.apify.com/api/v2/log-get
-     */
     async get(options = {}) {
-        const { timeoutSecs = 'long', signal, ...params } = parseArgument(options, logOptionsSchema, 'LogOptions');
+        const { timeoutSecs = 'long', signal, buffer, ...params } = parseArgument(options, logGetOptionsSchema, 'LogGetOptions');
         const requestOpts = {
             url: this.buildUrl(),
             method: 'GET',
@@ -66,6 +60,8 @@ export class LogClient extends ResourceClient {
             timeoutSecs,
             signal,
         };
+        if (buffer)
+            requestOpts.responseType = 'buffer';
         try {
             const response = await this.httpClient.call(requestOpts);
             return cast(response.data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.62",
+  "version": "3.0.0-beta.64",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.13.0"