apify-client 3.0.0-beta.8 → 3.0.0-rc.0

package/dist/http_compressors/brotli.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runtime } from '#runtime';
+import { parseArgument } from '../utils.js';
+/** Lowest valid brotli quality, the fastest with the least compression. */
+const MIN_QUALITY = 0;
+/** Highest valid brotli quality, the slowest with the best compression. */
+const MAX_QUALITY = 11;
+/** Middle of the range, where brotli already beats gzip at a comparable CPU cost. */
+const DEFAULT_QUALITY = 6;
+const optionsSchema = z.strictObject({
+    quality: z.int().min(MIN_QUALITY).max(MAX_QUALITY).default(DEFAULT_QUALITY),
+});
+/**
+ * Compresses request bodies using brotli.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, BrotliHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new BrotliHttpCompressor({ quality: 11 }) });
+ * ```
+ */
+export class BrotliHttpCompressor {
+    contentEncoding = 'br';
+    #quality;
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options = {}) {
+        const { quality } = parseArgument(options, optionsSchema, 'BrotliHttpCompressorOptions');
+        this.#quality = quality;
+    }
+    async compress(data) {
+        return runtime.compress(data, { algorithm: 'br', quality: this.#quality });
+    }
+}

package/dist/http_compressors/gzip.d.ts

@@ -0,0 +1,33 @@
+import type { HttpCompressor } from './base.js';
+/**
+ * Compresses request bodies using gzip.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, GzipHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new GzipHttpCompressor({ quality: 1 }) });
+ * ```
+ */
+export declare class GzipHttpCompressor implements HttpCompressor {
+    #private;
+    readonly contentEncoding = "gzip";
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options?: GzipHttpCompressorOptions);
+    compress(data: Buffer): Promise<Buffer>;
+}
+/**
+ * Options for {@link GzipHttpCompressor}.
+ */
+export interface GzipHttpCompressorOptions {
+    /**
+     * Compression level, from `1` (the fastest) to `9` (the best compression).
+     * @default 6
+     */
+    quality?: number;
+}

package/dist/http_compressors/gzip.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runtime } from '#runtime';
+import { parseArgument } from '../utils.js';
+/** Lowest valid gzip quality, the fastest with the least compression. */
+const MIN_QUALITY = 1;
+/** Highest valid gzip quality, the slowest with the best compression. */
+const MAX_QUALITY = 9;
+/** zlib's own default. The levels above it roughly double the CPU cost for about a percent fewer bytes. */
+const DEFAULT_QUALITY = 6;
+const optionsSchema = z.strictObject({
+    quality: z.int().min(MIN_QUALITY).max(MAX_QUALITY).default(DEFAULT_QUALITY),
+});
+/**
+ * Compresses request bodies using gzip.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, GzipHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new GzipHttpCompressor({ quality: 1 }) });
+ * ```
+ */
+export class GzipHttpCompressor {
+    contentEncoding = 'gzip';
+    #quality;
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options = {}) {
+        const { quality } = parseArgument(options, optionsSchema, 'GzipHttpCompressorOptions');
+        this.#quality = quality;
+    }
+    async compress(data) {
+        return runtime.compress(data, { algorithm: 'gzip', quality: this.#quality });
+    }
+}

package/dist/http_compressors/index.d.ts

@@ -0,0 +1,6 @@
+export type { HttpCompressor } from './base.js';
+export { BrotliHttpCompressor } from './brotli.js';
+export type { BrotliHttpCompressorOptions } from './brotli.js';
+export { GzipHttpCompressor } from './gzip.js';
+export type { GzipHttpCompressorOptions } from './gzip.js';
+export type { HttpCompressionAlgorithm } from './resolve.js';

package/dist/http_compressors/index.js

@@ -0,0 +1,2 @@
+export { BrotliHttpCompressor } from './brotli.js';
+export { GzipHttpCompressor } from './gzip.js';

package/dist/http_compressors/resolve.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { HttpCompressor } from './base.js';
+/**
+ * Compression algorithms the `compression` option of {@link ApifyClient} accepts by name. Each name selects the
+ * matching built-in compressor with its default quality: `'brotli'` a {@link BrotliHttpCompressor}, `'gzip'` a
+ * {@link GzipHttpCompressor}. The Apify API also accepts `deflate` and `identity`, which a custom
+ * {@link HttpCompressor} covers.
+ */
+export type HttpCompressionAlgorithm = 'brotli' | 'gzip';
+/**
+ * Schema of the `compression` option: an algorithm name or an {@link HttpCompressor}.
+ * @internal
+ */
+export declare const compressionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    brotli: "brotli";
+    gzip: "gzip";
+}>, z.ZodCustom<HttpCompressor, HttpCompressor>]>;
+/**
+ * Turns the `compression` option into a ready-to-use {@link HttpCompressor}: a name into the matching built-in
+ * compressor with its default quality, a compressor into itself.
+ * @internal
+ */
+export declare function resolveCompressor(compression: HttpCompressionAlgorithm | HttpCompressor): HttpCompressor;

package/dist/http_compressors/resolve.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { httpCompressorSchema } from './base.js';
+import { BrotliHttpCompressor } from './brotli.js';
+import { GzipHttpCompressor } from './gzip.js';
+/**
+ * Schema of the `compression` option: an algorithm name or an {@link HttpCompressor}.
+ * @internal
+ */
+export const compressionSchema = z.union([
+    z.enum(['brotli', 'gzip']),
+    httpCompressorSchema,
+]);
+/**
+ * Turns the `compression` option into a ready-to-use {@link HttpCompressor}: a name into the matching built-in
+ * compressor with its default quality, a compressor into itself.
+ * @internal
+ */
+export function resolveCompressor(compression) {
+    if (typeof compression !== 'string')
+        return compression;
+    switch (compression) {
+        case 'gzip':
+            return new GzipHttpCompressor();
+        case 'brotli':
+            return new BrotliHttpCompressor();
+    }
+}

package/dist/index.d.ts

@@ -29,5 +29,8 @@ export * from './resource_clients/webhook_dispatch_collection.js';
 export * from './apify_api_error.js';
 export { ArgumentValidationError } from '@apify/validations';
 export * from './response_validation_error.js';
-export { InvalidResponseBodyError } from './interceptors.js';
+export * from './invalid_response_body_error.js';
+export * from './http_clients/index.js';
+export * from './http_compressors/index.js';
 export type { PaginatedList, Dictionary } from './utils.js';
+export type { Timeout, TimeoutOptions, TimeoutTier } from './timeouts.js';

package/dist/index.js

@@ -29,4 +29,6 @@ export * from './resource_clients/webhook_dispatch_collection.js';
 export * from './apify_api_error.js';
 export { ArgumentValidationError } from '@apify/validations';
 export * from './response_validation_error.js';
-export { InvalidResponseBodyError } from './interceptors.js';
+export * from './invalid_response_body_error.js';
+export * from './http_clients/index.js';
+export * from './http_compressors/index.js';

package/dist/invalid_response_body_error.d.ts

@@ -0,0 +1,13 @@
+import type { HttpResponse } from './http_clients/base.js';
+/**
+ * Thrown when a response body does not parse as its content type claims, typically a JSON document cut short by a
+ * connection dropped mid-response. The client retries such requests, so the error surfaces once the retries are
+ * exhausted.
+ */
+export declare class InvalidResponseBodyError extends Error {
+    code: string;
+    /** The response whose body did not parse, with the body as the transport returned it. */
+    response: HttpResponse;
+    cause: Error;
+    constructor(response: HttpResponse, cause: Error);
+}

package/dist/invalid_response_body_error.js

@@ -0,0 +1,17 @@
+/**
+ * Thrown when a response body does not parse as its content type claims, typically a JSON document cut short by a
+ * connection dropped mid-response. The client retries such requests, so the error surfaces once the retries are
+ * exhausted.
+ */
+export class InvalidResponseBodyError extends Error {
+    code;
+    /** The response whose body did not parse, with the body as the transport returned it. */
+    response;
+    constructor(response, cause) {
+        super(`Response body could not be parsed.\nCause:${cause.message}`);
+        this.name = this.constructor.name;
+        this.code = 'invalid-response-body';
+        this.response = response;
+        this.cause = cause;
+    }
+}