@wener/utils 1.1.51 → 1.1.54

package/src/fetch/dumpRequest.ts

@@ -1,55 +1,152 @@
-export function dumpRequest({
-  url,
-  req = {},
-  log = console.log,
+import { isTextContentType } from './isTextContentType';
+
+export async function dumpRequest({
+	url,
+	req,
+	method,
+	body,
+	log = console.log,
+	dumpBody: shouldDumpBody = true,
 }: {
-  url: string;
-  req?: RequestInit;
-  log?: (s: string) => void;
+	url?: string;
+	req?: RequestInit;
+	method?: string;
+	body?: any;
+	log?: (s: string) => void;
+	dumpBody?: boolean;
 }) {
-  const { method = 'GET' } = req;
-  let out = `-> ${method} ${url}
-${Array.from(new Headers(req.headers).entries())
-  .map(([k, v]) => `${k}: ${v}`)
-  .join('\n')}
-`;
-
-  let done: Promise<string> | undefined;
-  if (req.body) {
-    let hdr = new Headers(req.headers);
-    let ct = hdr.get('content-type');
-    if (ct === 'application/octet-stream') {
-      // skip
-    } else if (req.body instanceof ReadableStream) {
-      const [a, b] = req.body.tee();
-      req.body = a;
-      const signal = req.signal;
-      done = Promise.resolve().then(async () => {
-        const reader = b.getReader();
-        log(out);
-        while (true) {
-          if (signal?.aborted) {
-            break;
-          }
-
-          let { done, value } = await reader.read();
-          value instanceof Uint8Array && (value = new TextDecoder().decode(value));
-          out += value;
-          log(value);
-          if (!done) {
-            break;
-          }
-        }
-        // maybe for archive
-        out += `\n`;
-        return out;
-      });
-    } else {
-      out += `
-${req.body}
-`;
-    }
-    log(out);
-  }
-  return done || Promise.resolve(out);
+	const parts = ['->'];
+	const requestMethod = method || req?.method;
+	if (requestMethod) {
+		parts.push(requestMethod);
+	}
+	if (url) {
+		parts.push(url);
+	}
+
+	let out = `${parts.join(' ')}
+${Array.from(new Headers(req?.headers).entries())
+	.map(([k, v]) => `${k}: ${v}`)
+	.join('\n')}
+   `;
+
+	const shouldTee = !body;
+	body ??= req?.body;
+	if (shouldDumpBody && body) {
+		const contentType = new Headers(req?.headers).get('content-type') || '';
+
+		if (shouldTee && req?.body instanceof ReadableStream) {
+			const [previewStream, originalStream] = req.body.tee();
+			req.body = originalStream;
+			body = previewStream;
+		}
+
+		out += await dumpBodyContent({ body, contentType, canPreviewStream: shouldTee });
+	}
+
+	log(out);
+	return out;
+}
+
+export async function dumpBodyContent({
+	body,
+	contentType,
+	canPreviewStream = true,
+}: {
+	body?: any;
+	contentType?: string;
+	canPreviewStream?: boolean;
+}): Promise<string> {
+	if (!body) return '';
+
+	if (contentType === 'application/octet-stream') {
+		return `\n[Binary content not displayed: ${contentType}]\n`;
+	} else if (body instanceof ReadableStream) {
+		if (!canPreviewStream) {
+			return `\n[ReadableStream - cannot preview external stream]\n`;
+		}
+
+		// Try to preview ReadableStream content safely
+		try {
+			const reader = body.getReader();
+			let previewedBytes = 0;
+			const maxPreviewSize = 1024; // 1KB preview limit
+			let previewContent = '';
+			let wasTruncated = false;
+
+			while (previewedBytes < maxPreviewSize) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				if (value instanceof Uint8Array) {
+					// Check if adding this chunk would exceed the limit
+					if (previewedBytes + value.length > maxPreviewSize) {
+						const remainingBytes = maxPreviewSize - previewedBytes;
+						const truncatedValue = value.slice(0, remainingBytes);
+						const decoded = new TextDecoder('utf-8', { fatal: false }).decode(truncatedValue);
+						previewContent += decoded;
+						wasTruncated = true;
+						break;
+					}
+
+					const decoded = new TextDecoder('utf-8', { fatal: false }).decode(value);
+					previewContent += decoded;
+					previewedBytes += value.length;
+				} else {
+					const strValue = String(value);
+					if (previewedBytes + strValue.length > maxPreviewSize) {
+						const remainingChars = maxPreviewSize - previewedBytes;
+						previewContent += strValue.slice(0, remainingChars);
+						wasTruncated = true;
+						break;
+					}
+
+					previewContent += strValue;
+					previewedBytes += strValue.length;
+				}
+			}
+
+			// If we exited the loop without hitting done, we were truncated
+			if (!wasTruncated && previewedBytes >= maxPreviewSize) {
+				wasTruncated = true;
+			}
+
+			let result = `\n${previewContent}`;
+			if (wasTruncated) {
+				result += `\n[... truncated]\n`;
+			} else {
+				result += `\n`;
+			}
+
+			reader.releaseLock();
+			return result;
+		} catch (error) {
+			return `\n[Error reading stream: ${error}]\n`;
+		}
+	} else if (body instanceof FormData) {
+		let result = `\n[FormData content]\n`;
+		try {
+			for (const [key, value] of body.entries()) {
+				if (typeof value === 'string') {
+					result += `${key}: ${value}\n`;
+				} else {
+					result += `${key}: [File: ${value.name || 'unknown'}]\n`;
+				}
+			}
+			return result;
+		} catch (error) {
+			return result + `[Error reading FormData: ${error}]\n`;
+		}
+	} else if (body instanceof URLSearchParams) {
+		return `\n${body.toString()}\n`;
+	} else if (isTextContentType(contentType || '') || typeof body === 'string') {
+		try {
+			const bodyContent = typeof body === 'string' ? body : String(body);
+			return `\n${bodyContent}\n`;
+		} catch (error) {
+			return `\n[Error reading request body: ${error}]\n`;
+		}
+	} else {
+		return `\n[Non-text content: ${typeof body}]\n`;
+	}
 }

package/src/fetch/dumpResponse.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it, vi } from 'vitest';
+import { dumpResponse } from './dumpResponse';
+
+describe('dumpResponse', () => {
+	const NETWORK_TIMEOUT = 15000;
+
+	it(
+		'should dump JSON response with all parameters',
+		async () => {
+			const logSpy = vi.fn();
+
+			const response = await fetch('https://httpbin.org/json');
+			const result = await dumpResponse({
+				res: response,
+				url: 'https://httpbin.org/json',
+				method: 'GET',
+				log: logSpy,
+				dumpBody: true,
+			});
+
+			expect(logSpy).toHaveBeenCalledOnce();
+			const loggedOutput = logSpy.mock.calls[0][0];
+
+			// Check basic format
+			expect(loggedOutput).toContain('<- 200 OK GET https://httpbin.org/json');
+			expect(loggedOutput).toContain('content-type: application/json');
+			expect(loggedOutput).toContain('slideshow');
+
+			// Should return original response
+			expect(result).toBe(response);
+		},
+		NETWORK_TIMEOUT,
+	);
+
+	it(
+		'should work with minimal parameters',
+		async () => {
+			const logSpy = vi.fn();
+
+			const response = await fetch('https://httpbin.org/status/204');
+			await dumpResponse({
+				res: response,
+				log: logSpy,
+			});
+
+			const loggedOutput = logSpy.mock.calls[0][0];
+
+			// Should only show status without method/url (HTTPBin uses uppercase)
+			expect(loggedOutput).toContain('<- 204');
+			expect(loggedOutput).not.toContain('GET');
+			expect(loggedOutput).not.toContain('https://');
+		},
+		NETWORK_TIMEOUT,
+	);
+
+	it('should handle binary content', async () => {
+		const logSpy = vi.fn();
+
+		// Create a mock response with binary content
+		const response = new Response(new Uint8Array([1, 2, 3]), {
+			status: 200,
+			statusText: 'OK',
+			headers: { 'content-type': 'application/octet-stream' },
+		});
+
+		await dumpResponse({
+			res: response,
+			url: 'https://example.com/binary',
+			method: 'GET',
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		expect(loggedOutput).toContain('<- 200 OK GET https://example.com/binary');
+		expect(loggedOutput).toContain('[Binary content not displayed: application/octet-stream]');
+	});
+
+	it(
+		'should preserve original response after dumping',
+		async () => {
+			const response = await fetch('https://httpbin.org/json');
+
+			const result = await dumpResponse({
+				res: response,
+				dumpBody: true,
+			});
+
+			// Original response should still be readable
+			const data = await result.json();
+			expect(data.slideshow).toBeDefined();
+		},
+		NETWORK_TIMEOUT,
+	);
+
+	it('should handle dumpBody false with mock response', async () => {
+		const logSpy = vi.fn();
+
+		const response = new Response('{"test": true}', {
+			status: 200,
+			statusText: 'OK',
+			headers: { 'content-type': 'application/json' },
+		});
+
+		await dumpResponse({
+			res: response,
+			url: 'https://example.com/test',
+			method: 'POST',
+			log: logSpy,
+			dumpBody: false,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+
+		// Should not contain body content
+		expect(loggedOutput).toContain('<- 200 OK POST https://example.com/test');
+		expect(loggedOutput).toContain('content-type: application/json');
+		expect(loggedOutput).not.toContain('{"test": true}');
+	});
+
+	it('should handle req.method fallback', async () => {
+		const logSpy = vi.fn();
+
+		const response = new Response('success', {
+			status: 200,
+			statusText: 'OK',
+			headers: { 'content-type': 'text/plain' },
+		});
+
+		await dumpResponse({
+			res: response,
+			req: { method: 'PUT' },
+			url: 'https://example.com/test',
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+		expect(loggedOutput).toContain('<- 200 OK PUT https://example.com/test');
+	});
+
+	it('should handle method parameter override', async () => {
+		const logSpy = vi.fn();
+
+		const response = new Response('success', {
+			status: 201,
+			statusText: 'Created',
+		});
+
+		await dumpResponse({
+			res: response,
+			req: { method: 'POST' },
+			method: 'PATCH', // should override req.method
+			url: 'https://example.com/test',
+			log: logSpy,
+		});
+
+		const loggedOutput = logSpy.mock.calls[0][0];
+		expect(loggedOutput).toContain('<- 201 Created PATCH https://example.com/test');
+	});
+});

package/src/fetch/dumpResponse.ts

@@ -1,28 +1,56 @@
+import { isTextContentType } from './isTextContentType';
+
 export async function dumpResponse({
-  res,
-  url,
-  req,
-  log = console.log,
+	res,
+	url,
+	req,
+	method,
+	log = console.log,
+	dumpBody = true,
+	clone = dumpBody,
 }: {
-  res: Response;
-  url: string;
-  req: RequestInit;
-  log?: (s: string) => void;
+	res: Response;
+	url?: string;
+	req?: RequestInit;
+	method?: string;
+	log?: (s: string) => void;
+	dumpBody?: boolean;
+	clone?: boolean;
 }) {
-  let out = `<- ${res.status} ${res.statusText} ${req.method} ${url}
+	const shouldClone = clone || dumpBody;
+	const responseToProcess = shouldClone ? res.clone() : res;
+
+	const parts = [`<- ${res.status} ${res.statusText}`];
+	const requestMethod = method || req?.method;
+	if (requestMethod) {
+		parts.push(requestMethod);
+	}
+	if (url) {
+		parts.push(url);
+	}
+
+	let out = `${parts.join(' ')}
 ${Array.from(res.headers.entries())
-  .map(([k, v]) => `${k}: ${v}`)
-  .join('\n')}
+	.map(([k, v]) => `${k}: ${v}`)
+	.join('\n')}
    `;
-  let contentType = res.headers.get('content-type');
-  // TODO text/event-stream
-  if (contentType?.includes('application/json') || contentType?.includes('text/plain')) {
-    const body = await res.text();
-    out += `\n${body}\n`;
-    res = new Response(body, res);
-  }
 
-  log(out);
+	if (dumpBody) {
+		const ct = res.headers.get('content-type') || '';
+
+		if (isTextContentType(ct)) {
+			try {
+				const responseBody = await responseToProcess.text();
+				out += `\n${responseBody}\n`;
+			} catch (error) {
+				out += `\n[Error reading response body: ${error}]\n`;
+			}
+		} else {
+			out += `\n[Binary content not displayed: ${ct}]\n`;
+		}
+	}
+
+	log(out);
 
-  return res;
+	return res;
 }

package/src/fetch/http.types.ts

@@ -5,42 +5,42 @@ export type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 |
 export type DeprecatedStatusCode = 305 | 306;
 export type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
 export type ClientErrorStatusCode =
-  | 400
-  | 401
-  | 402
-  | 403
-  | 404
-  | 405
-  | 406
-  | 407
-  | 408
-  | 409
-  | 410
-  | 411
-  | 412
-  | 413
-  | 414
-  | 415
-  | 416
-  | 417
-  | 418
-  | 421
-  | 422
-  | 423
-  | 424
-  | 425
-  | 426
-  | 428
-  | 429
-  | 431
-  | 451;
+	| 400
+	| 401
+	| 402
+	| 403
+	| 404
+	| 405
+	| 406
+	| 407
+	| 408
+	| 409
+	| 410
+	| 411
+	| 412
+	| 413
+	| 414
+	| 415
+	| 416
+	| 417
+	| 418
+	| 421
+	| 422
+	| 423
+	| 424
+	| 425
+	| 426
+	| 428
+	| 429
+	| 431
+	| 451;
 export type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
 
 export type UnofficialStatusCode = -1;
 export type StatusCode =
-  | InfoStatusCode
-  | SuccessStatusCode
-  | RedirectStatusCode
-  | ClientErrorStatusCode
-  | ServerErrorStatusCode
-  | UnofficialStatusCode;
+	| InfoStatusCode
+	| SuccessStatusCode
+	| RedirectStatusCode
+	| ClientErrorStatusCode
+	| ServerErrorStatusCode
+	| UnofficialStatusCode;

package/src/fetch/isTextContentType.ts

@@ -0,0 +1,12 @@
+/**
+ * Check if the content type represents text content that can be safely displayed
+ */
+export function isTextContentType(contentType: string): boolean {
+	return (
+		contentType.includes('application/json')
+		|| contentType.includes('text/')
+		|| contentType.includes('application/xml')
+		|| contentType.includes('application/javascript')
+		|| contentType.includes('application/x-www-form-urlencoded')
+	);
+}

package/src/fetch/resolveRequest.ts

@@ -0,0 +1 @@
+export function resolveRequest({}: {}) {}

package/src/fetch/types.ts

@@ -1,4 +1,4 @@
 export type FetchLike<R extends RequestInit = RequestInit> = (
-  url: string | URL | Request,
-  init?: R,
+	url: string | URL | Request,
+	init?: R,
 ) => Promise<Response>;