easier-http-request 0.1.0

package/dist/utilities/Utilities.js

@@ -0,0 +1,110 @@
+import { Timer } from './Timer.js';
+export function writeToStderr(message) {
+    process.stderr.write(message);
+}
+export function logToStderr(message) {
+    writeToStderr(message);
+    writeToStderr('\n');
+}
+export function formatIntegerWithLeadingZeros(num, minDigitCount) {
+    num = Math.floor(num);
+    let numAsString = `${num}`;
+    while (numAsString.length < minDigitCount) {
+        numAsString = `0${numAsString}`;
+    }
+    return numAsString;
+}
+export function roundToDigits(val, digits = 3) {
+    const multiplier = 10 ** digits;
+    return Math.round(val * multiplier) / multiplier;
+}
+export function sleep(timeMs) {
+    const timer = new Timer();
+    return new Promise((resolve) => {
+        const tickCallback = () => {
+            if (timer.elapsedTime < timeMs) {
+                //setImmediate(tickCallback)
+                setTimeout(tickCallback, 0);
+            }
+            else {
+                resolve();
+            }
+        };
+        //setImmediate(tickCallback)
+        setTimeout(tickCallback, 0);
+    });
+}
+export function parseUrlOrPath(inputString, baseUrl = 'https://dummy.com') {
+    try {
+        // Attempt 1: Try parsing as an absolute URL
+        const url = new URL(inputString);
+        return url;
+    }
+    catch (error) {
+        // If it failed, it's likely a relative URL.
+        // Attempt 2: Try parsing with a base URL.
+        // The base URL can be a real one (e.g., your server's origin)
+        // or a dummy one if you only care about path/query/hash.
+        try {
+            const url = new URL(inputString, baseUrl);
+            return url;
+        }
+        catch (relativeError) {
+            // If it fails even with a base, it's truly malformed or unparseable.
+            throw new Error(`Failed to parse URL '${inputString}' even with base '${baseUrl}': ${relativeError.message}`);
+        }
+    }
+}
+export function getDomainName(url) {
+    try {
+        const hostname = (new URL(url)).hostname;
+        const parts = hostname.split('.');
+        if (parts.length < 2) {
+            return url;
+        }
+        return parts.slice(parts.length - 2).join('.');
+    }
+    catch {
+        return '';
+    }
+}
+export function yieldToEventLoop() {
+    return new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}
+export function isValidHttpUrl(urlString) {
+    // 1. Basic type check and trim: Ensure the input is actually a non-empty string.
+    //    While TypeScript handles type at compile time, this adds runtime robustness.
+    if (typeof urlString !== 'string' || urlString.trim() === '') {
+        return false;
+    }
+    try {
+        // 2. Attempt to construct a URL object.
+        //    The URL constructor throws a TypeError if the URL is not valid
+        //    (e.g., malformed, relative without a base, etc.).
+        const url = new URL(urlString);
+        // 3. Additional robustness: Restrict allowed protocols.
+        //    The URL constructor accepts many protocols (e.g., 'ftp:', 'file:', 'data:', 'javascript:').
+        //    For typical web applications, we usually only want 'http:' or 'https:'.
+        //    The `protocol` property includes the trailing colon.
+        const allowedProtocols = ['http:', 'https:'];
+        if (!allowedProtocols.includes(url.protocol)) {
+            return false;
+        }
+        // 4. Optional but often desired: Ensure a non-empty hostname.
+        //    URLs like "http://" or "https://" are technically valid URL objects
+        //    but have an empty hostname, which might not be desired for a "valid" URL.
+        if (!url.hostname) {
+            return false;
+        }
+        // All checks passed
+        return true;
+    }
+    catch (error) {
+        // If the URL constructor throws an error, it's not a valid URL.
+        // console.error("URL validation error:", error); // Uncomment for debugging if needed
+        return false;
+    }
+}
+//# sourceMappingURL=Utilities.js.map

package/dist/utilities/Utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utilities.js","sourceRoot":"","sources":["../../src/utilities/Utilities.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "easier-http-request",
+	"version": "0.1.0",
+	"description": "Easier HTTP(S) request method. Wraps the Fetch API with some additional features and conveniences.",
+	"author": "Rotem Dan",
+	"license": "MIT",
+	"keywords": ["http", "http-request", "fetch-wrapper", "fetch", "fetch-api"],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/rotemdan/easier-http-request"
+	},
+	"bugs": {
+		"url": "https://github.com/rotemdan/easier-http-request/issues"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"private": false,
+	"main": "./dist/exports/Exports.js",
+	"type": "module",
+	"files": [
+		"dist",
+		"src",
+		"tsconfig.json",
+		"LICENSE.md",
+		"README.md"
+	],
+	"scripts": {
+		"test": "node dist/tests/Test.js"
+	},
+	"dependencies": {},
+	"devDependencies": {
+		"@types/node": "~26.1.1"
+	}
+}

package/src/exports/Exports.ts

@@ -0,0 +1,277 @@
+import { isPlainObject } from '../utilities/ObjectUtilities.js'
+import { isValidHttpUrl } from '../utilities/Utilities.js'
+
+export async function requestHttp(config: EasierHttpRequestConfig): Promise<Response> {
+	// Error if given a bad URL
+	if (!isValidHttpUrl(config.url)) {
+		throw new Error(`'${config.url}' is not a valid HTTP(S) URL.`)
+	}
+
+	// Resolve configuration
+	config = { ...defaultEasierHttpRequestConfig, ...config }
+
+	// Process URL and Params
+	const urlObject = new URL(config.url)
+
+	// Add parameters from parameter object
+	for (const [key, valueOrValues] of Object.entries(config.params!)) {
+		if (valueOrValues == null) {
+			continue
+		}
+
+		const values = Array.isArray(valueOrValues) ? valueOrValues : [valueOrValues]
+
+		for (const value of values) {
+			urlObject.searchParams.append(key, String(value))
+		}
+	}
+
+	// Derive final URL as string
+	const urlString = urlObject.toString()
+
+	// Get method
+	const method = config.method!.toUpperCase()
+
+	// Build headers
+	const headers = new Headers()
+
+	for (const [key, valueOrValues] of Object.entries(config.headers!)) {
+		if (valueOrValues === undefined) {
+			continue
+		}
+
+		let values: string[]
+
+		if (Array.isArray(valueOrValues)) {
+			values = valueOrValues
+		} else {
+			values = [valueOrValues]
+		}
+
+		// Ensure repeating keys with different capitalizations don't concatenate with each other
+		headers.delete(key)
+
+		// Append header values
+		for (const value of values) {
+			headers.append(key, String(value))
+		}
+	}
+
+	// Process request body
+	let body: BodyInit | undefined = undefined
+
+	const bodyArg = config.body
+
+	if (bodyArg !== undefined) {
+		if (['GET', 'HEAD'].includes(method)) {
+			throw new Error(`Request method '${method}' doesn't accept a request body.`)
+		}
+
+		if (isPlainObject(bodyArg)) {
+			body = JSON.stringify(bodyArg)
+
+			headers.set('Content-Type', 'application/json')
+		} else {
+			// TODO: consider ensuring bodyArg type is valid
+			body = bodyArg as any
+		}
+	}
+
+	// Handle timeout and user-defined abort signal
+	const abortController = new AbortController()
+	const abortSignal = abortController.signal
+
+	// Set timeout to abort when maximum time elapses before headers are sent by the server
+	const timeoutMilliseconds = Math.floor(config.timeout! * 1000)
+
+	const requestTimeoutHandle = setTimeout(() => {
+		abortController?.abort('timeout')
+	}, timeoutMilliseconds)
+
+	// Set user abort listener
+	const userAbortListener = () => abortController?.abort()
+	config.abortSignal?.addEventListener('abort', userAbortListener)
+
+	// Prepare fetch options (RequestInit)
+	const fetchInitOptions: RequestInit = {
+		// Pass arguments
+		method,
+		headers,
+		body,
+		signal: abortSignal,
+
+		// Forward other aruments to 'fetch', unmodified.
+		redirect: config.redirect,
+		integrity: config.integrity,
+
+		credentials: config.credentials,
+		mode: config.mode,
+		referrer: config.referrer,
+		referrerPolicy: config.referrerPolicy,
+	}
+
+	// Execute fetch
+	let response: Response
+
+	try {
+		response = await fetch(urlString, fetchInitOptions)
+
+		// Check for HTTP error (non-2xx status)
+		if (!response.ok) {
+			let errorBody: unknown
+
+			try {
+				// Attempt to parse body for error details, but don't fail if it's not JSON/text
+				const contentType = response.headers.get('content-type')
+
+				if (contentType?.includes('application/json')) {
+					errorBody = await response.json()
+				} else if (contentType?.includes('text/')) {
+					errorBody = await response.text()
+				}
+			} catch (e) {
+				// Ignore parsing errors for the error body itself
+			}
+
+			const status = response.status
+			const statusText = response.statusText || 'Unknown Error'
+			const errorMessage = `Request failed with status code ${status}: ${statusText}`
+
+			const error = new EasierHttpRequestError(errorMessage, config, response, errorBody)
+
+			throw error
+		}
+	} catch (error: any) {
+		if (error instanceof EasierHttpRequestError || error instanceof EasierHttpRequestTimeoutError) {
+			// This is our custom HTTP error (non-2xx)
+			throw error
+		} else if (error.name === 'AbortError') {
+			if (error.reason === 'timeout') {
+				throw new EasierHttpRequestTimeoutError(`Request timed out after ${config.timeout!}ms.`)
+			} else {
+				throw error
+			}
+		} else {
+			// Other network errors
+			const networkError = new EasierHttpRequestError(`Network Error: ${error.message}`, config);
+			// Optionally attach the original error
+			(networkError as any).originalError = error
+
+			throw networkError
+		}
+	} finally {
+		// Clear timeout
+		clearTimeout(requestTimeoutHandle)
+	}
+
+	return response
+}
+
+// Request configuration object type
+export interface EasierHttpRequestConfig {
+	///////////////////////////////////////////////////////////////////////////
+	// Simplified parameters. Wraps over 'fetch'.
+	///////////////////////////////////////////////////////////////////////////
+
+	// The URL for the request.
+	url: string
+
+	// The HTTP method. Defaults to 'GET'.
+	method?: HttpRequestMethod
+
+	// Parameters to be appended to the URL as a query string.
+	params?: Record<string, unknown>
+
+	// Custom headers to include in the request.
+	headers?: Record<string, string | string[] | undefined>
+
+	// Request body
+	body?: unknown
+
+	// The maximum number of seconds to wait for HTTP headers to be received from the server
+	timeout?: number
+
+	// Abort signal
+	abortSignal?: AbortSignal
+
+	///////////////////////////////////////////////////////////////////////////
+	// Additional parameters. Forwarded directly to 'fetch', unmodified.
+	///////////////////////////////////////////////////////////////////////////
+
+	// How to handle redirections
+	redirect?: RequestRedirect
+
+	// Subresource integrity value of the request.
+	integrity?: string
+
+	// Credentials
+	credentials?: RequestCredentials
+
+	// CORS mode
+	mode?: RequestMode
+
+	// Referrer
+	referrer?: string
+
+	// Referrer policy
+	referrerPolicy?: ReferrerPolicy
+}
+
+// Default configuration
+export const defaultEasierHttpRequestConfig: EasierHttpRequestConfig = {
+	url: '',
+	method: 'GET',
+	params: {},
+	headers: {},
+	body: undefined,
+	timeout: 60 * 2,
+}
+
+// HTTP methods
+export type HttpRequestMethod =
+	'get' | 'GET' |
+	'delete' | 'DELETE' |
+	'head' | 'HEAD' |
+	'options' | 'OPTIONS' |
+	'post' | 'POST' |
+	'put' | 'PUT' |
+	'patch' | 'PATCH' |
+	'purge' | 'PURGE' |
+	'link' | 'LINK' |
+	'unlink' | 'UNLINK'
+
+// Request error object
+export class EasierHttpRequestError extends Error {
+	constructor(
+		public readonly message: string,
+		public readonly config: EasierHttpRequestConfig,
+		public readonly response?: Response,
+		public readonly errorBody?: unknown) {
+		super(message)
+
+		this.name = 'RequestError'
+
+		// Capture stack trace, excluding constructor call from it
+		if (typeof Error.captureStackTrace === 'function') {
+			Error.captureStackTrace(this, EasierHttpRequestError)
+		} else {
+			this.stack = (new Error(message)).stack
+		}
+	}
+
+	get statusCode() {
+		return this.response?.status
+	}
+
+	get statusText() {
+		return this.response?.statusText
+	}
+}
+
+export class EasierHttpRequestTimeoutError extends Error {
+	constructor(public readonly message: string) {
+		super(message)
+
+		this.name = 'RequestTimeoutError'
+	}
+}

package/src/utilities/ObjectUtilities.ts

@@ -0,0 +1,193 @@
+export function extendDeep(base: any, extension: any): any {
+	const baseClone = deepClone(base)
+
+	if (isPlainObject(base) && extension === undefined) {
+		return baseClone
+	}
+
+	const extensionClone = deepClone(extension)
+	if (!isPlainObject(base) || !isPlainObject(extension)) {
+		return extensionClone
+	}
+
+	for (const propName in extensionClone) {
+		if (!extensionClone.hasOwnProperty(propName)) {
+			continue
+		}
+
+		baseClone[propName] = extendDeep(baseClone[propName], extensionClone[propName])
+	}
+
+	return baseClone
+}
+
+export function shallowClone<T>(val: T) {
+	return clone(val, false)
+}
+
+export function deepClone<T>(val: T) {
+	return clone(val, true)
+}
+
+function clone<T>(val: T, deep = true, seenObjects: any[] = []): T {
+	if (val === undefined || val === null || typeof val !== 'object') {
+		return val
+	}
+
+	const obj = <any>val
+	const prototypeIdentifier = toString.call(obj)
+
+	switch (prototypeIdentifier) {
+		case '[object Array]': {
+			if (seenObjects.includes(obj)) {
+				throw new Error('deepClone: encountered a cyclic object')
+			}
+
+			seenObjects.push(obj)
+
+			const clonedArray = new Array(obj.length)
+
+			for (let i = 0; i < obj.length; i++) {
+				if (deep) {
+					clonedArray[i] = clone(obj[i], true, seenObjects)
+				} else {
+					clonedArray[i] = obj[i]
+				}
+			}
+
+			seenObjects.pop()
+
+			return clonedArray as any
+		}
+
+		case '[object ArrayBuffer]': {
+			const clonedArray = new Uint8Array(obj.byteLength)
+			clonedArray.set(new Uint8Array(obj))
+
+			return clonedArray.buffer as any
+		}
+
+		case '[object Int8Array]': {
+			const clonedArray = new Int8Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Uint8Array]': {
+			const clonedArray = new Uint8Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Uint8ClampedArray]': {
+			const clonedArray = new Uint8ClampedArray(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Int16Array]': {
+			const clonedArray = new Int16Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Uint16Array]': {
+			const clonedArray = new Uint16Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Int32Array]': {
+			const clonedArray = new Int32Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Uint32Array]': {
+			const clonedArray = new Uint32Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Float32Array]': {
+			const clonedArray = new Float32Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Float64Array]': {
+			const clonedArray = new Float64Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object BigInt64Array]': {
+			const clonedArray = new BigInt64Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object BigUint64Array]': {
+			const clonedArray = new BigUint64Array(obj.length)
+			clonedArray.set(obj)
+
+			return clonedArray as any
+		}
+
+		case '[object Date]': {
+			return new Date(obj.valueOf()) as any
+		}
+
+		case '[object RegExp]': {
+			return obj
+		}
+
+		case '[object Function]': {
+			return obj
+		}
+
+		case '[object Object]': {
+			if (seenObjects.includes(obj)) {
+				throw new Error('deepClone: encountered a cyclic object')
+			}
+
+			seenObjects.push(obj)
+
+			const clonedObj: any = {}
+
+			for (const propName in obj) {
+				if (!obj.hasOwnProperty(propName)) {
+					continue
+				}
+
+				if (deep) {
+					clonedObj[propName] = clone(obj[propName], true, seenObjects)
+				} else {
+					clonedObj[propName] = obj[propName]
+				}
+			}
+
+			seenObjects.pop()
+
+			return clonedObj
+		}
+
+		default: {
+			throw new Error(`Cloning of type ${prototypeIdentifier} is not supported`)
+		}
+	}
+}
+
+export function isPlainObject(val: any) {
+	return val != null && typeof val === 'object' && toString.call(val) === '[object Object]'
+}

package/src/utilities/Timer.ts

@@ -0,0 +1,79 @@
+import { logToStderr, roundToDigits } from './Utilities.js'
+
+export class Timer {
+	startTime = 0
+
+	constructor() {
+		this.restart()
+	}
+
+	restart() {
+		this.startTime = Timer.currentTime
+	}
+
+	get elapsedTime(): number {
+		// Elapsed time (milliseconds)
+		return Timer.currentTime - this.startTime
+	}
+
+	get elapsedTimeSeconds(): number {
+		// Elapsed time (seconds)
+		return this.elapsedTime / 1000
+	}
+
+	getElapsedTimeAndRestart(): number {
+		const elapsedTime = this.elapsedTime
+		this.restart()
+
+		return elapsedTime
+	}
+
+	logAndRestart(title: string, timePrecision = 3): number {
+		const elapsedTime = this.elapsedTime
+
+		//
+		const message = `${title}: ${roundToDigits(elapsedTime, timePrecision)}ms`
+
+		logToStderr(message)
+		//
+
+		this.restart()
+
+		return elapsedTime
+	}
+
+	static get currentTime(): number {
+		if (!this.getTimestamp) {
+			this.createTimestampFunction()
+		}
+
+		return this.getTimestamp()
+	}
+
+	static get microsecondTimestamp(): number {
+		return Math.floor(Timer.currentTime * 1000)
+	}
+
+	private static createTimestampFunction() {
+		if (typeof process === 'object' && typeof process.hrtime === 'function') {
+			let baseTimestamp = 0
+
+			this.getTimestamp = () => {
+				const nodeTimeNanoSeconds = process.hrtime.bigint()
+				const nodeTimeMilliseconds = Number(nodeTimeNanoSeconds) / 1_000_000
+
+				return baseTimestamp + nodeTimeMilliseconds
+			}
+
+			baseTimestamp = Date.now() - this.getTimestamp()
+		} else if (typeof performance === 'object' && performance.now) {
+			const baseTimestamp = Date.now() - performance.now()
+
+			this.getTimestamp = () => baseTimestamp + performance.now()
+		} else {
+			this.getTimestamp = () => Date.now()
+		}
+	}
+
+	private static getTimestamp: () => number
+}