recker 1.0.26 → 1.0.27

package/dist/browser/core/response.d.ts

@@ -0,0 +1,34 @@
+import { ConnectionInfo, ReckerResponse, Timings, SSEEvent, ProgressEvent } from '../types/index.js';
+import { Dispatcher } from 'undici';
+import { type HeaderInfo, type CacheInfo, type RateLimitInfo } from '../utils/header-parser.js';
+import { type LinkHeaderParser } from '../utils/link-header.js';
+import type { Readable } from 'node:stream';
+export declare class HttpResponse<T = unknown> implements ReckerResponse<T> {
+    readonly timings?: Timings;
+    readonly connection?: ConnectionInfo;
+    readonly raw: Response;
+    constructor(undiciRawResponse: Response | Dispatcher.ResponseData, options?: {
+        timings?: Timings;
+        connection?: ConnectionInfo;
+    });
+    get status(): number;
+    get statusText(): string;
+    get headers(): Headers;
+    get ok(): boolean;
+    get url(): string;
+    get cache(): CacheInfo;
+    get rateLimit(): RateLimitInfo;
+    links(): LinkHeaderParser | null;
+    get headerInfo(): HeaderInfo;
+    json<R = T>(): Promise<R>;
+    text(): Promise<string>;
+    cleanText(): Promise<string>;
+    blob(): Promise<Blob>;
+    read(): ReadableStream<Uint8Array> | null;
+    toNodeStream(): Readable | null;
+    pipe(destination: NodeJS.WritableStream): Promise<void>;
+    clone(): ReckerResponse<T>;
+    sse(): AsyncGenerator<SSEEvent>;
+    download(): AsyncGenerator<ProgressEvent>;
+    [Symbol.asyncIterator](): AsyncGenerator<Uint8Array>;
+}

package/dist/browser/core/response.js

@@ -0,0 +1,178 @@
+import { parseSSE } from '../utils/sse.js';
+import { cleanHtml } from '../utils/html-cleaner.js';
+import { webToNodeStream } from '../utils/streaming.js';
+import { parseHeaders } from '../utils/header-parser.js';
+import { parseLinkHeader } from '../utils/link-header.js';
+import { StreamError } from './errors.js';
+export class HttpResponse {
+    timings;
+    connection;
+    raw;
+    constructor(undiciRawResponse, options = {}) {
+        this.timings = options.timings;
+        this.connection = options.connection;
+        if (undiciRawResponse instanceof Response) {
+            this.raw = undiciRawResponse;
+        }
+        else {
+            this.raw = new Response(undiciRawResponse.body, {
+                status: undiciRawResponse.statusCode,
+                statusText: String(undiciRawResponse.statusCode),
+                headers: undiciRawResponse.headers,
+            });
+        }
+    }
+    get status() {
+        return this.raw.status;
+    }
+    get statusText() {
+        return this.raw.statusText;
+    }
+    get headers() {
+        return this.raw.headers;
+    }
+    get ok() {
+        return this.raw.ok;
+    }
+    get url() {
+        return this.raw.url;
+    }
+    get cache() {
+        return parseHeaders(this.headers, this.status).cache;
+    }
+    get rateLimit() {
+        return parseHeaders(this.headers, this.status).rateLimit;
+    }
+    links() {
+        return parseLinkHeader(this.headers);
+    }
+    get headerInfo() {
+        return parseHeaders(this.headers, this.status);
+    }
+    async json() {
+        return (await this.raw.json());
+    }
+    async text() {
+        return this.raw.text();
+    }
+    async cleanText() {
+        const rawText = await this.text();
+        return cleanHtml(rawText);
+    }
+    async blob() {
+        return this.raw.blob();
+    }
+    read() {
+        return this.raw.body;
+    }
+    toNodeStream() {
+        if (!this.raw.body) {
+            return null;
+        }
+        return webToNodeStream(this.raw.body);
+    }
+    async pipe(destination) {
+        const nodeStream = this.toNodeStream();
+        if (!nodeStream) {
+            throw new StreamError('Response has no body to pipe', {
+                streamType: 'response',
+                retriable: true,
+            });
+        }
+        return new Promise((resolve, reject) => {
+            nodeStream.pipe(destination);
+            nodeStream.on('end', resolve);
+            nodeStream.on('error', reject);
+            destination.on('error', reject);
+        });
+    }
+    clone() {
+        return new HttpResponse(this.raw.clone(), {
+            timings: this.timings,
+            connection: this.connection
+        });
+    }
+    sse() {
+        return parseSSE(this.raw);
+    }
+    async *download() {
+        if (!this.raw.body) {
+            return;
+        }
+        const contentLength = this.headers.get('content-length');
+        const total = contentLength ? parseInt(contentLength, 10) : undefined;
+        let loaded = 0;
+        const startTime = Date.now();
+        let lastUpdate = 0;
+        let lastLoaded = 0;
+        let lastRateUpdate = startTime;
+        let smoothedRate = 0;
+        const rateSmoothingFactor = 0.3;
+        const createProgress = (isFinal) => {
+            const now = Date.now();
+            const intervalMs = now - lastRateUpdate;
+            const bytesInInterval = loaded - lastLoaded;
+            if (intervalMs > 0) {
+                const instantRate = (bytesInInterval / intervalMs) * 1000;
+                smoothedRate = smoothedRate === 0
+                    ? instantRate
+                    : smoothedRate * (1 - rateSmoothingFactor) + instantRate * rateSmoothingFactor;
+            }
+            lastLoaded = loaded;
+            lastRateUpdate = now;
+            let percent;
+            if (total) {
+                percent = isFinal ? 100 : Math.min((loaded / total) * 100, 99.9);
+            }
+            return {
+                loaded,
+                transferred: loaded,
+                total,
+                percent,
+                rate: smoothedRate,
+                estimated: total && smoothedRate > 0 ? ((total - loaded) / smoothedRate) * 1000 : undefined,
+                direction: 'download',
+            };
+        };
+        const reader = this.raw.body.getReader();
+        try {
+            yield createProgress(false);
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    yield createProgress(true);
+                    break;
+                }
+                if (value) {
+                    loaded += value.byteLength;
+                    const now = Date.now();
+                    if (now - lastUpdate > 100) {
+                        yield createProgress(false);
+                        lastUpdate = now;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        if (!this.raw.body) {
+            return;
+        }
+        const reader = this.raw.body.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                if (value)
+                    yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/browser/crypto.d.ts

@@ -0,0 +1,24 @@
+export type HashAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA-1';
+export type HmacAlgorithm = 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA-1';
+export declare class BrowserCrypto {
+    private encoder;
+    hash(algorithm: HashAlgorithm, data: string): Promise<string>;
+    hashBuffer(algorithm: HashAlgorithm, data: ArrayBuffer | Uint8Array): Promise<string>;
+    hmac(algorithm: HmacAlgorithm, key: string, data: string): Promise<string>;
+    hmacBuffer(algorithm: HmacAlgorithm, key: ArrayBuffer | Uint8Array, data: string | ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
+    randomUUID(): string;
+    randomBytes(length: number): Uint8Array;
+    randomHex(length: number): string;
+    bufferToHex(buffer: ArrayBuffer | Uint8Array): string;
+    hexToBuffer(hex: string): Uint8Array;
+    base64Encode(data: string): string;
+    base64Decode(data: string): string;
+    base64UrlEncode(data: string): string;
+    base64UrlDecode(data: string): string;
+}
+export declare const browserCrypto: BrowserCrypto;
+export declare const sha256: (data: string) => Promise<string>;
+export declare const sha1: (data: string) => Promise<string>;
+export declare const hmacSha256: (key: string, data: string) => Promise<string>;
+export declare const randomUUID: () => string;
+export declare const randomBytes: (length: number) => Uint8Array<ArrayBufferLike>;

package/dist/browser/crypto.js

@@ -0,0 +1,80 @@
+export class BrowserCrypto {
+    encoder = new TextEncoder();
+    async hash(algorithm, data) {
+        const dataBuffer = this.encoder.encode(data);
+        const hashBuffer = await crypto.subtle.digest(algorithm, dataBuffer);
+        return this.bufferToHex(hashBuffer);
+    }
+    async hashBuffer(algorithm, data) {
+        const buffer = data instanceof Uint8Array ? data.buffer : data;
+        const hashBuffer = await crypto.subtle.digest(algorithm, buffer);
+        return this.bufferToHex(hashBuffer);
+    }
+    async hmac(algorithm, key, data) {
+        const keyData = this.encoder.encode(key);
+        const cryptoKey = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: algorithm }, false, ['sign']);
+        const signature = await crypto.subtle.sign('HMAC', cryptoKey, this.encoder.encode(data));
+        return this.bufferToHex(signature);
+    }
+    async hmacBuffer(algorithm, key, data) {
+        const keyBuffer = key instanceof Uint8Array ? key.buffer : key;
+        const cryptoKey = await crypto.subtle.importKey('raw', keyBuffer, { name: 'HMAC', hash: algorithm }, false, ['sign']);
+        let dataBuffer;
+        if (typeof data === 'string') {
+            dataBuffer = this.encoder.encode(data).buffer;
+        }
+        else if (data instanceof Uint8Array) {
+            dataBuffer = data.buffer;
+        }
+        else {
+            dataBuffer = data;
+        }
+        return crypto.subtle.sign('HMAC', cryptoKey, dataBuffer);
+    }
+    randomUUID() {
+        return crypto.randomUUID();
+    }
+    randomBytes(length) {
+        const bytes = new Uint8Array(length);
+        crypto.getRandomValues(bytes);
+        return bytes;
+    }
+    randomHex(length) {
+        return this.bufferToHex(this.randomBytes(length));
+    }
+    bufferToHex(buffer) {
+        const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+        return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    hexToBuffer(hex) {
+        const matches = hex.match(/.{1,2}/g) || [];
+        return new Uint8Array(matches.map((byte) => parseInt(byte, 16)));
+    }
+    base64Encode(data) {
+        const bytes = this.encoder.encode(data);
+        const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join('');
+        return btoa(binString);
+    }
+    base64Decode(data) {
+        const binString = atob(data);
+        const bytes = Uint8Array.from(binString, (m) => m.codePointAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    base64UrlEncode(data) {
+        return this.base64Encode(data)
+            .replace(/\+/g, '-')
+            .replace(/\//g, '_')
+            .replace(/=+$/, '');
+    }
+    base64UrlDecode(data) {
+        const padded = data + '='.repeat((4 - (data.length % 4)) % 4);
+        const base64 = padded.replace(/-/g, '+').replace(/_/g, '/');
+        return this.base64Decode(base64);
+    }
+}
+export const browserCrypto = new BrowserCrypto();
+export const sha256 = (data) => browserCrypto.hash('SHA-256', data);
+export const sha1 = (data) => browserCrypto.hash('SHA-1', data);
+export const hmacSha256 = (key, data) => browserCrypto.hmac('SHA-256', key, data);
+export const randomUUID = () => browserCrypto.randomUUID();
+export const randomBytes = (length) => browserCrypto.randomBytes(length);

package/dist/browser/index.d.ts

@@ -0,0 +1,31 @@
+export * from '../core/request-promise.js';
+export * from '../core/errors.js';
+export * from '../core/client.js';
+export * from '../core/request.js';
+export * from '../core/response.js';
+export * from '../transport/fetch.js';
+export * from '../plugins/retry.js';
+export * from '../plugins/rate-limit.js';
+export * from '../plugins/dedup.js';
+export * from '../plugins/logger.js';
+export * from '../plugins/circuit-breaker.js';
+export * from '../plugins/cookie-jar.js';
+export * from '../plugins/xsrf.js';
+export * from '../plugins/graphql.js';
+export * from '../plugins/xml.js';
+export * from '../plugins/server-timing.js';
+export * from '../plugins/jsonrpc.js';
+export * from '../plugins/grpc-web.js';
+export * from '../plugins/soap.js';
+export * from '../plugins/odata.js';
+export * from '../plugins/auth.js';
+export * from '../cache/memory-storage.js';
+export * from '../utils/body.js';
+export * from '../utils/header-parser.js';
+export * from '../utils/link-header.js';
+export * from '../utils/charset.js';
+export * from '../constants/http-status.js';
+export * from './crypto.js';
+export * from './cache.js';
+export * from './recker.js';
+export { Client as Recker } from '../core/client.js';

package/dist/browser/index.js

@@ -0,0 +1,31 @@
+export * from '../core/request-promise.js';
+export * from '../core/errors.js';
+export * from '../core/client.js';
+export * from '../core/request.js';
+export * from '../core/response.js';
+export * from '../transport/fetch.js';
+export * from '../plugins/retry.js';
+export * from '../plugins/rate-limit.js';
+export * from '../plugins/dedup.js';
+export * from '../plugins/logger.js';
+export * from '../plugins/circuit-breaker.js';
+export * from '../plugins/cookie-jar.js';
+export * from '../plugins/xsrf.js';
+export * from '../plugins/graphql.js';
+export * from '../plugins/xml.js';
+export * from '../plugins/server-timing.js';
+export * from '../plugins/jsonrpc.js';
+export * from '../plugins/grpc-web.js';
+export * from '../plugins/soap.js';
+export * from '../plugins/odata.js';
+export * from '../plugins/auth.js';
+export * from '../cache/memory-storage.js';
+export * from '../utils/body.js';
+export * from '../utils/header-parser.js';
+export * from '../utils/link-header.js';
+export * from '../utils/charset.js';
+export * from '../constants/http-status.js';
+export * from './crypto.js';
+export * from './cache.js';
+export * from './recker.js';
+export { Client as Recker } from '../core/client.js';

package/dist/browser/plugins/auth/api-key.d.ts

@@ -0,0 +1,8 @@
+import { Middleware, Plugin } from '../../types/index.js';
+export interface ApiKeyAuthOptions {
+    key: string | (() => string | Promise<string>);
+    in?: 'header' | 'query';
+    name?: string;
+}
+export declare function apiKeyAuth(options: ApiKeyAuthOptions): Middleware;
+export declare function apiKeyAuthPlugin(options: ApiKeyAuthOptions): Plugin;

package/dist/browser/plugins/auth/api-key.js

@@ -0,0 +1,27 @@
+export function apiKeyAuth(options) {
+    const location = options.in ?? 'header';
+    const name = options.name ?? 'X-API-Key';
+    return async (req, next) => {
+        const key = typeof options.key === 'function'
+            ? await options.key()
+            : options.key;
+        if (location === 'header') {
+            const newReq = req.withHeader(name, key);
+            return next(newReq);
+        }
+        else {
+            const url = new URL(req.url);
+            url.searchParams.set(name, key);
+            const newReq = {
+                ...req,
+                url: url.toString(),
+            };
+            return next(newReq);
+        }
+    };
+}
+export function apiKeyAuthPlugin(options) {
+    return (client) => {
+        client.use(apiKeyAuth(options));
+    };
+}

package/dist/browser/plugins/auth/auth0.d.ts

@@ -0,0 +1,33 @@
+import { Middleware, Plugin } from '../../types/index.js';
+import { OIDCTokens } from './oidc.js';
+export interface Auth0Options {
+    domain: string;
+    clientId: string;
+    clientSecret?: string;
+    audience?: string;
+    scopes?: string[];
+    accessToken?: string | (() => string | Promise<string>);
+    refreshToken?: string;
+    tokenStorage?: {
+        get: () => Promise<OIDCTokens | null>;
+        set: (tokens: OIDCTokens) => Promise<void>;
+    };
+    organization?: string;
+    connection?: string;
+}
+export declare function generateAuth0AuthUrl(options: Auth0Options & {
+    redirectUri: string;
+    state?: string;
+    usePKCE?: boolean;
+}): Promise<{
+    url: string;
+    codeVerifier?: string;
+}>;
+export declare function exchangeAuth0Code(options: Auth0Options & {
+    code: string;
+    redirectUri: string;
+    codeVerifier?: string;
+}): Promise<OIDCTokens>;
+export declare function getAuth0UserInfo(domain: string, accessToken: string): Promise<Record<string, unknown>>;
+export declare function auth0(options: Auth0Options): Middleware;
+export declare function auth0Plugin(options: Auth0Options): Plugin;

package/dist/browser/plugins/auth/auth0.js

@@ -0,0 +1,94 @@
+import { oidc, generatePKCE } from './oidc.js';
+export async function generateAuth0AuthUrl(options) {
+    const issuer = `https://${options.domain}`;
+    const pkce = options.usePKCE ? generatePKCE() : undefined;
+    const params = new URLSearchParams({
+        response_type: 'code',
+        client_id: options.clientId,
+        redirect_uri: options.redirectUri,
+        scope: (options.scopes || ['openid', 'profile', 'email']).join(' '),
+    });
+    if (options.audience) {
+        params.set('audience', options.audience);
+    }
+    if (options.state) {
+        params.set('state', options.state);
+    }
+    if (options.organization) {
+        params.set('organization', options.organization);
+    }
+    if (options.connection) {
+        params.set('connection', options.connection);
+    }
+    if (pkce) {
+        params.set('code_challenge', pkce.codeChallenge);
+        params.set('code_challenge_method', 'S256');
+    }
+    return {
+        url: `${issuer}/authorize?${params.toString()}`,
+        codeVerifier: pkce?.codeVerifier,
+    };
+}
+export async function exchangeAuth0Code(options) {
+    const tokenUrl = `https://${options.domain}/oauth/token`;
+    const params = {
+        grant_type: 'authorization_code',
+        client_id: options.clientId,
+        code: options.code,
+        redirect_uri: options.redirectUri,
+    };
+    if (options.clientSecret) {
+        params.client_secret = options.clientSecret;
+    }
+    if (options.codeVerifier) {
+        params.code_verifier = options.codeVerifier;
+    }
+    const response = await fetch(tokenUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(params),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Auth0 token exchange failed: ${error}`);
+    }
+    const data = await response.json();
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        idToken: data.id_token,
+        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1000 : undefined,
+        tokenType: data.token_type || 'Bearer',
+    };
+}
+export async function getAuth0UserInfo(domain, accessToken) {
+    const response = await fetch(`https://${domain}/userinfo`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get user info: ${response.status}`);
+    }
+    return response.json();
+}
+export function auth0(options) {
+    const issuer = `https://${options.domain}`;
+    return oidc({
+        issuer,
+        clientId: options.clientId,
+        clientSecret: options.clientSecret,
+        scopes: options.scopes || ['openid', 'profile', 'email'],
+        accessToken: options.accessToken,
+        refreshToken: options.refreshToken,
+        tokenStorage: options.tokenStorage,
+        audience: options.audience,
+    });
+}
+export function auth0Plugin(options) {
+    return (client) => {
+        client.use(auth0(options));
+    };
+}

package/dist/browser/plugins/auth/aws-sigv4.d.ts

@@ -0,0 +1,10 @@
+import { Middleware, Plugin } from '../../types/index.js';
+export interface AWSSignatureV4Options {
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+    service: string;
+    sessionToken?: string;
+}
+export declare function awsSignatureV4(options: AWSSignatureV4Options): Middleware;
+export declare function awsSignatureV4Plugin(options: AWSSignatureV4Options): Plugin;

package/dist/browser/plugins/auth/aws-sigv4.js

@@ -0,0 +1,88 @@
+import { createHash, createHmac } from 'node:crypto';
+function sha256(str) {
+    return createHash('sha256').update(str).digest('hex');
+}
+export function awsSignatureV4(options) {
+    return async (req, next) => {
+        const url = new URL(req.url);
+        const host = url.host;
+        const pathname = url.pathname;
+        const queryString = url.search.slice(1);
+        const now = new Date();
+        const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, '');
+        const dateStamp = amzDate.slice(0, 8);
+        const method = req.method;
+        const canonicalUri = pathname || '/';
+        const canonicalQueryString = queryString
+            .split('&')
+            .filter(Boolean)
+            .sort()
+            .join('&');
+        let payload = '';
+        if (req.body) {
+            if (typeof req.body === 'string') {
+                payload = req.body;
+            }
+            else if (req.body instanceof ArrayBuffer) {
+                payload = Buffer.from(req.body).toString();
+            }
+        }
+        const payloadHash = sha256(payload);
+        const headers = {
+            host,
+            'x-amz-date': amzDate,
+            'x-amz-content-sha256': payloadHash,
+        };
+        if (options.sessionToken) {
+            headers['x-amz-security-token'] = options.sessionToken;
+        }
+        req.headers.forEach((value, key) => {
+            headers[key.toLowerCase()] = value;
+        });
+        const signedHeaders = Object.keys(headers).sort().join(';');
+        const canonicalHeaders = Object.keys(headers)
+            .sort()
+            .map(key => `${key}:${headers[key].trim()}\n`)
+            .join('');
+        const canonicalRequest = [
+            method,
+            canonicalUri,
+            canonicalQueryString,
+            canonicalHeaders,
+            signedHeaders,
+            payloadHash,
+        ].join('\n');
+        const algorithm = 'AWS4-HMAC-SHA256';
+        const credentialScope = `${dateStamp}/${options.region}/${options.service}/aws4_request`;
+        const stringToSign = [
+            algorithm,
+            amzDate,
+            credentialScope,
+            sha256(canonicalRequest),
+        ].join('\n');
+        const getSignatureKey = (key, dateStamp, regionName, serviceName) => {
+            const kDate = createHmac('sha256', `AWS4${key}`).update(dateStamp).digest();
+            const kRegion = createHmac('sha256', kDate).update(regionName).digest();
+            const kService = createHmac('sha256', kRegion).update(serviceName).digest();
+            const kSigning = createHmac('sha256', kService).update('aws4_request').digest();
+            return kSigning;
+        };
+        const signingKey = getSignatureKey(options.secretAccessKey, dateStamp, options.region, options.service);
+        const signature = createHmac('sha256', signingKey)
+            .update(stringToSign)
+            .digest('hex');
+        const authorizationHeader = `${algorithm} Credential=${options.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+        let newReq = req.withHeader('Authorization', authorizationHeader);
+        newReq = newReq.withHeader('x-amz-date', amzDate);
+        newReq = newReq.withHeader('x-amz-content-sha256', payloadHash);
+        if (options.sessionToken) {
+            newReq = newReq.withHeader('x-amz-security-token', options.sessionToken);
+        }
+        return next(newReq);
+    };
+}
+export function awsSignatureV4Plugin(options) {
+    return (client) => {
+        client.use(awsSignatureV4(options));
+    };
+}