@clickup/rest-client 2.10.292

package/dist/internal/RestFetchReader.d.ts

@@ -0,0 +1,72 @@
+import type { RequestInit } from "node-fetch";
+import { Headers } from "node-fetch";
+export interface RestFetchReaderOptions {
+    timeoutMs?: number;
+    heartbeat?: () => Promise<void>;
+    onTimeout?: (reader: RestFetchReader, e: any) => void;
+    onAfterRead?: (reader: RestFetchReader) => void;
+}
+/**
+ * A low-level stateful reader engine on top of node-fetch which implements
+ * "preload first N chars and then leave the rest ready for iteration" pattern,
+ * with global timeout for the entire fetching time.
+ *
+ * Once created, the object MUST be iterated in full to consume the rest of the
+ * stream and close the connection. In case you're not interested in its entire
+ * content, you must prematurely "return" (close) the iterator.
+ *
+ * The abstraction is intentionally kept independent on all others, to make it
+ * simple and testable separately.
+ */
+export default class RestFetchReader {
+    private _url;
+    private _req;
+    private _options;
+    private _status;
+    private _headers;
+    private _textFetched;
+    private _textIsPartial;
+    private _charsRead;
+    constructor(_url: string, _req: RequestInit, _options: RestFetchReaderOptions);
+    /**
+     * Returns the number of characters read from the stream so far.
+     */
+    get charsRead(): number;
+    /**
+     * Returns HTTP status after preload() was called.
+     */
+    get status(): number;
+    /**
+     * Returns HTTP headers after preload() was called.
+     */
+    get headers(): Headers;
+    /**
+     * Returns the data preloaded so far.
+     */
+    get textFetched(): string;
+    /**
+     * If true, then there is a chance that reading more from the stream will
+     * return more data.
+     */
+    get textIsPartial(): boolean;
+    /**
+     * Reads preloadChars chars or a little bit more from the response and puts
+     * them to this.textFetched. Leaves the rest of the data in res.body for
+     * future reads if there are more data to fetch (you must consume them or
+     * close the stream, otherwise the connection will remain open).
+     */
+    preload(preloadChars: number): Promise<void>;
+    /**
+     * Closes the connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns an async generator for the rest of the data. Must be consumed
+     * entirely, otherwise the connection may remain dangling.
+     *
+     * Memoization is important here, to return the same generator when we call
+     * this method multiple times and to not start a new iteration over and over.
+     */
+    [Symbol.asyncIterator](): AsyncGenerator<string, void, unknown>;
+}
+//# sourceMappingURL=RestFetchReader.d.ts.map

package/dist/internal/RestFetchReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestFetchReader.d.ts","sourceRoot":"","sources":["../../src/internal/RestFetchReader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAc,EAAE,OAAO,EAAW,MAAM,YAAY,CAAC;AAErD,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAChC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IACtD,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CACjD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe;IAQhC,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,QAAQ;IATlB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,UAAU,CAAK;gBAGb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,sBAAsB;IAG1C;;OAEG;IACH,IAAI,SAAS,WAEZ;IAED;;OAEG;IACH,IAAI,MAAM,WAET;IAED;;OAEG;IACH,IAAI,OAAO,YAEV;IAED;;OAEG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;OAGG;IACH,IAAI,aAAa,YAEhB;IAED;;;;;OAKG;IACG,OAAO,CAAC,YAAY,EAAE,MAAM;IAmBlC;;OAEG;IACG,KAAK;IAIX;;;;;;OAMG;IAEI,CAAC,MAAM,CAAC,aAAa,CAAC;CA8D9B"}

package/dist/internal/RestFetchReader.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const abort_controller_1 = __importDefault(require("abort-controller"));
+const fast_typescript_memoize_1 = require("fast-typescript-memoize");
+const node_fetch_1 = __importStar(require("node-fetch"));
+/**
+ * A low-level stateful reader engine on top of node-fetch which implements
+ * "preload first N chars and then leave the rest ready for iteration" pattern,
+ * with global timeout for the entire fetching time.
+ *
+ * Once created, the object MUST be iterated in full to consume the rest of the
+ * stream and close the connection. In case you're not interested in its entire
+ * content, you must prematurely "return" (close) the iterator.
+ *
+ * The abstraction is intentionally kept independent on all others, to make it
+ * simple and testable separately.
+ */
+class RestFetchReader {
+    constructor(_url, _req, _options) {
+        this._url = _url;
+        this._req = _req;
+        this._options = _options;
+        this._status = 0;
+        this._headers = new node_fetch_1.Headers();
+        this._textFetched = "";
+        this._textIsPartial = true;
+        this._charsRead = 0;
+    }
+    /**
+     * Returns the number of characters read from the stream so far.
+     */
+    get charsRead() {
+        return this._charsRead;
+    }
+    /**
+     * Returns HTTP status after preload() was called.
+     */
+    get status() {
+        return this._status;
+    }
+    /**
+     * Returns HTTP headers after preload() was called.
+     */
+    get headers() {
+        return this._headers;
+    }
+    /**
+     * Returns the data preloaded so far.
+     */
+    get textFetched() {
+        return this._textFetched;
+    }
+    /**
+     * If true, then there is a chance that reading more from the stream will
+     * return more data.
+     */
+    get textIsPartial() {
+        return this._textIsPartial;
+    }
+    /**
+     * Reads preloadChars chars or a little bit more from the response and puts
+     * them to this.textFetched. Leaves the rest of the data in res.body for
+     * future reads if there are more data to fetch (you must consume them or
+     * close the stream, otherwise the connection will remain open).
+     */
+    async preload(preloadChars) {
+        const generator = this[Symbol.asyncIterator]();
+        try {
+            while (this._charsRead < preloadChars) {
+                const { value, done } = await generator.next();
+                if (done) {
+                    this._textIsPartial = false;
+                    await generator.return();
+                    return;
+                }
+                this._textFetched += value;
+            }
+        }
+        catch (e) {
+            await generator.return();
+            throw e;
+        }
+    }
+    /**
+     * Closes the connection.
+     */
+    async close() {
+        await this[Symbol.asyncIterator]().return();
+    }
+    /**
+     * Returns an async generator for the rest of the data. Must be consumed
+     * entirely, otherwise the connection may remain dangling.
+     *
+     * Memoization is important here, to return the same generator when we call
+     * this method multiple times and to not start a new iteration over and over.
+     */
+    async *[_a = Symbol.asyncIterator]() {
+        var _b, _c, _d, _e;
+        const { timeoutMs, onTimeout, onAfterRead } = this._options;
+        // Some of react-client users are still on v14 node.
+        const controller = typeof AbortController === "undefined"
+            ? new abort_controller_1.default()
+            : new AbortController();
+        const timeout = timeoutMs
+            ? setTimeout(() => controller.abort(), timeoutMs)
+            : undefined;
+        try {
+            // DO NOT use fetch(fetchReq) with one argument! It clones the stream
+            // which just doesn't work in practice, even with file streams. I wasted
+            // 4h on debugging this: fetch(fetchReq.url, fetchReq) works and
+            // fetch(fetchReq) doesn't for e.g. Dropbox API and
+            // https://stackoverflow.com/a/44577569
+            const res = await (0, node_fetch_1.default)(this._url, new node_fetch_1.Request(this._url, {
+                ...this._req,
+                signal: controller.signal,
+            }));
+            this._status = res.status;
+            this._headers = res.headers;
+            // An opinionated choice is made here to always decode the response stream
+            // as UTF-8. This is because JSON is by definition a UTF-8 stream. In the
+            // future, when we need binary streams, we can tweak it by introducing
+            // some intermediate layer and doing some refactoring, but for now it's an
+            // overkill. See also
+            // https://nodejs.org/api/stream.html#readablesetencodingencoding on how
+            // Node streams handle decoding when the returned chunks cross the
+            // boundaries of multi-byte characters.
+            res.body.setEncoding("utf-8");
+            await ((_c = (_b = this._options).heartbeat) === null || _c === void 0 ? void 0 : _c.call(_b));
+            for await (const chunk of res.body) {
+                await ((_e = (_d = this._options).heartbeat) === null || _e === void 0 ? void 0 : _e.call(_d));
+                this._charsRead += chunk.length;
+                yield chunk;
+                onAfterRead === null || onAfterRead === void 0 ? void 0 : onAfterRead(this);
+            }
+        }
+        catch (e) {
+            if (controller.signal.aborted && onTimeout) {
+                onTimeout(this, e);
+            }
+            else {
+                throw e;
+            }
+        }
+        finally {
+            timeout && clearTimeout(timeout);
+            // If someone stops iterating prematurely, we forcefully close the
+            // connection in all cases. Theoretically, stopping the iteration on
+            // res.body should've closed the connection, but in practice it doesn't
+            // happen; it looks like a bug in node-fetch, and thus, we must always use
+            // the AbortController in the end.
+            controller.abort();
+        }
+    }
+}
+exports.default = RestFetchReader;
+__decorate([
+    (0, fast_typescript_memoize_1.Memoize)()
+], RestFetchReader.prototype, _a, null);
+//# sourceMappingURL=RestFetchReader.js.map

package/dist/internal/RestFetchReader.js.map

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

package/dist/internal/RestRangeUploader.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import type RestClient from "../RestClient";
+/**
+ * Sends a series of Content-Range requests to an URL.
+ * - The stream size is unknown in advance even theoretically. So we read it
+ *   with chunkSize+1 bytes chunks (+1 is to know for sure, is there something
+ *   else left in the stream or not) and then send data with chunkSize bytes
+ *   chunks.
+ * - The last chunk is a terminating one (and we know, which one is the last),
+ *   so we reflect it in "Content-Range: x-y/S" format setting S to the total
+ *   number of bytes in the stream.
+ */
+export default class RestRangeUploader {
+    private _client;
+    private _chunkSize;
+    private _method;
+    private _path;
+    private _mimeType;
+    private _pos;
+    constructor(_client: RestClient, _chunkSize: number, _method: "POST" | "PUT", _path: string, _mimeType: string);
+    upload(stream: AsyncIterable<Buffer>): Promise<string | null>;
+    private _flush;
+}
+//# sourceMappingURL=RestRangeUploader.d.ts.map

package/dist/internal/RestRangeUploader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestRangeUploader.d.ts","sourceRoot":"","sources":["../../src/internal/RestRangeUploader.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAE5C;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IAIlC,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,SAAS;IAPnB,OAAO,CAAC,IAAI,CAAK;gBAGP,OAAO,EAAE,UAAU,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,KAAK,EACvB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM;IAGrB,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC;YAqB5B,MAAM;CAgBrB"}

package/dist/internal/RestRangeUploader.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Sends a series of Content-Range requests to an URL.
+ * - The stream size is unknown in advance even theoretically. So we read it
+ *   with chunkSize+1 bytes chunks (+1 is to know for sure, is there something
+ *   else left in the stream or not) and then send data with chunkSize bytes
+ *   chunks.
+ * - The last chunk is a terminating one (and we know, which one is the last),
+ *   so we reflect it in "Content-Range: x-y/S" format setting S to the total
+ *   number of bytes in the stream.
+ */
+class RestRangeUploader {
+    constructor(_client, _chunkSize, _method, _path, _mimeType) {
+        this._client = _client;
+        this._chunkSize = _chunkSize;
+        this._method = _method;
+        this._path = _path;
+        this._mimeType = _mimeType;
+        this._pos = 0;
+    }
+    async upload(stream) {
+        let buf = Buffer.allocUnsafe(0);
+        let res = null;
+        for await (const readData of stream) {
+            buf = Buffer.concat([buf, readData]);
+            while (buf.length >= this._chunkSize + 1) {
+                res = await this._flush(buf.slice(0, this._chunkSize), false);
+                buf = Buffer.from(buf.slice(this._chunkSize));
+            }
+            // After this `while` loop finishes, there is always something left in buf
+            // (due to the +1 trick). It guarantees that we have a chance to call
+            // flush(..., true) for the very last chunk.
+        }
+        if (buf.length > 0) {
+            res = await this._flush(buf, true);
+        }
+        return res;
+    }
+    async _flush(buf, isLast) {
+        if (buf.length === 0) {
+            return null;
+        }
+        const totalSize = isLast ? this._pos + buf.length : "*";
+        const res = await this._client
+            .writeRaw(this._path, buf, this._mimeType, this._method, "*/*")
+            .setHeader("Content-Range", `bytes ${this._pos}-${this._pos + buf.length - 1}/${totalSize}`)
+            .text();
+        this._pos += buf.length;
+        return res;
+    }
+}
+exports.default = RestRangeUploader;
+//# sourceMappingURL=RestRangeUploader.js.map

package/dist/internal/RestRangeUploader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RestRangeUploader.js","sourceRoot":"","sources":["../../src/internal/RestRangeUploader.ts"],"names":[],"mappings":";;AAEA;;;;;;;;;GASG;AACH,MAAqB,iBAAiB;IAGpC,YACU,OAAmB,EACnB,UAAkB,EAClB,OAAuB,EACvB,KAAa,EACb,SAAiB;QAJjB,YAAO,GAAP,OAAO,CAAY;QACnB,eAAU,GAAV,UAAU,CAAQ;QAClB,YAAO,GAAP,OAAO,CAAgB;QACvB,UAAK,GAAL,KAAK,CAAQ;QACb,cAAS,GAAT,SAAS,CAAQ;QAPnB,SAAI,GAAG,CAAC,CAAC;IAQd,CAAC;IAEJ,KAAK,CAAC,MAAM,CAAC,MAA6B;QACxC,IAAI,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,GAAG,GAAkB,IAAI,CAAC;QAC9B,IAAI,KAAK,EAAE,MAAM,QAAQ,IAAI,MAAM,EAAE;YACnC,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;YACrC,OAAO,GAAG,CAAC,MAAM,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE;gBACxC,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC;gBAC9D,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;aAC/C;YACD,0EAA0E;YAC1E,qEAAqE;YACrE,4CAA4C;SAC7C;QAED,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;YAClB,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;SACpC;QAED,OAAO,GAAG,CAAC;IACb,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,GAAW,EAAE,MAAe;QAC/C,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC,EAAE;YACpB,OAAO,IAAI,CAAC;SACb;QAED,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;QACxD,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,OAAO;aAC3B,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC;aAC9D,SAAS,CACR,eAAe,EACf,SAAS,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,SAAS,EAAE,CAChE;aACA,IAAI,EAAE,CAAC;QACV,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC;QACxB,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAhDD,oCAgDC"}

package/dist/internal/calcRetryDelay.d.ts

@@ -0,0 +1,8 @@
+import type RestOptions from "../RestOptions";
+import type RestResponse from "../RestResponse";
+/**
+ * Returns a new retry delay of the error needs to be retried, otherwise
+ * "no_retry".
+ */
+export default function calcRetryDelay(error: any, options: RestOptions, res: RestResponse, retryDelayMs: number): number | "no_retry";
+//# sourceMappingURL=calcRetryDelay.d.ts.map

package/dist/internal/calcRetryDelay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calcRetryDelay.d.ts","sourceRoot":"","sources":["../../src/internal/calcRetryDelay.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAEhD;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,YAAY,EACjB,YAAY,EAAE,MAAM,GACnB,MAAM,GAAG,UAAU,CA0CrB"}

package/dist/internal/calcRetryDelay.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RestContentSizeOverLimitError_1 = __importDefault(require("../errors/RestContentSizeOverLimitError"));
+const RestRateLimitError_1 = __importDefault(require("../errors/RestRateLimitError"));
+const RestRetriableError_1 = __importDefault(require("../errors/RestRetriableError"));
+const RestTokenInvalidError_1 = __importDefault(require("../errors/RestTokenInvalidError"));
+/**
+ * Returns a new retry delay of the error needs to be retried, otherwise
+ * "no_retry".
+ */
+function calcRetryDelay(error, options, res, retryDelayMs) {
+    if (error instanceof RestRateLimitError_1.default ||
+        error instanceof RestRetriableError_1.default) {
+        // We've already made a decision to retry this error.
+        return Math.min(options.retryDelayMaxMs, Math.max(retryDelayMs, error.delayMs));
+    }
+    switch (options.isRetriableError(res, error)) {
+        case "RETRY":
+        default:
+            break; // number returned
+        case "BEST_EFFORT":
+            if (error instanceof RestTokenInvalidError_1.default) {
+                return "no_retry";
+            }
+            if (!(error instanceof RestRateLimitError_1.default) &&
+                res.status >= 400 &&
+                res.status <= 499) {
+                return "no_retry";
+            }
+            if (error instanceof RestContentSizeOverLimitError_1.default) {
+                // Content size ... over limit.
+                return "no_retry";
+            }
+            break;
+        case "NEVER_RETRY":
+            return "no_retry";
+    }
+    return retryDelayMs;
+}
+exports.default = calcRetryDelay;
+//# sourceMappingURL=calcRetryDelay.js.map

package/dist/internal/calcRetryDelay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calcRetryDelay.js","sourceRoot":"","sources":["../../src/internal/calcRetryDelay.ts"],"names":[],"mappings":";;;;;AAAA,4GAAoF;AACpF,sFAA8D;AAC9D,sFAA8D;AAC9D,4FAAoE;AAIpE;;;GAGG;AACH,SAAwB,cAAc,CACpC,KAAU,EACV,OAAoB,EACpB,GAAiB,EACjB,YAAoB;IAEpB,IACE,KAAK,YAAY,4BAAkB;QACnC,KAAK,YAAY,4BAAkB,EACnC;QACA,qDAAqD;QACrD,OAAO,IAAI,CAAC,GAAG,CACb,OAAO,CAAC,eAAe,EACvB,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,CACtC,CAAC;KACH;IAED,QAAQ,OAAO,CAAC,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE;QAC5C,KAAK,OAAO,CAAC;QACb;YACE,MAAM,CAAC,kBAAkB;QAE3B,KAAK,aAAa;YAChB,IAAI,KAAK,YAAY,+BAAqB,EAAE;gBAC1C,OAAO,UAAU,CAAC;aACnB;YAED,IACE,CAAC,CAAC,KAAK,YAAY,4BAAkB,CAAC;gBACtC,GAAG,CAAC,MAAM,IAAI,GAAG;gBACjB,GAAG,CAAC,MAAM,IAAI,GAAG,EACjB;gBACA,OAAO,UAAU,CAAC;aACnB;YAED,IAAI,KAAK,YAAY,uCAA6B,EAAE;gBAClD,+BAA+B;gBAC/B,OAAO,UAAU,CAAC;aACnB;YAED,MAAM;QAER,KAAK,aAAa;YAChB,OAAO,UAAU,CAAC;KACrB;IAED,OAAO,YAAY,CAAC;AACtB,CAAC;AA/CD,iCA+CC"}

package/dist/internal/inspectPossibleJSON.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export default function inspectPossibleJSON(headers: {
+    get(name: string): string | null;
+}, text: string | Buffer | NodeJS.ReadableStream, maxOutputLen: number): string;
+//# sourceMappingURL=inspectPossibleJSON.d.ts.map

package/dist/internal/inspectPossibleJSON.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectPossibleJSON.d.ts","sourceRoot":"","sources":["../../src/internal/inspectPossibleJSON.ts"],"names":[],"mappings":";;AAIA,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,OAAO,EAAE;IAAE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;CAAE,EAC7C,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC,cAAc,EAC7C,YAAY,EAAE,MAAM,GACnB,MAAM,CAuCR"}

package/dist/internal/inspectPossibleJSON.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const truncate_1 = __importDefault(require("lodash/truncate"));
+function inspectPossibleJSON(headers, text, maxOutputLen) {
+    const MAX_LEN_TO_TRY_PARSE = 1024 * 1024;
+    if (typeof text === "string" && text.length > MAX_LEN_TO_TRY_PARSE) {
+        // Don't even try to JSON-parse if the text is too long.
+        return ellipsis(text, maxOutputLen);
+    }
+    if (text instanceof Buffer) {
+        return `<Buffer: ${text.length} bytes>`;
+    }
+    if (!text || typeof text === "string") {
+        if (!(headers.get("content-type") || "").match(/json/)) {
+            return ellipsis(text, maxOutputLen);
+        }
+        try {
+            const json = JSON.parse(text);
+            if (json && typeof json === "object" && !(json instanceof Array)) {
+                // Move error/errors fields on top for better logging. This is a poor
+                // man's approach: of course not all APIs return error/errors fields at
+                // all, but it's hard to reorder at any other layer of abstraction.
+                reorderObjectProps(json, (k) => k === "error" || k === "errors" ? "" : k);
+            }
+            return ellipsis((0, util_1.inspect)(json, { depth: 20, compact: true }), maxOutputLen);
+        }
+        catch (e) {
+            return ellipsis(text, maxOutputLen);
+        }
+    }
+    return "<Stream>";
+}
+exports.default = inspectPossibleJSON;
+/**
+ * In-place-reorders keys in a given object. The important part is to do it
+ * in-place to e.g. be able to alter some @Memoized values.
+ */
+function reorderObjectProps(obj, ranker) {
+    const entries = Object.entries(obj);
+    for (const k in obj) {
+        delete obj[k];
+    }
+    Object.assign(obj, Object.fromEntries((0, sortBy_1.default)(entries, ([k, v]) => ranker(k, v))));
+}
+function ellipsis(text, length) {
+    return (0, truncate_1.default)("" + text, { length }).trimEnd();
+}
+//# sourceMappingURL=inspectPossibleJSON.js.map

package/dist/internal/inspectPossibleJSON.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectPossibleJSON.js","sourceRoot":"","sources":["../../src/internal/inspectPossibleJSON.ts"],"names":[],"mappings":";;;;;AAAA,+BAA+B;AAC/B,2DAAmC;AACnC,+DAAuC;AAEvC,SAAwB,mBAAmB,CACzC,OAA6C,EAC7C,IAA6C,EAC7C,YAAoB;IAEpB,MAAM,oBAAoB,GAAG,IAAI,GAAG,IAAI,CAAC;IAEzC,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,MAAM,GAAG,oBAAoB,EAAE;QAClE,wDAAwD;QACxD,OAAO,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;KACrC;IAED,IAAI,IAAI,YAAY,MAAM,EAAE;QAC1B,OAAO,YAAY,IAAI,CAAC,MAAM,SAAS,CAAC;KACzC;IAED,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QACrC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;YACtD,OAAO,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SACrC;QAED,IAAI;YACF,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAE9B,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,YAAY,KAAK,CAAC,EAAE;gBAChE,qEAAqE;gBACrE,uEAAuE;gBACvE,mEAAmE;gBACnE,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE,CAC7B,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CACzC,CAAC;aACH;YAED,OAAO,QAAQ,CACb,IAAA,cAAO,EAAC,IAAI,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,EAC3C,YAAY,CACb,CAAC;SACH;QAAC,OAAO,CAAM,EAAE;YACf,OAAO,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;SACrC;KACF;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AA3CD,sCA2CC;AAED;;;GAGG;AACH,SAAS,kBAAkB,CACzB,GAAwB,EACxB,MAA8C;IAE9C,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACpC,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE;QACnB,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;KACf;IAED,MAAM,CAAC,MAAM,CACX,GAAG,EACH,MAAM,CAAC,WAAW,CAAC,IAAA,gBAAM,EAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAC9D,CAAC;AACJ,CAAC;AAED,SAAS,QAAQ,CAAC,IAAS,EAAE,MAAc;IACzC,OAAO,IAAA,kBAAQ,EAAC,EAAE,GAAG,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;AACnD,CAAC"}

package/dist/internal/prependNewlineIfMultiline.d.ts

@@ -0,0 +1,2 @@
+export default function prependNewlineIfMultiline(str: string): string;
+//# sourceMappingURL=prependNewlineIfMultiline.d.ts.map

package/dist/internal/prependNewlineIfMultiline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prependNewlineIfMultiline.d.ts","sourceRoot":"","sources":["../../src/internal/prependNewlineIfMultiline.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAAC,GAAG,EAAE,MAAM,UAE5D"}

package/dist/internal/prependNewlineIfMultiline.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function prependNewlineIfMultiline(str) {
+    return str.trim().includes("\n") ? "\n" + str : str;
+}
+exports.default = prependNewlineIfMultiline;
+//# sourceMappingURL=prependNewlineIfMultiline.js.map

package/dist/internal/prependNewlineIfMultiline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prependNewlineIfMultiline.js","sourceRoot":"","sources":["../../src/internal/prependNewlineIfMultiline.ts"],"names":[],"mappings":";;AAAA,SAAwB,yBAAyB,CAAC,GAAW;IAC3D,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;AACtD,CAAC;AAFD,4CAEC"}

package/dist/internal/substituteParams.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Allows to use URLs like /some/:abc/other and pass { abc: "xyz" } as one of
+ * body parameters. Such body parameters will be excluded from the body before
+ * sending the request (so they're "moved" into the URL).
+ */
+export default function substituteParams<TBody>(url: string, body: TBody): [string, TBody];
+//# sourceMappingURL=substituteParams.d.ts.map

package/dist/internal/substituteParams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"substituteParams.d.ts","sourceRoot":"","sources":["../../src/internal/substituteParams.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,KAAK,EAC5C,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,KAAK,GACV,CAAC,MAAM,EAAE,KAAK,CAAC,CAgBjB"}

package/dist/internal/substituteParams.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Allows to use URLs like /some/:abc/other and pass { abc: "xyz" } as one of
+ * body parameters. Such body parameters will be excluded from the body before
+ * sending the request (so they're "moved" into the URL).
+ */
+function substituteParams(url, body) {
+    if (!body || typeof body !== "object") {
+        return [url, body];
+    }
+    url = url.replace(/:([a-z0-9_]+)/gi, (match, param) => {
+        const value = body[param];
+        if (typeof value === "string" || typeof value === "number") {
+            body = { ...body };
+            delete body[param];
+            return encodeURIComponent(value);
+        }
+        return match;
+    });
+    return [url, body];
+}
+exports.default = substituteParams;
+//# sourceMappingURL=substituteParams.js.map

package/dist/internal/substituteParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"substituteParams.js","sourceRoot":"","sources":["../../src/internal/substituteParams.ts"],"names":[],"mappings":";;AAAA;;;;GAIG;AACH,SAAwB,gBAAgB,CACtC,GAAW,EACX,IAAW;IAEX,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QACrC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;KACpB;IAED,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QACpD,MAAM,KAAK,GAAI,IAAY,CAAC,KAAK,CAAC,CAAC;QACnC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC1D,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,CAAC;YACnB,OAAQ,IAAY,CAAC,KAAK,CAAC,CAAC;YAC5B,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC;SAClC;QAED,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;IACH,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AACrB,CAAC;AAnBD,mCAmBC"}

package/dist/internal/throwIfErrorResponse.d.ts

@@ -0,0 +1,11 @@
+import type RestOptions from "../RestOptions";
+import type RestResponse from "../RestResponse";
+/**
+ * The general idea is that we turn all logical errors into exceptions and then
+ * deal with exceptions only. I.e. throwing an exception becomes an internal API
+ * convention for errors. This is because fetch() throws its own exceptions, and
+ * also there may be some exceptions during validation of the response, or
+ * inside a middleware etc.
+ */
+export default function throwIfErrorResponse(options: RestOptions, res: RestResponse): void;
+//# sourceMappingURL=throwIfErrorResponse.d.ts.map

package/dist/internal/throwIfErrorResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throwIfErrorResponse.d.ts","sourceRoot":"","sources":["../../src/internal/throwIfErrorResponse.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,YAAY,MAAM,iBAAiB,CAAC;AAIhD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,YAAY,QAsElB"}

package/dist/internal/throwIfErrorResponse.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RestRateLimitError_1 = __importDefault(require("../errors/RestRateLimitError"));
+const RestResponseError_1 = __importDefault(require("../errors/RestResponseError"));
+const RestRetriableError_1 = __importDefault(require("../errors/RestRetriableError"));
+const RestTokenInvalidError_1 = __importDefault(require("../errors/RestTokenInvalidError"));
+const STATUS_TOO_MANY_REQUESTS = 429;
+/**
+ * The general idea is that we turn all logical errors into exceptions and then
+ * deal with exceptions only. I.e. throwing an exception becomes an internal API
+ * convention for errors. This is because fetch() throws its own exceptions, and
+ * also there may be some exceptions during validation of the response, or
+ * inside a middleware etc.
+ */
+function throwIfErrorResponse(options, res) {
+    const isSuccessResponse = options.isSuccessResponse(res);
+    if (isSuccessResponse === "SUCCESS") {
+        return;
+    }
+    const rateLimitDelayMs = options.isRateLimitError(res);
+    switch (rateLimitDelayMs) {
+        case "RATE_LIMIT":
+            throw new RestRateLimitError_1.default(`isRateLimitError() returned ${rateLimitDelayMs}`, 0, res);
+        case "BEST_EFFORT":
+            if (res.status === STATUS_TOO_MANY_REQUESTS) {
+                const retryAfterHeader = res.headers.get("Retry-After") || "0";
+                throw new RestRateLimitError_1.default(`Rate limited by HTTP status ${STATUS_TOO_MANY_REQUESTS}`, parseInt(retryAfterHeader) || 0, res);
+            }
+            break;
+        case "SOMETHING_ELSE":
+            break;
+        default:
+            throw new RestRateLimitError_1.default(`isRateLimitError() returned retry delay ${rateLimitDelayMs} ms`, rateLimitDelayMs, res);
+    }
+    const isTokenInvalidError = options.isTokenInvalidError(res);
+    if (isTokenInvalidError) {
+        throw new RestTokenInvalidError_1.default("Invalid app token", res);
+    }
+    const retryDelayMs = options.isRetriableError(res, null);
+    switch (retryDelayMs) {
+        case "RETRY":
+            throw new RestRetriableError_1.default(`isRetriableError() returned ${retryDelayMs}`, 0, res);
+        case "BEST_EFFORT":
+        case "NEVER_RETRY":
+            break;
+        default:
+            throw new RestRetriableError_1.default(`"isRetriableError() returned retry delay ${retryDelayMs} ms`, retryDelayMs, res);
+    }
+    if (isSuccessResponse === "THROW") {
+        throw new RestResponseError_1.default(`isSuccessResponse() returned ${isSuccessResponse}`, res);
+    }
+    if (res.status >= 300) {
+        throw new RestResponseError_1.default("", res);
+    }
+}
+exports.default = throwIfErrorResponse;
+//# sourceMappingURL=throwIfErrorResponse.js.map

package/dist/internal/throwIfErrorResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throwIfErrorResponse.js","sourceRoot":"","sources":["../../src/internal/throwIfErrorResponse.ts"],"names":[],"mappings":";;;;;AAAA,sFAA8D;AAC9D,oFAA4D;AAC5D,sFAA8D;AAC9D,4FAAoE;AAIpE,MAAM,wBAAwB,GAAG,GAAG,CAAC;AAErC;;;;;;GAMG;AACH,SAAwB,oBAAoB,CAC1C,OAAoB,EACpB,GAAiB;IAEjB,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACzD,IAAI,iBAAiB,KAAK,SAAS,EAAE;QACnC,OAAO;KACR;IAED,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACvD,QAAQ,gBAAgB,EAAE;QACxB,KAAK,YAAY;YACf,MAAM,IAAI,4BAAkB,CAC1B,+BAA+B,gBAAgB,EAAE,EACjD,CAAC,EACD,GAAG,CACJ,CAAC;QACJ,KAAK,aAAa;YAChB,IAAI,GAAG,CAAC,MAAM,KAAK,wBAAwB,EAAE;gBAC3C,MAAM,gBAAgB,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC;gBAC/D,MAAM,IAAI,4BAAkB,CAC1B,+BAA+B,wBAAwB,EAAE,EACzD,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAC/B,GAAG,CACJ,CAAC;aACH;YAED,MAAM;QACR,KAAK,gBAAgB;YACnB,MAAM;QACR;YACE,MAAM,IAAI,4BAAkB,CAC1B,2CAA2C,gBAAgB,KAAK,EAChE,gBAAgB,EAChB,GAAG,CACJ,CAAC;KACL;IAED,MAAM,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;IAC7D,IAAI,mBAAmB,EAAE;QACvB,MAAM,IAAI,+BAAqB,CAAC,mBAAmB,EAAE,GAAG,CAAC,CAAC;KAC3D;IAED,MAAM,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;IACzD,QAAQ,YAAY,EAAE;QACpB,KAAK,OAAO;YACV,MAAM,IAAI,4BAAkB,CAC1B,+BAA+B,YAAY,EAAE,EAC7C,CAAC,EACD,GAAG,CACJ,CAAC;QACJ,KAAK,aAAa,CAAC;QACnB,KAAK,aAAa;YAChB,MAAM;QACR;YACE,MAAM,IAAI,4BAAkB,CAC1B,4CAA4C,YAAY,KAAK,EAC7D,YAAY,EACZ,GAAG,CACJ,CAAC;KACL;IAED,IAAI,iBAAiB,KAAK,OAAO,EAAE;QACjC,MAAM,IAAI,2BAAiB,CACzB,gCAAgC,iBAAiB,EAAE,EACnD,GAAG,CACJ,CAAC;KACH;IAED,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,EAAE;QACrB,MAAM,IAAI,2BAAiB,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;KACtC;AACH,CAAC;AAxED,uCAwEC"}