@clickup/rest-client 2.10.292

package/dist/RestOptions.d.ts

@@ -0,0 +1,143 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Agent as HttpAgent } from "http";
+import { Agent as HttpsAgent } from "https";
+import type RestRequest from "./RestRequest";
+import type RestResponse from "./RestResponse";
+/**
+ * An event which is passed to an external logger (see RestOptions).
+ */
+export interface RestLogEvent {
+    attempt: number;
+    req: RestRequest;
+    res: RestResponse | "backoff_delay" | null;
+    exception: any | null;
+    timestamp: number;
+    elapsed: number;
+    isFinalAttempt: boolean;
+    privateDataInResponse: boolean;
+    comment: string;
+}
+/**
+ * Middlewares allow to modify RestRequest and RestResponse objects during the
+ * request processing.
+ */
+export interface Middleware {
+    (req: RestRequest, next: (req: RestRequest) => Promise<RestResponse>): Promise<RestResponse>;
+}
+/**
+ * @ignore
+ * Parameters for Agents.
+ */
+interface AgentOptions {
+    keepAlive: boolean;
+    maxSockets?: number;
+    rejectUnauthorized?: boolean;
+    family?: 4 | 6 | 0;
+}
+/**
+ * @ignore
+ * An internal class which keeps the list of HttpAgent instances used in a
+ * particular RestClient instance.
+ */
+export declare class Agents {
+    http(options: AgentOptions): HttpAgent;
+    https(options: AgentOptions): HttpsAgent;
+}
+/**
+ * Options passed to RestClient. More options can be added by cloning an
+ * instance of RestClient, withOption() method.
+ */
+export default interface RestOptions {
+    /** Max number of retries. Default is 0, because some requests are from the
+     * web app, and we don't want to retry them. */
+    retries: number;
+    /** How much time to wait by default on the 1st retry attempt. */
+    retryDelayFirstMs: number;
+    /** How much to increase the retry delay on each retry. */
+    retryDelayFactor: number;
+    /** Use this fraction (random) of the current retry delay to jitter both ways
+     * (e.g. 0.1 means 90%...110% of the delay to be actually applied). */
+    retryDelayJitter: number;
+    /** Maximum delay between each retry. */
+    retryDelayMaxMs: number;
+    /** A logic which runs on different IO stages (delay and heartbeats). */
+    heartbeater: {
+        heartbeat(): Promise<void>;
+        /** A function which, when runs, resolves in the provided number of ms. Can
+         * be used for several purposes, like overriding in unit tests or to pass a
+         * custom delay implementation which can throw on some external event (like
+         * when the process wants to gracefully stop). */
+        delay(ms: number): Promise<void>;
+    };
+    /** Allows to limit huge requests and throw instead. */
+    throwIfResIsBigger: number | undefined;
+    /** Passed to the logger which may decide, should it log details of the
+     * response or not. */
+    privateDataInResponse: boolean;
+    /** If true, non-public IP addresses are allowed too; otherwise, only unicast
+     * addresses are allowed. */
+    allowInternalIPs: boolean;
+    /** If true, logs request-response pairs to console. */
+    isDebug: boolean;
+    /** @ignore Holds HttpsAgent/HttpAgent instances; used internally only. */
+    agents: Agents;
+    /** Sets Keep-Alive parameters (persistent connections). */
+    keepAlive: {
+        /** A hint to the server, how much time to keep the connection alive. Not
+         * all the servers respect it though (e.g. nginx and express do not). */
+        timeout: number;
+        /** How many requests are allowed to be processed in one connection. */
+        max: number;
+        /** How many sockets at maximum will be kept open. */
+        maxSockets?: number;
+    };
+    /** When resolving DNS, use IPv4, IPv6 or both (see dns.lookup() docs). */
+    family: 4 | 6 | 0;
+    /** Max timeout to wait for a response. */
+    timeoutMs: number;
+    /** Logger to be used for each responses (including retried) plus for backoff
+     * delay events logging. */
+    logger: (event: RestLogEvent) => void;
+    /** Middlewares to wrap requests. May alter both request and response. */
+    middlewares: Middleware[];
+    /** If set, makes decision whether the response is successful or not. The
+     * response will either be returned to the client, or an error will be thrown.
+     * This allows to treat some non-successful HTTP statuses as success if the
+     * remote API is that weird. Return values:
+     * * "SUCCESS" - the request will be considered successful, no further checks
+     *   will be performed;
+     * * "BEST_EFFORT" - inconclusive, the request may be either successful or
+     *   unsuccessful, additional tests (e.g. will check HTTP status code) will be
+     *   performed;
+     * * "THROW" - the request resulted in error. Additional tests will be
+     *   performed to determine is the error is retriable, is OAuth token good,
+     *   and etc.
+     */
+    isSuccessResponse: (res: RestResponse) => "SUCCESS" | "THROW" | "BEST_EFFORT";
+    /** Decides whether the response is a rate-limit error or not. Returning
+     * non-zero value is treated as retry delay (if retries are set up). In case
+     * the returned value is "SOMETHING_ELSE", the response ought to be either
+     * success or some other error. Returning "BEST_EFFORT" turns on built-in
+     * heuristic (e.g. relying on HTTP status code and Retry-After header). In
+     * case we've made a decision that it's a rate limited error, the request is
+     * always retried; this covers a very common case when we have both
+     * isRateLimitError and isRetriableError handlers set up, and they return
+     * contradictory information; then isRateLimitError wins. */
+    isRateLimitError: (res: RestResponse) => "SOMETHING_ELSE" | "RATE_LIMIT" | "BEST_EFFORT" | number;
+    /** Decides whether the response is a token-invalid error or not. In case it's
+     * not, the response ought to be either success or some other error. */
+    isTokenInvalidError: (res: RestResponse) => boolean;
+    /** Called only if we haven't decided earlier that it's a rate limit error.
+     * Decides whether the response is a retriable error or not. In case the
+     * returned value is "NEVER_RETRY", the response ought to be either success or
+     * some other error, but it's guaranteed that the request won't be retried.
+     * Returning "BEST_EFFORT" turns on built-in heuristics (e.g. never retry "not
+     * found" errors). Returning a number is treated as "RETRY", and the next
+     * retry will happen in not less than this number of milliseconds. */
+    isRetriableError: (res: RestResponse, _error: any) => "NEVER_RETRY" | "RETRY" | "BEST_EFFORT" | number;
+}
+/** @ignore */
+export declare const DEFAULT_OPTIONS: RestOptions;
+export {};
+//# sourceMappingURL=RestOptions.d.ts.map

package/dist/RestOptions.d.ts.map

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

package/dist/RestOptions.js

@@ -0,0 +1,63 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPTIONS = exports.Agents = void 0;
+const http_1 = require("http");
+const https_1 = require("https");
+const delay_1 = __importDefault(require("delay"));
+const fast_typescript_memoize_1 = require("fast-typescript-memoize");
+/**
+ * @ignore
+ * An internal class which keeps the list of HttpAgent instances used in a
+ * particular RestClient instance.
+ */
+class Agents {
+    http(options) {
+        return new http_1.Agent(options);
+    }
+    https(options) {
+        return new https_1.Agent(options);
+    }
+}
+exports.Agents = Agents;
+__decorate([
+    (0, fast_typescript_memoize_1.Memoize)((...args) => JSON.stringify(args))
+], Agents.prototype, "http", null);
+__decorate([
+    (0, fast_typescript_memoize_1.Memoize)((...args) => JSON.stringify(args))
+], Agents.prototype, "https", null);
+/** @ignore */
+exports.DEFAULT_OPTIONS = {
+    retries: 0,
+    retryDelayFirstMs: 1000,
+    retryDelayFactor: 2,
+    retryDelayJitter: 0.1,
+    retryDelayMaxMs: Number.MAX_SAFE_INTEGER,
+    heartbeater: {
+        heartbeat: async () => { },
+        delay: delay_1.default,
+    },
+    throwIfResIsBigger: undefined,
+    privateDataInResponse: false,
+    allowInternalIPs: false,
+    isDebug: false,
+    agents: new Agents(),
+    keepAlive: { timeout: 10, max: 100 },
+    family: 4,
+    timeoutMs: 4 * 60 * 1000,
+    logger: () => { },
+    middlewares: [],
+    isSuccessResponse: () => "BEST_EFFORT",
+    isRateLimitError: () => "BEST_EFFORT",
+    isTokenInvalidError: () => false,
+    isRetriableError: () => "BEST_EFFORT",
+};
+//# sourceMappingURL=RestOptions.js.map

package/dist/RestOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestOptions.js","sourceRoot":"","sources":["../src/RestOptions.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+BAA0C;AAC1C,iCAA4C;AAC5C,kDAA0B;AAC1B,qEAAkD;AAyClD;;;;GAIG;AACH,MAAa,MAAM;IAEjB,IAAI,CAAC,OAAqB;QACxB,OAAO,IAAI,YAAS,CAAC,OAAO,CAAC,CAAC;IAChC,CAAC;IAGD,KAAK,CAAC,OAAqB;QACzB,OAAO,IAAI,aAAU,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;CACF;AAVD,wBAUC;AARC;IADC,IAAA,iCAAO,EAAC,CAAC,GAAG,IAAW,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;kCAGjD;AAGD;IADC,IAAA,iCAAO,EAAC,CAAC,GAAG,IAAW,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;mCAGjD;AAwGH,cAAc;AACD,QAAA,eAAe,GAAgB;IAC1C,OAAO,EAAE,CAAC;IACV,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,CAAC;IACnB,gBAAgB,EAAE,GAAG;IACrB,eAAe,EAAE,MAAM,CAAC,gBAAgB;IACxC,WAAW,EAAE;QACX,SAAS,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;QACzB,KAAK,EAAL,eAAK;KACN;IACD,kBAAkB,EAAE,SAAS;IAC7B,qBAAqB,EAAE,KAAK;IAC5B,gBAAgB,EAAE,KAAK;IACvB,OAAO,EAAE,KAAK;IACd,MAAM,EAAE,IAAI,MAAM,EAAE;IACpB,SAAS,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE;IACpC,MAAM,EAAE,CAAC;IACT,SAAS,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;IACxB,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;IAChB,WAAW,EAAE,EAAE;IACf,iBAAiB,EAAE,GAAG,EAAE,CAAC,aAAa;IACtC,gBAAgB,EAAE,GAAG,EAAE,CAAC,aAAa;IACrC,mBAAmB,EAAE,GAAG,EAAE,CAAC,KAAK;IAChC,gBAAgB,EAAE,GAAG,EAAE,CAAC,aAAa;CACtC,CAAC"}

package/dist/RestRequest.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Headers } from "node-fetch";
+import type RestOptions from "./RestOptions";
+import RestResponse from "./RestResponse";
+import RestStream from "./RestStream";
+/**
+ * Type TAssertShape allows to limit json()'s assert callbacks to only those
+ * which return an object compatible with TAssertShape.
+ */
+export default class RestRequest<TAssertShape = any> {
+    readonly method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    url: string;
+    readonly headers: Headers;
+    readonly body: string | Buffer | NodeJS.ReadableStream;
+    readonly shape?: string | undefined;
+    readonly options: RestOptions;
+    constructor(options: RestOptions, method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, headers: Headers, body: string | Buffer | NodeJS.ReadableStream, shape?: string | undefined);
+    /**
+     * Modifies the request by adding a custom HTTP header.
+     */
+    setHeader(name: string, value: string): this;
+    /**
+     * Modifies the request by adding a custom request option.
+     */
+    setOptions(options: Partial<RestOptions>): this;
+    /**
+     * Forces RestClient to debug-output the request and response to console.
+     * Never use in production.
+     */
+    setDebug(flag?: boolean): this;
+    /**
+     * Sends the request and reads the response a JSON. In absolute most of the
+     * cases, this method is used to reach API responses. The assert callback
+     * (typically generated by typescript-is) is intentionally made mandatory to
+     * not let people to do anti-patterns.
+     */
+    json<TJson extends TAssertShape>(assert: ((obj: any) => TJson) | {
+        mask(obj: any): TJson;
+    } | {
+        $assert(obj: any): TJson;
+    }, ...checkers: Array<(json: TJson, res: RestResponse) => false | Error>): Promise<TJson>;
+    /**
+     * Sends the request and returns plaintext response.
+     */
+    text(): Promise<string>;
+    /**
+     * Returns the entire RestResponse object with response status and headers
+     * information in it. Try to minimize usage of this method, because it doesn't
+     * make any assumptions on the response structure.
+     */
+    response(): Promise<RestResponse>;
+    /**
+     * Sends the requests and returns RestStream object. You MUST iterate over
+     * this object entirely (or call its return() method), otherwise the
+     * connection will remain dangling.
+     */
+    stream(preloadChars?: number): Promise<RestStream>;
+    /**
+     * We can actually only create RequestInit. We can't create an instance of
+     * node-fetch.Request object since it doesn't allow injection of
+     * AbortController later, and we don't want to deal with AbortController here.
+     */
+    private _createFetchRequest;
+    /**
+     * Creates an instance of RestFetchReader.
+     */
+    private _createFetchReader;
+    /**
+     * Creates a RestResponse from a RestFetchReader. Assumes that
+     * RestFetchReader.preload() has already been called.
+     */
+    private _createRestResponse;
+    /**
+     * Logs a response event, an error event or a backoff event. If RestResponse
+     * is not yet known (e.g. an exception happened in a DNS resolution), res must
+     * be passed as null.
+     */
+    private _logResponse;
+}
+//# sourceMappingURL=RestRequest.d.ts.map

package/dist/RestRequest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestRequest.d.ts","sourceRoot":"","sources":["../src/RestRequest.ts"],"names":[],"mappings":";;AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AASrC,OAAO,KAAK,WAAW,MAAM,eAAe,CAAC;AAE7C,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAC1C,OAAO,UAAU,MAAM,cAAc,CAAC;AAItC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW,CAAC,YAAY,GAAG,GAAG;aAK/B,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ;IAC5D,GAAG,EAAE,MAAM;aACF,OAAO,EAAE,OAAO;aAChB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,cAAc;aAC7C,KAAK,CAAC;IARxB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;gBAG5B,OAAO,EAAE,WAAW,EACJ,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,EAC5D,GAAG,EAAE,MAAM,EACF,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,cAAc,EAC7C,KAAK,CAAC,oBAAQ;IAKhC;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAKrC;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC;IAQxC;;;OAGG;IACH,QAAQ,CAAC,IAAI,UAAO;IAKpB;;;;;OAKG;IACG,IAAI,CAAC,KAAK,SAAS,YAAY,EACnC,MAAM,EACF,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,KAAK,CAAC,GACrB;QAAE,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,KAAK,CAAA;KAAE,GACzB;QAAE,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,KAAK,CAAA;KAAE,EAChC,GAAG,QAAQ,EAAE,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,YAAY,KAAK,KAAK,GAAG,KAAK,CAAC,GACpE,OAAO,CAAC,KAAK,CAAC;IAuBjB;;OAEG;IACG,IAAI;IAKV;;;;OAIG;IAEG,QAAQ,IAAI,OAAO,CAAC,YAAY,CAAC;IAWvC;;;;OAIG;IACG,MAAM,CAAC,YAAY,SAAa,GAAG,OAAO,CAAC,UAAU,CAAC;IAwH5D;;;;OAIG;YACW,mBAAmB;IAyEjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAwB1B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAgDrB"}

package/dist/RestRequest.js

@@ -0,0 +1,367 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dns_1 = __importDefault(require("dns"));
+const util_1 = require("util");
+const fast_typescript_memoize_1 = require("fast-typescript-memoize");
+const ipaddr_js_1 = require("ipaddr.js");
+const random_1 = __importDefault(require("lodash/random"));
+const node_fetch_1 = require("node-fetch");
+const RestContentSizeOverLimitError_1 = __importDefault(require("./errors/RestContentSizeOverLimitError"));
+const RestError_1 = __importDefault(require("./errors/RestError"));
+const RestTimeoutError_1 = __importDefault(require("./errors/RestTimeoutError"));
+const calcRetryDelay_1 = __importDefault(require("./internal/calcRetryDelay"));
+const inspectPossibleJSON_1 = __importDefault(require("./internal/inspectPossibleJSON"));
+const RestFetchReader_1 = __importDefault(require("./internal/RestFetchReader"));
+const throwIfErrorResponse_1 = __importDefault(require("./internal/throwIfErrorResponse"));
+const toFloatMs_1 = __importDefault(require("./internal/toFloatMs"));
+const RestResponse_1 = __importDefault(require("./RestResponse"));
+const RestStream_1 = __importDefault(require("./RestStream"));
+const MAX_DEBUG_LEN = 1024 * 100;
+/**
+ * Type TAssertShape allows to limit json()'s assert callbacks to only those
+ * which return an object compatible with TAssertShape.
+ */
+class RestRequest {
+    constructor(options, method, url, headers, body, shape) {
+        this.method = method;
+        this.url = url;
+        this.headers = headers;
+        this.body = body;
+        this.shape = shape;
+        this.options = { ...options };
+    }
+    /**
+     * Modifies the request by adding a custom HTTP header.
+     */
+    setHeader(name, value) {
+        this.headers.append(name, value);
+        return this;
+    }
+    /**
+     * Modifies the request by adding a custom request option.
+     */
+    setOptions(options) {
+        for (const [k, v] of Object.entries(options)) {
+            this.options[k] = v;
+        }
+        return this;
+    }
+    /**
+     * Forces RestClient to debug-output the request and response to console.
+     * Never use in production.
+     */
+    setDebug(flag = true) {
+        this.options.isDebug = flag;
+        return this;
+    }
+    /**
+     * Sends the request and reads the response a JSON. In absolute most of the
+     * cases, this method is used to reach API responses. The assert callback
+     * (typically generated by typescript-is) is intentionally made mandatory to
+     * not let people to do anti-patterns.
+     */
+    async json(assert, ...checkers) {
+        const res = await this.response();
+        // Support Superstruct in a duck-typing way.
+        if (typeof assert !== "function") {
+            if ("mask" in assert) {
+                assert = assert.mask.bind(assert);
+            }
+            else if ("$assert" in assert) {
+                assert = assert.$assert.bind(assert);
+            }
+        }
+        const json = assert(res.json);
+        for (const checker of checkers) {
+            const error = checker(json, res);
+            if (error !== false) {
+                throw error;
+            }
+        }
+        return json;
+    }
+    /**
+     * Sends the request and returns plaintext response.
+     */
+    async text() {
+        const res = await this.response();
+        return res.text;
+    }
+    /**
+     * Returns the entire RestResponse object with response status and headers
+     * information in it. Try to minimize usage of this method, because it doesn't
+     * make any assumptions on the response structure.
+     */
+    async response() {
+        const stream = await this.stream(
+        // By passing Number.MAX_SAFE_INTEGER to stream(), we ensure that the
+        // entire data will be preloaded, or the loading will fail due to
+        // throwIfResIsBigger limitation, whichever will happen faster.
+        Number.MAX_SAFE_INTEGER);
+        await stream.close();
+        return stream.res;
+    }
+    /**
+     * Sends the requests and returns RestStream object. You MUST iterate over
+     * this object entirely (or call its return() method), otherwise the
+     * connection will remain dangling.
+     */
+    async stream(preloadChars = 128 * 1024) {
+        const finalAttempt = Math.max(this.options.retries + 1, 1);
+        let retryDelayMs = Math.max(this.options.retryDelayFirstMs, 10);
+        for (let attempt = 1; attempt <= finalAttempt; attempt++) {
+            let timeStart = process.hrtime();
+            let res = null;
+            try {
+                // Middlewares work with RestResponse (can alter it) and not with
+                // RestStream intentionally. So the goal here is to create a
+                // RestResponse object, and then later derive a RestStream from it.
+                let reader = null;
+                res = await runMiddlewares(this, this.options.middlewares, async (req) => {
+                    var _a;
+                    reader = null;
+                    try {
+                        timeStart = process.hrtime();
+                        res = null;
+                        try {
+                            const fetchReq = await req._createFetchRequest();
+                            reader = req._createFetchReader(fetchReq);
+                            await reader.preload(preloadChars);
+                        }
+                        finally {
+                            res =
+                                (_a = req._createRestResponse(reader)) !== null && _a !== void 0 ? _a : new RestResponse_1.default(req, 0, new node_fetch_1.Headers(), "", false);
+                        }
+                        (0, throwIfErrorResponse_1.default)(req.options, res);
+                        req._logResponse({
+                            attempt,
+                            req,
+                            res,
+                            exception: null,
+                            timestamp: Date.now(),
+                            elapsed: (0, toFloatMs_1.default)(process.hrtime(timeStart)),
+                            isFinalAttempt: attempt === finalAttempt,
+                            privateDataInResponse: req.options.privateDataInResponse,
+                            comment: "",
+                        });
+                        return res;
+                    }
+                    catch (e) {
+                        await (reader === null || reader === void 0 ? void 0 : reader.close());
+                        throw e;
+                    }
+                });
+                // The only place where we return the response. Otherwise we retry or
+                // throw an exception.
+                return new RestStream_1.default(res, reader);
+            }
+            catch (error) {
+                this._logResponse({
+                    attempt,
+                    req: this,
+                    res,
+                    exception: error,
+                    timestamp: Date.now(),
+                    elapsed: (0, toFloatMs_1.default)(process.hrtime(timeStart)),
+                    isFinalAttempt: attempt === finalAttempt,
+                    privateDataInResponse: this.options.privateDataInResponse,
+                    comment: "",
+                });
+                if (res === null) {
+                    // An error in internal function or middleware; this must not happen.
+                    throw error;
+                }
+                if (attempt === finalAttempt) {
+                    // Last retry attempt; always throw.
+                    throw error;
+                }
+                const newRetryDelay = (0, calcRetryDelay_1.default)(error, this.options, res, retryDelayMs);
+                if (newRetryDelay === "no_retry") {
+                    throw error;
+                }
+                retryDelayMs = newRetryDelay;
+            }
+            const delayStart = process.hrtime();
+            retryDelayMs *= (0, random_1.default)(1 - this.options.retryDelayJitter, 1 + this.options.retryDelayJitter, true);
+            await this.options.heartbeater.delay(retryDelayMs);
+            this._logResponse({
+                attempt,
+                req: this,
+                res: "backoff_delay",
+                exception: null,
+                timestamp: Date.now(),
+                elapsed: (0, toFloatMs_1.default)(process.hrtime(delayStart)),
+                isFinalAttempt: false,
+                privateDataInResponse: this.options.privateDataInResponse,
+                comment: "",
+            });
+            retryDelayMs *= this.options.retryDelayFactor;
+            retryDelayMs = Math.min(this.options.retryDelayMaxMs, retryDelayMs);
+        }
+        throw Error("BUG: should never happen");
+    }
+    /**
+     * We can actually only create RequestInit. We can't create an instance of
+     * node-fetch.Request object since it doesn't allow injection of
+     * AbortController later, and we don't want to deal with AbortController here.
+     */
+    async _createFetchRequest() {
+        var _a;
+        const url = new URL(this.url);
+        if (!["http:", "https:"].includes(url.protocol)) {
+            throw new RestError_1.default(`Unsupported protocol: ${url.protocol}`);
+        }
+        // TODO: rework DNS resolution to use a custom Agent. We'd be able to
+        // support safe redirects then.
+        // Resolve IP address, check it for being a public IP address and substitute
+        // it in the URL; the hostname will be passed separately via Host header.
+        const hostname = url.hostname;
+        const headers = new node_fetch_1.Headers(this.headers);
+        const addr = await (0, util_1.promisify)(dns_1.default.lookup)(hostname, {
+            family: this.options.family,
+        });
+        let redirectMode = "follow";
+        if (!this.options.allowInternalIPs) {
+            const range = (0, ipaddr_js_1.parse)(addr.address).range();
+            // External requests are returned as "unicast" by ipaddr.js.
+            const isInternal = range !== "unicast";
+            if (isInternal) {
+                throw new RestError_1.default(`Domain ${hostname} resolves to a non-public (${range}) IP address ${addr.address}`);
+            }
+            url.hostname = addr.address;
+            if (!headers.get("host")) {
+                headers.set("host", hostname);
+            }
+            // ATTENTION: don't turn on redirects, it's a security breach when using
+            // with allowInternalIPs=false which is default!
+            redirectMode = "error";
+        }
+        const hasKeepAlive = this.options.keepAlive.timeout > 0;
+        if (hasKeepAlive) {
+            headers.append("connection", "Keep-Alive");
+            headers.append("keep-alive", "timeout=" +
+                this.options.keepAlive.timeout +
+                ", max=" +
+                this.options.keepAlive.max);
+        }
+        // Use lazily created/cached per-RestClient Agent instance to utilize HTTP
+        // persistent connections and save on HTTPS connection re-establishment.
+        const agent = (url.protocol === "https:"
+            ? this.options.agents.https.bind(this.options.agents)
+            : this.options.agents.http.bind(this.options.agents))({
+            keepAlive: hasKeepAlive,
+            maxSockets: (_a = this.options.keepAlive) === null || _a === void 0 ? void 0 : _a.maxSockets,
+            rejectUnauthorized: this.options.allowInternalIPs ? false : undefined,
+            family: this.options.family,
+        });
+        return {
+            url: url.toString(),
+            method: this.method,
+            headers,
+            body: this.body || undefined,
+            timeout: this.options.timeoutMs,
+            redirect: redirectMode,
+            agent,
+        };
+    }
+    /**
+     * Creates an instance of RestFetchReader.
+     */
+    _createFetchReader(req) {
+        return new RestFetchReader_1.default(req.url, req, {
+            timeoutMs: this.options.timeoutMs,
+            heartbeat: async () => this.options.heartbeater.heartbeat(),
+            onTimeout: (reader) => {
+                throw new RestTimeoutError_1.default(`Timed out while reading response body (${this.options.timeoutMs} ms)`, this._createRestResponse(reader));
+            },
+            onAfterRead: (reader) => {
+                if (this.options.throwIfResIsBigger &&
+                    reader.charsRead > this.options.throwIfResIsBigger) {
+                    throw new RestContentSizeOverLimitError_1.default(`Content size is over limit of ${this.options.throwIfResIsBigger} characters`, this._createRestResponse(reader));
+                }
+            },
+        });
+    }
+    /**
+     * Creates a RestResponse from a RestFetchReader. Assumes that
+     * RestFetchReader.preload() has already been called.
+     */
+    _createRestResponse(reader) {
+        return reader
+            ? new RestResponse_1.default(this, reader.status, reader.headers, reader.textFetched, reader.textIsPartial)
+            : null;
+    }
+    /**
+     * Logs a response event, an error event or a backoff event. If RestResponse
+     * is not yet known (e.g. an exception happened in a DNS resolution), res must
+     * be passed as null.
+     */
+    _logResponse(event) {
+        this.options.logger(event);
+        // Debug-logging to console?
+        if (this.options.isDebug ||
+            (process.env["NODE_ENV"] === "development" &&
+                event.res === "backoff_delay")) {
+            let reqMessage = `${this.method} ${this.url}\n` +
+                Object.entries(this.headers.raw())
+                    .map(([k, vs]) => vs.map((v) => `${k}: ${v}`))
+                    .join("\n");
+            if (this.body) {
+                reqMessage +=
+                    "\n" + (0, inspectPossibleJSON_1.default)(this.headers, this.body, MAX_DEBUG_LEN);
+            }
+            let resMessage = "";
+            if (event.res === "backoff_delay") {
+                resMessage =
+                    "Previous request failed, backoff delay elapsed, retrying attempt " +
+                        (event.attempt + 1) +
+                        "...";
+            }
+            else if (event.res) {
+                resMessage =
+                    `HTTP ${event.res.status} ` +
+                        `(took ${Math.round(event.elapsed)} ms)`;
+                if (event.res.text) {
+                    resMessage +=
+                        "\n" +
+                            (0, inspectPossibleJSON_1.default)(event.res.headers, event.res.text, MAX_DEBUG_LEN);
+                }
+            }
+            else if (event.exception) {
+                resMessage = "" + event.exception;
+            }
+            // eslint-disable-next-line no-console
+            console.log(reqMessage.replace(/^/gm, "+++ "));
+            // eslint-disable-next-line no-console
+            console.log(resMessage.replace(/^/gm, "=== ") + "\n");
+        }
+    }
+}
+exports.default = RestRequest;
+__decorate([
+    (0, fast_typescript_memoize_1.Memoize)()
+], RestRequest.prototype, "response", null);
+/**
+ * Runs the middlewares chain of responsibility. Each middleware receives a
+ * mutable RestRequest object and next() callback which, when called, triggers
+ * execution of the remaining middlewares in the chain. This allows a middleware
+ * to not only modify the request object, but also alter the response received
+ * from the subsequent middlewares.
+ */
+async function runMiddlewares(req, middlewares, last) {
+    if (middlewares.length > 0) {
+        const [head, ...tail] = middlewares;
+        return head(req, async (req) => runMiddlewares(req, tail, last));
+    }
+    return last(req);
+}
+//# sourceMappingURL=RestRequest.js.map