forked from sindresorhus/got
-
Notifications
You must be signed in to change notification settings - Fork 0
/
types.ts
152 lines (129 loc) · 3.83 KB
/
types.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
import PCancelable = require('p-cancelable');
import {CancelError} from 'p-cancelable';
import {
// Interfaces to be extended
Options as RequestOptions,
NormalizedOptions as RequestNormalizedOptions,
Defaults as RequestDefaults,
Hooks as RequestHooks,
Response as RequestResponse,
// Errors to be exported
RequestError,
MaxRedirectsError,
CacheError,
UploadError,
TimeoutError,
HTTPError,
ReadError,
UnsupportedProtocolError,
// Hooks to be exported
HookEvent as RequestHookEvent,
InitHook,
BeforeRequestHook,
BeforeRedirectHook,
BeforeErrorHook,
// Other types to be exported
Progress,
Headers,
RequestFunction,
// Types that will not be exported
Method,
RequestEvents
} from '../core';
import PromisableRequest from './core';
export type ResponseType = 'json' | 'buffer' | 'text';
export interface Response<T = unknown> extends RequestResponse<T> {
request: PromisableRequest;
}
export interface RetryObject {
attemptCount: number;
retryOptions: RequiredRetryOptions;
error: TimeoutError | RequestError;
computedValue: number;
}
export type RetryFunction = (retryObject: RetryObject) => number;
export interface RequiredRetryOptions {
limit: number;
methods: Method[];
statusCodes: number[];
errorCodes: string[];
calculateDelay: RetryFunction;
maxRetryAfter?: number;
}
export type BeforeRetryHook = (options: NormalizedOptions, error?: RequestError, retryCount?: number) => void | Promise<void>;
export type AfterResponseHook = (response: Response, retryWithMergedOptions: (options: Options) => CancelableRequest<Response>) => Response | CancelableRequest<Response> | Promise<Response | CancelableRequest<Response>>;
export interface Hooks extends RequestHooks {
beforeRetry?: BeforeRetryHook[];
afterResponse?: AfterResponseHook[];
}
export interface PaginationOptions<T> {
pagination?: {
transform?: (response: Response) => Promise<T[]> | T[];
filter?: (item: T, allItems: T[], currentItems: T[]) => boolean;
paginate?: (response: Response, allItems: T[], currentItems: T[]) => Options | false;
shouldContinue?: (item: T, allItems: T[], currentItems: T[]) => boolean;
countLimit?: number;
};
}
export interface Options extends RequestOptions, PaginationOptions<unknown> {
hooks?: Hooks;
responseType?: ResponseType;
resolveBodyOnly?: boolean;
retry?: Partial<RequiredRetryOptions> | number;
isStream?: boolean;
}
export interface NormalizedOptions extends RequestNormalizedOptions {
hooks: Required<Hooks>;
responseType: ResponseType;
resolveBodyOnly: boolean;
retry: RequiredRetryOptions;
isStream: boolean;
pagination?: Required<PaginationOptions<unknown>['pagination']>;
}
export interface Defaults extends RequestDefaults {
hooks: Required<Hooks>;
responseType: ResponseType;
resolveBodyOnly: boolean;
retry: RequiredRetryOptions;
isStream: boolean;
pagination?: Required<PaginationOptions<unknown>['pagination']>;
}
export class ParseError extends RequestError {
declare readonly response: Response;
constructor(error: Error, response: Response, options: NormalizedOptions) {
super(`${error.message} in "${options.url.toString()}"`, error, options);
this.name = 'ParseError';
Object.defineProperty(this, 'response', {
enumerable: false,
value: response
});
}
}
export interface CancelableRequest<T extends Response | Response['body'] = Response['body']> extends PCancelable<T>, RequestEvents<CancelableRequest<T>> {
json<ReturnType>(): CancelableRequest<ReturnType>;
buffer(): CancelableRequest<Buffer>;
text(): CancelableRequest<string>;
}
export type HookEvent = RequestHookEvent | 'beforeRetry' | 'afterResponse';
export {
RequestError,
MaxRedirectsError,
CacheError,
UploadError,
TimeoutError,
HTTPError,
ReadError,
UnsupportedProtocolError,
CancelError
};
export {
InitHook,
BeforeRequestHook,
BeforeRedirectHook,
BeforeErrorHook
};
export {
Progress,
Headers,
RequestFunction
};