138 lines
6.0 KiB
Plaintext
Executable File
138 lines
6.0 KiB
Plaintext
Executable File
// 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
|
|
|
|
/// <reference types="node" />
|
|
|
|
import { request, RequestOptions, ClientRequest, ServerResponse } from 'http';
|
|
import { URL } from 'url';
|
|
import { EventEmitter } from 'events';
|
|
import { Store } from 'keyv';
|
|
import { Options as CacheSemanticsOptions } from 'http-cache-semantics';
|
|
import ResponseLike = require('responselike');
|
|
|
|
export = CacheableRequest;
|
|
|
|
declare const CacheableRequest: CacheableRequest;
|
|
|
|
type RequestFn = typeof request;
|
|
|
|
interface CacheableRequest {
|
|
new (requestFn: RequestFn, storageAdapter?: string | CacheableRequest.StorageAdapter): (
|
|
opts: string | URL | (RequestOptions & CacheSemanticsOptions),
|
|
cb?: (response: ServerResponse | ResponseLike) => void
|
|
) => CacheableRequest.Emitter;
|
|
|
|
RequestError: typeof RequestErrorCls;
|
|
CacheError: typeof CacheErrorCls;
|
|
}
|
|
|
|
declare namespace CacheableRequest {
|
|
type StorageAdapter = Store<any>;
|
|
|
|
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;
|
|
}
|
|
|
|
interface Emitter extends EventEmitter {
|
|
addListener(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
addListener(
|
|
event: 'response',
|
|
listener: (response: ServerResponse | ResponseLike) => void
|
|
): this;
|
|
addListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
|
|
on(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
on(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
|
|
on(event: 'error', listener: (error: RequestError | CacheError) => void): this;
|
|
once(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
once(event: 'response', listener: (response: ServerResponse | ResponseLike) => void): this;
|
|
once(event: 'error', listener: (error: RequestError | CacheError) => void): this;
|
|
prependListener(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
prependListener(
|
|
event: 'response',
|
|
listener: (response: ServerResponse | ResponseLike) => void
|
|
): this;
|
|
prependListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
|
|
prependOnceListener(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
prependOnceListener(
|
|
event: 'response',
|
|
listener: (response: ServerResponse | ResponseLike) => void
|
|
): this;
|
|
prependOnceListener(
|
|
event: 'error',
|
|
listener: (error: RequestError | CacheError) => void
|
|
): this;
|
|
removeListener(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
removeListener(
|
|
event: 'response',
|
|
listener: (response: ServerResponse | ResponseLike) => void
|
|
): this;
|
|
removeListener(event: 'error', listener: (error: RequestError | CacheError) => void): this;
|
|
off(event: 'request', listener: (request: ClientRequest) => void): this;
|
|
off(event: 'response', listener: (response: ServerResponse | ResponseLike) => 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: ServerResponse | ResponseLike) => void>;
|
|
listeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
|
|
rawListeners(event: 'request'): Array<(request: ClientRequest) => void>;
|
|
rawListeners(event: 'response'): Array<(response: ServerResponse | ResponseLike) => void>;
|
|
rawListeners(event: 'error'): Array<(error: RequestError | CacheError) => void>;
|
|
emit(event: 'request', request: ClientRequest): boolean;
|
|
emit(event: 'response', response: ServerResponse | ResponseLike): boolean;
|
|
emit(event: 'error', error: RequestError | CacheError): boolean;
|
|
eventNames(): Array<'request' | 'response' | 'error'>;
|
|
listenerCount(type: 'request' | 'response' | 'error'): number;
|
|
}
|
|
|
|
type RequestError = RequestErrorCls;
|
|
type CacheError = CacheErrorCls;
|
|
}
|
|
|
|
declare class RequestErrorCls extends Error {
|
|
readonly name: 'RequestError';
|
|
|
|
constructor(error: Error);
|
|
}
|
|
declare class CacheErrorCls extends Error {
|
|
readonly name: 'CacheError';
|
|
|
|
constructor(error: Error);
|
|
}
|