@chainlink/external-adapter-framework 1.7.6 → 2.0.0

package/generator-adapter/node_modules/got/dist/source/as-promise/index.js

@@ -1,158 +0,0 @@
-import { EventEmitter } from 'node:events';
-import is from '@sindresorhus/is';
-import PCancelable from 'p-cancelable';
-import { HTTPError, RetryError, } from '../core/errors.js';
-import Request from '../core/index.js';
-import { parseBody, isResponseOk } from '../core/response.js';
-import proxyEvents from '../core/utils/proxy-events.js';
-import { CancelError } from './types.js';
-const proxiedRequestEvents = [
-    'request',
-    'response',
-    'redirect',
-    'uploadProgress',
-    'downloadProgress',
-];
-export default function asPromise(firstRequest) {
-    let globalRequest;
-    let globalResponse;
-    let normalizedOptions;
-    const emitter = new EventEmitter();
-    const promise = new PCancelable((resolve, reject, onCancel) => {
-        onCancel(() => {
-            globalRequest.destroy();
-        });
-        onCancel.shouldReject = false;
-        onCancel(() => {
-            reject(new CancelError(globalRequest));
-        });
-        const makeRequest = (retryCount) => {
-            // Errors when a new request is made after the promise settles.
-            // Used to detect a race condition.
-            // See https://github.com/sindresorhus/got/issues/1489
-            onCancel(() => { });
-            const request = firstRequest ?? new Request(undefined, undefined, normalizedOptions);
-            request.retryCount = retryCount;
-            request._noPipe = true;
-            globalRequest = request;
-            request.once('response', async (response) => {
-                // Parse body
-                const contentEncoding = (response.headers['content-encoding'] ?? '').toLowerCase();
-                const isCompressed = contentEncoding === 'gzip' || contentEncoding === 'deflate' || contentEncoding === 'br';
-                const { options } = request;
-                if (isCompressed && !options.decompress) {
-                    response.body = response.rawBody;
-                }
-                else {
-                    try {
-                        response.body = parseBody(response, options.responseType, options.parseJson, options.encoding);
-                    }
-                    catch (error) {
-                        // Fall back to `utf8`
-                        response.body = response.rawBody.toString();
-                        if (isResponseOk(response)) {
-                            request._beforeError(error);
-                            return;
-                        }
-                    }
-                }
-                try {
-                    const hooks = options.hooks.afterResponse;
-                    for (const [index, hook] of hooks.entries()) {
-                        // @ts-expect-error TS doesn't notice that CancelableRequest is a Promise
-                        // eslint-disable-next-line no-await-in-loop
-                        response = await hook(response, async (updatedOptions) => {
-                            options.merge(updatedOptions);
-                            options.prefixUrl = '';
-                            if (updatedOptions.url) {
-                                options.url = updatedOptions.url;
-                            }
-                            // Remove any further hooks for that request, because we'll call them anyway.
-                            // The loop continues. We don't want duplicates (asPromise recursion).
-                            options.hooks.afterResponse = options.hooks.afterResponse.slice(0, index);
-                            throw new RetryError(request);
-                        });
-                        if (!(is.object(response) && is.number(response.statusCode) && !is.nullOrUndefined(response.body))) {
-                            throw new TypeError('The `afterResponse` hook returned an invalid value');
-                        }
-                    }
-                }
-                catch (error) {
-                    request._beforeError(error);
-                    return;
-                }
-                globalResponse = response;
-                if (!isResponseOk(response)) {
-                    request._beforeError(new HTTPError(response));
-                    return;
-                }
-                request.destroy();
-                resolve(request.options.resolveBodyOnly ? response.body : response);
-            });
-            const onError = (error) => {
-                if (promise.isCanceled) {
-                    return;
-                }
-                const { options } = request;
-                if (error instanceof HTTPError && !options.throwHttpErrors) {
-                    const { response } = error;
-                    request.destroy();
-                    resolve(request.options.resolveBodyOnly ? response.body : response);
-                    return;
-                }
-                reject(error);
-            };
-            request.once('error', onError);
-            const previousBody = request.options?.body;
-            request.once('retry', (newRetryCount, error) => {
-                firstRequest = undefined;
-                const newBody = request.options.body;
-                if (previousBody === newBody && is.nodeStream(newBody)) {
-                    error.message = 'Cannot retry with consumed body stream';
-                    onError(error);
-                    return;
-                }
-                // This is needed! We need to reuse `request.options` because they can get modified!
-                // For example, by calling `promise.json()`.
-                normalizedOptions = request.options;
-                makeRequest(newRetryCount);
-            });
-            proxyEvents(request, emitter, proxiedRequestEvents);
-            if (is.undefined(firstRequest)) {
-                void request.flush();
-            }
-        };
-        makeRequest(0);
-    });
-    promise.on = (event, fn) => {
-        emitter.on(event, fn);
-        return promise;
-    };
-    promise.off = (event, fn) => {
-        emitter.off(event, fn);
-        return promise;
-    };
-    const shortcut = (responseType) => {
-        const newPromise = (async () => {
-            // Wait until downloading has ended
-            await promise;
-            const { options } = globalResponse.request;
-            return parseBody(globalResponse, responseType, options.parseJson, options.encoding);
-        })();
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        Object.defineProperties(newPromise, Object.getOwnPropertyDescriptors(promise));
-        return newPromise;
-    };
-    promise.json = () => {
-        if (globalRequest.options) {
-            const { headers } = globalRequest.options;
-            if (!globalRequest.writableFinished && !('accept' in headers)) {
-                headers.accept = 'application/json';
-            }
-        }
-        return shortcut('json');
-    };
-    promise.buffer = () => shortcut('buffer');
-    promise.text = () => shortcut('text');
-    return promise;
-}

package/generator-adapter/node_modules/got/dist/source/as-promise/types.d.ts

@@ -1,38 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { Buffer } from 'node:buffer';
-import type PCancelable from 'p-cancelable';
-import { RequestError } from '../core/errors.js';
-import type Request from '../core/index.js';
-import type { RequestEvents } from '../core/index.js';
-import type { Response } from '../core/response.js';
-/**
-An error to be thrown when the request is aborted with `.cancel()`.
-*/
-export declare class CancelError extends RequestError {
-    readonly response: Response;
-    constructor(request: Request);
-    /**
-    Whether the promise is canceled.
-    */
-    get isCanceled(): boolean;
-}
-export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
-    /**
-    A shortcut method that gives a Promise returning a JSON object.
-
-    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'json'`.
-    */
-    json: <ReturnType>() => CancelableRequest<ReturnType>;
-    /**
-    A shortcut method that gives a Promise returning a [Buffer](https://nodejs.org/api/buffer.html).
-
-    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'buffer'`.
-    */
-    buffer: () => CancelableRequest<Buffer>;
-    /**
-    A shortcut method that gives a Promise returning a string.
-
-    It is semantically the same as settings `options.resolveBodyOnly` to `true` and `options.responseType` to `'text'`.
-    */
-    text: () => CancelableRequest<string>;
-}

package/generator-adapter/node_modules/got/dist/source/as-promise/types.js

@@ -1,17 +0,0 @@
-import { RequestError } from '../core/errors.js';
-/**
-An error to be thrown when the request is aborted with `.cancel()`.
-*/
-export class CancelError extends RequestError {
-    constructor(request) {
-        super('Promise was canceled', {}, request);
-        this.name = 'CancelError';
-        this.code = 'ERR_CANCELED';
-    }
-    /**
-    Whether the promise is canceled.
-    */
-    get isCanceled() {
-        return true;
-    }
-}

package/generator-adapter/node_modules/got/dist/source/core/calculate-retry-delay.d.ts

@@ -1,4 +0,0 @@
-import type { RetryFunction } from './options.js';
-type Returns<T extends (...args: any) => unknown, V> = (...args: Parameters<T>) => V;
-declare const calculateRetryDelay: Returns<RetryFunction, number>;
-export default calculateRetryDelay;

package/generator-adapter/node_modules/got/dist/source/core/calculate-retry-delay.js

@@ -1,29 +0,0 @@
-const calculateRetryDelay = ({ attemptCount, retryOptions, error, retryAfter, computedValue, }) => {
-    if (error.name === 'RetryError') {
-        return 1;
-    }
-    if (attemptCount > retryOptions.limit) {
-        return 0;
-    }
-    const hasMethod = retryOptions.methods.includes(error.options.method);
-    const hasErrorCode = retryOptions.errorCodes.includes(error.code);
-    const hasStatusCode = error.response && retryOptions.statusCodes.includes(error.response.statusCode);
-    if (!hasMethod || (!hasErrorCode && !hasStatusCode)) {
-        return 0;
-    }
-    if (error.response) {
-        if (retryAfter) {
-            // In this case `computedValue` is `options.request.timeout`
-            if (retryAfter > computedValue) {
-                return 0;
-            }
-            return retryAfter;
-        }
-        if (error.response.statusCode === 413) {
-            return 0;
-        }
-    }
-    const noise = Math.random() * retryOptions.noise;
-    return Math.min(((2 ** (attemptCount - 1)) * 1000), retryOptions.backoffLimit) + noise;
-};
-export default calculateRetryDelay;

package/generator-adapter/node_modules/got/dist/source/core/errors.d.ts

@@ -1,90 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { Timings } from '@szmarczak/http-timer';
-import type Options from './options.js';
-import type { TimeoutError as TimedOutTimeoutError } from './timed-out.js';
-import type { PlainResponse, Response } from './response.js';
-import type Request from './index.js';
-type Error = NodeJS.ErrnoException;
-/**
-An error to be thrown when a request fails.
-Contains a `code` property with error class code, like `ECONNREFUSED`.
-*/
-export declare class RequestError extends Error {
-    input?: string;
-    code: string;
-    stack: string;
-    readonly options: Options;
-    readonly response?: Response;
-    readonly request?: Request;
-    readonly timings?: Timings;
-    constructor(message: string, error: Partial<Error & {
-        code?: string;
-    }>, self: Request | Options);
-}
-/**
-An error to be thrown when the server redirects you more than ten times.
-Includes a `response` property.
-*/
-export declare class MaxRedirectsError extends RequestError {
-    readonly response: Response;
-    readonly request: Request;
-    readonly timings: Timings;
-    constructor(request: Request);
-}
-/**
-An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
-Includes a `response` property.
-*/
-export declare class HTTPError extends RequestError {
-    readonly response: Response;
-    readonly request: Request;
-    readonly timings: Timings;
-    constructor(response: PlainResponse);
-}
-/**
-An error to be thrown when a cache method fails.
-For example, if the database goes down or there's a filesystem error.
-*/
-export declare class CacheError extends RequestError {
-    readonly request: Request;
-    constructor(error: Error, request: Request);
-}
-/**
-An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
-*/
-export declare class UploadError extends RequestError {
-    readonly request: Request;
-    constructor(error: Error, request: Request);
-}
-/**
-An error to be thrown when the request is aborted due to a timeout.
-Includes an `event` and `timings` property.
-*/
-export declare class TimeoutError extends RequestError {
-    readonly request: Request;
-    readonly timings: Timings;
-    readonly event: string;
-    constructor(error: TimedOutTimeoutError, timings: Timings, request: Request);
-}
-/**
-An error to be thrown when reading from response stream fails.
-*/
-export declare class ReadError extends RequestError {
-    readonly request: Request;
-    readonly response: Response;
-    readonly timings: Timings;
-    constructor(error: Error, request: Request);
-}
-/**
-An error which always triggers a new retry when thrown.
-*/
-export declare class RetryError extends RequestError {
-    constructor(request: Request);
-}
-/**
-An error to be thrown when the request is aborted by AbortController.
-*/
-export declare class AbortError extends RequestError {
-    constructor(request: Request);
-}
-export {};

package/generator-adapter/node_modules/got/dist/source/core/errors.js

@@ -1,178 +0,0 @@
-import is from '@sindresorhus/is';
-// A hacky check to prevent circular references.
-function isRequest(x) {
-    return is.object(x) && '_onResponse' in x;
-}
-/**
-An error to be thrown when a request fails.
-Contains a `code` property with error class code, like `ECONNREFUSED`.
-*/
-export class RequestError extends Error {
-    constructor(message, error, self) {
-        super(message);
-        Object.defineProperty(this, "input", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "code", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "stack", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "response", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "request", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "timings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Error.captureStackTrace(this, this.constructor);
-        this.name = 'RequestError';
-        this.code = error.code ?? 'ERR_GOT_REQUEST_ERROR';
-        this.input = error.input;
-        if (isRequest(self)) {
-            Object.defineProperty(this, 'request', {
-                enumerable: false,
-                value: self,
-            });
-            Object.defineProperty(this, 'response', {
-                enumerable: false,
-                value: self.response,
-            });
-            this.options = self.options;
-        }
-        else {
-            this.options = self;
-        }
-        this.timings = this.request?.timings;
-        // Recover the original stacktrace
-        if (is.string(error.stack) && is.string(this.stack)) {
-            const indexOfMessage = this.stack.indexOf(this.message) + this.message.length;
-            const thisStackTrace = this.stack.slice(indexOfMessage).split('\n').reverse();
-            const errorStackTrace = error.stack.slice(error.stack.indexOf(error.message) + error.message.length).split('\n').reverse();
-            // Remove duplicated traces
-            while (errorStackTrace.length > 0 && errorStackTrace[0] === thisStackTrace[0]) {
-                thisStackTrace.shift();
-            }
-            this.stack = `${this.stack.slice(0, indexOfMessage)}${thisStackTrace.reverse().join('\n')}${errorStackTrace.reverse().join('\n')}`;
-        }
-    }
-}
-/**
-An error to be thrown when the server redirects you more than ten times.
-Includes a `response` property.
-*/
-export class MaxRedirectsError extends RequestError {
-    constructor(request) {
-        super(`Redirected ${request.options.maxRedirects} times. Aborting.`, {}, request);
-        this.name = 'MaxRedirectsError';
-        this.code = 'ERR_TOO_MANY_REDIRECTS';
-    }
-}
-/**
-An error to be thrown when the server response code is not 2xx nor 3xx if `options.followRedirect` is `true`, but always except for 304.
-Includes a `response` property.
-*/
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export class HTTPError extends RequestError {
-    constructor(response) {
-        super(`Response code ${response.statusCode} (${response.statusMessage})`, {}, response.request);
-        this.name = 'HTTPError';
-        this.code = 'ERR_NON_2XX_3XX_RESPONSE';
-    }
-}
-/**
-An error to be thrown when a cache method fails.
-For example, if the database goes down or there's a filesystem error.
-*/
-export class CacheError extends RequestError {
-    constructor(error, request) {
-        super(error.message, error, request);
-        this.name = 'CacheError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_CACHE_ACCESS' : this.code;
-    }
-}
-/**
-An error to be thrown when the request body is a stream and an error occurs while reading from that stream.
-*/
-export class UploadError extends RequestError {
-    constructor(error, request) {
-        super(error.message, error, request);
-        this.name = 'UploadError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_UPLOAD' : this.code;
-    }
-}
-/**
-An error to be thrown when the request is aborted due to a timeout.
-Includes an `event` and `timings` property.
-*/
-export class TimeoutError extends RequestError {
-    constructor(error, timings, request) {
-        super(error.message, error, request);
-        Object.defineProperty(this, "timings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "event", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = 'TimeoutError';
-        this.event = error.event;
-        this.timings = timings;
-    }
-}
-/**
-An error to be thrown when reading from response stream fails.
-*/
-export class ReadError extends RequestError {
-    constructor(error, request) {
-        super(error.message, error, request);
-        this.name = 'ReadError';
-        this.code = this.code === 'ERR_GOT_REQUEST_ERROR' ? 'ERR_READING_RESPONSE_STREAM' : this.code;
-    }
-}
-/**
-An error which always triggers a new retry when thrown.
-*/
-export class RetryError extends RequestError {
-    constructor(request) {
-        super('Retrying', {}, request);
-        this.name = 'RetryError';
-        this.code = 'ERR_RETRYING';
-    }
-}
-/**
-An error to be thrown when the request is aborted by AbortController.
-*/
-export class AbortError extends RequestError {
-    constructor(request) {
-        super('This operation was aborted.', {}, request);
-        this.code = 'ERR_ABORTED';
-        this.name = 'AbortError';
-    }
-}