@little-nebulae/web-fetch 0.2.0 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.d.ts +158 -51
  2. package/dist/index.js +333 -98
  3. package/package.json +30 -22
package/dist/index.d.ts CHANGED
@@ -1,55 +1,162 @@
1
- import { UnexpectedError } from "@little-nebulae/error";
2
- import { Result } from "@little-nebulae/result";
3
- import { InvalidJsonStringError } from "@little-nebulae/json";
4
- import { HttpHeader, HttpRequestMethod } from "@little-nebulae/http";
5
- import { ExtractLiteral } from "@little-nebulae/type-utils";
6
- import { JSONType } from "zod";
7
- //#region src/headers/create.d.ts
8
- export declare function createHeaders(init: { [header in HttpHeader]: string; }): Headers;
9
- //#endregion
10
- //#region src/request/create/index.d.ts
11
- export declare function createRequest({ url, method, headers, body }: {
12
- url: string | URL;
13
- method?: HttpRequestMethod;
14
- headers?: Headers;
15
- body?: string;
16
- }): Result<Request, UnexpectedError>;
17
- //#endregion
18
- //#region src/request/create/json.d.ts
19
- export declare function createJsonRequest({ url, method, headers, body }: {
20
- url: string | URL;
21
- method: ExtractLiteral<HttpRequestMethod, "POST" | "PUT" | "DELETE" | "PATCH">;
22
- headers?: Headers;
23
- body: JSONType;
24
- }): Result<Request, UnexpectedError>;
25
- //#endregion
26
- //#region src/request/parse-body/text.d.ts
27
- export declare function parseTextRequestBody({ request }: {
1
+ import { BaseError, UnexpectedError } from "@little-nebulae/error";
2
+ import { AsyncResult } from "@little-nebulae/result";
3
+ import { HTTP_ERROR_RESPONSE_STATUS_ENUM, HTTP_SUCCESSFUL_RESPONSE_STATUS_ENUM, HttpRequestMethod } from "@little-nebulae/http";
4
+ import { JsonParseError } from "@little-nebulae/json";
5
+ import { Except, ExcludeStrict, JsonValue } from "type-fest";
6
+ import { ExcludeFrom, ExtractFrom } from "@little-nebulae/utility-types";
7
+ type BodyInit = ExcludeStrict<RequestInit["body"], undefined>;
8
+ type HeadersInit = ExcludeStrict<ConstructorParameters<typeof Headers>[0], undefined>;
9
+ type HeaderEntries = [string, string][];
10
+ type HeaderRecord = ExcludeStrict<HeadersInit, HeaderEntries | Headers>;
11
+ type HeaderName = keyof HeaderRecord;
12
+ type RequestInfo = ConstructorParameters<typeof Request>[0];
13
+ export declare class WebUsedBodyError extends BaseError<"WEB_USED_BODY_ERROR", TypeError> {
14
+ readonly name = "WebUsedBodyError";
15
+ readonly code = "WEB_USED_BODY_ERROR";
16
+ constructor({ message, cause }: {
17
+ message?: string;
18
+ cause: TypeError;
19
+ });
20
+ }
21
+ export declare class WebBodyDecodingError extends BaseError<"WEB_BODY_DECODING_ERROR", TypeError, {
22
+ contentEncoding: string | null;
23
+ }> {
24
+ readonly name = "WebBodyDecodingError";
25
+ readonly code = "WEB_BODY_DECODING_ERROR";
26
+ constructor({ message, cause, contentEncoding }: {
27
+ message?: string;
28
+ cause: TypeError;
29
+ contentEncoding: string | null;
30
+ });
31
+ }
32
+ export declare class WebBodySizeTooLargeError extends BaseError<"WEB_BODY_SIZE_TOO_LARGE_ERROR", RangeError> {
33
+ readonly name = "WebBodySizeTooLargeError";
34
+ readonly code = "WEB_BODY_SIZE_TOO_LARGE_ERROR";
35
+ constructor({ message, cause }: {
36
+ message?: string;
37
+ cause: RangeError;
38
+ });
39
+ }
40
+ export declare function createHeaders(record: HeaderRecord): Headers;
41
+ export declare function getHeader({ headers, name }: {
42
+ headers: Headers;
43
+ name: HeaderName;
44
+ }): string | null;
45
+ export declare function hasHeader({ headers, name }: {
46
+ headers: Headers;
47
+ name: HeaderName;
48
+ }): boolean;
49
+ export declare function setHeader({ headers, name, value }: {
50
+ headers: Headers;
51
+ name: HeaderName;
52
+ value: string;
53
+ }): void;
54
+ interface CreateRequestParamsWithBody extends Except<RequestInit, "body"> {
55
+ input: RequestInfo;
56
+ method: ExtractFrom<HttpRequestMethod, "GET" | "PATCH" | "POST" | "PUT" | "QUERY">;
57
+ body: BodyInit;
58
+ }
59
+ interface CreateRequestParamsWithNoBody extends Except<RequestInit, "body"> {
60
+ input: RequestInfo;
61
+ method: ExtractFrom<HttpRequestMethod, "CONNECT" | "DELETE" | "HEAD" | "OPTIONS" | "TRACE">;
62
+ }
63
+ type CreateRequestParams = CreateRequestParamsWithBody | CreateRequestParamsWithNoBody;
64
+ export declare function webCreateRequest({ input, ...init }: CreateRequestParams): any;
65
+ interface CreateJsonRequestParams extends Except<RequestInit, "body" | "headers"> {
66
+ method: ExtractFrom<HttpRequestMethod, "GET" | "PATCH" | "POST" | "PUT" | "QUERY">;
67
+ input: string | URL;
68
+ data: JsonValue;
69
+ headers: Except<HeaderRecord, "Content-Type">;
70
+ }
71
+ export declare function webCreateJsonRequest({ input, data, headers, ...init }: CreateJsonRequestParams): any;
72
+ export declare function webReadArrayBufferRequestBody({ request }: {
28
73
  request: Request;
29
- }): Promise<Result<string, UnexpectedError>>;
30
- //#endregion
31
- //#region src/request/parse-body/json.d.ts
32
- export declare function parseJsonRequestBody({ request }: {
74
+ }): Promise<import("@little-nebulae/result").Result<ArrayBuffer, UnexpectedError<unknown, null> | WebBodyDecodingError | WebBodySizeTooLargeError | WebUsedBodyError>>;
75
+ export declare function webReadBlobRequestBody({ request }: {
33
76
  request: Request;
34
- }): Promise<Result<JSONType, InvalidJsonStringError | UnexpectedError>>;
35
- //#endregion
36
- //#region src/response/parse-text-body.d.ts
37
- export declare function parseTextResponseBody({ response }: {
38
- response: Response;
39
- }): Promise<Result<string, UnexpectedError>>;
40
- //#endregion
41
- //#region src/response/parse-json-body.d.ts
42
- export declare function parseJsonResponseBody({ response }: {
43
- response: Response;
44
- }): Promise<Result<JSONType, InvalidJsonStringError | UnexpectedError>>;
45
- //#endregion
46
- //#region src/fetch/response.d.ts
47
- export declare function fetchResponse({ request }: {
77
+ }): Promise<import("@little-nebulae/result").Result<import("node:buffer").Blob, UnexpectedError<unknown, null> | WebBodyDecodingError | WebUsedBodyError>>;
78
+ export declare function webReadBytesRequestBody({ request }: {
48
79
  request: Request;
49
- }): Promise<Result<Response, UnexpectedError>>;
50
- //#endregion
51
- //#region src/fetch/json.d.ts
52
- export declare function fetchJson({ request }: {
80
+ }): Promise<import("@little-nebulae/result").Result<Uint8Array<ArrayBufferLike>, UnexpectedError<unknown, null> | WebBodyDecodingError | WebBodySizeTooLargeError | WebUsedBodyError>>;
81
+ export declare function webReadTextRequestBody({ request }: {
53
82
  request: Request;
54
- }): Promise<Result<JSONType, InvalidJsonStringError | UnexpectedError>>;
55
- //#endregion
83
+ }): Promise<import("@little-nebulae/result").Result<string, UnexpectedError<unknown, null> | WebBodyDecodingError | WebUsedBodyError>>;
84
+ export declare function webParseJsonRequestBody<T = unknown>({ request }: {
85
+ request: Request;
86
+ }): AsyncResult<T, WebUsedBodyError | WebBodyDecodingError | JsonParseError<{
87
+ text: string;
88
+ }> | UnexpectedError>;
89
+ type CreateResponseParams = {
90
+ isOk: true;
91
+ inputs: {
92
+ requestMethod: ExtractFrom<HttpRequestMethod, "GET" | "QUERY" | "POST" | "TRACE">;
93
+ body: BodyInit;
94
+ status: keyof typeof HTTP_SUCCESSFUL_RESPONSE_STATUS_ENUM;
95
+ headers?: HeadersInit;
96
+ } | {
97
+ requestMethod: ExtractFrom<HttpRequestMethod, "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
98
+ body?: BodyInit;
99
+ status: keyof typeof HTTP_SUCCESSFUL_RESPONSE_STATUS_ENUM;
100
+ headers?: HeadersInit;
101
+ } | {
102
+ requestMethod: ExtractFrom<HttpRequestMethod, "HEAD" | "CONNECT">;
103
+ status: keyof typeof HTTP_SUCCESSFUL_RESPONSE_STATUS_ENUM;
104
+ headers?: HeadersInit;
105
+ };
106
+ } | {
107
+ isOk: false;
108
+ inputs: {
109
+ requestMethod: ExtractFrom<HttpRequestMethod, "HEAD">;
110
+ status: keyof typeof HTTP_ERROR_RESPONSE_STATUS_ENUM;
111
+ headers?: HeadersInit;
112
+ } | {
113
+ requestMethod: ExcludeFrom<HttpRequestMethod, "HEAD">;
114
+ body: BodyInit;
115
+ status: keyof typeof HTTP_ERROR_RESPONSE_STATUS_ENUM;
116
+ headers?: HeadersInit;
117
+ };
118
+ };
119
+ export declare function webCreateResponse({ isOk, inputs }: CreateResponseParams): any;
120
+ type CreateJsonResponseParams = {
121
+ isOk: true;
122
+ inputs: {
123
+ requestMethod: ExcludeFrom<HttpRequestMethod, "HEAD" | "CONNECT">;
124
+ data: JsonValue;
125
+ status: keyof typeof HTTP_SUCCESSFUL_RESPONSE_STATUS_ENUM;
126
+ headers?: Except<HeaderRecord, "Content-Type">;
127
+ };
128
+ } | {
129
+ isOk: false;
130
+ inputs: {
131
+ requestMethod: ExcludeFrom<HttpRequestMethod, "HEAD">;
132
+ data: JsonValue;
133
+ status: keyof typeof HTTP_ERROR_RESPONSE_STATUS_ENUM;
134
+ headers?: Except<HeaderRecord, "Content-Type">;
135
+ };
136
+ };
137
+ export declare function webCreateJsonResponse({ inputs }: CreateJsonResponseParams): any;
138
+ export declare function webCreateErrorResponse({ code, message, meta, status, headers }: {
139
+ code: string;
140
+ message: string;
141
+ meta: JsonValue;
142
+ status: keyof typeof HTTP_ERROR_RESPONSE_STATUS_ENUM;
143
+ headers?: Except<HeaderRecord, "Content-Type">;
144
+ }): any;
145
+ export declare function webReadArrayBufferResponseBody({ response }: {
146
+ response: Response;
147
+ }): Promise<import("@little-nebulae/result").Result<ArrayBuffer, UnexpectedError<unknown, null> | WebBodyDecodingError | WebBodySizeTooLargeError | WebUsedBodyError>>;
148
+ export declare function webReadBlobResponseBody({ response }: {
149
+ response: Response;
150
+ }): Promise<import("@little-nebulae/result").Result<import("node:buffer").Blob, UnexpectedError<unknown, null> | WebBodyDecodingError | WebUsedBodyError>>;
151
+ export declare function webReadBytesResponseBody({ response }: {
152
+ response: Response;
153
+ }): Promise<import("@little-nebulae/result").Result<Uint8Array<ArrayBufferLike>, UnexpectedError<unknown, null> | WebBodyDecodingError | WebBodySizeTooLargeError | WebUsedBodyError>>;
154
+ export declare function webReadTextResponseBody({ response }: {
155
+ response: Response;
156
+ }): Promise<import("@little-nebulae/result").Result<string, UnexpectedError<unknown, null> | WebBodyDecodingError | WebUsedBodyError>>;
157
+ export declare function webParseJsonResponseBody<T = unknown>({ response }: {
158
+ response: Response;
159
+ }): AsyncResult<T, WebUsedBodyError | WebBodyDecodingError | JsonParseError<{
160
+ text: string;
161
+ }> | UnexpectedError>;
162
+ export type { BodyInit, HeaderEntries, HeaderName, HeaderRecord, HeadersInit, RequestInfo };
package/dist/index.js CHANGED
@@ -1,115 +1,350 @@
1
- import { UnexpectedError, composeErrorMessage } from "@little-nebulae/error";
2
- import { fail, succeed } from "@little-nebulae/result";
3
- import { parseJsonString, stringifyJsonValue } from "@little-nebulae/json";
4
- //#region src/headers/create.ts
5
- function createHeaders(init) {
6
- return new Headers(init);
7
- }
8
- //#endregion
9
- //#region src/request/create/index.ts
10
- function createRequest({ url, method, headers, body }) {
11
- try {
12
- const request = new Request(url, {
13
- method,
14
- headers,
15
- body
1
+ import { BaseError, UnexpectedError, composeErrorMessage } from "@little-nebulae/error";
2
+ import { attempt, attemptAsync, fail } from "@little-nebulae/result";
3
+ import { HTTP_APPLICATION_MEDIA_TYPE_ENUM, HTTP_ERROR_RESPONSE_STATUS_ENUM, HTTP_HEADER_ENUM, HTTP_RESPONSE_STATUS_ENUM } from "@little-nebulae/http";
4
+ import { DEFAULT_JSON_STRINGIFY_SPACE, JsonParseError, jsonParse } from "@little-nebulae/json";
5
+ // src/errors/used-body.ts
6
+ var WebUsedBodyError = class extends BaseError {
7
+ name = "WebUsedBodyError";
8
+ code = "WEB_USED_BODY_ERROR";
9
+ constructor({ message, cause }) {
10
+ super({
11
+ message: message ?? cause.message,
12
+ cause,
13
+ meta: null
16
14
  });
17
- return succeed(request);
18
- } catch (error) {
19
- return fail(new UnexpectedError({
20
- message: composeErrorMessage({
21
- operation: "create web request",
22
- reason: "some unexpected error"
23
- }),
24
- cause: error,
15
+ }
16
+ };
17
+ // src/errors/body-decoding.ts
18
+ var WebBodyDecodingError = class extends BaseError {
19
+ name = "WebBodyDecodingError";
20
+ code = "WEB_BODY_DECODING_ERROR";
21
+ constructor({ message, cause, contentEncoding }) {
22
+ super({
23
+ message: message ?? cause.message,
24
+ cause,
25
+ meta: { contentEncoding }
26
+ });
27
+ }
28
+ };
29
+ // src/errors/body-size-too-large.ts
30
+ var WebBodySizeTooLargeError = class extends BaseError {
31
+ name = "WebBodySizeTooLargeError";
32
+ code = "WEB_BODY_SIZE_TOO_LARGE_ERROR";
33
+ constructor({ message, cause }) {
34
+ super({
35
+ message: message ?? cause.message,
36
+ cause,
25
37
  meta: null
26
- }));
38
+ });
27
39
  }
40
+ };
41
+ // src/headers/create.ts
42
+ function createHeaders(record) {
43
+ return new Headers(record);
44
+ }
45
+ // src/headers/get.ts
46
+ function getHeader({ headers, name }) {
47
+ return headers.get(name);
48
+ }
49
+ // src/headers/has.ts
50
+ function hasHeader({ headers, name }) {
51
+ return headers.has(name);
28
52
  }
29
- //#endregion
30
- //#region src/request/create/json.ts
31
- function createJsonRequest({ url, method, headers, body }) {
32
- return createRequest({
33
- url,
34
- method,
35
- headers,
36
- body: stringifyJsonValue({ value: body })
53
+ // src/headers/set.ts
54
+ function setHeader({ headers, name, value }) {
55
+ headers.set(name, value);
56
+ }
57
+ // src/request/create/index.ts
58
+ function webCreateRequest({ input, ...init }) {
59
+ return attempt({
60
+ tryFn: () => new Request(input, init),
61
+ catchFn: (error) => new UnexpectedError({
62
+ message: composeErrorMessage({ operation: "create a web request" }),
63
+ cause: error,
64
+ meta: null
65
+ })
37
66
  });
38
67
  }
39
- //#endregion
40
- //#region src/request/parse-body/text.ts
41
- async function parseTextRequestBody({ request }) {
42
- try {
43
- const text = await request.text();
44
- return succeed(text);
45
- } catch (error) {
46
- return fail(new UnexpectedError({
47
- message: composeErrorMessage({
48
- operation: "parse text request body",
49
- reason: "some unexpected error"
68
+ // src/request/create/json.ts
69
+ function webCreateJsonRequest({ input, data, headers, ...init }) {
70
+ return attempt({
71
+ tryFn: () => new Request(input, {
72
+ body: JSON.stringify(data, null, DEFAULT_JSON_STRINGIFY_SPACE),
73
+ headers: createHeaders({
74
+ "Content-Type": HTTP_APPLICATION_MEDIA_TYPE_ENUM.JSON,
75
+ ...headers
50
76
  }),
77
+ ...init
78
+ }),
79
+ catchFn: (error) => new UnexpectedError({
80
+ message: composeErrorMessage({ operation: "create a json web request" }),
51
81
  cause: error,
52
82
  meta: null
53
- }));
54
- }
83
+ })
84
+ });
55
85
  }
56
- //#endregion
57
- //#region src/request/parse-body/json.ts
58
- async function parseJsonRequestBody({ request }) {
59
- const parseTextResult = await parseTextRequestBody({ request });
60
- if (!parseTextResult.success) return parseTextResult;
61
- const text = parseTextResult.data;
62
- return parseJsonString(text);
63
- }
64
- //#endregion
65
- //#region src/response/parse-text-body.ts
66
- async function parseTextResponseBody({ response }) {
67
- try {
68
- const text = await response.text();
69
- return succeed(text);
70
- } catch (error) {
71
- return fail(new UnexpectedError({
72
- message: composeErrorMessage({
73
- operation: "parse text response body",
74
- reason: "some unexpected error"
75
- }),
86
+ // src/request/body/read/array-buffer.ts
87
+ async function webReadArrayBufferRequestBody({ request }) {
88
+ return attemptAsync({
89
+ tryFn: () => request.arrayBuffer(),
90
+ catchFn: (error) => {
91
+ if (error instanceof TypeError) {
92
+ if (request.bodyUsed) return new WebUsedBodyError({ cause: error });
93
+ return new WebBodyDecodingError({
94
+ cause: error,
95
+ contentEncoding: request.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
96
+ });
97
+ }
98
+ if (error instanceof RangeError) return new WebBodySizeTooLargeError({ cause: error });
99
+ return new UnexpectedError({
100
+ message: composeErrorMessage({ operation: "read array buffer request body" }),
101
+ cause: error,
102
+ meta: null
103
+ });
104
+ }
105
+ });
106
+ }
107
+ // src/request/body/read/blob.ts
108
+ async function webReadBlobRequestBody({ request }) {
109
+ return attemptAsync({
110
+ tryFn: () => request.blob(),
111
+ catchFn: (error) => {
112
+ if (error instanceof TypeError) {
113
+ if (request.bodyUsed) return new WebUsedBodyError({ cause: error });
114
+ return new WebBodyDecodingError({
115
+ cause: error,
116
+ contentEncoding: request.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
117
+ });
118
+ }
119
+ return new UnexpectedError({
120
+ message: composeErrorMessage({ operation: "read blob request body" }),
121
+ cause: error,
122
+ meta: null
123
+ });
124
+ }
125
+ });
126
+ }
127
+ // src/request/body/read/bytes.ts
128
+ async function webReadBytesRequestBody({ request }) {
129
+ return attemptAsync({
130
+ tryFn: () => request.bytes(),
131
+ catchFn: (error) => {
132
+ if (error instanceof TypeError) {
133
+ if (request.bodyUsed) return new WebUsedBodyError({ cause: error });
134
+ return new WebBodyDecodingError({
135
+ cause: error,
136
+ contentEncoding: request.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
137
+ });
138
+ }
139
+ if (error instanceof RangeError) return new WebBodySizeTooLargeError({ cause: error });
140
+ return new UnexpectedError({
141
+ message: composeErrorMessage({ operation: "read bytes request body" }),
142
+ cause: error,
143
+ meta: null
144
+ });
145
+ }
146
+ });
147
+ }
148
+ // src/request/body/read/text.ts
149
+ async function webReadTextRequestBody({ request }) {
150
+ return attemptAsync({
151
+ tryFn: () => request.text(),
152
+ catchFn: (error) => {
153
+ if (error instanceof TypeError) {
154
+ if (request.bodyUsed) return new WebUsedBodyError({ cause: error });
155
+ return new WebBodyDecodingError({
156
+ cause: error,
157
+ contentEncoding: request.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
158
+ });
159
+ }
160
+ return new UnexpectedError({
161
+ message: composeErrorMessage({ operation: "read text request body" }),
162
+ cause: error,
163
+ meta: null
164
+ });
165
+ }
166
+ });
167
+ }
168
+ // src/request/body/parse/json.ts
169
+ async function webParseJsonRequestBody({ request }) {
170
+ const readTextResult = await webReadTextRequestBody({ request });
171
+ if (!readTextResult.success) return readTextResult;
172
+ const text = readTextResult.data;
173
+ const jsonParseResult = jsonParse({ text });
174
+ if (jsonParseResult.success) return jsonParseResult;
175
+ return fail(new JsonParseError({
176
+ message: composeErrorMessage({
177
+ operation: "parse request body text",
178
+ reason: "the text being invalid JSON"
179
+ }),
180
+ cause: jsonParseResult.error.cause,
181
+ meta: { text }
182
+ }));
183
+ }
184
+ // src/response/create/index.ts
185
+ function webCreateResponse({ isOk, inputs }) {
186
+ return attempt({
187
+ tryFn: () => {
188
+ if (isOk) {
189
+ if (inputs.requestMethod === "GET" || inputs.requestMethod === "QUERY" || inputs.requestMethod === "POST" || inputs.requestMethod === "TRACE" || inputs.requestMethod === "PUT" || inputs.requestMethod === "PATCH" || inputs.requestMethod === "DELETE" || inputs.requestMethod === "OPTIONS") return new Response(inputs.body, {
190
+ status: HTTP_RESPONSE_STATUS_ENUM[inputs.status].CODE,
191
+ statusText: HTTP_RESPONSE_STATUS_ENUM[inputs.status].TEXT,
192
+ headers: inputs.headers ?? new Headers()
193
+ });
194
+ return new Response(void 0, {
195
+ status: HTTP_RESPONSE_STATUS_ENUM[inputs.status].CODE,
196
+ statusText: HTTP_RESPONSE_STATUS_ENUM[inputs.status].TEXT,
197
+ headers: inputs.headers ?? new Headers()
198
+ });
199
+ }
200
+ if (inputs.requestMethod !== "HEAD") return new Response(inputs.body, {
201
+ status: HTTP_RESPONSE_STATUS_ENUM[inputs.status].CODE,
202
+ statusText: HTTP_RESPONSE_STATUS_ENUM[inputs.status].TEXT,
203
+ headers: inputs.headers ?? new Headers()
204
+ });
205
+ return new Response(void 0, {
206
+ status: HTTP_RESPONSE_STATUS_ENUM[inputs.status].CODE,
207
+ statusText: HTTP_RESPONSE_STATUS_ENUM[inputs.status].TEXT,
208
+ headers: inputs.headers ?? new Headers()
209
+ });
210
+ },
211
+ catchFn: (error) => new UnexpectedError({
212
+ message: composeErrorMessage({ operation: "create a web response" }),
76
213
  cause: error,
77
214
  meta: null
78
- }));
79
- }
215
+ })
216
+ });
80
217
  }
81
- //#endregion
82
- //#region src/response/parse-json-body.ts
83
- async function parseJsonResponseBody({ response }) {
84
- const parseTextResult = await parseTextResponseBody({ response });
85
- if (!parseTextResult.success) return parseTextResult;
86
- const text = parseTextResult.data;
87
- return parseJsonString(text);
88
- }
89
- //#endregion
90
- //#region src/fetch/response.ts
91
- async function fetchResponse({ request }) {
92
- try {
93
- const response = await fetch(request);
94
- return succeed(response);
95
- } catch (error) {
96
- return fail(new UnexpectedError({
97
- message: composeErrorMessage({
98
- operation: "fetch response",
99
- reason: "some unexpected error"
100
- }),
218
+ // src/response/create/json.ts
219
+ function webCreateJsonResponse({ inputs }) {
220
+ return attempt({
221
+ tryFn: () => Response.json(inputs.data, {
222
+ status: HTTP_RESPONSE_STATUS_ENUM[inputs.status].CODE,
223
+ statusText: HTTP_RESPONSE_STATUS_ENUM[inputs.status].TEXT,
224
+ headers: inputs.headers ?? new Headers()
225
+ }),
226
+ catchFn: (error) => new UnexpectedError({
227
+ message: composeErrorMessage({ operation: "create a json web response" }),
101
228
  cause: error,
102
229
  meta: null
103
- }));
104
- }
230
+ })
231
+ });
232
+ }
233
+ // src/response/create/error.ts
234
+ function webCreateErrorResponse({ code, message, meta, status, headers }) {
235
+ return attempt({
236
+ tryFn: () => Response.json({
237
+ code,
238
+ message,
239
+ meta
240
+ }, {
241
+ status: HTTP_ERROR_RESPONSE_STATUS_ENUM[status].CODE,
242
+ statusText: HTTP_ERROR_RESPONSE_STATUS_ENUM[status].TEXT,
243
+ headers: headers ?? new Headers()
244
+ }),
245
+ catchFn: (error) => new UnexpectedError({
246
+ message: composeErrorMessage({ operation: "create a web error response" }),
247
+ cause: error,
248
+ meta: null
249
+ })
250
+ });
251
+ }
252
+ // src/response/body/read/array-buffer.ts
253
+ async function webReadArrayBufferResponseBody({ response }) {
254
+ return attemptAsync({
255
+ tryFn: () => response.arrayBuffer(),
256
+ catchFn: (error) => {
257
+ if (error instanceof TypeError) {
258
+ if (response.bodyUsed) return new WebUsedBodyError({ cause: error });
259
+ return new WebBodyDecodingError({
260
+ cause: error,
261
+ contentEncoding: response.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
262
+ });
263
+ }
264
+ if (error instanceof RangeError) return new WebBodySizeTooLargeError({ cause: error });
265
+ return new UnexpectedError({
266
+ message: composeErrorMessage({ operation: "read array buffer response body" }),
267
+ cause: error,
268
+ meta: null
269
+ });
270
+ }
271
+ });
272
+ }
273
+ // src/response/body/read/blob.ts
274
+ async function webReadBlobResponseBody({ response }) {
275
+ return attemptAsync({
276
+ tryFn: () => response.blob(),
277
+ catchFn: (error) => {
278
+ if (error instanceof TypeError) {
279
+ if (response.bodyUsed) return new WebUsedBodyError({ cause: error });
280
+ return new WebBodyDecodingError({
281
+ cause: error,
282
+ contentEncoding: response.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
283
+ });
284
+ }
285
+ return new UnexpectedError({
286
+ message: composeErrorMessage({ operation: "read blob response body" }),
287
+ cause: error,
288
+ meta: null
289
+ });
290
+ }
291
+ });
292
+ }
293
+ // src/response/body/read/bytes.ts
294
+ async function webReadBytesResponseBody({ response }) {
295
+ return attemptAsync({
296
+ tryFn: () => response.bytes(),
297
+ catchFn: (error) => {
298
+ if (error instanceof TypeError) {
299
+ if (response.bodyUsed) return new WebUsedBodyError({ cause: error });
300
+ return new WebBodyDecodingError({
301
+ cause: error,
302
+ contentEncoding: response.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
303
+ });
304
+ }
305
+ if (error instanceof RangeError) return new WebBodySizeTooLargeError({ cause: error });
306
+ return new UnexpectedError({
307
+ message: composeErrorMessage({ operation: "read bytes response body" }),
308
+ cause: error,
309
+ meta: null
310
+ });
311
+ }
312
+ });
313
+ }
314
+ // src/response/body/read/text.ts
315
+ async function webReadTextResponseBody({ response }) {
316
+ return attemptAsync({
317
+ tryFn: () => response.text(),
318
+ catchFn: (error) => {
319
+ if (error instanceof TypeError) {
320
+ if (response.bodyUsed) return new WebUsedBodyError({ cause: error });
321
+ return new WebBodyDecodingError({
322
+ cause: error,
323
+ contentEncoding: response.headers.get(HTTP_HEADER_ENUM.CONTENT_ENCODING)
324
+ });
325
+ }
326
+ return new UnexpectedError({
327
+ message: composeErrorMessage({ operation: "read text response body" }),
328
+ cause: error,
329
+ meta: null
330
+ });
331
+ }
332
+ });
105
333
  }
106
- //#endregion
107
- //#region src/fetch/json.ts
108
- async function fetchJson({ request }) {
109
- const fetchResponseResult = await fetchResponse({ request });
110
- if (!fetchResponseResult.success) return fetchResponseResult;
111
- const response = fetchResponseResult.data;
112
- return await parseJsonResponseBody({ response });
334
+ // src/response/body/parse/json.ts
335
+ async function webParseJsonResponseBody({ response }) {
336
+ const readTextResult = await webReadTextResponseBody({ response });
337
+ if (!readTextResult.success) return readTextResult;
338
+ const text = readTextResult.data;
339
+ const jsonParseResult = jsonParse({ text });
340
+ if (jsonParseResult.success) return jsonParseResult;
341
+ return fail(new JsonParseError({
342
+ message: composeErrorMessage({
343
+ operation: "parse response body text",
344
+ reason: "the text being invalid JSON"
345
+ }),
346
+ cause: jsonParseResult.error.cause,
347
+ meta: { text }
348
+ }));
113
349
  }
114
- //#endregion
115
- export { createHeaders, createJsonRequest, createRequest, fetchJson, fetchResponse, parseJsonRequestBody, parseJsonResponseBody, parseTextRequestBody, parseTextResponseBody };
350
+ export { WebBodyDecodingError, WebBodySizeTooLargeError, WebUsedBodyError, createHeaders, getHeader, hasHeader, setHeader, webCreateErrorResponse, webCreateJsonRequest, webCreateJsonResponse, webCreateRequest, webCreateResponse, webParseJsonRequestBody, webParseJsonResponseBody, webReadArrayBufferRequestBody, webReadArrayBufferResponseBody, webReadBlobRequestBody, webReadBlobResponseBody, webReadBytesRequestBody, webReadBytesResponseBody, webReadTextRequestBody, webReadTextResponseBody };
package/package.json CHANGED
@@ -1,51 +1,59 @@
1
1
  {
2
2
  "name": "@little-nebulae/web-fetch",
3
- "version": "0.2.0",
3
+ "version": "0.3.0",
4
4
  "license": "MIT",
5
5
  "files": [
6
6
  "dist"
7
7
  ],
8
8
  "type": "module",
9
+ "sideEffects": false,
9
10
  "exports": {
10
11
  ".": "./dist/index.js",
11
12
  "./package.json": "./package.json"
12
13
  },
14
+ "publishConfig": {
15
+ "access": "public",
16
+ "tag": "latest"
17
+ },
13
18
  "devDependencies": {
14
19
  "@arethetypeswrong/core": "0.18.5",
15
- "@little-nebulae/error": "1.1.0",
16
- "@little-nebulae/http": "0.1.0",
17
- "@little-nebulae/json": "0.1.0",
18
- "@little-nebulae/result": "1.0.0",
19
- "@little-nebulae/type-utils": "1.2.0",
20
- "@types/node": "26.6.2",
21
- "oxfmt": "0.70.0",
22
- "oxlint": "1.85.0",
23
- "oxlint-tsgolint": "7.0.2002",
24
- "publint": "0.3.24",
25
- "tsdown": "0.23.0",
26
- "tsx": "4.23.15",
27
- "typescript": "7.0.2",
28
- "vitest": "5.0.1",
29
- "zod": "4.6.5"
20
+ "@little-nebulae/error": "1.4.1",
21
+ "@little-nebulae/http": "0.4.0",
22
+ "@little-nebulae/json": "0.6.0",
23
+ "@little-nebulae/result": "1.4.0",
24
+ "@little-nebulae/utility-types": "0.4.0",
25
+ "@types/node": "26.6.6",
26
+ "oxfmt": "0.78.0",
27
+ "oxlint": "1.93.0",
28
+ "oxlint-tsgolint": "7.0.2007",
29
+ "publint": "0.3.25",
30
+ "tsdown": "0.23.7",
31
+ "type-fest": "5.10.0",
32
+ "typescript": "7.1.0-beta",
33
+ "vitest": "5.1.0"
30
34
  },
31
35
  "peerDependencies": {
32
36
  "@little-nebulae/error": "^1.0.0",
33
- "@little-nebulae/http": "^0.1.0",
34
- "@little-nebulae/json": "^0.1.0",
37
+ "@little-nebulae/http": "0",
38
+ "@little-nebulae/json": "0",
35
39
  "@little-nebulae/result": "^1.0.0",
36
- "@little-nebulae/type-utils": "^1.2.0",
37
- "zod": "^4.6.0"
40
+ "@little-nebulae/utility-types": "0",
41
+ "type-fest": "^5.0.0"
38
42
  },
39
43
  "devEngines": {
40
44
  "packageManager": {
41
45
  "name": "pnpm",
42
- "version": "12.6.0",
46
+ "version": "12.21.0",
47
+ "onFail": "warn"
48
+ },
49
+ "runtime": {
50
+ "name": "node",
51
+ "version": "26.13.1",
43
52
  "onFail": "warn"
44
53
  }
45
54
  },
46
55
  "scripts": {
47
56
  "build": "tsdown",
48
- "try": "tsx ./src/try.ts",
49
57
  "fmt": "oxfmt --disable-nested-config",
50
58
  "fmt:check": "oxfmt --check --disable-nested-config",
51
59
  "lint": "oxlint --disable-nested-config",