wreq-js 0.2.0 → 1.0.0

package/dist/wreq-js.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocket = void 0;
+exports.RequestError = exports.WebSocket = exports.Session = exports.Response = exports.Headers = void 0;
+exports.fetch = fetch;
+exports.createSession = createSession;
+exports.withSession = withSession;
 exports.request = request;
 exports.getProfiles = getProfiles;
 exports.get = get;
 exports.post = post;
 exports.websocket = websocket;
+const node_crypto_1 = require("node:crypto");
+const node_http_1 = require("node:http");
 const types_1 = require("./types");
+Object.defineProperty(exports, "RequestError", { enumerable: true, get: function () { return types_1.RequestError; } });
 let nativeBinding;
 let cachedProfiles;
 function loadNativeBinding() {
@@ -55,44 +61,550 @@ const websocketFinalizer = typeof FinalizationRegistry === "function"
         void nativeBinding.websocketClose(connection).catch(() => undefined);
     })
     : undefined;
+const DEFAULT_BROWSER = "chrome_142";
+function generateSessionId() {
+    const cryptoGlobal = globalThis.crypto;
+    if (cryptoGlobal?.randomUUID) {
+        return cryptoGlobal.randomUUID();
+    }
+    return (0, node_crypto_1.randomBytes)(16).toString("hex");
+}
+function normalizeSessionOptions(options) {
+    const sessionId = options?.sessionId ?? generateSessionId();
+    const defaults = {
+        browser: options?.browser ?? DEFAULT_BROWSER,
+    };
+    if (options?.proxy !== undefined) {
+        defaults.proxy = options.proxy;
+    }
+    if (options?.timeout !== undefined) {
+        defaults.timeout = options.timeout;
+    }
+    return { sessionId, defaults };
+}
+function isIterable(value) {
+    return Boolean(value) && typeof value[Symbol.iterator] === "function";
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function coerceHeaderValue(value) {
+    return String(value);
+}
+class Headers {
+    constructor(init) {
+        this.store = new Map();
+        if (init) {
+            this.applyInit(init);
+        }
+    }
+    applyInit(init) {
+        if (init instanceof Headers) {
+            for (const [name, value] of init) {
+                this.append(name, value);
+            }
+            return;
+        }
+        if (Array.isArray(init) || isIterable(init)) {
+            for (const tuple of init) {
+                if (!tuple) {
+                    continue;
+                }
+                const [name, value] = tuple;
+                this.append(name, value);
+            }
+            return;
+        }
+        if (isPlainObject(init)) {
+            for (const [name, value] of Object.entries(init)) {
+                if (value === undefined || value === null) {
+                    continue;
+                }
+                this.set(name, coerceHeaderValue(value));
+            }
+        }
+    }
+    normalizeName(name) {
+        if (typeof name !== "string") {
+            throw new TypeError("Header name must be a string");
+        }
+        const trimmed = name.trim();
+        if (!trimmed) {
+            throw new TypeError("Header name must not be empty");
+        }
+        return { key: trimmed.toLowerCase(), display: trimmed };
+    }
+    assertValue(value) {
+        if (value === undefined || value === null) {
+            throw new TypeError("Header value must not be null or undefined");
+        }
+        return coerceHeaderValue(value);
+    }
+    append(name, value) {
+        const normalized = this.normalizeName(name);
+        const existing = this.store.get(normalized.key);
+        const coercedValue = this.assertValue(value);
+        if (existing) {
+            existing.values.push(coercedValue);
+            return;
+        }
+        this.store.set(normalized.key, {
+            name: normalized.display,
+            values: [coercedValue],
+        });
+    }
+    set(name, value) {
+        const normalized = this.normalizeName(name);
+        const coercedValue = this.assertValue(value);
+        this.store.set(normalized.key, {
+            name: normalized.display,
+            values: [coercedValue],
+        });
+    }
+    get(name) {
+        const normalized = this.normalizeName(name);
+        const entry = this.store.get(normalized.key);
+        return entry ? entry.values.join(", ") : null;
+    }
+    has(name) {
+        const normalized = this.normalizeName(name);
+        return this.store.has(normalized.key);
+    }
+    delete(name) {
+        const normalized = this.normalizeName(name);
+        this.store.delete(normalized.key);
+    }
+    entries() {
+        return this[Symbol.iterator]();
+    }
+    *keys() {
+        for (const [name] of this) {
+            yield name;
+        }
+    }
+    *values() {
+        for (const [, value] of this) {
+            yield value;
+        }
+    }
+    forEach(callback, thisArg) {
+        for (const [name, value] of this) {
+            callback.call(thisArg, value, name, this);
+        }
+    }
+    [Symbol.iterator]() {
+        const generator = function* (store) {
+            for (const entry of store.values()) {
+                yield [entry.name, entry.values.join(", ")];
+            }
+        };
+        return generator(this.store);
+    }
+    toObject() {
+        const result = {};
+        for (const [name, value] of this) {
+            result[name] = value;
+        }
+        return result;
+    }
+}
+exports.Headers = Headers;
+function cloneNativeResponse(payload) {
+    return {
+        status: payload.status,
+        headers: { ...payload.headers },
+        body: payload.body,
+        cookies: { ...payload.cookies },
+        url: payload.url,
+    };
+}
+class Response {
+    constructor(payload, requestUrl) {
+        this.type = "basic";
+        this.bodyUsed = false;
+        this.payload = cloneNativeResponse(payload);
+        this.requestUrl = requestUrl;
+        this.status = payload.status;
+        this.statusText = node_http_1.STATUS_CODES[payload.status] ?? "";
+        this.ok = this.status >= 200 && this.status < 300;
+        this.headers = new Headers(payload.headers);
+        this.url = payload.url;
+        this.redirected = this.url !== requestUrl;
+        this.cookies = { ...payload.cookies };
+        this.body = payload.body;
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    async text() {
+        this.assertBodyAvailable();
+        this.bodyUsed = true;
+        return this.body;
+    }
+    clone() {
+        if (this.bodyUsed) {
+            throw new TypeError("Cannot clone a Response whose body is already used");
+        }
+        return new Response(cloneNativeResponse(this.payload), this.requestUrl);
+    }
+    assertBodyAvailable() {
+        if (this.bodyUsed) {
+            throw new TypeError("Response body is already used");
+        }
+    }
+}
+exports.Response = Response;
+class Session {
+    constructor(id, defaults) {
+        this.disposed = false;
+        this.id = id;
+        this.defaults = defaults;
+    }
+    get closed() {
+        return this.disposed;
+    }
+    ensureActive() {
+        if (this.disposed) {
+            throw new types_1.RequestError("Session has been closed");
+        }
+    }
+    enforceBrowser(browser) {
+        const resolved = browser ?? this.defaults.browser;
+        if (resolved !== this.defaults.browser) {
+            throw new types_1.RequestError("Session browser cannot be changed after creation");
+        }
+        return resolved;
+    }
+    enforceProxy(proxy) {
+        if (proxy === undefined) {
+            return this.defaults.proxy;
+        }
+        if ((this.defaults.proxy ?? null) !== (proxy ?? null)) {
+            throw new types_1.RequestError("Session proxy cannot be changed after creation");
+        }
+        return proxy;
+    }
+    async fetch(input, init) {
+        this.ensureActive();
+        const config = {
+            ...(init ?? {}),
+            session: this,
+            cookieMode: "session",
+        };
+        config.browser = this.enforceBrowser(config.browser);
+        const proxy = this.enforceProxy(config.proxy);
+        if (proxy !== undefined || config.proxy !== undefined) {
+            if (proxy === undefined) {
+                delete config.proxy;
+            }
+            else {
+                config.proxy = proxy;
+            }
+        }
+        if (config.timeout === undefined && this.defaults.timeout !== undefined) {
+            config.timeout = this.defaults.timeout;
+        }
+        return fetch(input, config);
+    }
+    async clearCookies() {
+        this.ensureActive();
+        try {
+            nativeBinding.clearSession(this.id);
+        }
+        catch (error) {
+            throw new types_1.RequestError(String(error));
+        }
+    }
+    async close() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        try {
+            nativeBinding.dropSession(this.id);
+        }
+        catch (error) {
+            throw new types_1.RequestError(String(error));
+        }
+    }
+}
+exports.Session = Session;
+function resolveSessionContext(config) {
+    const requestedMode = config.cookieMode ?? "ephemeral";
+    const sessionCandidate = config.session;
+    const providedSessionId = typeof config.sessionId === "string" ? config.sessionId.trim() : undefined;
+    if (sessionCandidate && providedSessionId) {
+        throw new types_1.RequestError("Provide either `session` or `sessionId`, not both.");
+    }
+    if (sessionCandidate) {
+        if (!(sessionCandidate instanceof Session)) {
+            throw new types_1.RequestError("`session` must be created via createSession()");
+        }
+        if (sessionCandidate.closed) {
+            throw new types_1.RequestError("Session has been closed");
+        }
+        return {
+            sessionId: sessionCandidate.id,
+            cookieMode: "session",
+            dropAfterRequest: false,
+        };
+    }
+    if (providedSessionId) {
+        if (!providedSessionId) {
+            throw new types_1.RequestError("sessionId must not be empty");
+        }
+        if (requestedMode === "ephemeral") {
+            throw new types_1.RequestError("cookieMode 'ephemeral' cannot be combined with sessionId");
+        }
+        return {
+            sessionId: providedSessionId,
+            cookieMode: "session",
+            dropAfterRequest: false,
+        };
+    }
+    if (requestedMode === "session") {
+        throw new types_1.RequestError("cookieMode 'session' requires a session or sessionId");
+    }
+    return {
+        sessionId: generateSessionId(),
+        cookieMode: "ephemeral",
+        dropAfterRequest: true,
+    };
+}
+function createAbortError(reason) {
+    const fallbackMessage = typeof reason === "string" ? reason : "The operation was aborted";
+    if (typeof DOMException !== "undefined" && reason instanceof DOMException) {
+        return reason.name === "AbortError" ? reason : new DOMException(reason.message || fallbackMessage, "AbortError");
+    }
+    if (reason instanceof Error) {
+        reason.name = "AbortError";
+        return reason;
+    }
+    if (typeof DOMException !== "undefined") {
+        return new DOMException(fallbackMessage, "AbortError");
+    }
+    const error = new Error(fallbackMessage);
+    error.name = "AbortError";
+    return error;
+}
+function isAbortError(error) {
+    return Boolean(error) && typeof error.name === "string" && error.name === "AbortError";
+}
+function setupAbort(signal) {
+    if (!signal) {
+        return null;
+    }
+    if (signal.aborted) {
+        throw createAbortError(signal.reason);
+    }
+    let onAbort;
+    const promise = new Promise((_, reject) => {
+        onAbort = () => {
+            reject(createAbortError(signal.reason));
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+    const cleanup = () => {
+        if (onAbort) {
+            signal.removeEventListener("abort", onAbort);
+            onAbort = undefined;
+        }
+    };
+    return { promise, cleanup };
+}
+function normalizeUrlInput(input) {
+    const value = typeof input === "string" ? input : input.toString();
+    if (!value) {
+        throw new types_1.RequestError("URL is required");
+    }
+    try {
+        return new URL(value).toString();
+    }
+    catch {
+        throw new types_1.RequestError(`Invalid URL: ${value}`);
+    }
+}
+function validateRedirectMode(mode) {
+    if (!mode || mode === "follow") {
+        return;
+    }
+    throw new types_1.RequestError(`Redirect mode '${mode}' is not supported`);
+}
+function serializeBody(body) {
+    if (body === null || body === undefined) {
+        return undefined;
+    }
+    if (typeof body === "string") {
+        return body;
+    }
+    if (Buffer.isBuffer(body)) {
+        return body.toString();
+    }
+    if (body instanceof URLSearchParams) {
+        return body.toString();
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body).toString();
+    }
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength).toString();
+    }
+    throw new TypeError("Unsupported body type; expected string, Buffer, ArrayBuffer, or URLSearchParams");
+}
+const SUPPORTED_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD"];
+function ensureMethod(method) {
+    const normalized = method?.trim().toUpperCase();
+    return normalized && normalized.length > 0 ? normalized : "GET";
+}
+function assertSupportedMethod(method) {
+    if (!SUPPORTED_METHODS.includes(method)) {
+        throw new types_1.RequestError(`Unsupported HTTP method: ${method}`);
+    }
+}
+function ensureBodyAllowed(method, body) {
+    if (!body) {
+        return;
+    }
+    if (method === "GET" || method === "HEAD") {
+        throw new types_1.RequestError(`Request with ${method} method cannot have a body`);
+    }
+}
+function validateBrowserProfile(browser) {
+    if (!browser) {
+        return;
+    }
+    const profiles = getProfiles();
+    if (!profiles.includes(browser)) {
+        throw new types_1.RequestError(`Invalid browser profile: ${browser}. Available profiles: ${profiles.join(", ")}`);
+    }
+}
+async function dispatchRequest(options, requestUrl, signal) {
+    const abortHandler = setupAbort(signal);
+    const nativePromise = nativeBinding.request(options);
+    const pending = abortHandler ? Promise.race([nativePromise, abortHandler.promise]) : nativePromise;
+    let payload;
+    try {
+        payload = (await pending);
+    }
+    catch (error) {
+        if (isAbortError(error)) {
+            throw error;
+        }
+        if (error instanceof types_1.RequestError) {
+            throw error;
+        }
+        throw new types_1.RequestError(String(error));
+    }
+    finally {
+        abortHandler?.cleanup();
+    }
+    return new Response(payload, requestUrl);
+}
 /**
- * Make an HTTP request with browser impersonation
- *
- * @param options - Request options
- * @returns Promise that resolves to the response
- *
- * @example
- * ```typescript
- * import { request } from 'wreq-js';
+ * Fetch-compatible entry point that adds browser impersonation controls.
  *
- * const response = await request({
- *   url: 'https://example.com/api',
- *   browser: 'chrome_137',
- *   headers: {
- *     'Custom-Header': 'value'
- *   }
- * });
- *
- * console.log(response.status); // 200
- * console.log(response.body);   // Response body
- * ```
+ * @param input - Request URL (string or URL instance)
+ * @param init - Fetch-compatible init options
  */
-async function request(options) {
-    if (!options.url) {
-        throw new types_1.RequestError("URL is required");
+async function fetch(input, init) {
+    const url = normalizeUrlInput(input);
+    const config = init ?? {};
+    const sessionContext = resolveSessionContext(config);
+    validateRedirectMode(config.redirect);
+    validateBrowserProfile(config.browser);
+    const headers = new Headers(config.headers);
+    const method = ensureMethod(config.method);
+    assertSupportedMethod(method);
+    const body = serializeBody(config.body ?? null);
+    ensureBodyAllowed(method, body);
+    const headerRecord = headers.toObject();
+    const hasHeaders = Object.keys(headerRecord).length > 0;
+    const requestOptions = {
+        url,
+        method,
+        ...(config.browser && { browser: config.browser }),
+        ...(hasHeaders && { headers: headerRecord }),
+        ...(body !== undefined && { body }),
+        ...(config.proxy !== undefined && { proxy: config.proxy }),
+        ...(config.timeout !== undefined && { timeout: config.timeout }),
+        sessionId: sessionContext.sessionId,
+        ephemeral: sessionContext.dropAfterRequest,
+    };
+    try {
+        return await dispatchRequest(requestOptions, url, config.signal ?? null);
     }
-    if (options.browser) {
-        const profiles = getProfiles();
-        if (!profiles.includes(options.browser)) {
-            throw new types_1.RequestError(`Invalid browser profile: ${options.browser}. Available profiles: ${profiles.join(", ")}`);
+    finally {
+        if (sessionContext.dropAfterRequest) {
+            try {
+                nativeBinding.dropSession(sessionContext.sessionId);
+            }
+            catch {
+                // ignore cleanup errors for ephemeral sessions
+            }
         }
     }
+}
+async function createSession(options) {
+    const { sessionId, defaults } = normalizeSessionOptions(options);
+    validateBrowserProfile(defaults.browser);
+    let createdId;
     try {
-        return await nativeBinding.request(options);
+        createdId = nativeBinding.createSession({
+            sessionId,
+            browser: defaults.browser,
+            ...(defaults.proxy !== undefined && { proxy: defaults.proxy }),
+        });
     }
     catch (error) {
         throw new types_1.RequestError(String(error));
     }
+    return new Session(createdId, defaults);
+}
+async function withSession(fn, options) {
+    const session = await createSession(options);
+    try {
+        return await fn(session);
+    }
+    finally {
+        await session.close();
+    }
+}
+/**
+ * @deprecated Use {@link fetch} instead.
+ */
+async function request(options) {
+    if (!options.url) {
+        throw new types_1.RequestError("URL is required");
+    }
+    const { url, ...rest } = options;
+    const init = {};
+    if (rest.method !== undefined) {
+        init.method = rest.method;
+    }
+    if (rest.headers !== undefined) {
+        init.headers = rest.headers;
+    }
+    if (rest.body !== undefined) {
+        init.body = rest.body;
+    }
+    if (rest.browser !== undefined) {
+        init.browser = rest.browser;
+    }
+    if (rest.proxy !== undefined) {
+        init.proxy = rest.proxy;
+    }
+    if (rest.timeout !== undefined) {
+        init.timeout = rest.timeout;
+    }
+    if (rest.sessionId !== undefined) {
+        init.sessionId = rest.sessionId;
+    }
+    return fetch(url, init);
 }
 /**
  * Get list of available browser profiles
@@ -114,43 +626,21 @@ function getProfiles() {
     return cachedProfiles;
 }
 /**
- * Convenience function for GET requests
- *
- * @param url - URL to request
- * @param options - Additional request options
- * @returns Promise that resolves to the response
- *
- * @example
- * ```typescript
- * import { get } from 'wreq-js';
- *
- * const response = await get('https://example.com/api');
- * ```
+ * Convenience helper for GET requests using {@link fetch}.
  */
-async function get(url, options) {
-    return request({ ...options, url, method: "GET" });
+async function get(url, init) {
+    return fetch(url, { ...(init ?? {}), method: "GET" });
 }
 /**
- * Convenience function for POST requests
- *
- * @param url - URL to request
- * @param body - Request body
- * @param options - Additional request options
- * @returns Promise that resolves to the response
- *
- * @example
- * ```typescript
- * import { post } from 'wreq-js';
- *
- * const response = await post(
- *   'https://example.com/api',
- *   JSON.stringify({ foo: 'bar' }),
- *   { headers: { 'Content-Type': 'application/json' } }
- * );
- * ```
+ * Convenience helper for POST requests using {@link fetch}.
  */
-async function post(url, body, options) {
-    return request({ ...options, url, method: "POST", ...(body !== undefined && { body }) });
+async function post(url, body, init) {
+    const config = {
+        ...(init ?? {}),
+        method: "POST",
+        ...(body !== undefined ? { body } : {}),
+    };
+    return fetch(url, config);
 }
 /**
  * WebSocket connection class
@@ -161,7 +651,7 @@ async function post(url, body, options) {
  *
  * const ws = await websocket({
  *   url: 'wss://echo.websocket.org',
- *   browser: 'chrome_137',
+ *   browser: 'chrome_142',
  *   onMessage: (data) => {
  *     console.log('Received:', data);
  *   },
@@ -246,7 +736,7 @@ async function websocket(options) {
     try {
         const connection = await nativeBinding.websocketConnect({
             url: options.url,
-            browser: options.browser || "chrome_137",
+            browser: options.browser || DEFAULT_BROWSER,
             headers: options.headers || {},
             ...(options.proxy !== undefined && { proxy: options.proxy }),
             onMessage: options.onMessage,
@@ -260,11 +750,17 @@ async function websocket(options) {
     }
 }
 exports.default = {
+    fetch,
     request,
     get,
     post,
     getProfiles,
+    createSession,
+    withSession,
     websocket,
     WebSocket,
+    Headers,
+    Response,
+    Session,
 };
 //# sourceMappingURL=wreq-js.js.map