request-got-adapter 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,106 @@
+import { type RequestJar, jar as createJar, cookie as parseCookieString } from './cookies';
+import { RequestError as RequestErrorClass, StatusCodeError as StatusCodeErrorClass, TransformError as TransformErrorClass } from './errors';
+import type { FullResponse as FullResponseShape } from './response';
+import type { AuthOptions, OAuthOptions } from './rp-options';
+declare function requestGotAdapter(uriOrOptions: string | requestGotAdapter.Options, optionsOrCallback?: requestGotAdapter.RequestPromiseOptions | requestGotAdapter.RequestCallback, callback?: requestGotAdapter.RequestCallback): requestGotAdapter.RequestPromise;
+declare namespace requestGotAdapter {
+    type RequestCallback = (error: unknown, response: FullResponse, body: unknown) => void;
+    type FullResponse = FullResponseShape;
+    interface RequestPromise<T = any> extends Promise<T> {
+        promise(): Promise<T>;
+    }
+    interface RequestPromiseOptions {
+        baseUrl?: string;
+        method?: string;
+        headers?: Record<string, any>;
+        qs?: any;
+        qsParseOptions?: any;
+        qsStringifyOptions?: any;
+        useQuerystring?: boolean;
+        body?: any;
+        json?: any;
+        form?: Record<string, any> | string;
+        formData?: Record<string, any>;
+        auth?: AuthOptions;
+        oauth?: OAuthOptions;
+        gzip?: boolean;
+        encoding?: string | null;
+        timeout?: number;
+        time?: boolean;
+        simple?: boolean;
+        resolveWithFullResponse?: boolean;
+        followRedirect?: boolean;
+        followAllRedirects?: boolean;
+        followOriginalHttpMethod?: boolean;
+        maxRedirects?: number;
+        strictSSL?: boolean;
+        rejectUnauthorized?: boolean;
+        ca?: string | Buffer | Array<string | Buffer>;
+        cert?: string | Buffer;
+        key?: string | Buffer;
+        pfx?: string | Buffer;
+        passphrase?: string;
+        agent?: any;
+        agentOptions?: Record<string, any>;
+        forever?: boolean;
+        jar?: CookieJar | boolean;
+        transform?: (body: any, response: FullResponse, resolveWithFullResponse?: boolean) => any;
+        transform2xxOnly?: boolean;
+        localAddress?: string;
+        family?: 4 | 6;
+        lookup?: any;
+        callback?: RequestCallback;
+    }
+    interface OptionsWithUri extends RequestPromiseOptions {
+        uri: string | {
+            href: string;
+        };
+    }
+    interface OptionsWithUrl extends RequestPromiseOptions {
+        url: string | {
+            href: string;
+        };
+    }
+    type Options = OptionsWithUri | OptionsWithUrl;
+    type CookieJar = RequestJar;
+    interface RequestPromiseCall {
+        (options: Options, callback?: RequestCallback): RequestPromise;
+        (uri: string, options?: RequestPromiseOptions, callback?: RequestCallback): RequestPromise;
+        (uri: string, callback?: RequestCallback): RequestPromise;
+    }
+    interface RequestPromiseAPI extends RequestPromiseCall {
+        get: RequestPromiseCall;
+        head: RequestPromiseCall;
+        options: RequestPromiseCall;
+        post: RequestPromiseCall;
+        put: RequestPromiseCall;
+        patch: RequestPromiseCall;
+        del: RequestPromiseCall;
+        delete: RequestPromiseCall;
+        defaults: (options: RequestPromiseOptions) => RequestPromiseAPI;
+        forever: (agentOptions?: Record<string, any>) => RequestPromiseAPI;
+        jar: typeof createJar;
+        cookie: typeof parseCookieString;
+        StatusCodeError: typeof StatusCodeErrorClass;
+        RequestError: typeof RequestErrorClass;
+        TransformError: typeof TransformErrorClass;
+    }
+    const get: RequestPromiseCall;
+    const head: RequestPromiseCall;
+    const options: RequestPromiseCall;
+    const post: RequestPromiseCall;
+    const put: RequestPromiseCall;
+    const patch: RequestPromiseCall;
+    const del: RequestPromiseCall;
+    const defaults: (options: RequestPromiseOptions) => RequestPromiseAPI;
+    const forever: (agentOptions?: Record<string, any>) => RequestPromiseAPI;
+    const jar: typeof createJar;
+    const cookie: typeof parseCookieString;
+    const StatusCodeError: typeof StatusCodeErrorClass;
+    const RequestError: typeof RequestErrorClass;
+    const TransformError: typeof TransformErrorClass;
+    type StatusCodeError = StatusCodeErrorClass;
+    type RequestError = RequestErrorClass;
+    type TransformError = TransformErrorClass;
+}
+export = requestGotAdapter;

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+const args_1 = require("./args");
+const cookies_1 = require("./cookies");
+const core_1 = require("./core");
+const errors_1 = require("./errors");
+function buildApi(defaultOptions) {
+    const invoke = (method, args) => {
+        const { options, callback } = (0, args_1.normalizeArgs)(args[0], args[1], args[2]);
+        const merged = (0, args_1.mergeDefaults)(defaultOptions, options);
+        if (method !== undefined)
+            merged.method = method;
+        return (0, core_1.doRequest)(merged, callback);
+    };
+    const api = ((...args) => invoke(undefined, args));
+    api.get = (...args) => invoke('GET', args);
+    api.head = (...args) => invoke('HEAD', args);
+    api.options = (...args) => invoke('OPTIONS', args);
+    api.post = (...args) => invoke('POST', args);
+    api.put = (...args) => invoke('PUT', args);
+    api.patch = (...args) => invoke('PATCH', args);
+    api.del = (...args) => invoke('DELETE', args);
+    api.delete = (...args) => invoke('DELETE', args);
+    api.defaults = (options) => buildApi(defaultOptions ? (0, args_1.mergeDefaults)(defaultOptions, options) : options);
+    api.forever = (agentOptions) => buildApi({ ...defaultOptions, forever: true, ...(agentOptions !== undefined ? { agentOptions } : {}) });
+    api.jar = cookies_1.jar;
+    api.cookie = cookies_1.cookie;
+    api.StatusCodeError = errors_1.StatusCodeError;
+    api.RequestError = errors_1.RequestError;
+    api.TransformError = errors_1.TransformError;
+    return api;
+}
+const baseApi = buildApi();
+function requestGotAdapter(uriOrOptions, optionsOrCallback, callback) {
+    return baseApi(uriOrOptions, optionsOrCallback, callback);
+}
+// Mirrors @types/request-promise-native's export= namespace shape
+(function (requestGotAdapter) {
+    requestGotAdapter.get = baseApi.get;
+    requestGotAdapter.head = baseApi.head;
+    requestGotAdapter.options = baseApi.options;
+    requestGotAdapter.post = baseApi.post;
+    requestGotAdapter.put = baseApi.put;
+    requestGotAdapter.patch = baseApi.patch;
+    requestGotAdapter.del = baseApi.del;
+    requestGotAdapter.defaults = baseApi.defaults;
+    requestGotAdapter.forever = baseApi.forever;
+    requestGotAdapter.jar = baseApi.jar;
+    requestGotAdapter.cookie = baseApi.cookie;
+    requestGotAdapter.StatusCodeError = errors_1.StatusCodeError;
+    requestGotAdapter.RequestError = errors_1.RequestError;
+    requestGotAdapter.TransformError = errors_1.TransformError;
+})(requestGotAdapter || (requestGotAdapter = {}));
+// `delete` is a reserved word and cannot be a namespace export — TS callers use
+// .del; runtime .delete still works for JS consumers.
+;
+requestGotAdapter.delete = baseApi.delete;
+module.exports = requestGotAdapter;

package/dist/oauth.d.ts

@@ -0,0 +1,5 @@
+import type { OAuthOptions } from './rp-options';
+export declare function buildOAuthParams(oauth: OAuthOptions, method: string, urlString: string, formBody?: string, rawBodyForHash?: string | Buffer): Record<string, string>;
+export declare function orderedOAuthKeys(params: Record<string, string>): string[];
+export declare function toOAuthHeader(params: Record<string, string>): string;
+export declare function toOAuthQuery(params: Record<string, string>): string;

package/dist/oauth.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOAuthParams = buildOAuthParams;
+exports.orderedOAuthKeys = orderedOAuthKeys;
+exports.toOAuthHeader = toOAuthHeader;
+exports.toOAuthQuery = toOAuthQuery;
+const node_crypto_1 = require("node:crypto");
+// RFC 3986 percent-encoding as OAuth 1.0 requires (RFC 5849 §3.6)
+const encode = (value) => encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+const NON_PARAM_FIELDS = new Set([
+    'consumer_secret',
+    'private_key',
+    'token_secret',
+    'realm',
+    'transport_method',
+    'body_hash'
+]);
+function buildOAuthParams(oauth, method, urlString, formBody, rawBodyForHash) {
+    const url = new URL(urlString);
+    const oauthParams = {};
+    for (const [key, value] of Object.entries(oauth)) {
+        if (value === undefined || NON_PARAM_FIELDS.has(key))
+            continue;
+        oauthParams[key.startsWith('oauth_') ? key : `oauth_${key}`] = String(value);
+    }
+    oauthParams.oauth_version ??= '1.0';
+    oauthParams.oauth_timestamp ??= String(Math.floor(Date.now() / 1000));
+    oauthParams.oauth_nonce ??= (0, node_crypto_1.randomBytes)(16).toString('hex');
+    oauthParams.oauth_signature_method ??= 'HMAC-SHA1';
+    if (oauth.body_hash !== undefined) {
+        oauthParams.oauth_body_hash =
+            oauth.body_hash === true
+                ? (0, node_crypto_1.createHash)('sha1')
+                    .update(rawBodyForHash ?? '')
+                    .digest('base64')
+                : oauth.body_hash;
+    }
+    const pairs = [];
+    for (const [key, value] of new URLSearchParams(url.search))
+        pairs.push([key, value]);
+    if (formBody !== undefined)
+        for (const [key, value] of new URLSearchParams(formBody))
+            pairs.push([key, value]);
+    for (const [key, value] of Object.entries(oauthParams))
+        pairs.push([key, value]);
+    const parameterString = pairs
+        .map(([key, value]) => [encode(key), encode(value)])
+        .sort(([aKey, aValue], [bKey, bValue]) => {
+        if (aKey === bKey)
+            return aValue < bValue ? -1 : 1;
+        return aKey < bKey ? -1 : 1;
+    })
+        .map(([key, value]) => `${key}=${value}`)
+        .join('&');
+    const baseUrl = `${url.protocol}//${url.host}${url.pathname}`;
+    const baseString = [method.toUpperCase(), encode(baseUrl), encode(parameterString)].join('&');
+    const signingKey = `${encode(oauth.consumer_secret ?? '')}&${encode(oauth.token_secret ?? '')}`;
+    const signatureMethod = oauthParams.oauth_signature_method;
+    let signature;
+    switch (signatureMethod) {
+        case 'HMAC-SHA1':
+            signature = (0, node_crypto_1.createHmac)('sha1', signingKey).update(baseString).digest('base64');
+            break;
+        case 'HMAC-SHA256':
+            signature = (0, node_crypto_1.createHmac)('sha256', signingKey).update(baseString).digest('base64');
+            break;
+        case 'RSA-SHA1':
+            signature = (0, node_crypto_1.createSign)('RSA-SHA1')
+                .update(baseString)
+                .sign(oauth.private_key ?? '', 'base64');
+            break;
+        case 'PLAINTEXT':
+            signature = signingKey;
+            break;
+        default:
+            throw new Error(`Invalid signature method: ${signatureMethod}`);
+    }
+    oauthParams.oauth_signature = signature;
+    if (oauth.realm !== undefined)
+        oauthParams.realm = oauth.realm;
+    return oauthParams;
+}
+// request's concatParams ordering: realm first, params sorted, oauth_signature last
+function orderedOAuthKeys(params) {
+    const keys = Object.keys(params)
+        .filter((key) => key !== 'realm' && key !== 'oauth_signature')
+        .sort();
+    if (params.realm !== undefined)
+        keys.unshift('realm');
+    keys.push('oauth_signature');
+    return keys;
+}
+function toOAuthHeader(params) {
+    const parts = orderedOAuthKeys(params).map((key) => `${key}="${encode(params[key])}"`);
+    return `OAuth ${parts.join(',')}`;
+}
+function toOAuthQuery(params) {
+    return orderedOAuthKeys(params)
+        .map((key) => `${key}=${encode(params[key])}`)
+        .join('&');
+}

package/dist/response.d.ts

@@ -0,0 +1,45 @@
+import { parse as parseLegacyUrl } from 'node:url';
+import type { Prepared } from './translate';
+interface GotResponseLike {
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, unknown>;
+    rawHeaders?: string[];
+    httpVersion?: string;
+    url?: string;
+    timings?: {
+        response?: number;
+        phases: {
+            wait?: number;
+            dns?: number;
+            tcp?: number;
+            firstByte?: number;
+            download?: number;
+            total?: number;
+        };
+    };
+    request?: {
+        options?: {
+            method?: string;
+        };
+    };
+}
+export interface FullResponse {
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, unknown>;
+    rawHeaders?: string[];
+    httpVersion?: string;
+    body: unknown;
+    request: {
+        uri: ReturnType<typeof parseLegacyUrl>;
+        method: string;
+        headers: Record<string, unknown>;
+    };
+    toJSON: () => unknown;
+    elapsedTime?: number;
+    responseStartTime?: number;
+    timingPhases?: Record<string, number | undefined>;
+}
+export declare function buildFullResponse(gotResponse: GotResponseLike, prepared: Prepared, body: unknown): FullResponse;
+export {};

package/dist/response.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFullResponse = buildFullResponse;
+const node_url_1 = require("node:url");
+function buildFullResponse(gotResponse, prepared, body) {
+    const finalMethod = gotResponse.request?.options?.method ?? prepared.method;
+    const requestPart = {
+        uri: (0, node_url_1.parse)(gotResponse.url ?? prepared.url),
+        method: finalMethod,
+        headers: prepared.requestHeaders
+    };
+    const response = {
+        statusCode: gotResponse.statusCode,
+        statusMessage: gotResponse.statusMessage,
+        headers: gotResponse.headers,
+        rawHeaders: gotResponse.rawHeaders,
+        httpVersion: gotResponse.httpVersion,
+        body,
+        request: requestPart,
+        toJSON() {
+            return {
+                statusCode: this.statusCode,
+                body: this.body,
+                headers: this.headers,
+                request: { uri: requestPart.uri, method: requestPart.method, headers: requestPart.headers }
+            };
+        }
+    };
+    if (prepared.time && gotResponse.timings) {
+        const phases = gotResponse.timings.phases;
+        response.elapsedTime = phases.total;
+        response.responseStartTime = gotResponse.timings.response;
+        response.timingPhases = {
+            wait: phases.wait,
+            dns: phases.dns,
+            tcp: phases.tcp,
+            firstByte: phases.firstByte,
+            download: phases.download,
+            total: phases.total
+        };
+    }
+    return response;
+}

package/dist/rp-options.d.ts

@@ -0,0 +1,81 @@
+import type { IParseOptions, IStringifyOptions } from 'qs';
+export interface AuthOptions {
+    user?: string;
+    username?: string;
+    pass?: string;
+    password?: string;
+    bearer?: string | (() => string);
+    sendImmediately?: boolean;
+}
+export interface OAuthOptions {
+    consumer_key?: string;
+    consumer_secret?: string;
+    private_key?: string;
+    token?: string;
+    token_secret?: string;
+    verifier?: string;
+    version?: string;
+    signature_method?: string;
+    realm?: string;
+    transport_method?: 'header' | 'query' | 'body';
+    body_hash?: true | string;
+    timestamp?: string;
+    nonce?: string;
+}
+export type Callback = (error: unknown, response: unknown, body: unknown) => void;
+export type TransformFunction = (body: unknown, response: unknown, resolveWithFullResponse?: boolean) => unknown;
+export interface CookieJarLike {
+    setCookie(cookieOrString: unknown, uri: string, options?: unknown): unknown;
+    getCookieString(uri: string): string;
+    getCookies(uri: string): unknown[];
+    _jar?: unknown;
+}
+export interface RpOptions {
+    uri?: string | {
+        href: string;
+    };
+    url?: string | {
+        href: string;
+    };
+    baseUrl?: string;
+    method?: string;
+    headers?: Record<string, unknown>;
+    qs?: Record<string, unknown>;
+    qsParseOptions?: IParseOptions;
+    qsStringifyOptions?: IStringifyOptions;
+    useQuerystring?: boolean;
+    body?: unknown;
+    json?: unknown;
+    form?: Record<string, unknown> | string;
+    formData?: Record<string, unknown>;
+    auth?: AuthOptions;
+    oauth?: OAuthOptions;
+    gzip?: boolean;
+    encoding?: string | null;
+    timeout?: number;
+    time?: boolean;
+    simple?: boolean;
+    resolveWithFullResponse?: boolean;
+    followRedirect?: boolean | ((response: unknown) => boolean);
+    followAllRedirects?: boolean;
+    followOriginalHttpMethod?: boolean;
+    maxRedirects?: number;
+    strictSSL?: boolean;
+    rejectUnauthorized?: boolean;
+    ca?: string | Buffer | Array<string | Buffer>;
+    cert?: string | Buffer;
+    key?: string | Buffer;
+    pfx?: string | Buffer;
+    passphrase?: string;
+    agent?: unknown;
+    agentOptions?: Record<string, unknown>;
+    forever?: boolean;
+    jar?: boolean | CookieJarLike;
+    transform?: TransformFunction;
+    transform2xxOnly?: boolean;
+    localAddress?: string;
+    family?: 4 | 6;
+    lookup?: unknown;
+    callback?: Callback;
+    [key: string]: unknown;
+}

package/dist/rp-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/translate.d.ts

@@ -0,0 +1,18 @@
+import { type Headers } from './headers';
+import type { AuthOptions, RpOptions, TransformFunction } from './rp-options';
+export interface Prepared {
+    url: string;
+    method: string;
+    gotOptions: Record<string, unknown>;
+    requestHeaders: Headers;
+    simple: boolean;
+    resolveWithFullResponse: boolean;
+    jsonMode: boolean;
+    encoding: string | null | undefined;
+    transform?: TransformFunction;
+    transform2xxOnly: boolean;
+    time: boolean;
+    deferredAuth?: AuthOptions;
+    rpOptions: RpOptions;
+}
+export declare function prepare(rpOptions: RpOptions): Prepared;