@crawlee/core 3.0.0-alpha.2 → 3.0.0-alpha.22

package/proxy_configuration.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyConfiguration = void 0;
+const tslib_1 = require("tslib");
+const ow_1 = tslib_1.__importDefault(require("ow"));
+const log_1 = tslib_1.__importDefault(require("@apify/log"));
+const configuration_1 = require("./configuration");
+/**
+ * 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
+ * them to use the selected proxies for all connections. You can get information about the currently used proxy by inspecting
+ * the {@link ProxyInfo} property in your crawler's page function. There, you can inspect the proxy's URL and other attributes.
+ *
+ * If you want to use your own proxies, use the {@link ProxyConfigurationOptions.proxyUrls} option. Your list of proxy URLs will
+ * be rotated by the configuration if this option is provided.
+ *
+ * **Example usage:**
+ *
+ * ```javascript
+ *
+ * const proxyConfiguration = new ProxyConfiguration({
+ *   proxyUrls: ['...', '...'],
+ * });
+ *
+ * const crawler = new CheerioCrawler({
+ *   // ...
+ *   proxyConfiguration,
+ *   handlePageFunction: ({ proxyInfo }) => {
+ *      const usedProxyUrl = proxyInfo.url; // Getting the proxy URL
+ *   }
+ * })
+ *
+ * ```
+ * @category Scaling
+ */
+class ProxyConfiguration {
+    /**
+     * Creates a {@link ProxyConfiguration} instance based on 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
+     * them to use the selected proxies for all connections.
+     *
+     * ```javascript
+     * const proxyConfiguration = new ProxyConfiguration({
+     *     proxyUrls: ['http://user:pass@proxy-1.com', 'http://user:pass@proxy-2.com'],
+     * });
+     *
+     * const crawler = new CheerioCrawler({
+     *   // ...
+     *   proxyConfiguration,
+     *   handlePageFunction: ({ proxyInfo }) => {
+     *       const usedProxyUrl = proxyInfo.url; // Getting the proxy URL
+     *   }
+     * })
+     *
+     * ```
+     * @param options
+     * @param config
+     * @param validateRequired internal flag to disable validation that requires one of `proxyUrls` or `newUrlFunction`, defaults to true
+     */
+    constructor(options = {}, config = configuration_1.Configuration.getGlobalConfig(), validateRequired = true) {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: config
+        });
+        Object.defineProperty(this, "isManInTheMiddle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "nextCustomUrlIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "proxyUrls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "usedProxyUrls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "newUrlFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "log", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: log_1.default.child({ prefix: 'ProxyConfiguration' })
+        });
+        (0, ow_1.default)(options, ow_1.default.object.exactShape({
+            proxyUrls: ow_1.default.optional.array.nonEmpty.ofType(ow_1.default.string.url),
+            newUrlFunction: ow_1.default.optional.function,
+        }));
+        const { proxyUrls, newUrlFunction } = options;
+        if (proxyUrls && newUrlFunction)
+            this._throwCannotCombineCustomMethods();
+        if (!proxyUrls && !newUrlFunction && validateRequired)
+            this._throwNoOptionsProvided();
+        this.proxyUrls = proxyUrls;
+        this.newUrlFunction = newUrlFunction;
+    }
+    /**
+     * This function creates a new {@link ProxyInfo} info object.
+     * It is used by CheerioCrawler and PuppeteerCrawler to generate proxy URLs and also to allow the user to inspect
+     * the currently used proxy via the handlePageFunction parameter: proxyInfo.
+     * Use it if you want to work with a rich representation of a proxy URL.
+     * If you need the URL string only, use {@link ProxyConfiguration.newUrl}.
+     * @param [sessionId]
+     *  Represents the identifier of user {@link Session} that can be managed by the {@link SessionPool} or
+     *  you can use the Apify Proxy [Session](https://docs.apify.com/proxy#sessions) identifier.
+     *  When the provided sessionId is a number, it's converted to a string. Property sessionId of
+     *  {@link ProxyInfo} is always returned as a type string.
+     *
+     *  All the HTTP requests going through the proxy with the same session identifier
+     *  will use the same target proxy server (i.e. the same IP address).
+     *  The identifier must not be longer than 50 characters and include only the following: `0-9`, `a-z`, `A-Z`, `"."`, `"_"` and `"~"`.
+     * @return Represents information about used proxy and its configuration.
+     */
+    async newProxyInfo(sessionId) {
+        if (typeof sessionId === 'number')
+            sessionId = `${sessionId}`;
+        const url = await this.newUrl(sessionId);
+        const { username, password, port, hostname } = new URL(url);
+        return {
+            sessionId,
+            url,
+            username,
+            password,
+            hostname,
+            port: port,
+        };
+    }
+    /**
+     * Returns a new proxy URL based on provided configuration options and the `sessionId` parameter.
+     * @param [sessionId]
+     *  Represents the identifier of user {@link Session} that can be managed by the {@link SessionPool} or
+     *  you can use the Apify Proxy [Session](https://docs.apify.com/proxy#sessions) identifier.
+     *  When the provided sessionId is a number, it's converted to a string.
+     *
+     *  All the HTTP requests going through the proxy with the same session identifier
+     *  will use the same target proxy server (i.e. the same IP address).
+     *  The identifier must not be longer than 50 characters and include only the following: `0-9`, `a-z`, `A-Z`, `"."`, `"_"` and `"~"`.
+     * @return A string with a proxy URL, including authentication credentials and port number.
+     *  For example, `http://bob:password123@proxy.example.com:8000`
+     */
+    async newUrl(sessionId) {
+        if (typeof sessionId === 'number')
+            sessionId = `${sessionId}`;
+        if (this.newUrlFunction) {
+            return this._callNewUrlFunction(sessionId);
+        }
+        return this._handleCustomUrl(sessionId);
+    }
+    /**
+     * Handles custom url rotation with session
+     */
+    _handleCustomUrl(sessionId) {
+        let customUrlToUse;
+        if (!sessionId) {
+            return this.proxyUrls[this.nextCustomUrlIndex++ % this.proxyUrls.length];
+        }
+        if (this.usedProxyUrls.has(sessionId)) {
+            customUrlToUse = this.usedProxyUrls.get(sessionId);
+        }
+        else {
+            customUrlToUse = this.proxyUrls[this.nextCustomUrlIndex++ % this.proxyUrls.length];
+            this.usedProxyUrls.set(sessionId, customUrlToUse);
+        }
+        return customUrlToUse;
+    }
+    /**
+     * Calls the custom newUrlFunction and checks format of its return value
+     */
+    async _callNewUrlFunction(sessionId) {
+        let proxyUrl;
+        try {
+            proxyUrl = await this.newUrlFunction(sessionId);
+            new URL(proxyUrl); // eslint-disable-line no-new
+            return proxyUrl;
+        }
+        catch (err) {
+            this._throwNewUrlFunctionInvalid(err);
+        }
+    }
+    _throwNewUrlFunctionInvalid(err) {
+        throw new Error(`The provided newUrlFunction did not return a valid URL.\nCause: ${err.message}`);
+    }
+    _throwCannotCombineCustomMethods() {
+        throw new Error('Cannot combine custom proxies "options.proxyUrls" with custom generating function "options.newUrlFunction".');
+    }
+    _throwNoOptionsProvided() {
+        throw new Error('One of "options.proxyUrls" or "options.newUrlFunction" needs to be provided.');
+    }
+}
+exports.ProxyConfiguration = ProxyConfiguration;
+//# sourceMappingURL=proxy_configuration.js.map

package/proxy_configuration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy_configuration.js","sourceRoot":"","sources":["../src/proxy_configuration.ts"],"names":[],"mappings":"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"}

package/request.d.ts

@@ -0,0 +1,185 @@
+/// <reference types="node" />
+import { BinaryLike } from 'crypto';
+import { AllowedHttpMethods } from './typedefs';
+/**
+ * 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.
+ *
+ * Each `Request` instance has the `uniqueKey` property, which can be either specified
+ * manually in the constructor or generated automatically from the URL. Two requests with the same `uniqueKey`
+ * are considered as pointing to the same web resource. This behavior applies to all Apify SDK classes,
+ * such as {@link RequestList}, {@link RequestQueue}, {@link PuppeteerCrawler} or {@link PlaywrightCrawler}.
+ *
+ * Example use:
+ *
+ * ```javascript
+ * const request = new Request({
+ *     url: 'http://www.example.com',
+ *     headers: { Accept: 'application/json' },
+ * });
+ *
+ * ...
+ *
+ * request.userData.foo = 'bar';
+ * request.pushErrorMessage(new Error('Request failed!'));
+ *
+ * ...
+ *
+ * const foo = request.userData.foo;
+ * ```
+ * @category Sources
+ */
+export declare class Request {
+    /** Request ID */
+    id?: string;
+    /** URL of the web page to crawl. */
+    url: string;
+    /**
+     * An actually loaded URL after redirects, if present. HTTP redirects are guaranteed
+     * to be included.
+     *
+     * When using {@link PuppeteerCrawler} or {@link PlaywrightCrawler}, meta tag and JavaScript redirects may,
+     * or may not be included, depending on their nature. This generally means that redirects,
+     * which happen immediately will most likely be included, but delayed redirects will not.
+     */
+    loadedUrl?: string;
+    /**
+     * A unique key identifying the request.
+     * Two requests with the same `uniqueKey` are considered as pointing to the same URL.
+     */
+    uniqueKey: string;
+    /** HTTP method, e.g. `GET` or `POST`. */
+    method: AllowedHttpMethods;
+    /** HTTP request payload, e.g. for POST requests. */
+    payload?: string;
+    /** The `true` value indicates that the request will not be automatically retried on error. */
+    noRetry: boolean;
+    /** Indicates the number of times the crawling of the request has been retried on error. */
+    retryCount: number;
+    /** An array of error messages from request processing. */
+    errorMessages: string[];
+    /** Object with HTTP headers. Key is header name, value is the value. */
+    headers?: Record<string, string>;
+    /** Private store for the custom user data assigned to the request. */
+    private _userData;
+    /** Custom user data assigned to the request. */
+    userData: Record<string, any>;
+    /**
+     * ISO datetime string that indicates the time when the request has been processed.
+     * Is `null` if the request has not been crawled yet.
+     */
+    handledAt?: string;
+    /**
+     * `Request` parameters including the URL, HTTP method and headers, and others.
+     */
+    constructor(options: RequestOptions);
+    /** Tells the crawler processing this request to skip the navigation and process the request directly. */
+    get skipNavigation(): boolean;
+    set skipNavigation(value: boolean);
+    /**
+     * Stores information about an error that occurred during processing of this request.
+     *
+     * You should always use Error instances when throwing errors in JavaScript.
+     *
+     * Nevertheless, to improve the debugging experience when using third party libraries
+     * that may not always throw an Error instance, the function performs a type
+     * inspection of the passed argument and attempts to extract as much information
+     * as possible, since just throwing a bad type error makes any debugging rather difficult.
+     *
+     * @param errorOrMessage Error object or error message to be stored in the request.
+     * @param [options]
+     */
+    pushErrorMessage(errorOrMessage: unknown, options?: PushErrorMessageOptions): void;
+    protected _computeUniqueKey({ url, method, payload, keepUrlFragment, useExtendedUniqueKey }: ComputeUniqueKeyOptions): string;
+    protected _hashPayload(payload: BinaryLike): string;
+}
+/**
+ * Specifies required and optional fields for constructing a {@link Request}.
+ */
+export interface RequestOptions {
+    /** URL of the web page to crawl. It must be a non-empty string. */
+    url: string;
+    /**
+     * A unique key identifying the request.
+     * Two requests with the same `uniqueKey` are considered as pointing to the same URL.
+     *
+     * If `uniqueKey` is not provided, then it is automatically generated by normalizing the URL.
+     * For example, the URL of `HTTP://www.EXAMPLE.com/something/` will produce the `uniqueKey`
+     * of `http://www.example.com/something`.
+     *
+     * The `keepUrlFragment` option determines whether URL hash fragment is included in the `uniqueKey` or not.
+     *
+     * The `useExtendedUniqueKey` options determines whether method and payload are included in the `uniqueKey`,
+     * producing a `uniqueKey` in the following format: `METHOD(payloadHash):normalizedUrl`. This is useful
+     * when requests point to the same URL, but with different methods and payloads. For example: form submits.
+     *
+     * Pass an arbitrary non-empty text value to the `uniqueKey` property
+     * to override the default behavior and specify which URLs shall be considered equal.
+     */
+    uniqueKey?: string;
+    /** @default 'GET' */
+    method?: AllowedHttpMethods | Lowercase<AllowedHttpMethods>;
+    /** HTTP request payload, e.g. for POST requests. */
+    payload?: string;
+    /**
+     * HTTP headers in the following format:
+     * ```
+     * {
+     *     Accept: 'text/html',
+     *     'Content-Type': 'application/json'
+     * }
+     * ```
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom user data assigned to the request. Use this to save any request related data to the
+     * request's scope, keeping them accessible on retries, failures etc.
+     */
+    userData?: Record<string, any>;
+    /**
+     * If `false` then the hash part of a URL is removed when computing the `uniqueKey` property.
+     * For example, this causes the `http://www.example.com#foo` and `http://www.example.com#bar` URLs
+     * to have the same `uniqueKey` of `http://www.example.com` and thus the URLs are considered equal.
+     * Note that this option only has an effect if `uniqueKey` is not set.
+     * @default false
+     */
+    keepUrlFragment?: boolean;
+    /**
+     * If `true` then the `uniqueKey` is computed not only from the URL, but also from the method and payload
+     * properties. This is useful when making requests to the same URL that are differentiated by method
+     * or payload, such as form submit navigations in browsers.
+     * @default false
+     */
+    useExtendedUniqueKey?: boolean;
+    /**
+     * The `true` value indicates that the request will not be automatically retried on error.
+     * @default false
+     */
+    noRetry?: boolean;
+    /**
+     * If set to `true` then the crawler processing this request evaluates
+     * the `handleRequestFunction` immediately without prior browser navigation.
+     * @default false
+     */
+    skipNavigation?: boolean;
+    /** @internal */
+    id?: string;
+    /** @internal */
+    handledAt?: string;
+}
+export interface PushErrorMessageOptions {
+    /**
+     * Only push the error message without stack trace when true.
+     * @default false
+     */
+    omitStack?: boolean;
+}
+interface ComputeUniqueKeyOptions {
+    url: string;
+    method: AllowedHttpMethods;
+    payload?: string | Buffer;
+    keepUrlFragment?: boolean;
+    useExtendedUniqueKey?: boolean;
+}
+export {};
+//# sourceMappingURL=request.d.ts.map

package/request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.d.ts","sourceRoot":"","sources":["../src/request.ts"],"names":[],"mappings":";AACA,OAAe,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAI5C,OAAO,EAAE,kBAAkB,EAAQ,MAAM,YAAY,CAAC;AAsBtD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,OAAO;IAChB,iBAAiB;IACjB,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB,yCAAyC;IACzC,MAAM,EAAE,kBAAkB,CAAC;IAE3B,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,8FAA8F;IAC9F,OAAO,EAAE,OAAO,CAAC;IAEjB,2FAA2F;IAC3F,UAAU,EAAE,MAAM,CAAC;IAEnB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,EAAE,CAAC;IAExB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC,sEAAsE;IACtE,OAAO,CAAC,SAAS,CAA2B;IAE5C,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IAEnC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;gBACS,OAAO,EAAE,cAAc;IAqGnC,yGAAyG;IACzG,IAAI,cAAc,IAAI,OAAO,CAG5B;IAED,IAAI,cAAc,CAAC,KAAK,EAAE,OAAO,EAKhC;IAED;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,cAAc,EAAE,OAAO,EAAE,OAAO,GAAE,uBAA4B,GAAG,IAAI;IAgCtF,SAAS,CAAC,iBAAiB,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,EAAE,uBAAuB;IAgBpH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM;CAQtD;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAE3B,mEAAmE;IACnE,GAAG,EAAE,MAAM,CAAC;IAEZ;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,qBAAqB;IACrB,MAAM,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,CAAC,CAAC;IAE5D,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE/B;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAE/B;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,gBAAgB;IAChB,EAAE,CAAC,EAAE,MAAM,CAAC;IAEZ,gBAAgB;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CAEtB;AAED,MAAM,WAAW,uBAAuB;IACpC;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,UAAU,uBAAuB;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAClC"}