up n_m

node_modules/cacheable-request/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { RequestFn, StorageAdapter, CacheResponse, CacheValue, CacheableOptions, Emitter } from './types.js';
+type Func = (...args: any[]) => any;
+declare class CacheableRequest {
+    cache: StorageAdapter;
+    cacheRequest: RequestFn;
+    hooks: Map<string, Func>;
+    constructor(cacheRequest: RequestFn, cacheAdapter?: StorageAdapter | string);
+    request: () => (options: CacheableOptions, cb?: (response: CacheResponse) => void) => Emitter;
+    addHook: (name: string, fn: Func) => void;
+    removeHook: (name: string) => boolean;
+    getHook: (name: string) => Func;
+    runHook: (name: string, ...args: any[]) => Promise<CacheValue>;
+}
+export default CacheableRequest;
+export * from './types.js';
+export declare const onResponse = "onResponse";
+//# sourceMappingURL=index.d.ts.map

node_modules/cacheable-request/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,OAAO,EAAC,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAuC,OAAO,EAA2B,MAAM,YAAY,CAAC;AAE1K,KAAK,IAAI,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AAEpC,cAAM,gBAAgB;IACrB,KAAK,EAAE,cAAc,CAAC;IACtB,YAAY,EAAE,SAAS,CAAC;IACxB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAA2B;gBACvC,YAAY,EAAE,SAAS,EAAE,YAAY,CAAC,EAAE,cAAc,GAAG,MAAM;IAmB3E,OAAO,kBAAmB,gBAAgB,kBACzB,aAAa,KAAK,IAAI,KAAG,OAAO,CAuM/C;IAEF,OAAO,SAAU,MAAM,MAAM,IAAI,UAI/B;IAEF,UAAU,SAAU,MAAM,aAA6B;IAEvD,OAAO,SAAU,MAAM,UAA0B;IAEjD,OAAO,SAAgB,MAAM,WAAW,GAAG,EAAE,KAAG,QAAQ,UAAU,CAAC,CAAoC;CACvG;AA6CD,eAAe,gBAAgB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,eAAO,MAAM,UAAU,eAAe,CAAC"}

node_modules/cacheable-request/dist/index.js

@@ -0,0 +1,275 @@
+import EventEmitter from 'node:events';
+import urlLib from 'node:url';
+import crypto from 'node:crypto';
+import stream, { PassThrough as PassThroughStream } from 'node:stream';
+import normalizeUrl from 'normalize-url';
+import getStream from 'get-stream';
+import CachePolicy from 'http-cache-semantics';
+import Response from 'responselike';
+import Keyv from 'keyv';
+import mimicResponse from 'mimic-response';
+import { CacheError, RequestError } from './types.js';
+class CacheableRequest {
+    constructor(cacheRequest, cacheAdapter) {
+        this.hooks = new Map();
+        this.request = () => (options, cb) => {
+            let url;
+            if (typeof options === 'string') {
+                url = normalizeUrlObject(urlLib.parse(options));
+                options = {};
+            }
+            else if (options instanceof urlLib.URL) {
+                url = normalizeUrlObject(urlLib.parse(options.toString()));
+                options = {};
+            }
+            else {
+                const [pathname, ...searchParts] = (options.path ?? '').split('?');
+                const search = searchParts.length > 0
+                    ? `?${searchParts.join('?')}`
+                    : '';
+                url = normalizeUrlObject({ ...options, pathname, search });
+            }
+            options = {
+                headers: {},
+                method: 'GET',
+                cache: true,
+                strictTtl: false,
+                automaticFailover: false,
+                ...options,
+                ...urlObjectToRequestOptions(url),
+            };
+            options.headers = Object.fromEntries(entries(options.headers).map(([key, value]) => [key.toLowerCase(), value]));
+            const ee = new EventEmitter();
+            const normalizedUrlString = normalizeUrl(urlLib.format(url), {
+                stripWWW: false,
+                removeTrailingSlash: false,
+                stripAuthentication: false,
+            });
+            let key = `${options.method}:${normalizedUrlString}`;
+            // POST, PATCH, and PUT requests may be cached, depending on the response
+            // cache-control headers. As a result, the body of the request should be
+            // added to the cache key in order to avoid collisions.
+            if (options.body && options.method !== undefined && ['POST', 'PATCH', 'PUT'].includes(options.method)) {
+                if (options.body instanceof stream.Readable) {
+                    // Streamed bodies should completely skip the cache because they may
+                    // or may not be hashable and in either case the stream would need to
+                    // close before the cache key could be generated.
+                    options.cache = false;
+                }
+                else {
+                    key += `:${crypto.createHash('md5').update(options.body).digest('hex')}`;
+                }
+            }
+            let revalidate = false;
+            let madeRequest = false;
+            const makeRequest = (options_) => {
+                madeRequest = true;
+                let requestErrored = false;
+                let requestErrorCallback = () => { };
+                const requestErrorPromise = new Promise(resolve => {
+                    requestErrorCallback = () => {
+                        if (!requestErrored) {
+                            requestErrored = true;
+                            resolve();
+                        }
+                    };
+                });
+                const handler = async (response) => {
+                    if (revalidate) {
+                        response.status = response.statusCode;
+                        const revalidatedPolicy = CachePolicy.fromObject(revalidate.cachePolicy).revalidatedPolicy(options_, response);
+                        if (!revalidatedPolicy.modified) {
+                            response.resume();
+                            await new Promise(resolve => {
+                                // Skipping 'error' handler cause 'error' event should't be emitted for 304 response
+                                response
+                                    .once('end', resolve);
+                            });
+                            const headers = convertHeaders(revalidatedPolicy.policy.responseHeaders());
+                            response = new Response({ statusCode: revalidate.statusCode, headers, body: revalidate.body, url: revalidate.url });
+                            response.cachePolicy = revalidatedPolicy.policy;
+                            response.fromCache = true;
+                        }
+                    }
+                    if (!response.fromCache) {
+                        response.cachePolicy = new CachePolicy(options_, response, options_);
+                        response.fromCache = false;
+                    }
+                    let clonedResponse;
+                    if (options_.cache && response.cachePolicy.storable()) {
+                        clonedResponse = cloneResponse(response);
+                        (async () => {
+                            try {
+                                const bodyPromise = getStream.buffer(response);
+                                await Promise.race([
+                                    requestErrorPromise,
+                                    new Promise(resolve => response.once('end', resolve)),
+                                    new Promise(resolve => response.once('close', resolve)), // eslint-disable-line no-promise-executor-return
+                                ]);
+                                const body = await bodyPromise;
+                                let value = {
+                                    url: response.url,
+                                    statusCode: response.fromCache ? revalidate.statusCode : response.statusCode,
+                                    body,
+                                    cachePolicy: response.cachePolicy.toObject(),
+                                };
+                                let ttl = options_.strictTtl ? response.cachePolicy.timeToLive() : undefined;
+                                if (options_.maxTtl) {
+                                    ttl = ttl ? Math.min(ttl, options_.maxTtl) : options_.maxTtl;
+                                }
+                                if (this.hooks.size > 0) {
+                                    /* eslint-disable no-await-in-loop */
+                                    for (const key_ of this.hooks.keys()) {
+                                        value = await this.runHook(key_, value, response);
+                                    }
+                                    /* eslint-enable no-await-in-loop */
+                                }
+                                await this.cache.set(key, value, ttl);
+                            }
+                            catch (error) {
+                                ee.emit('error', new CacheError(error));
+                            }
+                        })();
+                    }
+                    else if (options_.cache && revalidate) {
+                        (async () => {
+                            try {
+                                await this.cache.delete(key);
+                            }
+                            catch (error) {
+                                ee.emit('error', new CacheError(error));
+                            }
+                        })();
+                    }
+                    ee.emit('response', clonedResponse ?? response);
+                    if (typeof cb === 'function') {
+                        cb(clonedResponse ?? response);
+                    }
+                };
+                try {
+                    const request_ = this.cacheRequest(options_, handler);
+                    request_.once('error', requestErrorCallback);
+                    request_.once('abort', requestErrorCallback);
+                    request_.once('destroy', requestErrorCallback);
+                    ee.emit('request', request_);
+                }
+                catch (error) {
+                    ee.emit('error', new RequestError(error));
+                }
+            };
+            (async () => {
+                const get = async (options_) => {
+                    await Promise.resolve();
+                    const cacheEntry = options_.cache ? await this.cache.get(key) : undefined;
+                    if (cacheEntry === undefined && !options_.forceRefresh) {
+                        makeRequest(options_);
+                        return;
+                    }
+                    const policy = CachePolicy.fromObject(cacheEntry.cachePolicy);
+                    if (policy.satisfiesWithoutRevalidation(options_) && !options_.forceRefresh) {
+                        const headers = convertHeaders(policy.responseHeaders());
+                        const response = new Response({ statusCode: cacheEntry.statusCode, headers, body: cacheEntry.body, url: cacheEntry.url });
+                        response.cachePolicy = policy;
+                        response.fromCache = true;
+                        ee.emit('response', response);
+                        if (typeof cb === 'function') {
+                            cb(response);
+                        }
+                    }
+                    else if (policy.satisfiesWithoutRevalidation(options_) && Date.now() >= policy.timeToLive() && options_.forceRefresh) {
+                        await this.cache.delete(key);
+                        options_.headers = policy.revalidationHeaders(options_);
+                        makeRequest(options_);
+                    }
+                    else {
+                        revalidate = cacheEntry;
+                        options_.headers = policy.revalidationHeaders(options_);
+                        makeRequest(options_);
+                    }
+                };
+                const errorHandler = (error) => ee.emit('error', new CacheError(error));
+                if (this.cache instanceof Keyv) {
+                    const cachek = this.cache;
+                    cachek.once('error', errorHandler);
+                    ee.on('error', () => cachek.removeListener('error', errorHandler));
+                    ee.on('response', () => cachek.removeListener('error', errorHandler));
+                }
+                try {
+                    await get(options);
+                }
+                catch (error) {
+                    if (options.automaticFailover && !madeRequest) {
+                        makeRequest(options);
+                    }
+                    ee.emit('error', new CacheError(error));
+                }
+            })();
+            return ee;
+        };
+        this.addHook = (name, fn) => {
+            if (!this.hooks.has(name)) {
+                this.hooks.set(name, fn);
+            }
+        };
+        this.removeHook = (name) => this.hooks.delete(name);
+        this.getHook = (name) => this.hooks.get(name);
+        this.runHook = async (name, ...args) => this.hooks.get(name)?.(...args);
+        if (cacheAdapter instanceof Keyv) {
+            this.cache = cacheAdapter;
+        }
+        else if (typeof cacheAdapter === 'string') {
+            this.cache = new Keyv({
+                uri: cacheAdapter,
+                namespace: 'cacheable-request',
+            });
+        }
+        else {
+            this.cache = new Keyv({
+                store: cacheAdapter,
+                namespace: 'cacheable-request',
+            });
+        }
+        this.request = this.request.bind(this);
+        this.cacheRequest = cacheRequest;
+    }
+}
+const entries = Object.entries;
+const cloneResponse = (response) => {
+    const clone = new PassThroughStream({ autoDestroy: false });
+    mimicResponse(response, clone);
+    return response.pipe(clone);
+};
+const urlObjectToRequestOptions = (url) => {
+    const options = { ...url };
+    options.path = `${url.pathname || '/'}${url.search || ''}`;
+    delete options.pathname;
+    delete options.search;
+    return options;
+};
+const normalizeUrlObject = (url) => 
+// If url was parsed by url.parse or new URL:
+// - hostname will be set
+// - host will be hostname[:port]
+// - port will be set if it was explicit in the parsed string
+// Otherwise, url was from request options:
+// - hostname or host may be set
+// - host shall not have port encoded
+({
+    protocol: url.protocol,
+    auth: url.auth,
+    hostname: url.hostname || url.host || 'localhost',
+    port: url.port,
+    pathname: url.pathname,
+    search: url.search,
+});
+const convertHeaders = (headers) => {
+    const result = [];
+    for (const name of Object.keys(headers)) {
+        result[name.toLowerCase()] = headers[name];
+    }
+    return result;
+};
+export default CacheableRequest;
+export * from './types.js';
+export const onResponse = 'onResponse';
+//# sourceMappingURL=index.js.map

node_modules/cacheable-request/dist/types.d.ts

@@ -0,0 +1,106 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { request, RequestOptions, ClientRequest, ServerResponse } from 'node:http';
+import { URL } from 'node:url';
+import { EventEmitter } from 'node:events';
+import { Buffer } from 'node:buffer';
+import { Store } from 'keyv';
+import ResponseLike from 'responselike';
+import { CachePolicyObject } from 'http-cache-semantics';
+export type RequestFn = typeof request;
+export type RequestFunction = typeof request;
+export type CacheResponse = ServerResponse | typeof ResponseLike;
+export type CacheableRequestFunction = (options: CacheableOptions, cb?: (response: CacheResponse) => void) => Emitter;
+export type CacheableOptions = Options & RequestOptions | string | URL;
+export type StorageAdapter = Store<any>;
+export interface Options {
+    /**
+             * If the cache should be used. Setting this to `false` will completely bypass the cache for the current request.
+             * @default true
+             */
+    cache?: boolean | undefined;
+    /**
+             * If set to `true` once a cached resource has expired it is deleted and will have to be re-requested.
+             *
+             * If set to `false`, after a cached resource's TTL expires it is kept in the cache and will be revalidated
+             * on the next request with `If-None-Match`/`If-Modified-Since` headers.
+             * @default false
+             */
+    strictTtl?: boolean | undefined;
+    /**
+             * Limits TTL. The `number` represents milliseconds.
+             * @default undefined
+             */
+    maxTtl?: number | undefined;
+    /**
+             * When set to `true`, if the DB connection fails we will automatically fallback to a network request.
+             * DB errors will still be emitted to notify you of the problem even though the request callback may succeed.
+             * @default false
+             */
+    automaticFailover?: boolean | undefined;
+    /**
+ * Forces refreshing the cache. If the response could be retrieved from the cache, it will perform a
+ * new request and override the cache instead.
+ * @default false
+ */
+    forceRefresh?: boolean | undefined;
+    remoteAddress?: boolean | undefined;
+    url?: string | undefined;
+    headers?: Record<string, string | string[] | undefined>;
+    body?: Buffer;
+}
+export interface CacheValue extends Record<string, any> {
+    url: string;
+    statusCode: number;
+    body: Buffer | string;
+    cachePolicy: CachePolicyObject;
+}
+export interface Emitter extends EventEmitter {
+    addListener(event: 'request', listener: (request: ClientRequest) => void): this;
+    addListener(event: 'response', listener: (response: CacheResponse) => void): this;
+    addListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    on(event: 'request', listener: (request: ClientRequest) => void): this;
+    on(event: 'response', listener: (response: CacheResponse) => void): this;
+    on(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    once(event: 'request', listener: (request: ClientRequest) => void): this;
+    once(event: 'response', listener: (response: CacheResponse) => void): this;
+    once(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    prependListener(event: 'request', listener: (request: ClientRequest) => void): this;
+    prependListener(event: 'response', listener: (response: CacheResponse) => void): this;
+    prependListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    prependOnceListener(event: 'request', listener: (request: ClientRequest) => void): this;
+    prependOnceListener(event: 'response', listener: (response: CacheResponse) => void): this;
+    prependOnceListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    removeListener(event: 'request', listener: (request: ClientRequest) => void): this;
+    removeListener(event: 'response', listener: (response: CacheResponse) => void): this;
+    removeListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    off(event: 'request', listener: (request: ClientRequest) => void): this;
+    off(event: 'response', listener: (response: CacheResponse) => void): this;
+    off(event: 'error', listener: (error: RequestError | CacheError) => void): this;
+    removeAllListeners(event?: 'request' | 'response' | 'error'): this;
+    listeners(event: 'request'): Array<(request: ClientRequest) => void>;
+    listeners(event: 'response'): Array<(response: CacheResponse) => void>;
+    listeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
+    rawListeners(event: 'request'): Array<(request: ClientRequest) => void>;
+    rawListeners(event: 'response'): Array<(response: CacheResponse) => void>;
+    rawListeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
+    emit(event: 'request', request: ClientRequest): boolean;
+    emit(event: 'response', response: CacheResponse): boolean;
+    emit(event: 'error', error: RequestError | CacheError): boolean;
+    eventNames(): Array<'request' | 'response' | 'error'>;
+    listenerCount(type: 'request' | 'response' | 'error'): number;
+}
+export declare class RequestError extends Error {
+    constructor(error: Error);
+}
+export declare class CacheError extends Error {
+    constructor(error: Error);
+}
+export interface UrlOption {
+    path: string;
+    pathname?: string;
+    search?: string;
+}
+//# sourceMappingURL=types.d.ts.map

node_modules/cacheable-request/dist/types.d.ts.map

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

node_modules/cacheable-request/dist/types.js

@@ -0,0 +1,19 @@
+// Type definitions for cacheable-request 6.0
+// Project: https://github.com/lukechilds/cacheable-request#readme
+// Definitions by: BendingBender <https://github.com/BendingBender>
+//                 Paul Melnikow <https://github.com/paulmelnikow>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+export class RequestError extends Error {
+    constructor(error) {
+        super(error.message);
+        Object.assign(this, error);
+    }
+}
+export class CacheError extends Error {
+    constructor(error) {
+        super(error.message);
+        Object.assign(this, error);
+    }
+}
+//# sourceMappingURL=types.js.map