@wener/utils 1.1.50 → 1.1.53

package/src/fetch/HttpStatus.ts

@@ -1,80 +1,80 @@
 // http://httpstat.us/
 // https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
 const HttpStatus: Record<string, string> = {
-  100: 'Continue',
-  101: 'Switching Protocols',
-  102: 'Processing',
-  103: 'Early Hints',
-  200: 'OK',
-  201: 'Created',
-  202: 'Accepted',
-  203: 'Non-Authoritative Information',
-  204: 'No Content',
-  205: 'Reset Content',
-  206: 'Partial Content',
-  207: 'Multi-Status',
-  208: 'Already Reported',
-  226: 'IM Used',
-  300: 'Multiple Choices',
-  301: 'Moved Permanently',
-  302: 'Found',
-  303: 'See Other',
-  304: 'Not Modified',
-  305: 'Use Proxy',
-  306: 'Unused',
-  307: 'Temporary Redirect',
-  308: 'Permanent Redirect',
+	100: 'Continue',
+	101: 'Switching Protocols',
+	102: 'Processing',
+	103: 'Early Hints',
+	200: 'OK',
+	201: 'Created',
+	202: 'Accepted',
+	203: 'Non-Authoritative Information',
+	204: 'No Content',
+	205: 'Reset Content',
+	206: 'Partial Content',
+	207: 'Multi-Status',
+	208: 'Already Reported',
+	226: 'IM Used',
+	300: 'Multiple Choices',
+	301: 'Moved Permanently',
+	302: 'Found',
+	303: 'See Other',
+	304: 'Not Modified',
+	305: 'Use Proxy',
+	306: 'Unused',
+	307: 'Temporary Redirect',
+	308: 'Permanent Redirect',
 
-  400: 'Bad Request',
-  401: 'Unauthorized',
-  402: 'Payment Required',
-  403: 'Forbidden',
-  404: 'Not Found',
-  405: 'Method Not Allowed',
-  406: 'Not Acceptable',
-  407: 'Proxy Authentication Required',
-  408: 'Request Timeout',
-  409: 'Conflict',
-  410: 'Gone',
-  411: 'Length Required',
-  412: 'Precondition Required',
-  413: 'Request Entry Too Large',
-  414: 'Request-URI Too Long',
-  415: 'Unsupported Media Type',
-  416: 'Requested Range Not Satisfiable',
-  417: 'Expectation Failed',
-  418: "I'm a teapot",
-  421: 'Misdirected Request',
-  422: 'Unprocessable Entity',
-  423: 'Locked',
-  424: 'Failed Dependency',
-  425: 'Too Early',
-  426: 'Upgrade Required',
-  428: 'Precondition Required',
-  429: 'Too Many Requests',
-  431: 'Request Header Fields Too Large',
-  451: 'Unavailable For Legal Reasons',
-  500: 'Internal Server Error',
-  501: 'Not Implemented',
-  502: 'Bad Gateway',
-  503: 'Service Unavailable',
-  504: 'Gateway Timeout',
-  505: 'HTTP Version Not Supported',
-  506: 'Variant Also Negotiates',
-  507: 'Insufficient Storage',
-  508: 'Loop Detected',
-  509: 'Bandwidth Limit Exceeded',
-  510: 'Not Extended',
-  511: 'Network Authentication Required',
+	400: 'Bad Request',
+	401: 'Unauthorized',
+	402: 'Payment Required',
+	403: 'Forbidden',
+	404: 'Not Found',
+	405: 'Method Not Allowed',
+	406: 'Not Acceptable',
+	407: 'Proxy Authentication Required',
+	408: 'Request Timeout',
+	409: 'Conflict',
+	410: 'Gone',
+	411: 'Length Required',
+	412: 'Precondition Required',
+	413: 'Request Entry Too Large',
+	414: 'Request-URI Too Long',
+	415: 'Unsupported Media Type',
+	416: 'Requested Range Not Satisfiable',
+	417: 'Expectation Failed',
+	418: "I'm a teapot",
+	421: 'Misdirected Request',
+	422: 'Unprocessable Entity',
+	423: 'Locked',
+	424: 'Failed Dependency',
+	425: 'Too Early',
+	426: 'Upgrade Required',
+	428: 'Precondition Required',
+	429: 'Too Many Requests',
+	431: 'Request Header Fields Too Large',
+	451: 'Unavailable For Legal Reasons',
+	500: 'Internal Server Error',
+	501: 'Not Implemented',
+	502: 'Bad Gateway',
+	503: 'Service Unavailable',
+	504: 'Gateway Timeout',
+	505: 'HTTP Version Not Supported',
+	506: 'Variant Also Negotiates',
+	507: 'Insufficient Storage',
+	508: 'Loop Detected',
+	509: 'Bandwidth Limit Exceeded',
+	510: 'Not Extended',
+	511: 'Network Authentication Required',
 };
 
 export function getHttpStatusText(status: number | string): string | undefined {
-  return HttpStatus[status];
+	return HttpStatus[status];
 }
 
 export function isRetryableHttpStatus(status: number) {
-  switch (status) {
-    /*
+	switch (status) {
+		/*
 408 Request Timeout
 425 Too Early
 429 Too Many Requests
@@ -83,14 +83,14 @@ export function isRetryableHttpStatus(status: number) {
 503 Service Unavailable
 504 Gateway Timeout
      */
-    case 408:
-    case 425:
-    case 429:
-    case 502:
-    case 503:
-    case 504:
-      return true;
-    default:
-      return false;
-  }
+		case 408:
+		case 425:
+		case 429:
+		case 502:
+		case 503:
+		case 504:
+			return true;
+		default:
+			return false;
+	}
 }

package/src/fetch/createFetchWith.ts

@@ -1,33 +1,33 @@
 import type { MaybePromise } from '../asyncs/MaybePromise';
-import { getGlobalThis } from '../runtime/getGlobalThis';
-import { type FetchLike } from './types';
+import { getGlobalThis } from '../web/getGlobalThis';
+import type { FetchLike } from './types';
 
 export function createFetchWith({
-  fetch = getGlobalThis().fetch,
-  onRequest = (ctx) => ctx.next(ctx.url, ctx.req),
-  onResponse = (ctx) => ctx.res,
+	fetch = getGlobalThis().fetch,
+	onRequest = (ctx) => ctx.next(ctx.url, ctx.req),
+	onResponse = (ctx) => ctx.res,
 }: {
-  fetch?: FetchLike;
-  onRequest?: (ctx: {
-    url: string;
-    req: RequestInit;
-    next: (url: string, req: RequestInit) => Promise<Response>;
-  }) => MaybePromise<Response | void>;
-  onResponse?: (ctx: { url: string; req: RequestInit; res: Response }) => MaybePromise<Response>;
+	fetch?: FetchLike;
+	onRequest?: (ctx: {
+		url: string;
+		req: RequestInit;
+		next: (url: string, req: RequestInit) => Promise<Response>;
+	}) => MaybePromise<Response | void>;
+	onResponse?: (ctx: { url: string; req: RequestInit; res: Response }) => MaybePromise<Response>;
 }) {
-  return async (urlOrRequest: string | URL | Request, init?: RequestInit & { fetch?: FetchLike }) => {
-    const url = String(urlOrRequest);
-    let req = init || {};
-    const nextFetch = req.fetch || fetch;
-    const res =
-      (await onRequest({
-        url,
-        req,
-        next: (url, init) => {
-          req = init;
-          return nextFetch(url, init);
-        },
-      })) ?? (await nextFetch(url, init));
-    return onResponse({ url, req, res });
-  };
+	return async (urlOrRequest: string | URL | Request, init?: RequestInit & { fetch?: FetchLike }) => {
+		const url = String(urlOrRequest);
+		let req = init || {};
+		const nextFetch = req.fetch || fetch;
+		const res =
+			(await onRequest({
+				url,
+				req,
+				next: (url, init) => {
+					req = init;
+					return nextFetch(url, init);
+				},
+			})) ?? (await nextFetch(url, init));
+		return onResponse({ url, req, res });
+	};
 }

package/src/fetch/createFetchWithLogging.ts

@@ -1,22 +1,19 @@
 import { createFetchWith } from './createFetchWith';
 import { dumpRequest } from './dumpRequest';
 import { dumpResponse } from './dumpResponse';
-import { type FetchLike } from './types';
+import type { FetchLike } from './types';
 
 export function createFetchWithLogging({
-  fetch,
-  log = console.log,
-}: {
-  fetch?: FetchLike;
-  log?: (s: string) => void;
-} = {}): FetchLike {
-  return createFetchWith({
-    fetch,
-    onRequest: ({ url, req }) => {
-      void dumpRequest({ url, req, log });
-    },
-    onResponse: ({ url, req, res }) => {
-      return dumpResponse({ url, req, res, log });
-    },
-  });
+	fetch,
+	log = console.log,
+}: { fetch?: FetchLike; log?: (s: string) => void } = {}): FetchLike {
+	return createFetchWith({
+		fetch,
+		onRequest: ({ url, req }) => {
+			void dumpRequest({ url, req, log });
+		},
+		onResponse: ({ url, req, res }) => {
+			return dumpResponse({ url, req, res, log });
+		},
+	});
 }

package/src/fetch/createFetchWithRetry.ts

@@ -1,95 +1,95 @@
-import { getGlobalThis } from '../runtime/getGlobalThis';
+import { getGlobalThis } from '../web/getGlobalThis';
 import type { FetchLike } from './types';
 
 type RequestDelayFunction = (attempt: number, error: Error | null, response: Response | null) => number;
 type RequestRetryOnFunction = (
-  attempt: number,
-  error: Error | null,
-  response: Response | null,
+	attempt: number,
+	error: Error | null,
+	response: Response | null,
 ) => boolean | Promise<boolean>;
 
 export interface FetchWithRetryOptions {
-  fetch?: FetchLike;
-  retries?: number;
-  retryDelay?: number | RequestDelayFunction;
-  retryOn?: number[] | RequestRetryOnFunction;
+	fetch?: FetchLike;
+	retries?: number;
+	retryDelay?: number | RequestDelayFunction;
+	retryOn?: number[] | RequestRetryOnFunction;
 }
 
 export function createFetchWithRetry({
-  fetch = getGlobalThis().fetch,
-  retries = 3,
-  retryDelay = 1000,
-  retryOn = [],
+	fetch = getGlobalThis().fetch,
+	retries = 3,
+	retryDelay = 1000,
+	retryOn = [],
 }: FetchWithRetryOptions = {}): FetchLike {
-  // https://github.com/jonbern/fetch-retry/blob/master/index.js
+	// https://github.com/jonbern/fetch-retry/blob/master/index.js
 
-  return function fetchRetry(input: string | URL | Request, init?: RequestInit) {
-    return new Promise(function (resolve, reject) {
-      var wrappedFetch = function (attempt: number) {
-        // As of node 18, this is no longer needed since node comes with native support for fetch:
-        /* istanbul ignore next */
-        var _input = typeof Request !== 'undefined' && input instanceof Request ? input.clone() : input;
-        fetch(_input, init)
-          .then(function (response) {
-            if (Array.isArray(retryOn) && retryOn.indexOf(response.status) === -1) {
-              resolve(response);
-            } else if (typeof retryOn === 'function') {
-              try {
-                return Promise.resolve(retryOn(attempt, null, response))
-                  .then(function (retryOnResponse) {
-                    if (retryOnResponse) {
-                      retry(attempt, null, response);
-                    } else {
-                      resolve(response);
-                    }
-                  })
-                  .catch(reject);
-              } catch (error) {
-                reject(error);
-              }
-            } else {
-              if (attempt < retries) {
-                retry(attempt, null, response);
-              } else {
-                resolve(response);
-              }
-            }
-            return;
-          })
-          .catch(function (error) {
-            if (typeof retryOn === 'function') {
-              try {
-                // eslint-disable-next-line no-undef
-                Promise.resolve(retryOn(attempt, error, null))
-                  .then(function (retryOnResponse) {
-                    if (retryOnResponse) {
-                      retry(attempt, error, null);
-                    } else {
-                      reject(error);
-                    }
-                  })
-                  .catch(function (error) {
-                    reject(error);
-                  });
-              } catch (error) {
-                reject(error);
-              }
-            } else if (attempt < retries) {
-              retry(attempt, error, null);
-            } else {
-              reject(error);
-            }
-          });
-      };
+	return function fetchRetry(input: string | URL | Request, init?: RequestInit) {
+		return new Promise(function (resolve, reject) {
+			var wrappedFetch = function (attempt: number) {
+				// As of node 18, this is no longer needed since node comes with native support for fetch:
+				/* istanbul ignore next */
+				var _input = typeof Request !== 'undefined' && input instanceof Request ? input.clone() : input;
+				fetch(_input, init)
+					.then(function (response) {
+						if (Array.isArray(retryOn) && retryOn.indexOf(response.status) === -1) {
+							resolve(response);
+						} else if (typeof retryOn === 'function') {
+							try {
+								return Promise.resolve(retryOn(attempt, null, response))
+									.then(function (retryOnResponse) {
+										if (retryOnResponse) {
+											retry(attempt, null, response);
+										} else {
+											resolve(response);
+										}
+									})
+									.catch(reject);
+							} catch (error) {
+								reject(error);
+							}
+						} else {
+							if (attempt < retries) {
+								retry(attempt, null, response);
+							} else {
+								resolve(response);
+							}
+						}
+						return;
+					})
+					.catch(function (error) {
+						if (typeof retryOn === 'function') {
+							try {
+								// eslint-disable-next-line no-undef
+								Promise.resolve(retryOn(attempt, error, null))
+									.then(function (retryOnResponse) {
+										if (retryOnResponse) {
+											retry(attempt, error, null);
+										} else {
+											reject(error);
+										}
+									})
+									.catch(function (error) {
+										reject(error);
+									});
+							} catch (error) {
+								reject(error);
+							}
+						} else if (attempt < retries) {
+							retry(attempt, error, null);
+						} else {
+							reject(error);
+						}
+					});
+			};
 
-      function retry(attempt: number, error: any, response: Response | null) {
-        let delay = typeof retryDelay === 'function' ? retryDelay(attempt, error, response) : retryDelay;
-        setTimeout(function () {
-          wrappedFetch(++attempt);
-        }, delay);
-      }
+			function retry(attempt: number, error: any, response: Response | null) {
+				let delay = typeof retryDelay === 'function' ? retryDelay(attempt, error, response) : retryDelay;
+				setTimeout(function () {
+					wrappedFetch(++attempt);
+				}, delay);
+			}
 
-      wrappedFetch(0);
-    });
-  };
+			wrappedFetch(0);
+		});
+	};
 }

package/src/fetch/dumpRequest.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it, vi } from 'vitest';
+import { dumpRequest } from './dumpRequest';
+
+describe('dumpRequest', () => {
+	it('should preview ReadableStream content with size limit', async () => {
+		const logSpy = vi.fn();
+
+		// Create a ReadableStream with text content
+		const encoder = new TextEncoder();
+		const stream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode('{"message": "hello"}'));
+				controller.close();
+			},
+		});
+
+		await dumpRequest({
+			url: 'https://api.example.com/test',
+			req: {
+				method: 'POST',
+				body: stream,
+				headers: { 'content-type': 'application/json' },
+			},
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('-> POST https://api.example.com/test');
+		expect(loggedOutput).toContain('{"message": "hello"}');
+		expect(loggedOutput).not.toContain('[... truncated]');
+	});
+
+	it('should truncate large ReadableStream content', async () => {
+		const logSpy = vi.fn();
+
+		// Create a large stream that exceeds preview limit
+		const encoder = new TextEncoder();
+		const largeData = 'x'.repeat(2000); // 2KB, exceeds 1KB limit
+
+		const stream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode(largeData));
+				controller.close();
+			},
+		});
+
+		await dumpRequest({
+			url: 'https://api.example.com/large',
+			req: {
+				method: 'POST',
+				body: stream,
+			},
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('-> POST https://api.example.com/large');
+		expect(loggedOutput).toContain('[... truncated]');
+		// Should contain some 'x' characters but not all 2000
+		expect(loggedOutput).toContain('xxx');
+		expect(loggedOutput.length).toBeLessThan(2500); // Much less than full content
+	});
+
+	it('should handle FormData correctly', async () => {
+		const logSpy = vi.fn();
+
+		const formData = new FormData();
+		formData.append('username', 'john');
+		formData.append('email', 'john@example.com');
+
+		await dumpRequest({
+			url: 'https://api.example.com/form',
+			req: {
+				method: 'POST',
+				body: formData,
+			},
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('-> POST https://api.example.com/form');
+		expect(loggedOutput).toContain('[FormData content]');
+		expect(loggedOutput).toContain('username: john');
+		expect(loggedOutput).toContain('email: john@example.com');
+	});
+
+	it('should use optional body parameter instead of req.body to avoid tee-ing', async () => {
+		const logSpy = vi.fn();
+
+		// Create a ReadableStream that we want to preserve
+		const encoder = new TextEncoder();
+		const originalStream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode('{"original": "data"}'));
+				controller.close();
+			},
+		});
+
+		// Pass separate body to display without affecting original stream
+		const displayBody = '{"display": "body"}';
+
+		await dumpRequest({
+			url: 'https://api.example.com/preserve',
+			req: {
+				method: 'POST',
+				body: originalStream,
+				headers: { 'content-type': 'application/json' },
+			},
+			body: displayBody, // This should be displayed instead
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('-> POST https://api.example.com/preserve');
+		expect(loggedOutput).toContain('{"display": "body"}');
+		expect(loggedOutput).not.toContain('{"original": "data"}');
+
+		// Verify original stream is still readable (not tee'd)
+		const reader = originalStream.getReader();
+		const { value } = await reader.read();
+		const decoded = new TextDecoder().decode(value);
+		expect(decoded).toBe('{"original": "data"}');
+	});
+
+	it('should handle external ReadableStream in body parameter', async () => {
+		const logSpy = vi.fn();
+
+		// Create a ReadableStream to pass as body parameter
+		const encoder = new TextEncoder();
+		const externalStream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(encoder.encode('external stream data'));
+				controller.close();
+			},
+		});
+
+		await dumpRequest({
+			url: 'https://api.example.com/external',
+			req: {
+				method: 'POST',
+				headers: { 'content-type': 'application/json' },
+			},
+			body: externalStream,
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('-> POST https://api.example.com/external');
+		expect(loggedOutput).toContain('[ReadableStream - cannot preview external stream]');
+	});
+
+	it('should handle string body parameter', async () => {
+		const logSpy = vi.fn();
+
+		await dumpRequest({
+			url: 'https://api.example.com/string',
+			req: {
+				method: 'POST',
+				headers: { 'content-type': 'application/json' },
+			},
+			body: '{"custom": "body"}',
+			method: 'PATCH', // Test method override too
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('-> PATCH https://api.example.com/string');
+		expect(loggedOutput).toContain('{"custom": "body"}');
+	});
+});